@telepat/ideon 0.1.21 → 0.1.25

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: 0, max: 1 };
+  if (alias === "medium") return { min: 1, max: 2 };
+  return { min: 2, 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.25",
   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,9 +1623,9 @@ 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";
+import path9 from "path";
 
 // src/generation/enrichLinks.ts
 import { readFile as readFile4 } from "fs/promises";
@@ -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,28 +2372,57 @@ function buildArticlePlanJsonSchema(targetLengthWords) {
       coverImageDescription: { type: "string" },
       inlineImages: {
         type: "array",
-        minItems: 2,
-        maxItems: 3,
+        minItems: imageCounts.min,
+        maxItems: imageCounts.max,
         items: {
           type: "object",
           additionalProperties: false,
           required: ["description", "anchorAfterSection"],
           properties: {
             description: { type: "string" },
-            anchorAfterSection: { type: "number", minimum: 1 }
+            anchorAfterSection: { type: "number", minimum: 2 }
           }
         }
       }
     }
   };
 }
-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,20 +2433,20 @@ 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.",
-        "- Each inline image must specify which section it follows (anchorAfterSection, 1-based index). Choose sections where visual reinforcement adds the most value.",
+        "- 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, starting at 2). Choose sections where visual reinforcement adds the most value. Do not anchor inline images after the first section because the cover image already appears near the title.",
         "- 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,16 +2458,63 @@ 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",
         "- slug: string in lowercase kebab-case",
-        "- description: string",
-        "- introBrief: string",
-        "- outroBrief: string",
-        `- sections: array of ${sectionCounts.label} objects, each with title and description strings`,
+        "- description: string",
+        "- introBrief: string",
+        "- outroBrief: string",
+        `- sections: array of ${sectionCounts.label} objects, each with title and description strings`,
+        "- coverImageDescription: string",
+        `- inlineImages: array of ${imageCounts.min} to ${imageCounts.max} objects, each with a description string and an anchorAfterSection number (starting at 2, since the cover image already appears near the title)`,
+        "",
+        "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",
-        "- inlineImages: array of 2 to 3 objects, each with a description string and an anchorAfterSection number (1-based section index)",
+        "- angle: string (the hook or framing that makes this post work)",
         "",
         "Do not omit any required fields. Return strict JSON only."
       ].join("\n")
@@ -2361,9 +2530,24 @@ var articleSectionPlanSchema = z5.object({
 });
 var inlineImagePlanSchema = z5.object({
   description: z5.string().min(1),
-  anchorAfterSection: z5.number().int().min(1)
+  anchorAfterSection: z5.number().int().min(2)
+});
+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(0).max(4).optional(),
+  angle: z5.string().min(1).optional()
 });
