claudekit-cli 3.42.2-dev.7 → 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.7",
+    version: "3.42.2-dev.9",
     description: "CLI tool for bootstrapping and updating ClaudeKit projects",
     type: "module",
     repository: {
@@ -63356,6 +63356,9 @@ async function invalidateAuth() {
   cachedOctokit = null;
   logger.debug("Invalidated cached authentication due to 401 error");
 }
+function resetClient() {
+  cachedOctokit = null;
+}
 var cachedOctokit = null;
 var init_auth_api = __esm(() => {
   init_claudekit_constants();
@@ -64268,6 +64271,16 @@ var init_asset_utils = __esm(() => {
 });
 
 // src/domains/github/client/index.ts
+var exports_client = {};
+__export(exports_client, {
+  resetClient: () => resetClient,
+  invalidateAuth: () => invalidateAuth,
+  handleHttpError: () => handleHttpError,
+  getDownloadableAsset: () => getDownloadableAsset,
+  getAuthenticatedClient: () => getAuthenticatedClient,
+  RepoApi: () => RepoApi,
+  ReleasesApi: () => ReleasesApi
+});
 var init_client = __esm(() => {
   init_auth_api();
   init_error_handler2();
@@ -73512,7 +73525,7 @@ async function restoreOriginalBranch(branchName, cwd2, issueNumber) {
   }
 }
 function spawnAndCollect(command, args, cwd2) {
-  return new Promise((resolve49, reject) => {
+  return new Promise((resolve44, reject) => {
     const child = spawn6(command, args, { ...cwd2 && { cwd: cwd2 }, stdio: ["ignore", "pipe", "pipe"] });
     const chunks = [];
     const stderrChunks = [];
@@ -73525,7 +73538,7 @@ function spawnAndCollect(command, args, cwd2) {
         reject(new Error(`${command} ${args[0] ?? ""} exited with code ${code2}: ${stderr}`));
         return;
       }
-      resolve49(Buffer.concat(chunks).toString("utf-8"));
+      resolve44(Buffer.concat(chunks).toString("utf-8"));
     });
   });
 }
@@ -73543,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`);
@@ -73564,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);
@@ -73578,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 ")) {
@@ -73606,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) {
@@ -73644,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)`);
     }
@@ -73675,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 };
@@ -73711,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))
@@ -73722,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)
@@ -73738,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");
@@ -73756,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 {}
   }
