@telepat/ideon 0.1.7 → 0.1.13

package/dist/ideon.js

@@ -12,15 +12,87 @@ import { z } from "zod";
 var contentTypeValues = [
   "article",
   "blog-post",
-  "x-thread",
-  "x-post",
-  "reddit-post",
   "linkedin-post",
   "newsletter",
-  "landing-page-copy"
+  "press-release",
+  "reddit-post",
+  "science-paper",
+  "x-post",
+  "x-thread"
+];
+var writingStyleValues = [
+  "academic",
+  "analytical",
+  "authoritative",
+  "conversational",
+  "empathetic",
+  "friendly",
+  "journalistic",
+  "minimalist",
+  "persuasive",
+  "playful",
+  "professional",
+  "storytelling",
+  "technical"
+];
+var contentIntentValues = [
+  "announcement",
+  "case-study",
+  "cornerstone",
+  "counterargument",
+  "critique-review",
+  "deep-dive-analysis",
+  "how-to-guide",
+  "interview-q-and-a",
+  "listicle",
+  "opinion-piece",
+  "personal-essay",
+  "roundup-curation",
+  "tutorial"
 ];
-var writingStyleValues = ["professional", "friendly", "technical", "academic", "opinionated", "storytelling"];
 var targetLengthValues = ["small", "medium", "large"];