-var articlePlanSchema = z5.object({
+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),
@@ -2373,15 +2557,24 @@ var articlePlanSchema = z5.object({
   outroBrief: z5.string().min(1),
   sections: z5.array(articleSectionPlanSchema).min(2).max(10),
   coverImageDescription: z5.string().min(1),
-  inlineImages: z5.array(inlineImagePlanSchema).min(2).max(3)
+  inlineImages: z5.array(inlineImagePlanSchema).min(0).max(4)
+});
+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(2, 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 = [
@@ -2991,7 +3276,7 @@ function buildImageSlots(plan, sections, options) {
       kind: "inline",
       prompt: "",
       description: img.description,
-      anchorAfterSection: Math.max(1, Math.min(sectionCount, img.anchorAfterSection))
+      anchorAfterSection: Math.max(2, Math.min(sectionCount, img.anchorAfterSection))
     });
   }
   return 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,
@@ -3715,10 +4003,69 @@ ${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";
+// src/output/meta.ts
 import path7 from "path";
+function buildMetaJson(input) {
+  const plan = input.plan;
+  const contentPlan = input.contentPlan;
+  const generationDir = input.generationDir;
+  const title = plan?.title ?? contentPlan?.title ?? input.idea;
+  const slug = plan?.slug ?? "";
+  const description = plan?.description ?? contentPlan?.description ?? "";
+  const subtitle = (plan && "subtitle" in plan ? plan.subtitle : null) ?? null;
+  const keywords = (plan && "keywords" in plan ? plan.keywords : null) ?? [];
+  const contentType = plan?.contentType ?? contentPlan?.primaryContentType ?? "article";
+  const angle = plan?.angle ?? null;
+  const coverImage = input.renderedImages.find((image) => image.kind === "cover") ?? null;
+  const cover = coverImage ? {
+    path: coverImage.outputPath,
+    relativePath: coverImage.relativePath,
+    description: coverImage.description
+  } : null;
+  const sections = plan?.sections?.map((section) => ({
+    title: section.title,
+    description: section.description
+  })) ?? [];
+  const images = input.renderedImages.map((image) => ({
+    id: image.id,
+    kind: image.kind,
+    path: image.outputPath,
+    relativePath: image.relativePath,
+    description: image.description,
+    anchorAfterSection: image.anchorAfterSection
+  }));
+  const outputs = input.outputs.map((output) => ({
+    fileId: output.fileId,
+    contentType: output.contentType,
+    path: output.markdownPath,
+    relativePath: path7.relative(generationDir, output.markdownPath)
+  }));
+  return {
+    version: 1,
+    title,
+    slug,
+    idea: input.idea,
+    description,
+    subtitle,
+    keywords,
+    contentType,
+    style: input.style,
+    intent: input.intent,
+    targetLength: input.targetLength,
+    angle,
+    cover,
+    sections,
+    images,
+    outputs,
+    generatedAt: input.generatedAt,
+    generationDir
+  };
+}
+
+// src/pipeline/sessionStore.ts
+import { createHash as createHash2 } from "crypto";
+import { mkdir as mkdir5, readFile as readFile5, rm as rm2, writeFile as writeFile5 } from "fs/promises";
+import path8 from "path";
 import envPaths3 from "env-paths";
 import { z as z6 } from "zod";
 var STAGE_IDS = ["shared-plan", "planning", "sections", "image-prompts", "images", "output", "links"];
@@ -3761,7 +4108,8 @@ var pipelineArtifactSummarySchema = z6.object({
   assetDir: z6.string().min(1),
   analyticsPath: z6.string().min(1).default("unknown.analytics.json"),
   interactionsPath: z6.string().min(1).default("unknown.interactions.json"),
-  planPath: z6.string().min(1).nullable().default(null)
+  planPath: z6.string().min(1).nullable().default(null),
+  metaJsonPath: z6.string().min(1).default("meta.json")
 });
 var resolvedPathsSchema = z6.object({
   markdownOutputDir: z6.string().min(1),
@@ -3782,7 +4130,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),
@@ -3797,23 +4145,23 @@ var writeSessionStateSchema = z6.object({
   artifact: pipelineArtifactSummarySchema.nullable()
 });
 var ideonPaths3 = envPaths3("ideon", { suffix: "" });
-var sessionsDir = path7.join(ideonPaths3.config, "sessions");
+var sessionsDir = path8.join(ideonPaths3.config, "sessions");
 function hashProjectPath(workingDir) {
-  return createHash("sha256").update(path7.resolve(workingDir)).digest("hex").slice(0, 16);
+  return createHash2("sha256").update(path8.resolve(workingDir)).digest("hex").slice(0, 16);
 }
 function resolveWriteRoot(workingDir) {
-  return path7.join(sessionsDir, hashProjectPath(workingDir));
+  return path8.join(sessionsDir, hashProjectPath(workingDir));
 }
 function resolveStateFilePath(workingDir) {
-  return path7.join(resolveWriteRoot(workingDir), "state.json");
+  return path8.join(resolveWriteRoot(workingDir), "state.json");
 }
 function resolveLegacyStatePath(workingDir) {
-  return path7.join(workingDir, ".ideon", "write", "state.json");
+  return path8.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,
@@ -3846,7 +4194,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 +4205,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 +4217,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(path8.dirname(statePath), { recursive: true });
   await writeFile5(statePath, `${JSON.stringify(next, null, 2)}
 `, "utf8");
   return next;
@@ -3897,16 +4245,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 +4260,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 +4302,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 +4311,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 +4444,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 +4534,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 +4647,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 +4709,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 +4727,7 @@ async function runPipelineShell(input, options = {}) {
         outputCountForType: 1,
         articleReferenceMarkdown: void 0,
         contentPlan,
+        plan,
         settings: input.config.settings,
         openRouter,
         dryRun,
@@ -4425,7 +4753,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],
@@ -4448,12 +4776,12 @@ async function runPipelineShell(input, options = {}) {
       options.onUpdate?.(cloneStages(stages));
     }
     const baseSlug = plan?.slug ?? resolveGenerationSlug(input.idea, contentPlan?.title);
-    const generationDir = path8.join(
+    const generationDir = path9.join(
       writeSession.outputPaths.markdownOutputDir,
       buildGenerationDirectoryName(baseSlug)
     );
-    await mkdir5(generationDir, { recursive: true });
-    const jobDefinitionPath = path8.join(generationDir, "job.json");
+    await mkdir6(generationDir, { recursive: true });
+    const jobDefinitionPath = path9.join(generationDir, "job.json");
     await writeJsonFile(
       jobDefinitionPath,
       buildRunJobDefinition({
@@ -4465,14 +4793,15 @@ async function runPipelineShell(input, options = {}) {
         sourceJob: input.job
       })
     );
-    const planPath = plan ? path8.join(generationDir, "plan.md") : null;
+    const planPath = plan ? path9.join(generationDir, "plan.md") : null;
     if (plan && planPath) {
       await writeUtf8File(planPath, renderPlanMarkdown(plan));
     }
     const primaryFilePrefix = toFilePrefix(primaryTarget.contentType);
-    const primaryMarkdownPath = path8.join(generationDir, `${primaryFilePrefix}-1.md`);
+    const primaryMarkdownPath = path9.join(generationDir, `${primaryFilePrefix}-1.md`);
     const sharedAssetDir = generationDir;
-    if (hasArticlePrimary) {
+    if (isLongForm) {
+      const longPlan = plan;
       if (imageArtifacts) {
         markStageCompleted(stageTracking, "images");
         stages[4] = {
@@ -4548,7 +4877,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 +4962,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 = [];
@@ -4693,7 +5022,7 @@ async function runPipelineShell(input, options = {}) {
         })
       };
       options.onUpdate?.(cloneStages(stages));
-      const markdownPath = path8.join(generationDir, `${output.filePrefix}-${output.index}.md`);
+      const markdownPath = path9.join(generationDir, `${output.filePrefix}-${output.index}.md`);
       try {
         const content = await writeSingleShotContent({
           idea: input.idea,
@@ -4704,6 +5033,7 @@ async function runPipelineShell(input, options = {}) {
           outputCountForType: output.outputCountForType,
           articleReferenceMarkdown: primaryMarkdownTemplate ?? void 0,
           contentPlan,
+          plan,
           settings: input.config.settings,
           openRouter,
           dryRun,
@@ -4755,7 +5085,7 @@ async function runPipelineShell(input, options = {}) {
               ...item,
               status: "succeeded",
               detail: "Saved markdown output.",
-              summary: path8.basename(markdownPath),
+              summary: path9.basename(markdownPath),
               analytics: {
                 durationMs: itemDurationMs,
                 costUsd: knownItemCost.usd,
@@ -4970,10 +5300,24 @@ async function runPipelineShell(input, options = {}) {
       llmCalls: llmInteractions,
       t2iCalls: t2iInteractions
     };
-    const analyticsPath = path8.join(generationDir, "generation.analytics.json");
-    const interactionsPath = path8.join(generationDir, "model.interactions.json");
+    const analyticsPath = path9.join(generationDir, "generation.analytics.json");
+    const interactionsPath = path9.join(generationDir, "model.interactions.json");
     await writeJsonFile(analyticsPath, analytics);
     await writeJsonFile(interactionsPath, interactions);
+    const metaJson = buildMetaJson({
+      idea: input.idea,
+      generationDir,
+      contentPlan,
+      plan,
+      renderedImages: imageArtifacts?.renderedImages ?? [],
+      outputs: generatedOutputs,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      style: input.config.settings.style,
+      intent: input.config.settings.intent,
+      targetLength: input.config.settings.targetLength ? resolveTargetLengthAlias(input.config.settings.targetLength) : null
+    });
+    const metaJsonPath = path9.join(generationDir, "meta.json");
+    await writeJsonFile(metaJsonPath, metaJson);
     const primaryMarkdownPathForArtifact = markdownPaths[0] ?? primaryMarkdownPath;
     const artifact = {
       title: plan?.title ?? contentPlan.title ?? deriveTitleFromIdea2(input.idea),
@@ -4987,7 +5331,8 @@ async function runPipelineShell(input, options = {}) {
       assetDir: sharedAssetDir,
       analyticsPath,
       interactionsPath,
-      planPath
+      planPath,
+      metaJsonPath
     };
     writeSession = await patchWriteSession(
       {
@@ -5303,20 +5648,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 +5724,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") {
@@ -5445,7 +5806,7 @@ function parsePipelineCustomLinks(rawLinks, unlinks) {
 
 // src/cli/commands/links.ts
 import { readFile as readFile6, stat as stat3 } from "fs/promises";
-import path9 from "path";
+import path10 from "path";
 async function runLinksCommand(options, dependencies = {}) {
   const slug = normalizeSlug2(options.slug);
   const mode = normalizeMode(options.mode);
@@ -5454,9 +5815,9 @@ 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 fileId = path10.parse(markdownPath).name;
   const articleTitle = frontmatter.title ?? toTitleFromSlug(slug);
   const articleDescription = frontmatter.description ?? "";
   const openRouterApiKey = resolved.config.secrets.openRouterApiKey;
@@ -5524,16 +5885,16 @@ function normalizeSlug2(rawSlug) {
   }
   return slug;
 }
-async function resolveMarkdownPathForSlug2(settings, slug, cwd2) {
-  const outputPaths = resolveOutputPaths(settings, cwd2);
-  const directPath = path9.join(outputPaths.markdownOutputDir, `${slug}.md`);
+async function resolveMarkdownPathForSlug2(slug, cwd2) {
+  const outputPaths = resolveOutputPaths();
+  const directPath = path10.join(outputPaths.markdownOutputDir, `${slug}.md`);
   if (await isReadableFile(directPath)) {
     return directPath;
   }
   const markdownFiles = await listMarkdownFilesRecursively(outputPaths.markdownOutputDir);
   const matches = [];
   for (const candidate of markdownFiles) {
-    if (path9.basename(candidate) === `${slug}.md`) {
+    if (path10.basename(candidate) === `${slug}.md`) {
       matches.push(candidate);
       continue;
     }
@@ -5667,7 +6028,7 @@ function readErrorCode2(error) {
   return typeof code === "string" ? code : null;
 }
 function formatRelativePath2(cwd2, targetPath) {
-  const relativePath = path9.relative(cwd2, targetPath);
+  const relativePath = path10.relative(cwd2, targetPath);
   return relativePath.length > 0 ? relativePath : targetPath;
 }
 function logProgress(event, log) {
@@ -5706,8 +6067,8 @@ 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 path11 from "path";
+import { copyFile as copyFile2, mkdir as mkdir7, readFile as readFile8, stat as stat5, writeFile as writeFile6 } from "fs/promises";
+import path12 from "path";
 
 // src/output/enrichMarkdownWithLinks.ts
 function enrichMarkdownWithLinks(markdown, links) {
@@ -5764,7 +6125,7 @@ function escapeRegExp(value2) {
 
 // src/server/previewHelpers.ts
 import { readdir, stat as stat4, readFile as readFile7 } from "fs/promises";
-import path10 from "path";
+import path11 from "path";
 var DEFAULT_PORT = 4173;
 var CONTENT_TYPE_ORDER = ["article", "blog-post", "x-thread", "x-post", "linkedin-post", "reddit-post", "newsletter"];
 var FILE_PREFIX_TO_CONTENT_TYPE = {
@@ -5822,8 +6183,8 @@ function extractHeadingTitle(markdown) {
 }
 async function resolveMarkdownPath(markdownPathArg, markdownOutputDir, cwd2) {
   if (markdownPathArg) {
-    const resolved = path10.isAbsolute(markdownPathArg) ? markdownPathArg : path10.resolve(cwd2, markdownPathArg);
-    if (path10.extname(resolved).toLowerCase() !== ".md") {
+    const resolved = path11.isAbsolute(markdownPathArg) ? markdownPathArg : path11.resolve(cwd2, markdownPathArg);
+    if (path11.extname(resolved).toLowerCase() !== ".md") {
       throw new Error(`Expected a markdown file (.md), received: ${resolved}`);
     }
     await assertFileExists(resolved, "Could not find markdown file");
@@ -5867,7 +6228,7 @@ function extractCoverImageUrl(markdown) {
 async function extractArticleMetadata(markdownPath) {
   const markdown = await readFile7(markdownPath, "utf8");
   const fileStat = await stat4(markdownPath);
-  const slug = extractFrontmatterSlug(markdown) ?? path10.basename(markdownPath, ".md");
+  const slug = extractFrontmatterSlug(markdown) ?? path11.basename(markdownPath, ".md");
   const title = extractHeadingTitle(stripFrontmatter2(markdown)) ?? slug;
   const body = stripFrontmatter2(markdown);
   const previewSnippet = body.replace(/[#\[\]()!\-*_`]/g, "").trim().substring(0, 150);
@@ -5932,16 +6293,16 @@ async function listAllGenerations(markdownOutputDir) {
   return generations;
 }
 function deriveGenerationId(markdownPath, markdownOutputDir) {
-  const relative = path10.relative(markdownOutputDir, markdownPath);
-  const normalized = relative.split(path10.sep).join("/");
+  const relative = path11.relative(markdownOutputDir, markdownPath);
+  const normalized = relative.split(path11.sep).join("/");
   if (!normalized || normalized.startsWith("../")) {
-    return path10.basename(markdownPath, ".md");
+    return path11.basename(markdownPath, ".md");
   }
   const segments = normalized.split("/").filter(Boolean);
   if (segments.length <= 1) {
-    return path10.basename(markdownPath, ".md");
+    return path11.basename(markdownPath, ".md");
   }
-  return segments[0] ?? path10.basename(markdownPath, ".md");
+  return segments[0] ?? path11.basename(markdownPath, ".md");
 }
 async function findMarkdownFiles(markdownOutputDir) {
   const files = [];
@@ -5958,7 +6319,7 @@ async function findMarkdownFiles(markdownOutputDir) {
       continue;
     }
     for (const entry of entries) {
-      const fullPath = path10.join(current, entry.name);
+      const fullPath = path11.join(current, entry.name);
       if (entry.isDirectory()) {
         stack.push(fullPath);
         continue;
@@ -5972,7 +6333,7 @@ async function findMarkdownFiles(markdownOutputDir) {
 }
 function deriveOutputIdentity(markdownPath, markdownOutputDir) {
   const generationId = deriveGenerationId(markdownPath, markdownOutputDir);
-  const fileBase = path10.basename(markdownPath, ".md");
+  const fileBase = path11.basename(markdownPath, ".md");
   const parsed = fileBase.match(/^([a-z0-9-]+)-(\d+)$/i);
   if (!parsed || !parsed[1] || !parsed[2]) {
     return {
@@ -6008,11 +6369,11 @@ function toContentTypeLabel(contentType) {
 }
 async function resolvePrimaryContentType(outputs) {
   const fallback = outputs.find((output) => output.contentType === "article")?.contentType ?? outputs[0]?.contentType ?? "article";
-  const generationDir = path10.dirname(outputs[0]?.sourcePath ?? "");
+  const generationDir = path11.dirname(outputs[0]?.sourcePath ?? "");
   if (!generationDir) {
     return fallback;
   }
-  const jobPath = path10.join(generationDir, "job.json");
+  const jobPath = path11.join(generationDir, "job.json");
   try {
     const raw = await readFile7(jobPath, "utf8");
     const parsed = JSON.parse(raw);
@@ -6028,12 +6389,17 @@ async function resolvePrimaryContentType(outputs) {
 }
 
 // src/cli/commands/export.ts
+var INTERNAL_FILE_NAMES = /* @__PURE__ */ new Set([
+  "job.json",
+  "model.interactions.json",
+  "generation.analytics.json"
+]);
 async function runOutputCommand(options, dependencies = {}) {
   const cwd2 = dependencies.cwd ?? process.cwd();
   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);
@@ -6051,44 +6417,36 @@ async function runOutputCommand(options, dependencies = {}) {
   }
   const sourceMarkdownPath = articleOutput.sourcePath;
   const sourceMarkdown = await readFile8(sourceMarkdownPath, "utf8");
-  const slug = extractFrontmatterSlug2(sourceMarkdown) ?? path11.basename(sourceMarkdownPath, ".md");
+  const slug = extractFrontmatterSlug2(sourceMarkdown) ?? path12.basename(sourceMarkdownPath, ".md");
   const exportFilename = `${slug}.md`;
   const destinationDir = await resolveDestinationDir(options.destinationPath, cwd2);
-  const destinationFilePath = path11.join(destinationDir, exportFilename);
+  const destinationFilePath = path12.join(destinationDir, exportFilename);
   if (!options.overwrite && await fileExists2(destinationFilePath)) {
     throw new ReportedError(
       `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);
-  const imagePaths = extractLocalImagePaths(sourceMarkdown);
-  const copiedImages = [];
-  for (const relImagePath of imagePaths) {
-    const absoluteImageSrc = path11.resolve(sourceDir, relImagePath);
-    let imageStat = null;
-    try {
-      imageStat = await stat5(absoluteImageSrc);
-    } catch {
-      throw new ReportedError(
-        `Referenced image not found: ${relImagePath} (resolved to ${absoluteImageSrc}).`
-      );
-    }
-    if (!imageStat.isFile()) {
-      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);
-    copiedImages.push(relImagePath);
+  const sourceDir = path12.dirname(sourceMarkdownPath);
+  const allFiles = await listFilesRecursively(sourceDir, () => true);
+  const copiedFiles = [];
+  for (const absoluteSrc of allFiles) {
+    const basename = path12.basename(absoluteSrc);
+    if (INTERNAL_FILE_NAMES.has(basename)) continue;
+    if (path12.resolve(absoluteSrc) === path12.resolve(sourceMarkdownPath)) continue;
+    const relativePath = path12.relative(sourceDir, absoluteSrc);
+    const destPath = path12.join(destinationDir, relativePath);
+    await mkdir7(path12.dirname(destPath), { recursive: true });
+    await copyFile2(absoluteSrc, destPath);
+    copiedFiles.push(relativePath);
   }
   await writeFile6(destinationFilePath, enrichedMarkdown, "utf8");
-  const relDest = path11.relative(cwd2, destinationFilePath);
+  const relDest = path12.relative(cwd2, destinationFilePath);
   log(`Exported "${generation.id}" (${generation.primaryContentType} #${targetIndex}) \u2192 ${relDest}`);
-  if (copiedImages.length > 0) {
-    log(`Copied ${copiedImages.length} image${copiedImages.length === 1 ? "" : "s"}: ${copiedImages.join(", ")}`);
+  if (copiedFiles.length > 0) {
+    log(`Copied ${copiedFiles.length} file${copiedFiles.length === 1 ? "" : "s"}: ${copiedFiles.join(", ")}`);
   }
   if (links.length > 0) {
     log(`Injected ${links.length} inline link${links.length === 1 ? "" : "s"}.`);
@@ -6110,7 +6468,7 @@ function resolveGeneration(generations, generationId) {
   );
 }
 async function resolveDestinationDir(destinationPath, cwd2) {
-  const resolved = path11.isAbsolute(destinationPath) ? destinationPath : path11.resolve(cwd2, destinationPath);
+  const resolved = path12.isAbsolute(destinationPath) ? destinationPath : path12.resolve(cwd2, destinationPath);
   return resolved;
 }
 async function fileExists2(filePath) {
@@ -6180,22 +6538,6 @@ function extractFrontmatterSlug2(markdown) {
   const unquoted = rawSlug.replace(/^['""]|['""]$/g, "").trim();
   return unquoted.length > 0 ? unquoted : null;
 }
-function extractLocalImagePaths(markdown) {
-  const imagePattern = /!\[[^\]]*\]\(([^)]+)\)/g;
-  const paths = [];
-  let match;
-  while ((match = imagePattern.exec(markdown)) !== null) {
-    const rawPath = match[1]?.trim();
-    if (!rawPath) {
-      continue;
-    }
-    if (rawPath.startsWith("http://") || rawPath.startsWith("https://") || rawPath.startsWith("data:") || rawPath.startsWith("/") || rawPath.startsWith("#")) {
-      continue;
-    }
-    paths.push(rawPath);
-  }
-  return paths;
-}
 
 // src/cli/commands/writeTargetSpecs.ts
 function parseTargetSpec(spec) {
@@ -6642,12 +6984,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 +7008,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 +7021,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 +7098,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 +7127,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 +7192,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 +7246,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 +7277,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: {}
               }
             }));
@@ -7059,7 +7399,7 @@ async function openSettings() {
 }
 
 // src/cli/commands/serve.ts
-import path13 from "path";
+import path14 from "path";
 import { spawn } from "child_process";
 
 // src/server/previewServer.ts
@@ -7067,7 +7407,7 @@ import { execFile } from "child_process";
 import { promisify } from "util";
 import { readFile as readFile9, stat as stat6 } from "fs/promises";
 import { watch as fsWatch } from "fs";
-import path12 from "path";
+import path13 from "path";
 import { fileURLToPath } from "url";
 import express from "express";
 import { marked } from "marked";
@@ -7165,7 +7505,7 @@ async function startPreviewServer(options) {
         if (options.watch) {
           let html2;
           try {
-            html2 = await readFile9(path12.join(previewClientDir, "index.html"), "utf8");
+            html2 = await readFile9(path13.join(previewClientDir, "index.html"), "utf8");
           } catch {
             res.status(200).type("html").send(
               `<!doctype html><html><head><meta charset="utf-8"><title>Rebuilding\u2026</title><style>body{margin:0;display:flex;align-items:center;justify-content:center;height:100vh;font-family:sans-serif;background:#101820;color:#e0eaf0}p{font-size:15px;opacity:.7}</style></head><body><p>Rebuilding\u2026</p><script>const s=new EventSource('/api/__reload');s.onmessage=function(){location.reload()};</script></body></html>`
@@ -7176,7 +7516,7 @@ async function startPreviewServer(options) {
           const injected = html2.replace("</body>", `${reloadScript}</body>`);
           res.status(200).type("html").send(injected);
         } else {
-          res.status(200).sendFile(path12.join(previewClientDir, "index.html"));
+          res.status(200).sendFile(path13.join(previewClientDir, "index.html"));
         }
         return;
       }
@@ -7247,15 +7587,17 @@ async function getArticleContent(generationId, markdownOutputDir) {
       };
     })
   );
-  const generationDir = path12.dirname(generation.outputs[0]?.sourcePath ?? "");
+  const generationDir = path13.dirname(generation.outputs[0]?.sourcePath ?? "");
   const interactions = generationDir ? await loadSavedInteractions(generationDir) : { llmCalls: [], t2iCalls: [] };
   const analyticsSummary = generationDir ? await loadSavedAnalyticsSummary(generationDir) : null;
+  const metaJson = generationDir ? await loadSavedMetaJson(generationDir) : null;
   return {
     title: generation.title,
     generationId: generation.id,
     sourcePath,
     interactions,
     analyticsSummary,
+    metaJson,
     outputs
   };
 }
@@ -7276,7 +7618,7 @@ async function resolveActivePreviewArticle(preferredMarkdownPath, markdownOutput
   };
 }
 function resolveGenerationSourcePath(generation, markdownOutputDir) {
-  return generation.outputs.find((output) => output.contentType === generation.primaryContentType)?.sourcePath ?? generation.outputs[0]?.sourcePath ?? path12.join(markdownOutputDir, generation.id);
+  return generation.outputs.find((output) => output.contentType === generation.primaryContentType)?.sourcePath ?? generation.outputs[0]?.sourcePath ?? path13.join(markdownOutputDir, generation.id);
 }
 function isMissingFileError(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
@@ -7315,7 +7657,7 @@ async function loadSavedLinks(markdownPath) {
   }
 }
 async function loadSavedInteractions(generationDir) {
-  const interactionsPath = path12.join(generationDir, "model.interactions.json");
+  const interactionsPath = path13.join(generationDir, "model.interactions.json");
   try {
     const raw = await readFile9(interactionsPath, "utf8");
     const parsed = JSON.parse(raw);
@@ -7333,7 +7675,7 @@ async function loadSavedInteractions(generationDir) {
   }
 }
 async function loadSavedAnalyticsSummary(generationDir) {
-  const analyticsPath = path12.join(generationDir, "generation.analytics.json");
+  const analyticsPath = path13.join(generationDir, "generation.analytics.json");
   try {
     const raw = await readFile9(analyticsPath, "utf8");
     const parsed = JSON.parse(raw);
@@ -7356,6 +7698,15 @@ async function loadSavedAnalyticsSummary(generationDir) {
     return null;
   }
 }
+async function loadSavedMetaJson(generationDir) {
+  const metaJsonPath = path13.join(generationDir, "meta.json");
+  try {
+    const raw = await readFile9(metaJsonPath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
 async function getPreviewBootstrapData(preferredMarkdownPath, markdownOutputDir) {
   const activeArticle = await resolveActivePreviewArticle(preferredMarkdownPath, markdownOutputDir);
   const emptyStateMessage = activeArticle ? null : `No generated content found in ${markdownOutputDir}. Run ideon write "your idea" first.`;
@@ -7367,14 +7718,14 @@ async function getPreviewBootstrapData(preferredMarkdownPath, markdownOutputDir)
   };
 }
 async function resolvePreviewClientBuildDir() {
-  const currentDir = path12.dirname(fileURLToPath(import.meta.url));
+  const currentDir = path13.dirname(fileURLToPath(import.meta.url));
   const candidates = [
-    path12.resolve(currentDir, "preview"),
-    path12.resolve(currentDir, "../../dist/preview")
+    path13.resolve(currentDir, "preview"),
+    path13.resolve(currentDir, "../../dist/preview")
   ];
   for (const candidate of candidates) {
     try {
-      const indexStat = await stat6(path12.join(candidate, "index.html"));
+      const indexStat = await stat6(path13.join(candidate, "index.html"));
       if (indexStat.isFile()) {
         return candidate;
       }
@@ -7436,17 +7787,17 @@ async function resolveGenerationAssetPath(generationId, rawAssetPath, markdownOu
     throw new MissingArticleError(`Generation "${generationId}" no longer exists.`);
   }
   const decodedAssetPath = decodeURIComponent(rawAssetPath);
-  const normalizedRelative = path12.posix.normalize(decodedAssetPath.replace(/\\/g, "/"));
-  if (normalizedRelative.length === 0 || normalizedRelative === "." || normalizedRelative.startsWith("../") || normalizedRelative.includes("/../") || path12.posix.isAbsolute(normalizedRelative)) {
+  const normalizedRelative = path13.posix.normalize(decodedAssetPath.replace(/\\/g, "/"));
+  if (normalizedRelative.length === 0 || normalizedRelative === "." || normalizedRelative.startsWith("../") || normalizedRelative.includes("/../") || path13.posix.isAbsolute(normalizedRelative)) {
     throw new Error("Invalid generation asset path.");
   }
-  const generationDir = path12.dirname(generation.outputs[0]?.sourcePath ?? "");
+  const generationDir = path13.dirname(generation.outputs[0]?.sourcePath ?? "");
   if (!generationDir) {
     throw new MissingArticleError(`Generation "${generationId}" has no source directory.`);
   }
-  const resolvedPath = path12.resolve(generationDir, normalizedRelative);
-  const relativeToGeneration = path12.relative(generationDir, resolvedPath);
-  if (relativeToGeneration.startsWith("..") || path12.isAbsolute(relativeToGeneration)) {
+  const resolvedPath = path13.resolve(generationDir, normalizedRelative);
+  const relativeToGeneration = path13.relative(generationDir, resolvedPath);
+  if (relativeToGeneration.startsWith("..") || path13.isAbsolute(relativeToGeneration)) {
     throw new Error("Invalid generation asset path.");
   }
   try {
@@ -8920,17 +9271,11 @@ 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) {
-    const viteBin = path13.resolve(process.cwd(), "node_modules", ".bin", "vite");
+    const viteBin = path14.resolve(process.cwd(), "node_modules", ".bin", "vite");
     const viteProcess = spawn(viteBin, ["build", "--watch"], {
       stdio: "inherit",
       shell: process.platform === "win32"
@@ -8956,8 +9301,8 @@ async function runServeCommand(options) {
     openBrowser: options.openBrowser,
     watch: options.watch
   });
-  const relativeArticle = path13.relative(process.cwd(), markdownPath);
-  const relativeAssets = path13.relative(process.cwd(), outputPaths.assetOutputDir);
+  const relativeArticle = path14.relative(process.cwd(), markdownPath);
+  const relativeAssets = path14.relative(process.cwd(), outputPaths.assetOutputDir);
   console.log(`Previewing ${relativeArticle || markdownPath}`);
   console.log(`Serving assets from ${relativeAssets || outputPaths.assetOutputDir}`);
   console.log(`Open ${server.url}`);
@@ -9507,6 +9852,7 @@ async function renderPlainPipeline(input, dryRun, enrichLinks2, runMode, links,
       title: result.artifact.title,
       slug: result.artifact.slug
     });
+    return result;
   } catch (error) {
     const message = error instanceof Error ? withWriteResumeHint(error.message) : withWriteResumeHint("Pipeline failed.");
     await notifyWriteFailed({
@@ -9823,13 +10169,12 @@ function WriteApp({
   unlinks,
   maxLinks,
   maxImages,
+  onSuccess,
   onError
 }) {
   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);
@@ -9860,6 +10205,7 @@ function WriteApp({
           return;
         }
         setResult(runResult);
+        onSuccess?.(runResult);
         await notifyWriteSucceeded({
           enabled: input.config.settings.notifications.enabled,
           title: runResult.artifact.title,
@@ -9898,7 +10244,7 @@ function WriteApp({
 }
 async function runWriteCommand(options) {
   const input = await resolveInputWithInteractiveIdeaFallback(options);
-  await runWritePipeline(input, options.dryRun, options.enrichLinks, "fresh", options.noInteractive, options.links, options.unlinks, options.maxLinks, options.maxImages);
+  await runWritePipeline(input, options.dryRun, options.enrichLinks, "fresh", options.noInteractive, options.links, options.unlinks, options.maxLinks, options.maxImages, options.exportPath);
 }
 async function runWriteResumeCommand(options = {}) {
   const session = await loadWriteSession();
@@ -9920,9 +10266,9 @@ async function runWriteResumeCommand(options = {}) {
       secrets: resolved.config.secrets
     }
   };
-  await runWritePipeline(input, session.dryRun, options.enrichLinks ?? false, "resume", options.noInteractive ?? false, options.links, options.unlinks, options.maxLinks, options.maxImages);
+  await runWritePipeline(input, session.dryRun, options.enrichLinks ?? false, "resume", options.noInteractive ?? false, options.links, options.unlinks, options.maxLinks, options.maxImages, options.exportPath);
 }
-async function runWritePipeline(input, dryRun, enrichLinks2, runMode, noInteractive, links, unlinks, maxLinks, maxImages) {
+async function runWritePipeline(input, dryRun, enrichLinks2, runMode, noInteractive, links, unlinks, maxLinks, maxImages, exportPath) {
   let interruptHandled = false;
   const handleSignal = (signal) => {
     if (interruptHandled) {
@@ -9956,10 +10302,17 @@ async function runWritePipeline(input, dryRun, enrichLinks2, runMode, noInteract
   process.on("SIGTERM", onSigterm);
   try {
     if (noInteractive || !process.stdout.isTTY) {
-      await renderPlainPipeline(input, dryRun, enrichLinks2, runMode, links, unlinks, maxLinks, maxImages);
+      const result = await renderPlainPipeline(input, dryRun, enrichLinks2, runMode, links, unlinks, maxLinks, maxImages);
+      if (exportPath) {
+        await runOutputCommand({
+          generationId: result.artifact.slug,
+          destinationPath: exportPath
+        });
+      }
       return;
     }
     let commandError = null;
+    let pipelineResult = null;
     const app = render2(
       /* @__PURE__ */ jsx7(
         WriteApp,
@@ -9972,6 +10325,9 @@ async function runWritePipeline(input, dryRun, enrichLinks2, runMode, noInteract
           unlinks,
           maxLinks,
           maxImages,
+          onSuccess: (result) => {
+            pipelineResult = result;
+          },
           onError: (error) => {
             commandError = error;
           }
@@ -9984,6 +10340,9 @@ async function runWritePipeline(input, dryRun, enrichLinks2, runMode, noInteract
     if (finalError) {
       throw new ReportedError(withWriteResumeHint(finalError.message));
     }
+    if (exportPath && pipelineResult) {
+      await autoExport(exportPath, pipelineResult);
+    }
   } finally {
     cleanupSignalHandlers();
   }
@@ -10131,6 +10490,12 @@ async function promptForIdea() {
     readline.close();
   }
 }
+async function autoExport(exportPath, result) {
+  await runOutputCommand({
+    generationId: result.artifact.slug,
+    destinationPath: exportPath
+  });
+}
 
 // src/cli/app.ts
 var { version } = package_default;
@@ -10200,7 +10565,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-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) => {
+  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)).option("--export <path>", "Export the generated article to the given directory after writing").action(async (ideaArg, options) => {
     await runWriteCommand({
       idea: options.idea ?? ideaArg,
       audience: options.audience,
@@ -10216,17 +10581,19 @@ async function runCli(argv) {
       links: options.link,
       unlinks: options.unlink,
       maxLinks: options.maxLinks,
-      maxImages: options.maxImages
+      maxImages: options.maxImages,
+      exportPath: options.export
     });
   });
-  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) => {
+  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)).option("--export <path>", "Export the generated article to the given directory after writing").action(async (options) => {
     await runWriteResumeCommand({
       noInteractive: options.noInteractive,
       enrichLinks: options.enrichLinks,
       links: options.link,
       unlinks: options.unlink,
       maxLinks: options.maxLinks,
-      maxImages: options.maxImages
+      maxImages: options.maxImages,
+      exportPath: options.export
     });
   });
   await program.parseAsync(argv);