@telepat/ideon 0.1.20 → 0.1.24

package/dist/ideon.js

@@ -5,243 +5,29 @@ import { Command } from "commander";
 
 // src/cli/commands/delete.ts
 import { rm, stat } from "fs/promises";
-import path3 from "path";
-
-// src/config/schema.ts
-import { z } from "zod";
-var contentTypeValues = [
-  "article",
-  "blog-post",
-  "linkedin-post",
-  "newsletter",
-  "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 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";
-}
-function resolveDefaultMaxLinks(targetLengthWords) {
-  const alias = resolveTargetLengthAlias(targetLengthWords);
-  if (alias === "small") return 5;
-  if (alias === "medium") return 8;
-  return 12;
-}
-var contentTargetRoleValues = ["primary", "secondary"];
-var contentTargetSchema = z.object({
-  contentType: z.enum(contentTypeValues),
-  role: z.enum(contentTargetRoleValues),
-  count: z.number().int().positive().default(1)
-});
-var modelSettingsSchema = z.object({
-  temperature: z.number().min(0).max(2).default(0.7),
-  maxTokens: z.number().int().positive().default(4e3),
-  topP: z.number().min(0).max(1).default(1)
-});
-var baseT2ISettingsSchema = z.object({
-  modelId: z.string().default("flux"),
-  inputOverrides: z.record(z.string(), z.unknown()).default({})
-});
-var notificationsSettingsSchema = z.object({
-  enabled: z.boolean().default(false)
-});
-var appSettingsSchema = z.object({
-  model: z.string().default("deepseek/deepseek-v4-pro"),
-  modelSettings: modelSettingsSchema.default(modelSettingsSchema.parse({})),
-  modelRequestTimeoutMs: z.number().int().positive().default(9e4),
-  t2i: baseT2ISettingsSchema.default(baseT2ISettingsSchema.parse({})),
-  notifications: notificationsSettingsSchema.default(notificationsSettingsSchema.parse({})),
-  markdownOutputDir: z.string().default("/output"),
-  assetOutputDir: z.string().default("/output/assets"),
-  contentTargets: z.array(contentTargetSchema).min(1).refine((targets) => targets.filter((target) => target.role === "primary").length === 1, {
-    message: "contentTargets must include exactly one primary target."
-  }).default([{ contentType: "article", role: "primary", count: 1 }]),
-  style: z.enum(writingStyleValues).default("professional"),
-  intent: z.enum(contentIntentValues).default("tutorial"),
-  targetLength: targetLengthWordsSchema.default(defaultTargetLengthWords)
-});
-var envSettingsSchema = z.object({
-  openRouterApiKey: z.string().optional(),
-  replicateApiToken: z.string().optional(),
-  disableKeytar: z.boolean().optional(),
-  model: z.string().optional(),
-  temperature: z.number().min(0).max(2).optional(),
-  maxTokens: z.number().int().positive().optional(),
-  topP: z.number().min(0).max(1).optional(),
-  modelRequestTimeoutMs: z.number().int().positive().optional(),
-  notificationsEnabled: z.boolean().optional(),
-  markdownOutputDir: z.string().optional(),
-  assetOutputDir: z.string().optional(),
-  style: z.enum(writingStyleValues).optional(),
-  intent: z.enum(contentIntentValues).optional(),
-  targetLength: targetLengthWordsSchema.optional()
-});
-var jobInputSchema = z.object({
-  idea: z.string().min(1).optional(),
-  prompt: z.string().min(1).optional(),
-  targetAudience: z.string().min(1).optional(),
-  settings: appSettingsSchema.partial().optional()
-});
-var defaultAppSettings = appSettingsSchema.parse({});
-
-// src/config/env.ts
-function parseNumber(value2) {
-  if (!value2) {
-    return void 0;
-  }
-  const parsed = Number(value2);
-  return Number.isFinite(parsed) ? parsed : void 0;
-}
-function parseBoolean(value2) {
-  if (!value2) {
-    return void 0;
-  }
-  const normalized = value2.trim().toLowerCase();
-  if (normalized === "true") {
-    return true;
-  }
-  if (normalized === "false") {
-    return false;
-  }
-  return void 0;
-}
-function readEnvSettings(env = process.env) {
-  return envSettingsSchema.parse({
-    openRouterApiKey: env.IDEON_OPENROUTER_API_KEY,
-    replicateApiToken: env.IDEON_REPLICATE_API_TOKEN,
-    disableKeytar: parseBoolean(env.IDEON_DISABLE_KEYTAR),
-    model: env.IDEON_MODEL,
-    temperature: parseNumber(env.IDEON_TEMPERATURE),
-    maxTokens: parseNumber(env.IDEON_MAX_TOKENS),
-    topP: parseNumber(env.IDEON_TOP_P),
-    modelRequestTimeoutMs: parseNumber(env.IDEON_MODEL_REQUEST_TIMEOUT_MS),
-    notificationsEnabled: parseBoolean(env.IDEON_NOTIFICATIONS_ENABLED),
-    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
-  });
-}
-
-// src/config/settingsFile.ts
-import { mkdir, readFile, writeFile } from "fs/promises";
-import path from "path";
-import envPaths from "env-paths";
-var ideonPaths = envPaths("ideon", { suffix: "" });
-var settingsDir = path.join(ideonPaths.config);
-var settingsFilePath = path.join(settingsDir, "settings.json");
-function getSettingsFilePath() {
-  return settingsFilePath;
-}
-async function loadSavedSettings() {
-  try {
-    const raw = await readFile(settingsFilePath, "utf8");
-    return appSettingsSchema.parse(JSON.parse(raw));
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return defaultAppSettings;
-    }
-    throw error;
-  }
-}
-async function saveSettings(settings) {
-  await mkdir(settingsDir, { recursive: true });
-  await writeFile(settingsFilePath, `${JSON.stringify(settings, null, 2)}
-`, "utf8");
-}
+import path2 from "path";
 
 // src/output/filesystem.ts
