Separate the write-failure budget

One counter, two unrelated failures

MAX_RECOVERABLE_ERRORS is tolerance for malformed model output. But the consume loop incremented the same counter when a settings write failed. So an unwritable settings.json (all targets failing) aborted after 5 valid directives with "too many errors" — blaming the model for an editor/permissions problem and dropping the useful guidance.

Two named budgets: parse-quality vs settings-write.

src/application/generateTheme.ts · 347 lines

src/application/generateTheme.ts347 lines · TypeScript

⋯ 57 lines hidden (lines 1–57)1/**
* The Change Theme use case: provision a key, get a vibe, open the model stream,
* and apply each directive to the editor as it arrives.
*
* The orchestration lives here; every *decision* is delegated to a pure function
* (`parseLine`, `progressPercent`, `shouldShowMessage`, `coverage`) or a domain
* constructor, and every *effect* goes through a port. That split is what makes the
* whole flow testable with in-memory fakes — see `test/generateTheme.test.ts`.
*
* Benign exits (user dismisses the key prompt or the vibe picker) are *outcomes*,
* not errors. Genuine failures (prompt missing, OpenAI down, too many malformed
* lines) are errors.
*/
14 
15import {
type AsyncResultType,
err,
matchTag,
type NonEmptyArray,
type NonEmptyString,
none,
ok,
Option,
type Redacted,
type ResultType,
some,
27} from '../fp';
28import { type ApiKey } from '../domain/apiKey';
29import { coverage } from '../domain/coverage';
30import { type StreamingDirective } from '../domain/directive';
31import { DEFAULT_MODEL, type Model } from '../domain/model';
32import { type WriteTarget, writePreference } from '../domain/scope';
33import { type ThemeSetting } from '../domain/theme';
34import { type Vibe } from '../domain/vibe';
35import { parseLine, renderParseError } from '../protocol/streamingParser';
36import {
type CancellationSignal,
type Capabilities,
type ConfigError,
isProviderError,
type KeepOrReset,
type Millis,
type ProgressReporter,
type PromptError,
type ProviderError,
renderConfigError,
renderProviderError,
renderPromptError,
renderUiError,
type UiError,
type UserMessage,
userMessage,
53} from '../ports';
54import { buildUserPrompt } from './context';
55import { markShown, neverShown, progressPercent, shouldShowMessage } from './progress';
56import { type ProvisionError, provisionApiKey, renderProvisionError } from './provisionApiKey';
57import { curatedSuggestions } from './suggestions';
58 
59// Tolerance for malformed *model output* (a parse-quality signal).
60const MAX_RECOVERABLE_ERRORS = 5;
61// Tolerance for *settings-write* failures (an environment/permissions signal,
62// kept separate so an IO problem isn't misreported as bad model output).
63const MAX_WRITE_ERRORS = 5;
64const DEFAULT_EXPECTED_SETTINGS = 120;
⋯ 283 lines hidden (lines 65–347)65const INITIAL_MESSAGE = '🤖 AI analyzing your vibe...';
66const PROGRESS_TITLE = 'Vibe Themer';
67 
68export type GenerationOutcome =
| { readonly _tag: 'NoKey' }
| { readonly _tag: 'NoVibe' }
| { readonly _tag: 'Completed'; readonly applied: number }
| { readonly _tag: 'CancelledKept'; readonly applied: number }
| { readonly _tag: 'CancelledReset' };
74 
75export type GenerationError =
| { readonly _tag: 'Provision'; readonly error: ProvisionError }
| { readonly _tag: 'Ui'; readonly error: UiError }
| { readonly _tag: 'Prompt'; readonly error: PromptError }
| { readonly _tag: 'Provider'; readonly error: ProviderError }
| { readonly _tag: 'StreamInterrupted'; readonly applied: number; readonly error: ProviderError }
| { readonly _tag: 'WriteAborted'; readonly applied: number; readonly error: ConfigError }
| { readonly _tag: 'Aborted'; readonly applied: number; readonly lastError: string };
83 
84type ApplyStatus = 'ok' | 'error';
85 
86type ConsumeOutcome =
| { readonly _tag: 'Completed'; readonly applied: number }
| { readonly _tag: 'Cancelled'; readonly applied: number }
| { readonly _tag: 'StreamFailed'; readonly applied: number; readonly error: ProviderError }
| { readonly _tag: 'WriteFailed'; readonly applied: number; readonly error: ConfigError }
| { readonly _tag: 'Aborted'; readonly applied: number; readonly lastError: string };
92 
93// ── The streaming consume loop ─────────────────────────────────────────────────
94 
95const consumeStream = async (
caps: Capabilities,
stream: AsyncIterable<string>,
reporter: ProgressReporter,
signal: CancellationSignal,
preference: NonEmptyArray<WriteTarget>,
101): Promise<ConsumeOutcome> => {
let buffer = '';
let applied = 0;
let expected = DEFAULT_EXPECTED_SETTINGS;
let parseErrors = 0;
let writeErrors = 0;
let lastParseError = '';
let lastConfigError: ConfigError | undefined;
let currentMessage = INITIAL_MESSAGE;
let lastMessageAt = neverShown;
111 
const reportProgress = (): void =>
  reporter.report({ message: currentMessage, percent: some(progressPercent(applied, expected)) });
114 
const applySetting = async (setting: ThemeSetting): Promise<ApplyStatus> => {
  const result = await caps.config.applySetting(setting, preference);
  if (result._tag === 'Ok') {
    applied += 1;
    reportProgress();
    return 'ok';
  }
  // A write failure is environmental, not a model-output problem — track it on
  // its own budget and log it, rather than spending the malformed-line tolerance.
  writeErrors += 1;
  lastConfigError = result.error;
  caps.logger.debug('apply setting failed', { error: renderConfigError(result.error).title });
  return 'error';
};
129 
const applyDirective = (directive: StreamingDirective): Promise<ApplyStatus> =>
  matchTag(directive, {
    Count: async ({ total }): Promise<ApplyStatus> => {
      expected = total;
      currentMessage = `🎯 Planning ${total} theme settings...`;
      reportProgress();
      return 'ok';
    },
    Message: async ({ text }): Promise<ApplyStatus> => {
      const now: Millis = caps.clock.now();
      if (shouldShowMessage(lastMessageAt, now)) {
        currentMessage = `✨ ${text}`;
        lastMessageAt = markShown(now);
        reporter.report({ message: currentMessage, percent: none });
      }
      return 'ok';
    },
    Selector: ({ selector, color }): Promise<ApplyStatus> =>
      applySetting({ _tag: 'SelectorSetting', selector, color }),
    Token: ({ scope, color, fontStyle }): Promise<ApplyStatus> =>
      applySetting({ _tag: 'TokenSetting', scope, color, fontStyle }),
  });
152 
const handleLine = async (line: string): Promise<ConsumeOutcome | null> => {
  if (line.trim() === '') {
    return null;
  }
  const parsed = parseLine(line);
  if (parsed._tag === 'Ok') {
    // Write failures are counted inside applySetting, on their own budget.
    await applyDirective(parsed.value);
  } else {
    parseErrors += 1;
    lastParseError = renderParseError(parsed.error);
    caps.logger.debug('directive parse failed', { line, error: lastParseError });
  }
  if (parseErrors >= MAX_RECOVERABLE_ERRORS) {
    return { _tag: 'Aborted', applied, lastError: lastParseError };
  }
  if (writeErrors >= MAX_WRITE_ERRORS && lastConfigError !== undefined) {
    return { _tag: 'WriteFailed', applied, error: lastConfigError };
  }
  return null;
};
174 
try {
  for await (const chunk of stream) {
    if (signal.isCancelled()) {
      break;
    }
    buffer += chunk;
    const segments = buffer.split('\n');
    buffer = segments.pop() ?? '';
    for (const line of segments) {
      if (signal.isCancelled()) {
        break;
      }
      const aborted = await handleLine(line);
      if (aborted !== null) {
        return aborted;
      }
    }
  }
} catch (e) {
  // The stream threw after opening (provider error mid-generation). Adapters
  // re-throw a classified ProviderError; anything else becomes Unexpected.
  const error: ProviderError = isProviderError(e) ? e : { _tag: 'Unexpected', detail: String(e) };
  return { _tag: 'StreamFailed', applied, error };
}
199 
// Flush a trailing partial line on clean completion (v1 parity); ignore its errors.
if (!signal.isCancelled() && buffer.trim() !== '') {
  const parsed = parseLine(buffer);
  if (parsed._tag === 'Ok') {
    await applyDirective(parsed.value);
  }
}
207 
return signal.isCancelled() ? { _tag: 'Cancelled', applied } : { _tag: 'Completed', applied };
209};
210 
211// ── Finalization: keep/reset modals after the progress notification closes ─────
212 
213const decideKeepOrReset = (result: ResultType<UiError, KeepOrReset>): KeepOrReset =>
result._tag === 'Ok' ? result.value : 'keep';
215 
216const finalize = (
caps: Capabilities,
consumed: ConsumeOutcome,
219): AsyncResultType<GenerationError, GenerationOutcome> =>
matchTag(consumed, {
  Aborted: ({ applied, lastError }): AsyncResultType<GenerationError, GenerationOutcome> =>
    Promise.resolve(err({ _tag: 'Aborted', applied, lastError })),
223 
  StreamFailed: ({ applied, error }): AsyncResultType<GenerationError, GenerationOutcome> =>
    Promise.resolve(err({ _tag: 'StreamInterrupted', applied, error })),
226 
  WriteFailed: ({ applied, error }): AsyncResultType<GenerationError, GenerationOutcome> =>
    Promise.resolve(err({ _tag: 'WriteAborted', applied, error })),
229 
  Completed: async ({ applied }): AsyncResultType<GenerationError, GenerationOutcome> => {
    const choice = await caps.ui.announceCompletion({
      applied,
      coverage: coverage(applied, DEFAULT_EXPECTED_SETTINGS),
    });
    if (decideKeepOrReset(choice) === 'reset') {
      await resetQuietly(caps);
    }
    return ok({ _tag: 'Completed', applied });
  },
240 
  Cancelled: async ({ applied }): AsyncResultType<GenerationError, GenerationOutcome> => {
    const choice = await caps.ui.confirmCancellation(applied);
    if (decideKeepOrReset(choice) === 'reset') {
      await resetQuietly(caps);
      return ok({ _tag: 'CancelledReset' });
    }
    return ok({ _tag: 'CancelledKept', applied });
  },
});
250 
251const resetQuietly = async (caps: Capabilities): Promise<void> => {
const result = await caps.config.reset();
if (result._tag === 'Err') {
  caps.logger.error('reset after generation failed', {
    error: renderConfigError(result.error).title,
  });
}
258};
259 
260// ── The use case ───────────────────────────────────────────────────────────────
261 
262const runGeneration = async (
caps: Capabilities,
model: Model,
key: Redacted<ApiKey>,
vibe: Vibe,
system: NonEmptyString,
268): AsyncResultType<GenerationError, GenerationOutcome> => {
const current = caps.config.readCurrentTheme();
const user = buildUserPrompt(current, vibe);
const preference = writePreference(caps.config.hasWorkspaceFolders());
272 
const streamResult = await caps.gateway.streamTheme({
  provider: model.provider,
  key,
  model: model.id,
  system,
  user,
});
if (streamResult._tag === 'Err') {
  return err({ _tag: 'Provider', error: streamResult.error });
}
283 
const consumed = await caps.ui.runWithProgress(PROGRESS_TITLE, (reporter, signal) => {
  reporter.report({ message: INITIAL_MESSAGE, percent: none });
  return consumeStream(caps, streamResult.value, reporter, signal, preference);
});
288 
return finalize(caps, consumed);
290};
291 
292export const generateTheme = async (
caps: Capabilities,
294): AsyncResultType<GenerationError, GenerationOutcome> => {
const model = Option.getOrElse(() => DEFAULT_MODEL)(caps.preferences.selectedModel());
296 
const keyResult = await provisionApiKey(caps, model.provider);
if (keyResult._tag === 'Err') {
  return keyResult.error._tag === 'Cancelled'
    ? ok({ _tag: 'NoKey' })
    : err({ _tag: 'Provision', error: keyResult.error });
}
303 
const vibeResult = await caps.ui.pickVibe(curatedSuggestions);
if (vibeResult._tag === 'Err') {
  return err({ _tag: 'Ui', error: vibeResult.error });
}
if (vibeResult.value._tag === 'None') {
  return ok({ _tag: 'NoVibe' });
}
311 
const promptResult = await caps.prompts.systemPrompt();
if (promptResult._tag === 'Err') {
  return err({ _tag: 'Prompt', error: promptResult.error });
}
316 
return runGeneration(caps, model, keyResult.value, vibeResult.value.value, promptResult.value);
318};
319 
320export const renderGenerationError = (e: GenerationError): Option.Option<UserMessage> =>
matchTag(e, {
  Provision: ({ error }) => renderProvisionError(error),
  Ui: ({ error }) => some(renderUiError(error)),
  Prompt: ({ error }) => some(renderPromptError(error)),
  Provider: ({ error }) => some(renderProviderError(error)),
  StreamInterrupted: ({ applied, error }) =>
    some(
      userMessage(renderProviderError(error).title, {
        detail: `Generation stopped after applying ${applied} settings.`,
        suggestion: 'Try again, or run "Reset Theme Customizations" to start fresh.',
      }),
    ),
  WriteAborted: ({ applied, error }) =>
    some(
      userMessage(renderConfigError(error).title, {
        detail: `Stopped after applying ${applied} settings — the editor kept refusing writes.`,
        suggestion: 'Check VS Code permissions and try restarting the editor.',
      }),
    ),
  Aborted: ({ applied, lastError }) =>
    some(
      userMessage('⚠️ Theme generation was interrupted', {
        detail: `${applied} settings were applied before too many errors (last: ${lastError}).`,
        suggestion: 'Try again, or run "Reset Theme Customizations" to start fresh.',
      }),
    ),
});