+var targetLengthAliasWordCounts = {
+  small: 500,
+  medium: 900,
+  large: 1400
+};
+var defaultTargetLengthWords = targetLengthAliasWordCounts.medium;
+function parseTargetLengthWords(value2) {
+  if (typeof value2 === "number") {
+    return Number.isInteger(value2) && value2 > 0 ? value2 : void 0;
+  }
+  if (typeof value2 !== "string") {
+    return void 0;
+  }
+  const normalized = value2.trim().toLowerCase();
+  if (normalized.length === 0) {
+    return void 0;
+  }
+  if (targetLengthValues.includes(normalized)) {
+    return targetLengthAliasWordCounts[normalized];
+  }
+  if (!/^\d+$/.test(normalized)) {
+    return void 0;
+  }
+  const parsed = Number.parseInt(normalized, 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
+}
+var targetLengthWordsSchema = z.preprocess(
+  (value2) => parseTargetLengthWords(value2),
+  z.number().int().positive()
+);
+function resolveTargetLengthAlias(targetLengthWords) {
+  if (!Number.isFinite(targetLengthWords) || targetLengthWords <= 0) {
+    return "medium";
+  }
+  if (targetLengthWords <= 700) {
+    return "small";
+  }
+  if (targetLengthWords <= 1150) {
+    return "medium";
+  }
+  return "large";
+}
 var contentTargetRoleValues = ["primary", "secondary"];
 var contentTargetSchema = z.object({
   contentType: z.enum(contentTypeValues),
@@ -51,7 +123,8 @@ var appSettingsSchema = z.object({
     message: "contentTargets must include exactly one primary target."
   }).default([{ contentType: "article", role: "primary", count: 1 }]),
   style: z.enum(writingStyleValues).default("professional"),
-  targetLength: z.enum(targetLengthValues).default("medium")
+  intent: z.enum(contentIntentValues).default("tutorial"),
+  targetLength: targetLengthWordsSchema.default(defaultTargetLengthWords)
 });
 var envSettingsSchema = z.object({
   openRouterApiKey: z.string().optional(),
@@ -66,7 +139,8 @@ var envSettingsSchema = z.object({
   markdownOutputDir: z.string().optional(),
   assetOutputDir: z.string().optional(),
   style: z.enum(writingStyleValues).optional(),
-  targetLength: z.enum(targetLengthValues).optional()
+  intent: z.enum(contentIntentValues).optional(),
+  targetLength: targetLengthWordsSchema.optional()
 });
 var jobInputSchema = z.object({
   idea: z.string().min(1).optional(),
@@ -111,6 +185,7 @@ function readEnvSettings(env = process.env) {
     markdownOutputDir: env.IDEON_MARKDOWN_OUTPUT_DIR,
     assetOutputDir: env.IDEON_ASSET_OUTPUT_DIR,
     style: env.IDEON_STYLE,
+    intent: env.IDEON_INTENT,
     targetLength: env.IDEON_TARGET_LENGTH
   });
 }
@@ -179,6 +254,37 @@ function buildGenerationDirectoryName(baseSlug, now = /* @__PURE__ */ new Date()
   ].join("");
   return `${stamp}-${baseSlug}`;
 }
+async function listMarkdownFilesRecursively(rootDir) {
+  return listFilesRecursively(rootDir, (fileName) => fileName.toLowerCase().endsWith(".md"));
+}
+async function listFilesRecursively(rootDir, predicate) {
+  const fs = await import("fs/promises");
+  const results = [];
+  const stack = [rootDir];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) {
+      continue;
+    }
+    let entries;
+    try {
+      entries = await fs.readdir(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const fullPath = path2.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+        continue;
+      }
+      if (entry.isFile() && predicate(entry.name)) {
+        results.push(fullPath);
+      }
+    }
+  }
+  return results;
+}
 async function writeUtf8File(filePath, content) {
   await mkdir2(path2.dirname(filePath), { recursive: true });
   await writeFile2(filePath, content, "utf8");
@@ -637,6 +743,7 @@ var configSettingKeys = [
   "markdownOutputDir",
   "assetOutputDir",
   "style",
+  "intent",
   "targetLength"
 ];
 var configSecretKeys = ["openRouterApiKey", "replicateApiToken"];
@@ -665,6 +772,7 @@ async function configList() {
       markdownOutputDir: settings.markdownOutputDir,
       assetOutputDir: settings.assetOutputDir,
       style: settings.style,
+      intent: settings.intent,
       targetLength: settings.targetLength
     },
     secrets: {
@@ -767,12 +875,23 @@ function coerceSettingValue(key, rawValue) {
       }
       return trimmed;
     }
-    case "targetLength": {
-      if (!targetLengthValues.includes(trimmed)) {
-        throw new Error(`targetLength must be one of: ${targetLengthValues.join(", ")}.`);
+    case "intent": {
+      if (!contentIntentValues.includes(trimmed)) {
+        throw new Error(`intent must be one of: ${contentIntentValues.join(", ")}.`);
       }
       return trimmed;
     }
+    case "targetLength": {
+      const normalized = trimmed.toLowerCase();
+      if (targetLengthValues.includes(normalized)) {
+        return normalized;
+      }
+      const parsed = Number.parseInt(trimmed, 10);
+      if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error(`targetLength must be one of: ${targetLengthValues.join(", ")}, or a positive integer word count.`);
+      }
+      return parsed;
+    }
     default:
       throw new Error(`Unsupported config key: ${key}`);
   }
@@ -797,6 +916,8 @@ function getSettingValue(settings, key) {
       return settings.assetOutputDir;
     case "style":
       return settings.style;
+    case "intent":
+      return settings.intent;
     case "targetLength":
       return settings.targetLength;
     default:
@@ -823,6 +944,8 @@ function setSettingValue(settings, key, value2) {
       return { ...settings, assetOutputDir: value2 };
     case "style":
       return { ...settings, style: value2 };
+    case "intent":
+      return { ...settings, intent: value2 };
     case "targetLength":
       return { ...settings, targetLength: value2 };
     default:
@@ -840,7 +963,8 @@ var writeToolInputSchema = {
   primary: z3.string().optional(),
   secondary: z3.array(z3.string()).optional(),
   style: z3.enum(writingStyleValues).optional(),
-  length: z3.enum(targetLengthValues).optional(),
+  intent: z3.enum(contentIntentValues).optional(),
+  length: z3.union([z3.enum(targetLengthValues), z3.coerce.number().int().positive()]).optional(),
   dryRun: z3.boolean().optional(),
   enrichLinks: z3.boolean().optional()
 };
@@ -869,6 +993,7 @@ var ideonToolContracts = [
     required: ["idea"],
     enums: {
       style: [...writingStyleValues],
+      intent: [...contentIntentValues],
       length: [...targetLengthValues]
     }
   },
@@ -899,6 +1024,7 @@ var ideonSkillRegistry = [
       required: ["idea"],
       enums: {
         style: [...writingStyleValues],
+        intent: [...contentIntentValues],
         length: [...targetLengthValues]
       }
     }
@@ -959,6 +1085,18 @@ function validateIntegrationContracts(sources = {
       [...writeSkill.inputContract.enums.style ?? []].sort(),
       [...writingStyleValues].sort()
     );
+    compareStringArrays(
+      drifts,
+      "write.enum.intent.tool-vs-schema",
+      [...writeTool.enums.intent ?? []].sort(),
+      [...contentIntentValues].sort()
+    );
+    compareStringArrays(
+      drifts,
+      "write.enum.intent.skill-vs-schema",
+      [...writeSkill.inputContract.enums.intent ?? []].sort(),
+      [...contentIntentValues].sort()
+    );
     compareStringArrays(
       drifts,
       "write.enum.length.tool-vs-schema",
@@ -1161,7 +1299,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 // package.json
 var package_default = {
   name: "@telepat/ideon",
-  version: "0.1.7",
+  version: "0.1.13",
   description: "CLI for generating rich articles and images from ideas.",
   type: "module",
   repository: {
@@ -1301,8 +1439,10 @@ async function resolveRunInput(input) {
     ...envSettings.markdownOutputDir ? { markdownOutputDir: envSettings.markdownOutputDir } : {},
     ...envSettings.assetOutputDir ? { assetOutputDir: envSettings.assetOutputDir } : {},
     ...envSettings.style ? { style: envSettings.style } : {},
+    ...envSettings.intent ? { intent: envSettings.intent } : {},
     ...envSettings.targetLength ? { targetLength: envSettings.targetLength } : {},
     ...input.style ? { style: input.style } : {},
+    ...input.intent ? { intent: input.intent } : {},
     ...input.targetLength ? { targetLength: input.targetLength } : {},
     ...input.contentTargets ? { contentTargets: input.contentTargets } : {}
   });
@@ -1362,7 +1502,7 @@ function assertNoLegacyXMode(contentTargets, sourceLabel) {
 // src/pipeline/runner.ts
 import { mkdir as mkdir5, stat as stat2 } from "fs/promises";
 import { randomUUID } from "crypto";
-import path7 from "path";
+import path8 from "path";
 
 // src/generation/enrichLinks.ts
 import { readFile as readFile4 } from "fs/promises";
@@ -1669,44 +1809,6 @@ function toExpressionPreview(expression, maxLength = 60) {
 }
 
 // src/llm/prompts/writingFramework.ts
-var BASE_WRITING_FRAMEWORK = [
-  "Writing framework:",
-  "Structure with intent: open with a clear hook, build ideas in a logical progression, and close with a concrete takeaway.",
-  "Information density mandate: each sentence must add new value, mechanism, evidence, or action; avoid empty recap lines.",
-  "Specificity over vagueness: use concrete details, named mechanisms, and practical examples instead of abstract filler.",
-  "Rhythm and readability: vary sentence length with short, medium, and occasional longer lines to avoid monotony and keep pace.",
-  "Scannability and signposting: make section flow obvious with strong headings, parallel list structure, and clear paragraph openings.",
-  "Active voice and concrete subjects: make the actor explicit and keep claims verifiable.",
-  "Story discipline: use narrative only when it clarifies the idea, and tie every story beat to reader outcome.",
-  "Channel fit: match native conventions of the target format while preserving clarity and substance.",
-  "Authenticity filter: prefer plain professional language over polished AI-sounding phrasing or generic corporate jargon."
-].join(" ");
-var DO_AVOID_EXAMPLES = [
-  "Do examples:",
-  'Do write concrete guidance such as "Use a 3-step rollout checklist with owner, deadline, and acceptance signal".',
-  'Do write a precise hook such as "Most teams lose two weeks per launch because approvals have no clear owner".',
-  "Do make outcomes measurable with numbers, constraints, or operational tradeoffs when possible.",
-  "Avoid examples:",
-  'Avoid generic lines such as "In todays world, innovation is important".',
-  'Avoid empty claims such as "This strategy changes everything" without evidence or mechanism.',
-  "Avoid over-polished transitions and dramatic cliches when a simple connector is clearer.",
-  "Avoid ending paragraphs with summary-only filler that adds no new information."
-].join(" ");
-var STYLE_DIRECTIVES = {
-  professional: "Style directive (professional): use crisp, confident language, balanced tone, and decision-ready framing. Favor precise terms, low hype, and explicit constraints.",
-  friendly: "Style directive (friendly): use warm, conversational language, simple transitions, and approachable phrasing. Use natural contractions and short punchy lines without losing specificity.",
-  technical: "Style directive (technical): prioritize precision, explicit terminology, and implementation-level clarity. Preserve canonical technical terms, avoid unnecessary synonyms, and state assumptions directly.",
-  academic: "Style directive (academic): use formal tone, careful qualification, and analytical structure. Distinguish evidence from inference and avoid rhetorical overstatement.",
-  opinionated: "Style directive (opinionated): take a clear stance, defend it with reasoning, and avoid hedging. Make tradeoffs explicit and support claims with concrete examples.",
-  storytelling: "Style directive (storytelling): foreground scene and momentum, then extract practical insight at each turn. Use sensory or situational detail sparingly and always tie it to utility."
-};
-var FALLBACK_STYLE_DIRECTIVE = "Style directive: keep tone consistent, intentional, and aligned with requested audience and channel. Prefer specific, active, and concrete language over generic polish.";
-function buildWritingFrameworkInstruction() {
-  return [BASE_WRITING_FRAMEWORK, DO_AVOID_EXAMPLES].join(" ");
-}
-function buildStyleDirective(style) {
-  return STYLE_DIRECTIVES[style] ?? FALLBACK_STYLE_DIRECTIVE;
-}
 function buildRunContextDirective(contentTypes) {
   const normalizedTypes = contentTypes.length > 0 ? contentTypes.join(", ") : "article";
   return `Run context: requested content types are ${normalizedTypes}. Keep output aligned with this distribution plan, maintain one shared content brief, and adapt structure per channel without duplicating article-only scaffolding.`;
@@ -1716,42 +1818,148 @@ var TARGET_LENGTH_TIERS = {
     label: "small",
     article: "Target length (small article): 300\u2013800 words total, 2\u20134 sections, ~2\u20133 paragraphs per section. One core idea, lightly explored. Minimal storytelling. Use for quick explainers.",
     "blog-post": "Target length (small blog post): 500\u2013900 words. Answer-focused, minimal fluff, straight to value. Good for long-tail SEO and short how-to queries.",
-    "x-thread": "Target length (small x-thread): 3\u20135 posts, each post one clear idea with momentum from one step to the next.",
-    "x-post": "Target length (small x-post): 70\u2013150 characters, one idea, pure hook or insight.",
-    "reddit-post": "Target length (small reddit post): 150\u2013400 words. Quick question or observation, minimal formatting.",
     "linkedin-post": "Target length (small linkedin post): 50\u2013150 words, 3\u20136 lines, single insight.",
     newsletter: "Target length (small newsletter): 300\u2013800 words, 1\u20132 sections, one core idea.",
-    "landing-page-copy": "Target length (small landing page): 150\u2013400 words total. Sections: headline, subhead, CTA only.",
+    "press-release": "Target length (small press release): 300\u2013700 words with headline, lead, core announcement details, and concise quote block.",
+    "reddit-post": "Target length (small reddit post): 150\u2013400 words. Quick question or observation, minimal formatting.",
+    "science-paper": "Target length (small science paper): 800\u20131,400 words condensed structure with abstract-style opener, methods summary, and key findings.",
+    "x-post": "Target length (small x-post): 70\u2013150 characters, one idea, pure hook or insight.",
+    "x-thread": "Target length (small x-thread): 3\u20135 posts, each post one clear idea with momentum from one step to the next.",
     fallback: "Target length (small): 50\u2013300 words. Compressed insight density. Prioritise hooks and key points over elaboration."
   },
   medium: {
     label: "medium",
     article: "Target length (medium article): 800\u20131,800 words total, 4\u20136 sections, ~3\u20135 paragraphs per section. 2\u20133 core ideas with examples and light narrative. Default best-performing size.",
     "blog-post": "Target length (medium blog post): 900\u20131,800 words. Structured with clear H2s, includes examples and takeaways. Sweet spot for SEO and readability.",
-    "x-thread": "Target length (medium x-thread): 5\u20138 posts, each post concise and additive, with clear narrative progression.",
-    "x-post": "Target length (medium x-post): 150\u2013280 characters or 2\u20134 short lines, 1\u20132 ideas with slight expansion.",
-    "reddit-post": "Target length (medium reddit post): 400\u20131,200 words. Context, experience, and question. Conversational tone.",
     "linkedin-post": "Target length (medium linkedin post): 150\u2013400 words, 8\u201315 short lines, story plus takeaway. Best performing range.",
     newsletter: "Target length (medium newsletter): 800\u20131,800 words, 2\u20134 sections, curated insights. Ideal default.",
-    "landing-page-copy": "Target length (medium landing page): 400\u2013900 words. Sections: hero, benefits, social proof, CTA.",
+    "press-release": "Target length (medium press release): 700\u20131,200 words with complete release anatomy, context, quote, and next-step details.",
+    "reddit-post": "Target length (medium reddit post): 400\u20131,200 words. Context, experience, and question. Conversational tone.",
+    "science-paper": "Target length (medium science paper): 1,400\u20132,600 words with clearer methodological depth, results framing, and discussion of limitations.",
+    "x-post": "Target length (medium x-post): 150\u2013280 characters or 2\u20134 short lines, 1\u20132 ideas with slight expansion.",
+    "x-thread": "Target length (medium x-thread): 5\u20138 posts, each post concise and additive, with clear narrative progression.",
     fallback: "Target length (medium): 300\u20131,200 words. Balanced depth and breadth with examples and actionable takeaways."
   },
   large: {
     label: "large",
     article: "Target length (large article): 1,800\u20133,500+ words total, 6\u201310 sections, ~5\u20138 paragraphs per section. Deep exploration with frameworks, strong internal linking potential. Use for SEO authority and pillar content.",
     "blog-post": "Target length (large blog post): 1,800\u20133,000 words. Comprehensive coverage with FAQs, examples, and edge cases. Use when competing for high-value keywords.",
-    "x-thread": "Target length (large x-thread): 8\u201312 posts, each post one punchy idea with strong narrative progression. Every post must independently hook.",
-    "x-post": "Target length (large x-post): 200\u2013300 characters, one strong stance plus one supporting detail or proof.",
-    "reddit-post": "Target length (large reddit post): 1,200\u20132,500+ words. Detailed breakdown with story, lessons, numbers, and mistakes.",
     "linkedin-post": "Target length (large linkedin post): 400\u2013900 words. Structured storytelling, multiple insights. Use sparingly for deep authority posts.",
     newsletter: "Target length (large newsletter): 1,800\u20133,000 words. Multi-topic edition with deep commentary. Use for weekly deep dives.",
-    "landing-page-copy": "Target length (large landing page): 900\u20132,000+ words. Includes objection handling, FAQs, detailed benefits, and case studies.",
+    "press-release": "Target length (large press release): 1,200\u20132,000+ words with full context, expanded quote material, and detailed release implications.",
+    "reddit-post": "Target length (large reddit post): 1,200\u20132,500+ words. Detailed breakdown with story, lessons, numbers, and mistakes.",
+    "science-paper": "Target length (large science paper): 2,600\u20134,500+ words with full narrative arc from research question through methods, results, and implications.",
+    "x-post": "Target length (large x-post): 200\u2013300 characters, one strong stance plus one supporting detail or proof.",
+    "x-thread": "Target length (large x-thread): 8\u201312 posts, each post one punchy idea with strong narrative progression. Every post must independently hook.",
     fallback: "Target length (large): 1,200\u20133,500+ words. Deep exploration with frameworks, multiple examples, and expanded narrative."
   }
 };
-function buildTargetLengthDirective(contentType, targetLength) {
-  const tier = TARGET_LENGTH_TIERS[targetLength] ?? TARGET_LENGTH_TIERS["medium"];
-  return tier[contentType] ?? tier.fallback;
+function buildTargetLengthDirective(contentType, targetLengthWords) {
+  const normalizedTargetLengthWords = Number.isFinite(targetLengthWords) && targetLengthWords > 0 ? Math.round(targetLengthWords) : 900;
+  const alias = resolveTargetLengthAlias(normalizedTargetLengthWords);
+  const tier = TARGET_LENGTH_TIERS[alias] ?? TARGET_LENGTH_TIERS["medium"];
+  if (contentType === "article") {
+    return `Target length (article): aim for about ${normalizedTargetLengthWords} words total while keeping section depth and structure consistent.`;
+  }
+  const baseDirective = tier[contentType] ?? tier.fallback;
+  return `${baseDirective} Overall run target is about ${normalizedTargetLengthWords} words.`;
+}
+
+// src/llm/prompts/guideBundles.ts
+import { existsSync, readFileSync } from "fs";
+import path5 from "path";
+var guideCache = /* @__PURE__ */ new Map();
+function normalizeGuideContent(content) {
+  return content.replace(/\r\n/g, "\n").trim();
+}
+function readGuideFile(relativePath) {
+  const cached = guideCache.get(relativePath);
+  if (cached) {
+    return cached;
+  }
+  const absolutePath = path5.resolve(process.cwd(), relativePath);
+  if (!existsSync(absolutePath)) {
+    const fallback = `Guide unavailable: ${relativePath}. Continue with the remaining guidance.`;
+    guideCache.set(relativePath, fallback);
+    return fallback;
+  }
+  try {
+    const content = normalizeGuideContent(readFileSync(absolutePath, "utf8"));
+    guideCache.set(relativePath, content);
+    return content;
+  } catch {
+    const fallback = `Guide failed to load: ${relativePath}. Continue with the remaining guidance.`;
+    guideCache.set(relativePath, fallback);
+    return fallback;
+  }
+}
+function buildGuideSection(relativePath) {
+  const content = readGuideFile(relativePath);
+  return [
+    `Guide source: ${relativePath}`,
+    content
+  ].join("\n");
+}
+function formatToGuidePath(contentType) {
+  return `writing-guide/formats/${contentType}.md`;
+}
+function intentToGuidePath(intent) {
+  return `writing-guide/content-intent/${intent}.md`;
+}
+function styleToGuidePath(style) {
+  return `writing-guide/styles/${style}.md`;
+}
+function dedupe(items) {
+  return Array.from(new Set(items));
+}
+function buildGuideBundle(relativePaths) {
+  const blocks = dedupe(relativePaths).map((relativePath) => buildGuideSection(relativePath));
+  return [
+    "External writing guides (apply these rules directly):",
+    ...blocks
+  ].join("\n\n");
+}
+function buildArticlePlanGuideInstruction(intent, contentType) {
+  return buildGuideBundle([
+    "writing-guide/references/headline-writing-systems.md",
+    "writing-guide/references/ideation-and-credibility-systems.md",
+    "writing-guide/references/content-frameworks.md",
+    intentToGuidePath(intent),
+    formatToGuidePath(contentType)
+  ]);
+}
+function buildArticleSectionGuideInstruction(style, intent, contentType) {
+  return buildGuideBundle([
+    "writing-guide/general/core-web-writing-rules.md",
+    "writing-guide/references/emotional-resonance.md",
+    "writing-guide/references/prose-quality-checks.md",
+    "writing-guide/references/readability-and-pace.md",
+    "writing-guide/references/skimmability-patterns.md",
+    styleToGuidePath(style),
+    intentToGuidePath(intent),
+    formatToGuidePath(contentType)
+  ]);
+}
+function buildContentBriefGuideInstruction(intent, primaryContentType, secondaryContentTypes) {
+  return buildGuideBundle([
+    "writing-guide/references/multi-channel-brief-strategy.md",
+    "writing-guide/references/content-frameworks.md",
+    "writing-guide/references/target-length-guidance.md",
+    intentToGuidePath(intent),
+    formatToGuidePath(primaryContentType),
+    ...secondaryContentTypes.map((contentType) => formatToGuidePath(contentType))
+  ]);
+}
+function buildChannelContentGuideInstruction(style, intent, contentType) {
+  const conditionalGuides = contentType === "x-thread" ? ["writing-guide/references/x-thread-hooks.md"] : [];
+  return buildGuideBundle([
+    "writing-guide/references/truthful-value-framing.md",
+    "writing-guide/references/target-length-guidance.md",
+    ...conditionalGuides,
+    styleToGuidePath(style),
+    intentToGuidePath(intent),
+    formatToGuidePath(contentType)
+  ]);
 }
 
 // src/llm/prompts/contentBrief.ts
@@ -1791,11 +1999,11 @@ var contentBriefSchema = {
 };
 function buildContentBriefMessages(idea, options) {
   const audienceSeed = options.targetAudienceHint?.trim() || "A general, non-specific audience.";
+  const hasSecondaryContentTypes = options.secondaryContentTypes.length > 0;
   const systemInstruction = [
     "You are a senior editorial strategist.",
     "Produce a shared content brief that can guide all requested content types in this run.",
-    buildWritingFrameworkInstruction(),
-    buildStyleDirective(options.style),
+    buildContentBriefGuideInstruction(options.intent, options.primaryContentType, options.secondaryContentTypes),
     buildRunContextDirective([options.primaryContentType, ...options.secondaryContentTypes]),
     "The brief must be specific, concrete, and directly usable by writers without extra clarification.",
     "This run has one explicit primary output and optional secondary outputs that should promote or incite interest in the primary while remaining independently valuable.",
@@ -1824,7 +2032,7 @@ function buildContentBriefMessages(idea, options) {
         "- voiceNotes: practical tone/voice constraints to keep outputs consistent.",
         `- primaryContentType: set to "${options.primaryContentType}" exactly.`,
         `- secondaryContentTypes: include these types exactly: ${options.secondaryContentTypes.join(", ") || "none"}.`,
-        "- secondaryContentStrategy: explicit guidance for making secondary outputs channel-native, self-contained, and enticing gateways into the primary content.",
+        hasSecondaryContentTypes ? "- secondaryContentStrategy: explicit guidance for making secondary outputs channel-native, self-contained, and enticing gateways into the primary content." : "- secondaryContentStrategy: set to an empty string because this run has no secondary outputs.",
         "",
         "Return JSON only with all required fields."
       ].join("\n")
@@ -1834,6 +2042,15 @@ function buildContentBriefMessages(idea, options) {
 
 // src/types/contentBriefSchema.ts
 import { z as z4 } from "zod";
+var secondaryTypeSentinelValues = /* @__PURE__ */ new Set([
+  "none",
+  "n/a",
+  "na",
+  "null",
+  "not applicable",
+  "no secondary content",
+  "no secondary outputs"
+]);
 var contentBriefSchema2 = z4.object({
   title: z4.string().min(8),
   description: z4.string().min(40),
@@ -1842,8 +2059,24 @@ var contentBriefSchema2 = z4.object({
   keyPoints: z4.array(z4.string().min(8)).min(3).max(6),
   voiceNotes: z4.string().min(20),
   primaryContentType: z4.string().min(2),
-  secondaryContentTypes: z4.array(z4.string().min(2)).max(10),
-  secondaryContentStrategy: z4.string().min(20)
+  secondaryContentTypes: z4.array(z4.string().min(2)).max(10).transform((values) => values.map((value2) => value2.trim()).filter((value2) => value2.length > 0).filter((value2) => !secondaryTypeSentinelValues.has(value2.toLowerCase()))),
+  secondaryContentStrategy: z4.string()
+}).superRefine((brief, ctx) => {
+  const hasSecondaryTargets = brief.secondaryContentTypes.length > 0;
+  if (!hasSecondaryTargets) {
+    return;
+  }
+  if (brief.secondaryContentStrategy.trim().length < 20) {
+    ctx.addIssue({
+      code: z4.ZodIssueCode.too_small,
+      minimum: 20,
+      inclusive: true,
+      origin: "string",
+      path: ["secondaryContentStrategy"],
+      type: "string",
+      message: "Too small: expected string to have >=20 characters"
+    });
+  }
 });
 
 // src/generation/planContentBrief.ts
@@ -1871,7 +2104,7 @@ async function planContentBrief({
     schemaName: "content_brief",
     schema: contentBriefSchema,
     messages: buildContentBriefMessages(idea, {
-      style: settings.style,
+      intent: settings.intent,
       targetAudienceHint,
       primaryContentType: settings.contentTargets.find((target) => target.role === "primary")?.contentType ?? "article",
       secondaryContentTypes: settings.contentTargets.filter((target) => target.role === "secondary").map((target) => target.contentType)
@@ -1916,13 +2149,19 @@ function deriveTitleFromIdea(idea) {
 }
 
 // src/llm/prompts/articlePlan.ts
-var ARTICLE_SECTION_COUNTS = {
-  small: { min: 2, max: 4, label: "2 to 4" },
-  medium: { min: 4, max: 7, label: "4 to 6" },
-  large: { min: 6, max: 10, label: "6 to 10" }
-};
-function buildArticlePlanJsonSchema(targetLength) {
-  const sectionCounts = ARTICLE_SECTION_COUNTS[targetLength] ?? ARTICLE_SECTION_COUNTS["medium"];
+function deriveArticleSectionCounts(targetLengthWords) {
+  const normalizedWords = Number.isFinite(targetLengthWords) && targetLengthWords > 0 ? targetLengthWords : 900;
+  const center = Math.max(2, Math.min(10, Math.round(normalizedWords / 220)));
+  const min = Math.max(2, center - 1);
+  const max = Math.min(10, center + 1);
+  return {
+    min,
+    max,
+    label: `${min} to ${max}`
+  };
+}
+function buildArticlePlanJsonSchema(targetLengthWords) {
+  const sectionCounts = deriveArticleSectionCounts(targetLengthWords);
   return {
     type: "object",
     additionalProperties: false,
@@ -1984,16 +2223,12 @@ function buildArticlePlanJsonSchema(targetLength) {
   };
 }
 function buildArticlePlanMessages(idea, options) {
-  const sectionCounts = ARTICLE_SECTION_COUNTS[options.targetLength] ?? ARTICLE_SECTION_COUNTS["medium"];
+  const sectionCounts = deriveArticleSectionCounts(options.targetLength);
   const systemInstruction = [
     "You are a senior editorial strategist. Produce a rigorous article plan for a polished long-form Markdown article.",
-    buildWritingFrameworkInstruction(),
-    buildStyleDirective(options.style),
+    buildArticlePlanGuideInstruction(options.intent, "article"),
     buildRunContextDirective(options.contentTypes),
     buildTargetLengthDirective("article", options.targetLength),
-    "Quality bar: produce expert-level structure with high information density, concrete mechanisms, and practical reader outcomes.",
-    "Choose an adaptive persuasion structure (AIDA, PAS, or BAB) based on audience need, search intent, and the job-to-be-done of the idea.",
-    "Avoid generic filler, empty wrap-up sentences, and vague claims that do not specify how or why.",
     "Return only the requested JSON."
   ].join(" ");
   return [
@@ -2011,7 +2246,7 @@ function buildArticlePlanMessages(idea, options) {
         "- The article should feel authoritative, practical, and clearly structured for scanning and deep reading.",
         "- Generate a memorable title and a sharp subtitle that promise a concrete benefit, mechanism, or outcome.",
         "- The slug must be lowercase kebab-case and publication-ready.",
-        "- The description should work as a concise meta description, align with the shared content brief, and avoid hype language.",
+        "- The description should work as a concise meta description and align with the shared content brief.",
         `- Plan ${sectionCounts.label} strong sections with distinct focus areas and logical progression (no repetitive section intent).`,
         "- Frame section titles to reflect likely search intent or practical reader questions when appropriate.",
         "- Each section description should name the mechanism, evidence type, or practical action that makes the section useful.",
@@ -2019,7 +2254,6 @@ function buildArticlePlanMessages(idea, options) {
         "- Include a cover image description and 2 to 3 inline image descriptions.",
         "- Image descriptions must be concrete and contextual, not generic stock-photo phrasing.",
         "- Inline images should be anchored after specific sections using 1-based indexes.",
-        "- Avoid AI giveaway phrasing, dramatic cliches, and generic conclusions that add no new information.",
         "",
         "Shared content brief context:",
         `- description: ${options.contentBrief.description}`,
@@ -2087,7 +2321,7 @@ async function planArticle({
     schemaName: "article_plan",
     schema: buildArticlePlanJsonSchema(settings.targetLength),
     messages: buildArticlePlanMessages(idea, {
-      style: settings.style,
+      intent: settings.intent,
       contentTypes: settings.contentTargets.map((target) => target.contentType),
       contentBrief,
       targetLength: settings.targetLength
@@ -2162,40 +2396,17 @@ function slugify(value2) {
 }
 
 // src/llm/prompts/channelContent.ts
-var CHANNEL_RULES = {
-  "blog-post": [
-    "Write a complete Markdown blog post with a clear title, short lead, scannable subheadings, and practical takeaways.",
-    "Favor concrete examples, compact paragraphs, and actionable guidance over theory."
-  ].join(" "),
-  "x-thread": [
-    "Write native X thread content with short lines, high signal, and a strong hook in the first line.",
-    'Return a numbered thread with one post per line prefixed like "1/7".',
-    "Each thread line must be self-contained but still advance the same core narrative."
-  ].join(" "),
-  "x-post": [
-    "Write native X content with short lines, high signal, and a strong hook in the first line.",
-    "Return one concise post only. Do not return numbered thread lines."
-  ].join(" "),
-  "reddit-post": [
-    "Write a Reddit-native post in plain, authentic voice with practical detail and no marketing gloss.",
-    "Use first-hand framing, candid constraints, and only minimal formatting that improves readability."
-  ].join(" "),
-  "linkedin-post": [
-    "Write a LinkedIn-native post for professional clarity and engagement.",
-    "Open with a strong two-line hook, use spaced short paragraphs, and end with one focused reflection or CTA."
-  ].join(" "),
-  newsletter: [
-    "Write a concise newsletter piece with a subject-line-quality opening and clear section flow.",
-    "Prioritize practical value density, strong transitions, and sustained reader momentum."
-  ].join(" "),
-  "landing-page-copy": [
-    "Write landing-page copy in Markdown with headline, value proposition, proof-oriented body blocks, objection handling, and clear CTA text.",
-    "Keep claims specific, credible, and measurable. Avoid hype language."
-  ].join(" "),
-  article: "Write a polished Markdown article."
-};
+function buildOutputShapeConstraint(contentType) {
+  if (contentType === "x-thread") {
+    return 'Return a numbered thread with one post per line prefixed like "1/7".';
+  }
+  if (contentType === "x-post") {
+    return "Return one concise post only. Do not return numbered thread lines.";
+  }
+  return "";
+}
 function buildSingleShotContentMessages(options) {
-  const channelRule = CHANNEL_RULES[options.contentType] ?? "Write channel-native Markdown content.";
+  const outputShapeConstraint = buildOutputShapeConstraint(options.contentType);
   const articleContext = options.articleReferenceMarkdown ? [
     "Reference primary context (use as anchor source, but adapt natively for the requested channel):",
     options.articleReferenceMarkdown
@@ -2213,10 +2424,9 @@ function buildSingleShotContentMessages(options) {
       content: [
         "You are a senior content strategist and copywriter.",
         `Write exactly one ${options.contentType} output.`,
-        buildWritingFrameworkInstruction(),
-        buildStyleDirective(options.style),
+        buildChannelContentGuideInstruction(options.style, options.intent, options.contentType),
         roleDirective,
-        channelRule
+        outputShapeConstraint
       ].join(" ")
     },
     {
@@ -2257,6 +2467,7 @@ async function writeSingleShotContent({
   role = "secondary",
   primaryContentType,
   style,
+  intent,
   outputIndex,
   outputCountForType,
   articleReferenceMarkdown,
@@ -2286,6 +2497,7 @@ async function writeSingleShotContent({
       role,
       primaryContentType,
       style,
+      intent,
       outputIndex,
       outputCountForType,
       contentBrief,
@@ -2333,13 +2545,12 @@ var OUTRO_PARAGRAPH_COUNTS = {
   medium: "2 to 3",
   large: "3 to 5"
 };
-function buildSystemInstruction(base, style, contentTypes, targetLength) {
+function buildSystemInstruction(base, style, intent, contentTypes, targetLengthWords) {
   return [
     base,
-    buildWritingFrameworkInstruction(),
-    buildStyleDirective(style),
+    buildArticleSectionGuideInstruction(style, intent, "article"),
     buildRunContextDirective(contentTypes),
-    buildTargetLengthDirective("article", targetLength)
+    buildTargetLengthDirective("article", targetLengthWords)
   ].join(" ");
 }
 function sharedPlanContext(plan) {
@@ -2363,14 +2574,16 @@ function sharedDraftContext(articleSoFar) {
     normalized
   ].join("\n");
 }
-function buildIntroMessages(plan, style, contentTypes, targetLength) {
+function buildIntroMessages(plan, style, intent, contentTypes, targetLengthWords, introTargetWords) {
   const baseSystemInstruction = buildSystemInstruction(
     "You write polished editorial prose for Markdown articles. Return only the prose body with no heading and no code fences.",
     style,
+    intent,
     contentTypes,
-    targetLength
+    targetLengthWords
   );
-  const paragraphCount = INTRO_PARAGRAPH_COUNTS[targetLength] ?? INTRO_PARAGRAPH_COUNTS["medium"];
+  const targetLengthAlias = resolveTargetLengthAlias(targetLengthWords);
+  const paragraphCount = INTRO_PARAGRAPH_COUNTS[targetLengthAlias] ?? INTRO_PARAGRAPH_COUNTS["medium"];
   return [
     {
       role: "system",
@@ -2384,20 +2597,23 @@ function buildIntroMessages(plan, style, contentTypes, targetLength) {
         `Write the article introduction using this brief: ${plan.introBrief}`,
         "Requirements:",
         `- ${paragraphCount} paragraphs.`,
+        `- Target length: about ${introTargetWords} words.`,
         "- Hook the reader quickly.",
         "- Set up the argument and tone for the rest of the article."
       ].join("\n")
     }
   ];
 }
-function buildSectionMessages(plan, section, articleSoFar, style, contentTypes, targetLength) {
+function buildSectionMessages(plan, section, articleSoFar, style, intent, contentTypes, targetLengthWords, sectionTargetWords) {
   const baseSystemInstruction = buildSystemInstruction(
     "You write in-depth Markdown article sections. Return only the prose body for the section, with no heading and no code fences.",
     style,
+    intent,
     contentTypes,
-    targetLength
+    targetLengthWords
   );
-  const paragraphCount = SECTION_PARAGRAPH_COUNTS[targetLength] ?? SECTION_PARAGRAPH_COUNTS["medium"];
+  const targetLengthAlias = resolveTargetLengthAlias(targetLengthWords);
+  const paragraphCount = SECTION_PARAGRAPH_COUNTS[targetLengthAlias] ?? SECTION_PARAGRAPH_COUNTS["medium"];
   return [
     {
       role: "system",
@@ -2414,6 +2630,7 @@ function buildSectionMessages(plan, section, articleSoFar, style, contentTypes,
         `Section focus: ${section.description}`,
         "Requirements:",
         `- ${paragraphCount} paragraphs.`,
+        `- Target length: about ${sectionTargetWords} words.`,
         "- Be concrete and specific.",
         "- Continue naturally from the article draft so far without rehashing prior sections.",
         "- Use short Markdown lists only if they materially improve clarity."
@@ -2421,14 +2638,16 @@ function buildSectionMessages(plan, section, articleSoFar, style, contentTypes,
     }
   ];
 }
-function buildOutroMessages(plan, style, contentTypes, targetLength) {
+function buildOutroMessages(plan, style, intent, contentTypes, targetLengthWords, outroTargetWords) {
   const baseSystemInstruction = buildSystemInstruction(
     "You write polished editorial conclusions for Markdown articles. Return only the prose body with no heading and no code fences.",
     style,
+    intent,
     contentTypes,
-    targetLength
+    targetLengthWords
   );
-  const paragraphCount = OUTRO_PARAGRAPH_COUNTS[targetLength] ?? OUTRO_PARAGRAPH_COUNTS["medium"];
+  const targetLengthAlias = resolveTargetLengthAlias(targetLengthWords);
+  const paragraphCount = OUTRO_PARAGRAPH_COUNTS[targetLengthAlias] ?? OUTRO_PARAGRAPH_COUNTS["medium"];
   return [
     {
       role: "system",
@@ -2442,6 +2661,7 @@ function buildOutroMessages(plan, style, contentTypes, targetLength) {
         `Write the article conclusion using this brief: ${plan.outroBrief}`,
         "Requirements:",
         `- ${paragraphCount} paragraphs.`,
+        `- Target length: about ${outroTargetWords} words.`,
         "- Synthesize the main argument.",
         "- End with a strong, thoughtful closing line."
       ].join("\n")
@@ -2459,13 +2679,16 @@ async function writeArticleSections({
   onLlmMetrics,
   onInteraction
 }) {
+  const wordBudgets = allocateWordBudgets(settings.targetLength, plan.sections.length);
   onSectionStart?.("Writing introduction");
   const intro = dryRun || !openRouter ? dryRunIntro(plan) : await openRouter.requestText({
     messages: buildIntroMessages(
       plan,
       settings.style,
+      settings.intent,
       settings.contentTargets.map((target) => target.contentType),
-      settings.targetLength
+      settings.targetLength,
+      wordBudgets.intro
     ),
     settings,
     interactionContext: {
@@ -2487,8 +2710,10 @@ async function writeArticleSections({
         section,
         buildArticleSoFarContext(intro, sections),
         settings.style,
+        settings.intent,
         settings.contentTargets.map((target) => target.contentType),
-        settings.targetLength
+        settings.targetLength,
+        wordBudgets.sections[index] ?? wordBudgets.sections[wordBudgets.sections.length - 1] ?? 150
       ),
       settings,
       interactionContext: {
@@ -2510,8 +2735,10 @@ async function writeArticleSections({
     messages: buildOutroMessages(
       plan,
       settings.style,
+      settings.intent,
       settings.contentTargets.map((target) => target.contentType),
-      settings.targetLength
+      settings.targetLength,
+      wordBudgets.outro
     ),
     settings,
     interactionContext: {
@@ -2547,6 +2774,23 @@ function dryRunOutro(plan) {
     "What matters is a workflow that can repeatedly transform a promising idea into a piece that is clear, useful, and worth reading."
   ].join("\n\n");
 }
+function allocateWordBudgets(totalTargetWords, sectionCount) {
+  const normalizedTotal = Number.isFinite(totalTargetWords) && totalTargetWords > 0 ? Math.round(totalTargetWords) : 900;
+  const normalizedSectionCount = Math.max(1, sectionCount);
+  const intro = Math.max(80, Math.round(normalizedTotal * 0.15));
+  const outro = Math.max(80, Math.round(normalizedTotal * 0.1));
+  const remainingForSections = Math.max(normalizedSectionCount * 120, normalizedTotal - intro - outro);
+  const baseSectionWords = Math.floor(remainingForSections / normalizedSectionCount);
+  let remainder = remainingForSections - baseSectionWords * normalizedSectionCount;
+  const sections = Array.from({ length: normalizedSectionCount }, () => {
+    const next = baseSectionWords + (remainder > 0 ? 1 : 0);
+    if (remainder > 0) {
+      remainder -= 1;
+    }
+    return Math.max(120, next);
+  });
+  return { intro, sections, outro };
+}
 function buildArticleSoFarContext(intro, sections) {
   const parts = ["## Introduction", intro.trim()];
   for (const section of sections) {
@@ -2594,6 +2838,14 @@ var ReplicateClient = class {
           const backoff = backoffMs(attempt);
           retries += 1;
           retryBackoffMs += backoff;
+          options.onRetry?.({
+            attempts,
+            retries,
+            retryBackoffMs,
+            backoffMs: backoff,
+            errorMessage: lastError.message,
+            modelId: model
+          });
           await wait(backoff);
           continue;
         }
@@ -2617,7 +2869,7 @@ function wait(ms) {
 
 // src/images/renderImages.ts
 import { writeFile as writeFile4 } from "fs/promises";
-import path5 from "path";
+import path6 from "path";
 
 // src/llm/prompts/imagePrompt.ts
 var imagePromptSchema = {
@@ -3296,14 +3548,15 @@ async function renderExpandedImages({
   dryRun,
   onProgress,
   onRenderComplete,
-  onInteraction
+  onInteraction,
+  onRetry
 }) {
   const renderedImages = [];
   for (let index = 0; index < prompts.length; index += 1) {
     const prompt = prompts[index];
     onProgress?.(`Rendering image ${index + 1}/${prompts.length} with ${settings.t2i.modelId}`);
     const fileName = `${prompt.kind === "cover" ? "cover" : `inline-${prompt.anchorAfterSection}`}-${index + 1}.${resolveOutputFormat(settings)}`;
-    const outputPath = path5.join(assetDir, fileName);
+    const outputPath = path6.join(assetDir, fileName);
     if (dryRun || !replicate) {
       const dryRunStartMs = Date.now();
       await writeFile4(outputPath, `Placeholder image for: ${prompt.prompt}
@@ -3361,6 +3614,14 @@ async function renderExpandedImages({
           runAttempts = metrics.attempts;
           runRetries = metrics.retries;
           runRetryBackoffMs = metrics.retryBackoffMs;
+        },
+        onRetry(event) {
+          onRetry?.({
+            imageId: prompt.id,
+            kind: prompt.kind,
+            retries: event.retries,
+            errorMessage: event.errorMessage
+          });
         }
       });
       const bytes = await normalizeReplicateOutput(output);
@@ -4067,7 +4328,7 @@ ${body.join("\n").trim()}
 
 // src/pipeline/sessionStore.ts
 import { mkdir as mkdir4, readFile as readFile5, rm as rm2, writeFile as writeFile5 } from "fs/promises";
-import path6 from "path";
+import path7 from "path";
 import { z as z6 } from "zod";
 var STAGE_IDS = ["shared-brief", "planning", "sections", "image-prompts", "images", "output", "links"];
 var generatedArticleSectionSchema = z6.object({
@@ -4143,10 +4404,10 @@ var writeSessionStateSchema = z6.object({
   artifact: pipelineArtifactSummarySchema.nullable()
 });
 function resolveWriteRoot(workingDir) {
-  return path6.join(workingDir, ".ideon", "write");
+  return path7.join(workingDir, ".ideon", "write");
 }
 function resolveStateFilePath(workingDir) {
-  return path6.join(resolveWriteRoot(workingDir), "state.json");
+  return path7.join(resolveWriteRoot(workingDir), "state.json");
 }
 async function startFreshWriteSession(seed, workingDir = process.cwd()) {
   const writeRoot = resolveWriteRoot(workingDir);
@@ -4196,7 +4457,7 @@ async function saveWriteSession(state, workingDir = process.cwd()) {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
   const statePath = resolveStateFilePath(workingDir);
-  await mkdir4(path6.dirname(statePath), { recursive: true });
+  await mkdir4(path7.dirname(statePath), { recursive: true });
   await writeFile5(statePath, `${JSON.stringify(next, null, 2)}
 `, "utf8");
   return next;
@@ -4289,12 +4550,15 @@ async function runPipelineShell(input, options = {}) {
   const stages = createInitialStages({ isArticlePrimary });
   options.onUpdate?.(cloneStages(stages));
   const dryRun = options.dryRun ?? false;
-  const shouldEnrichLinks = options.enrichLinks ?? true;
+  const shouldEnrichLinks = options.enrichLinks ?? false;
   const runMode = options.runMode ?? "fresh";
   const workingDir = options.workingDir ?? process.cwd();
   const outputPaths = resolveOutputPaths(input.config.settings, workingDir);
   const hasArticlePrimary = isArticlePrimary;
   const stageTracking = /* @__PURE__ */ new Map();
+  const stageRetryState = /* @__PURE__ */ new Map();
+  const llmOperationRetryState = /* @__PURE__ */ new Map();
+  const imageOperationRetryState = /* @__PURE__ */ new Map();
   stageTracking.set("shared-brief", {
     startedAtMs: runStartedAtMs,
     endedAtMs: null,
@@ -4309,6 +4573,41 @@ async function runPipelineShell(input, options = {}) {
   const llmInteractions = [];
   const t2iInteractions = [];
   let writeSession;
+  const applyRetryUpdate = (stageId, retryIncrement, errorMessage) => {
+    if (retryIncrement <= 0) {
+      return;
+    }
+    const stageIndex = stages.findIndex((stage) => stage.id === stageId);
+    if (stageIndex < 0) {
+      return;
+    }
+    const existing = stageRetryState.get(stageId) ?? { retries: 0, lastError: null };
+    const next = {
+      retries: existing.retries + retryIncrement,
+      lastError: errorMessage && errorMessage.trim().length > 0 ? errorMessage : existing.lastError
+    };
+    stageRetryState.set(stageId, next);
+    stages[stageIndex] = {
+      ...stages[stageIndex],
+      retryCount: next.retries,
+      lastRetryError: next.lastError ?? void 0
+    };
+    options.onUpdate?.(cloneStages(stages));
+  };
+  const onLlmInteraction = (interaction) => {
+    llmInteractions.push(interaction);
+    const stageId = asWriteStageId(interaction.stageId);
+    if (!stageId) {
+      return;
+    }
+    const previousRetries = llmOperationRetryState.get(interaction.operationId) ?? 0;
+    if (interaction.retries <= previousRetries) {
+      return;
+    }
+    const retryIncrement = interaction.retries - previousRetries;
+    llmOperationRetryState.set(interaction.operationId, interaction.retries);
+    applyRetryUpdate(stageId, retryIncrement, interaction.errorMessage);
+  };
   if (runMode === "fresh") {
     writeSession = await startFreshWriteSession(
       {
@@ -4360,7 +4659,7 @@ async function runPipelineShell(input, options = {}) {
         openRouter,
         dryRun,
         onInteraction(interaction) {
-          llmInteractions.push(interaction);
+          onLlmInteraction(interaction);
         },
         onLlmMetrics(metrics) {
           recordLlmMetrics(stageTracking, "shared-brief", metrics);
@@ -4414,7 +4713,7 @@ async function runPipelineShell(input, options = {}) {
           openRouter,
           dryRun,
           onInteraction(interaction) {
-            llmInteractions.push(interaction);
+            onLlmInteraction(interaction);
           },
           onLlmMetrics(metrics) {
             recordLlmMetrics(stageTracking, "planning", metrics);
@@ -4477,7 +4776,7 @@ async function runPipelineShell(input, options = {}) {
           openRouter,
           dryRun,
           onInteraction(interaction) {
-            llmInteractions.push(interaction);
+            onLlmInteraction(interaction);
           },
           onLlmMetrics(phase, metrics, sectionIndex) {
             recordLlmMetrics(stageTracking, "sections", metrics);
@@ -4590,7 +4889,7 @@ async function runPipelineShell(input, options = {}) {
           openRouter,
           dryRun,
           onInteraction(interaction) {
-            llmInteractions.push(interaction);
+            onLlmInteraction(interaction);
           },
           onPromptComplete(metrics) {
             imagePromptCalls.push({
@@ -4676,6 +4975,7 @@ async function runPipelineShell(input, options = {}) {
         role: "primary",
         primaryContentType: primaryTarget.contentType,
         style: input.config.settings.style,
+        intent: input.config.settings.intent,
         outputIndex: 1,
         outputCountForType: 1,
         articleReferenceMarkdown: void 0,
@@ -4684,7 +4984,7 @@ async function runPipelineShell(input, options = {}) {
         openRouter,
         dryRun,
         onInteraction(interaction) {
-          llmInteractions.push(interaction);
+          onLlmInteraction(interaction);
         },
         onLlmMetrics(metrics) {
           recordLlmMetrics(stageTracking, "sections", metrics);
@@ -4728,12 +5028,12 @@ async function runPipelineShell(input, options = {}) {
       options.onUpdate?.(cloneStages(stages));
     }
     const baseSlug = plan?.slug ?? slugifyIdea(input.idea);
-    const generationDir = path7.join(
+    const generationDir = path8.join(
       writeSession.outputPaths.markdownOutputDir,
       buildGenerationDirectoryName(baseSlug)
     );
     await mkdir5(generationDir, { recursive: true });
-    const jobDefinitionPath = path7.join(generationDir, "job.json");
+    const jobDefinitionPath = path8.join(generationDir, "job.json");
     await writeJsonFile(
       jobDefinitionPath,
       buildRunJobDefinition({
@@ -4746,7 +5046,7 @@ async function runPipelineShell(input, options = {}) {
       })
     );
     const primaryFilePrefix = toFilePrefix(primaryTarget.contentType);
-    const primaryMarkdownPath = path7.join(generationDir, `${primaryFilePrefix}-1.md`);
+    const primaryMarkdownPath = path8.join(generationDir, `${primaryFilePrefix}-1.md`);
     const sharedAssetDir = generationDir;
     if (hasArticlePrimary) {
       if (imageArtifacts) {
@@ -4788,6 +5088,15 @@ async function runPipelineShell(input, options = {}) {
             recordStageCost(stageTracking, "images", metrics.costUsd, metrics.costSource);
             addStageRetries(stageTracking, "images", metrics.retries);
           },
+          onRetry(event) {
+            const operationKey = `images:${event.imageId}`;
+            const previousRetries = imageOperationRetryState.get(operationKey) ?? 0;
+            if (event.retries <= previousRetries) {
+              return;
+            }
+            imageOperationRetryState.set(operationKey, event.retries);
+            applyRetryUpdate("images", event.retries - previousRetries, event.errorMessage);
+          },
           onProgress(detail) {
             stages[4] = {
               ...stages[4],
@@ -4872,6 +5181,15 @@ async function runPipelineShell(input, options = {}) {
             recordStageCost(stageTracking, "images", metrics.costUsd, metrics.costSource);
             addStageRetries(stageTracking, "images", metrics.retries);
           },
+          onRetry(event) {
+            const operationKey = `images:${event.imageId}`;
+            const previousRetries = imageOperationRetryState.get(operationKey) ?? 0;
+            if (event.retries <= previousRetries) {
+              return;
+            }
+            imageOperationRetryState.set(operationKey, event.retries);
+            applyRetryUpdate("images", event.retries - previousRetries, event.errorMessage);
+          },
           onProgress(detail) {
             stages[4] = {
               ...stages[4],
@@ -4969,12 +5287,13 @@ async function runPipelineShell(input, options = {}) {
         })
       };
       options.onUpdate?.(cloneStages(stages));
-      const markdownPath = path7.join(generationDir, `${output.filePrefix}-${output.index}.md`);
+      const markdownPath = path8.join(generationDir, `${output.filePrefix}-${output.index}.md`);
       try {
         const content = await writeSingleShotContent({
           idea: input.idea,
           contentType: output.contentType,
           style: input.config.settings.style,
+          intent: input.config.settings.intent,
           outputIndex: output.index,
           outputCountForType: output.outputCountForType,
           articleReferenceMarkdown: primaryMarkdownTemplate ?? void 0,
@@ -4985,7 +5304,7 @@ async function runPipelineShell(input, options = {}) {
           role: "secondary",
           primaryContentType: primaryTarget.contentType,
           onInteraction(interaction) {
-            llmInteractions.push(interaction);
+            onLlmInteraction(interaction);
           },
           onLlmMetrics(metrics) {
             recordLlmMetrics(stageTracking, "output", metrics);
@@ -5030,7 +5349,7 @@ async function runPipelineShell(input, options = {}) {
               ...item,
               status: "succeeded",
               detail: "Saved markdown output.",
-              summary: path7.basename(markdownPath),
+              summary: path8.basename(markdownPath),
               analytics: {
                 durationMs: itemDurationMs,
                 costUsd: knownItemCost.usd,
@@ -5086,7 +5405,7 @@ async function runPipelineShell(input, options = {}) {
       stages[6] = {
         ...stages[6],
         status: "succeeded",
-        detail: "Skipped link enrichment (--no-enrich-links).",
+        detail: "Skipped link enrichment (enable with --enrich-links).",
         summary: "Link enrichment disabled for this run",
         stageAnalytics: snapshotStageAnalytics(stageTracking, "links")
       };
@@ -5139,7 +5458,7 @@ async function runPipelineShell(input, options = {}) {
         settings: input.config.settings,
         dryRun,
         onInteraction(interaction) {
-          llmInteractions.push(interaction);
+          onLlmInteraction(interaction);
         },
         onLlmMetrics(fileId, metrics) {
           recordLlmMetrics(stageTracking, "links", metrics);
@@ -5238,8 +5557,8 @@ async function runPipelineShell(input, options = {}) {
       llmCalls: llmInteractions,
       t2iCalls: t2iInteractions
     };
-    const analyticsPath = path7.join(generationDir, "generation.analytics.json");
-    const interactionsPath = path7.join(generationDir, "model.interactions.json");
+    const analyticsPath = path8.join(generationDir, "generation.analytics.json");
+    const interactionsPath = path8.join(generationDir, "model.interactions.json");
     await writeJsonFile(analyticsPath, analytics);
     await writeJsonFile(interactionsPath, interactions);
     const primaryMarkdownPathForArtifact = markdownPaths[0] ?? primaryMarkdownPath;
@@ -5931,6 +6250,229 @@ async function runMcpServeCommand() {
   await startIdeonMcpServer();
 }
 
+// src/cli/commands/links.ts
+import { readFile as readFile6, stat as stat3 } from "fs/promises";
+import path9 from "path";
+async function runLinksCommand(options, dependencies = {}) {
+  const slug = normalizeSlug2(options.slug);
+  const mode = normalizeMode(options.mode);
+  const cwd2 = dependencies.cwd ?? process.cwd();
+  const log = dependencies.log ?? ((message) => console.log(message));
+  const resolved = await resolveRunInput({
+    idea: `Enrich links for ${slug}`
+  });
+  const markdownPath = await resolveMarkdownPathForSlug2(resolved.config.settings, slug, cwd2);
+  const frontmatter = await readFrontmatter(markdownPath);
+  const fileId = path9.parse(markdownPath).name;
+  const articleTitle = frontmatter.title ?? toTitleFromSlug(slug);
+  const articleDescription = frontmatter.description ?? "";
+  const openRouterApiKey = resolved.config.secrets.openRouterApiKey;
+  if (!openRouterApiKey) {
+    throw new ReportedError(
+      "Missing OpenRouter API key. Run `ideon settings` to configure credentials or set IDEON_OPENROUTER_API_KEY."
+    );
+  }
+  const openRouter = new OpenRouterClient(openRouterApiKey);
+  const linksResult = await enrichLinks({
+    markdownFiles: [{ markdownPath, fileId, contentType: "article" }],
+    articleTitle,
+    articleDescription,
+    openRouter,
+    settings: resolved.config.settings,
+    dryRun: false,
+    onItemProgress(event) {
+      logProgress(event, log);
+    }
+  });
+  const generatedLinks = linksResult[0]?.links ?? [];
+  const linksPath = resolveLinksPath(markdownPath);
+  const existing = await readExistingLinks(linksPath);
+  const mergedLinks = mode === "append" ? mergeLinks(existing?.links ?? [], generatedLinks) : generatedLinks;
+  const appendedCount = Math.max(0, mergedLinks.length - (existing?.links.length ?? 0));
+  await writeLinksFile(markdownPath, {
+    version: 1,
+    links: mergedLinks
+  });
+  const relativeMarkdownPath = formatRelativePath2(cwd2, markdownPath);
+  const relativeLinksPath = formatRelativePath2(cwd2, linksPath);
+  if (mode === "fresh") {
+    const replaced = existing ? "Replaced existing links." : "Created links sidecar.";
+    log(`Enriched links for "${slug}".`);
+    log(`${replaced} Saved ${generatedLinks.length} links to ${relativeLinksPath} (${relativeMarkdownPath}).`);
+    return;
+  }
+  const baseCount = existing?.links.length ?? 0;
+  const verb = existing ? "Appended and deduplicated links." : "Created links sidecar.";
+  log(`Enriched links for "${slug}".`);
+  log(`${verb} Base ${baseCount}, added ${appendedCount}, total ${mergedLinks.length} in ${relativeLinksPath} (${relativeMarkdownPath}).`);
+}
+function normalizeMode(rawMode) {
+  const normalized = rawMode.trim().toLowerCase();
+  if (normalized === "fresh" || normalized === "append") {
+    return normalized;
+  }
+  throw new ReportedError(`Unsupported --mode value "${rawMode}". Use "fresh" or "append".`);
+}
+function normalizeSlug2(rawSlug) {
+  const slug = rawSlug.trim();
+  if (!slug) {
+    throw new ReportedError("Slug cannot be empty. Pass the generated article slug, for example `ideon links my-article-slug`.");
+  }
+  if (slug.toLowerCase().endsWith(".md")) {
+    throw new ReportedError(`Expected a slug, not a markdown filename: ${slug}. Pass the slug without .md.`);
+  }
+  if (slug === "." || slug === ".." || /[/\\]/.test(slug)) {
+    throw new ReportedError(`Invalid slug "${slug}". Pass the article slug only, without any path separators.`);
+  }
+  return slug;
+}
+async function resolveMarkdownPathForSlug2(settings, slug, cwd2) {
+  const outputPaths = resolveOutputPaths(settings, cwd2);
+  const directPath = path9.join(outputPaths.markdownOutputDir, `${slug}.md`);
+  if (await isReadableFile(directPath)) {
+    return directPath;
+  }
+  const markdownFiles = await listMarkdownFilesRecursively(outputPaths.markdownOutputDir);
+  const matches = [];
+  for (const candidate of markdownFiles) {
+    if (path9.basename(candidate) === `${slug}.md`) {
+      matches.push(candidate);
+      continue;
+    }
+    const frontmatter = await readFrontmatter(candidate);
+    if (frontmatter.slug === slug) {
+      matches.push(candidate);
+    }
+  }
+  if (matches.length === 0) {
+    throw new ReportedError(
+      `Could not find article "${slug}". Expected a markdown file in ${outputPaths.markdownOutputDir} with frontmatter slug "${slug}".`
+    );
+  }
+  return newestPath(matches);
+}
+async function newestPath(paths) {
+  let latestPath = paths[0];
+  let latestMtime = 0;
+  for (const candidate of paths) {
+    const candidateStat = await stat3(candidate);
+    if (candidateStat.mtimeMs >= latestMtime) {
+      latestMtime = candidateStat.mtimeMs;
+      latestPath = candidate;
+    }
+  }
+  return latestPath;
+}
+async function readFrontmatter(markdownPath) {
+  const markdown = await readFile6(markdownPath, "utf8");
+  return parseFrontmatter(markdown);
+}
+function parseFrontmatter(markdown) {
+  if (!markdown.startsWith("---\n")) {
+    return { slug: null, title: null, description: null };
+  }
+  const frontmatterEnd = markdown.indexOf("\n---\n", 4);
+  if (frontmatterEnd < 0) {
+    return { slug: null, title: null, description: null };
+  }
+  const block = markdown.slice(4, frontmatterEnd);
+  return {
+    slug: parseFrontmatterValue(block, "slug"),
+    title: parseFrontmatterValue(block, "title"),
+    description: parseFrontmatterValue(block, "description")
+  };
+}
+function parseFrontmatterValue(block, key) {
+  const pattern = new RegExp(`^${key}:\\s*(.+)$`, "m");
+  const match = block.match(pattern);
+  if (!match || !match[1]) {
+    return null;
+  }
+  const rawValue = match[1].trim();
+  if (!rawValue) {
+    return null;
+  }
+  if (rawValue.startsWith('"') && rawValue.endsWith('"') || rawValue.startsWith("'") && rawValue.endsWith("'")) {
+    return rawValue.slice(1, -1);
+  }
+  return rawValue;
+}
+function toTitleFromSlug(slug) {
+  return slug.split("-").filter((part) => part.length > 0).map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`).join(" ");
+}
+async function isReadableFile(filePath) {
+  try {
+    const fileStat = await stat3(filePath);
+    return fileStat.isFile();
+  } catch {
+    return false;
+  }
+}
+async function readExistingLinks(linksPath) {
+  try {
+    const raw = await readFile6(linksPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const links = Array.isArray(parsed.links) ? parsed.links.filter((entry) => isValidLinkEntry(entry)).map((entry) => ({
+      expression: entry.expression.trim(),
+      url: entry.url.trim(),
+      title: typeof entry.title === "string" ? entry.title : null
+    })) : null;
+    if (!links) {
+      throw new ReportedError(`Invalid links sidecar format at ${linksPath}. Expected { version, links[] }.`);
+    }
+    return {
+      version: typeof parsed.version === "number" ? parsed.version : 1,
+      links
+    };
+  } catch (error) {
+    if (readErrorCode2(error) === "ENOENT") {
+      return null;
+    }
+    if (error instanceof ReportedError) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : "Unknown links sidecar read error.";
+    throw new ReportedError(`Failed to read existing links from ${linksPath}: ${message}`);
+  }
+}
+function mergeLinks(existingLinks, generatedLinks) {
+  const merged = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of [...existingLinks, ...generatedLinks]) {
+    const key = `${entry.expression.trim().toLowerCase()}::${entry.url.trim().toLowerCase()}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    merged.push(entry);
+  }
+  return merged;
+}
+function isValidLinkEntry(value2) {
+  if (typeof value2 !== "object" || value2 === null) {
+    return false;
+  }
+  const record = value2;
+  return typeof record.expression === "string" && typeof record.url === "string" && (typeof record.title === "string" || record.title === null || record.title === void 0);
+}
+function readErrorCode2(error) {
+  if (typeof error !== "object" || error === null || !("code" in error)) {
+    return null;
+  }
+  const code = error.code;
+  return typeof code === "string" ? code : null;
+}
+function formatRelativePath2(cwd2, targetPath) {
+  const relativePath = path9.relative(cwd2, targetPath);
+  return relativePath.length > 0 ? relativePath : targetPath;
+}
+function logProgress(event, log) {
+  if (event.phase === "resolving-expression" || event.phase === "selecting-expressions") {
+    return;
+  }
+  log(event.detail);
+}
+
 // src/cli/commands/settings.tsx
 import { render } from "ink";
 
@@ -6303,12 +6845,12 @@ async function openSettings() {
 }
 
 // src/cli/commands/serve.ts
-import path10 from "path";
+import path12 from "path";
 import { spawn } from "child_process";
 
 // src/server/previewHelpers.ts
-import { readdir, stat as stat3, readFile as readFile6 } from "fs/promises";
-import path8 from "path";
+import { readdir, stat as stat4, readFile as readFile7 } from "fs/promises";
+import path10 from "path";
 var DEFAULT_PORT = 4173;
 var CONTENT_TYPE_ORDER = ["article", "blog-post", "x-thread", "x-post", "linkedin-post", "reddit-post", "newsletter", "landing-page-copy"];
 var FILE_PREFIX_TO_CONTENT_TYPE = {
@@ -6368,8 +6910,8 @@ function extractHeadingTitle(markdown) {
 }
 async function resolveMarkdownPath(markdownPathArg, markdownOutputDir, cwd2) {
   if (markdownPathArg) {
-    const resolved = path8.isAbsolute(markdownPathArg) ? markdownPathArg : path8.resolve(cwd2, markdownPathArg);
-    if (path8.extname(resolved).toLowerCase() !== ".md") {
+    const resolved = path10.isAbsolute(markdownPathArg) ? markdownPathArg : path10.resolve(cwd2, markdownPathArg);
+    if (path10.extname(resolved).toLowerCase() !== ".md") {
       throw new Error(`Expected a markdown file (.md), received: ${resolved}`);
     }
     await assertFileExists(resolved, "Could not find markdown file");
@@ -6387,7 +6929,7 @@ async function resolveLatestMarkdown(markdownOutputDir) {
   let latestPath = markdownCandidates[0];
   let latestMtime = 0;
   for (const candidate of markdownCandidates) {
-    const fileStat = await stat3(candidate);
+    const fileStat = await stat4(candidate);
     if (fileStat.mtimeMs >= latestMtime) {
       latestMtime = fileStat.mtimeMs;
       latestPath = candidate;
@@ -6397,7 +6939,7 @@ async function resolveLatestMarkdown(markdownOutputDir) {
 }
 async function assertFileExists(filePath, errorPrefix) {
   try {
-    const fileStat = await stat3(filePath);
+    const fileStat = await stat4(filePath);
     if (!fileStat.isFile()) {
       throw new Error(`${errorPrefix}: ${filePath}`);
     }
@@ -6411,9 +6953,9 @@ function extractCoverImageUrl(markdown) {
   return match?.[1] ?? null;
 }
 async function extractArticleMetadata(markdownPath) {
-  const markdown = await readFile6(markdownPath, "utf8");
-  const fileStat = await stat3(markdownPath);
-  const slug = extractFrontmatterSlug(markdown) ?? path8.basename(markdownPath, ".md");
+  const markdown = await readFile7(markdownPath, "utf8");
+  const fileStat = await stat4(markdownPath);
+  const slug = extractFrontmatterSlug(markdown) ?? path10.basename(markdownPath, ".md");
   const title = extractHeadingTitle(stripFrontmatter2(markdown)) ?? slug;
   const body = stripFrontmatter2(markdown);
   const previewSnippet = body.replace(/[#\[\]()!\-*_`]/g, "").trim().substring(0, 150);
@@ -6478,16 +7020,16 @@ async function listAllGenerations(markdownOutputDir) {
   return generations;
 }
 function deriveGenerationId(markdownPath, markdownOutputDir) {
-  const relative = path8.relative(markdownOutputDir, markdownPath);
-  const normalized = relative.split(path8.sep).join("/");
+  const relative = path10.relative(markdownOutputDir, markdownPath);
+  const normalized = relative.split(path10.sep).join("/");
   if (!normalized || normalized.startsWith("../")) {
-    return path8.basename(markdownPath, ".md");
+    return path10.basename(markdownPath, ".md");
   }
   const segments = normalized.split("/").filter(Boolean);
   if (segments.length <= 1) {
-    return path8.basename(markdownPath, ".md");
+    return path10.basename(markdownPath, ".md");
   }
-  return segments[0] ?? path8.basename(markdownPath, ".md");
+  return segments[0] ?? path10.basename(markdownPath, ".md");
 }
 async function findMarkdownFiles(markdownOutputDir) {
   const files = [];
@@ -6504,7 +7046,7 @@ async function findMarkdownFiles(markdownOutputDir) {
       continue;
     }
     for (const entry of entries) {
-      const fullPath = path8.join(current, entry.name);
+      const fullPath = path10.join(current, entry.name);
       if (entry.isDirectory()) {
         stack.push(fullPath);
         continue;
@@ -6518,7 +7060,7 @@ async function findMarkdownFiles(markdownOutputDir) {
 }
 function deriveOutputIdentity(markdownPath, markdownOutputDir) {
   const generationId = deriveGenerationId(markdownPath, markdownOutputDir);
-  const fileBase = path8.basename(markdownPath, ".md");
+  const fileBase = path10.basename(markdownPath, ".md");
   const parsed = fileBase.match(/^([a-z0-9-]+)-(\d+)$/i);
   if (!parsed || !parsed[1] || !parsed[2]) {
     return {
@@ -6554,13 +7096,13 @@ function toContentTypeLabel(contentType) {
 }
 async function resolvePrimaryContentType(outputs) {
   const fallback = outputs.find((output) => output.contentType === "article")?.contentType ?? outputs[0]?.contentType ?? "article";
-  const generationDir = path8.dirname(outputs[0]?.sourcePath ?? "");
+  const generationDir = path10.dirname(outputs[0]?.sourcePath ?? "");
   if (!generationDir) {
     return fallback;
   }
-  const jobPath = path8.join(generationDir, "job.json");
+  const jobPath = path10.join(generationDir, "job.json");
   try {
-    const raw = await readFile6(jobPath, "utf8");
+    const raw = await readFile7(jobPath, "utf8");
     const parsed = JSON.parse(raw);
     const targets = Array.isArray(parsed.contentTargets) ? parsed.contentTargets : Array.isArray(parsed.settings?.contentTargets) ? parsed.settings.contentTargets : [];
     const primary = targets.find((target) => target?.role === "primary" && typeof target.contentType === "string");
@@ -6576,9 +7118,9 @@ async function resolvePrimaryContentType(outputs) {
 // src/server/previewServer.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
-import { readFile as readFile7, stat as stat4 } from "fs/promises";
+import { readFile as readFile8, stat as stat5 } from "fs/promises";
 import { watch as fsWatch } from "fs";
-import path9 from "path";
+import path11 from "path";
 import { fileURLToPath } from "url";
 import express from "express";
 import { marked } from "marked";
@@ -6731,7 +7273,7 @@ async function startPreviewServer(options) {
         if (options.watch) {
           let html2;
           try {
-            html2 = await readFile7(path9.join(previewClientDir, "index.html"), "utf8");
+            html2 = await readFile8(path11.join(previewClientDir, "index.html"), "utf8");
           } catch {
             res.status(200).type("html").send(
               `<!doctype html><html><head><meta charset="utf-8"><title>Rebuilding\u2026</title><style>body{margin:0;display:flex;align-items:center;justify-content:center;height:100vh;font-family:sans-serif;background:#101820;color:#e0eaf0}p{font-size:15px;opacity:.7}</style></head><body><p>Rebuilding\u2026</p><script>const s=new EventSource('/api/__reload');s.onmessage=function(){location.reload()};</script></body></html>`
@@ -6742,7 +7284,7 @@ async function startPreviewServer(options) {
           const injected = html2.replace("</body>", `${reloadScript}</body>`);
           res.status(200).type("html").send(injected);
         } else {
-          res.status(200).sendFile(path9.join(previewClientDir, "index.html"));
+          res.status(200).sendFile(path11.join(previewClientDir, "index.html"));
         }
         return;
       }
@@ -6795,7 +7337,7 @@ async function getArticleContent(generationId, markdownOutputDir) {
     generation.outputs.map(async (output) => {
       let markdown = "";
       try {
-        markdown = await readFile7(output.sourcePath, "utf8");
+        markdown = await readFile8(output.sourcePath, "utf8");
       } catch (error) {
         if (isMissingFileError(error)) {
           throw new MissingArticleError(`Generation "${generationId}" no longer exists.`);
@@ -6813,7 +7355,7 @@ async function getArticleContent(generationId, markdownOutputDir) {
       };
     })
   );
-  const generationDir = path9.dirname(generation.outputs[0]?.sourcePath ?? "");
+  const generationDir = path11.dirname(generation.outputs[0]?.sourcePath ?? "");
   const interactions = generationDir ? await loadSavedInteractions(generationDir) : { llmCalls: [], t2iCalls: [] };
   const analyticsSummary = generationDir ? await loadSavedAnalyticsSummary(generationDir) : null;
   return {
@@ -6842,7 +7384,7 @@ async function resolveActivePreviewArticle(preferredMarkdownPath, markdownOutput
   };
 }
 function resolveGenerationSourcePath(generation, markdownOutputDir) {
-  return generation.outputs.find((output) => output.contentType === generation.primaryContentType)?.sourcePath ?? generation.outputs[0]?.sourcePath ?? path9.join(markdownOutputDir, generation.id);
+  return generation.outputs.find((output) => output.contentType === generation.primaryContentType)?.sourcePath ?? generation.outputs[0]?.sourcePath ?? path11.join(markdownOutputDir, generation.id);
 }
 function isMissingFileError(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
@@ -6857,7 +7399,7 @@ async function renderArticleHtml(markdown, generationId, sourcePath) {
 async function loadSavedLinks(markdownPath) {
   const linksPath = resolveLinksPath(markdownPath);
   try {
-    const raw = await readFile7(linksPath, "utf8");
+    const raw = await readFile8(linksPath, "utf8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.links)) {
       return [];
@@ -6881,9 +7423,9 @@ async function loadSavedLinks(markdownPath) {
   }
 }
 async function loadSavedInteractions(generationDir) {
-  const interactionsPath = path9.join(generationDir, "model.interactions.json");
+  const interactionsPath = path11.join(generationDir, "model.interactions.json");
   try {
-    const raw = await readFile7(interactionsPath, "utf8");
+    const raw = await readFile8(interactionsPath, "utf8");
     const parsed = JSON.parse(raw);
     const llmCalls = Array.isArray(parsed.llmCalls) ? parsed.llmCalls.filter(isPreviewLlmInteraction) : [];
     const t2iCalls = Array.isArray(parsed.t2iCalls) ? parsed.t2iCalls.filter(isPreviewT2IInteraction) : [];
@@ -6899,9 +7441,9 @@ async function loadSavedInteractions(generationDir) {
   }
 }
 async function loadSavedAnalyticsSummary(generationDir) {
-  const analyticsPath = path9.join(generationDir, "generation.analytics.json");
+  const analyticsPath = path11.join(generationDir, "generation.analytics.json");
   try {
-    const raw = await readFile7(analyticsPath, "utf8");
+    const raw = await readFile8(analyticsPath, "utf8");
     const parsed = JSON.parse(raw);
     const summary = parsed.summary;
     if (!summary || typeof summary !== "object") {
@@ -6933,14 +7475,14 @@ async function getPreviewBootstrapData(preferredMarkdownPath, markdownOutputDir)
   };
 }
 async function resolvePreviewClientBuildDir() {
-  const currentDir = path9.dirname(fileURLToPath(import.meta.url));
+  const currentDir = path11.dirname(fileURLToPath(import.meta.url));
   const candidates = [
-    path9.resolve(currentDir, "preview"),
-    path9.resolve(currentDir, "../../dist/preview")
+    path11.resolve(currentDir, "preview"),
+    path11.resolve(currentDir, "../../dist/preview")
   ];
   for (const candidate of candidates) {
     try {
-      const indexStat = await stat4(path9.join(candidate, "index.html"));
+      const indexStat = await stat5(path11.join(candidate, "index.html"));
       if (indexStat.isFile()) {
         return candidate;
       }
@@ -7002,21 +7544,21 @@ async function resolveGenerationAssetPath(generationId, rawAssetPath, markdownOu
     throw new MissingArticleError(`Generation "${generationId}" no longer exists.`);
   }
   const decodedAssetPath = decodeURIComponent(rawAssetPath);
-  const normalizedRelative = path9.posix.normalize(decodedAssetPath.replace(/\\/g, "/"));
-  if (normalizedRelative.length === 0 || normalizedRelative === "." || normalizedRelative.startsWith("../") || normalizedRelative.includes("/../") || path9.posix.isAbsolute(normalizedRelative)) {
+  const normalizedRelative = path11.posix.normalize(decodedAssetPath.replace(/\\/g, "/"));
+  if (normalizedRelative.length === 0 || normalizedRelative === "." || normalizedRelative.startsWith("../") || normalizedRelative.includes("/../") || path11.posix.isAbsolute(normalizedRelative)) {
     throw new Error("Invalid generation asset path.");
   }
-  const generationDir = path9.dirname(generation.outputs[0]?.sourcePath ?? "");
+  const generationDir = path11.dirname(generation.outputs[0]?.sourcePath ?? "");
   if (!generationDir) {
     throw new MissingArticleError(`Generation "${generationId}" has no source directory.`);
   }
-  const resolvedPath = path9.resolve(generationDir, normalizedRelative);
-  const relativeToGeneration = path9.relative(generationDir, resolvedPath);
-  if (relativeToGeneration.startsWith("..") || path9.isAbsolute(relativeToGeneration)) {
+  const resolvedPath = path11.resolve(generationDir, normalizedRelative);
+  const relativeToGeneration = path11.relative(generationDir, resolvedPath);
+  if (relativeToGeneration.startsWith("..") || path11.isAbsolute(relativeToGeneration)) {
     throw new Error("Invalid generation asset path.");
   }
   try {
-    const fileStat = await stat4(resolvedPath);
+    const fileStat = await stat5(resolvedPath);
     if (!fileStat.isFile()) {
       throw new Error("Invalid generation asset path.");
     }
@@ -8527,7 +9069,7 @@ async function runServeCommand(options) {
   const markdownPath = await resolveMarkdownPath(options.markdownPath, outputPaths.markdownOutputDir, process.cwd());
   const port = parsePort(options.port);
   if (options.watch) {
-    const viteBin = path10.resolve(process.cwd(), "node_modules", ".bin", "vite");
+    const viteBin = path12.resolve(process.cwd(), "node_modules", ".bin", "vite");
     const viteProcess = spawn(viteBin, ["build", "--watch"], {
       stdio: "inherit",
       shell: process.platform === "win32"
@@ -8553,8 +9095,8 @@ async function runServeCommand(options) {
     openBrowser: options.openBrowser,
     watch: options.watch
   });
-  const relativeArticle = path10.relative(process.cwd(), markdownPath);
-  const relativeAssets = path10.relative(process.cwd(), outputPaths.assetOutputDir);
+  const relativeArticle = path12.relative(process.cwd(), markdownPath);
+  const relativeAssets = path12.relative(process.cwd(), outputPaths.assetOutputDir);
   console.log(`Previewing ${relativeArticle || markdownPath}`);
   console.log(`Serving assets from ${relativeAssets || outputPaths.assetOutputDir}`);
   console.log(`Open ${server.url}`);
@@ -8594,11 +9136,28 @@ function colon(id) {
 function value(id, text) {
   return { id, text, color: "white" };
 }
+function formatStageCost(costUsd, costSource) {
+  const formatted = formatCost(costUsd);
+  if (costUsd === null) {
+    return formatted;
+  }
+  return costSource === "estimated" ? `~${formatted}` : formatted;
+}
+function formatStageId(stageId) {
+  if (stageId === "shared-brief") return "shared-brief";
+  if (stageId === "planning") return "planning";
+  if (stageId === "sections") return "sections";
+  if (stageId === "image-prompts") return "image-prompts";
+  if (stageId === "images") return "images";
+  if (stageId === "output") return "output";
+  if (stageId === "links") return "links";
+  return stageId;
+}
 function buildFinalSummaryRows({
   artifact,
   analytics
 }) {
-  return [
+  const rows = [
     {
       id: "slug",
       segments: [
@@ -8648,6 +9207,16 @@ function buildFinalSummaryRows({
       ]
     }
   ];
+  const stageCostRows = analytics.stages.map((stage) => ({
+    id: `stage-cost:${stage.stageId}`,
+    segments: [
+      label(`stage-cost-label:${stage.stageId}`, `cost/${formatStageId(stage.stageId)}`, "greenBright"),
+      colon(`stage-cost-colon:${stage.stageId}`),
+      value(`stage-cost-value:${stage.stageId}`, formatStageCost(stage.costUsd, stage.costSource))
+    ]
+  }));
+  rows.push(...stageCostRows);
+  return rows;
 }
 
 // src/cli/ui/finalSummary.tsx
@@ -8715,7 +9284,7 @@ function formatDuration(durationMs) {
   }
   return `${durationMs}ms`;
 }
-function formatStageCost(stage) {
+function formatStageCost2(stage) {
   const analytics = stage.stageAnalytics;
   if (!analytics || analytics.costUsd === null) {
     return "no cost data";
@@ -8723,6 +9292,15 @@ function formatStageCost(stage) {
   const formatted = `$${analytics.costUsd.toFixed(4)}`;
   return analytics.costSource === "estimated" ? `~${formatted}` : formatted;
 }
+function formatRetryContext(stage) {
+  if (!stage.retryCount || stage.retryCount <= 0) {
+    return "";
+  }
+  if (stage.lastRetryError) {
+    return ` \u2022 retried ${stage.retryCount}x \u2022 last error: ${stage.lastRetryError}`;
+  }
+  return ` \u2022 retried ${stage.retryCount}x`;
+}
 function StageRow({
   stage,
   isActive,
@@ -8748,7 +9326,10 @@ function StageRow({
       /* @__PURE__ */ jsx4(Text3, { children: " " }),
       /* @__PURE__ */ jsx4(Text3, { bold: stage.status === "running", children: stage.title })
     ] }),
-    /* @__PURE__ */ jsx4(Box3, { marginLeft: 2, children: /* @__PURE__ */ jsx4(Text3, { color: "gray", children: stage.detail }) }),
+    /* @__PURE__ */ jsx4(Box3, { marginLeft: 2, children: /* @__PURE__ */ jsxs3(Text3, { color: "gray", children: [
+      stage.detail,
+      formatRetryContext(stage)
+    ] }) }),
     /* @__PURE__ */ jsx4(
       ItemRows,
       {
@@ -8763,7 +9344,7 @@ function StageRow({
       "analytics: ",
       formatDuration(stage.stageAnalytics.durationMs),
       " \u2022 cost: ",
-      formatStageCost(stage)
+      formatStageCost2(stage)
     ] }) }) : null
   ] });
 }
@@ -8947,7 +9528,7 @@ function formatDuration2(durationMs) {
   }
   return `${durationMs}ms`;
 }
-function formatStageCost2(stage) {
+function formatStageCost3(stage) {
   const analytics = stage.stageAnalytics;
   if (!analytics) {
     return "unavailable";
@@ -8959,9 +9540,19 @@ function formatStage(stage) {
   const summary = stage.summary ? `
     ${stage.summary}` : "";
   const analytics = stage.status === "succeeded" && stage.stageAnalytics ? `
-    analytics: ${formatDuration2(stage.stageAnalytics.durationMs)} \u2022 cost: ${formatStageCost2(stage)}` : "";
+    analytics: ${formatDuration2(stage.stageAnalytics.durationMs)} \u2022 cost: ${formatStageCost3(stage)}` : "";
+  const retryContext = formatRetryContext2(stage);
   return `[${stage.status}] ${stage.title}
-    ${stage.detail}${summary}${analytics}`;
+    ${stage.detail}${retryContext}${summary}${analytics}`;
+}
+function formatRetryContext2(stage) {
+  if (!stage.retryCount || stage.retryCount <= 0) {
+    return "";
+  }
+  if (stage.lastRetryError) {
+    return ` \u2022 retried ${stage.retryCount}x \u2022 last error: ${stage.lastRetryError}`;
+  }
+  return ` \u2022 retried ${stage.retryCount}x`;
 }
 function formatItem(stage, item) {
   const summary = item.summary ? `
@@ -8984,8 +9575,15 @@ function formatCost2(costUsd) {
   }
   return `$${costUsd.toFixed(4)}`;
 }
+function formatPipelineStageCost(stage) {
+  const formatted = formatCost2(stage.costUsd);
+  if (stage.costUsd === null) {
+    return formatted;
+  }
+  return stage.costSource === "estimated" ? `~${formatted}` : formatted;
+}
 async function renderPlainPipeline(input, dryRun, enrichLinks2, runMode) {
-  let previousStatuses = /* @__PURE__ */ new Map();
+  let previousStages = /* @__PURE__ */ new Map();
   let previousItemStatuses = /* @__PURE__ */ new Map();
   const notificationsEnabled = input.config.settings.notifications.enabled;
   try {
@@ -9000,10 +9598,16 @@ async function renderPlainPipeline(input, dryRun, enrichLinks2, runMode) {
       runMode,
       onUpdate(stages) {
         for (const stage of stages) {
-          const previous = previousStatuses.get(stage.id);
-          if (previous !== stage.status) {
+          const previous = previousStages.get(stage.id);
+          const shouldLogStage = !previous || previous.status !== stage.status || stage.status === "running" && (previous.detail !== stage.detail || previous.retryCount !== stage.retryCount || previous.lastRetryError !== stage.lastRetryError);
+          if (shouldLogStage) {
             console.log(formatStage(stage));
-            previousStatuses.set(stage.id, stage.status);
+            previousStages.set(stage.id, {
+              status: stage.status,
+              detail: stage.detail,
+              retryCount: stage.retryCount,
+              lastRetryError: stage.lastRetryError
+            });
           }
           for (const item of stage.items ?? []) {
             const itemKey = `${stage.id}:${item.id}`;
@@ -9029,6 +9633,10 @@ async function renderPlainPipeline(input, dryRun, enrichLinks2, runMode) {
     console.log(`  duration_ms: ${result.analytics.summary.totalDurationMs}`);
     console.log(`  retries: ${result.analytics.summary.totalRetries}`);
     console.log(`  cost: ${formatCost2(result.analytics.summary.totalCostUsd)}`);
+    console.log("  cost_by_stage:");
+    for (const stage of result.analytics.stages) {
+      console.log(`    ${stage.stageId}: ${formatPipelineStageCost(stage)}`);
+    }
     await notifyWriteSucceeded({
       enabled: notificationsEnabled,
       title: result.artifact.title,
@@ -9053,9 +9661,11 @@ import TextInput2 from "ink-text-input";
 import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
 function WriteOptionsFlow({
   askStyle,
+  askIntent,
   askTargets,
   askLength,
   initialStyle,
+  initialIntent,
   initialTargetLength,
   initialTargets,
   onDone
@@ -9064,6 +9674,7 @@ function WriteOptionsFlow({
   const [step, setStep] = useState3(() => {
     if (askTargets) return "primary";
     if (askStyle) return "style";
+    if (askIntent) return "intent";
     if (askLength) return "length";
     return "primary";
   });
@@ -9089,6 +9700,7 @@ function WriteOptionsFlow({
   const [countInput, setCountInput] = useState3("1");
   const [countIndex, setCountIndex] = useState3(0);
   const [style, setStyle] = useState3(initialStyle);
+  const [intent, setIntent] = useState3(initialIntent);
   const [targetLength, setTargetLength] = useState3(initialTargetLength);
   const selectedSecondaryTypes = useMemo2(
     () => secondarySelections.filter((item) => item.checked).map((item) => item.contentType),
@@ -9215,6 +9827,8 @@ function WriteOptionsFlow({
               if (nextIndex >= countTypes.length) {
                 if (askStyle) {
                   setStep("style");
+                } else if (askIntent) {
+                  setStep("intent");
                 } else if (askLength) {
                   setStep("length");
                 } else {
@@ -9252,6 +9866,10 @@ function WriteOptionsFlow({
           onSelect: (item) => {
             const contentTargets = askTargets ? buildContentTargets(primaryType, selectedSecondaryTypes) : void 0;
             setStyle(item.value);
+            if (askIntent) {
+              setStep("intent");
+              return;
+            }
             if (askLength) {
               setStep("length");
               return;
@@ -9266,6 +9884,37 @@ function WriteOptionsFlow({
       ) })
     ] });
   }
+  const intentItems = contentIntentValues.map((value2) => ({
+    label: value2,
+    value: value2
+  }));
+  if (step === "intent") {
+    return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Text5, { bold: true, color: "cyanBright", children: "Select Intent" }),
+      /* @__PURE__ */ jsx6(Text5, { color: "gray", children: "Choose the primary content intent for this generation run." }),
+      /* @__PURE__ */ jsx6(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx6(
+        SelectInput2,
+        {
+          items: intentItems,
+          initialIndex: Math.max(0, intentItems.findIndex((item) => item.value === intent)),
+          onSelect: (item) => {
+            const contentTargets = askTargets ? buildContentTargets(primaryType, selectedSecondaryTypes) : void 0;
+            setIntent(item.value);
+            if (askLength) {
+              setStep("length");
+              return;
+            }
+            onDone({
+              ...askStyle ? { style } : {},
+              intent: item.value,
+              ...contentTargets ? { contentTargets } : {}
+            });
+            exit();
+          }
+        }
+      ) })
+    ] });
+  }
   const lengthItems = targetLengthValues.map((value2) => ({
     label: value2,
     value: value2
@@ -9284,6 +9933,7 @@ function WriteOptionsFlow({
             setTargetLength(item.value);
             onDone({
               ...askStyle ? { style } : {},
+              ...askIntent ? { intent } : {},
               targetLength: item.value,
               ...contentTargets ? { contentTargets } : {}
             });
@@ -9397,7 +10047,7 @@ async function runWriteResumeCommand(options = {}) {
       secrets: resolved.config.secrets
     }
   };
-  await runWritePipeline(input, session.dryRun, true, "resume", options.noInteractive ?? false);
+  await runWritePipeline(input, session.dryRun, options.enrichLinks ?? false, "resume", options.noInteractive ?? false);
 }
 async function runWritePipeline(input, dryRun, enrichLinks2, runMode, noInteractive) {
   let interruptHandled = false;
@@ -9482,6 +10132,7 @@ async function resolveInputWithInteractiveIdeaFallback(options) {
       audience: options.audience,
       jobPath: options.jobPath,
       style: options.style,
+      intent: options.intent,
       targetLength: options.length,
       contentTargets: parsedTargets
     });
@@ -9499,6 +10150,7 @@ async function resolveInputWithInteractiveIdeaFallback(options) {
       audience: options.audience,
       jobPath: options.jobPath,
       style: options.style,
+      intent: options.intent,
       targetLength: options.length,
       contentTargets: parsedTargets
     });
@@ -9507,12 +10159,14 @@ async function resolveInputWithInteractiveIdeaFallback(options) {
 }
 async function applyInteractiveWriteOptionsIfNeeded(resolved, options, parsedTargets) {
   const styleProvided = Boolean(options.style ?? resolved.job?.settings?.style);
+  const intentProvided = Boolean(options.intent);
   const lengthProvided = Boolean(options.length ?? resolved.job?.settings?.targetLength);
   const providedTargets = parsedTargets && parsedTargets.length > 0 ? parsedTargets : resolved.job?.settings?.contentTargets ?? resolved.config.settings.contentTargets;
   const targetsProvided = Boolean(parsedTargets && parsedTargets.length > 0 || resolved.job?.settings?.contentTargets?.length);
-  if (options.noInteractive && (!styleProvided || !targetsProvided || !lengthProvided)) {
+  if (options.noInteractive && (!styleProvided || !intentProvided || !targetsProvided || !lengthProvided)) {
     const missingFlags = [
       !styleProvided ? "--style <style>" : null,
+      !intentProvided ? "--intent <intent>" : null,
       !targetsProvided ? "--primary <content-type=1>" : null,
       !lengthProvided ? "--length <size>" : null
     ].filter((value2) => Boolean(value2));
@@ -9523,15 +10177,17 @@ async function applyInteractiveWriteOptionsIfNeeded(resolved, options, parsedTar
   if (!process.stdout.isTTY || !process.stdin.isTTY || options.noInteractive) {
     return resolved;
   }
-  if (styleProvided && targetsProvided && lengthProvided) {
+  if (styleProvided && intentProvided && targetsProvided && lengthProvided) {
     return resolved;
   }
   const prompted = await promptForMissingWriteOptions({
     askStyle: !styleProvided,
+    askIntent: !intentProvided,
     askTargets: !targetsProvided,
     askLength: !lengthProvided,
     style: resolved.config.settings.style,
     targetLength: resolved.config.settings.targetLength,
+    intent: resolved.config.settings.intent,
     targets: providedTargets
   });
   return {
@@ -9541,6 +10197,7 @@ async function applyInteractiveWriteOptionsIfNeeded(resolved, options, parsedTar
       settings: appSettingsSchema.parse({
         ...resolved.config.settings,
         ...prompted.style ? { style: prompted.style } : {},
+        ...prompted.intent ? { intent: prompted.intent } : {},
         ...prompted.targetLength ? { targetLength: prompted.targetLength } : {},
         ...prompted.contentTargets ? { contentTargets: prompted.contentTargets } : {}
       })
@@ -9552,10 +10209,12 @@ async function promptForMissingWriteOptions(params) {
   const app = render2(
     React4.createElement(WriteOptionsFlow, {
       askStyle: params.askStyle,
+      askIntent: params.askIntent,
       askTargets: params.askTargets,
       askLength: params.askLength,
       initialStyle: writingStyleValues.includes(params.style) ? params.style : "professional",
-      initialTargetLength: targetLengthValues.includes(params.targetLength) ? params.targetLength : "medium",
+      initialIntent: contentIntentValues.includes(params.intent) ? params.intent : "tutorial",
+      initialTargetLength: resolveTargetLengthAlias(params.targetLength),
       initialTargets: params.targets,
       onDone: (result) => {
         flowResult = result;
@@ -9639,6 +10298,12 @@ async function runCli(argv) {
       force: options.force
     });
   });
+  program.command("links").description("Run link enrichment for a previously generated article by slug.").argument("<slug>", "Slug of the generated article to enrich").option("--mode <mode>", "Link merge mode: fresh or append", "fresh").action(async (slug, options) => {
+    await runLinksCommand({
+      slug,
+      mode: options.mode
+    });
+  });
   program.command("preview").description("Preview a generated article in a local browser with linked assets.").argument("[markdownPath]", "Path to the markdown file to preview").option("-p, --port <port>", "Port for the local preview server (default: 4173)").option("--no-open", "Do not auto-open browser after server startup").option("--watch", "Rebuild the preview UI on source changes and auto-reload the browser", false).action(async (markdownPath, options) => {
     await runServeCommand({
       markdownPath,
@@ -9647,7 +10312,7 @@ async function runCli(argv) {
       watch: options.watch
     });
   });
-  const writeCommand = program.command("write").description("Generate one primary content output plus optional secondary outputs from a prompt or job file.").argument("[idea]", "Natural-language idea for the generation run").option("-i, --idea <idea>", "Natural-language idea for the generation run").option("--audience <description>", "Optional natural-language audience description for shared-brief targeting").option("-j, --job <path>", "Path to a JSON job definition").option("--primary <type=count>", "Required primary output target (for example: article=1 or x-post=1)").option("--secondary <type=count>", "Secondary output target, repeatable (for example: x-thread=3, linkedin-post=2)", collectOptionValue).option("--style <style>", "Writing style (professional, friendly, technical, academic, opinionated, storytelling)").option("--length <size>", "Target length: small, medium, or large").option("--no-interactive", "Fail instead of prompting for missing input in TTY mode").option("--dry-run", "Run the pipeline shell without external API calls", false).option("--no-enrich-links", "Skip link enrichment after markdown generation").action(async (ideaArg, options) => {
+  const writeCommand = program.command("write").description("Generate one primary content output plus optional secondary outputs from a prompt or job file.").argument("[idea]", "Natural-language idea for the generation run").option("-i, --idea <idea>", "Natural-language idea for the generation run").option("--audience <description>", "Optional natural-language audience description for shared-brief targeting").option("-j, --job <path>", "Path to a JSON job definition").option("--primary <type=count>", "Required primary output target (for example: article=1 or x-post=1)").option("--secondary <type=count>", "Secondary output target, repeatable (for example: x-thread=3, linkedin-post=2)", collectOptionValue).option("--style <style>", "Writing style (academic, analytical, authoritative, conversational, empathetic, friendly, journalistic, minimalist, persuasive, playful, professional, storytelling, technical)").option("--intent <intent>", "Content intent (announcement, case-study, cornerstone, counterargument, critique-review, deep-dive-analysis, how-to-guide, interview-q-and-a, listicle, opinion-piece, personal-essay, roundup-curation, tutorial)").option("--length <size>", "Target length: small, medium, large, or a positive integer word count").option("--no-interactive", "Fail instead of prompting for missing input in TTY mode").option("--dry-run", "Run the pipeline shell without external API calls", false).option("--enrich-links", "Run link enrichment after markdown generation", false).action(async (ideaArg, options) => {
     await runWriteCommand({
       idea: options.idea ?? ideaArg,
       audience: options.audience,
@@ -9655,14 +10320,18 @@ async function runCli(argv) {
       primarySpec: options.primary,
       secondarySpecs: options.secondary,
       style: options.style,
+      intent: options.intent,
       length: options.length,
       noInteractive: !options.interactive,
       dryRun: options.dryRun,
       enrichLinks: options.enrichLinks
     });
   });
-  writeCommand.command("resume").description("Resume the last failed or interrupted write session from .ideon/write.").option("--no-interactive", "Force plain non-interactive output even in TTY mode", false).action(async (options) => {
-    await runWriteResumeCommand({ noInteractive: options.noInteractive });
+  writeCommand.command("resume").description("Resume the last failed or interrupted write session from .ideon/write.").option("--no-interactive", "Force plain non-interactive output even in TTY mode", false).option("--enrich-links", "Run link enrichment after markdown generation", false).action(async (options) => {
+    await runWriteResumeCommand({
+      noInteractive: options.noInteractive,
+      enrichLinks: options.enrichLinks
+    });
   });
   await program.parseAsync(argv);
 }