@@ -73783,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
@@ -73968,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) {
@@ -74022,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}`);
@@ -74041,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 };
@@ -74089,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;
@@ -74107,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()
@@ -74145,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)",
@@ -74185,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
@@ -74201,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
@@ -74218,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
@@ -74241,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", {
@@ -74269,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;
@@ -74287,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, {
@@ -74313,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"],
@@ -74324,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,
@@ -74341,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(() => {
@@ -74358,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;
@@ -74367,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() {
@@ -74399,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();
@@ -74416,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 {}
@@ -74653,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);
@@ -74762,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();
@@ -74772,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 {
@@ -74850,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)) {
@@ -74863,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)
@@ -75233,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;
@@ -75261,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 {
@@ -75287,7 +75300,7 @@ class RateLimiter {
     } catch {
       dateStr = new Date().toISOString().slice(0, 10);
     }
-    return `${platform17}-${dateStr}`;
+    return `${platform18}-${dateStr}`;
   }
 }
 
@@ -75404,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":
@@ -75413,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) {
@@ -75530,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 {
@@ -75543,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 ?? {});
@@ -75560,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);
@@ -75578,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 {};
@@ -75586,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(() => {
@@ -75693,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}?` });
@@ -75785,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",
@@ -75842,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 ")));
@@ -75910,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`);
@@ -75978,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;
@@ -76009,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));
@@ -76021,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);
@@ -76052,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 {
@@ -76087,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;
@@ -76126,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;
@@ -76160,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;
@@ -76198,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);
@@ -76327,8 +76340,8 @@ function shouldRunCleanup(lastAt) {
   return Date.now() - new Date(lastAt).getTime() >= 86400000;
 }
 function sleep2(ms) {
-  return new Promise((resolve49) => {
-    setTimeout(resolve49, ms);
+  return new Promise((resolve44) => {
+    setTimeout(resolve44, ms);
   });
 }
 var LOCK_DIR2, LOCK_FILE, MAX_CREATION_RETRIES = 3, MAX_PUBLISH_RETRIES_PER_CYCLE = 3, PUBLISH_RETRY_WINDOW_HOURS = 24;
@@ -76344,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
@@ -78611,7 +78624,7 @@ function getPagerArgs(pagerCmd) {
   return [];
 }
 async function trySystemPager(content) {
-  return new Promise((resolve49) => {
+  return new Promise((resolve44) => {
     const pagerCmd = process.env.PAGER || "less";
     const pagerArgs = getPagerArgs(pagerCmd);
     try {
@@ -78621,20 +78634,20 @@ async function trySystemPager(content) {
       });
       const timeout2 = setTimeout(() => {
         pager.kill();
-        resolve49(false);
+        resolve44(false);
       }, 30000);
       pager.stdin.write(content);
       pager.stdin.end();
       pager.on("close", (code2) => {
         clearTimeout(timeout2);
-        resolve49(code2 === 0);
+        resolve44(code2 === 0);
       });
       pager.on("error", () => {
         clearTimeout(timeout2);
-        resolve49(false);
+        resolve44(false);
       });
     } catch {
-      resolve49(false);
+      resolve44(false);
     }
   });
 }
@@ -78661,16 +78674,16 @@ async function basicPager(content) {
       break;
     }
     const remaining = lines.length - currentLine;
-    await new Promise((resolve49) => {
+    await new Promise((resolve44) => {
       rl.question(`-- More (${remaining} lines) [Enter/q] --`, (answer) => {
         if (answer.toLowerCase() === "q") {
           rl.close();
           process.exitCode = 0;
-          resolve49();
+          resolve44();
           return;
         }
         process.stdout.write("\x1B[1A\x1B[2K");
-        resolve49();
+        resolve44();
       });
     });
   }
@@ -88254,6 +88267,313 @@ class NetworkChecker {
     }
   }
 }
+// src/domains/health-checks/checkers/github-reachability-checker.ts
+init_environment();
+init_logger();
+init_types3();
+import * as dnsPromises from "node:dns/promises";
+import * as https from "node:https";
+import * as net2 from "node:net";
+var DNS_TIMEOUT_MS = (() => {
+  const envVal = Number.parseInt(process.env.CLAUDEKIT_DNS_TIMEOUT ?? "", 10);
+  return Number.isFinite(envVal) && envVal > 0 ? envVal : 500;
+})();
+var TCP_TIMEOUT_MS = 1000;
+var TLS_TIMEOUT_MS = 3000;
+var AUTH_TIMEOUT_MS = 5000;
+var API_HOST = "api.github.com";
+var ZEN_URL = `https://${API_HOST}/zen`;
+var PROBE_KIT = "engineer";
+function createDefaultDeps() {
+  return {
+    dns: createDefaultDns(),
+    tcp: createDefaultTcp(),
+    tls: createDefaultTls(),
+    auth: createDefaultAuth()
+  };
+}
+function createDefaultDns() {
+  return {
+    resolve4: (host) => dnsPromises.resolve4(host),
+    resolve6: (host) => dnsPromises.resolve6(host)
+  };
+}
+function createDefaultTcp() {
+  return {
+    connect: ({ host, port, timeoutMs }) => new Promise((resolve32) => {
+      const start = Date.now();
+      const socket = net2.createConnection({ host, port });
+      const timer = setTimeout(() => {
+        socket.destroy();
+        resolve32({ ok: false, layer: "tcp", detail: "timeout", latencyMs: Date.now() - start });
+      }, timeoutMs);
+      socket.on("connect", () => {
+        clearTimeout(timer);
+        socket.destroy();
+        resolve32({
+          ok: true,
+          layer: "tcp",
+          detail: "connected",
+          latencyMs: Date.now() - start
+        });
+      });
+      socket.on("error", (err) => {
+        clearTimeout(timer);
+        resolve32({
+          ok: false,
+          layer: "tcp",
+          detail: err.message,
+          latencyMs: Date.now() - start
+        });
+      });
+    })
+  };
+}
+function createDefaultTls() {
+  return {
+    get: (url, timeoutMs) => new Promise((resolve32) => {
+      const start = Date.now();
+      const timer = setTimeout(() => {
+        req.destroy();
+        resolve32({ ok: false, layer: "tls", detail: "timeout", latencyMs: Date.now() - start });
+      }, timeoutMs);
+      const req = https.get(url, {
+        headers: {
+          "User-Agent": "claudekit-cli-doctor/1.0"
+        }
+      }, (res) => {
+        res.resume();
+        clearTimeout(timer);
+        const status = res.statusCode ?? 0;
+        const latencyMs = Date.now() - start;
+        if (status === 200) {
+          resolve32({ ok: true, layer: "tls", detail: `HTTP ${status}`, latencyMs });
+        } else {
+          resolve32({ ok: false, layer: "tls", detail: `HTTP ${status}`, latencyMs });
+        }
+      });
+      req.on("error", (err) => {
+        clearTimeout(timer);
+        resolve32({
+          ok: false,
+          layer: "tls",
+          detail: err.message,
+          latencyMs: Date.now() - start
+        });
+      });
+    })
+  };
+}
+function createDefaultAuth() {
+  return {
+    checkKitAccess: async () => {
+      const start = Date.now();
+      const { getAuthenticatedClient: getAuthenticatedClient2 } = await Promise.resolve().then(() => (init_client(), exports_client));
+      const kit = AVAILABLE_KITS[PROBE_KIT];
+      try {
+        const client = await getAuthenticatedClient2();
+        await client.repos.get({ owner: kit.owner, repo: kit.repo });
+        return {
+          ok: true,
+          layer: "auth",
+          detail: "200 OK",
+          latencyMs: Date.now() - start,
+          statusCode: 200
+        };
+      } catch (err) {
+        const latencyMs = Date.now() - start;
+        const status = err?.status ?? err?.statusCode;
+        const message = err instanceof Error ? err.message : String(err);
+        if (status === 401) {
+          return {
+            ok: false,
+            layer: "auth",
+            detail: `401 Unauthorized — token invalid or missing. ${message}`,
+            latencyMs,
+            statusCode: 401
+          };
+        }
+        if (status === 404) {
+          return {
+            ok: false,
+            layer: "auth",
+            detail: `404 — no repository access (invitation pending). ${message}`,
+            latencyMs,
+            statusCode: 404
+          };
+        }
+        return {
+          ok: false,
+          layer: "auth",
+          detail: `${status ?? "?"} — ${message}`,
+          latencyMs,
+          statusCode: status
+        };
+      }
+    }
+  };
+}
+async function checkGitHubReachability(deps) {
+  const dnsStart = Date.now();
+  let dnsResult;
+  try {
+    const [r4, r6] = await Promise.allSettled([
+      raceTimeout(deps.dns.resolve4(API_HOST), DNS_TIMEOUT_MS),
+      raceTimeout(deps.dns.resolve6(API_HOST), DNS_TIMEOUT_MS)
+    ]);
+    const ok = r4.status === "fulfilled" || r6.status === "fulfilled";
+    let detail;
+    if (ok) {
+      if (r4.status === "fulfilled") {
+        detail = `resolved: ${r4.value[0]}`;
+      } else {
+        const r6Value = r6.value;
+        detail = `resolved (IPv6): ${r6Value[0]}`;
+      }
+    } else {
+      detail = "NXDOMAIN / timeout";
+    }
+    dnsResult = { ok, layer: "dns", detail, latencyMs: Date.now() - dnsStart };
+  } catch {
+    dnsResult = {
+      ok: false,
+      layer: "dns",
+      detail: "DNS resolution failed",
+      latencyMs: Date.now() - dnsStart
+    };
+  }
+  if (!dnsResult.ok) {
+    return { ok: false, failedLayer: "dns", layers: { dns: dnsResult } };
+  }
+  const tcpResult = await deps.tcp.connect({
+    host: API_HOST,
+    port: 443,
+    timeoutMs: TCP_TIMEOUT_MS
+  });
+  if (!tcpResult.ok) {
+    return { ok: false, failedLayer: "tcp", layers: { dns: dnsResult, tcp: tcpResult } };
+  }
+  const tlsResult = await deps.tls.get(ZEN_URL, TLS_TIMEOUT_MS);
+  if (!tlsResult.ok) {
+    return {
+      ok: false,
+      failedLayer: "tls",
+      layers: { dns: dnsResult, tcp: tcpResult, tls: tlsResult }
+    };
+  }
+  const authResult = await deps.auth.checkKitAccess();
+  if (!authResult.ok) {
+    return {
+      ok: false,
+      failedLayer: "auth",
+      layers: { dns: dnsResult, tcp: tcpResult, tls: tlsResult, auth: authResult }
+    };
+  }
+  return {
+    ok: true,
+    layers: { dns: dnsResult, tcp: tcpResult, tls: tlsResult, auth: authResult }
+  };
+}
+function raceTimeout(promise, ms) {
+  return new Promise((resolve32, reject) => {
+    const timer = setTimeout(() => reject(new Error(`timeout after ${ms}ms`)), ms);
+    promise.then((v2) => {
+      clearTimeout(timer);
+      resolve32(v2);
+    }, (e2) => {
+      clearTimeout(timer);
+      reject(e2);
+    });
+  });
+}
+
+class GitHubReachabilityChecker {
+  group = "network";
+  deps;
+  usingRealDeps;
+  constructor(options2 = {}) {
+    this.usingRealDeps = options2.deps === undefined;
+    this.deps = options2.deps ?? createDefaultDeps();
+  }
+  async run() {
+    if (this.usingRealDeps && (isCIEnvironment() || isTestEnvironment())) {
+      return [
+        {
+          id: "github-reachability",
+          name: "GitHub Reachability",
+          group: "network",
+          priority: "standard",
+          status: "info",
+          message: "Skipped in CI/test environment",
+          autoFixable: false
+        }
+      ];
+    }
+    logger.verbose("GitHubReachabilityChecker: running layered probe");
+    let result;
+    try {
+      result = await raceTimeout(checkGitHubReachability(this.deps), AUTH_TIMEOUT_MS + TLS_TIMEOUT_MS + TCP_TIMEOUT_MS + DNS_TIMEOUT_MS + 500);
+    } catch (err) {
+      return [
+        {
+          id: "github-reachability",
+          name: "GitHub Reachability",
+          group: "network",
+          priority: "standard",
+          status: "fail",
+          message: "Probe timed out",
+          details: err instanceof Error ? err.message : String(err),
+          suggestion: "Check internet connection and proxy settings",
+          autoFixable: false
+        }
+      ];
+    }
+    logger.verbose("GitHubReachabilityChecker: probe complete", { result });
+    return [buildCheckResult(result)];
+  }
+}
+function buildCheckResult(result) {
+  if (result.ok) {
+    const { dns, tcp, tls, auth } = result.layers;
+    const details = [
+      `DNS: ${dns.latencyMs}ms`,
+      tcp ? `TCP: ${tcp.latencyMs}ms` : null,
+      tls ? `TLS/GET: ${tls.latencyMs}ms` : null,
+      auth ? `Auth: ${auth.latencyMs}ms` : null
+    ].filter(Boolean).join(", ");
+    return {
+      id: "github-reachability",
+      name: "GitHub Reachability",
+      group: "network",
+      priority: "standard",
+      status: "pass",
+      message: "All layers reachable",
+      details,
+      autoFixable: false
+    };
+  }
+  const { failedLayer, layers } = result;
+  const failedProbe = layers[failedLayer];
+  const detail = failedProbe?.detail ?? "unknown";
+  const authSuggestion = failedProbe?.statusCode === 401 ? "GitHub token invalid or missing — run: gh auth login" : "No repository access — check GitHub invitation email or purchase at https://claudekit.cc";
+  const suggestions = {
+    dns: "DNS resolution failed — check /etc/resolv.conf or system DNS settings",
+    tcp: "TCP connect to api.github.com:443 failed — check firewall or proxy blocking port 443",
+    tls: "HTTPS GET /zen returned unexpected status — possible TLS interception or GitHub outage. Check https://githubstatus.com",
+    auth: authSuggestion
+  };
+  return {
+    id: "github-reachability",
+    name: "GitHub Reachability",
+    group: "network",
+    priority: "standard",
+    status: "fail",
+    message: `GitHub unreachable at ${failedLayer?.toUpperCase()} layer`,
+    details: detail,
+    suggestion: suggestions[failedLayer ?? ""] ?? "Run: ck doctor for full diagnostics",
+    autoFixable: false
+  };
+}
 // src/domains/health-checks/auto-healer.ts
 class AutoHealer {
   timeout;
@@ -88680,6 +89000,7 @@ async function doctorCommand(options2 = {}) {
   runner.registerChecker(new AuthChecker);
   runner.registerChecker(new PlatformChecker);
   runner.registerChecker(new NetworkChecker);
+  runner.registerChecker(new GitHubReachabilityChecker);
   const summary = await runner.run();
   if (json) {
     const generator = new ReportGenerator;
@@ -105382,7 +105703,15 @@ async function handleSelection(ctx) {
       logger.info("Full diagnostics: ck doctor");
       return { ...ctx, cancelled: true };
     }
-    accessibleKits = await detectAccessibleKits();
+    try {
+      accessibleKits = await detectAccessibleKits();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      logger.error(`Failed to check repository access: ${message}`);
+      logger.info("");
+      logger.info("Run: ck doctor");
+      return { ...ctx, cancelled: true };
+    }
     if (accessibleKits.length === 0) {
       logger.error("No ClaudeKit repository access found.");
       logger.info("Check email for GitHub invitation, or purchase at https://claudekit.cc");
@@ -106746,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
@@ -107220,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: [] };
   }
-  return { model: OPENCODE_DEFAULT_MODEL, reason: "fallback default" };
+  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 { 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.";
@@ -107267,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("/"))
@@ -107279,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`);
@@ -107298,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
   };
 }
 
@@ -108106,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}`);
@@ -108119,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 {
@@ -108241,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: [
@@ -108405,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];
@@ -108552,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) {
@@ -108817,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,
@@ -108835,7 +109453,7 @@ var import_picocolors31 = __toESM(require_picocolors(), 1);
 
 // src/commands/new/phases/directory-setup.ts
 init_config_manager();
-import { resolve as resolve42 } from "node:path";
+import { resolve as resolve43 } from "node:path";
 init_logger();
 init_path_resolver();
 init_types3();
@@ -108920,7 +109538,7 @@ async function directorySetup(validOptions, prompts) {
       targetDir = await prompts.getDirectory(targetDir);
     }
   }
-  const resolvedDir = resolve42(targetDir);
+  const resolvedDir = resolve43(targetDir);
   logger.info(`Target directory: ${resolvedDir}`);
   if (PathResolver.isLocalSameAsGlobal(resolvedDir)) {
     logger.warning("You're creating a project at HOME directory.");
@@ -108977,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();
@@ -109103,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);
@@ -109150,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();
@@ -109182,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,
@@ -109254,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 resolve46 } 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();
@@ -109264,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 resolve44 } 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 [];
@@ -109291,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 {
@@ -109322,14 +109940,14 @@ init_config();
 init_plan_parser();
 init_plan_scope();
 init_plans_registry();
-import { isAbsolute as isAbsolute10, resolve as resolve43 } from "node:path";
+import { isAbsolute as isAbsolute10, resolve as resolve45 } from "node:path";
 async function getGlobalPlansDirFromCwd() {
   const projectRoot = findProjectRoot(process.cwd());
   const { config } = await CkConfigManager.loadFull(projectRoot);
   return resolveGlobalPlansDir(config);
 }
 function resolveTargetFromBase(target, baseDir) {
-  const resolvedTarget = isAbsolute10(target) ? resolve43(target) : resolve43(baseDir, target);
+  const resolvedTarget = isAbsolute10(target) ? resolve45(target) : resolve45(baseDir, target);
   return isWithinDir(resolvedTarget, baseDir) ? resolvedTarget : null;
 }
 
@@ -109432,8 +110050,8 @@ async function handleStatus(target, options2) {
     return;
   }
   const effectiveTarget = !resolvedTarget && globalBaseDir ? globalBaseDir : resolvedTarget;
-  const t = effectiveTarget ? resolve44(effectiveTarget) : null;
-  const plansDir = t && existsSync66(t) && statSync11(t).isDirectory() && !existsSync66(join146(t, "plan.md")) ? t : null;
+  const t = effectiveTarget ? resolve46(effectiveTarget) : 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) {
@@ -109617,7 +110235,7 @@ init_plan_parser();
 init_plans_registry();
 init_output_manager();
 var import_picocolors33 = __toESM(require_picocolors(), 1);
-import { basename as basename29, dirname as dirname45, relative as relative28, resolve as resolve45 } from "node:path";
+import { basename as basename29, dirname as dirname45, relative as relative28, resolve as resolve47 } from "node:path";
 async function handleCreate(target, options2) {
   if (!options2.title) {
     output.error("[X] --title is required for create");
@@ -109649,13 +110267,13 @@ async function handleCreate(target, options2) {
     return;
   }
   const globalBaseDir = options2.global ? await getGlobalPlansDirFromCwd() : undefined;
-  const resolvedDir = globalBaseDir ? resolveTargetFromBase(dir, globalBaseDir) : resolve45(dir);
+  const resolvedDir = globalBaseDir ? resolveTargetFromBase(dir, globalBaseDir) : resolve47(dir);
   if (globalBaseDir && !resolvedDir) {
     output.error("[X] Target directory must stay within the configured global plans root");
     process.exitCode = 1;
     return;
   }
-  const safeResolvedDir = resolvedDir ?? resolve45(dir);
+  const safeResolvedDir = resolvedDir ?? resolve47(dir);
   const result = scaffoldPlan({
     title: options2.title,
     phases: phaseNames.map((name2) => ({ name: name2 })),
@@ -109831,24 +110449,24 @@ async function handleAddPhase(target, options2) {
 // src/commands/plan/plan-command.ts
 function resolveTargetPath(target, baseDir) {
   if (!baseDir) {
-    return resolve46(target);
+    return resolve48(target);
   }
   if (isAbsolute11(target)) {
-    return resolve46(target);
+    return resolve48(target);
   }
-  const cwdCandidate = resolve46(target);
+  const cwdCandidate = resolve48(target);
   if (existsSync67(cwdCandidate)) {
     return cwdCandidate;
   }
-  return resolve46(baseDir, target);
+  return resolve48(baseDir, target);
 }
 function resolvePlanFile(target, baseDir) {
-  const t = target ? resolveTargetPath(target, baseDir) : baseDir ? resolve46(baseDir) : process.cwd();
+  const t = target ? resolveTargetPath(target, baseDir) : baseDir ? resolve48(baseDir) : process.cwd();
   if (existsSync67(t)) {
     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;
   }
@@ -109856,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);
@@ -109907,7 +110525,7 @@ async function planCommand(action, target, options2) {
   let resolvedTarget = target;
   if (resolvedAction && !knownActions.has(resolvedAction)) {
     const looksLikePath = resolvedAction.includes("/") || resolvedAction.includes("\\") || resolvedAction.endsWith(".md") || resolvedAction === "." || resolvedAction === "..";
-    const existsOnDisk = !looksLikePath && existsSync67(resolve46(resolvedAction));
+    const existsOnDisk = !looksLikePath && existsSync67(resolve48(resolvedAction));
     if (looksLikePath || existsOnDisk) {
       resolvedTarget = resolvedAction;
       resolvedAction = undefined;
@@ -109950,11 +110568,11 @@ init_logger();
 init_safe_prompts();
 var import_picocolors34 = __toESM(require_picocolors(), 1);
 import { existsSync as existsSync68 } from "node:fs";
-import { resolve as resolve47 } from "node:path";
+import { resolve as resolve49 } from "node:path";
 async function handleAdd(projectPath, options2) {
   logger.debug(`Adding project: ${projectPath}, options: ${JSON.stringify(options2)}`);
   intro("Add Project");
-  const absolutePath = resolve47(projectPath);
+  const absolutePath = resolve49(projectPath);
   if (!existsSync68(absolutePath)) {
     log.error(`Path does not exist: ${absolutePath}`);
     process.exitCode = 1;
@@ -110378,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();
@@ -110501,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: () => ({}) } }
       });
@@ -111059,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 resolve48, 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();
@@ -111068,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);
@@ -111125,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);
         }
       }
@@ -111133,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;
@@ -111166,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;
@@ -111240,8 +111858,8 @@ async function restoreUninstallBackup(backup) {
 }
 async function isPathSafeToRemove(filePath, baseDir) {
   try {
-    const resolvedPath = resolve48(filePath);
-    const resolvedBase = resolve48(baseDir);
+    const resolvedPath = resolve50(filePath);
+    const resolvedBase = resolve50(baseDir);
     if (!resolvedPath.startsWith(resolvedBase + sep12) && resolvedPath !== resolvedBase) {
       logger.debug(`Path outside installation directory: ${filePath}`);
       return false;
@@ -111249,7 +111867,7 @@ async function isPathSafeToRemove(filePath, baseDir) {
     const stats = await import_fs_extra44.lstat(filePath);
     if (stats.isSymbolicLink()) {
       const realPath = await import_fs_extra44.realpath(filePath);
-      const resolvedReal = resolve48(realPath);
+      const resolvedReal = resolve50(realPath);
       if (!resolvedReal.startsWith(resolvedBase + sep12) && resolvedReal !== resolvedBase) {
         logger.debug(`Symlink points outside installation directory: ${filePath} -> ${realPath}`);
         return false;
@@ -111309,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)) {
@@ -111643,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
@@ -111712,7 +112330,7 @@ function getDisclaimerMarker() {
   return AI_DISCLAIMER;
 }
 function spawnAndCollect2(command, args) {
-  return new Promise((resolve49, reject) => {
+  return new Promise((resolve44, reject) => {
     const child = spawn7(command, args, { stdio: ["ignore", "pipe", "pipe"] });
     const chunks = [];
     const stderrChunks = [];
@@ -111725,7 +112343,7 @@ function spawnAndCollect2(command, args) {
         reject(new Error(`${command} exited with code ${code2}: ${stderr}`));
         return;
       }
-      resolve49(Buffer.concat(chunks).toString("utf-8"));
+      resolve44(Buffer.concat(chunks).toString("utf-8"));
     });
   });
 }
@@ -111833,7 +112451,7 @@ function formatResponse(content, showBranding) {
   return disclaimer + formatted + branding;
 }
 async function postViaGh(owner, repo, issueNumber, body) {
-  return new Promise((resolve49, reject) => {
+  return new Promise((resolve44, reject) => {
     const args = [
       "issue",
       "comment",
@@ -111855,7 +112473,7 @@ async function postViaGh(owner, repo, issueNumber, body) {
         reject(new Error(`gh exited with code ${code2}: ${stderr}`));
         return;
       }
-      resolve49();
+      resolve44();
     });
   });
 }
@@ -111973,7 +112591,7 @@ After completing the implementation:
     "--allowedTools",
     tools
   ];
-  await new Promise((resolve49, reject) => {
+  await new Promise((resolve44, reject) => {
     const child = spawn9("claude", args, { cwd: cwd2, stdio: ["pipe", "pipe", "pipe"], detached: false });
     child.stdin.write(prompt);
     child.stdin.end();
@@ -111998,7 +112616,7 @@ After completing the implementation:
         reject(new Error(`Claude exited ${code2}: ${stderr.slice(0, 500)}`));
         return;
       }
-      resolve49();
+      resolve44();
     });
   });
 }
@@ -112142,7 +112760,7 @@ function checkRateLimit2(processedThisHour, maxPerHour) {
   return processedThisHour < maxPerHour;
 }
 function spawnAndCollect3(command, args) {
-  return new Promise((resolve49, reject) => {
+  return new Promise((resolve44, reject) => {
     const child = spawn10(command, args, { stdio: ["ignore", "pipe", "pipe"] });
     const chunks = [];
     const stderrChunks = [];
@@ -112155,14 +112773,14 @@ function spawnAndCollect3(command, args) {
         reject(new Error(`${command} exited with code ${code2}: ${stderr}`));
         return;
       }
-      resolve49(Buffer.concat(chunks).toString("utf-8"));
+      resolve44(Buffer.concat(chunks).toString("utf-8"));
     });
   });
 }
 
 // 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();
@@ -112207,7 +112825,7 @@ async function invokeClaude(options2) {
   return collectClaudeOutput(child, options2.timeoutSec, verbose);
 }
 function collectClaudeOutput(child, timeoutSec, verbose = false) {
-  return new Promise((resolve49, reject) => {
+  return new Promise((resolve44, reject) => {
     const chunks = [];
     const stderrChunks = [];
     child.stdout?.on("data", (chunk) => {
@@ -112237,7 +112855,7 @@ function collectClaudeOutput(child, timeoutSec, verbose = false) {
         reject(new Error(`Claude exited with code ${code2}: ${stderr}`));
         return;
       }
-      resolve49(verbose ? parseStreamJsonOutput(stdout2) : parseClaudeOutput(stdout2));
+      resolve44(verbose ? parseStreamJsonOutput(stdout2) : parseClaudeOutput(stdout2));
     });
   });
 }
@@ -112540,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;
@@ -112551,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;
       }
@@ -112789,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) {
@@ -112873,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());
@@ -112882,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]));
@@ -112941,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) {
@@ -112949,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"}`);
@@ -112974,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 ?? {};
@@ -113102,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"], {
@@ -113139,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 });
@@ -113171,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}`);
@@ -113189,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;
@@ -113198,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"}`);
@@ -113272,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 {}
   }
@@ -113389,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);
   }
@@ -113501,7 +114119,7 @@ function formatQueueInfo(state) {
   return "idle";
 }
 function sleep(ms) {
-  return new Promise((resolve49) => setTimeout(resolve49, ms));
+  return new Promise((resolve44) => setTimeout(resolve44, ms));
 }
 // src/cli/command-registry.ts
 init_logger();
@@ -113648,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();
@@ -113662,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();
@@ -113679,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");
@@ -113697,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}`);
@@ -113981,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 {