Count each on its own budget

applySetting counts write failures and remembers the ConfigError; handleLine counts only parse failures and checks both thresholds, returning a distinct outcome for each.

Write failures tracked in applySetting; handleLine aborts parse vs write distinctly.

src/application/generateTheme.ts · 347 lines

src/application/generateTheme.ts347 lines · TypeScript

⋯ 118 lines hidden (lines 1–118)1/**
* The Change Theme use case: provision a key, get a vibe, open the model stream,
* and apply each directive to the editor as it arrives.
*
* The orchestration lives here; every *decision* is delegated to a pure function
* (`parseLine`, `progressPercent`, `shouldShowMessage`, `coverage`) or a domain
* constructor, and every *effect* goes through a port. That split is what makes the
* whole flow testable with in-memory fakes — see `test/generateTheme.test.ts`.
*
* Benign exits (user dismisses the key prompt or the vibe picker) are *outcomes*,
* not errors. Genuine failures (prompt missing, OpenAI down, too many malformed
* lines) are errors.
*/
14 
15import {
type AsyncResultType,
err,
matchTag,
type NonEmptyArray,
type NonEmptyString,
none,
ok,
Option,
type Redacted,
type ResultType,
some,
27} from '../fp';
28import { type ApiKey } from '../domain/apiKey';
29import { coverage } from '../domain/coverage';
30import { type StreamingDirective } from '../domain/directive';
31import { DEFAULT_MODEL, type Model } from '../domain/model';
32import { type WriteTarget, writePreference } from '../domain/scope';
33import { type ThemeSetting } from '../domain/theme';
34import { type Vibe } from '../domain/vibe';
35import { parseLine, renderParseError } from '../protocol/streamingParser';
36import {
type CancellationSignal,
type Capabilities,
type ConfigError,
isProviderError,
type KeepOrReset,
type Millis,
type ProgressReporter,
type PromptError,
type ProviderError,
renderConfigError,
renderProviderError,
renderPromptError,
renderUiError,
type UiError,
type UserMessage,
userMessage,
53} from '../ports';
54import { buildUserPrompt } from './context';
55import { markShown, neverShown, progressPercent, shouldShowMessage } from './progress';
56import { type ProvisionError, provisionApiKey, renderProvisionError } from './provisionApiKey';
57import { curatedSuggestions } from './suggestions';
58 
59// Tolerance for malformed *model output* (a parse-quality signal).
60const MAX_RECOVERABLE_ERRORS = 5;
61// Tolerance for *settings-write* failures (an environment/permissions signal,
62// kept separate so an IO problem isn't misreported as bad model output).
63const MAX_WRITE_ERRORS = 5;
64const DEFAULT_EXPECTED_SETTINGS = 120;
65const INITIAL_MESSAGE = '🤖 AI analyzing your vibe...';
66const PROGRESS_TITLE = 'Vibe Themer';
67 
68export type GenerationOutcome =
| { readonly _tag: 'NoKey' }
| { readonly _tag: 'NoVibe' }
| { readonly _tag: 'Completed'; readonly applied: number }
| { readonly _tag: 'CancelledKept'; readonly applied: number }
| { readonly _tag: 'CancelledReset' };
74 
75export type GenerationError =
| { readonly _tag: 'Provision'; readonly error: ProvisionError }
| { readonly _tag: 'Ui'; readonly error: UiError }
| { readonly _tag: 'Prompt'; readonly error: PromptError }
| { readonly _tag: 'Provider'; readonly error: ProviderError }
| { readonly _tag: 'StreamInterrupted'; readonly applied: number; readonly error: ProviderError }
| { readonly _tag: 'WriteAborted'; readonly applied: number; readonly error: ConfigError }
| { readonly _tag: 'Aborted'; readonly applied: number; readonly lastError: string };
83 
84type ApplyStatus = 'ok' | 'error';
85 
86type ConsumeOutcome =
| { readonly _tag: 'Completed'; readonly applied: number }
| { readonly _tag: 'Cancelled'; readonly applied: number }
| { readonly _tag: 'StreamFailed'; readonly applied: number; readonly error: ProviderError }
| { readonly _tag: 'WriteFailed'; readonly applied: number; readonly error: ConfigError }
| { readonly _tag: 'Aborted'; readonly applied: number; readonly lastError: string };
92 
93// ── The streaming consume loop ─────────────────────────────────────────────────
94 
95const consumeStream = async (
caps: Capabilities,
stream: AsyncIterable<string>,
reporter: ProgressReporter,
signal: CancellationSignal,
preference: NonEmptyArray<WriteTarget>,
101): Promise<ConsumeOutcome> => {
let buffer = '';
let applied = 0;
let expected = DEFAULT_EXPECTED_SETTINGS;
let parseErrors = 0;
let writeErrors = 0;
let lastParseError = '';
let lastConfigError: ConfigError | undefined;
let currentMessage = INITIAL_MESSAGE;
let lastMessageAt = neverShown;
111 
const reportProgress = (): void =>
  reporter.report({ message: currentMessage, percent: some(progressPercent(applied, expected)) });
114 
const applySetting = async (setting: ThemeSetting): Promise<ApplyStatus> => {
  const result = await caps.config.applySetting(setting, preference);
  if (result._tag === 'Ok') {
    applied += 1;
    reportProgress();
    return 'ok';
  }
  // A write failure is environmental, not a model-output problem — track it on
  // its own budget and log it, rather than spending the malformed-line tolerance.
  writeErrors += 1;
  lastConfigError = result.error;
  caps.logger.debug('apply setting failed', { error: renderConfigError(result.error).title });
  return 'error';
⋯ 30 lines hidden (lines 128–157)128  };
129 
const applyDirective = (directive: StreamingDirective): Promise<ApplyStatus> =>
  matchTag(directive, {
    Count: async ({ total }): Promise<ApplyStatus> => {
      expected = total;
      currentMessage = `🎯 Planning ${total} theme settings...`;
      reportProgress();
      return 'ok';
    },
    Message: async ({ text }): Promise<ApplyStatus> => {
      const now: Millis = caps.clock.now();
      if (shouldShowMessage(lastMessageAt, now)) {
        currentMessage = `✨ ${text}`;
        lastMessageAt = markShown(now);
        reporter.report({ message: currentMessage, percent: none });
      }
      return 'ok';
    },
    Selector: ({ selector, color }): Promise<ApplyStatus> =>
      applySetting({ _tag: 'SelectorSetting', selector, color }),
    Token: ({ scope, color, fontStyle }): Promise<ApplyStatus> =>
      applySetting({ _tag: 'TokenSetting', scope, color, fontStyle }),
  });
152 
const handleLine = async (line: string): Promise<ConsumeOutcome | null> => {
  if (line.trim() === '') {
    return null;
  }
  const parsed = parseLine(line);
  if (parsed._tag === 'Ok') {
    // Write failures are counted inside applySetting, on their own budget.
    await applyDirective(parsed.value);
  } else {
    parseErrors += 1;
    lastParseError = renderParseError(parsed.error);
    caps.logger.debug('directive parse failed', { line, error: lastParseError });
  }
  if (parseErrors >= MAX_RECOVERABLE_ERRORS) {
    return { _tag: 'Aborted', applied, lastError: lastParseError };
  }
  if (writeErrors >= MAX_WRITE_ERRORS && lastConfigError !== undefined) {
    return { _tag: 'WriteFailed', applied, error: lastConfigError };
  }
  return null;
⋯ 175 lines hidden (lines 173–347)173  };
174 
try {
  for await (const chunk of stream) {
    if (signal.isCancelled()) {
      break;
    }
    buffer += chunk;
    const segments = buffer.split('\n');
    buffer = segments.pop() ?? '';
    for (const line of segments) {
      if (signal.isCancelled()) {
        break;
      }
      const aborted = await handleLine(line);
      if (aborted !== null) {
        return aborted;
      }
    }
  }
} catch (e) {
  // The stream threw after opening (provider error mid-generation). Adapters
  // re-throw a classified ProviderError; anything else becomes Unexpected.
  const error: ProviderError = isProviderError(e) ? e : { _tag: 'Unexpected', detail: String(e) };
  return { _tag: 'StreamFailed', applied, error };
}
199 
// Flush a trailing partial line on clean completion (v1 parity); ignore its errors.
if (!signal.isCancelled() && buffer.trim() !== '') {
  const parsed = parseLine(buffer);
  if (parsed._tag === 'Ok') {
    await applyDirective(parsed.value);
  }
}
207 
return signal.isCancelled() ? { _tag: 'Cancelled', applied } : { _tag: 'Completed', applied };
209};
210 
211// ── Finalization: keep/reset modals after the progress notification closes ─────
212 
213const decideKeepOrReset = (result: ResultType<UiError, KeepOrReset>): KeepOrReset =>
result._tag === 'Ok' ? result.value : 'keep';
215 
216const finalize = (
caps: Capabilities,
consumed: ConsumeOutcome,
219): AsyncResultType<GenerationError, GenerationOutcome> =>
matchTag(consumed, {
  Aborted: ({ applied, lastError }): AsyncResultType<GenerationError, GenerationOutcome> =>
    Promise.resolve(err({ _tag: 'Aborted', applied, lastError })),
223 
  StreamFailed: ({ applied, error }): AsyncResultType<GenerationError, GenerationOutcome> =>
    Promise.resolve(err({ _tag: 'StreamInterrupted', applied, error })),
226 
  WriteFailed: ({ applied, error }): AsyncResultType<GenerationError, GenerationOutcome> =>
    Promise.resolve(err({ _tag: 'WriteAborted', applied, error })),
229 
  Completed: async ({ applied }): AsyncResultType<GenerationError, GenerationOutcome> => {
    const choice = await caps.ui.announceCompletion({
      applied,
      coverage: coverage(applied, DEFAULT_EXPECTED_SETTINGS),
    });
    if (decideKeepOrReset(choice) === 'reset') {
      await resetQuietly(caps);
    }
    return ok({ _tag: 'Completed', applied });
  },
240 
  Cancelled: async ({ applied }): AsyncResultType<GenerationError, GenerationOutcome> => {
    const choice = await caps.ui.confirmCancellation(applied);
    if (decideKeepOrReset(choice) === 'reset') {
      await resetQuietly(caps);
      return ok({ _tag: 'CancelledReset' });
    }
    return ok({ _tag: 'CancelledKept', applied });
  },
});
250 
251const resetQuietly = async (caps: Capabilities): Promise<void> => {
const result = await caps.config.reset();
if (result._tag === 'Err') {
  caps.logger.error('reset after generation failed', {
    error: renderConfigError(result.error).title,
  });
}
258};
259 
260// ── The use case ───────────────────────────────────────────────────────────────
261 
262const runGeneration = async (
caps: Capabilities,
model: Model,
key: Redacted<ApiKey>,
vibe: Vibe,
system: NonEmptyString,
268): AsyncResultType<GenerationError, GenerationOutcome> => {
const current = caps.config.readCurrentTheme();
const user = buildUserPrompt(current, vibe);
const preference = writePreference(caps.config.hasWorkspaceFolders());
272 
const streamResult = await caps.gateway.streamTheme({
  provider: model.provider,
  key,
  model: model.id,
  system,
  user,
});
if (streamResult._tag === 'Err') {
  return err({ _tag: 'Provider', error: streamResult.error });
}
283 
const consumed = await caps.ui.runWithProgress(PROGRESS_TITLE, (reporter, signal) => {
  reporter.report({ message: INITIAL_MESSAGE, percent: none });
  return consumeStream(caps, streamResult.value, reporter, signal, preference);
});
288 
return finalize(caps, consumed);
290};
291 
292export const generateTheme = async (
caps: Capabilities,
294): AsyncResultType<GenerationError, GenerationOutcome> => {
const model = Option.getOrElse(() => DEFAULT_MODEL)(caps.preferences.selectedModel());
296 
const keyResult = await provisionApiKey(caps, model.provider);
if (keyResult._tag === 'Err') {
  return keyResult.error._tag === 'Cancelled'
    ? ok({ _tag: 'NoKey' })
    : err({ _tag: 'Provision', error: keyResult.error });
}
303 
const vibeResult = await caps.ui.pickVibe(curatedSuggestions);
if (vibeResult._tag === 'Err') {
  return err({ _tag: 'Ui', error: vibeResult.error });
}
if (vibeResult.value._tag === 'None') {
  return ok({ _tag: 'NoVibe' });
}
311 
const promptResult = await caps.prompts.systemPrompt();
if (promptResult._tag === 'Err') {
  return err({ _tag: 'Prompt', error: promptResult.error });
}
316 
return runGeneration(caps, model, keyResult.value, vibeResult.value.value, promptResult.value);
318};
319 
320export const renderGenerationError = (e: GenerationError): Option.Option<UserMessage> =>
matchTag(e, {
  Provision: ({ error }) => renderProvisionError(error),
  Ui: ({ error }) => some(renderUiError(error)),
  Prompt: ({ error }) => some(renderPromptError(error)),
  Provider: ({ error }) => some(renderProviderError(error)),
  StreamInterrupted: ({ applied, error }) =>
    some(
      userMessage(renderProviderError(error).title, {
        detail: `Generation stopped after applying ${applied} settings.`,
        suggestion: 'Try again, or run "Reset Theme Customizations" to start fresh.',
      }),
    ),
  WriteAborted: ({ applied, error }) =>
    some(
      userMessage(renderConfigError(error).title, {
        detail: `Stopped after applying ${applied} settings — the editor kept refusing writes.`,
        suggestion: 'Check VS Code permissions and try restarting the editor.',
      }),
    ),
  Aborted: ({ applied, lastError }) =>
    some(
      userMessage('⚠️ Theme generation was interrupted', {
        detail: `${applied} settings were applied before too many errors (last: ${lastError}).`,
        suggestion: 'Try again, or run "Reset Theme Customizations" to start fresh.',
      }),
    ),
});

