@telepat/ideon 0.1.29 → 0.1.31

package/dist/ideon.js

@@ -552,7 +552,8 @@ var baseT2ISettingsSchema = z2.preprocess(
   z2.object({
     modelId: z2.string().default(DEFAULT_LIMN_MODEL_ID),
     replicateModelId: z2.string().optional(),
-    inputOverrides: z2.record(z2.string(), z2.unknown()).default({})
+    inputOverrides: z2.record(z2.string(), z2.unknown()).default({}),
+    maxAttempts: z2.number().int().min(1).max(10).default(4)
   })
 );
 var notificationsSettingsSchema = z2.object({
@@ -562,6 +563,7 @@ var appSettingsSchema = z2.object({
   model: z2.string().default("deepseek/deepseek-v4-pro"),
   modelSettings: modelSettingsSchema.default(modelSettingsSchema.parse({})),
   modelRequestTimeoutMs: z2.number().int().positive().default(9e4),
+  modelRequestMaxAttempts: z2.number().int().min(1).max(10).default(4),
   t2i: baseT2ISettingsSchema.default(baseT2ISettingsSchema.parse({})),
   notifications: notificationsSettingsSchema.default(notificationsSettingsSchema.parse({})),
   contentTargets: z2.array(contentTargetSchema).min(1).refine((targets) => targets.filter((target) => target.role === "primary").length === 1, {
@@ -580,6 +582,7 @@ var envSettingsSchema = z2.object({
   maxTokens: z2.number().int().positive().optional(),
   topP: z2.number().min(0).max(1).optional(),
   modelRequestTimeoutMs: z2.number().int().positive().optional(),
+  modelRequestMaxAttempts: z2.number().int().min(1).max(10).optional(),
   notificationsEnabled: z2.boolean().optional(),
   style: z2.enum(writingStyleValues).optional(),
   intent: z2.enum(contentIntentValues).optional(),
@@ -624,6 +627,7 @@ function readEnvSettings(env = process.env) {
     maxTokens: parseNumber(env.IDEON_MAX_TOKENS),
     topP: parseNumber(env.IDEON_TOP_P),
     modelRequestTimeoutMs: parseNumber(env.IDEON_MODEL_REQUEST_TIMEOUT_MS),
+    modelRequestMaxAttempts: parseNumber(env.IDEON_MODEL_REQUEST_MAX_ATTEMPTS),
     notificationsEnabled: parseBoolean(env.IDEON_NOTIFICATIONS_ENABLED),
     style: env.IDEON_STYLE,
     intent: env.IDEON_INTENT,
@@ -1424,7 +1428,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 // package.json
 var package_default = {
   name: "@telepat/ideon",
-  version: "0.1.29",
+  version: "0.1.31",
   description: "CLI for generating rich articles and images from ideas.",
   type: "module",
   repository: {
@@ -1461,6 +1465,7 @@ var package_default = {
     test: "NODE_OPTIONS=--experimental-vm-modules jest",
     "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch",
     "test:coverage": "NODE_OPTIONS=--experimental-vm-modules jest --coverage",
+    "guides:sync": "node scripts/sync-writing-guides.mjs",
     "pricing:refresh": "node scripts/refresh-openrouter-pricing.mjs",
     "docs:start": "npm --prefix docs-site run start",
     "docs:start:en": "npm --prefix docs-site run start -- --locale en",
@@ -1546,6 +1551,7 @@ async function resolveRunInput(input) {
     ...job?.settings ?? {},
     ...envSettings.model ? { model: envSettings.model } : {},
     ...envSettings.modelRequestTimeoutMs !== void 0 ? { modelRequestTimeoutMs: envSettings.modelRequestTimeoutMs } : {},
+    ...envSettings.modelRequestMaxAttempts !== void 0 ? { modelRequestMaxAttempts: envSettings.modelRequestMaxAttempts } : {},
     ...envSettings.notificationsEnabled !== void 0 ? {
       notifications: {
         ...savedSettings.notifications,
@@ -3180,6 +3186,212 @@ function buildImagePromptMessages(plan, image, section) {
   ];
 }
 
+// src/llm/retry.ts
+var DEFAULT_BASE_BACKOFF_MS = 1500;
+var DEFAULT_MAX_BACKOFF_MS = 6e4;
+var DEFAULT_JITTER_MS = 250;
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 409, 425, 429]);
+var TRANSIENT_ERROR_PATTERN = /timeout|network|fetch|temporarily|aborted|ECONNRESET|ECONNREFUSED|ENOTFOUND|EAI_AGAIN|ETIMEDOUT|socket hang up/i;
+async function withRetry(op, opts) {
+  const maxAttempts = Math.max(1, Math.floor(opts.maxAttempts));
+  const baseBackoffMs = opts.baseBackoffMs ?? DEFAULT_BASE_BACKOFF_MS;
+  const maxBackoffMs = opts.maxBackoffMs ?? DEFAULT_MAX_BACKOFF_MS;
+  const jitterMs = opts.jitterMs ?? DEFAULT_JITTER_MS;
+  const sleep = opts.sleep ?? defaultSleep;
+  const randomFraction = opts.randomFraction ?? Math.random;
+  let lastError;
+  let lastClassification = null;
+  let attemptsMade = 0;
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    attemptsMade = attempt;
+    try {
+      return await op(attempt);
+    } catch (error) {
+      lastError = error;
+      const classification = classifyHttpError(error);
+      lastClassification = classification;
+      if (!classification.retryable || attempt >= maxAttempts) {
+        break;
+      }
+      const delayMs = computeDelayMs({
+        retryAfterMs: classification.retryAfterMs,
+        attempt,
+        baseBackoffMs,
+        maxBackoffMs,
+        jitterMs,
+        randomFraction
+      });
+      opts.onRetry?.({
+        attempt,
+        delayMs,
+        reason: classification.reason,
+        statusCode: classification.statusCode
+      });
+      await sleep(delayMs);
+    }
+  }
+  throw buildFinalError(opts.operationLabel, attemptsMade, lastError, lastClassification);
+}
+function computeDelayMs(input) {
+  if (typeof input.retryAfterMs === "number" && input.retryAfterMs > 0) {
+    return Math.min(input.maxBackoffMs, input.retryAfterMs);
+  }
+  const exponential = input.baseBackoffMs * 2 ** (input.attempt - 1);
+  const capped = Math.min(input.maxBackoffMs, exponential);
+  const jitter = input.jitterMs > 0 ? input.randomFraction() * input.jitterMs : 0;
+  return Math.floor(capped + jitter);
+}
+function classifyHttpError(error) {
+  if (!error) {
+    return { retryable: true, reason: "Empty error value treated as transient." };
+  }
+  const message = errorMessage(error);
+  const statusFromObject = extractStatusFromObject(error);
+  const statusFromMessage = statusFromObject ?? extractStatusFromMessage(message);
+  const retryAfterMs = extractRetryAfterMs(error, message);
+  if (statusFromMessage !== void 0) {
+    if (RETRYABLE_STATUS_CODES.has(statusFromMessage) || statusFromMessage >= 500) {
+      return {
+        retryable: true,
+        statusCode: statusFromMessage,
+        retryAfterMs,
+        reason: `HTTP ${statusFromMessage}`
+      };
+    }
+    return {
+      retryable: false,
+      statusCode: statusFromMessage,
+      reason: `HTTP ${statusFromMessage}`
+    };
+  }
+  if (TRANSIENT_ERROR_PATTERN.test(message)) {
+    return {
+      retryable: true,
+      retryAfterMs,
+      reason: "Transient network or timeout error."
+    };
+  }
+  return {
+    retryable: true,
+    retryAfterMs,
+    reason: "Unknown error treated as transient."
+  };
+}
+function extractStatusFromObject(error) {
+  if (typeof error !== "object" || error === null) {
+    return void 0;
+  }
+  const record = error;
+  const direct = numberFrom(record.status);
+  if (direct !== void 0) {
+    return direct;
+  }
+  const response = record.response;
+  if (typeof response === "object" && response !== null) {
+    const responseStatus = numberFrom(response.status);
+    if (responseStatus !== void 0) {
+      return responseStatus;
+    }
+  }
+  return void 0;
+}
+function extractStatusFromMessage(message) {
+  const match = message.match(/status\s+(\d{3})/i);
+  if (!match) {
+    return void 0;
+  }
+  const parsed = Number.parseInt(match[1], 10);
+  return Number.isInteger(parsed) ? parsed : void 0;
+}
+function extractRetryAfterMs(error, message) {
+  const headerSeconds = extractRetryAfterHeader(error);
+  if (headerSeconds !== void 0) {
+    return Math.round(headerSeconds * 1e3);
+  }
+  const bodyMatch = message.match(/"?retry_after"?\s*[:=]\s*(\d+(?:\.\d+)?)/i);
+  if (bodyMatch) {
+    const seconds = Number.parseFloat(bodyMatch[1]);
+    if (Number.isFinite(seconds) && seconds > 0) {
+      return Math.round(seconds * 1e3);
+    }
+  }
+  return void 0;
+}
+function extractRetryAfterHeader(error) {
+  if (typeof error !== "object" || error === null) {
+    return void 0;
+  }
+  const response = error.response;
+  if (typeof response !== "object" || response === null) {
+    return void 0;
+  }
+  const headers = response.headers;
+  if (!headers) {
+    return void 0;
+  }
+  let rawValue;
+  if (typeof headers === "object" && typeof headers.get === "function") {
+    rawValue = headers.get("retry-after");
+  } else if (typeof headers === "object") {
+    const entries = headers;
+    rawValue = entries["retry-after"] ?? entries["Retry-After"];
+  }
+  if (typeof rawValue !== "string" && typeof rawValue !== "number") {
+    return void 0;
+  }
+  const stringValue = String(rawValue).trim();
+  if (!stringValue) {
+    return void 0;
+  }
+  const numeric = Number.parseFloat(stringValue);
+  if (Number.isFinite(numeric) && numeric > 0) {
+    return numeric;
+  }
+  const dateMs = Date.parse(stringValue);
+  if (Number.isFinite(dateMs)) {
+    const diffSeconds = (dateMs - Date.now()) / 1e3;
+    return diffSeconds > 0 ? diffSeconds : void 0;
+  }
+  return void 0;
+}
+function numberFrom(value2) {
+  if (typeof value2 === "number" && Number.isFinite(value2)) {
+    return value2;
+  }
+  if (typeof value2 === "string") {
+    const parsed = Number.parseFloat(value2);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
+function errorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}
+function buildFinalError(operationLabel, attempts, cause, classification) {
+  const detail = errorMessage(cause) || classification?.reason || "unknown error";
+  const message = `${operationLabel} failed after ${attempts} attempt${attempts === 1 ? "" : "s"}: ${detail}`;
+  const wrapped = new Error(message, cause instanceof Error ? { cause } : void 0);
+  if (!(cause instanceof Error) && cause !== void 0) {
+    wrapped.cause = cause;
+  }
+  return wrapped;
+}
+function defaultSleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
 // src/pipeline/analytics.ts
 var LLM_USD_PER_1K_TOKENS = {
   // AUTO-GENERATED:OPENROUTER_PRICING_START
@@ -3432,8 +3644,26 @@ async function renderExpandedImages({
       ...replicateModelOverride && isReplicateModelIdForFamily(family, replicateModelOverride) ? { replicateModel: replicateModelOverride } : {}
     };
     const renderStartedAtMs = Date.now();
+    let attemptsMade = 0;
+    let retryCount = 0;
+    let retryBackoffMs = 0;
     try {
-      const result = await limn.generate(prompt.prompt, family, limnOptions);
+      const result = await withRetry(
+        () => {
+          attemptsMade += 1;
+          return limn.generate(prompt.prompt, family, limnOptions);
+        },
+        {
+          operationLabel: `Replicate ${prompt.kind} image (${prompt.id})`,
+          maxAttempts: settings.t2i.maxAttempts,
+          baseBackoffMs: 1500,
+          maxBackoffMs: 6e4,
+          onRetry({ delayMs }) {
+            retryCount += 1;
+            retryBackoffMs += delayMs;
+          }
+        }
+      );
       const ext = mimeTypeToExtension(result.mimeType);
       const liveFileName = `${prompt.kind === "cover" ? "cover" : `inline-${prompt.anchorAfterSection}`}-${index + 1}.${ext}`;
       const liveOutputPath = path6.join(assetDir, liveFileName);
@@ -3455,9 +3685,9 @@ async function renderExpandedImages({
         kind: prompt.kind,
         modelId: result.modelSlug,
         durationMs: result.analytics.totalDurationMs,
-        attempts: 1,
-        retries: 0,
-        retryBackoffMs: 0,
+        attempts: attemptsMade,
+        retries: retryCount,
+        retryBackoffMs,
         outputBytes: result.image.byteLength,
         costUsd: result.analytics.totalEstimatedCostUsd,
         costSource
@@ -3471,9 +3701,9 @@ async function renderExpandedImages({
         startedAt: new Date(renderStartedAtMs).toISOString(),
         endedAt: (/* @__PURE__ */ new Date()).toISOString(),
         durationMs: result.analytics.totalDurationMs,
-        attempts: 1,
-        retries: 0,
-        retryBackoffMs: 0,
+        attempts: attemptsMade,
+        retries: retryCount,
+        retryBackoffMs,
         status: "succeeded",
         prompt: prompt.prompt,
         input: {},
@@ -3490,9 +3720,9 @@ async function renderExpandedImages({
         startedAt: new Date(renderStartedAtMs).toISOString(),
         endedAt: (/* @__PURE__ */ new Date()).toISOString(),
         durationMs,
-        attempts: 1,
-        retries: 0,
-        retryBackoffMs: 0,
+        attempts: Math.max(attemptsMade, 1),
+        retries: retryCount,
+        retryBackoffMs,
         status: "failed",
         prompt: prompt.prompt,
         input: {},
@@ -3552,8 +3782,9 @@ var OpenRouterClient = class {
   }
   async requestStructured(request) {
     let aggregatedMetrics = null;
+    const maxParseAttempts = Math.max(1, request.settings.modelRequestMaxAttempts);
     try {
-      for (let attempt = 0; attempt < 3; attempt += 1) {
+      for (let attempt = 0; attempt < maxParseAttempts; attempt += 1) {
         const response = await this.sendCompletion({
           messages: request.messages,
           settings: request.settings,
@@ -3578,7 +3809,7 @@ var OpenRouterClient = class {
           request.onMetrics?.(aggregatedMetrics);
           return structured;
         } catch (parseError) {
-          if (attempt < 2 && shouldRetryStructuredParseError(parseError)) {
+          if (attempt < maxParseAttempts - 1 && shouldRetryStructuredParseError(parseError)) {
             const backoff = backoffMs(attempt);
             aggregatedMetrics = recordParseRetryMetrics(aggregatedMetrics, backoff);
             await wait(backoff);
@@ -3644,7 +3875,8 @@ var OpenRouterClient = class {
     let attempts = 0;
     let retries = 0;
     let retryBackoffMs = 0;
-    for (let attempt = 0; attempt < 3; attempt += 1) {
+    const maxAttempts = Math.max(1, settings.modelRequestMaxAttempts);
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
       attempts = attempt + 1;
       const attemptStartedAtMs = Date.now();
       const controller = new AbortController();
@@ -3691,9 +3923,12 @@ var OpenRouterClient = class {
         responseBodyRaw = rawBody;
         const json = parseOpenRouterResponse(rawBody);
         if (!response.ok) {
-          const message = json?.error?.message ?? `OpenRouter request failed with status ${response.status}`;
-          if (shouldRetryStatus(response.status) && attempt < 2) {
-            const backoff = backoffMs(attempt);
+          const providerMessage = json?.error?.message ?? `OpenRouter request failed with status ${response.status}`;
+          const raw = json?.error?.metadata?.raw;
+          const message = raw ? `${raw} (OpenRouter: ${providerMessage})` : providerMessage;
+          if (shouldRetryStatus(response.status) && attempt < maxAttempts - 1) {
+            const advisedMs = extractRetryAfterFromResponse(response, json, rawBody);
+            const backoff = advisedMs !== null ? Math.min(MAX_RETRY_BACKOFF_MS, advisedMs) : backoffMs(attempt);
             retries += 1;
             retryBackoffMs += backoff;
             onInteraction?.({
@@ -3719,7 +3954,7 @@ var OpenRouterClient = class {
           throw new Error(message);
         }
         const content = json.choices?.[0]?.message?.content;
-        if (!content && attempt < 2) {
+        if (!content && attempt < maxAttempts - 1) {
           const backoff = backoffMs(attempt);
           retries += 1;
           retryBackoffMs += backoff;
@@ -3795,7 +4030,7 @@ var OpenRouterClient = class {
           responseBody: responseBodyRaw,
           errorMessage: lastError.message
         });
-        if (attempt < 2 && shouldRetryError(lastError)) {
+        if (attempt < maxAttempts - 1 && shouldRetryError(lastError)) {
           const backoff = backoffMs(attempt);
           retries += 1;
           retryBackoffMs += backoff;
@@ -3922,6 +4157,61 @@ function normalizeClientError(error, timeoutMs) {
 function backoffMs(attempt) {
   return 500 * (attempt + 1);
 }
+var MAX_RETRY_BACKOFF_MS = 6e4;
+function extractRetryAfterFromResponse(response, json, rawBody) {
+  const headerValue = typeof response.headers?.get === "function" ? response.headers.get("retry-after") : null;
+  if (headerValue) {
+    const numeric = Number.parseFloat(headerValue);
+    if (Number.isFinite(numeric) && numeric > 0) {
+      return Math.round(numeric * 1e3);
+    }
+    const dateMs = Date.parse(headerValue);
+    if (Number.isFinite(dateMs)) {
+      const diff = dateMs - Date.now();
+      if (diff > 0) {
+        return diff;
+      }
+    }
+  }
+  const metadata = json?.error?.metadata;
+  if (metadata) {
+    const fromMetadata = metadata["retry_after"] ?? metadata["retryAfter"];
+    const numeric = toFiniteNumber(fromMetadata);
+    if (numeric !== null && numeric > 0) {
+      return Math.round(numeric * 1e3);
+    }
+    const rawCandidate = metadata["raw"];
+    if (typeof rawCandidate === "string") {
+      const fromRaw = extractRetryAfterFromString(rawCandidate);
+      if (fromRaw !== null) {
+        return fromRaw;
+      }
+    }
+  }
+  const fromBody = extractRetryAfterFromString(rawBody);
+  if (fromBody !== null) {
+    return fromBody;
+  }
+  return null;
+}
+function extractRetryAfterFromString(value2) {
+  const bodyMatch = value2.match(/\\?"retry_after\\?"\s*:\s*(\d+(?:\.\d+)?)/i);
+  if (!bodyMatch) {
+    return null;
+  }
+  const numeric = Number.parseFloat(bodyMatch[1]);
+  return Number.isFinite(numeric) && numeric > 0 ? Math.round(numeric * 1e3) : null;
+}
+function toFiniteNumber(value2) {
+  if (typeof value2 === "number" && Number.isFinite(value2)) {
+    return value2;
+  }
+  if (typeof value2 === "string") {
+    const parsed = Number.parseFloat(value2);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
 function aggregateLlmMetrics(total, next) {
   if (!total) {
     return { ...next };
@@ -4330,7 +4620,7 @@ async function runPipelineShell(input, options = {}) {
   const llmInteractions = [];
   const t2iInteractions = [];
   let writeSession;
-  const applyRetryUpdate = (stageId, retryIncrement, errorMessage) => {
+  const applyRetryUpdate = (stageId, retryIncrement, errorMessage2) => {
     if (retryIncrement <= 0) {
       return;
     }
@@ -4341,7 +4631,7 @@ async function runPipelineShell(input, options = {}) {
     const existing = stageRetryState.get(stageId) ?? { retries: 0, lastError: null };
     const next = {
       retries: existing.retries + retryIncrement,
-      lastError: errorMessage && errorMessage.trim().length > 0 ? errorMessage : existing.lastError
+      lastError: errorMessage2 && errorMessage2.trim().length > 0 ? errorMessage2 : existing.lastError
     };
     stageRetryState.set(stageId, next);
     stages[stageIndex] = {
@@ -7381,7 +7671,8 @@ function SettingsFlow({ initialSettings, initialSecrets, onDone }) {
               t2i: {
                 modelId: item.value,
                 replicateModelId: current.t2i.replicateModelId && isReplicateModelIdForFamily(item.value, current.t2i.replicateModelId) ? current.t2i.replicateModelId : void 0,
-                inputOverrides: {}
+                inputOverrides: {},
+                maxAttempts: current.t2i.maxAttempts
               }
             }));
             setShowModelSelect(false);
@@ -9201,6 +9492,10 @@ function renderShell({
           \`<code class="slug-text">\${escapeHtml(output.slug)}</code>\`,
           \`<button class="copy-btn" data-copy-slug="\${escapeHtml(output.slug)}" type="button">Copy slug</button>\`,
           '</div>',
+          '<div class="slug-row">',
+          \`<code class="slug-text">\${escapeHtml(currentGeneration.generationId)}</code>\`,
+          \`<button class="copy-btn" data-copy-generation-id="\${escapeHtml(currentGeneration.generationId)}" type="button">Copy generation ID</button>\`,
+          '</div>',
           \`<div class="channel-meta">\${escapeHtml(output.contentTypeLabel)} \u2022 Variant \${output.index}</div>\`,
           '</div>',
           '</div>',
@@ -9312,6 +9607,12 @@ function renderShell({
         const copyButton = target.closest('[data-copy-slug]');
         if (copyButton instanceof HTMLElement && copyButton.dataset.copySlug) {
           copySlug(copyButton, copyButton.dataset.copySlug);
+          return;
+        }
+
+        const copyGenerationIdButton = target.closest('[data-copy-generation-id]');
+        if (copyGenerationIdButton instanceof HTMLElement && copyGenerationIdButton.dataset.copyGenerationId) {
+          copySlug(copyGenerationIdButton, copyGenerationIdButton.dataset.copyGenerationId);
         }
       });
 
@@ -9697,13 +9998,13 @@ function PipelinePresenter({
   prompt,
   stages,
   result,
-  errorMessage
+  errorMessage: errorMessage2
 }) {
   const visibleStages = getVisibleStages(stages);
   const maxVisibleItems = computeMaxVisibleItemsPerStage({
     terminalRows: process.stdout.rows,
     visibleStageCount: visibleStages.length,
-    hasError: Boolean(errorMessage),
+    hasError: Boolean(errorMessage2),
     hasResult: Boolean(result)
   });
   return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", paddingX: 1, children: [
@@ -9719,7 +10020,7 @@ function PipelinePresenter({
       },
       stage.id
     )) }),
-    errorMessage ? /* @__PURE__ */ jsx5(Box4, { marginTop: 1, borderStyle: "round", borderColor: "red", paddingX: 1, children: /* @__PURE__ */ jsx5(Text4, { color: "red", children: errorMessage }) }) : null,
+    errorMessage2 ? /* @__PURE__ */ jsx5(Box4, { marginTop: 1, borderStyle: "round", borderColor: "red", paddingX: 1, children: /* @__PURE__ */ jsx5(Text4, { color: "red", children: errorMessage2 }) }) : null,
     result ? /* @__PURE__ */ jsx5(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx5(FinalSummary, { artifact: result.artifact, analytics: result.analytics }) }) : null
   ] });
 }
@@ -10254,7 +10555,7 @@ function WriteApp({
     () => createInitialStages()
   );
   const [result, setResult] = useState4(null);
-  const [errorMessage, setErrorMessage] = useState4(null);
+  const [errorMessage2, setErrorMessage] = useState4(null);
   useEffect3(() => {
     let mounted = true;
     void (async () => {
@@ -10307,7 +10608,7 @@ function WriteApp({
     };
   }, [dryRun, enrichLinks2, input, links, unlinks, maxLinks, maxImages, onError, runMode]);
   useEffect3(() => {
-    if (!result && !errorMessage) {
+    if (!result && !errorMessage2) {
       return;
     }
     const exitTimer = setTimeout(() => {
@@ -10316,8 +10617,8 @@ function WriteApp({
     return () => {
       clearTimeout(exitTimer);
     };
-  }, [errorMessage, exit, result]);
-  return /* @__PURE__ */ jsx7(PipelinePresenter, { prompt: input.idea, stages, result, errorMessage });
+  }, [errorMessage2, exit, result]);
+  return /* @__PURE__ */ jsx7(PipelinePresenter, { prompt: input.idea, stages, result, errorMessage: errorMessage2 });
 }
 async function runWriteCommand(options) {
   const input = await resolveInputWithInteractiveIdeaFallback(options);