@telepat/ideon 0.1.21 → 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.21",
+  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";
 
@@ -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([
@@ -2220,8 +2304,8 @@ function deriveTitleFromIdea(idea) {
   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,19 +2433,19 @@ 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 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.",
@@ -2336,6 +2458,7 @@ function buildArticlePlanMessages(idea, options) {
         `- 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,13 +2559,22 @@ 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,
+  contentType,
   contentPlan,
   settings,
   markdownOutputDir,
@@ -2390,10 +2583,12 @@ async function planArticle({
   onLlmMetrics,
   onInteraction
 }) {
-  const basePlan = dryRun || !openRouter ? buildDryRunPlan(idea, contentPlan) : 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),
       contentPlan,
@@ -2402,32 +2597,53 @@ async function planArticle({
     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, contentPlan) {
-  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: contentPlan.description,
@@ -2436,10 +2652,10 @@ function buildDryRunPlan(idea, contentPlan) {
     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, contentPlan) {
     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, contentPlan) {
   };
 }
 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",
@@ -2525,6 +2749,7 @@ function buildSingleShotContentMessages(options) {
         `- primaryContentType: ${options.contentPlan.primaryContentType}`,
         `- secondaryContentTypes: ${options.contentPlan.secondaryContentTypes.join(" | ") || "none"}`,
         `- secondaryContentStrategy: ${options.contentPlan.secondaryContentStrategy}`,
+        planContext,
         "",
         articleContext,
         "",
@@ -2549,6 +2774,7 @@ async function writeSingleShotContent({
   outputCountForType,
   articleReferenceMarkdown,
   contentPlan,
+  plan,
   settings,
   openRouter,
   dryRun,
@@ -2564,6 +2790,7 @@ async function writeSingleShotContent({
       outputIndex,
       outputCountForType,
       contentPlan,
+      plan,
       articleReferenceMarkdown
     });
   }
@@ -2578,6 +2805,7 @@ async function writeSingleShotContent({
       outputIndex,
       outputCountForType,
       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}`,
     "",
@@ -2600,6 +2831,7 @@ function buildDryRunContent(options) {
     `Role: ${options.role}`,
     `Primary content type: ${options.primaryContentType}`,
     `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,8 +4004,8 @@ ${body.join("\n").trim()}
 }
 
 // src/pipeline/sessionStore.ts
-import { createHash } from "crypto";
-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";
@@ -3782,7 +4070,7 @@ var writeSessionStateSchema = z6.object({
   failedStage: z6.enum(STAGE_IDS).nullable(),
   errorMessage: z6.string().nullable(),
   contentPlan: contentPlanSchema2.nullable().default(null),
-  plan: articlePlanSchema.nullable(),
+  plan: primaryPlanSchema.nullable(),
   text: z6.object({
     intro: z6.string().min(1),
     sections: z6.array(generatedArticleSectionSchema),
@@ -3799,7 +4087,7 @@ var writeSessionStateSchema = z6.object({
 var ideonPaths3 = envPaths3("ideon", { suffix: "" });
 var sessionsDir = path7.join(ideonPaths3.config, "sessions");
 function hashProjectPath(workingDir) {
-  return createHash("sha256").update(path7.resolve(workingDir)).digest("hex").slice(0, 16);
+  return createHash2("sha256").update(path7.resolve(workingDir)).digest("hex").slice(0, 16);
 }
 function resolveWriteRoot(workingDir) {
   return path7.join(sessionsDir, hashProjectPath(workingDir));
@@ -3813,7 +4101,7 @@ function resolveLegacyStatePath(workingDir) {
 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,
@@ -3846,7 +4134,7 @@ 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;
     }
   }
@@ -3857,7 +4145,7 @@ async function loadWriteSession(workingDir = process.cwd()) {
     await saveWriteSession(state, workingDir);
     return state;
   } catch (error) {
-    if (isNotFoundError(error)) {
+    if (isNotFoundError2(error)) {
       return null;
     }
     throw error;
@@ -3869,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;
@@ -3897,16 +4185,12 @@ 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-plan",
@@ -3916,15 +4200,15 @@ function createInitialStages(options = { isArticlePrimary: true }) {
     },
     {
       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",
@@ -3958,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;
@@ -3968,8 +4251,7 @@ 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();
@@ -4102,66 +4384,69 @@ async function runPipelineShell(input, options = {}) {
         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 cached session.",
-          summary: `${plan.title} \u2022 ${plan.slug} \u2022 ${plan.sections.length} sections \u2022 ${plan.inlineImages.length + 1} images`,
-          stageAnalytics: snapshotStageAnalytics(stageTracking, "planning")
-        };
-      } else {
-        if (!contentPlan) {
-          throw new Error("Shared content plan is missing for article planning stage.");
+    } 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);
         }
-        plan = await planArticle({
-          idea: input.idea,
+      });
+      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,
-          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,
-            contentPlan,
-            plan
-          },
-          workingDir
-        );
-      }
+          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));
@@ -4189,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,
@@ -4302,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,
@@ -4364,24 +4649,6 @@ async function runPipelineShell(input, options = {}) {
         );
       }
     } else {
-      if (!contentPlan) {
-        throw new Error("Shared content plan 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",
@@ -4400,6 +4667,7 @@ async function runPipelineShell(input, options = {}) {
         outputCountForType: 1,
         articleReferenceMarkdown: void 0,
         contentPlan,
+        plan,
         settings: input.config.settings,
         openRouter,
         dryRun,
@@ -4425,7 +4693,7 @@ async function runPipelineShell(input, options = {}) {
       };
       markStageStarted(stageTracking, "image-prompts");
       options.onUpdate?.(cloneStages(stages));
-      imagePrompts = [buildPrimaryCoverPrompt(contentPlan, primaryTarget.contentType, primaryMarkdownTemplate)];
+      imagePrompts = [buildPrimaryCoverPrompt(plan, contentPlan, primaryTarget.contentType)];
       markStageCompleted(stageTracking, "image-prompts");
       stages[3] = {
         ...stages[3],
@@ -4452,7 +4720,7 @@ async function runPipelineShell(input, options = {}) {
       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,
@@ -4472,7 +4740,8 @@ 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] = {
@@ -4548,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,
@@ -4633,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,
-        contentPlan.title || deriveTitleFromIdea2(input.idea)
+        plan.title || contentPlan.title || deriveTitleFromIdea2(input.idea)
       );
     }
     const markdownPaths = [];
@@ -4704,6 +4973,7 @@ async function runPipelineShell(input, options = {}) {
           outputCountForType: output.outputCountForType,
           articleReferenceMarkdown: primaryMarkdownTemplate ?? void 0,
           contentPlan,
+          plan,
           settings: input.config.settings,
           openRouter,
           dryRun,
@@ -5303,20 +5573,19 @@ function getSecondaryTargets(contentTargets) {
     count: target.count
   }));
 }
-function buildPrimaryCoverPrompt(contentPlan, 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}.`,
+      plan.coverImageDescription,
+      `Content type: ${primaryContentType}`,
       `Core angle: ${contentPlan.description}`,
       `Audience: ${contentPlan.targetAudience}`,
       `Promise: ${contentPlan.corePromise}`,
       `Voice: ${contentPlan.voiceNotes}`,
-      `Primary excerpt: ${markdownExcerpt}`,
       "Do not include any words, letters, numbers, logos, watermarks, or signage in the image."
     ].join(" ")
   };
@@ -5380,43 +5649,60 @@ 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-plan" || stageId === "planning" || stageId === "sections" || stageId === "image-prompts" || stageId === "images" || stageId === "output" || stageId === "links") {
@@ -5454,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);
@@ -5524,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;
@@ -5706,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
@@ -6033,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);
@@ -6060,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);
@@ -6080,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");
@@ -6642,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) {
@@ -6672,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;
@@ -6691,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;
@@ -6761,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) {
@@ -6798,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) {
@@ -6852,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"
@@ -6899,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"
@@ -6938,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: {}
               }
             }));
@@ -8920,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) {
@@ -9827,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);