WriteFailed -> WriteAborted, rendered as a settings/permissions problem.

src/application/generateTheme.ts · 347 lines

src/application/generateTheme.ts347 lines · TypeScript

⋯ 226 lines hidden (lines 1–226)1/**
* The Change Theme use case: provision a key, get a vibe, open the model stream,
* and apply each directive to the editor as it arrives.
*
* The orchestration lives here; every *decision* is delegated to a pure function
* (`parseLine`, `progressPercent`, `shouldShowMessage`, `coverage`) or a domain
* constructor, and every *effect* goes through a port. That split is what makes the
* whole flow testable with in-memory fakes — see `test/generateTheme.test.ts`.
*
* Benign exits (user dismisses the key prompt or the vibe picker) are *outcomes*,
* not errors. Genuine failures (prompt missing, OpenAI down, too many malformed
* lines) are errors.
*/
14 
15import {
type AsyncResultType,
err,
matchTag,
type NonEmptyArray,
type NonEmptyString,
none,
ok,
Option,
type Redacted,
type ResultType,
some,
27} from '../fp';
28import { type ApiKey } from '../domain/apiKey';
29import { coverage } from '../domain/coverage';
30import { type StreamingDirective } from '../domain/directive';
31import { DEFAULT_MODEL, type Model } from '../domain/model';
32import { type WriteTarget, writePreference } from '../domain/scope';
33import { type ThemeSetting } from '../domain/theme';
34import { type Vibe } from '../domain/vibe';
35import { parseLine, renderParseError } from '../protocol/streamingParser';
36import {
type CancellationSignal,
type Capabilities,
type ConfigError,
isProviderError,
type KeepOrReset,
type Millis,
type ProgressReporter,
type PromptError,
type ProviderError,
renderConfigError,
renderProviderError,
renderPromptError,
renderUiError,
type UiError,
type UserMessage,
userMessage,
53} from '../ports';
54import { buildUserPrompt } from './context';
55import { markShown, neverShown, progressPercent, shouldShowMessage } from './progress';
56import { type ProvisionError, provisionApiKey, renderProvisionError } from './provisionApiKey';
57import { curatedSuggestions } from './suggestions';
58 
59// Tolerance for malformed *model output* (a parse-quality signal).
60const MAX_RECOVERABLE_ERRORS = 5;
61// Tolerance for *settings-write* failures (an environment/permissions signal,
62// kept separate so an IO problem isn't misreported as bad model output).
63const MAX_WRITE_ERRORS = 5;
64const DEFAULT_EXPECTED_SETTINGS = 120;
65const INITIAL_MESSAGE = '🤖 AI analyzing your vibe...';
66const PROGRESS_TITLE = 'Vibe Themer';
67 
68export type GenerationOutcome =
| { readonly _tag: 'NoKey' }
| { readonly _tag: 'NoVibe' }
| { readonly _tag: 'Completed'; readonly applied: number }
| { readonly _tag: 'CancelledKept'; readonly applied: number }
| { readonly _tag: 'CancelledReset' };
74 
75export type GenerationError =
| { readonly _tag: 'Provision'; readonly error: ProvisionError }
| { readonly _tag: 'Ui'; readonly error: UiError }
| { readonly _tag: 'Prompt'; readonly error: PromptError }
| { readonly _tag: 'Provider'; readonly error: ProviderError }
| { readonly _tag: 'StreamInterrupted'; readonly applied: number; readonly error: ProviderError }
| { readonly _tag: 'WriteAborted'; readonly applied: number; readonly error: ConfigError }
| { readonly _tag: 'Aborted'; readonly applied: number; readonly lastError: string };
83 
84type ApplyStatus = 'ok' | 'error';
85 
86type ConsumeOutcome =
| { readonly _tag: 'Completed'; readonly applied: number }
| { readonly _tag: 'Cancelled'; readonly applied: number }
| { readonly _tag: 'StreamFailed'; readonly applied: number; readonly error: ProviderError }
| { readonly _tag: 'WriteFailed'; readonly applied: number; readonly error: ConfigError }
| { readonly _tag: 'Aborted'; readonly applied: number; readonly lastError: string };
92 
93// ── The streaming consume loop ─────────────────────────────────────────────────
94 
95const consumeStream = async (
caps: Capabilities,
stream: AsyncIterable<string>,
reporter: ProgressReporter,
signal: CancellationSignal,
preference: NonEmptyArray<WriteTarget>,
101): Promise<ConsumeOutcome> => {
let buffer = '';
let applied = 0;
let expected = DEFAULT_EXPECTED_SETTINGS;
let parseErrors = 0;
let writeErrors = 0;
let lastParseError = '';
let lastConfigError: ConfigError | undefined;
let currentMessage = INITIAL_MESSAGE;
let lastMessageAt = neverShown;
111 
const reportProgress = (): void =>
  reporter.report({ message: currentMessage, percent: some(progressPercent(applied, expected)) });
114 
const applySetting = async (setting: ThemeSetting): Promise<ApplyStatus> => {
  const result = await caps.config.applySetting(setting, preference);
  if (result._tag === 'Ok') {
    applied += 1;
    reportProgress();
    return 'ok';
  }
  // A write failure is environmental, not a model-output problem — track it on
  // its own budget and log it, rather than spending the malformed-line tolerance.
  writeErrors += 1;
  lastConfigError = result.error;
  caps.logger.debug('apply setting failed', { error: renderConfigError(result.error).title });
  return 'error';
};
129 
const applyDirective = (directive: StreamingDirective): Promise<ApplyStatus> =>
  matchTag(directive, {
    Count: async ({ total }): Promise<ApplyStatus> => {
      expected = total;
      currentMessage = `🎯 Planning ${total} theme settings...`;
      reportProgress();
      return 'ok';
    },
    Message: async ({ text }): Promise<ApplyStatus> => {
      const now: Millis = caps.clock.now();
      if (shouldShowMessage(lastMessageAt, now)) {
        currentMessage = `✨ ${text}`;
        lastMessageAt = markShown(now);
        reporter.report({ message: currentMessage, percent: none });
      }
      return 'ok';
    },
    Selector: ({ selector, color }): Promise<ApplyStatus> =>
      applySetting({ _tag: 'SelectorSetting', selector, color }),
    Token: ({ scope, color, fontStyle }): Promise<ApplyStatus> =>
      applySetting({ _tag: 'TokenSetting', scope, color, fontStyle }),
  });
152 
const handleLine = async (line: string): Promise<ConsumeOutcome | null> => {
  if (line.trim() === '') {
    return null;
  }
  const parsed = parseLine(line);
  if (parsed._tag === 'Ok') {
    // Write failures are counted inside applySetting, on their own budget.
    await applyDirective(parsed.value);
  } else {
    parseErrors += 1;
    lastParseError = renderParseError(parsed.error);
    caps.logger.debug('directive parse failed', { line, error: lastParseError });
  }
  if (parseErrors >= MAX_RECOVERABLE_ERRORS) {
    return { _tag: 'Aborted', applied, lastError: lastParseError };
  }
  if (writeErrors >= MAX_WRITE_ERRORS && lastConfigError !== undefined) {
    return { _tag: 'WriteFailed', applied, error: lastConfigError };
  }
  return null;
};
174 
try {
  for await (const chunk of stream) {
    if (signal.isCancelled()) {
      break;
    }
    buffer += chunk;
    const segments = buffer.split('\n');
    buffer = segments.pop() ?? '';
    for (const line of segments) {
      if (signal.isCancelled()) {
        break;
      }
      const aborted = await handleLine(line);
      if (aborted !== null) {
        return aborted;
      }
    }
  }
} catch (e) {
  // The stream threw after opening (provider error mid-generation). Adapters
  // re-throw a classified ProviderError; anything else becomes Unexpected.
  const error: ProviderError = isProviderError(e) ? e : { _tag: 'Unexpected', detail: String(e) };
  return { _tag: 'StreamFailed', applied, error };
}
199 
// Flush a trailing partial line on clean completion (v1 parity); ignore its errors.
if (!signal.isCancelled() && buffer.trim() !== '') {
  const parsed = parseLine(buffer);
  if (parsed._tag === 'Ok') {
    await applyDirective(parsed.value);
  }
}
207 
return signal.isCancelled() ? { _tag: 'Cancelled', applied } : { _tag: 'Completed', applied };
209};
210 
211// ── Finalization: keep/reset modals after the progress notification closes ─────
212 
213const decideKeepOrReset = (result: ResultType<UiError, KeepOrReset>): KeepOrReset =>
result._tag === 'Ok' ? result.value : 'keep';
215 
216const finalize = (
caps: Capabilities,
consumed: ConsumeOutcome,
219): AsyncResultType<GenerationError, GenerationOutcome> =>
matchTag(consumed, {
  Aborted: ({ applied, lastError }): AsyncResultType<GenerationError, GenerationOutcome> =>
    Promise.resolve(err({ _tag: 'Aborted', applied, lastError })),
223 
  StreamFailed: ({ applied, error }): AsyncResultType<GenerationError, GenerationOutcome> =>
    Promise.resolve(err({ _tag: 'StreamInterrupted', applied, error })),
226 
  WriteFailed: ({ applied, error }): AsyncResultType<GenerationError, GenerationOutcome> =>
    Promise.resolve(err({ _tag: 'WriteAborted', applied, error })),
⋯ 104 lines hidden (lines 229–332)229 
  Completed: async ({ applied }): AsyncResultType<GenerationError, GenerationOutcome> => {
    const choice = await caps.ui.announceCompletion({
      applied,
      coverage: coverage(applied, DEFAULT_EXPECTED_SETTINGS),
    });
    if (decideKeepOrReset(choice) === 'reset') {
      await resetQuietly(caps);
    }
    return ok({ _tag: 'Completed', applied });
  },
240 
  Cancelled: async ({ applied }): AsyncResultType<GenerationError, GenerationOutcome> => {
    const choice = await caps.ui.confirmCancellation(applied);
    if (decideKeepOrReset(choice) === 'reset') {
      await resetQuietly(caps);
      return ok({ _tag: 'CancelledReset' });
    }
    return ok({ _tag: 'CancelledKept', applied });
  },
});
250 
251const resetQuietly = async (caps: Capabilities): Promise<void> => {
const result = await caps.config.reset();
if (result._tag === 'Err') {
  caps.logger.error('reset after generation failed', {
    error: renderConfigError(result.error).title,
  });
}
258};
259 
260// ── The use case ───────────────────────────────────────────────────────────────
261 
262const runGeneration = async (
caps: Capabilities,
model: Model,
key: Redacted<ApiKey>,
vibe: Vibe,
system: NonEmptyString,
268): AsyncResultType<GenerationError, GenerationOutcome> => {
const current = caps.config.readCurrentTheme();
const user = buildUserPrompt(current, vibe);
const preference = writePreference(caps.config.hasWorkspaceFolders());
272 
const streamResult = await caps.gateway.streamTheme({
  provider: model.provider,
  key,
  model: model.id,
  system,
  user,
});
if (streamResult._tag === 'Err') {
  return err({ _tag: 'Provider', error: streamResult.error });
}
283 
const consumed = await caps.ui.runWithProgress(PROGRESS_TITLE, (reporter, signal) => {
  reporter.report({ message: INITIAL_MESSAGE, percent: none });
  return consumeStream(caps, streamResult.value, reporter, signal, preference);
});
288 
return finalize(caps, consumed);
290};
291 
292export const generateTheme = async (
caps: Capabilities,
294): AsyncResultType<GenerationError, GenerationOutcome> => {
const model = Option.getOrElse(() => DEFAULT_MODEL)(caps.preferences.selectedModel());
296 
const keyResult = await provisionApiKey(caps, model.provider);
if (keyResult._tag === 'Err') {
  return keyResult.error._tag === 'Cancelled'
    ? ok({ _tag: 'NoKey' })
    : err({ _tag: 'Provision', error: keyResult.error });
}
303 
const vibeResult = await caps.ui.pickVibe(curatedSuggestions);
if (vibeResult._tag === 'Err') {
  return err({ _tag: 'Ui', error: vibeResult.error });
}
if (vibeResult.value._tag === 'None') {
  return ok({ _tag: 'NoVibe' });
}
311 
const promptResult = await caps.prompts.systemPrompt();
if (promptResult._tag === 'Err') {
  return err({ _tag: 'Prompt', error: promptResult.error });
}
316 
return runGeneration(caps, model, keyResult.value, vibeResult.value.value, promptResult.value);
318};
319 
320export const renderGenerationError = (e: GenerationError): Option.Option<UserMessage> =>
matchTag(e, {
  Provision: ({ error }) => renderProvisionError(error),
  Ui: ({ error }) => some(renderUiError(error)),
  Prompt: ({ error }) => some(renderPromptError(error)),
  Provider: ({ error }) => some(renderProviderError(error)),
  StreamInterrupted: ({ applied, error }) =>
    some(
      userMessage(renderProviderError(error).title, {
        detail: `Generation stopped after applying ${applied} settings.`,
        suggestion: 'Try again, or run "Reset Theme Customizations" to start fresh.',
      }),
    ),
  WriteAborted: ({ applied, error }) =>
    some(
      userMessage(renderConfigError(error).title, {
        detail: `Stopped after applying ${applied} settings — the editor kept refusing writes.`,
        suggestion: 'Check VS Code permissions and try restarting the editor.',
      }),
    ),
⋯ 8 lines hidden (lines 340–347)340    Aborted: ({ applied, lastError }) =>
    some(
      userMessage('⚠️ Theme generation was interrupted', {
        detail: `${applied} settings were applied before too many errors (last: ${lastError}).`,
        suggestion: 'Try again, or run "Reset Theme Customizations" to start fresh.',
      }),
    ),
});

