claudekit-cli 3.42.2-dev.8 → 3.42.2-dev.9

package/dist/index.js

@@ -6944,7 +6944,7 @@ function resolveModel(sourceModel, targetProvider) {
   }
   return { resolved: providerMap[tier] };
 }
-var OPENCODE_DEFAULT_MODEL = "anthropic/claude-sonnet-4-6", SOURCE_TIER_MAP, DEFAULT_PROVIDER_MODEL_MAP, userOverrides;
+var SOURCE_TIER_MAP, DEFAULT_PROVIDER_MODEL_MAP, userOverrides;
 var init_model_taxonomy = __esm(() => {
   SOURCE_TIER_MAP = {
     opus: "heavy",
@@ -62389,7 +62389,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "claudekit-cli",
-    version: "3.42.2-dev.8",
+    version: "3.42.2-dev.9",
     description: "CLI tool for bootstrapping and updating ClaudeKit projects",
     type: "module",
     repository: {
@@ -73556,10 +73556,10 @@ __export(exports_worktree_manager, {
   cleanupAllWorktrees: () => cleanupAllWorktrees
 });
 import { existsSync as existsSync69 } from "node:fs";
-import { readFile as readFile63, writeFile as writeFile36 } from "node:fs/promises";
-import { join as join151 } from "node:path";
+import { readFile as readFile65, writeFile as writeFile37 } from "node:fs/promises";
+import { join as join153 } from "node:path";
 async function createWorktree(projectDir, issueNumber, baseBranch) {
-  const worktreePath = join151(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
+  const worktreePath = join153(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
   const branchName = `ck-watch/issue-${issueNumber}`;
   await spawnAndCollect("git", ["fetch", "origin", baseBranch], projectDir).catch(() => {
     logger.warning(`[worktree] Could not fetch origin/${baseBranch}, using local`);
@@ -73577,7 +73577,7 @@ async function createWorktree(projectDir, issueNumber, baseBranch) {
   return worktreePath;
 }
 async function removeWorktree(projectDir, issueNumber) {
-  const worktreePath = join151(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
+  const worktreePath = join153(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
   const branchName = `ck-watch/issue-${issueNumber}`;
   try {
     await spawnAndCollect("git", ["worktree", "remove", worktreePath, "--force"], projectDir);
@@ -73591,7 +73591,7 @@ async function listActiveWorktrees(projectDir) {
   try {
     const output2 = await spawnAndCollect("git", ["worktree", "list", "--porcelain"], projectDir);
     const issueNumbers = [];
-    const worktreePrefix = join151(projectDir, WORKTREE_DIR, "issue-").replace(/\\/g, "/");
+    const worktreePrefix = join153(projectDir, WORKTREE_DIR, "issue-").replace(/\\/g, "/");
     for (const line of output2.split(`
 `)) {
       if (line.startsWith("worktree ")) {
@@ -73619,16 +73619,16 @@ async function cleanupAllWorktrees(projectDir) {
   await spawnAndCollect("git", ["worktree", "prune"], projectDir).catch(() => {});
 }
 async function ensureGitignore(projectDir) {
-  const gitignorePath = join151(projectDir, ".gitignore");
+  const gitignorePath = join153(projectDir, ".gitignore");
   try {
-    const content = existsSync69(gitignorePath) ? await readFile63(gitignorePath, "utf-8") : "";
+    const content = existsSync69(gitignorePath) ? await readFile65(gitignorePath, "utf-8") : "";
     if (!content.includes(".worktrees")) {
       const newContent = content.endsWith(`
 `) ? `${content}.worktrees/
 ` : `${content}
 .worktrees/
 `;
-      await writeFile36(gitignorePath, newContent, "utf-8");
+      await writeFile37(gitignorePath, newContent, "utf-8");
       logger.info("[worktree] Added .worktrees/ to .gitignore");
     }
   } catch (err) {
@@ -73657,15 +73657,15 @@ function countTwitterChars(text) {
   }
   return count;
 }
-function validateContent(content, platform17) {
+function validateContent(content, platform18) {
   const issues = [];
   if (!content.text || content.text.trim().length === 0) {
     issues.push("Content text is empty");
     return { valid: false, issues };
   }
-  if (platform17 !== "x_thread") {
-    const limit = platform17 === "facebook" ? 500 : 280;
-    const charCount = platform17 === "x" ? countTwitterChars(content.text) : content.text.length;
+  if (platform18 !== "x_thread") {
+    const limit = platform18 === "facebook" ? 500 : 280;
+    const charCount = platform18 === "x" ? countTwitterChars(content.text) : content.text.length;
     if (charCount > limit) {
       issues.push(`Text exceeds ${limit} char limit (${charCount} weighted chars)`);
     }
@@ -73688,7 +73688,7 @@ function validateContent(content, platform17) {
     issues.push("Hook (first sentence) is too long (>25 words)");
   }
   const hashtagCount = content.hashtags?.length ?? 0;
-  if (platform17 === "x" && hashtagCount > 5) {
+  if (platform18 === "x" && hashtagCount > 5) {
     issues.push("Too many hashtags for X (max 5)");
   }
   return { valid: issues.length === 0, issues };
@@ -73724,9 +73724,9 @@ var init_content_validator = __esm(() => {
 // src/commands/content/phases/context-cache-manager.ts
 import { createHash as createHash9 } from "node:crypto";
 import { existsSync as existsSync75, mkdirSync as mkdirSync5, readFileSync as readFileSync18, readdirSync as readdirSync11, statSync as statSync14 } from "node:fs";
-import { rename as rename14, writeFile as writeFile38 } from "node:fs/promises";
-import { homedir as homedir52 } from "node:os";
-import { basename as basename31, join as join158 } from "node:path";
+import { rename as rename15, writeFile as writeFile39 } from "node:fs/promises";
+import { homedir as homedir54 } from "node:os";
+import { basename as basename31, join as join160 } from "node:path";
 function getCachedContext(repoPath) {
   const cachePath = getCacheFilePath(repoPath);
   if (!existsSync75(cachePath))
@@ -73735,7 +73735,7 @@ function getCachedContext(repoPath) {
     const raw2 = readFileSync18(cachePath, "utf-8");
     const cache5 = JSON.parse(raw2);
     const age = Date.now() - new Date(cache5.createdAt).getTime();
-    if (age >= CACHE_TTL_MS4)
+    if (age >= CACHE_TTL_MS5)
       return null;
     const currentHash = computeSourceHash(repoPath);
     if (currentHash !== cache5.sourceHash)
@@ -73751,8 +73751,8 @@ async function saveCachedContext(repoPath, cache5) {
   }
   const cachePath = getCacheFilePath(repoPath);
   const tmpPath = `${cachePath}.tmp`;
-  await writeFile38(tmpPath, JSON.stringify(cache5, null, 2), "utf-8");
-  await rename14(tmpPath, cachePath);
+  await writeFile39(tmpPath, JSON.stringify(cache5, null, 2), "utf-8");
+  await rename15(tmpPath, cachePath);
 }
 function computeSourceHash(repoPath) {
   const hash = createHash9("sha256");
@@ -73769,25 +73769,25 @@ function computeSourceHash(repoPath) {
 }
 function getDocSourcePaths(repoPath) {
   const paths = [];
-  const docsDir = join158(repoPath, "docs");
+  const docsDir = join160(repoPath, "docs");
   if (existsSync75(docsDir)) {
     try {
       const files = readdirSync11(docsDir);
       for (const f3 of files) {
         if (f3.endsWith(".md"))
-          paths.push(join158(docsDir, f3));
+          paths.push(join160(docsDir, f3));
       }
     } catch {}
   }
-  const readme = join158(repoPath, "README.md");
+  const readme = join160(repoPath, "README.md");
   if (existsSync75(readme))
     paths.push(readme);
-  const stylesDir = join158(repoPath, "assets", "writing-styles");
+  const stylesDir = join160(repoPath, "assets", "writing-styles");
   if (existsSync75(stylesDir)) {
     try {
       const files = readdirSync11(stylesDir);
       for (const f3 of files) {
-        paths.push(join158(stylesDir, f3));
+        paths.push(join160(stylesDir, f3));
       }
     } catch {}
   }
@@ -73796,12 +73796,12 @@ function getDocSourcePaths(repoPath) {
 function getCacheFilePath(repoPath) {
   const repoName = basename31(repoPath).replace(/[^a-zA-Z0-9_-]/g, "_");
   const pathHash = createHash9("sha256").update(repoPath).digest("hex").slice(0, 8);
-  return join158(CACHE_DIR, `${repoName}-${pathHash}-context-cache.json`);
+  return join160(CACHE_DIR, `${repoName}-${pathHash}-context-cache.json`);
 }
-var CACHE_DIR, CACHE_TTL_MS4;
+var CACHE_DIR, CACHE_TTL_MS5;
 var init_context_cache_manager = __esm(() => {
-  CACHE_DIR = join158(homedir52(), ".claudekit", "cache");
-  CACHE_TTL_MS4 = 24 * 60 * 60 * 1000;
+  CACHE_DIR = join160(homedir54(), ".claudekit", "cache");
+  CACHE_TTL_MS5 = 24 * 60 * 60 * 1000;
 });
 
 // src/commands/content/phases/db-queries-git-events.ts
@@ -73981,7 +73981,7 @@ function extractContentFromResponse(response) {
 // src/commands/content/phases/docs-summarizer.ts
 import { execSync as execSync7 } from "node:child_process";
 import { existsSync as existsSync76, readFileSync as readFileSync19, readdirSync as readdirSync12 } from "node:fs";
-import { join as join159 } from "node:path";
+import { join as join161 } from "node:path";
 async function summarizeProjectDocs(repoPath, contentLogger) {
   const rawContent = collectRawDocs(repoPath);
   if (rawContent.total.length < 200) {
@@ -74035,12 +74035,12 @@ function collectRawDocs(repoPath) {
     return capped;
   };
   const docsContent = [];
-  const docsDir = join159(repoPath, "docs");
+  const docsDir = join161(repoPath, "docs");
   if (existsSync76(docsDir)) {
     try {
       const files = readdirSync12(docsDir).filter((f3) => f3.endsWith(".md")).sort();
       for (const f3 of files) {
-        const content = readCapped(join159(docsDir, f3), 5000);
+        const content = readCapped(join161(docsDir, f3), 5000);
         if (content) {
           docsContent.push(`### ${f3}
 ${content}`);
@@ -74054,21 +74054,21 @@ ${content}`);
   let brand = "";
   const brandCandidates = ["docs/brand-guidelines.md", "docs/design-guidelines.md"];
   for (const p of brandCandidates) {
-    brand = readCapped(join159(repoPath, p), 3000);
+    brand = readCapped(join161(repoPath, p), 3000);
     if (brand)
       break;
   }
   let styles3 = "";
-  const stylesDir = join159(repoPath, "assets", "writing-styles");
+  const stylesDir = join161(repoPath, "assets", "writing-styles");
   if (existsSync76(stylesDir)) {
     try {
       const files = readdirSync12(stylesDir).slice(0, 3);
-      styles3 = files.map((f3) => readCapped(join159(stylesDir, f3), 1000)).filter(Boolean).join(`
+      styles3 = files.map((f3) => readCapped(join161(stylesDir, f3), 1000)).filter(Boolean).join(`
 
 `);
     } catch {}
   }
-  const readme = readCapped(join159(repoPath, "README.md"), 3000);
+  const readme = readCapped(join161(repoPath, "README.md"), 3000);
   const total = [docs, brand, styles3, readme].join(`
 `);
   return { docs, brand, styles: styles3, readme, total };
@@ -74102,10 +74102,10 @@ var MAX_RAW_CONTENT_CHARS = 50000;
 var init_docs_summarizer = () => {};
 
 // src/commands/content/phases/context-builder.ts
-async function buildContentContext(event, repoPath, config, db, platform17, contentLogger) {
+async function buildContentContext(event, repoPath, config, db, platform18, contentLogger) {
   const cached = getCachedContext(repoPath);
   if (cached) {
-    return buildFromCache(cached, event, db, platform17, config);
+    return buildFromCache(cached, event, db, platform18, config);
   }
   const noopLogger = { debug: () => {}, info: () => {}, warn: () => {}, error: () => {} };
   const log2 = contentLogger ?? noopLogger;
@@ -74120,16 +74120,16 @@ async function buildContentContext(event, repoPath, config, db, platform17, cont
     sourceHash: hash
   };
   await saveCachedContext(repoPath, newCache);
-  return buildFromCache(newCache, event, db, platform17, config);
+  return buildFromCache(newCache, event, db, platform18, config);
 }
-function buildFromCache(cache5, event, db, platform17, config) {
+function buildFromCache(cache5, event, db, platform18, config) {
   return {
     brandGuidelines: cache5.brandSummary,
     writingStyles: cache5.stylesSummary,
     gitEventDetails: formatGitEvent(event),
     recentContent: formatRecentContent(db),
     topPerformingContent: "",
-    platformRules: getPlatformRules(platform17, config),
+    platformRules: getPlatformRules(platform18, config),
     projectReadme: cache5.readmeSummary,
     projectDocsSummary: cache5.docsSummary,
     currentDateTime: new Date().toISOString()
@@ -74158,8 +74158,8 @@ function formatRecentContent(db) {
   return recent.map((c2) => `[${c2.platform}] ${c2.textContent.slice(0, 100)}`).join(`
 `);
 }
-function getPlatformRules(platform17, config) {
-  switch (platform17) {
+function getPlatformRules(platform18, config) {
+  switch (platform18) {
     case "x":
       return [
         "Platform: X (Twitter)",
@@ -74198,8 +74198,8 @@ var init_context_builder = __esm(() => {
 });
 
 // src/commands/content/phases/prompt-templates.ts
-function buildTextPrompt(context, platform17) {
-  const charLimit = platform17 === "x" || platform17 === "x_thread" ? 280 : 500;
+function buildTextPrompt(context, platform18) {
+  const charLimit = platform18 === "x" || platform18 === "x_thread" ? 280 : 500;
   return `You are a social media content creator.
 
 ## Project Context
@@ -74214,14 +74214,14 @@ ${context.writingStyles}
 ## Content Source
 ${context.gitEventDetails}
 
-## Platform: ${platform17}
+## Platform: ${platform18}
 ${context.platformRules}
 
 ## Past Content (avoid repetition)
 ${context.recentContent}
 
 ## Instructions
-1. Create a ${platform17} post about this development update
+1. Create a ${platform18} post about this development update
 2. Start with a compelling hook that creates curiosity
 3. Keep it conversational and authentic (avoid AI-sounding language)
 4. No generic statements — be specific about what changed and why it matters
@@ -74231,8 +74231,8 @@ ${context.recentContent}
 
 IMPORTANT: Output ONLY the JSON object, nothing else.`;
 }
-function buildPhotoPrompt(context, platform17) {
-  const dimensions = platform17 === "facebook" ? "1200x630" : "1200x675";
+function buildPhotoPrompt(context, platform18) {
+  const dimensions = platform18 === "facebook" ? "1200x630" : "1200x675";
   return `Generate an image for this social media post.
 
 ## Brand Guidelines
@@ -74254,15 +74254,15 @@ IMPORTANT: Generate the image and output the path as JSON: {"imagePath": "/path/
 // src/commands/content/phases/photo-generator.ts
 import { execSync as execSync8 } from "node:child_process";
 import { existsSync as existsSync77, mkdirSync as mkdirSync6, readdirSync as readdirSync13 } from "node:fs";
-import { homedir as homedir53 } from "node:os";
-import { join as join160 } from "node:path";
-async function generatePhoto(_content, context, config, platform17, contentId, contentLogger) {
-  const mediaDir = join160(config.contentDir.replace(/^~/, homedir53()), "media", String(contentId));
+import { homedir as homedir55 } from "node:os";
+import { join as join162 } from "node:path";
+async function generatePhoto(_content, context, config, platform18, contentId, contentLogger) {
+  const mediaDir = join162(config.contentDir.replace(/^~/, homedir55()), "media", String(contentId));
   if (!existsSync77(mediaDir)) {
     mkdirSync6(mediaDir, { recursive: true });
   }
-  const prompt = buildPhotoPrompt(context, platform17);
-  const dimensions = platform17 === "facebook" ? { width: 1200, height: 630 } : { width: 1200, height: 675 };
+  const prompt = buildPhotoPrompt(context, platform18);
+  const dimensions = platform18 === "facebook" ? { width: 1200, height: 630 } : { width: 1200, height: 675 };
   try {
     contentLogger.debug(`Generating photo for content ${contentId}...`);
     const result = execSync8("claude -p --output-format text --max-turns 40", {
@@ -74282,7 +74282,7 @@ async function generatePhoto(_content, context, config, platform17, contentId, c
     const imageFile = files.find((f3) => /\.(png|jpg|jpeg|webp)$/i.test(f3));
     if (imageFile) {
       const ext2 = imageFile.split(".").pop() ?? "png";
-      return { path: join160(mediaDir, imageFile), ...dimensions, format: ext2 };
+      return { path: join162(mediaDir, imageFile), ...dimensions, format: ext2 };
     }
     contentLogger.warn(`Photo generation produced no image for content ${contentId}`);
     return null;
@@ -74300,14 +74300,14 @@ async function createContent(event, config, db, contentLogger, options2) {
   const startTime = Date.now();
   const items = [];
   const platforms = resolveEnabledPlatforms(config);
-  for (const platform17 of platforms) {
+  for (const platform18 of platforms) {
     try {
-      const item = await createContentForPlatform(event, platform17, config, db, contentLogger, options2);
+      const item = await createContentForPlatform(event, platform18, config, db, contentLogger, options2);
       if (item)
         items.push(item);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      contentLogger.error(`Failed to create ${platform17} content: ${msg}`);
+      contentLogger.error(`Failed to create ${platform18} content: ${msg}`);
     }
   }
   insertTaskLog(db, {
@@ -74326,10 +74326,10 @@ function resolveEnabledPlatforms(config) {
     platforms.push("facebook");
   return platforms;
 }
-async function createContentForPlatform(event, platform17, config, db, contentLogger, options2) {
-  const context = await buildContentContext(event, event.repoPath, config, db, platform17, contentLogger);
-  const prompt = buildTextPrompt(context, platform17);
-  contentLogger.debug(`Generating ${platform17} content for event ${event.id}...`);
+async function createContentForPlatform(event, platform18, config, db, contentLogger, options2) {
+  const context = await buildContentContext(event, event.repoPath, config, db, platform18, contentLogger);
+  const prompt = buildTextPrompt(context, platform18);
+  contentLogger.debug(`Generating ${platform18} content for event ${event.id}...`);
   const stdout2 = execSync9("claude -p --output-format text --max-turns 5", {
     input: prompt,
     stdio: ["pipe", "pipe", "pipe"],
@@ -74337,14 +74337,14 @@ async function createContentForPlatform(event, platform17, config, db, contentLo
   }).toString();
   const parsed = parseClaudeJsonOutput(stdout2);
   const generated = extractContentFromResponse(parsed);
-  const validation = validateContent(generated, platform17);
+  const validation = validateContent(generated, platform18);
   if (!validation.valid) {
-    contentLogger.warn(`Content validation failed for ${platform17}: ${validation.issues.join(", ")}`);
+    contentLogger.warn(`Content validation failed for ${platform18}: ${validation.issues.join(", ")}`);
   }
   const status = validation.valid ? config.reviewMode === "auto" ? "scheduled" : "reviewing" : "draft";
   const itemId = insertContentItem(db, {
     gitEventId: event.id,
-    platform: platform17,
+    platform: platform18,
     textContent: generated.text,
     hashtags: JSON.stringify(generated.hashtags),
     hookLine: generated.hook,
@@ -74354,12 +74354,12 @@ async function createContentForPlatform(event, platform17, config, db, contentLo
     scheduledAt: null
   });
   if (!options2.dryRun && generated.mediaPrompt) {
-    const photo = await generatePhoto(generated, context, config, platform17, itemId, contentLogger);
+    const photo = await generatePhoto(generated, context, config, platform18, itemId, contentLogger);
     if (photo) {
       db.prepare("UPDATE content_items SET media_path = ? WHERE id = ?").run(photo.path, itemId);
     }
   }
-  contentLogger.info(`Created ${platform17} content (id: ${itemId}, status: ${status})`);
+  contentLogger.info(`Created ${platform18} content (id: ${itemId}, status: ${status})`);
   return getContentById(db, itemId);
 }
 var init_content_creator = __esm(() => {
@@ -74371,8 +74371,8 @@ var init_content_creator = __esm(() => {
 
 // src/commands/content/phases/content-logger.ts
 import { createWriteStream as createWriteStream4, existsSync as existsSync78, mkdirSync as mkdirSync7, statSync as statSync15 } from "node:fs";
-import { homedir as homedir54 } from "node:os";
-import { join as join161 } from "node:path";
+import { homedir as homedir56 } from "node:os";
+import { join as join163 } from "node:path";
 
 class ContentLogger {
   stream = null;
@@ -74380,7 +74380,7 @@ class ContentLogger {
   logDir;
   maxBytes;
   constructor(maxBytes = 0) {
-    this.logDir = join161(homedir54(), ".claudekit", "logs");
+    this.logDir = join163(homedir56(), ".claudekit", "logs");
     this.maxBytes = maxBytes;
   }
   init() {
@@ -74412,7 +74412,7 @@ class ContentLogger {
     }
   }
   getLogPath() {
-    return join161(this.logDir, `content-${this.getDateStr()}.log`);
+    return join163(this.logDir, `content-${this.getDateStr()}.log`);
   }
   write(level, message) {
     this.rotateIfNeeded();
@@ -74429,19 +74429,19 @@ class ContentLogger {
     if (dateStr !== this.currentDate) {
       this.close();
       this.currentDate = dateStr;
-      const logPath = join161(this.logDir, `content-${dateStr}.log`);
+      const logPath = join163(this.logDir, `content-${dateStr}.log`);
       this.stream = createWriteStream4(logPath, { flags: "a", mode: 384 });
       return;
     }
     if (this.maxBytes > 0 && this.stream) {
-      const logPath = join161(this.logDir, `content-${this.currentDate}.log`);
+      const logPath = join163(this.logDir, `content-${this.currentDate}.log`);
       try {
         const stat26 = statSync15(logPath);
         if (stat26.size >= this.maxBytes) {
           this.close();
           const suffix = Date.now();
-          const rotatedPath = join161(this.logDir, `content-${this.currentDate}-${suffix}.log`);
-          import("node:fs/promises").then(({ rename: rename15 }) => rename15(logPath, rotatedPath).catch(() => {}));
+          const rotatedPath = join163(this.logDir, `content-${this.currentDate}-${suffix}.log`);
+          import("node:fs/promises").then(({ rename: rename16 }) => rename16(logPath, rotatedPath).catch(() => {}));
           this.stream = createWriteStream4(logPath, { flags: "w", mode: 384 });
         }
       } catch {}
@@ -74666,7 +74666,7 @@ function isNoiseCommit(title, author) {
 // src/commands/content/phases/change-detector.ts
 import { execSync as execSync10, spawnSync as spawnSync9 } from "node:child_process";
 import { existsSync as existsSync80, readFileSync as readFileSync20, readdirSync as readdirSync14, statSync as statSync16 } from "node:fs";
-import { join as join162 } from "node:path";
+import { join as join164 } from "node:path";
 function detectCommits(repo, since) {
   try {
     const fetchUrl = sshToHttps(repo.remoteUrl);
@@ -74775,7 +74775,7 @@ function detectTags(repo, since) {
   }
 }
 function detectCompletedPlans(repo, since) {
-  const plansDir = join162(repo.path, "plans");
+  const plansDir = join164(repo.path, "plans");
   if (!existsSync80(plansDir))
     return [];
   const sinceMs = new Date(since).getTime();
@@ -74785,7 +74785,7 @@ function detectCompletedPlans(repo, since) {
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const planFile = join162(plansDir, entry.name, "plan.md");
+      const planFile = join164(plansDir, entry.name, "plan.md");
       if (!existsSync80(planFile))
         continue;
       try {
@@ -74863,7 +74863,7 @@ function classifyCommit(event) {
 // src/commands/content/phases/repo-discoverer.ts
 import { execSync as execSync11 } from "node:child_process";
 import { readdirSync as readdirSync15 } from "node:fs";
-import { join as join163 } from "node:path";
+import { join as join165 } from "node:path";
 function discoverRepos2(cwd2) {
   const repos = [];
   if (isGitRepoRoot(cwd2)) {
@@ -74876,7 +74876,7 @@ function discoverRepos2(cwd2) {
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith("."))
         continue;
-      const dirPath = join163(cwd2, entry.name);
+      const dirPath = join165(cwd2, entry.name);
       if (isGitRepoRoot(dirPath)) {
         const info = getRepoInfo(dirPath);
         if (info)
@@ -75246,15 +75246,15 @@ class RateLimiter {
     this.state = state;
     this.config = config;
   }
-  canPost(platform17) {
-    return this.getTodayCount(platform17) < this.getMaxPerDay(platform17);
+  canPost(platform18) {
+    return this.getTodayCount(platform18) < this.getMaxPerDay(platform18);
   }
-  recordPost(platform17) {
-    const key = this.dailyKey(platform17);
+  recordPost(platform18) {
+    const key = this.dailyKey(platform18);
     this.state.dailyPostCounts[key] = (this.state.dailyPostCounts[key] ?? 0) + 1;
   }
-  getRemainingToday(platform17) {
-    return Math.max(0, this.getMaxPerDay(platform17) - this.getTodayCount(platform17));
+  getRemainingToday(platform18) {
+    return Math.max(0, this.getMaxPerDay(platform18) - this.getTodayCount(platform18));
   }
   isInQuietHours() {
     const { timezone, quietHoursStart, quietHoursEnd } = this.config.schedule;
@@ -75274,19 +75274,19 @@ class RateLimiter {
       return false;
     }
   }
-  getMaxPerDay(platform17) {
-    if (platform17 === "x" || platform17 === "x_thread") {
+  getMaxPerDay(platform18) {
+    if (platform18 === "x" || platform18 === "x_thread") {
       return this.config.platforms.x.maxPostsPerDay;
     }
-    if (platform17 === "facebook") {
+    if (platform18 === "facebook") {
       return this.config.platforms.facebook.maxPostsPerDay;
     }
     return this.config.maxContentPerDay;
   }
-  getTodayCount(platform17) {
-    return this.state.dailyPostCounts[this.dailyKey(platform17)] ?? 0;
+  getTodayCount(platform18) {
+    return this.state.dailyPostCounts[this.dailyKey(platform18)] ?? 0;
   }
-  dailyKey(platform17) {
+  dailyKey(platform18) {
     const { timezone } = this.config.schedule;
     let dateStr;
     try {
@@ -75300,7 +75300,7 @@ class RateLimiter {
     } catch {
       dateStr = new Date().toISOString().slice(0, 10);
     }
-    return `${platform17}-${dateStr}`;
+    return `${platform18}-${dateStr}`;
   }
 }
 
@@ -75417,8 +75417,8 @@ function previewContent(content) {
   console.log(import_picocolors42.default.dim("─".repeat(60)));
   console.log();
 }
-function getPlatformBadge(platform17) {
-  switch (platform17) {
+function getPlatformBadge(platform18) {
+  switch (platform18) {
     case "x":
       return import_picocolors42.default.bgBlue(import_picocolors42.default.white(" X "));
     case "x_thread":
@@ -75426,7 +75426,7 @@ function getPlatformBadge(platform17) {
     case "facebook":
       return import_picocolors42.default.bgCyan(import_picocolors42.default.white(" Facebook "));
     default:
-      return import_picocolors42.default.bgBlack(import_picocolors42.default.white(` ${platform17} `));
+      return import_picocolors42.default.bgBlack(import_picocolors42.default.white(` ${platform18} `));
   }
 }
 function getStatusColor(status) {
@@ -75543,12 +75543,12 @@ var init_types6 = __esm(() => {
 });
 
 // src/commands/content/phases/state-manager.ts
-import { readFile as readFile65, rename as rename15, writeFile as writeFile39 } from "node:fs/promises";
-import { join as join164 } from "node:path";
+import { readFile as readFile67, rename as rename16, writeFile as writeFile40 } from "node:fs/promises";
+import { join as join166 } from "node:path";
 async function loadContentConfig(projectDir) {
-  const configPath = join164(projectDir, CK_CONFIG_FILE2);
+  const configPath = join166(projectDir, CK_CONFIG_FILE2);
   try {
-    const raw2 = await readFile65(configPath, "utf-8");
+    const raw2 = await readFile67(configPath, "utf-8");
     const json = JSON.parse(raw2);
     return ContentConfigSchema.parse(json.content ?? {});
   } catch {
@@ -75556,15 +75556,15 @@ async function loadContentConfig(projectDir) {
   }
 }
 async function saveContentConfig(projectDir, config) {
-  const configPath = join164(projectDir, CK_CONFIG_FILE2);
+  const configPath = join166(projectDir, CK_CONFIG_FILE2);
   const json = await readJsonSafe(configPath);
   json.content = { ...json.content, ...config };
   await atomicWrite2(configPath, json);
 }
 async function loadContentState(projectDir) {
-  const configPath = join164(projectDir, CK_CONFIG_FILE2);
+  const configPath = join166(projectDir, CK_CONFIG_FILE2);
   try {
-    const raw2 = await readFile65(configPath, "utf-8");
+    const raw2 = await readFile67(configPath, "utf-8");
     const json = JSON.parse(raw2);
     const contentBlock = json.content ?? {};
     return ContentStateSchema.parse(contentBlock.state ?? {});
@@ -75573,7 +75573,7 @@ async function loadContentState(projectDir) {
   }
 }
 async function saveContentState(projectDir, state) {
-  const configPath = join164(projectDir, CK_CONFIG_FILE2);
+  const configPath = join166(projectDir, CK_CONFIG_FILE2);
   const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString().slice(0, 10);
   for (const key of Object.keys(state.dailyPostCounts)) {
     const dateStr = key.slice(-10);
@@ -75591,7 +75591,7 @@ async function saveContentState(projectDir, state) {
 }
 async function readJsonSafe(filePath) {
   try {
-    const raw2 = await readFile65(filePath, "utf-8");
+    const raw2 = await readFile67(filePath, "utf-8");
     return JSON.parse(raw2);
   } catch {
     return {};
@@ -75599,8 +75599,8 @@ async function readJsonSafe(filePath) {
 }
 async function atomicWrite2(filePath, data) {
   const tmpPath = `${filePath}.tmp`;
-  await writeFile39(tmpPath, JSON.stringify(data, null, 2), "utf-8");
-  await rename15(tmpPath, filePath);
+  await writeFile40(tmpPath, JSON.stringify(data, null, 2), "utf-8");
+  await rename16(tmpPath, filePath);
 }
 var CK_CONFIG_FILE2 = ".ck.json";
 var init_state_manager = __esm(() => {
@@ -75706,15 +75706,15 @@ async function autoInstallFbcli(contentLogger) {
     contentLogger.warn("go install failed or Go not available");
   }
   try {
-    const { platform: platform17, arch: arch3 } = process;
+    const { platform: platform18, arch: arch3 } = process;
     const osMap = { darwin: "darwin", linux: "linux", win32: "windows" };
     const archMap = { arm64: "arm64", x64: "amd64" };
-    const os7 = osMap[platform17];
+    const os7 = osMap[platform18];
     const cpu = archMap[arch3];
     if (os7 && cpu) {
-      const ext2 = platform17 === "win32" ? ".exe" : "";
+      const ext2 = platform18 === "win32" ? ".exe" : "";
       const url = `https://github.com/mrgoonie/fbcli/releases/latest/download/fbcli_${os7}_${cpu}${ext2}`;
-      const dest = platform17 === "win32" ? "fbcli.exe" : "/usr/local/bin/fbcli";
+      const dest = platform18 === "win32" ? "fbcli.exe" : "/usr/local/bin/fbcli";
       f2.warning(`Will download fbcli binary from: ${url}`);
       f2.warning("Note: Binary integrity is not verified. Review the source at https://github.com/mrgoonie/fbcli");
       const consent = await se({ message: `Download and install fbcli to ${dest}?` });
@@ -75798,15 +75798,15 @@ async function autoInstallXurl(contentLogger) {
     contentLogger.warn("go install failed or Go not available");
   }
   try {
-    const { platform: platform17, arch: arch3 } = process;
+    const { platform: platform18, arch: arch3 } = process;
     const osMap = { darwin: "darwin", linux: "linux", win32: "windows" };
     const archMap = { arm64: "arm64", x64: "amd64" };
-    const os7 = osMap[platform17];
+    const os7 = osMap[platform18];
     const cpu = archMap[arch3];
     if (os7 && cpu) {
-      const ext2 = platform17 === "win32" ? ".exe" : "";
+      const ext2 = platform18 === "win32" ? ".exe" : "";
       const url = `https://github.com/xdevplatform/xurl/releases/latest/download/xurl_${os7}_${cpu}${ext2}`;
-      const dest = platform17 === "win32" ? "xurl.exe" : "/usr/local/bin/xurl";
+      const dest = platform18 === "win32" ? "xurl.exe" : "/usr/local/bin/xurl";
       f2.info(`Downloading xurl binary for ${os7}/${cpu}...`);
       execSync14(`curl -fsSL "${url}" -o "${dest}" && chmod +x "${dest}"`, {
         stdio: "inherit",
@@ -75855,7 +75855,7 @@ var init_platform_setup_x = __esm(() => {
 
 // src/commands/content/phases/setup-wizard.ts
 import { existsSync as existsSync81 } from "node:fs";
-import { join as join165 } from "node:path";
+import { join as join167 } from "node:path";
 async function runSetupWizard2(cwd2, contentLogger) {
   console.log();
   oe(import_picocolors43.default.bgCyan(import_picocolors43.default.white(" CK Content — Multi-Channel Content Engine ")));
@@ -75923,8 +75923,8 @@ async function showRepoSummary(cwd2) {
 function detectBrandAssets(cwd2, contentLogger) {
   const repos = discoverRepos2(cwd2);
   for (const repo of repos) {
-    const hasGuidelines = existsSync81(join165(repo.path, "docs", "brand-guidelines.md"));
-    const hasStyles = existsSync81(join165(repo.path, "assets", "writing-styles"));
+    const hasGuidelines = existsSync81(join167(repo.path, "docs", "brand-guidelines.md"));
+    const hasStyles = existsSync81(join167(repo.path, "assets", "writing-styles"));
     if (!hasGuidelines) {
       f2.warning(`${repo.name}: No docs/brand-guidelines.md — content will use generic tone.`);
       contentLogger.warn(`${repo.name}: missing docs/brand-guidelines.md`);
@@ -75991,11 +75991,11 @@ var init_setup_wizard = __esm(() => {
 
 // src/commands/content/content-review-commands.ts
 import { existsSync as existsSync82 } from "node:fs";
-import { homedir as homedir55 } from "node:os";
+import { homedir as homedir57 } from "node:os";
 async function queueContent() {
   const cwd2 = process.cwd();
   const config = await loadContentConfig(cwd2);
-  const dbPath = config.dbPath.replace(/^~/, homedir55());
+  const dbPath = config.dbPath.replace(/^~/, homedir57());
   if (!existsSync82(dbPath)) {
     logger.info("No content database found. Run 'ck content setup' first.");
     return;
@@ -76022,7 +76022,7 @@ async function queueContent() {
 async function approveContentCmd(id) {
   const cwd2 = process.cwd();
   const config = await loadContentConfig(cwd2);
-  const dbPath = config.dbPath.replace(/^~/, homedir55());
+  const dbPath = config.dbPath.replace(/^~/, homedir57());
   const db = initDatabase(dbPath);
   try {
     approveContent(db, Number.parseInt(id, 10));
@@ -76034,7 +76034,7 @@ async function approveContentCmd(id) {
 async function rejectContentCmd(id, reason) {
   const cwd2 = process.cwd();
   const config = await loadContentConfig(cwd2);
-  const dbPath = config.dbPath.replace(/^~/, homedir55());
+  const dbPath = config.dbPath.replace(/^~/, homedir57());
   const db = initDatabase(dbPath);
   try {
     rejectContent(db, Number.parseInt(id, 10), reason);
@@ -76065,10 +76065,10 @@ __export(exports_content_subcommands, {
   approveContentCmd: () => approveContentCmd
 });
 import { existsSync as existsSync83, readFileSync as readFileSync21, unlinkSync as unlinkSync6 } from "node:fs";
-import { homedir as homedir56 } from "node:os";
-import { join as join166 } from "node:path";
+import { homedir as homedir58 } from "node:os";
+import { join as join168 } from "node:path";
 function isDaemonRunning() {
-  const lockFile = join166(LOCK_DIR, `${LOCK_NAME2}.lock`);
+  const lockFile = join168(LOCK_DIR, `${LOCK_NAME2}.lock`);
   if (!existsSync83(lockFile))
     return { running: false, pid: null };
   try {
@@ -76100,7 +76100,7 @@ async function startContent(options2) {
   await contentCommand(options2);
 }
 async function stopContent() {
-  const lockFile = join166(LOCK_DIR, `${LOCK_NAME2}.lock`);
+  const lockFile = join168(LOCK_DIR, `${LOCK_NAME2}.lock`);
   if (!existsSync83(lockFile)) {
     logger.info("Content daemon is not running.");
     return;
@@ -76139,9 +76139,9 @@ async function statusContent() {
   } catch {}
 }
 async function logsContent(options2) {
-  const logDir = join166(homedir56(), ".claudekit", "logs");
+  const logDir = join168(homedir58(), ".claudekit", "logs");
   const dateStr = new Date().toISOString().slice(0, 10).replace(/-/g, "");
-  const logPath = join166(logDir, `content-${dateStr}.log`);
+  const logPath = join168(logDir, `content-${dateStr}.log`);
   if (!existsSync83(logPath)) {
     logger.info("No content logs found for today.");
     return;
@@ -76173,13 +76173,13 @@ var init_content_subcommands = __esm(() => {
   init_setup_wizard();
   init_state_manager();
   init_content_review_commands();
-  LOCK_DIR = join166(homedir56(), ".claudekit", "locks");
+  LOCK_DIR = join168(homedir58(), ".claudekit", "locks");
 });
 
 // src/commands/content/content-command.ts
 import { existsSync as existsSync84, mkdirSync as mkdirSync9, unlinkSync as unlinkSync7, writeFileSync as writeFileSync7 } from "node:fs";
-import { homedir as homedir57 } from "node:os";
-import { join as join167 } from "node:path";
+import { homedir as homedir59 } from "node:os";
+import { join as join169 } from "node:path";
 async function contentCommand(options2) {
   const cwd2 = process.cwd();
   const contentLogger = new ContentLogger;
@@ -76211,7 +76211,7 @@ async function contentCommand(options2) {
     if (!existsSync84(LOCK_DIR2))
       mkdirSync9(LOCK_DIR2, { recursive: true });
     writeFileSync7(LOCK_FILE, String(process.pid), "utf-8");
-    const dbPath = config.dbPath.replace(/^~/, homedir57());
+    const dbPath = config.dbPath.replace(/^~/, homedir59());
     const db = initDatabase(dbPath);
     contentLogger.info(`Database initialised at ${dbPath}`);
     const adapters = initializeAdapters(config);
@@ -76357,8 +76357,8 @@ var init_content_command = __esm(() => {
   init_publisher();
   init_review_manager();
   init_state_manager();
-  LOCK_DIR2 = join167(homedir57(), ".claudekit", "locks");
-  LOCK_FILE = join167(LOCK_DIR2, "ck-content.lock");
+  LOCK_DIR2 = join169(homedir59(), ".claudekit", "locks");
+  LOCK_FILE = join169(LOCK_DIR2, "ck-content.lock");
 });
 
 // src/commands/content/index.ts
@@ -107075,9 +107075,9 @@ async function initCommand(options2) {
 init_dist2();
 var import_picocolors30 = __toESM(require_picocolors(), 1);
 import { existsSync as existsSync64 } from "node:fs";
-import { readFile as readFile61, rm as rm16, unlink as unlink13 } from "node:fs/promises";
-import { homedir as homedir50 } from "node:os";
-import { basename as basename27, join as join142, resolve as resolve41 } from "node:path";
+import { readFile as readFile63, rm as rm16, unlink as unlink13 } from "node:fs/promises";
+import { homedir as homedir52 } from "node:os";
+import { basename as basename27, join as join144, resolve as resolve41 } from "node:path";
 init_logger();
 
 // src/ui/ck-cli-design/tokens.ts
@@ -107549,32 +107549,262 @@ init_model_taxonomy();
 init_logger();
 init_dist2();
 init_model_taxonomy();
-import { mkdir as mkdir36, readFile as readFile60, writeFile as writeFile35 } from "node:fs/promises";
+import { mkdir as mkdir37, readFile as readFile62, writeFile as writeFile36 } from "node:fs/promises";
+import { homedir as homedir51 } from "node:os";
+import { dirname as dirname41, join as join143 } from "node:path";
+
+// src/commands/portable/models-dev-cache.ts
+init_logger();
+import { mkdir as mkdir36, readFile as readFile60, rename as rename13, writeFile as writeFile35 } from "node:fs/promises";
 import { homedir as homedir49 } from "node:os";
-import { dirname as dirname41, join as join141 } from "node:path";
-function getOpenCodeConfigPath(options2) {
-  if (options2.global) {
-    return join141(options2.homeDir ?? homedir49(), ".config", "opencode", "opencode.json");
+import { join as join141 } from "node:path";
+
+class ModelsDevUnavailableError extends Error {
+  constructor(message, cause) {
+    super(message, { cause });
+    this.name = "ModelsDevUnavailableError";
+  }
+}
+var MODELS_DEV_URL = "https://models.dev/api.json";
+var CACHE_TTL_MS3 = 24 * 60 * 60 * 1000;
+var FETCH_TIMEOUT_MS = 1e4;
+function defaultCacheDir() {
+  return join141(homedir49(), ".config", "claudekit", "cache");
+}
+function cacheFilePath(cacheDir) {
+  return join141(cacheDir, "models-dev.json");
+}
+function tmpFilePath(cacheDir) {
+  return join141(cacheDir, "models-dev.json.tmp");
+}
+async function readCacheEntry(cacheDir) {
+  const filePath = cacheFilePath(cacheDir);
+  try {
+    const raw2 = await readFile60(filePath, "utf-8");
+    const parsed = JSON.parse(raw2);
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) && "fetchedAt" in parsed && typeof parsed.fetchedAt === "string" && "payload" in parsed && typeof parsed.payload === "object" && parsed.payload !== null) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function isCacheFresh(entry) {
+  const fetchedAt = new Date(entry.fetchedAt).getTime();
+  return Date.now() - fetchedAt < CACHE_TTL_MS3;
+}
+async function writeCacheEntry(cacheDir, entry) {
+  await mkdir36(cacheDir, { recursive: true });
+  const tmp = tmpFilePath(cacheDir);
+  const dest = cacheFilePath(cacheDir);
+  await writeFile35(tmp, JSON.stringify(entry), "utf-8");
+  await rename13(tmp, dest);
+}
+async function fetchCatalog(fetcher) {
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const response = await fetcher(MODELS_DEV_URL, { signal: controller.signal });
+    if (!response.ok) {
+      throw new Error(`models.dev returned HTTP ${response.status}`);
+    }
+    const json = await response.json();
+    if (json === null || typeof json !== "object" || Array.isArray(json)) {
+      throw new Error("models.dev response is not an object");
+    }
+    return json;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function getModelsDevCatalog(opts = {}) {
+  const cacheDir = opts.cacheDir ?? defaultCacheDir();
+  const fetcher = opts.fetcher ?? globalThis.fetch;
+  const cached = await readCacheEntry(cacheDir);
+  if (cached !== null && isCacheFresh(cached)) {
+    return cached.payload;
+  }
+  try {
+    const payload = await fetchCatalog(fetcher);
+    const entry = {
+      fetchedAt: new Date().toISOString(),
+      payload
+    };
+    try {
+      await writeCacheEntry(cacheDir, entry);
+    } catch (writeErr) {
+      logger.verbose(`models-dev-cache: failed to write cache to ${cacheDir}: ${String(writeErr)}`);
+    }
+    return payload;
+  } catch (fetchErr) {
+    if (cached !== null) {
+      logger.warning(`models-dev-cache: fetch failed (${String(fetchErr)}), using stale cache from ${cached.fetchedAt}`);
+      return cached.payload;
+    }
+    throw new ModelsDevUnavailableError(`models.dev catalog unavailable: ${String(fetchErr)}`, fetchErr);
   }
-  return join141(options2.cwd ?? process.cwd(), "opencode.json");
 }
-async function detectAuthenticatedProviders(homeDir) {
-  const authPath = join141(homeDir ?? homedir49(), ".local", "share", "opencode", "auth.json");
+
+// src/commands/portable/opencode-model-discovery.ts
+init_logger();
+import { readFile as readFile61 } from "node:fs/promises";
+import { homedir as homedir50, platform as platform17 } from "node:os";
+import { join as join142 } from "node:path";
+function resolveOpenCodeAuthPath(homeDir) {
+  if (platform17() === "win32") {
+    const dataRoot2 = process.env.LOCALAPPDATA ?? join142(homeDir, "AppData", "Local");
+    return join142(dataRoot2, "opencode", "auth.json");
+  }
+  const dataRoot = process.env.XDG_DATA_HOME ?? join142(homeDir, ".local", "share");
+  return join142(dataRoot, "opencode", "auth.json");
+}
+async function readAuthedProviders(homeDir) {
+  const authPath = resolveOpenCodeAuthPath(homeDir);
   try {
-    const raw2 = await readFile60(authPath, "utf-8");
+    const raw2 = await readFile61(authPath, "utf-8");
     const parsed = JSON.parse(raw2);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
       return Object.keys(parsed);
     }
   } catch {}
   return [];
 }
-async function suggestOpenCodeDefaultModel(homeDir) {
+function releaseDateMs(model) {
+  const d3 = new Date(model.release_date);
+  return Number.isNaN(d3.getTime()) ? 0 : d3.getTime();
+}
+function sortByDateDesc(models) {
+  return [...models].sort((a3, b3) => releaseDateMs(b3) - releaseDateMs(a3));
+}
+function pickOpenCodeModel(models) {
+  const all = Object.values(models);
+  const freeCallable = all.filter((m2) => m2.tool_call && m2.id.endsWith("-free"));
+  const sortedFree = sortByDateDesc(freeCallable);
+  const topFree = sortedFree[0];
+  if (topFree !== undefined) {
+    return topFree;
+  }
+  const callable = all.filter((m2) => m2.tool_call);
+  const sortedCallable = sortByDateDesc(callable);
+  return sortedCallable[0] ?? null;
+}
+function pickGenericModel(models) {
+  const callable = Object.values(models).filter((m2) => m2.tool_call);
+  const sorted = sortByDateDesc(callable);
+  return sorted[0] ?? null;
+}
+async function resolveOpenCodeDefaultModel(opts = {}) {
+  const home9 = opts.homeDir ?? homedir50();
+  const authedProviders = await readAuthedProviders(home9);
+  if (authedProviders.length === 0) {
+    return { ok: false, reason: "no-auth", authedProviders: [] };
+  }
+  let catalog;
+  try {
+    catalog = await getModelsDevCatalog({ fetcher: opts.fetcher, cacheDir: opts.cacheDir });
+  } catch (err) {
+    if (err instanceof ModelsDevUnavailableError) {
+      logger.verbose(`opencode-model-discovery: models.dev unavailable, cannot auto-resolve model: ${err.message}`);
+      return { ok: false, reason: "catalog-unavailable", authedProviders };
+    }
+    throw err;
+  }
+  const orderedProviders = [
+    ...authedProviders.filter((id) => id === "opencode"),
+    ...authedProviders.filter((id) => id !== "opencode")
+  ];
+  for (const providerId of orderedProviders) {
+    const providerEntry = catalog[providerId];
+    if (!providerEntry) {
+      continue;
+    }
+    const picked = providerId === "opencode" ? pickOpenCodeModel(providerEntry.models) : pickGenericModel(providerEntry.models);
+    if (!picked) {
+      continue;
+    }
+    const isFree = picked.id.endsWith("-free");
+    const tierLabel = isFree ? "free tier" : "paid";
+    const reason = `auth-detected: ${providerId} (${tierLabel}, released ${picked.release_date})`;
+    return {
+      ok: true,
+      value: {
+        model: `${providerId}/${picked.id}`,
+        reason,
+        authedProviders
+      }
+    };
+  }
+  return { ok: false, reason: "no-usable-model", authedProviders };
+}
+
+// src/commands/portable/opencode-config-installer.ts
+class OpenCodeAuthRequiredError extends Error {
+  reason;
+  constructor(reason = "no-auth") {
+    super(messageForReason(reason));
+    this.name = "OpenCodeAuthRequiredError";
+    this.reason = reason;
+  }
+}
+function messageForReason(reason) {
+  switch (reason) {
+    case "no-auth":
+      return "opencode has no authenticated providers. Run `opencode auth login` first, then re-run `ck migrate`.";
+    case "catalog-unavailable":
+      return "Cannot reach models.dev to pick a default model. Check your network, then re-run `ck migrate` — or set `model` in opencode.json manually.";
+    case "no-usable-model":
+      return "None of your authenticated opencode providers have a tool-capable model in the models.dev catalog. Set `model` in opencode.json manually.";
+  }
+}
+function getOpenCodeConfigPath(options2) {
+  if (options2.global) {
+    return join143(options2.homeDir ?? homedir51(), ".config", "opencode", "opencode.json");
+  }
+  return join143(options2.cwd ?? process.cwd(), "opencode.json");
+}
+function makeCatalogOpts(options2) {
+  return {
+    fetcher: options2.fetcher,
+    cacheDir: options2.cacheDir
+  };
+}
+async function validateModelAgainstCatalog(model, options2) {
+  const slashIdx = model.indexOf("/");
+  if (slashIdx <= 0 || slashIdx === model.length - 1) {
+    return false;
+  }
+  const providerId = model.slice(0, slashIdx);
+  const modelId = model.slice(slashIdx + 1);
+  try {
+    const catalog = await getModelsDevCatalog(makeCatalogOpts(options2));
+    const provider = catalog[providerId];
+    if (!provider)
+      return false;
+    return modelId in provider.models;
+  } catch {
+    return true;
+  }
+}
+async function suggestModel(options2) {
   const override = getOpenCodeDefaultModelOverride();
   if (override) {
-    return { model: override, reason: ".ck.json override" };
+    return { ok: true, model: override, reason: ".ck.json override", authedProviders: [] };
+  }
+  const result = await resolveOpenCodeDefaultModel({
+    homeDir: options2.homeDir,
+    fetcher: options2.fetcher,
+    cacheDir: options2.cacheDir
+  });
+  if (result.ok) {
+    return {
+      ok: true,
+      model: result.value.model,
+      reason: result.value.reason,
+      authedProviders: result.value.authedProviders
+    };
   }
-  return { model: OPENCODE_DEFAULT_MODEL, reason: "fallback default" };
+  return { ok: false, failure: result.reason, authedProviders: result.authedProviders };
 }
 var clackPrompter = async ({ suggestion, reason, detectedProviders }) => {
   const providersHint = detectedProviders.length > 0 ? `Authenticated providers in opencode: ${detectedProviders.join(", ")}` : "No authenticated providers detected in opencode.";
@@ -107596,7 +107826,7 @@ var clackPrompter = async ({ suggestion, reason, detectedProviders }) => {
   if (response === "accept")
     return { action: "accept" };
   const custom2 = await te({
-    message: "Model (format: provider/model-id, e.g. openai/gpt-5)",
+    message: "Model (format: provider/model-id, e.g. opencode/qwen3.5-plus-free)",
     placeholder: suggestion,
     validate: (value) => {
       if (!value || !value.includes("/"))
@@ -107608,13 +107838,35 @@ var clackPrompter = async ({ suggestion, reason, detectedProviders }) => {
     return { action: "skip" };
   return { action: "custom", value: custom2 };
 };
+var makeInvalidModelPrompter = (existingModel, suggestion, reason) => async ({ detectedProviders }) => {
+  const providersHint = detectedProviders.length > 0 ? `Authenticated providers: ${detectedProviders.join(", ")}` : "No authenticated providers detected.";
+  const response = await ie({
+    message: `Existing model "${existingModel}" is not in the models.dev catalog. ${providersHint}`,
+    options: [
+      {
+        value: "rewrite",
+        label: `Replace with "${suggestion}"`,
+        hint: reason
+      },
+      {
+        value: "keep",
+        label: `Keep "${existingModel}" as-is`,
+        hint: "May cause ProviderModelNotFoundError at runtime"
+      }
+    ],
+    initialValue: "rewrite"
+  });
+  if (lD(response) || response === "keep")
+    return { action: "skip" };
+  return { action: "accept" };
+};
 async function ensureOpenCodeModel(options2) {
   const configPath = getOpenCodeConfigPath(options2);
   let existing = null;
   try {
-    const raw2 = await readFile60(configPath, "utf-8");
+    const raw2 = await readFile62(configPath, "utf-8");
     const parsed = JSON.parse(raw2);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
       existing = parsed;
     } else {
       logger.warning(`ensureOpenCodeModel: ${configPath} is valid JSON but not an object; overwriting with default model`);
@@ -107627,40 +107879,72 @@ async function ensureOpenCodeModel(options2) {
       logger.verbose(`ensureOpenCodeModel: failed to read ${configPath} (${errno ?? String(err)}); recreating`);
     }
   }
-  if (existing && typeof existing.model === "string" && existing.model.trim().length > 0) {
-    return { path: configPath, action: "existing", model: existing.model };
-  }
-  const suggestion = await suggestOpenCodeDefaultModel(options2.homeDir);
-  let chosenModel = suggestion.model;
-  if (options2.interactive) {
-    const detectedProviders = await detectAuthenticatedProviders(options2.homeDir);
-    const prompter = options2.prompter ?? clackPrompter;
-    const response = await prompter({
-      suggestion: suggestion.model,
-      reason: suggestion.reason,
-      detectedProviders
+  if (existing !== null && typeof existing.model === "string" && existing.model.trim().length > 0) {
+    const existingModel = existing.model.trim();
+    const isValid2 = await validateModelAgainstCatalog(existingModel, options2);
+    if (isValid2) {
+      return { path: configPath, action: "existing", model: existingModel };
+    }
+    if (!options2.interactive) {
+      logger.warning(`ensureOpenCodeModel: existing model "${existingModel}" is not found in the models.dev catalog. ` + `Run \`ck migrate --agent opencode\` interactively to update it, or edit ${configPath} manually.`);
+      return { path: configPath, action: "existing", model: existingModel };
+    }
+    const suggestion2 = await suggestModel(options2);
+    if (!suggestion2.ok) {
+      return { path: configPath, action: "existing", model: existingModel };
+    }
+    const invalidPrompter = options2.prompter ?? makeInvalidModelPrompter(existingModel, suggestion2.model, suggestion2.reason);
+    const response2 = await invalidPrompter({
+      suggestion: suggestion2.model,
+      reason: suggestion2.reason,
+      detectedProviders: suggestion2.authedProviders
     });
-    if (response.action === "skip") {
-      return {
-        path: configPath,
-        action: "skipped",
-        model: "",
-        reason: "user declined"
-      };
+    if (response2.action === "skip") {
+      return { path: configPath, action: "existing", model: existingModel };
     }
-    if (response.action === "custom") {
-      chosenModel = response.value;
+    const chosenModel2 = response2.action === "custom" ? response2.value : suggestion2.model;
+    const next2 = { ...existing, model: chosenModel2 };
+    await mkdir37(dirname41(configPath), { recursive: true });
+    await writeFile36(configPath, `${JSON.stringify(next2, null, 2)}
+`, "utf-8");
+    return { path: configPath, action: "added", model: chosenModel2, reason: suggestion2.reason };
+  }
+  const suggestion = await suggestModel(options2);
+  if (!options2.interactive) {
+    if (!suggestion.ok) {
+      throw new OpenCodeAuthRequiredError(suggestion.failure);
     }
+    const next2 = { ...existing ?? {}, model: suggestion.model };
+    await mkdir37(dirname41(configPath), { recursive: true });
+    await writeFile36(configPath, `${JSON.stringify(next2, null, 2)}
+`, "utf-8");
+    return {
+      path: configPath,
+      action: existing ? "added" : "created",
+      model: suggestion.model,
+      reason: suggestion.reason
+    };
+  }
+  const prompter = options2.prompter ?? clackPrompter;
+  const detectedProviders = suggestion.ok ? suggestion.authedProviders : suggestion.authedProviders;
+  const response = await prompter({
+    suggestion: suggestion.ok ? suggestion.model : "",
+    reason: suggestion.ok ? suggestion.reason : messageForReason(suggestion.failure),
+    detectedProviders
+  });
+  if (response.action === "skip") {
+    return { path: configPath, action: "skipped", model: "", reason: "user declined" };
   }
+  const chosenModel = response.action === "custom" ? response.value : suggestion.ok ? suggestion.model : "";
   const next = { ...existing ?? {}, model: chosenModel };
-  await mkdir36(dirname41(configPath), { recursive: true });
-  await writeFile35(configPath, `${JSON.stringify(next, null, 2)}
+  await mkdir37(dirname41(configPath), { recursive: true });
+  await writeFile36(configPath, `${JSON.stringify(next, null, 2)}
 `, "utf-8");
   return {
     path: configPath,
     action: existing ? "added" : "created",
     model: chosenModel,
-    reason: suggestion.reason
+    reason: suggestion.ok ? suggestion.reason : undefined
   };
 }
 
@@ -108435,12 +108719,12 @@ async function executeDeleteAction(action, options2) {
 async function processMetadataDeletions(skillSourcePath, installGlobally) {
   if (!skillSourcePath)
     return;
-  const sourceMetadataPath = join142(resolve41(skillSourcePath, ".."), "metadata.json");
+  const sourceMetadataPath = join144(resolve41(skillSourcePath, ".."), "metadata.json");
   if (!existsSync64(sourceMetadataPath))
     return;
   let sourceMetadata;
   try {
-    const content = await readFile61(sourceMetadataPath, "utf-8");
+    const content = await readFile63(sourceMetadataPath, "utf-8");
     sourceMetadata = JSON.parse(content);
   } catch (error) {
     logger.debug(`[migrate] Failed to parse source metadata.json: ${error}`);
@@ -108448,7 +108732,7 @@ async function processMetadataDeletions(skillSourcePath, installGlobally) {
   }
   if (!sourceMetadata.deletions || sourceMetadata.deletions.length === 0)
     return;
-  const claudeDir3 = installGlobally ? join142(homedir50(), ".claude") : join142(process.cwd(), ".claude");
+  const claudeDir3 = installGlobally ? join144(homedir52(), ".claude") : join144(process.cwd(), ".claude");
   if (!existsSync64(claudeDir3))
     return;
   try {
@@ -108570,8 +108854,8 @@ async function migrateCommand(options2) {
     let requestedGlobal = options2.global ?? false;
     let installGlobally = requestedGlobal;
     if (options2.global === undefined && !options2.yes) {
-      const projectTarget = join142(process.cwd(), ".claude");
-      const globalTarget = join142(homedir50(), ".claude");
+      const projectTarget = join144(process.cwd(), ".claude");
+      const globalTarget = join144(homedir52(), ".claude");
       const scopeChoice = await ie({
         message: "Installation scope",
         options: [
@@ -108734,7 +109018,7 @@ async function migrateCommand(options2) {
       for (const action of conflictActions) {
         if (!action.diff && action.targetPath && existsSync64(action.targetPath)) {
           try {
-            const targetContent = await readFile61(action.targetPath, "utf-8");
+            const targetContent = await readFile63(action.targetPath, "utf-8");
             const sourceItem = effectiveAgents.find((a3) => a3.name === action.item) || effectiveCommands.find((c2) => c2.name === action.item) || (effectiveConfigItem?.name === action.item ? effectiveConfigItem : null) || effectiveRuleItems.find((r2) => r2.name === action.item) || effectiveHookItems.find((h2) => h2.name === action.item);
             if (sourceItem) {
               const providerConfig = providers[action.provider];
@@ -108881,7 +109165,12 @@ async function migrateCommand(options2) {
           f2.warn("Skipped writing default model to opencode.json. Migrated agents may fail with ProviderModelNotFoundError until you set one.");
         }
       } catch (err) {
-        postProgressWarnings.push(`Could not update opencode.json model (${err instanceof Error ? err.message : String(err)}). Agents may fail with ProviderModelNotFoundError until a model is set.`);
+        if (err instanceof OpenCodeAuthRequiredError) {
+          f2.warn(err.message);
+          postProgressWarnings.push(`opencode setup is incomplete: ${err.message}`);
+        } else {
+          postProgressWarnings.push(`Could not update opencode.json model (${err instanceof Error ? err.message : String(err)}). Agents may fail with ProviderModelNotFoundError until a model is set.`);
+        }
       }
     }
     if (hooksSource && successfulHookFiles.size > 0) {
@@ -109146,7 +109435,7 @@ function buildDryRunFallbackResults(skills, selectedProviders, installGlobally,
       results.push({
         itemName: skill.name,
         operation: "apply",
-        path: join142(basePath, skill.name),
+        path: join144(basePath, skill.name),
         portableType: "skill",
         provider,
         providerDisplayName: providers[provider].displayName,
@@ -109306,7 +109595,7 @@ async function handleDirectorySetup(ctx) {
 // src/commands/new/phases/project-creation.ts
 init_config_manager();
 init_github_client();
-import { join as join143 } from "node:path";
+import { join as join145 } from "node:path";
 init_logger();
 init_output_manager();
 init_types3();
@@ -109432,7 +109721,7 @@ async function projectCreation(kit, resolvedDir, validOptions, isNonInteractive2
   output.section("Installing");
   logger.verbose("Installation target", { directory: resolvedDir });
   const merger = new FileMerger;
-  const claudeDir3 = join143(resolvedDir, ".claude");
+  const claudeDir3 = join145(resolvedDir, ".claude");
   merger.setMultiKitContext(claudeDir3, kit);
   if (validOptions.exclude && validOptions.exclude.length > 0) {
     merger.addIgnorePatterns(validOptions.exclude);
@@ -109479,7 +109768,7 @@ async function handleProjectCreation(ctx) {
 }
 // src/commands/new/phases/post-setup.ts
 init_projects_registry();
-import { join as join144 } from "node:path";
+import { join as join146 } from "node:path";
 init_package_installer();
 init_logger();
 init_path_resolver();
@@ -109511,9 +109800,9 @@ async function postSetup(resolvedDir, validOptions, isNonInteractive2, prompts)
       withSudo: validOptions.withSudo
     });
   }
-  const claudeDir3 = join144(resolvedDir, ".claude");
+  const claudeDir3 = join146(resolvedDir, ".claude");
   await promptSetupWizardIfNeeded({
-    envPath: join144(claudeDir3, ".env"),
+    envPath: join146(claudeDir3, ".env"),
     claudeDir: claudeDir3,
     isGlobal: false,
     isNonInteractive: isNonInteractive2,
@@ -109583,7 +109872,7 @@ Please use only one download method.`);
 // src/commands/plan/plan-command.ts
 init_output_manager();
 import { existsSync as existsSync67, statSync as statSync12 } from "node:fs";
-import { dirname as dirname46, isAbsolute as isAbsolute11, join as join147, parse as parse7, resolve as resolve48 } from "node:path";
+import { dirname as dirname46, isAbsolute as isAbsolute11, join as join149, parse as parse7, resolve as resolve48 } from "node:path";
 
 // src/commands/plan/plan-read-handlers.ts
 init_config();
@@ -109593,14 +109882,14 @@ init_logger();
 init_output_manager();
 var import_picocolors32 = __toESM(require_picocolors(), 1);
 import { existsSync as existsSync66, statSync as statSync11 } from "node:fs";
-import { basename as basename28, dirname as dirname44, join as join146, relative as relative27, resolve as resolve46 } from "node:path";
+import { basename as basename28, dirname as dirname44, join as join148, relative as relative27, resolve as resolve46 } from "node:path";
 
 // src/commands/plan/plan-dependencies.ts
 init_config();
 init_plan_parser();
 init_plans_registry();
 import { existsSync as existsSync65 } from "node:fs";
-import { dirname as dirname43, join as join145 } from "node:path";
+import { dirname as dirname43, join as join147 } from "node:path";
 async function resolvePlanDependencies(references, currentPlanFile, options2 = {}) {
   if (references.length === 0)
     return [];
@@ -109620,7 +109909,7 @@ async function resolvePlanDependencies(references, currentPlanFile, options2 = {
       };
     }
     const scopeRoot = resolvePlanDirForScope(scope, projectRoot, config);
-    const planFile = join145(scopeRoot, planId, "plan.md");
+    const planFile = join147(scopeRoot, planId, "plan.md");
     const isSelfReference = planFile === currentPlanFile;
     if (!existsSync65(planFile)) {
       return {
@@ -109762,7 +110051,7 @@ async function handleStatus(target, options2) {
   }
   const effectiveTarget = !resolvedTarget && globalBaseDir ? globalBaseDir : resolvedTarget;
   const t = effectiveTarget ? resolve46(effectiveTarget) : null;
-  const plansDir = t && existsSync66(t) && statSync11(t).isDirectory() && !existsSync66(join146(t, "plan.md")) ? t : null;
+  const plansDir = t && existsSync66(t) && statSync11(t).isDirectory() && !existsSync66(join148(t, "plan.md")) ? t : null;
   if (plansDir) {
     const planFiles = scanPlanDir(plansDir);
     if (planFiles.length === 0) {
@@ -110177,7 +110466,7 @@ function resolvePlanFile(target, baseDir) {
     const stat24 = statSync12(t);
     if (stat24.isFile())
       return t;
-    const candidate = join147(t, "plan.md");
+    const candidate = join149(t, "plan.md");
     if (existsSync67(candidate))
       return candidate;
   }
@@ -110185,7 +110474,7 @@ function resolvePlanFile(target, baseDir) {
     let dir = process.cwd();
     const root = parse7(dir).root;
     while (dir !== root) {
-      const candidate = join147(dir, "plan.md");
+      const candidate = join149(dir, "plan.md");
       if (existsSync67(candidate))
         return candidate;
       dir = dirname46(dir);
@@ -110707,8 +110996,8 @@ init_skills_registry();
 init_skills_uninstaller();
 var import_gray_matter11 = __toESM(require_gray_matter(), 1);
 var import_picocolors37 = __toESM(require_picocolors(), 1);
-import { readFile as readFile62 } from "node:fs/promises";
-import { join as join148 } from "node:path";
+import { readFile as readFile64 } from "node:fs/promises";
+import { join as join150 } from "node:path";
 
 // src/commands/skills/types.ts
 init_zod();
@@ -110830,9 +111119,9 @@ async function handleValidate2(sourcePath) {
   spinner.stop(`Checked ${skills.length} skill(s)`);
   let hasIssues = false;
   for (const skill of skills) {
-    const skillMdPath = join148(skill.path, "SKILL.md");
+    const skillMdPath = join150(skill.path, "SKILL.md");
     try {
-      const content = await readFile62(skillMdPath, "utf-8");
+      const content = await readFile64(skillMdPath, "utf-8");
       const { data } = import_gray_matter11.default(content, {
         engines: { javascript: { parse: () => ({}) } }
       });
@@ -111388,7 +111677,7 @@ async function detectInstallations() {
 
 // src/commands/uninstall/removal-handler.ts
 import { readdirSync as readdirSync10, rmSync as rmSync5 } from "node:fs";
-import { basename as basename30, join as join150, resolve as resolve50, sep as sep12 } from "node:path";
+import { basename as basename30, join as join152, resolve as resolve50, sep as sep12 } from "node:path";
 init_logger();
 init_safe_prompts();
 init_safe_spinner();
@@ -111397,7 +111686,7 @@ var import_fs_extra44 = __toESM(require_lib3(), 1);
 // src/commands/uninstall/analysis-handler.ts
 init_metadata_migration();
 import { readdirSync as readdirSync9, rmSync as rmSync4 } from "node:fs";
-import { dirname as dirname47, join as join149 } from "node:path";
+import { dirname as dirname47, join as join151 } from "node:path";
 init_logger();
 init_safe_prompts();
 var import_fs_extra43 = __toESM(require_lib3(), 1);
@@ -111454,7 +111743,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
       const remainingFiles = metadata.kits?.[remainingKit]?.files || [];
       for (const file of remainingFiles) {
         const relativePath = normalizeTrackedPath(file.path);
-        if (await import_fs_extra43.pathExists(join149(installation.path, relativePath))) {
+        if (await import_fs_extra43.pathExists(join151(installation.path, relativePath))) {
           result.retainedManifestPaths.push(relativePath);
         }
       }
@@ -111462,7 +111751,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
     const kitFiles = metadata.kits[kit].files || [];
     for (const trackedFile of kitFiles) {
       const relativePath = normalizeTrackedPath(trackedFile.path);
-      const filePath = join149(installation.path, relativePath);
+      const filePath = join151(installation.path, relativePath);
       if (preservedPaths.has(relativePath)) {
         result.toPreserve.push({ path: relativePath, reason: "shared with other kit" });
         continue;
@@ -111495,7 +111784,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
   }
   for (const trackedFile of allTrackedFiles) {
     const relativePath = normalizeTrackedPath(trackedFile.path);
-    const filePath = join149(installation.path, relativePath);
+    const filePath = join151(installation.path, relativePath);
     const ownershipResult = await OwnershipChecker.checkOwnership(filePath, metadata, installation.path);
     if (!ownershipResult.exists)
       continue;
@@ -111638,7 +111927,7 @@ async function removeInstallations(installations, options2) {
         let removedCount = 0;
         let cleanedDirs = 0;
         for (const item of analysis.toDelete) {
-          const filePath = join150(installation.path, item.path);
+          const filePath = join152(installation.path, item.path);
           if (!await import_fs_extra44.pathExists(filePath))
             continue;
           if (!await isPathSafeToRemove(filePath, installation.path)) {
@@ -111972,7 +112261,7 @@ ${import_picocolors40.default.bold(import_picocolors40.default.cyan(result.kitCo
 init_logger();
 import { existsSync as existsSync74 } from "node:fs";
 import { rm as rm17 } from "node:fs/promises";
-import { join as join157 } from "node:path";
+import { join as join159 } from "node:path";
 var import_picocolors41 = __toESM(require_picocolors(), 1);
 
 // src/commands/watch/phases/implementation-runner.ts
@@ -112490,8 +112779,8 @@ function spawnAndCollect3(command, args) {
 }
 
 // src/commands/watch/phases/issue-processor.ts
-import { mkdir as mkdir37, writeFile as writeFile37 } from "node:fs/promises";
-import { join as join153 } from "node:path";
+import { mkdir as mkdir38, writeFile as writeFile38 } from "node:fs/promises";
+import { join as join155 } from "node:path";
 
 // src/commands/watch/phases/approval-detector.ts
 init_logger();
@@ -112869,9 +113158,9 @@ async function checkAwaitingApproval(state, setup, options2, watchLog, projectDi
 
 // src/commands/watch/phases/plan-dir-finder.ts
 import { readdir as readdir44, stat as stat24 } from "node:fs/promises";
-import { join as join152 } from "node:path";
+import { join as join154 } from "node:path";
 async function findRecentPlanDir(cwd2, issueNumber, watchLog) {
-  const plansRoot = join152(cwd2, "plans");
+  const plansRoot = join154(cwd2, "plans");
   try {
     const entries = await readdir44(plansRoot);
     const tenMinAgo = Date.now() - 10 * 60 * 1000;
@@ -112880,14 +113169,14 @@ async function findRecentPlanDir(cwd2, issueNumber, watchLog) {
     for (const entry of entries) {
       if (entry === "watch" || entry === "reports" || entry === "visuals")
         continue;
-      const dirPath = join152(plansRoot, entry);
+      const dirPath = join154(plansRoot, entry);
       const dirStat = await stat24(dirPath);
       if (!dirStat.isDirectory())
         continue;
       if (dirStat.mtimeMs < tenMinAgo)
         continue;
       try {
-        await stat24(join152(dirPath, "plan.md"));
+        await stat24(join154(dirPath, "plan.md"));
       } catch {
         continue;
       }
@@ -113118,14 +113407,14 @@ async function handlePlanGeneration(issue, state, config, setup, options2, watch
     stats.plansCreated++;
     const detectedPlanDir = await findRecentPlanDir(projectDir, issue.number, watchLog);
     if (detectedPlanDir) {
-      state.activeIssues[numStr].planPath = join153(detectedPlanDir, "plan.md");
+      state.activeIssues[numStr].planPath = join155(detectedPlanDir, "plan.md");
       watchLog.info(`Plan directory detected: ${detectedPlanDir}`);
     } else {
       try {
-        const planDir = join153(projectDir, "plans", "watch");
-        await mkdir37(planDir, { recursive: true });
-        const planFilePath = join153(planDir, `issue-${issue.number}-plan.md`);
-        await writeFile37(planFilePath, planResult.planText, "utf-8");
+        const planDir = join155(projectDir, "plans", "watch");
+        await mkdir38(planDir, { recursive: true });
+        const planFilePath = join155(planDir, `issue-${issue.number}-plan.md`);
+        await writeFile38(planFilePath, planResult.planText, "utf-8");
         state.activeIssues[numStr].planPath = planFilePath;
         watchLog.info(`Plan saved (fallback) to ${planFilePath}`);
       } catch (err) {
@@ -113202,7 +113491,7 @@ async function checkActiveIssues(state, config, setup, options2, watchLog, stats
 // src/commands/watch/phases/maintainer-resolver.ts
 init_logger();
 init_implementation_git_helpers();
-var CACHE_TTL_MS3 = 3600000;
+var CACHE_TTL_MS4 = 3600000;
 var cache4 = new Map;
 async function resolveMaintainers(owner, repo, excludeAuthors, autoDetect) {
   const normalizedExclude = excludeAuthors.map((s) => s.toLowerCase());
@@ -113211,7 +113500,7 @@ async function resolveMaintainers(owner, repo, excludeAuthors, autoDetect) {
   }
   const cacheKey = `${owner}/${repo}`;
   const cached = cache4.get(cacheKey);
-  if (cached && Date.now() - cached.fetchedAt >= CACHE_TTL_MS3) {
+  if (cached && Date.now() - cached.fetchedAt >= CACHE_TTL_MS4) {
     cache4.delete(cacheKey);
   } else if (cached) {
     const merged = Array.from(new Set([...cached.users, ...normalizedExclude]));
@@ -113270,7 +113559,7 @@ init_ck_config_manager();
 init_file_io();
 init_logger();
 import { existsSync as existsSync70 } from "node:fs";
-import { mkdir as mkdir38, readFile as readFile64 } from "node:fs/promises";
+import { mkdir as mkdir39, readFile as readFile66 } from "node:fs/promises";
 import { dirname as dirname48 } from "node:path";
 var PROCESSED_ISSUES_CAP = 500;
 async function readCkJson(projectDir) {
@@ -113278,7 +113567,7 @@ async function readCkJson(projectDir) {
   try {
     if (!existsSync70(configPath))
       return {};
-    const content = await readFile64(configPath, "utf-8");
+    const content = await readFile66(configPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     logger.warning(`Failed to parse .ck.json: ${error instanceof Error ? error.message : "Unknown"}`);
@@ -113303,7 +113592,7 @@ async function saveWatchState(projectDir, state) {
   const configPath = CkConfigManager.getProjectConfigPath(projectDir);
   const configDir = dirname48(configPath);
   if (!existsSync70(configDir)) {
-    await mkdir38(configDir, { recursive: true });
+    await mkdir39(configDir, { recursive: true });
   }
   const raw2 = await readCkJson(projectDir);
   const watchRaw = raw2.watch ?? {};
@@ -113431,18 +113720,18 @@ init_logger();
 import { spawnSync as spawnSync7 } from "node:child_process";
 import { existsSync as existsSync71 } from "node:fs";
 import { readdir as readdir45, stat as stat25 } from "node:fs/promises";
-import { join as join154 } from "node:path";
+import { join as join156 } from "node:path";
 async function scanForRepos(parentDir) {
   const repos = [];
   const entries = await readdir45(parentDir);
   for (const entry of entries) {
     if (entry.startsWith("."))
       continue;
-    const fullPath = join154(parentDir, entry);
+    const fullPath = join156(parentDir, entry);
     const entryStat = await stat25(fullPath);
     if (!entryStat.isDirectory())
       continue;
-    const gitDir = join154(fullPath, ".git");
+    const gitDir = join156(fullPath, ".git");
     if (!existsSync71(gitDir))
       continue;
     const result = spawnSync7("gh", ["repo", "view", "--json", "owner,name"], {
@@ -113468,8 +113757,8 @@ async function scanForRepos(parentDir) {
 init_logger();
 import { spawnSync as spawnSync8 } from "node:child_process";
 import { existsSync as existsSync72 } from "node:fs";
-import { homedir as homedir51 } from "node:os";
-import { join as join155 } from "node:path";
+import { homedir as homedir53 } from "node:os";
+import { join as join157 } from "node:path";
 async function validateSetup(cwd2) {
   const workDir = cwd2 ?? process.cwd();
   const ghVersion = spawnSync8("gh", ["--version"], { encoding: "utf-8", timeout: 1e4 });
@@ -113500,7 +113789,7 @@ Run this command from a directory with a GitHub remote.`);
   } catch {
     throw new Error(`Failed to parse repository info: ${ghRepo.stdout}`);
   }
-  const skillsPath = join155(homedir51(), ".claude", "skills");
+  const skillsPath = join157(homedir53(), ".claude", "skills");
   const skillsAvailable = existsSync72(skillsPath);
   if (!skillsAvailable) {
     logger.warning(`ClaudeKit Engineer skills not found at ${skillsPath}`);
@@ -113518,8 +113807,8 @@ init_logger();
 init_path_resolver();
 import { createWriteStream as createWriteStream3, statSync as statSync13 } from "node:fs";
 import { existsSync as existsSync73 } from "node:fs";
-import { mkdir as mkdir39, rename as rename13 } from "node:fs/promises";
-import { join as join156 } from "node:path";
+import { mkdir as mkdir40, rename as rename14 } from "node:fs/promises";
+import { join as join158 } from "node:path";
 
 class WatchLogger {
   logStream = null;
@@ -113527,16 +113816,16 @@ class WatchLogger {
   logPath = null;
   maxBytes;
   constructor(logDir, maxBytes = 0) {
-    this.logDir = logDir ?? join156(PathResolver.getClaudeKitDir(), "logs");
+    this.logDir = logDir ?? join158(PathResolver.getClaudeKitDir(), "logs");
     this.maxBytes = maxBytes;
   }
   async init() {
     try {
       if (!existsSync73(this.logDir)) {
-        await mkdir39(this.logDir, { recursive: true });
+        await mkdir40(this.logDir, { recursive: true });
       }
       const dateStr = formatDate(new Date);
-      this.logPath = join156(this.logDir, `watch-${dateStr}.log`);
+      this.logPath = join158(this.logDir, `watch-${dateStr}.log`);
       this.logStream = createWriteStream3(this.logPath, { flags: "a", mode: 384 });
     } catch (error) {
       logger.warning(`Cannot create watch log file: ${error instanceof Error ? error.message : "Unknown"}`);
@@ -113601,7 +113890,7 @@ class WatchLogger {
     try {
       this.logStream.end();
       const rotatedPath = `${this.logPath}.1`;
-      rename13(this.logPath, rotatedPath).catch(() => {});
+      rename14(this.logPath, rotatedPath).catch(() => {});
       this.logStream = createWriteStream3(this.logPath, { flags: "w", mode: 384 });
     } catch {}
   }
@@ -113718,7 +114007,7 @@ async function watchCommand(options2) {
 }
 async function discoverRepos(options2, watchLog) {
   const cwd2 = process.cwd();
-  const isGitRepo = existsSync74(join157(cwd2, ".git"));
+  const isGitRepo = existsSync74(join159(cwd2, ".git"));
   if (options2.force) {
     await forceRemoveLock(watchLog);
   }
@@ -113977,7 +114266,7 @@ function registerCommands(cli) {
 init_package();
 init_config_version_checker();
 import { existsSync as existsSync86, readFileSync as readFileSync22 } from "node:fs";
-import { join as join169 } from "node:path";
+import { join as join171 } from "node:path";
 
 // src/domains/versioning/version-checker.ts
 init_version_utils();
@@ -113991,15 +114280,15 @@ init_types3();
 init_logger();
 init_path_resolver();
 import { existsSync as existsSync85 } from "node:fs";
-import { mkdir as mkdir40, readFile as readFile66, writeFile as writeFile40 } from "node:fs/promises";
-import { join as join168 } from "node:path";
+import { mkdir as mkdir41, readFile as readFile68, writeFile as writeFile41 } from "node:fs/promises";
+import { join as join170 } from "node:path";
 
 class VersionCacheManager {
   static CACHE_FILENAME = "version-check.json";
   static CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
   static getCacheFile() {
     const cacheDir = PathResolver.getCacheDir(false);
-    return join168(cacheDir, VersionCacheManager.CACHE_FILENAME);
+    return join170(cacheDir, VersionCacheManager.CACHE_FILENAME);
   }
   static async load() {
     const cacheFile = VersionCacheManager.getCacheFile();
@@ -114008,7 +114297,7 @@ class VersionCacheManager {
         logger.debug("Version check cache not found");
         return null;
       }
-      const content = await readFile66(cacheFile, "utf-8");
+      const content = await readFile68(cacheFile, "utf-8");
       const cache5 = JSON.parse(content);
       if (!cache5.lastCheck || !cache5.currentVersion || !cache5.latestVersion) {
         logger.debug("Invalid cache structure, ignoring");
@@ -114026,9 +114315,9 @@ class VersionCacheManager {
     const cacheDir = PathResolver.getCacheDir(false);
     try {
       if (!existsSync85(cacheDir)) {
-        await mkdir40(cacheDir, { recursive: true, mode: 448 });
+        await mkdir41(cacheDir, { recursive: true, mode: 448 });
       }
-      await writeFile40(cacheFile, JSON.stringify(cache5, null, 2), "utf-8");
+      await writeFile41(cacheFile, JSON.stringify(cache5, null, 2), "utf-8");
       logger.debug(`Version check cache saved to ${cacheFile}`);
     } catch (error) {
       logger.debug(`Failed to save version check cache: ${error}`);
@@ -114310,9 +114599,9 @@ async function displayVersion() {
   let localInstalledKits = [];
   let globalInstalledKits = [];
   const globalKitDir = PathResolver.getGlobalKitDir();
-  const globalMetadataPath = join169(globalKitDir, "metadata.json");
+  const globalMetadataPath = join171(globalKitDir, "metadata.json");
   const prefix = PathResolver.getPathPrefix(false);
-  const localMetadataPath = prefix ? join169(process.cwd(), prefix, "metadata.json") : join169(process.cwd(), "metadata.json");
+  const localMetadataPath = prefix ? join171(process.cwd(), prefix, "metadata.json") : join171(process.cwd(), "metadata.json");
   const isLocalSameAsGlobal = localMetadataPath === globalMetadataPath;
   if (!isLocalSameAsGlobal && existsSync86(localMetadataPath)) {
     try {