-import { access, mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
-import path2 from "path";
-function resolveOutputPaths(settings, cwd2 = process.cwd()) {
+import { access, mkdir, writeFile } from "fs/promises";
+import os from "os";
+import path from "path";
+function resolveOutputPaths() {
+  const base = path.join(os.homedir(), ".ideon", "output");
   return {
-    markdownOutputDir: resolveConfiguredDir(settings.markdownOutputDir, cwd2),
-    assetOutputDir: resolveConfiguredDir(settings.assetOutputDir, cwd2)
+    markdownOutputDir: base,
+    assetOutputDir: path.join(base, "assets")
   };
 }
 async function ensureOutputDirectories(paths) {
   await Promise.all([
-    mkdir2(paths.markdownOutputDir, { recursive: true }),
-    mkdir2(paths.assetOutputDir, { recursive: true })
+    mkdir(paths.markdownOutputDir, { recursive: true }),
+    mkdir(paths.assetOutputDir, { recursive: true })
   ]);
 }
 async function resolveUniqueSlug(markdownOutputDir, baseSlug) {
   let attempt = 0;
   let candidate = baseSlug;
-  while (await fileExists(path2.join(markdownOutputDir, `${candidate}.md`))) {
+  while (await fileExists(path.join(markdownOutputDir, `${candidate}.md`))) {
     attempt += 1;
     candidate = `${baseSlug}-${attempt}`;
   }
@@ -279,7 +65,7 @@ async function listFilesRecursively(rootDir, predicate) {
       continue;
     }
     for (const entry of entries) {
-      const fullPath = path2.join(current, entry.name);
+      const fullPath = path.join(current, entry.name);
       if (entry.isDirectory()) {
         stack.push(fullPath);
         continue;
@@ -292,35 +78,26 @@ async function listFilesRecursively(rootDir, predicate) {
   return results;
 }
 async function writeUtf8File(filePath, content) {
-  await mkdir2(path2.dirname(filePath), { recursive: true });
-  await writeFile2(filePath, content, "utf8");
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, content, "utf8");
 }
 async function writeJsonFile(filePath, data) {
   await writeUtf8File(filePath, `${JSON.stringify(data, null, 2)}
 `);
 }
 function resolveLinksPath(markdownPath) {
-  const parsed = path2.parse(markdownPath);
-  return path2.join(parsed.dir, `${parsed.name}.links.json`);
+  const parsed = path.parse(markdownPath);
+  return path.join(parsed.dir, `${parsed.name}.links.json`);
 }
 async function writeLinksFile(markdownPath, links) {
   await writeJsonFile(resolveLinksPath(markdownPath), links);
 }
 function resolveAnalyticsPath(markdownPath) {
-  const parsed = path2.parse(markdownPath);
-  return path2.join(parsed.dir, `${parsed.name}.analytics.json`);
+  const parsed = path.parse(markdownPath);
+  return path.join(parsed.dir, `${parsed.name}.analytics.json`);
 }
 function relativeAssetPath(markdownPath, assetPath) {
-  return path2.relative(path2.dirname(markdownPath), assetPath).split(path2.sep).join("/");
-}
-function resolveConfiguredDir(configuredPath, cwd2) {
-  if (configuredPath === "/output" || configuredPath.startsWith("/output/")) {
-    return path2.join(cwd2, configuredPath.slice(1));
-  }
-  if (path2.isAbsolute(configuredPath)) {
-    return configuredPath;
-  }
-  return path2.resolve(cwd2, configuredPath);
+  return path.relative(path.dirname(markdownPath), assetPath).split(path.sep).join("/");
 }
 async function fileExists(filePath) {
   try {
@@ -372,24 +149,18 @@ async function runDeleteCommand(options, dependencies = {}) {
   log(`Removed ${relativeMarkdown} and cleaned ${relativeAssetDir}.`);
 }
 async function resolveDeleteTargets(slug, cwd2) {
-  const [savedSettings, envSettings] = await Promise.all([loadSavedSettings(), Promise.resolve(readEnvSettings())]);
-  const mergedSettings = appSettingsSchema.parse({
-    ...savedSettings,
-    ...envSettings.markdownOutputDir ? { markdownOutputDir: envSettings.markdownOutputDir } : {},
-    ...envSettings.assetOutputDir ? { assetOutputDir: envSettings.assetOutputDir } : {}
-  });
-  const outputPaths = resolveOutputPaths(mergedSettings, cwd2);
+  const outputPaths = resolveOutputPaths();
   const markdownPath = await resolveMarkdownPathForSlug(outputPaths.markdownOutputDir, slug);
   await assertMarkdownExists(markdownPath, slug);
   return {
     slug,
     markdownPath,
     analyticsPath: resolveAnalyticsPath(markdownPath),
-    assetDir: path3.dirname(markdownPath)
+    assetDir: path2.dirname(markdownPath)
   };
 }
 async function resolveMarkdownPathForSlug(markdownOutputDir, slug) {
-  const directPath = path3.join(markdownOutputDir, `${slug}.md`);
+  const directPath = path2.join(markdownOutputDir, `${slug}.md`);
   if (await pathExists(directPath)) {
     return directPath;
   }
@@ -424,7 +195,7 @@ async function findMarkdownCandidates(rootDir, fileName) {
       continue;
     }
     for (const entry of entries) {
-      const fullPath = path3.join(current, entry.name);
+      const fullPath = path2.join(current, entry.name);
       if (entry.isDirectory()) {
         stack.push(fullPath);
         continue;
@@ -503,7 +274,7 @@ function isNodeError(error) {
   return error instanceof Error;
 }
 function formatRelativePath(cwd2, targetPath) {
-  const relativePath = path3.relative(cwd2, targetPath);
+  const relativePath = path2.relative(cwd2, targetPath);
   return relativePath.length > 0 ? relativePath : targetPath;
 }
 async function directoryContainsMarkdown(dirPath) {
@@ -517,23 +288,23 @@ async function directoryContainsMarkdown(dirPath) {
 }
 
 // src/integrations/agent/store.ts
-import { mkdir as mkdir3, readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
-import path4 from "path";
-import envPaths2 from "env-paths";
-import { z as z2 } from "zod";
+import { mkdir as mkdir2, readFile, writeFile as writeFile2 } from "fs/promises";
+import path3 from "path";
+import envPaths from "env-paths";
+import { z } from "zod";
 var supportedAgentRuntimeValues = ["claude", "claude-desktop", "chatgpt", "gemini", "codex", "cursor", "vscode", "opencode", "generic-mcp"];
-var integrationEntrySchema = z2.object({
-  runtime: z2.enum(supportedAgentRuntimeValues),
-  installedAt: z2.string(),
-  updatedAt: z2.string()
+var integrationEntrySchema = z.object({
+  runtime: z.enum(supportedAgentRuntimeValues),
+  installedAt: z.string(),
+  updatedAt: z.string()
 });
-var integrationStoreSchema = z2.object({
-  version: z2.literal(1),
-  integrations: z2.record(z2.string(), integrationEntrySchema).default({})
+var integrationStoreSchema = z.object({
+  version: z.literal(1),
+  integrations: z.record(z.string(), integrationEntrySchema).default({})
 });
-var ideonPaths2 = envPaths2("ideon", { suffix: "" });
-var storeDir = ideonPaths2.config;
-var storePath = path4.join(storeDir, "agent-integrations.json");
+var ideonPaths = envPaths("ideon", { suffix: "" });
+var storeDir = ideonPaths.config;
+var storePath = path3.join(storeDir, "agent-integrations.json");
 function getAgentIntegrationStorePath() {
   return storePath;
 }
@@ -578,7 +349,7 @@ async function uninstallAgentIntegration(runtime, targetStorePath = storePath) {
 }
 async function readStore(targetStorePath) {
   try {
-    const raw = await readFile2(targetStorePath, "utf8");
+    const raw = await readFile(targetStorePath, "utf8");
     return integrationStoreSchema.parse(JSON.parse(raw));
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -588,8 +359,301 @@ async function readStore(targetStorePath) {
   }
 }
 async function writeStore(store, targetStorePath) {
-  await mkdir3(path4.dirname(targetStorePath), { recursive: true });
-  await writeFile3(targetStorePath, `${JSON.stringify(store, null, 2)}
+  await mkdir2(path3.dirname(targetStorePath), { recursive: true });
+  await writeFile2(targetStorePath, `${JSON.stringify(store, null, 2)}
+`, "utf8");
+}
+
+// src/config/schema.ts
+import { z as z2 } from "zod";
+
+// src/images/limnModelCatalog.ts
+import { getSupportedModelCatalog } from "@telepat/limn";
+function getLimnGenerationModels() {
+  return getSupportedModelCatalog().filter((entry) => entry.generationEnabled);
+}
+var DEFAULT_LIMN_MODEL_ID = "flux";
+function resolveFamilyFromReplicateModelId(replicateModelId) {
+  const match = getLimnGenerationModels().find((model) => model.replicateModelIds.includes(replicateModelId));
+  return match?.family ?? null;
+}
+function isKnownLimnFamily(family) {
+  return getLimnGenerationModels().some((model) => model.family === family);
+}
+function isKnownReplicateModelId(replicateModelId) {
+  return getLimnGenerationModels().some((model) => model.replicateModelIds.includes(replicateModelId));
+}
+function isReplicateModelIdForFamily(family, replicateModelId) {
+  const match = getLimnGenerationModels().find((model) => model.family === family);
+  if (!match) {
+    return false;
+  }
+  return match.replicateModelIds.includes(replicateModelId);
+}
+
+// src/config/schema.ts
+var contentTypeValues = [
+  "article",
+  "blog-post",
+  "linkedin-post",
+  "newsletter",
+  "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 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 = z2.preprocess(
+  (value2) => parseTargetLengthWords(value2),
+  z2.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";
+}
+function resolveDefaultMaxLinks(targetLengthWords) {
+  const alias = resolveTargetLengthAlias(targetLengthWords);
+  if (alias === "small") return 5;
+  if (alias === "medium") return 8;
+  return 12;
+}
+function resolveDefaultInlineImageCount(targetLengthWords) {
+  const alias = resolveTargetLengthAlias(targetLengthWords);
+  if (alias === "small") return { min: 1, max: 2 };
+  if (alias === "medium") return { min: 2, max: 3 };
+  return { min: 3, max: 4 };
+}
+var contentTargetRoleValues = ["primary", "secondary"];
+var contentTargetSchema = z2.object({
+  contentType: z2.enum(contentTypeValues),
+  role: z2.enum(contentTargetRoleValues),
+  count: z2.number().int().positive().default(1)
+});
+var modelSettingsSchema = z2.object({
+  temperature: z2.number().min(0).max(2).default(0.7),
+  maxTokens: z2.number().int().positive().default(4e3),
+  topP: z2.number().min(0).max(1).default(1)
+});
+function normalizeT2ISettings(value2) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) {
+    return value2;
+  }
+  const raw = value2;
+  const rawModelId = typeof raw.modelId === "string" ? raw.modelId.trim() : "";
+  const rawReplicateModelId = typeof raw.replicateModelId === "string" ? raw.replicateModelId.trim() : "";
+  let modelId = rawModelId || DEFAULT_LIMN_MODEL_ID;
+  let replicateModelId = rawReplicateModelId || void 0;
+  if (isKnownLimnFamily(modelId)) {
+    if (replicateModelId && !isReplicateModelIdForFamily(modelId, replicateModelId)) {
+      replicateModelId = void 0;
+    }
+    return {
+      ...raw,
+      modelId,
+      replicateModelId
+    };
+  }
+  if (isKnownReplicateModelId(modelId)) {
+    const derivedFamily = resolveFamilyFromReplicateModelId(modelId);
+    if (derivedFamily) {
+      modelId = derivedFamily;
+      replicateModelId = replicateModelId && isReplicateModelIdForFamily(modelId, replicateModelId) ? replicateModelId : rawModelId;
+      return {
+        ...raw,
+        modelId,
+        replicateModelId
+      };
+    }
+  }
+  if (replicateModelId && isKnownReplicateModelId(replicateModelId)) {
+    const derivedFamily = resolveFamilyFromReplicateModelId(replicateModelId);
+    if (derivedFamily) {
+      return {
+        ...raw,
+        modelId: derivedFamily,
+        replicateModelId
+      };
+    }
+  }
+  return {
+    ...raw,
+    modelId: DEFAULT_LIMN_MODEL_ID,
+    replicateModelId: void 0
+  };
+}
+var baseT2ISettingsSchema = z2.preprocess(
+  normalizeT2ISettings,
+  z2.object({
+    modelId: z2.string().default(DEFAULT_LIMN_MODEL_ID),
+    replicateModelId: z2.string().optional(),
+    inputOverrides: z2.record(z2.string(), z2.unknown()).default({})
+  })
+);
+var notificationsSettingsSchema = z2.object({
+  enabled: z2.boolean().default(false)
+});
+var appSettingsSchema = z2.object({
+  model: z2.string().default("deepseek/deepseek-v4-pro"),
+  modelSettings: modelSettingsSchema.default(modelSettingsSchema.parse({})),
+  modelRequestTimeoutMs: z2.number().int().positive().default(9e4),
+  t2i: baseT2ISettingsSchema.default(baseT2ISettingsSchema.parse({})),
+  notifications: notificationsSettingsSchema.default(notificationsSettingsSchema.parse({})),
+  contentTargets: z2.array(contentTargetSchema).min(1).refine((targets) => targets.filter((target) => target.role === "primary").length === 1, {
+    message: "contentTargets must include exactly one primary target."
+  }).default([{ contentType: "article", role: "primary", count: 1 }]),
+  style: z2.enum(writingStyleValues).default("professional"),
+  intent: z2.enum(contentIntentValues).default("tutorial"),
+  targetLength: targetLengthWordsSchema.default(defaultTargetLengthWords)
+});
+var envSettingsSchema = z2.object({
+  openRouterApiKey: z2.string().optional(),
+  replicateApiToken: z2.string().optional(),
+  disableKeytar: z2.boolean().optional(),
+  model: z2.string().optional(),
+  temperature: z2.number().min(0).max(2).optional(),
+  maxTokens: z2.number().int().positive().optional(),
+  topP: z2.number().min(0).max(1).optional(),
+  modelRequestTimeoutMs: z2.number().int().positive().optional(),
+  notificationsEnabled: z2.boolean().optional(),
+  style: z2.enum(writingStyleValues).optional(),
+  intent: z2.enum(contentIntentValues).optional(),
+  targetLength: targetLengthWordsSchema.optional()
+});
+var jobInputSchema = z2.object({
+  idea: z2.string().min(1).optional(),
+  prompt: z2.string().min(1).optional(),
+  targetAudience: z2.string().min(1).optional(),
+  settings: appSettingsSchema.partial().optional()
+});
+var defaultAppSettings = appSettingsSchema.parse({});
+
+// src/config/env.ts
+function parseNumber(value2) {
+  if (!value2) {
+    return void 0;
+  }
+  const parsed = Number(value2);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function parseBoolean(value2) {
+  if (!value2) {
+    return void 0;
+  }
+  const normalized = value2.trim().toLowerCase();
+  if (normalized === "true") {
+    return true;
+  }
+  if (normalized === "false") {
+    return false;
+  }
+  return void 0;
+}
+function readEnvSettings(env = process.env) {
+  return envSettingsSchema.parse({
+    openRouterApiKey: env.IDEON_OPENROUTER_API_KEY,
+    replicateApiToken: env.IDEON_REPLICATE_API_TOKEN,
+    disableKeytar: parseBoolean(env.IDEON_DISABLE_KEYTAR),
+    model: env.IDEON_MODEL,
+    temperature: parseNumber(env.IDEON_TEMPERATURE),
+    maxTokens: parseNumber(env.IDEON_MAX_TOKENS),
+    topP: parseNumber(env.IDEON_TOP_P),
+    modelRequestTimeoutMs: parseNumber(env.IDEON_MODEL_REQUEST_TIMEOUT_MS),
+    notificationsEnabled: parseBoolean(env.IDEON_NOTIFICATIONS_ENABLED),
+    style: env.IDEON_STYLE,
+    intent: env.IDEON_INTENT,
+    targetLength: env.IDEON_TARGET_LENGTH
+  });
+}
+
+// src/config/settingsFile.ts
+import { mkdir as mkdir3, readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
+import path4 from "path";
+import envPaths2 from "env-paths";
+var ideonPaths2 = envPaths2("ideon", { suffix: "" });
+var settingsDir = path4.join(ideonPaths2.config);
+var settingsFilePath = path4.join(settingsDir, "settings.json");
+function getSettingsFilePath() {
+  return settingsFilePath;
+}
+async function loadSavedSettings() {
+  try {
+    const raw = await readFile2(settingsFilePath, "utf8");
+    return appSettingsSchema.parse(JSON.parse(raw));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return defaultAppSettings;
+    }
+    throw error;
+  }
+}
+async function saveSettings(settings) {
+  await mkdir3(settingsDir, { recursive: true });
+  await writeFile3(settingsFilePath, `${JSON.stringify(settings, null, 2)}
 `, "utf8");
 }
 
@@ -746,8 +810,7 @@ var configSettingKeys = [
   "modelSettings.topP",
   "modelRequestTimeoutMs",
   "notifications.enabled",
-  "markdownOutputDir",
-  "assetOutputDir",
+  "t2i.replicateModelId",
   "style",
   "intent",
   "targetLength"
@@ -775,8 +838,7 @@ async function configList() {
       "modelSettings.topP": settings.modelSettings.topP,
       modelRequestTimeoutMs: settings.modelRequestTimeoutMs,
       "notifications.enabled": settings.notifications.enabled,
-      markdownOutputDir: settings.markdownOutputDir,
-      assetOutputDir: settings.assetOutputDir,
+      "t2i.replicateModelId": settings.t2i.replicateModelId,
       style: settings.style,
       intent: settings.intent,
       targetLength: settings.targetLength
@@ -837,12 +899,15 @@ function coerceSettingValue(key, rawValue) {
   const trimmed = rawValue.trim();
   switch (key) {
     case "model":
-    case "markdownOutputDir":
-    case "assetOutputDir": {
       if (trimmed.length === 0) {
         throw new Error(`${key} cannot be empty.`);
       }
       return trimmed;
+    case "t2i.replicateModelId": {
+      if (trimmed.length === 0) {
+        throw new Error("t2i.replicateModelId cannot be empty. Use config unset to clear it.");
+      }
+      return trimmed;
     }
     case "modelSettings.temperature": {
       const parsed = Number(trimmed);
@@ -916,10 +981,8 @@ function getSettingValue(settings, key) {
       return settings.modelRequestTimeoutMs;
     case "notifications.enabled":
       return settings.notifications.enabled;
-    case "markdownOutputDir":
-      return settings.markdownOutputDir;
-    case "assetOutputDir":
-      return settings.assetOutputDir;
+    case "t2i.replicateModelId":
+      return settings.t2i.replicateModelId;
     case "style":
       return settings.style;
     case "intent":
@@ -944,10 +1007,8 @@ function setSettingValue(settings, key, value2) {
       return { ...settings, modelRequestTimeoutMs: value2 };
     case "notifications.enabled":
       return { ...settings, notifications: { ...settings.notifications, enabled: value2 } };
-    case "markdownOutputDir":
-      return { ...settings, markdownOutputDir: value2 };
-    case "assetOutputDir":
-      return { ...settings, assetOutputDir: value2 };
+    case "t2i.replicateModelId":
+      return { ...settings, t2i: { ...settings.t2i, replicateModelId: value2 } };
     case "style":
       return { ...settings, style: value2 };
     case "intent":
@@ -1362,7 +1423,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 // package.json
 var package_default = {
   name: "@telepat/ideon",
-  version: "0.1.20",
+  version: "0.1.24",
   description: "CLI for generating rich articles and images from ideas.",
   type: "module",
   repository: {
@@ -1500,8 +1561,6 @@ async function resolveRunInput(input) {
         ...envSettings.topP !== void 0 ? { topP: envSettings.topP } : {}
       }
     } : {},
-    ...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 } : {},
@@ -1564,7 +1623,7 @@ function assertNoLegacyXMode(contentTargets, sourceLabel) {
 }
 
 // src/pipeline/runner.ts
-import { mkdir as mkdir5, stat as stat2 } from "fs/promises";
+import { mkdir as mkdir6, stat as stat2 } from "fs/promises";
 import { randomUUID } from "crypto";
 import path8 from "path";
 
@@ -1883,7 +1942,7 @@ function toExpressionPreview(expression, maxLength = 60) {
 // src/llm/prompts/writingFramework.ts
 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.`;
+  return `Run context: requested content types are ${normalizedTypes}. Keep output aligned with this distribution plan, maintain one shared content plan, and adapt structure per channel without duplicating article-only scaffolding.`;
 }
 var TARGET_LENGTH_TIERS = {
   small: {
@@ -1940,6 +1999,23 @@ function buildTargetLengthDirective(contentType, targetLengthWords) {
 // src/llm/prompts/guideBundles.ts
 import { existsSync, readFileSync } from "fs";
 import path5 from "path";
+
+// src/types/article.ts
+var LONG_FORM_CONTENT_TYPES = [
+  "article",
+  "blog-post",
+  "newsletter",
+  "press-release",
+  "science-paper"
+];
+function isLongFormContentType(contentType) {
+  return LONG_FORM_CONTENT_TYPES.includes(contentType);
+}
+function isLongFormPlan(plan) {
+  return isLongFormContentType(plan.contentType) && plan.sections !== void 0 && plan.sections.length > 0;
+}
+
+// src/llm/prompts/guideBundles.ts
 var guideCache = /* @__PURE__ */ new Map();
 function normalizeGuideContent(content) {
   return content.replace(/\r\n/g, "\n").trim();
@@ -1991,14 +2067,22 @@ function buildGuideBundle(relativePaths) {
     ...blocks
   ].join("\n\n");
 }
-function buildArticlePlanGuideInstruction(intent, contentType) {
-  return buildGuideBundle([
+function buildPrimaryPlanGuideInstruction(intent, contentType) {
+  const baseGuides = [
     "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)
-  ]);
+  ];
+  if (!isLongFormContentType(contentType)) {
+    return buildGuideBundle([
+      "writing-guide/references/headline-writing-systems.md",
+      intentToGuidePath(intent),
+      formatToGuidePath(contentType)
+    ]);
+  }
+  return buildGuideBundle(baseGuides);
 }
 function buildArticleSectionGuideInstruction(style, intent, contentType) {
   return buildGuideBundle([
@@ -2012,9 +2096,9 @@ function buildArticleSectionGuideInstruction(style, intent, contentType) {
     formatToGuidePath(contentType)
   ]);
 }
-function buildContentBriefGuideInstruction(intent, primaryContentType, secondaryContentTypes) {
+function buildContentPlanGuideInstruction(intent, primaryContentType, secondaryContentTypes) {
   return buildGuideBundle([
-    "writing-guide/references/multi-channel-brief-strategy.md",
+    "writing-guide/references/multi-channel-plan-strategy.md",
     "writing-guide/references/content-frameworks.md",
     "writing-guide/references/target-length-guidance.md",
     intentToGuidePath(intent),
@@ -2034,8 +2118,8 @@ function buildChannelContentGuideInstruction(style, intent, contentType) {
   ]);
 }
 
-// src/llm/prompts/contentBrief.ts
-var contentBriefSchema = {
+// src/llm/prompts/contentPlan.ts
+var contentPlanSchema = {
   type: "object",
   additionalProperties: false,
   required: [
@@ -2069,15 +2153,15 @@ var contentBriefSchema = {
     secondaryContentStrategy: { type: "string" }
   }
 };
-function buildContentBriefMessages(idea, options) {
+function buildContentPlanMessages(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.",
-    buildContentBriefGuideInstruction(options.intent, options.primaryContentType, options.secondaryContentTypes),
+    "Produce a shared content plan that can guide all requested content types in this run.",
+    buildContentPlanGuideInstruction(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.",
+    "The plan 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.",
     "Return only the requested JSON."
   ].join(" ");
@@ -2089,7 +2173,7 @@ function buildContentBriefMessages(idea, options) {
     {
       role: "user",
       content: [
-        "Create a shared content brief from this idea:",
+        "Create a shared content plan from this idea:",
         idea,
         "",
         `Audience seed (optional user guidance): ${audienceSeed}`,
@@ -2112,7 +2196,7 @@ function buildContentBriefMessages(idea, options) {
   ];
 }
 
-// src/types/contentBriefSchema.ts
+// src/types/contentPlanSchema.ts
 import { z as z4 } from "zod";
 var secondaryTypeSentinelValues = /* @__PURE__ */ new Set([
   "none",
@@ -2123,7 +2207,7 @@ var secondaryTypeSentinelValues = /* @__PURE__ */ new Set([
   "no secondary content",
   "no secondary outputs"
 ]);
-var contentBriefSchema2 = z4.object({
+var contentPlanSchema2 = z4.object({
   title: z4.string().min(8),
   description: z4.string().min(40),
   targetAudience: z4.string().min(10),
@@ -2133,12 +2217,12 @@ var contentBriefSchema2 = z4.object({
   primaryContentType: z4.string().min(2),
   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;
+}).superRefine((plan, ctx) => {
+  const hasSecondaryTargets = plan.secondaryContentTypes.length > 0;
   if (!hasSecondaryTargets) {
     return;
   }
-  if (brief.secondaryContentStrategy.trim().length < 20) {
+  if (plan.secondaryContentStrategy.trim().length < 20) {
     ctx.addIssue({
       code: z4.ZodIssueCode.too_small,
       minimum: 20,
@@ -2151,9 +2235,9 @@ var contentBriefSchema2 = z4.object({
   }
 });
 
-// src/generation/planContentBrief.ts
-var SHARED_BRIEF_MAX_TOKENS = 8e3;
-async function planContentBrief({
+// src/generation/planContentPlan.ts
+var SHARED_PLAN_MAX_TOKENS = 8e3;
+async function planContentPlan({
   idea,
   targetAudienceHint,
   settings,
@@ -2163,37 +2247,37 @@ async function planContentBrief({
   onInteraction
 }) {
   if (dryRun || !openRouter) {
-    return buildDryRunContentBrief(idea, targetAudienceHint);
+    return buildDryRunContentPlan(idea, targetAudienceHint);
   }
-  const sharedBriefSettings = {
+  const sharedPlanSettings = {
     ...settings,
     modelSettings: {
       ...settings.modelSettings,
-      maxTokens: Math.max(settings.modelSettings.maxTokens, SHARED_BRIEF_MAX_TOKENS)
+      maxTokens: Math.max(settings.modelSettings.maxTokens, SHARED_PLAN_MAX_TOKENS)
     }
   };
   return await openRouter.requestStructured({
-    schemaName: "content_brief",
-    schema: contentBriefSchema,
-    messages: buildContentBriefMessages(idea, {
+    schemaName: "content_plan",
+    schema: contentPlanSchema,
+    messages: buildContentPlanMessages(idea, {
       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)
     }),
-    settings: sharedBriefSettings,
+    settings: sharedPlanSettings,
     interactionContext: {
-      stageId: "shared-brief",
-      operationId: "shared-brief:content-brief"
+      stageId: "shared-plan",
+      operationId: "shared-plan:content-plan"
     },
     onInteraction,
     onMetrics: onLlmMetrics,
     parse(data) {
-      return contentBriefSchema2.parse(data);
+      return contentPlanSchema2.parse(data);
     }
   });
 }
-function buildDryRunContentBrief(idea, targetAudienceHint) {
+function buildDryRunContentPlan(idea, targetAudienceHint) {
   const normalizedIdea = idea.trim();
   const normalizedAudience = targetAudienceHint?.trim();
   const targetAudience = normalizedAudience && normalizedAudience.length > 0 ? `Audience seed: ${normalizedAudience}. Extend this profile with specific motivations, constraints, and context tied to ${normalizedIdea}.` : "A broad, general audience of curious professionals and creators seeking practical, applicable insight.";
@@ -2215,13 +2299,13 @@ function buildDryRunContentBrief(idea, targetAudienceHint) {
 }
 function deriveTitleFromIdea(idea) {
   if (!idea) {
-    return "Generated Content Brief";
+    return "Generated Content Plan";
   }
   return idea.split(/\s+/).slice(0, 8).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
 }
 
-// src/llm/prompts/articlePlan.ts
-function deriveArticleSectionCounts(targetLengthWords) {
+// src/llm/prompts/primaryPlan.ts
+function deriveSectionCounts(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);
@@ -2232,12 +2316,20 @@ function deriveArticleSectionCounts(targetLengthWords) {
     label: `${min} to ${max}`
   };
 }
-function buildArticlePlanJsonSchema(targetLengthWords) {
-  const sectionCounts = deriveArticleSectionCounts(targetLengthWords);
+function buildPrimaryPlanJsonSchema(contentType, targetLengthWords) {
+  if (!isLongFormContentType(contentType)) {
+    return buildShortFormPlanJsonSchema();
+  }
+  return buildLongFormPlanJsonSchema(targetLengthWords);
+}
+function buildLongFormPlanJsonSchema(targetLengthWords) {
+  const sectionCounts = deriveSectionCounts(targetLengthWords);
+  const imageCounts = resolveDefaultInlineImageCount(targetLengthWords);
   return {
     type: "object",
     additionalProperties: false,
     required: [
+      "contentType",
       "title",
       "subtitle",
       "keywords",
@@ -2250,6 +2342,7 @@ function buildArticlePlanJsonSchema(targetLengthWords) {
       "inlineImages"
     ],
     properties: {
+      contentType: { type: "string" },
       title: { type: "string" },
       subtitle: { type: "string" },
       keywords: {
@@ -2279,8 +2372,8 @@ function buildArticlePlanJsonSchema(targetLengthWords) {
       coverImageDescription: { type: "string" },
       inlineImages: {
         type: "array",
-        minItems: 2,
-        maxItems: 3,
+        minItems: imageCounts.min,
+        maxItems: imageCounts.max,
         items: {
           type: "object",
           additionalProperties: false,
@@ -2294,13 +2387,42 @@ function buildArticlePlanJsonSchema(targetLengthWords) {
     }
   };
 }
-function buildArticlePlanMessages(idea, options) {
-  const sectionCounts = deriveArticleSectionCounts(options.targetLength);
+function buildShortFormPlanJsonSchema() {
+  return {
+    type: "object",
+    additionalProperties: false,
+    required: [
+      "contentType",
+      "title",
+      "slug",
+      "description",
+      "coverImageDescription",
+      "angle"
+    ],
+    properties: {
+      contentType: { type: "string" },
+      title: { type: "string" },
+      slug: { type: "string" },
+      description: { type: "string" },
+      coverImageDescription: { type: "string" },
+      angle: { type: "string" }
+    }
+  };
+}
+function buildPrimaryPlanMessages(idea, options) {
+  if (!isLongFormContentType(options.contentType)) {
+    return buildShortFormPlanMessages(idea, options);
+  }
+  return buildLongFormPlanMessages(idea, options);
+}
+function buildLongFormPlanMessages(idea, options) {
+  const sectionCounts = deriveSectionCounts(options.targetLength);
+  const imageCounts = resolveDefaultInlineImageCount(options.targetLength);
   const systemInstruction = [
-    "You are a senior editorial strategist. Produce a rigorous article plan for a polished long-form Markdown article.",
-    buildArticlePlanGuideInstruction(options.intent, "article"),
+    "You are a senior editorial strategist. Produce a rigorous content plan for a polished long-form Markdown output.",
+    buildPrimaryPlanGuideInstruction(options.intent, options.contentType),
     buildRunContextDirective(options.contentTypes),
-    buildTargetLengthDirective("article", options.targetLength),
+    buildTargetLengthDirective(options.contentType, options.targetLength),
     "Return only the requested JSON."
   ].join(" ");
   return [
@@ -2311,31 +2433,32 @@ function buildArticlePlanMessages(idea, options) {
     {
       role: "user",
       content: [
-        "Create an article plan from this idea:",
+        `Create a ${options.contentType} plan from this idea:`,
         idea,
         "",
         "Requirements:",
-        "- The article should feel authoritative, practical, and clearly structured for scanning and deep reading.",
+        "- The content 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 and align with the shared content brief.",
+        "- The description should work as a concise meta description and align with the shared content plan.",
         `- 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.",
-        "- Sections are article-only structure and must not be treated as requirements for non-article channels.",
-        "- Include a cover image description and 2 to 3 inline image descriptions.",
+        "- Sections are primary-only structure and must not be treated as requirements for non-primary channels.",
+        `- Include a cover image description and ${imageCounts.min} to ${imageCounts.max} inline image descriptions.`,
         "- Each inline image must specify which section it follows (anchorAfterSection, 1-based index). Choose sections where visual reinforcement adds the most value.",
         "- Image descriptions should capture the general concept and mood \u2014 the exact text-to-image prompt will be refined later using the actual section content.",
         "- Image descriptions must be concrete and contextual, not generic stock-photo phrasing.",
         "",
-        "Shared content brief context:",
-        `- description: ${options.contentBrief.description}`,
-        `- targetAudience: ${options.contentBrief.targetAudience}`,
-        `- corePromise: ${options.contentBrief.corePromise}`,
-        `- keyPoints: ${options.contentBrief.keyPoints.join(" | ")}`,
-        `- voiceNotes: ${options.contentBrief.voiceNotes}`,
+        "Shared content plan context:",
+        `- description: ${options.contentPlan.description}`,
+        `- targetAudience: ${options.contentPlan.targetAudience}`,
+        `- corePromise: ${options.contentPlan.corePromise}`,
+        `- keyPoints: ${options.contentPlan.keyPoints.join(" | ")}`,
+        `- voiceNotes: ${options.contentPlan.voiceNotes}`,
         "",
         "Return JSON with all required fields:",
+        `- contentType: set to "${options.contentType}" exactly`,
         "- title: string",
         "- subtitle: string",
         "- keywords: array of 3 to 8 strings",
@@ -2345,7 +2468,53 @@ function buildArticlePlanMessages(idea, options) {
         "- outroBrief: string",
         `- sections: array of ${sectionCounts.label} objects, each with title and description strings`,
         "- coverImageDescription: string",
-        "- inlineImages: array of 2 to 3 objects, each with a description string and an anchorAfterSection number (1-based section index)",
+        `- inlineImages: array of ${imageCounts.min} to ${imageCounts.max} objects, each with a description string and an anchorAfterSection number (1-based section index)`,
+        "",
+        "Do not omit any required fields. Return strict JSON only."
+      ].join("\n")
+    }
+  ];
+}
+function buildShortFormPlanMessages(idea, options) {
+  const systemInstruction = [
+    "You are a senior content strategist. Produce a concise content plan for a short-form social media post.",
+    buildPrimaryPlanGuideInstruction(options.intent, options.contentType),
+    buildRunContextDirective(options.contentTypes),
+    "Return only the requested JSON."
+  ].join(" ");
+  return [
+    {
+      role: "system",
+      content: systemInstruction
+    },
+    {
+      role: "user",
+      content: [
+        `Create a ${options.contentType} plan from this idea:`,
+        idea,
+        "",
+        "Requirements:",
+        "- Generate a sharp, attention-grabbing title suitable for social media.",
+        "- The slug must be lowercase kebab-case and publication-ready.",
+        "- The description should capture the core message in one sentence.",
+        "- The angle should describe the hook, framing, or unique take that makes this post compelling.",
+        "- Include a cover image description that works as a visual anchor for the post.",
+        "- Do NOT include sections, subtitles, keywords, intros, or outros \u2014 this is short-form content.",
+        "",
+        "Shared content plan context:",
+        `- description: ${options.contentPlan.description}`,
+        `- targetAudience: ${options.contentPlan.targetAudience}`,
+        `- corePromise: ${options.contentPlan.corePromise}`,
+        `- keyPoints: ${options.contentPlan.keyPoints.join(" | ")}`,
+        `- voiceNotes: ${options.contentPlan.voiceNotes}`,
+        "",
+        "Return JSON with all required fields:",
+        `- contentType: set to "${options.contentType}" exactly`,
+        "- title: string (short, punchy, social-media-ready)",
+        "- slug: string in lowercase kebab-case",
+        "- description: string (one-sentence core message)",
+        "- coverImageDescription: string",
+        "- angle: string (the hook or framing that makes this post work)",
         "",
         "Do not omit any required fields. Return strict JSON only."
       ].join("\n")
@@ -2363,7 +2532,22 @@ var inlineImagePlanSchema = z5.object({
   description: z5.string().min(1),
   anchorAfterSection: z5.number().int().min(1)
 });
-var articlePlanSchema = z5.object({
+var primaryPlanSchema = z5.object({
+  contentType: z5.string().min(1).default("article"),
+  title: z5.string().min(1),
+  slug: z5.string().min(1),
+  description: z5.string().min(1),
+  coverImageDescription: z5.string().min(1),
+  subtitle: z5.string().min(1).optional(),
+  keywords: z5.array(z5.string().min(1)).min(3).max(8).optional(),
+  introBrief: z5.string().min(1).optional(),
+  outroBrief: z5.string().min(1).optional(),
+  sections: z5.array(articleSectionPlanSchema).min(2).max(10).optional(),
+  inlineImages: z5.array(inlineImagePlanSchema).min(2).max(3).optional(),
+  angle: z5.string().min(1).optional()
+});
+var longFormPlanSchema = z5.object({
+  contentType: z5.string().min(1),
   title: z5.string().min(1),
   subtitle: z5.string().min(1),
   keywords: z5.array(z5.string().min(1)).min(3).max(8),
@@ -2375,14 +2559,23 @@ var articlePlanSchema = z5.object({
   coverImageDescription: z5.string().min(1),
   inlineImages: z5.array(inlineImagePlanSchema).min(2).max(3)
 });
+var shortFormPlanSchema = z5.object({
+  contentType: z5.string().min(1),
+  title: z5.string().min(1),
+  slug: z5.string().min(1),
+  description: z5.string().min(1),
+  coverImageDescription: z5.string().min(1),
+  angle: z5.string().min(1).optional()
+});
 var imagePromptResultSchema = z5.object({
   prompt: z5.string().min(1)
 });
 
-// src/generation/planArticle.ts
-async function planArticle({
+// src/generation/planPrimaryContent.ts
+async function planPrimaryContent({
   idea,
-  contentBrief,
+  contentType,
+  contentPlan,
   settings,
   markdownOutputDir,
   openRouter,
@@ -2390,56 +2583,79 @@ async function planArticle({
   onLlmMetrics,
   onInteraction
 }) {
-  const basePlan = dryRun || !openRouter ? buildDryRunPlan(idea, contentBrief) : await openRouter.requestStructured({
-    schemaName: "article_plan",
-    schema: buildArticlePlanJsonSchema(settings.targetLength),
-    messages: buildArticlePlanMessages(idea, {
+  const isLongForm = isLongFormContentType(contentType);
+  const basePlan = dryRun || !openRouter ? buildDryRunPlan(idea, contentType, contentPlan) : await openRouter.requestStructured({
+    schemaName: "primary_plan",
+    schema: buildPrimaryPlanJsonSchema(contentType, settings.targetLength),
+    messages: buildPrimaryPlanMessages(idea, {
+      contentType,
       intent: settings.intent,
       contentTypes: settings.contentTargets.map((target) => target.contentType),
-      contentBrief,
+      contentPlan,
       targetLength: settings.targetLength
     }),
     settings,
     interactionContext: {
       stageId: "planning",
-      operationId: "planning:article-plan"
+      operationId: `planning:${contentType}-plan`
     },
     onInteraction,
     onMetrics: onLlmMetrics,
     parse(data) {
-      return articlePlanSchema.parse(data);
+      if (isLongForm) {
+        return longFormPlanSchema.parse(data);
+      }
+      return shortFormPlanSchema.parse(data);
     }
   });
   const normalizedSlug = slugify(basePlan.slug || basePlan.title);
   const uniqueSlug = await resolveUniqueSlug(markdownOutputDir, normalizedSlug);
-  const sectionCount = basePlan.sections.length;
+  if (isLongForm) {
+    const longPlan = basePlan;
+    const sectionCount = longPlan.sections.length;
+    return {
+      ...longPlan,
+      slug: uniqueSlug,
+      keywords: longPlan.keywords.slice(0, 8),
+      inlineImages: longPlan.inlineImages.slice(0, 3).map((img) => ({
+        ...img,
+        anchorAfterSection: Math.max(1, Math.min(sectionCount, img.anchorAfterSection))
+      }))
+    };
+  }
   return {
     ...basePlan,
-    slug: uniqueSlug,
-    keywords: basePlan.keywords.slice(0, 8),
-    inlineImages: basePlan.inlineImages.slice(0, 3).map((img) => ({
-      ...img,
-      anchorAfterSection: Math.max(1, Math.min(sectionCount, img.anchorAfterSection))
-    }))
+    slug: uniqueSlug
   };
 }
-function buildDryRunPlan(idea, contentBrief) {
-  const title = idea.trim().split(/\s+/).slice(0, 7).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+function buildDryRunPlan(idea, contentType, contentPlan) {
+  const title = idea.trim().split(/\s+/).slice(0, 7).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ") || contentPlan.title;
+  if (!isLongFormContentType(contentType)) {
+    return {
+      contentType,
+      title,
+      slug: slugify(title),
+      description: contentPlan.description,
+      coverImageDescription: `A visually striking cover image for a ${contentType} about ${idea.trim().split(/\s+/).slice(0, 5).join(" ")}.`,
+      angle: `Direct, practical framing that hooks the audience immediately with a clear value proposition tied to ${contentPlan.corePromise}`
+    };
+  }
   return {
+    contentType,
     title,
-    subtitle: "A practical editorial blueprint for turning a good idea into a strong article",
+    subtitle: "A practical editorial blueprint for turning a good idea into strong published content",
     keywords: ["writing", "editorial workflow", "ai tools", "content strategy"],
     slug: slugify(title),
-    description: contentBrief.description,
+    description: contentPlan.description,
     introBrief: "Frame the tension between having ideas and actually shaping them into useful published work.",
     outroBrief: "End by emphasizing disciplined workflows, taste, and iteration.",
     sections: [
       {
         title: "Why raw ideas are not enough",
-        description: "Explain why strong articles need structure, intent, and editorial judgment."
+        description: "Explain why strong content needs structure, intent, and editorial judgment."
       },
       {
-        title: "Designing the article before drafting",
+        title: "Designing the content before drafting",
         description: "Show how planning title, sections, and narrative flow improves the final result."
       },
       {
@@ -2458,7 +2674,7 @@ function buildDryRunPlan(idea, contentBrief) {
     coverImageDescription: "A refined editorial workspace with notebooks, sketches, and glowing structured outlines, cinematic but minimal.",
     inlineImages: [
       {
-        description: "A rough idea evolving into a structured article outline on a desk full of notes.",
+        description: "A rough idea evolving into a structured content outline on a desk full of notes.",
         anchorAfterSection: 2
       },
       {
@@ -2469,7 +2685,7 @@ function buildDryRunPlan(idea, contentBrief) {
   };
 }
 function slugify(value2) {
-  return value2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "untitled-article";
+  return value2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "untitled-content";
 }
 
 // src/llm/prompts/channelContent.ts
@@ -2495,6 +2711,14 @@ function buildSingleShotContentMessages(options) {
     `This output is secondary content and must promote or incite interest in the primary ${options.primaryContentType} content.`,
     "Keep it independently useful, avoid sounding like an ad, and include channel-native cues that point back to the primary narrative."
   ].join(" ");
+  const planContext = options.plan ? [
+    "",
+    "Primary content plan (use to guide tone, angle, and structure):",
+    `- title: ${options.plan.title}`,
+    `- description: ${options.plan.description}`,
+    `- coverImageDescription: ${options.plan.coverImageDescription}`,
+    ...options.plan.angle ? [`- angle: ${options.plan.angle}`] : []
+  ].join("\n") : "";
   return [
     {
       role: "system",
@@ -2515,16 +2739,17 @@ function buildSingleShotContentMessages(options) {
         `Primary content type: ${options.primaryContentType}`,
         `Output index: ${options.outputIndex} of ${options.outputCountForType}`,
         "",
-        "Shared content brief (must guide this output):",
-        `- title: ${options.contentBrief.title}`,
-        `- description: ${options.contentBrief.description}`,
-        `- targetAudience: ${options.contentBrief.targetAudience}`,
-        `- corePromise: ${options.contentBrief.corePromise}`,
-        `- keyPoints: ${options.contentBrief.keyPoints.join(" | ")}`,
-        `- voiceNotes: ${options.contentBrief.voiceNotes}`,
-        `- primaryContentType: ${options.contentBrief.primaryContentType}`,
-        `- secondaryContentTypes: ${options.contentBrief.secondaryContentTypes.join(" | ") || "none"}`,
-        `- secondaryContentStrategy: ${options.contentBrief.secondaryContentStrategy}`,
+        "Shared content plan (must guide this output):",
+        `- title: ${options.contentPlan.title}`,
+        `- description: ${options.contentPlan.description}`,
+        `- targetAudience: ${options.contentPlan.targetAudience}`,
+        `- corePromise: ${options.contentPlan.corePromise}`,
+        `- keyPoints: ${options.contentPlan.keyPoints.join(" | ")}`,
+        `- voiceNotes: ${options.contentPlan.voiceNotes}`,
+        `- primaryContentType: ${options.contentPlan.primaryContentType}`,
+        `- secondaryContentTypes: ${options.contentPlan.secondaryContentTypes.join(" | ") || "none"}`,
+        `- secondaryContentStrategy: ${options.contentPlan.secondaryContentStrategy}`,
+        planContext,
         "",
         articleContext,
         "",
@@ -2548,7 +2773,8 @@ async function writeSingleShotContent({
   outputIndex,
   outputCountForType,
   articleReferenceMarkdown,
-  contentBrief,
+  contentPlan,
+  plan,
   settings,
   openRouter,
   dryRun,
@@ -2563,7 +2789,8 @@ async function writeSingleShotContent({
       primaryContentType,
       outputIndex,
       outputCountForType,
-      contentBrief,
+      contentPlan,
+      plan,
       articleReferenceMarkdown
     });
   }
@@ -2577,7 +2804,8 @@ async function writeSingleShotContent({
       intent,
       outputIndex,
       outputCountForType,
-      contentBrief,
+      contentPlan,
+      plan,
       articleReferenceMarkdown,
       targetLength: settings.targetLength
     }),
@@ -2592,6 +2820,9 @@ async function writeSingleShotContent({
 }
 function buildDryRunContent(options) {
   const anchorNote = options.articleReferenceMarkdown ? "Anchored to generated primary context from this run." : "No primary anchor available; generated directly from idea.";
+  const planNote = options.plan ? `Plan title: ${options.plan.title}
+Plan description: ${options.plan.description}${options.plan.angle ? `
+Angle: ${options.plan.angle}` : ""}` : "No primary plan available.";
   return [
     `# ${options.contentType} draft ${options.outputIndex}`,
     "",
@@ -2599,7 +2830,8 @@ function buildDryRunContent(options) {
     `Variant: ${options.outputIndex}/${options.outputCountForType}`,
     `Role: ${options.role}`,
     `Primary content type: ${options.primaryContentType}`,
-    `Shared brief: ${options.contentBrief.description}`,
+    `Shared plan: ${options.contentPlan.description}`,
+    planNote,
     anchorNote,
     "",
     "This is a dry-run placeholder for single-prompt channel generation."
@@ -2622,12 +2854,12 @@ var OUTRO_PARAGRAPH_COUNTS = {
   medium: "2 to 3",
   large: "3 to 5"
 };
-function buildSystemInstruction(base, style, intent, contentTypes, targetLengthWords) {
+function buildSystemInstruction(base, style, intent, contentTypes, targetLengthWords, contentType) {
   return [
     base,
-    buildArticleSectionGuideInstruction(style, intent, "article"),
+    buildArticleSectionGuideInstruction(style, intent, contentType),
     buildRunContextDirective(contentTypes),
-    buildTargetLengthDirective("article", targetLengthWords)
+    buildTargetLengthDirective(contentType, targetLengthWords)
   ].join(" ");
 }
 function sharedPlanContext(plan) {
@@ -2657,7 +2889,8 @@ function buildIntroMessages(plan, style, intent, contentTypes, targetLengthWords
     style,
     intent,
     contentTypes,
-    targetLengthWords
+    targetLengthWords,
+    plan.contentType
   );
   const targetLengthAlias = resolveTargetLengthAlias(targetLengthWords);
   const paragraphCount = INTRO_PARAGRAPH_COUNTS[targetLengthAlias] ?? INTRO_PARAGRAPH_COUNTS["medium"];
@@ -2687,7 +2920,8 @@ function buildSectionMessages(plan, section, articleSoFar, style, intent, conten
     style,
     intent,
     contentTypes,
-    targetLengthWords
+    targetLengthWords,
+    plan.contentType
   );
   const targetLengthAlias = resolveTargetLengthAlias(targetLengthWords);
   const paragraphCount = SECTION_PARAGRAPH_COUNTS[targetLengthAlias] ?? SECTION_PARAGRAPH_COUNTS["medium"];
@@ -2721,7 +2955,8 @@ function buildOutroMessages(plan, style, intent, contentTypes, targetLengthWords
     style,
     intent,
     contentTypes,
-    targetLengthWords
+    targetLengthWords,
+    plan.contentType
   );
   const targetLengthAlias = resolveTargetLengthAlias(targetLengthWords);
   const paragraphCount = OUTRO_PARAGRAPH_COUNTS[targetLengthAlias] ?? OUTRO_PARAGRAPH_COUNTS["medium"];
@@ -2876,19 +3111,36 @@ function buildArticleSoFarContext(intro, sections) {
   }
   return parts.join("\n\n").trim();
 }
+function normalizeWhitespaceForHeadingMatch(text) {
+  return text.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function stripMatchingLeadingHeading(content, label2) {
+  const headingMatch = content.match(/^#{1,6}\s+(.+?)(?:\r?\n|$)/);
+  if (!headingMatch) {
+    return content;
+  }
+  const headingText = normalizeWhitespaceForHeadingMatch(headingMatch[1] ?? "");
+  const expectedLabel = normalizeWhitespaceForHeadingMatch(label2);
+  if (headingText !== expectedLabel) {
+    return content;
+  }
+  return content.slice(headingMatch[0].length).trimStart();
+}
 function normalizeGeneratedSection(content, label2) {
   const normalized = content.trim();
   if (!normalized) {
     throw new Error(`The model returned an empty ${label2} draft.`);
   }
-  return normalized.replace(/^```(?:markdown)?\s*/i, "").replace(/```\s*$/i, "").trim();
+  const withoutFences = normalized.replace(/^```(?:markdown)?\s*/i, "").replace(/```\s*$/i, "").trim();
+  return stripMatchingLeadingHeading(withoutFences, label2).trim();
 }
 
 // src/pipeline/runner.ts
 import { Limn } from "@telepat/limn";
 
 // src/images/renderImages.ts
-import { writeFile as writeFile4 } from "fs/promises";
+import { copyFile, mkdir as mkdir4, rename, unlink, writeFile as writeFile4 } from "fs/promises";
+import { createHash } from "crypto";
 import path6 from "path";
 
 // src/llm/prompts/imagePrompt.ts
@@ -2965,6 +3217,39 @@ function sumKnownCosts(values) {
 
 // src/images/renderImages.ts
 var MIN_IMAGE_BYTES = 1024;
+function getLocalSessionArtifactDir(workingDir = process.cwd()) {
+  const hash = createHash("sha256").update(path6.resolve(workingDir)).digest("hex").slice(0, 16);
+  return path6.join(workingDir, ".ideon", "sessions", hash, "limn-artifacts");
+}
+function isNotFoundError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function isCrossDeviceError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "EXDEV";
+}
+async function moveLimnTemporaryArtifact(savedPath) {
+  if (!savedPath || savedPath.trim().length === 0) {
+    return;
+  }
+  const sourcePath = path6.resolve(savedPath);
+  const destinationDir = getLocalSessionArtifactDir(path6.dirname(sourcePath));
+  const destinationPath = path6.join(destinationDir, path6.basename(sourcePath));
+  await mkdir4(destinationDir, { recursive: true });
+  try {
+    await rename(sourcePath, destinationPath);
+    return;
+  } catch (error) {
+    if (isCrossDeviceError(error)) {
+      await copyFile(sourcePath, destinationPath);
+      await unlink(sourcePath);
+      return;
+    }
+    if (isNotFoundError(error)) {
+      return;
+    }
+    throw error;
+  }
+}
 function buildImageSlots(plan, sections, options) {
   const sectionCount = sections.length;
   const slots = [
@@ -3140,12 +3425,14 @@ async function renderExpandedImages({
       continue;
     }
     const family = settings.t2i.modelId;
+    const replicateModelOverride = settings.t2i.replicateModelId;
+    const limnOptions = {
+      aspectRatio: "16:9",
+      ...replicateModelOverride && isReplicateModelIdForFamily(family, replicateModelOverride) ? { replicateModel: replicateModelOverride } : {}
+    };
     const renderStartedAtMs = Date.now();
     try {
-      const result = await limn.generate(prompt.prompt, family, {
-        replicateModel: settings.t2i.modelId,
-        aspectRatio: "16:9"
-      });
+      const result = await limn.generate(prompt.prompt, family, limnOptions);
       const ext = mimeTypeToExtension(result.mimeType);
       const liveFileName = `${prompt.kind === "cover" ? "cover" : `inline-${prompt.anchorAfterSection}`}-${index + 1}.${ext}`;
       const liveOutputPath = path6.join(assetDir, liveFileName);
@@ -3155,6 +3442,7 @@ async function renderExpandedImages({
         );
       }
       await writeFile4(liveOutputPath, result.image);
+      await moveLimnTemporaryArtifact(result.savedPath);
       renderedImages.push({
         ...prompt,
         outputPath: liveOutputPath,
@@ -3716,10 +4004,12 @@ ${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 { createHash as createHash2 } from "crypto";
+import { mkdir as mkdir5, readFile as readFile5, rm as rm2, writeFile as writeFile5 } from "fs/promises";
 import path7 from "path";
+import envPaths3 from "env-paths";
 import { z as z6 } from "zod";
-var STAGE_IDS = ["shared-brief", "planning", "sections", "image-prompts", "images", "output", "links"];
+var STAGE_IDS = ["shared-plan", "planning", "sections", "image-prompts", "images", "output", "links"];
 var generatedArticleSectionSchema = z6.object({
   title: z6.string().min(1),
   body: z6.string().min(1)
@@ -3779,8 +4069,8 @@ var writeSessionStateSchema = z6.object({
   lastCompletedStage: z6.enum(STAGE_IDS).nullable(),
   failedStage: z6.enum(STAGE_IDS).nullable(),
   errorMessage: z6.string().nullable(),
-  contentBrief: contentBriefSchema2.nullable().default(null),
-  plan: articlePlanSchema.nullable(),
+  contentPlan: contentPlanSchema2.nullable().default(null),
+  plan: primaryPlanSchema.nullable(),
   text: z6.object({
     intro: z6.string().min(1),
     sections: z6.array(generatedArticleSectionSchema),
@@ -3794,16 +4084,24 @@ var writeSessionStateSchema = z6.object({
   links: z6.array(linksResultSchema).nullable().default(null),
   artifact: pipelineArtifactSummarySchema.nullable()
 });
+var ideonPaths3 = envPaths3("ideon", { suffix: "" });
+var sessionsDir = path7.join(ideonPaths3.config, "sessions");
+function hashProjectPath(workingDir) {
+  return createHash2("sha256").update(path7.resolve(workingDir)).digest("hex").slice(0, 16);
+}
 function resolveWriteRoot(workingDir) {
-  return path7.join(workingDir, ".ideon", "write");
+  return path7.join(sessionsDir, hashProjectPath(workingDir));
 }
 function resolveStateFilePath(workingDir) {
   return path7.join(resolveWriteRoot(workingDir), "state.json");
 }
+function resolveLegacyStatePath(workingDir) {
+  return path7.join(workingDir, ".ideon", "write", "state.json");
+}
 async function startFreshWriteSession(seed, workingDir = process.cwd()) {
   const writeRoot = resolveWriteRoot(workingDir);
   await rm2(writeRoot, { recursive: true, force: true });
-  await mkdir4(writeRoot, { recursive: true });
+  await mkdir5(writeRoot, { recursive: true });
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const state = {
     version: 1,
@@ -3819,7 +4117,7 @@ async function startFreshWriteSession(seed, workingDir = process.cwd()) {
     lastCompletedStage: null,
     failedStage: null,
     errorMessage: null,
-    contentBrief: null,
+    contentPlan: null,
     plan: null,
     text: null,
     imagePrompts: null,
@@ -3836,7 +4134,18 @@ async function loadWriteSession(workingDir = process.cwd()) {
     const raw = await readFile5(statePath, "utf8");
     return writeSessionStateSchema.parse(JSON.parse(raw));
   } catch (error) {
-    if (isNotFoundError(error)) {
+    if (!isNotFoundError2(error)) {
+      throw error;
+    }
+  }
+  const legacyPath = resolveLegacyStatePath(workingDir);
+  try {
+    const raw = await readFile5(legacyPath, "utf8");
+    const state = writeSessionStateSchema.parse(JSON.parse(raw));
+    await saveWriteSession(state, workingDir);
+    return state;
+  } catch (error) {
+    if (isNotFoundError2(error)) {
       return null;
     }
     throw error;
@@ -3848,7 +4157,7 @@ async function saveWriteSession(state, workingDir = process.cwd()) {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
   const statePath = resolveStateFilePath(workingDir);
-  await mkdir4(path7.dirname(statePath), { recursive: true });
+  await mkdir5(path7.dirname(statePath), { recursive: true });
   await writeFile5(statePath, `${JSON.stringify(next, null, 2)}
 `, "utf8");
   return next;
@@ -3856,7 +4165,7 @@ async function saveWriteSession(state, workingDir = process.cwd()) {
 async function patchWriteSession(patch, workingDir = process.cwd()) {
   const existing = await loadWriteSession(workingDir);
   if (!existing) {
-    throw new Error("No active write session found in .ideon/write/state.json. Start a fresh write first.");
+    throw new Error("No active write session found. Start a fresh write first.");
   }
   const has = (key) => Object.hasOwn(patch, key);
   const merged = {
@@ -3866,7 +4175,7 @@ async function patchWriteSession(patch, workingDir = process.cwd()) {
     lastCompletedStage: has("lastCompletedStage") ? patch.lastCompletedStage ?? null : existing.lastCompletedStage,
     failedStage: has("failedStage") ? patch.failedStage ?? null : existing.failedStage,
     errorMessage: has("errorMessage") ? patch.errorMessage ?? null : existing.errorMessage,
-    contentBrief: has("contentBrief") ? patch.contentBrief ?? null : existing.contentBrief,
+    contentPlan: has("contentPlan") ? patch.contentPlan ?? null : existing.contentPlan,
     plan: has("plan") ? patch.plan ?? null : existing.plan,
     text: has("text") ? patch.text ?? null : existing.text,
     imagePrompts: has("imagePrompts") ? patch.imagePrompts ?? null : existing.imagePrompts,
@@ -3876,34 +4185,30 @@ async function patchWriteSession(patch, workingDir = process.cwd()) {
   };
   return saveWriteSession(merged, workingDir);
 }
-function isNotFoundError(error) {
+function isNotFoundError2(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
 // src/pipeline/runner.ts
-function createInitialStages(options = { isArticlePrimary: true }) {
-  const planningTitle = options.isArticlePrimary ? "Planning Primary Article" : "Planning Primary Content";
-  const planningDetail = options.isArticlePrimary ? "Generating title, slug, section plan, and image slots." : "Defining the primary angle and output intent.";
-  const sectionsTitle = options.isArticlePrimary ? "Writing Sections" : "Generating Primary Content";
-  const sectionsDetail = options.isArticlePrimary ? "Waiting for the approved article plan." : "Waiting for primary content generation to begin.";
+function createInitialStages() {
   return [
     {
-      id: "shared-brief",
-      title: "Planning Shared Brief",
+      id: "shared-plan",
+      title: "Planning Shared Plan",
       status: "running",
       detail: "Generating explicit cross-channel content guidance."
     },
     {
       id: "planning",
-      title: planningTitle,
+      title: "Planning Primary Content",
       status: "pending",
-      detail: planningDetail
+      detail: "Generating title, slug, and content plan for the primary output."
     },
     {
       id: "sections",
-      title: sectionsTitle,
+      title: "Writing Primary Content",
       status: "pending",
-      detail: sectionsDetail
+      detail: "Waiting for the approved primary plan."
     },
     {
       id: "image-prompts",
@@ -3937,8 +4242,7 @@ async function runPipelineShell(input, options = {}) {
   const runId = randomUUID();
   const primaryTarget = getPrimaryTarget(input.config.settings.contentTargets);
   const secondaryTargets = getSecondaryTargets(input.config.settings.contentTargets);
-  const isArticlePrimary = primaryTarget.contentType === "article";
-  const stages = createInitialStages({ isArticlePrimary });
+  const stages = createInitialStages();
   options.onUpdate?.(cloneStages(stages));
   const dryRun = options.dryRun ?? false;
   const shouldEnrichLinks = options.enrichLinks ?? false;
@@ -3947,12 +4251,11 @@ async function runPipelineShell(input, options = {}) {
   const pipelineCustomLinkRaws = options.customLinks ?? [];
   const pipelineUnlinks = options.unlinks ?? [];
   const pipelineMaxLinks = options.maxLinks;
-  const outputPaths = resolveOutputPaths(input.config.settings, workingDir);
-  const hasArticlePrimary = isArticlePrimary;
+  const outputPaths = resolveOutputPaths();
   const stageTracking = /* @__PURE__ */ new Map();
   const stageRetryState = /* @__PURE__ */ new Map();
   const llmOperationRetryState = /* @__PURE__ */ new Map();
-  stageTracking.set("shared-brief", {
+  stageTracking.set("shared-plan", {
     startedAtMs: runStartedAtMs,
     endedAtMs: null,
     retries: 0,
@@ -4016,7 +4319,7 @@ async function runPipelineShell(input, options = {}) {
   } else {
     const existing = await loadWriteSession(workingDir);
     if (!existing) {
-      throw new Error("No resumable write session found in .ideon/write/state.json. Start a fresh write first.");
+      throw new Error("No resumable write session found. Start a fresh write first.");
     }
     if (existing.status === "completed") {
     }
@@ -4032,24 +4335,24 @@ async function runPipelineShell(input, options = {}) {
       replicateApiKey: requireSecret(input.config.secrets.replicateApiToken, "Replicate API token"),
       openrouterModel: input.config.settings.model
     });
-    let contentBrief = writeSession.contentBrief;
+    let contentPlan = writeSession.contentPlan;
     let plan = writeSession.plan;
     let text = writeSession.text;
     let imagePrompts = writeSession.imagePrompts ?? writeSession.imageArtifacts?.imagePrompts ?? null;
     let imageArtifacts = writeSession.imageArtifacts;
     let linksResult = writeSession.links;
     let primaryMarkdownTemplate = null;
-    if (contentBrief) {
-      markStageCompleted(stageTracking, "shared-brief");
+    if (contentPlan) {
+      markStageCompleted(stageTracking, "shared-plan");
       stages[0] = {
         ...stages[0],
         status: "succeeded",
-        detail: "Reused saved shared brief from .ideon/write.",
-        summary: contentBrief.title,
-        stageAnalytics: snapshotStageAnalytics(stageTracking, "shared-brief")
+        detail: "Reused saved shared plan from cached session.",
+        summary: contentPlan.title,
+        stageAnalytics: snapshotStageAnalytics(stageTracking, "shared-plan")
       };
     } else {
-      contentBrief = await planContentBrief({
+      contentPlan = await planContentPlan({
         idea: input.idea,
         targetAudienceHint: input.targetAudienceHint,
         settings: input.config.settings,
@@ -4059,88 +4362,91 @@ async function runPipelineShell(input, options = {}) {
           onLlmInteraction(interaction);
         },
         onLlmMetrics(metrics) {
-          recordLlmMetrics(stageTracking, "shared-brief", metrics);
+          recordLlmMetrics(stageTracking, "shared-plan", metrics);
         }
       });
-      markStageCompleted(stageTracking, "shared-brief");
+      markStageCompleted(stageTracking, "shared-plan");
       stages[0] = {
         ...stages[0],
         status: "succeeded",
-        detail: "Shared brief generated successfully.",
-        summary: contentBrief.title,
-        stageAnalytics: snapshotStageAnalytics(stageTracking, "shared-brief")
+        detail: "Shared plan generated successfully.",
+        summary: contentPlan.title,
+        stageAnalytics: snapshotStageAnalytics(stageTracking, "shared-plan")
       };
       writeSession = await patchWriteSession(
         {
           status: "running",
-          lastCompletedStage: "shared-brief",
+          lastCompletedStage: "shared-plan",
           failedStage: null,
           errorMessage: null,
-          contentBrief
+          contentPlan
         },
         workingDir
       );
     }
-    if (hasArticlePrimary) {
+    stages[1] = {
+      ...stages[1],
+      status: "running",
+      detail: `Planning primary ${primaryTarget.contentType} content.`
+    };
+    markStageStarted(stageTracking, "planning");
+    options.onUpdate?.(cloneStages(stages));
+    if (plan) {
+      markStageCompleted(stageTracking, "planning");
       stages[1] = {
         ...stages[1],
-        status: "running",
-        detail: "Generating title, slug, section plan, and image slots."
+        status: "succeeded",
+        detail: "Reused saved plan from cached session.",
+        summary: buildPlanSummary(plan),
+        stageAnalytics: snapshotStageAnalytics(stageTracking, "planning")
       };
-      markStageStarted(stageTracking, "planning");
-      options.onUpdate?.(cloneStages(stages));
-      if (plan) {
-        markStageCompleted(stageTracking, "planning");
-        stages[1] = {
-          ...stages[1],
-          status: "succeeded",
-          detail: "Reused saved plan from .ideon/write.",
-          summary: `${plan.title} \u2022 ${plan.slug} \u2022 ${plan.sections.length} sections \u2022 ${plan.inlineImages.length + 1} images`,
-          stageAnalytics: snapshotStageAnalytics(stageTracking, "planning")
-        };
-      } else {
-        if (!contentBrief) {
-          throw new Error("Shared content brief is missing for article planning stage.");
-        }
-        plan = await planArticle({
-          idea: input.idea,
-          contentBrief,
-          settings: input.config.settings,
-          markdownOutputDir: writeSession.outputPaths.markdownOutputDir,
-          openRouter,
-          dryRun,
-          onInteraction(interaction) {
-            onLlmInteraction(interaction);
-          },
-          onLlmMetrics(metrics) {
-            recordLlmMetrics(stageTracking, "planning", metrics);
-          }
-        });
-        markStageCompleted(stageTracking, "planning");
-        stages[1] = {
-          ...stages[1],
-          status: "succeeded",
-          detail: "Plan generated successfully.",
-          summary: `${plan.title} \u2022 ${plan.slug} \u2022 ${plan.sections.length} sections \u2022 ${plan.inlineImages.length + 1} images`,
-          stageAnalytics: snapshotStageAnalytics(stageTracking, "planning")
-        };
-        writeSession = await patchWriteSession(
-          {
-            status: "running",
-            lastCompletedStage: "planning",
-            failedStage: null,
-            errorMessage: null,
-            contentBrief,
-            plan
-          },
-          workingDir
-        );
+    } else {
+      if (!contentPlan) {
+        throw new Error("Shared content plan is missing for primary planning stage.");
       }
+      plan = await planPrimaryContent({
+        idea: input.idea,
+        contentType: primaryTarget.contentType,
+        contentPlan,
+        settings: input.config.settings,
+        markdownOutputDir: writeSession.outputPaths.markdownOutputDir,
+        openRouter,
+        dryRun,
+        onInteraction(interaction) {
+          onLlmInteraction(interaction);
+        },
+        onLlmMetrics(metrics) {
+          recordLlmMetrics(stageTracking, "planning", metrics);
+        }
+      });
+      markStageCompleted(stageTracking, "planning");
+      stages[1] = {
+        ...stages[1],
+        status: "succeeded",
+        detail: "Plan generated successfully.",
+        summary: buildPlanSummary(plan),
+        stageAnalytics: snapshotStageAnalytics(stageTracking, "planning")
+      };
+      writeSession = await patchWriteSession(
+        {
+          status: "running",
+          lastCompletedStage: "planning",
+          failedStage: null,
+          errorMessage: null,
+          contentPlan,
+          plan
+        },
+        workingDir
+      );
+    }
+    const isLongForm = isLongFormPlan(plan);
+    if (isLongForm) {
+      const longPlan = plan;
       stages[2] = {
         ...stages[2],
         status: "running",
         detail: "Writing introduction.",
-        items: buildSectionItems(plan.sections.map((section) => section.title))
+        items: buildSectionItems(longPlan.sections.map((section) => section.title))
       };
       markStageStarted(stageTracking, "sections");
       options.onUpdate?.(cloneStages(stages));
@@ -4149,12 +4455,12 @@ async function runPipelineShell(input, options = {}) {
         stages[2] = {
           ...stages[2],
           status: "succeeded",
-          detail: "Reused saved section drafts from .ideon/write.",
+          detail: "Reused saved section drafts from cached session.",
           summary: `Intro + ${text.sections.length} sections + conclusion`,
           items: (stages[2].items ?? []).map((item) => ({
             ...item,
             status: "succeeded",
-            detail: "Reused saved section draft from .ideon/write."
+            detail: "Reused saved section draft from cached session."
           })),
           stageAnalytics: snapshotStageAnalytics(stageTracking, "sections")
         };
@@ -4168,7 +4474,7 @@ async function runPipelineShell(input, options = {}) {
       } else {
         const sectionItemTracking = /* @__PURE__ */ new Map();
         text = await writeArticleSections({
-          plan,
+          plan: longPlan,
           settings: input.config.settings,
           openRouter,
           dryRun,
@@ -4268,7 +4574,7 @@ async function runPipelineShell(input, options = {}) {
         stages[3] = {
           ...stages[3],
           status: "succeeded",
-          detail: "Reused saved image prompts from .ideon/write.",
+          detail: "Reused saved image prompts from cached session.",
           summary: `${imagePrompts.length} prompts ready`,
           stageAnalytics: snapshotStageAnalytics(stageTracking, "image-prompts")
         };
@@ -4281,8 +4587,8 @@ async function runPipelineShell(input, options = {}) {
         options.onUpdate?.(cloneStages(stages));
       } else {
         imagePrompts = await expandImagePrompts({
-          slots: buildImageSlots(plan, text.sections, { maxImages: options.maxImages }),
-          planContext: plan,
+          slots: buildImageSlots(longPlan, text.sections, { maxImages: options.maxImages }),
+          planContext: longPlan,
           sections: text.sections,
           settings: input.config.settings,
           openRouter,
@@ -4343,24 +4649,6 @@ async function runPipelineShell(input, options = {}) {
         );
       }
     } else {
-      if (!contentBrief) {
-        throw new Error("Shared content brief is missing for primary content planning stage.");
-      }
-      stages[1] = {
-        ...stages[1],
-        status: "running",
-        detail: `Defining primary direction for ${primaryTarget.contentType}.`
-      };
-      markStageStarted(stageTracking, "planning");
-      options.onUpdate?.(cloneStages(stages));
-      markStageCompleted(stageTracking, "planning");
-      stages[1] = {
-        ...stages[1],
-        status: "succeeded",
-        detail: `Primary direction locked for ${primaryTarget.contentType}.`,
-        summary: `Primary: ${primaryTarget.contentType}`,
-        stageAnalytics: snapshotStageAnalytics(stageTracking, "planning")
-      };
       stages[2] = {
         ...stages[2],
         status: "running",
@@ -4378,7 +4666,8 @@ async function runPipelineShell(input, options = {}) {
         outputIndex: 1,
         outputCountForType: 1,
         articleReferenceMarkdown: void 0,
-        contentBrief,
+        contentPlan,
+        plan,
         settings: input.config.settings,
         openRouter,
         dryRun,
@@ -4404,7 +4693,7 @@ async function runPipelineShell(input, options = {}) {
       };
       markStageStarted(stageTracking, "image-prompts");
       options.onUpdate?.(cloneStages(stages));
-      imagePrompts = [buildPrimaryCoverPrompt(contentBrief, primaryTarget.contentType, primaryMarkdownTemplate)];
+      imagePrompts = [buildPrimaryCoverPrompt(plan, contentPlan, primaryTarget.contentType)];
       markStageCompleted(stageTracking, "image-prompts");
       stages[3] = {
         ...stages[3],
@@ -4426,12 +4715,12 @@ async function runPipelineShell(input, options = {}) {
       };
       options.onUpdate?.(cloneStages(stages));
     }
-    const baseSlug = plan?.slug ?? slugifyIdea(input.idea);
+    const baseSlug = plan?.slug ?? resolveGenerationSlug(input.idea, contentPlan?.title);
     const generationDir = path8.join(
       writeSession.outputPaths.markdownOutputDir,
       buildGenerationDirectoryName(baseSlug)
     );
-    await mkdir5(generationDir, { recursive: true });
+    await mkdir6(generationDir, { recursive: true });
     const jobDefinitionPath = path8.join(generationDir, "job.json");
     await writeJsonFile(
       jobDefinitionPath,
@@ -4451,13 +4740,14 @@ async function runPipelineShell(input, options = {}) {
     const primaryFilePrefix = toFilePrefix(primaryTarget.contentType);
     const primaryMarkdownPath = path8.join(generationDir, `${primaryFilePrefix}-1.md`);
     const sharedAssetDir = generationDir;
-    if (hasArticlePrimary) {
+    if (isLongForm) {
+      const longPlan = plan;
       if (imageArtifacts) {
         markStageCompleted(stageTracking, "images");
         stages[4] = {
           ...stages[4],
           status: "succeeded",
-          detail: "Reused previously rendered images from .ideon/write.",
+          detail: "Reused previously rendered images from cached session.",
           summary: sharedAssetDir,
           stageAnalytics: snapshotStageAnalytics(stageTracking, "images")
         };
@@ -4527,7 +4817,7 @@ async function runPipelineShell(input, options = {}) {
         throw new Error("Article generation requested but required article artifacts are missing.");
       }
       const article = {
-        plan,
+        plan: longPlan,
         intro: text.intro,
         sections: text.sections,
         outro: text.outro,
@@ -4544,7 +4834,7 @@ async function runPipelineShell(input, options = {}) {
         stages[4] = {
           ...stages[4],
           status: "succeeded",
-          detail: "Reused previously rendered primary cover image from .ideon/write.",
+          detail: "Reused previously rendered primary cover image from cached session.",
           summary: sharedAssetDir,
           stageAnalytics: snapshotStageAnalytics(stageTracking, "images")
         };
@@ -4612,11 +4902,11 @@ async function runPipelineShell(input, options = {}) {
       }
       const coverImage = imageArtifacts?.renderedImages.find((image) => image.kind === "cover") ?? null;
       if (coverImage) {
-        primaryMarkdownTemplate = withCoverImage(primaryMarkdownTemplate, coverImage.relativePath, deriveTitleFromIdea2(input.idea));
+        primaryMarkdownTemplate = withCoverImage(primaryMarkdownTemplate, coverImage.relativePath, plan.title || deriveTitleFromIdea2(input.idea));
       }
       primaryMarkdownTemplate = applyPrimaryTitleHeading(
         primaryMarkdownTemplate,
-        contentBrief.title || deriveTitleFromIdea2(input.idea)
+        plan.title || contentPlan.title || deriveTitleFromIdea2(input.idea)
       );
     }
     const markdownPaths = [];
@@ -4646,8 +4936,8 @@ async function runPipelineShell(input, options = {}) {
     };
     markStageStarted(stageTracking, "output");
     options.onUpdate?.(cloneStages(stages));
-    if (!contentBrief) {
-      throw new Error("Shared content brief is missing for output generation stage.");
+    if (!contentPlan) {
+      throw new Error("Shared content plan is missing for output generation stage.");
     }
     for (const output of requestedOutputs) {
       const itemId = toOutputItemId(output.filePrefix, output.index);
@@ -4682,7 +4972,8 @@ async function runPipelineShell(input, options = {}) {
           outputIndex: output.index,
           outputCountForType: output.outputCountForType,
           articleReferenceMarkdown: primaryMarkdownTemplate ?? void 0,
-          contentBrief,
+          contentPlan,
+          plan,
           settings: input.config.settings,
           openRouter,
           dryRun,
@@ -4827,7 +5118,7 @@ async function runPipelineShell(input, options = {}) {
       stages[6] = {
         ...stages[6],
         status: "succeeded",
-        detail: "Reused saved link metadata from .ideon/write.",
+        detail: "Reused saved link metadata from cached session.",
         summary: `${resumedLinks.reduce((sum, item) => sum + item.links.length, 0)} links`,
         items: (stages[6].items ?? []).map((item) => ({
           ...item,
@@ -4841,8 +5132,8 @@ async function runPipelineShell(input, options = {}) {
       const itemTracking = /* @__PURE__ */ new Map();
       linksResult = await enrichLinks({
         markdownFiles: eligibleOutputsForLinks,
-        articleTitle: plan?.title ?? contentBrief.title ?? deriveTitleFromIdea2(input.idea),
-        articleDescription: plan?.description ?? contentBrief.description,
+        articleTitle: plan?.title ?? contentPlan.title ?? deriveTitleFromIdea2(input.idea),
+        articleDescription: plan?.description ?? contentPlan.description,
         openRouter,
         settings: input.config.settings,
         dryRun,
@@ -4955,8 +5246,8 @@ async function runPipelineShell(input, options = {}) {
     await writeJsonFile(interactionsPath, interactions);
     const primaryMarkdownPathForArtifact = markdownPaths[0] ?? primaryMarkdownPath;
     const artifact = {
-      title: plan?.title ?? contentBrief.title ?? deriveTitleFromIdea2(input.idea),
-      slug: plan?.slug ?? slugifyIdea(input.idea),
+      title: plan?.title ?? contentPlan.title ?? deriveTitleFromIdea2(input.idea),
+      slug: plan?.slug ?? resolveGenerationSlug(input.idea, contentPlan?.title),
       sectionCount: text?.sections.length ?? 0,
       imageCount: imageArtifacts?.renderedImages.length ?? 0,
       outputCount: markdownPaths.length,
@@ -5065,7 +5356,7 @@ function buildRunAnalytics({
   linkEnrichmentCalls
 }) {
   const runEndedAtMs = Date.now();
-  const orderedStageIds = ["shared-brief", "planning", "sections", "image-prompts", "images", "output", "links"];
+  const orderedStageIds = ["shared-plan", "planning", "sections", "image-prompts", "images", "output", "links"];
   const stages = orderedStageIds.map((stageId) => {
     const tracked = stageTracking.get(stageId);
     const startedAtMs = tracked?.startedAtMs ?? runEndedAtMs;
@@ -5282,20 +5573,19 @@ function getSecondaryTargets(contentTargets) {
     count: target.count
   }));
 }
-function buildPrimaryCoverPrompt(contentBrief, primaryContentType, primaryMarkdown) {
-  const markdownExcerpt = primaryMarkdown.replace(/\s+/g, " ").trim().slice(0, 240);
+function buildPrimaryCoverPrompt(plan, contentPlan, primaryContentType) {
   return {
     id: "cover",
     kind: "cover",
-    description: `Cover image for ${primaryContentType}`,
+    description: plan.coverImageDescription,
     anchorAfterSection: null,
     prompt: [
-      `Cover image for ${primaryContentType}.`,
-      `Core angle: ${contentBrief.description}`,
-      `Audience: ${contentBrief.targetAudience}`,
-      `Promise: ${contentBrief.corePromise}`,
-      `Voice: ${contentBrief.voiceNotes}`,
-      `Primary excerpt: ${markdownExcerpt}`,
+      plan.coverImageDescription,
+      `Content type: ${primaryContentType}`,
+      `Core angle: ${contentPlan.description}`,
+      `Audience: ${contentPlan.targetAudience}`,
+      `Promise: ${contentPlan.corePromise}`,
+      `Voice: ${contentPlan.voiceNotes}`,
       "Do not include any words, letters, numbers, logos, watermarks, or signage in the image."
     ].join(" ")
   };
@@ -5329,8 +5619,18 @@ function deriveTitleFromIdea2(idea) {
   }
   return normalized.split(/\s+/).slice(0, 8).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
 }
-function slugifyIdea(idea) {
-  return idea.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "generated-content";
+function slugifyIdea(idea, maxLength) {
+  const slug = idea.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "generated-content";
+  if (maxLength !== void 0 && slug.length > maxLength) {
+    return slug.slice(0, maxLength).replace(/-+$/, "");
+  }
+  return slug;
+}
+function resolveGenerationSlug(idea, planTitle) {
+  if (planTitle) {
+    return slugifyIdea(planTitle);
+  }
+  return slugifyIdea(idea, 80);
 }
 function buildRunJobDefinition(input) {
   return {
@@ -5349,46 +5649,63 @@ function buildRunJobDefinition(input) {
   };
 }
 function renderPlanMarkdown(plan) {
-  const yamlKeywords = plan.keywords.map((kw) => `  - "${kw}"`).join("\n");
-  const sectionsRows = plan.sections.map((section, index) => `| ${index + 1} | ${section.title} | ${section.description} |`).join("\n");
-  const inlineImageRows = plan.inlineImages.map((img, index) => `| Inline ${index + 1} | ${img.description} |`).join("\n");
-  const imageRows = `| Cover | ${plan.coverImageDescription} |
-${inlineImageRows}`;
-  return `---
-title: "${plan.title.replace(/"/g, '\\"')}"
-subtitle: "${plan.subtitle.replace(/"/g, '\\"')}"
-slug: "${plan.slug}"
-keywords:
-${yamlKeywords}
----
-
-## Description
-
-${plan.description}
-
-## Introduction Brief
-
-${plan.introBrief}
-
-## Sections
-
-| # | Title | Description |
-|---|-------|-------------|
-${sectionsRows}
-
-## Outro Brief
-
-${plan.outroBrief}
-
-## Image Plan
-
-| Type | Description |
-|------|-------------|
-${imageRows}
-`;
+  const lines = [
+    `# ${plan.title}`,
+    "",
+    `**Content type:** ${plan.contentType}`,
+    `**Slug:** ${plan.slug}`,
+    "",
+    "## Description",
+    "",
+    plan.description,
+    ""
+  ];
+  if (plan.subtitle) {
+    lines.push("## Subtitle", "", plan.subtitle, "");
+  }
+  if (plan.keywords && plan.keywords.length > 0) {
+    lines.push("## Keywords", "", ...plan.keywords.map((kw) => `- ${kw}`), "");
+  }
+  if (plan.introBrief) {
+    lines.push("## Introduction Brief", "", plan.introBrief, "");
+  }
+  if (plan.sections && plan.sections.length > 0) {
+    lines.push("## Sections", "", "| # | Title | Description |", "|---|-------|-------------|");
+    plan.sections.forEach((section, index) => {
+      lines.push(`| ${index + 1} | ${section.title} | ${section.description} |`);
+    });
+    lines.push("");
+  }
+  if (plan.outroBrief) {
+    lines.push("## Outro Brief", "", plan.outroBrief, "");
+  }
+  if (plan.angle) {
+    lines.push("## Angle", "", plan.angle, "");
+  }
+  lines.push("## Image Plan", "");
+  lines.push(`- **Cover:** ${plan.coverImageDescription}`);
+  if (plan.inlineImages && plan.inlineImages.length > 0) {
+    plan.inlineImages.forEach((img, index) => {
+      lines.push(`- **Inline ${index + 1}:** ${img.description} (after section ${img.anchorAfterSection})`);
+    });
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function buildPlanSummary(plan) {
+  const parts = [plan.title, plan.slug];
+  if (plan.sections && plan.sections.length > 0) {
+    parts.push(`${plan.sections.length} sections`);
+  }
+  if (plan.inlineImages && plan.inlineImages.length > 0) {
+    parts.push(`${plan.inlineImages.length + 1} images`);
+  } else {
+    parts.push("1 image");
+  }
+  return parts.join(" \u2022 ");
 }
 function asWriteStageId(stageId) {
-  if (stageId === "shared-brief" || stageId === "planning" || stageId === "sections" || stageId === "image-prompts" || stageId === "images" || stageId === "output" || stageId === "links") {
+  if (stageId === "shared-plan" || stageId === "planning" || stageId === "sections" || stageId === "image-prompts" || stageId === "images" || stageId === "output" || stageId === "links") {
     return stageId;
   }
   return null;
@@ -5423,7 +5740,7 @@ async function runLinksCommand(options, dependencies = {}) {
   const resolved = await resolveRunInput({
     idea: `Enrich links for ${slug}`
   });
-  const markdownPath = await resolveMarkdownPathForSlug2(resolved.config.settings, slug, cwd2);
+  const markdownPath = await resolveMarkdownPathForSlug2(slug, cwd2);
   const frontmatter = await readFrontmatter(markdownPath);
   const fileId = path9.parse(markdownPath).name;
   const articleTitle = frontmatter.title ?? toTitleFromSlug(slug);
@@ -5493,8 +5810,8 @@ function normalizeSlug2(rawSlug) {
   }
   return slug;
 }
-async function resolveMarkdownPathForSlug2(settings, slug, cwd2) {
-  const outputPaths = resolveOutputPaths(settings, cwd2);
+async function resolveMarkdownPathForSlug2(slug, cwd2) {
+  const outputPaths = resolveOutputPaths();
   const directPath = path9.join(outputPaths.markdownOutputDir, `${slug}.md`);
   if (await isReadableFile(directPath)) {
     return directPath;
@@ -5675,7 +5992,7 @@ function resolveCustomLinks(existing, addRaw, removeExpressions) {
 }
 
 // src/cli/commands/export.ts
-import { copyFile, mkdir as mkdir6, readFile as readFile8, stat as stat5, writeFile as writeFile6 } from "fs/promises";
+import { copyFile as copyFile2, mkdir as mkdir7, readFile as readFile8, stat as stat5, writeFile as writeFile6 } from "fs/promises";
 import path11 from "path";
 
 // src/output/enrichMarkdownWithLinks.ts
@@ -6002,7 +6319,7 @@ async function runOutputCommand(options, dependencies = {}) {
   const log = dependencies.log ?? ((message) => console.log(message));
   const targetIndex = options.index ?? 1;
   const resolved = await resolveRunInput({ idea: `Export generation ${options.generationId}` });
-  const outputPaths = resolveOutputPaths(resolved.config.settings, cwd2);
+  const outputPaths = resolveOutputPaths();
   const generations = await listAllGenerations(outputPaths.markdownOutputDir);
   const generation = resolveGeneration(generations, options.generationId);
   const articleOutputs = generation.outputs.filter((output) => output.contentType === generation.primaryContentType);
@@ -6029,7 +6346,7 @@ async function runOutputCommand(options, dependencies = {}) {
       `Export file already exists: ${destinationFilePath}. Pass --overwrite to replace it.`
     );
   }
-  await mkdir6(destinationDir, { recursive: true });
+  await mkdir7(destinationDir, { recursive: true });
   const links = await loadLinks(sourceMarkdownPath);
   const enrichedMarkdown = enrichWithFrontmatterGuard(sourceMarkdown, links);
   const sourceDir = path11.dirname(sourceMarkdownPath);
@@ -6049,8 +6366,8 @@ async function runOutputCommand(options, dependencies = {}) {
       throw new ReportedError(`Referenced image path is not a file: ${absoluteImageSrc}.`);
     }
     const destImagePath = path11.join(destinationDir, relImagePath);
-    await mkdir6(path11.dirname(destImagePath), { recursive: true });
-    await copyFile(absoluteImageSrc, destImagePath);
+    await mkdir7(path11.dirname(destImagePath), { recursive: true });
+    await copyFile2(absoluteImageSrc, destImagePath);
     copiedImages.push(relImagePath);
   }
   await writeFile6(destinationFilePath, enrichedMarkdown, "utf8");
@@ -6301,7 +6618,7 @@ async function startIdeonMcpServer() {
       try {
         const session = await loadWriteSession(cwd());
         if (!session) {
-          throw new ReportedError("No resumable write session found in .ideon/write/state.json.");
+          throw new ReportedError("No resumable write session found.");
         }
         if (session.status === "completed") {
           throw new ReportedError("The last write session already completed.");
@@ -6611,12 +6928,6 @@ import { Box, Text, useApp, useInput } from "ink";
 import SelectInput from "ink-select-input";
 import TextInput from "ink-text-input";
 
-// src/images/limnModelCatalog.ts
-import { getSupportedModelCatalog } from "@telepat/limn";
-function getLimnGenerationModels() {
-  return getSupportedModelCatalog().filter((entry) => entry.generationEnabled);
-}
-
 // src/cli/flows/settingsFlowLogic.ts
 function handleMenuSelect(action, settings, secrets, setEditing, setShowModelSelect, setMenuMode, onDone, exit) {
   switch (action) {
@@ -6641,12 +6952,6 @@ function handleMenuSelect(action, settings, secrets, setEditing, setShowModelSel
     case "topP":
       setEditing({ key: action, label: "Top p", value: String(settings.modelSettings.topP) });
       return;
-    case "markdownOutputDir":
-      setEditing({ key: action, label: "Markdown output directory", value: settings.markdownOutputDir });
-      return;
-    case "assetOutputDir":
-      setEditing({ key: action, label: "Asset output directory", value: settings.assetOutputDir });
-      return;
     case "t2i-settings":
       setMenuMode("t2i");
       return;
@@ -6660,6 +6965,13 @@ function handleMenuSelect(action, settings, secrets, setEditing, setShowModelSel
         value: JSON.stringify(settings.t2i.inputOverrides, null, 2)
       });
       return;
+    case "t2i-replicate-model-id":
+      setEditing({
+        key: action,
+        label: "T2I Replicate model ID override (blank to clear)",
+        value: settings.t2i.replicateModelId ?? ""
+      });
+      return;
     case "t2i-back":
       setMenuMode("main");
       return;
@@ -6730,14 +7042,6 @@ function applyEdit(action, value2, settings, secrets, setSettings, setSecrets) {
     });
     return true;
   }
-  if (action === "markdownOutputDir") {
-    setSettings({ ...settings, markdownOutputDir: value2.trim() || settings.markdownOutputDir });
-    return true;
-  }
-  if (action === "assetOutputDir") {
-    setSettings({ ...settings, assetOutputDir: value2.trim() || settings.assetOutputDir });
-    return true;
-  }
   if (action === "t2i-input-overrides") {
     const trimmed = value2.trim();
     if (trimmed.length === 0) {
@@ -6767,6 +7071,17 @@ function applyEdit(action, value2, settings, secrets, setSettings, setSecrets) {
       return false;
     }
   }
+  if (action === "t2i-replicate-model-id") {
+    const trimmed = value2.trim();
+    setSettings({
+      ...settings,
+      t2i: {
+        ...settings.t2i,
+        replicateModelId: trimmed.length > 0 ? trimmed : void 0
+      }
+    });
+    return true;
+  }
   return false;
 }
 function parseNumberOrFallback(value2, fallback) {
@@ -6821,12 +7136,19 @@ function SettingsFlow({ initialSettings, initialSecrets, onDone }) {
     const count = Object.keys(overrides).length;
     return count === 0 ? "none" : `${count} override${count === 1 ? "" : "s"}`;
   };
+  const formatReplicateOverrideSummary = (replicateModelId) => {
+    return replicateModelId && replicateModelId.length > 0 ? replicateModelId : "auto";
+  };
   const menuItems = useMemo(() => {
     const t2iSubmenu = [
       {
         label: `T2I model: ${currentModelEntry?.displayName ?? settings.t2i.modelId}`,
         value: "t2i-model"
       },
+      {
+        label: `T2I Replicate model override: ${formatReplicateOverrideSummary(settings.t2i.replicateModelId)}`,
+        value: "t2i-replicate-model-id"
+      },
       {
         label: `T2I input overrides: ${formatT2iOverridesSummary(settings.t2i.inputOverrides)}`,
         value: "t2i-input-overrides"
@@ -6868,14 +7190,6 @@ function SettingsFlow({ initialSettings, initialSecrets, onDone }) {
         label: `Top p: ${settings.modelSettings.topP}`,
         value: "topP"
       },
-      {
-        label: `Markdown output directory: ${settings.markdownOutputDir}`,
-        value: "markdownOutputDir"
-      },
-      {
-        label: `Asset output directory: ${settings.assetOutputDir}`,
-        value: "assetOutputDir"
-      },
       {
         label: `T2I settings: ${currentModelEntry?.displayName ?? settings.t2i.modelId}`,
         value: "t2i-settings"
@@ -6907,6 +7221,7 @@ function SettingsFlow({ initialSettings, initialSecrets, onDone }) {
               ...current,
               t2i: {
                 modelId: item.value,
+                replicateModelId: current.t2i.replicateModelId && isReplicateModelIdForFamily(item.value, current.t2i.replicateModelId) ? current.t2i.replicateModelId : void 0,
                 inputOverrides: {}
               }
             }));
@@ -8312,7 +8627,7 @@ function renderShell({
       const articleListElement = document.getElementById('articleList');
       const themeToggleButton = document.getElementById('themeToggle');
       const typeOrder = ['article', 'blog-post', 'x-thread', 'x-post', 'linkedin-post', 'reddit-post', 'newsletter'];
-      const stageOrder = ['shared-brief', 'planning', 'sections', 'image-prompts', 'images', 'output', 'links'];
+      const stageOrder = ['shared-plan', 'planning', 'sections', 'image-prompts', 'images', 'output', 'links'];
 
       let currentGeneration = null;
       let activeType = '';
@@ -8889,13 +9204,7 @@ function escapeHtml(value2) {
 
 // src/cli/commands/serve.ts
 async function runServeCommand(options) {
-  const [savedSettings, envSettings] = await Promise.all([loadSavedSettings(), Promise.resolve(readEnvSettings())]);
-  const mergedSettings = appSettingsSchema.parse({
-    ...savedSettings,
-    ...envSettings.markdownOutputDir ? { markdownOutputDir: envSettings.markdownOutputDir } : {},
-    ...envSettings.assetOutputDir ? { assetOutputDir: envSettings.assetOutputDir } : {}
-  });
-  const outputPaths = resolveOutputPaths(mergedSettings);
+  const outputPaths = resolveOutputPaths();
   const markdownPath = await resolveMarkdownPath(options.markdownPath, outputPaths.markdownOutputDir, process.cwd());
   const port = parsePort(options.port);
   if (options.watch) {
@@ -8974,7 +9283,7 @@ function formatStageCost(costUsd, costSource) {
   return costSource === "estimated" ? `~${formatted}` : formatted;
 }
 function formatStageId(stageId) {
-  if (stageId === "shared-brief") return "shared-brief";
+  if (stageId === "shared-plan") return "shared-plan";
   if (stageId === "planning") return "planning";
   if (stageId === "sections") return "sections";
   if (stageId === "image-prompts") return "image-prompts";
@@ -9796,9 +10105,7 @@ function WriteApp({
 }) {
   const { exit } = useApp3();
   const [stages, setStages] = useState4(
-    () => createInitialStages({
-      isArticlePrimary: input.config.settings.contentTargets.some((target) => target.role === "primary" && target.contentType === "article")
-    })
+    () => createInitialStages()
   );
   const [result, setResult] = useState4(null);
   const [errorMessage, setErrorMessage] = useState4(null);
@@ -9872,7 +10179,7 @@ async function runWriteCommand(options) {
 async function runWriteResumeCommand(options = {}) {
   const session = await loadWriteSession();
   if (!session) {
-    throw new ReportedError("No resumable write session found in .ideon/write/state.json. Run ideon write <idea> first.");
+    throw new ReportedError("No resumable write session found. Run ideon write <idea> first.");
   }
   if (session.status === "completed") {
     throw new ReportedError("The last write session already completed. Run ideon write <idea> to start fresh.");
@@ -10169,7 +10476,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 (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).option("--link <pair>", 'Custom link "expression->url", repeatable', collectOptionValue).option("--unlink <expression>", "Remove a custom link by expression, repeatable", collectOptionValue).option("--max-links <n>", "Max number of generated links", (v) => Number.parseInt(v, 10)).option("--max-images <n>", "Max total images including cover (1=cover only, 2=cover+1 inline, 3=cover+2 inline)", (v) => Number.parseInt(v, 10)).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-plan 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).option("--link <pair>", 'Custom link "expression->url", repeatable', collectOptionValue).option("--unlink <expression>", "Remove a custom link by expression, repeatable", collectOptionValue).option("--max-links <n>", "Max number of generated links", (v) => Number.parseInt(v, 10)).option("--max-images <n>", "Max total images including cover (1=cover only, 2=cover+1 inline, 3=cover+2 inline)", (v) => Number.parseInt(v, 10)).action(async (ideaArg, options) => {
     await runWriteCommand({
       idea: options.idea ?? ideaArg,
       audience: options.audience,
@@ -10188,7 +10495,7 @@ async function runCli(argv) {
       maxImages: options.maxImages
     });
   });
-  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).option("--link <pair>", 'Custom link "expression->url", repeatable', collectOptionValue).option("--unlink <expression>", "Remove a custom link by expression, repeatable", collectOptionValue).option("--max-links <n>", "Max number of generated links", (v) => Number.parseInt(v, 10)).option("--max-images <n>", "Max total images including cover (1=cover only, 2=cover+1 inline, 3=cover+2 inline)", (v) => Number.parseInt(v, 10)).action(async (options) => {
+  writeCommand.command("resume").description("Resume the last failed or interrupted write session.").option("--no-interactive", "Force plain non-interactive output even in TTY mode", false).option("--enrich-links", "Run link enrichment after markdown generation", false).option("--link <pair>", 'Custom link "expression->url", repeatable', collectOptionValue).option("--unlink <expression>", "Remove a custom link by expression, repeatable", collectOptionValue).option("--max-links <n>", "Max number of generated links", (v) => Number.parseInt(v, 10)).option("--max-images <n>", "Max total images including cover (1=cover only, 2=cover+1 inline, 3=cover+2 inline)", (v) => Number.parseInt(v, 10)).action(async (options) => {
     await runWriteResumeCommand({
       noInteractive: options.noInteractive,
       enrichLinks: options.enrichLinks,