The discriminating test

With failApply, six valid directives whose writes all fail must surface WriteAborted (a config/IO error), not Aborted (malformed output). Before the split, this produced the wrong, output-blaming message.

Valid directives + failing writes -> WriteAborted, not Aborted.

test/generateTheme.test.ts · 212 lines

test/generateTheme.test.ts212 lines · TypeScript

⋯ 147 lines hidden (lines 1–147)1import { describe, it } from 'node:test';
2import assert from 'node:assert/strict';
3import { generateTheme } from '../src/application/generateTheme';
4import { makeModel } from '../src/domain/model';
5import { harness } from './support/harness';
6 
7const VALID_KEY = `sk-${'x'.repeat(40)}`;
8 
9const HAPPY_STREAM = [
'COUNT:3',
'MESSAGE:Warming up the editor 🔥',
'SELECTOR:editor.background=#1a1a1a',
'TOKEN:comment=#6a9955,italic',
'SELECTOR:activityBar.background=REMOVE',
'',
16].join('\n');
17 
18describe('generateTheme — happy path', () => {
it('applies each setting live and completes', async () => {
  const h = harness({ storedKey: VALID_KEY, vibe: 'cozy autumn evening', streamText: HAPPY_STREAM });
  const result = await generateTheme(h.caps);
22 
  assert.equal(result._tag, 'Ok');
  if (result._tag === 'Ok') {
    assert.deepEqual(result.value, { _tag: 'Completed', applied: 3 });
  }
  assert.equal(h.colors.get('editor.background'), '#1a1a1a');
  assert.equal(h.colors.has('activityBar.background'), false);
  assert.deepEqual(h.tokenRules, [
    { scope: 'comment', settings: { foreground: '#6a9955', fontStyle: 'italic' } },
  ]);
});
33 
it('REMOVE deletes a previously applied selector (iteration)', async () => {
  const text = ['COUNT:2', 'SELECTOR:foo.bar=#111111', 'SELECTOR:foo.bar=REMOVE', ''].join('\n');
  const h = harness({ storedKey: VALID_KEY, vibe: 'make it warmer', streamText: text });
  const result = await generateTheme(h.caps);
38 
  assert.equal(h.colors.has('foo.bar'), false);
  if (result._tag === 'Ok') {
    assert.equal(result.value._tag, 'Completed');
  }
});
44 
it('injects existing customizations into the streamed prompt for iteration', async () => {
  const currentTheme = {
    global: { colors: { 'editor.background': '#1e1e1e' }, tokens: {} },
    workspace: { colors: {}, tokens: {} },
  };
  const text = ['COUNT:1', 'SELECTOR:editor.background=#2a1f1a', ''].join('\n');
  const h = harness({ storedKey: VALID_KEY, vibe: 'make it warmer', streamText: text, currentTheme });
  await generateTheme(h.caps);
53 
  assert.ok(h.captured.streamUserPrompt.includes('CURRENT THEME CONTEXT:'));
  assert.ok(h.captured.streamUserPrompt.includes('editor.background: #1e1e1e'));
  assert.ok(h.captured.streamUserPrompt.endsWith('make it warmer'));
});
58 
it('prompts for, verifies, and stores a new key, then proceeds', async () => {
  const text = ['COUNT:1', 'SELECTOR:editor.background=#000000', ''].join('\n');
  const h = harness({ promptKey: VALID_KEY, vibe: 'minimal dark', streamText: text });
  const result = await generateTheme(h.caps);
63 
  assert.equal(h.captured.keySet, true);
  if (result._tag === 'Ok') {
    assert.equal(result.value._tag, 'Completed');
  }
});
69 
it('routes to Anthropic when a Claude model is selected, storing an sk-ant- key', async () => {
  const anthropicKey = `sk-ant-${'x'.repeat(40)}`;
  const text = ['COUNT:1', 'SELECTOR:editor.background=#101010', ''].join('\n');
  const h = harness({
    selectedModel: makeModel('anthropic', 'claude-sonnet-4-6'),
    promptKey: anthropicKey,
    vibe: 'calm ocean depths',
    streamText: text,
  });
  const result = await generateTheme(h.caps);
80 
  assert.deepEqual(h.captured.keySetProviders, ['anthropic']);
  // The gateway is actually asked to stream the Anthropic model, not just the key.
  assert.equal(h.captured.streamProvider, 'anthropic');
  assert.equal(h.captured.streamModel, 'claude-sonnet-4-6');
  assert.equal(h.colors.get('editor.background'), '#101010');
  if (result._tag === 'Ok') {
    assert.equal(result.value._tag, 'Completed');
  }
});
90});
91 
92describe('generateTheme — benign exits', () => {
it('returns NoVibe when the picker is dismissed', async () => {
  const h = harness({ storedKey: VALID_KEY });
  assert.deepEqual(await generateTheme(h.caps), { _tag: 'Ok', value: { _tag: 'NoVibe' } });
});
97 
it('returns NoKey when no key is stored and the prompt is dismissed', async () => {
  const h = harness({ vibe: 'cozy autumn' });
  assert.deepEqual(await generateTheme(h.caps), { _tag: 'Ok', value: { _tag: 'NoKey' } });
});
102});
103 
104describe('generateTheme — failures', () => {
it('surfaces a provider stream error', async () => {
  const h = harness({ storedKey: VALID_KEY, vibe: 'cozy', streamError: { _tag: 'RateLimited' } });
  assert.deepEqual(await generateTheme(h.caps), {
    _tag: 'Err',
    error: { _tag: 'Provider', error: { _tag: 'RateLimited' } },
  });
});
112 
it('surfaces a mid-stream provider error and keeps the partial theme', async () => {
  // The stream opens, applies some settings, then throws (e.g. a 429 once tokens
  // flow). Before the fix this escaped as an unhandled rejection; now it is a
  // typed StreamInterrupted error and the partial theme is left for the user.
  const h = harness({
    storedKey: VALID_KEY,
    vibe: 'cozy',
    streamText: HAPPY_STREAM,
    chunkSize: 1000,
    streamThrowAfter: 1,
    streamThrowError: { _tag: 'RateLimited' },
  });
  const result = await generateTheme(h.caps);
126 
  assert.equal(result._tag, 'Err');
  if (result._tag === 'Err' && result.error._tag === 'StreamInterrupted') {
    assert.equal(result.error.error._tag, 'RateLimited');
    assert.equal(result.error.applied, 3);
  } else {
    assert.fail(`expected StreamInterrupted, got ${JSON.stringify(result)}`);
  }
  assert.equal(h.colors.get('editor.background'), '#1a1a1a');
  assert.equal(h.captured.resets, 0);
});
137 
it('aborts after too many malformed lines', async () => {
  const garbage = Array.from({ length: 6 }, (_unused, i) => `GARBAGE:${i}`).join('\n');
  const h = harness({ storedKey: VALID_KEY, vibe: 'cozy', streamText: garbage });
  const result = await generateTheme(h.caps);
  assert.equal(result._tag, 'Err');
  if (result._tag === 'Err') {
    assert.equal(result.error._tag, 'Aborted');
  }
});
147 
it('reports a write failure distinctly from malformed output', async () => {
  // Valid directives whose *writes* all fail must abort as a config/IO error,
  // not as "too many malformed lines" — they never spend the parse budget.
  const lines = ['COUNT:6'];
  for (let i = 0; i < 6; i += 1) {
    lines.push(`SELECTOR:editor.k${i}=#111111`);
  }
  const h = harness({
    storedKey: VALID_KEY,
    vibe: 'cozy',
    streamText: `${lines.join('\n')}\n`,
    chunkSize: 1000,
    failApply: true,
  });
  const result = await generateTheme(h.caps);
163 
  assert.equal(result._tag, 'Err');
  if (result._tag === 'Err' && result.error._tag === 'WriteAborted') {
    assert.equal(result.error.applied, 0);
  } else {
    assert.fail(`expected WriteAborted, got ${JSON.stringify(result)}`);
  }
});
⋯ 42 lines hidden (lines 171–212)171});
172 
173describe('generateTheme — cancellation and reset', () => {
it('on cancel + reset, clears the theme', async () => {
  const h = harness({
    storedKey: VALID_KEY,
    vibe: 'cozy',
    streamText: HAPPY_STREAM,
    cancelAfterReports: 2,
    cancellationChoice: 'reset',
  });
  const result = await generateTheme(h.caps);
  if (result._tag === 'Ok') {
    assert.equal(result.value._tag, 'CancelledReset');
  }
  assert.ok(h.captured.resets >= 1);
});
188 
it('on success + reset choice, clears the theme', async () => {
  const h = harness({
    storedKey: VALID_KEY,
    vibe: 'cozy',
    streamText: HAPPY_STREAM,
    completionChoice: 'reset',
  });
  const result = await generateTheme(h.caps);
  if (result._tag === 'Ok') {
    assert.equal(result.value._tag, 'Completed');
  }
  assert.equal(h.captured.resets, 1);
});
202});
203 
204describe('generateTheme — secret safety', () => {
it('never lets the raw API key reach logs or notifications', async () => {
  const h = harness({ storedKey: VALID_KEY, vibe: 'cozy autumn', streamText: HAPPY_STREAM });
  await generateTheme(h.caps);
  const serialized = JSON.stringify(h.captured);
  assert.equal(serialized.includes('sk-'), false);
  assert.equal(serialized.includes('x'.repeat(40)), false);
});
212});