@sunasteriskrnd/takumi 0.5.0 → 0.7.0

package/dist/index.js

@@ -11225,12 +11225,12 @@ function isSafeRelativeLayoutPath(value) {
   return segments.every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
 }
 function isValidKitType(value) {
-  return value === "engineer";
+  return value === "engineer" || value === "extras";
 }
-var KitType, KitConfigSchema, KitLayoutSchema, TakumiPackageMetadataSchema, DEFAULT_KIT_LAYOUT, AVAILABLE_KITS, NEVER_COPY_PATTERNS, USER_CONFIG_PATTERNS, PROTECTED_PATTERNS;
+var KitType, KitConfigSchema, KitLayoutSchema, TakumiPackageMetadataSchema, DEFAULT_KIT_LAYOUT, AVAILABLE_KITS, BASE_KIT = "engineer", NEVER_COPY_PATTERNS, USER_CONFIG_PATTERNS, PROTECTED_PATTERNS;
 var init_kit = __esm(() => {
   init_zod();
-  KitType = exports_external.enum(["engineer"]);
+  KitType = exports_external.enum(["engineer", "extras"]);
   KitConfigSchema = exports_external.object({
     id: KitType,
     name: exports_external.string(),
@@ -11256,6 +11256,13 @@ var init_kit = __esm(() => {
       repo: "takumi",
       owner: "sun-asterisk-internal",
       description: "Engineering toolkit for building with Claude"
+    },
+    extras: {
+      id: "extras",
+      name: "Takumi Extras",
+      repo: "takumi-extras",
+      owner: "sun-asterisk-internal",
+      description: "Extras agent kit"
     }
   };
   NEVER_COPY_PATTERNS = [
@@ -11444,13 +11451,14 @@ var init_metadata = __esm(() => {
   KitMetadataSchema = exports_external.object({
     version: exports_external.string(),
     installedAt: exports_external.string(),
+    installState: exports_external.enum(["pending", "complete"]).optional(),
     files: exports_external.array(TrackedFileSchema).optional(),
     lastUpdateCheck: exports_external.string().optional(),
     dismissedVersion: exports_external.string().optional(),
     installedSettings: InstalledSettingsSchema.optional()
   });
   MultiKitMetadataSchema = exports_external.object({
-    kits: exports_external.record(KitType, KitMetadataSchema).optional(),
+    kits: exports_external.record(exports_external.string(), KitMetadataSchema).optional(),
     scope: exports_external.enum(["local", "global"]).optional(),
     name: exports_external.string().optional(),
     version: exports_external.string().optional(),
@@ -12116,6 +12124,7 @@ __export(exports_types, {
   DEFAULT_FOLDERS: () => DEFAULT_FOLDERS,
   ConfigSchema: () => ConfigSchema,
   CodingLevelSchema: () => CodingLevelSchema,
+  BASE_KIT: () => BASE_KIT,
   AuthenticationError: () => AuthenticationError,
   ApiStatusOptionsSchema: () => ApiStatusOptionsSchema,
   ApiSetupOptionsSchema: () => ApiSetupOptionsSchema,
@@ -34351,7 +34360,7 @@ __export(exports_monorepo_resolver, {
   resolveMonorepoRoot: () => resolveMonorepoRoot
 });
 import { existsSync as existsSync44, readFileSync as readFileSync11 } from "node:fs";
-import { dirname as dirname25, join as join95, resolve as resolve20 } from "node:path";
+import { dirname as dirname25, join as join93, resolve as resolve20 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function parseMetadataAt(metadataPath) {
   if (!existsSync44(metadataPath))
@@ -34368,7 +34377,7 @@ function parseMetadataAt(metadataPath) {
   }
 }
 function readSourceDirFromPackageJson(candidateRoot) {
-  const packageJsonPath = join95(candidateRoot, "package.json");
+  const packageJsonPath = join93(candidateRoot, "package.json");
   if (!existsSync44(packageJsonPath))
     return null;
   try {
@@ -34381,7 +34390,7 @@ function readSourceDirFromPackageJson(candidateRoot) {
   return null;
 }
 function tryReadAtCandidate(candidateRoot) {
-  const flatMetadata = parseMetadataAt(join95(candidateRoot, "metadata.json"));
+  const flatMetadata = parseMetadataAt(join93(candidateRoot, "metadata.json"));
   if (flatMetadata) {
     return {
       root: candidateRoot,
@@ -34391,10 +34400,10 @@ function tryReadAtCandidate(candidateRoot) {
     };
   }
   const sourceDir = readSourceDirFromPackageJson(candidateRoot) ?? "claude";
-  const nestedMetadata = parseMetadataAt(join95(candidateRoot, sourceDir, "metadata.json"));
+  const nestedMetadata = parseMetadataAt(join93(candidateRoot, sourceDir, "metadata.json"));
   if (nestedMetadata) {
     return {
-      root: join95(candidateRoot, sourceDir),
+      root: join93(candidateRoot, sourceDir),
       repoRoot: candidateRoot,
       version: nestedMetadata.version,
       name: nestedMetadata.name
@@ -34554,9 +34563,9 @@ __export(exports_worktree_manager, {
 });
 import { existsSync as existsSync60 } from "node:fs";
 import { readFile as readFile49, writeFile as writeFile36 } from "node:fs/promises";
-import { join as join119 } from "node:path";
+import { join as join120 } from "node:path";
 async function createWorktree(projectDir, issueNumber, baseBranch) {
-  const worktreePath = join119(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
+  const worktreePath = join120(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
   const branchName = `sk-watch/issue-${issueNumber}`;
   await spawnAndCollect("git", ["fetch", "origin", baseBranch], projectDir).catch(() => {
     logger.warning(`[worktree] Could not fetch origin/${baseBranch}, using local`);
@@ -34574,7 +34583,7 @@ async function createWorktree(projectDir, issueNumber, baseBranch) {
   return worktreePath;
 }
 async function removeWorktree(projectDir, issueNumber) {
-  const worktreePath = join119(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
+  const worktreePath = join120(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
   const branchName = `sk-watch/issue-${issueNumber}`;
   try {
     await spawnAndCollect("git", ["worktree", "remove", worktreePath, "--force"], projectDir);
@@ -34588,7 +34597,7 @@ async function listActiveWorktrees(projectDir) {
   try {
     const output2 = await spawnAndCollect("git", ["worktree", "list", "--porcelain"], projectDir);
     const issueNumbers = [];
-    const worktreePrefix = join119(projectDir, WORKTREE_DIR, "issue-").replace(/\\/g, "/");
+    const worktreePrefix = join120(projectDir, WORKTREE_DIR, "issue-").replace(/\\/g, "/");
     for (const line of output2.split(`
 `)) {
       if (line.startsWith("worktree ")) {
@@ -34616,7 +34625,7 @@ async function cleanupAllWorktrees(projectDir) {
   await spawnAndCollect("git", ["worktree", "prune"], projectDir).catch(() => {});
 }
 async function ensureGitignore(projectDir) {
-  const gitignorePath = join119(projectDir, ".gitignore");
+  const gitignorePath = join120(projectDir, ".gitignore");
   try {
     const content = existsSync60(gitignorePath) ? await readFile49(gitignorePath, "utf-8") : "";
     if (!content.includes(".worktrees")) {
@@ -34723,7 +34732,7 @@ import { createHash as createHash8 } from "node:crypto";
 import { existsSync as existsSync66, mkdirSync as mkdirSync4, readFileSync as readFileSync16, readdirSync as readdirSync10, statSync as statSync7 } from "node:fs";
 import { rename as rename10, writeFile as writeFile38 } from "node:fs/promises";
 import { homedir as homedir32 } from "node:os";
-import { basename as basename17, join as join126 } from "node:path";
+import { basename as basename17, join as join127 } from "node:path";
 function getCachedContext(repoPath) {
   const cachePath = getCacheFilePath(repoPath);
   if (!existsSync66(cachePath))
@@ -34766,25 +34775,25 @@ function computeSourceHash(repoPath) {
 }
 function getDocSourcePaths(repoPath) {
   const paths = [];
-  const docsDir = join126(repoPath, "docs");
+  const docsDir = join127(repoPath, "docs");
   if (existsSync66(docsDir)) {
     try {
       const files = readdirSync10(docsDir);
       for (const f4 of files) {
         if (f4.endsWith(".md"))
-          paths.push(join126(docsDir, f4));
+          paths.push(join127(docsDir, f4));
       }
     } catch {}
   }
-  const readme = join126(repoPath, "README.md");
+  const readme = join127(repoPath, "README.md");
   if (existsSync66(readme))
     paths.push(readme);
-  const stylesDir = join126(repoPath, "assets", "writing-styles");
+  const stylesDir = join127(repoPath, "assets", "writing-styles");
   if (existsSync66(stylesDir)) {
     try {
       const files = readdirSync10(stylesDir);
       for (const f4 of files) {
-        paths.push(join126(stylesDir, f4));
+        paths.push(join127(stylesDir, f4));
       }
     } catch {}
   }
@@ -34793,11 +34802,11 @@ function getDocSourcePaths(repoPath) {
 function getCacheFilePath(repoPath) {
   const repoName = basename17(repoPath).replace(/[^a-zA-Z0-9_-]/g, "_");
   const pathHash = createHash8("sha256").update(repoPath).digest("hex").slice(0, 8);
-  return join126(CACHE_DIR, `${repoName}-${pathHash}-context-cache.json`);
+  return join127(CACHE_DIR, `${repoName}-${pathHash}-context-cache.json`);
 }
 var CACHE_DIR, CACHE_TTL_MS3;
 var init_context_cache_manager = __esm(() => {
-  CACHE_DIR = join126(homedir32(), ".sunagentkit", "cache");
+  CACHE_DIR = join127(homedir32(), ".sunagentkit", "cache");
   CACHE_TTL_MS3 = 24 * 60 * 60 * 1000;
 });
 
@@ -34978,7 +34987,7 @@ function extractContentFromResponse(response) {
 // src/commands/content/phases/docs-summarizer.ts
 import { execSync as execSync5 } from "node:child_process";
 import { existsSync as existsSync67, readFileSync as readFileSync17, readdirSync as readdirSync11 } from "node:fs";
-import { join as join127 } from "node:path";
+import { join as join128 } from "node:path";
 async function summarizeProjectDocs(repoPath, contentLogger) {
   const rawContent = collectRawDocs(repoPath);
   if (rawContent.total.length < 200) {
@@ -35032,12 +35041,12 @@ function collectRawDocs(repoPath) {
     return capped;
   };
   const docsContent = [];
-  const docsDir = join127(repoPath, "docs");
+  const docsDir = join128(repoPath, "docs");
   if (existsSync67(docsDir)) {
     try {
       const files = readdirSync11(docsDir).filter((f4) => f4.endsWith(".md")).sort();
       for (const f4 of files) {
-        const content = readCapped(join127(docsDir, f4), 5000);
+        const content = readCapped(join128(docsDir, f4), 5000);
         if (content) {
           docsContent.push(`### ${f4}
 ${content}`);
@@ -35051,21 +35060,21 @@ ${content}`);
   let brand = "";
   const brandCandidates = ["docs/brand-guidelines.md", "docs/design-guidelines.md"];
   for (const p2 of brandCandidates) {
-    brand = readCapped(join127(repoPath, p2), 3000);
+    brand = readCapped(join128(repoPath, p2), 3000);
     if (brand)
       break;
   }
   let styles3 = "";
-  const stylesDir = join127(repoPath, "assets", "writing-styles");
+  const stylesDir = join128(repoPath, "assets", "writing-styles");
   if (existsSync67(stylesDir)) {
     try {
       const files = readdirSync11(stylesDir).slice(0, 3);
-      styles3 = files.map((f4) => readCapped(join127(stylesDir, f4), 1000)).filter(Boolean).join(`
+      styles3 = files.map((f4) => readCapped(join128(stylesDir, f4), 1000)).filter(Boolean).join(`
 
 `);
     } catch {}
   }
-  const readme = readCapped(join127(repoPath, "README.md"), 3000);
+  const readme = readCapped(join128(repoPath, "README.md"), 3000);
   const total = [docs, brand, styles3, readme].join(`
 `);
   return { docs, brand, styles: styles3, readme, total };
@@ -35252,9 +35261,9 @@ IMPORTANT: Generate the image and output the path as JSON: {"imagePath": "/path/
 import { execSync as execSync6 } from "node:child_process";
 import { existsSync as existsSync68, mkdirSync as mkdirSync5, readdirSync as readdirSync12 } from "node:fs";
 import { homedir as homedir33 } from "node:os";
-import { join as join128 } from "node:path";
+import { join as join129 } from "node:path";
 async function generatePhoto(_content, context, config, platform10, contentId, contentLogger) {
-  const mediaDir = join128(config.contentDir.replace(/^~/, homedir33()), "media", String(contentId));
+  const mediaDir = join129(config.contentDir.replace(/^~/, homedir33()), "media", String(contentId));
   if (!existsSync68(mediaDir)) {
     mkdirSync5(mediaDir, { recursive: true });
   }
@@ -35279,7 +35288,7 @@ async function generatePhoto(_content, context, config, platform10, contentId, c
     const imageFile = files.find((f4) => /\.(png|jpg|jpeg|webp)$/i.test(f4));
     if (imageFile) {
       const ext2 = imageFile.split(".").pop() ?? "png";
-      return { path: join128(mediaDir, imageFile), ...dimensions, format: ext2 };
+      return { path: join129(mediaDir, imageFile), ...dimensions, format: ext2 };
     }
     contentLogger.warn(`Photo generation produced no image for content ${contentId}`);
     return null;
@@ -35369,7 +35378,7 @@ var init_content_creator = __esm(() => {
 // src/commands/content/phases/content-logger.ts
 import { createWriteStream as createWriteStream5, existsSync as existsSync69, mkdirSync as mkdirSync6, statSync as statSync8 } from "node:fs";
 import { homedir as homedir34 } from "node:os";
-import { join as join129 } from "node:path";
+import { join as join130 } from "node:path";
 
 class ContentLogger {
   stream = null;
@@ -35377,7 +35386,7 @@ class ContentLogger {
   logDir;
   maxBytes;
   constructor(maxBytes = 0) {
-    this.logDir = join129(homedir34(), ".sunagentkit", "logs");
+    this.logDir = join130(homedir34(), ".sunagentkit", "logs");
     this.maxBytes = maxBytes;
   }
   init() {
@@ -35409,7 +35418,7 @@ class ContentLogger {
     }
   }
   getLogPath() {
-    return join129(this.logDir, `content-${this.getDateStr()}.log`);
+    return join130(this.logDir, `content-${this.getDateStr()}.log`);
   }
   write(level, message) {
     this.rotateIfNeeded();
@@ -35426,18 +35435,18 @@ class ContentLogger {
     if (dateStr !== this.currentDate) {
       this.close();
       this.currentDate = dateStr;
-      const logPath = join129(this.logDir, `content-${dateStr}.log`);
+      const logPath = join130(this.logDir, `content-${dateStr}.log`);
       this.stream = createWriteStream5(logPath, { flags: "a", mode: 384 });
       return;
     }
     if (this.maxBytes > 0 && this.stream) {
-      const logPath = join129(this.logDir, `content-${this.currentDate}.log`);
+      const logPath = join130(this.logDir, `content-${this.currentDate}.log`);
       try {
         const stat16 = statSync8(logPath);
         if (stat16.size >= this.maxBytes) {
           this.close();
           const suffix = Date.now();
-          const rotatedPath = join129(this.logDir, `content-${this.currentDate}-${suffix}.log`);
+          const rotatedPath = join130(this.logDir, `content-${this.currentDate}-${suffix}.log`);
           import("node:fs/promises").then(({ rename: rename11 }) => rename11(logPath, rotatedPath).catch(() => {}));
           this.stream = createWriteStream5(logPath, { flags: "w", mode: 384 });
         }
@@ -35663,7 +35672,7 @@ function isNoiseCommit(title, author) {
 // src/commands/content/phases/change-detector.ts
 import { execSync as execSync8 } from "node:child_process";
 import { existsSync as existsSync71, readFileSync as readFileSync18, readdirSync as readdirSync13, statSync as statSync9 } from "node:fs";
-import { join as join130 } from "node:path";
+import { join as join131 } from "node:path";
 function detectCommits(repo, since) {
   try {
     const fetchUrl = sshToHttps(repo.remoteUrl);
@@ -35761,7 +35770,7 @@ function detectTags(repo, since) {
   }
 }
 function detectCompletedPlans(repo, since) {
-  const plansDir = join130(repo.path, "plans");
+  const plansDir = join131(repo.path, "plans");
   if (!existsSync71(plansDir))
     return [];
   const sinceMs = new Date(since).getTime();
@@ -35771,7 +35780,7 @@ function detectCompletedPlans(repo, since) {
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const planFile = join130(plansDir, entry.name, "plan.md");
+      const planFile = join131(plansDir, entry.name, "plan.md");
       if (!existsSync71(planFile))
         continue;
       try {
@@ -35849,7 +35858,7 @@ function classifyCommit(event) {
 // src/commands/content/phases/repo-discoverer.ts
 import { execSync as execSync9 } from "node:child_process";
 import { readdirSync as readdirSync14 } from "node:fs";
-import { join as join131 } from "node:path";
+import { join as join132 } from "node:path";
 function discoverRepos2(cwd2) {
   const repos = [];
   if (isGitRepoRoot(cwd2)) {
@@ -35862,7 +35871,7 @@ function discoverRepos2(cwd2) {
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith("."))
         continue;
-      const dirPath = join131(cwd2, entry.name);
+      const dirPath = join132(cwd2, entry.name);
       if (isGitRepoRoot(dirPath)) {
         const info = getRepoInfo(dirPath);
         if (info)
@@ -36529,9 +36538,9 @@ var init_types3 = __esm(() => {
 
 // src/commands/content/phases/state-manager.ts
 import { readFile as readFile51, rename as rename11, writeFile as writeFile39 } from "node:fs/promises";
-import { join as join132 } from "node:path";
+import { join as join133 } from "node:path";
 async function loadContentConfig(projectDir) {
-  const configPath = join132(projectDir, TAKUMI_CONFIG_FILE2);
+  const configPath = join133(projectDir, TAKUMI_CONFIG_FILE2);
   try {
     const raw = await readFile51(configPath, "utf-8");
     const json = JSON.parse(raw);
@@ -36541,13 +36550,13 @@ async function loadContentConfig(projectDir) {
   }
 }
 async function saveContentConfig(projectDir, config) {
-  const configPath = join132(projectDir, TAKUMI_CONFIG_FILE2);
+  const configPath = join133(projectDir, TAKUMI_CONFIG_FILE2);
   const json = await readJsonSafe(configPath);
   json.content = { ...json.content, ...config };
   await atomicWrite3(configPath, json);
 }
 async function loadContentState(projectDir) {
-  const configPath = join132(projectDir, TAKUMI_CONFIG_FILE2);
+  const configPath = join133(projectDir, TAKUMI_CONFIG_FILE2);
   try {
     const raw = await readFile51(configPath, "utf-8");
     const json = JSON.parse(raw);
@@ -36558,7 +36567,7 @@ async function loadContentState(projectDir) {
   }
 }
 async function saveContentState(projectDir, state) {
-  const configPath = join132(projectDir, TAKUMI_CONFIG_FILE2);
+  const configPath = join133(projectDir, TAKUMI_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);
@@ -36840,7 +36849,7 @@ var init_platform_setup_x = __esm(() => {
 
 // src/commands/content/phases/setup-wizard.ts
 import { existsSync as existsSync72 } from "node:fs";
-import { join as join133 } from "node:path";
+import { join as join134 } from "node:path";
 async function runSetupWizard2(cwd2, contentLogger) {
   console.log();
   oe(import_picocolors40.default.bgCyan(import_picocolors40.default.white(" SK Content — Multi-Channel Content Engine ")));
@@ -36908,8 +36917,8 @@ async function showRepoSummary(cwd2) {
 function detectBrandAssets(cwd2, contentLogger) {
   const repos = discoverRepos2(cwd2);
   for (const repo of repos) {
-    const hasGuidelines = existsSync72(join133(repo.path, "docs", "brand-guidelines.md"));
-    const hasStyles = existsSync72(join133(repo.path, "assets", "writing-styles"));
+    const hasGuidelines = existsSync72(join134(repo.path, "docs", "brand-guidelines.md"));
+    const hasStyles = existsSync72(join134(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`);
@@ -37051,9 +37060,9 @@ __export(exports_content_subcommands, {
 });
 import { existsSync as existsSync74, readFileSync as readFileSync19, unlinkSync as unlinkSync6 } from "node:fs";
 import { homedir as homedir36 } from "node:os";
-import { join as join134 } from "node:path";
+import { join as join135 } from "node:path";
 function isDaemonRunning() {
-  const lockFile = join134(LOCK_DIR, `${LOCK_NAME2}.lock`);
+  const lockFile = join135(LOCK_DIR, `${LOCK_NAME2}.lock`);
   if (!existsSync74(lockFile))
     return { running: false, pid: null };
   try {
@@ -37085,7 +37094,7 @@ async function startContent(options2) {
   await contentCommand(options2);
 }
 async function stopContent() {
-  const lockFile = join134(LOCK_DIR, `${LOCK_NAME2}.lock`);
+  const lockFile = join135(LOCK_DIR, `${LOCK_NAME2}.lock`);
   if (!existsSync74(lockFile)) {
     logger.info("Content daemon is not running.");
     return;
@@ -37124,9 +37133,9 @@ async function statusContent() {
   } catch {}
 }
 async function logsContent(options2) {
-  const logDir = join134(homedir36(), ".sunagentkit", "logs");
+  const logDir = join135(homedir36(), ".sunagentkit", "logs");
   const dateStr = new Date().toISOString().slice(0, 10).replace(/-/g, "");
-  const logPath = join134(logDir, `content-${dateStr}.log`);
+  const logPath = join135(logDir, `content-${dateStr}.log`);
   if (!existsSync74(logPath)) {
     logger.info("No content logs found for today.");
     return;
@@ -37158,13 +37167,13 @@ var init_content_subcommands = __esm(() => {
   init_setup_wizard();
   init_state_manager();
   init_content_review_commands();
-  LOCK_DIR = join134(homedir36(), ".sunagentkit", "locks");
+  LOCK_DIR = join135(homedir36(), ".sunagentkit", "locks");
 });
 
 // src/commands/content/content-command.ts
 import { existsSync as existsSync75, mkdirSync as mkdirSync8, unlinkSync as unlinkSync7, writeFileSync as writeFileSync6 } from "node:fs";
 import { homedir as homedir37 } from "node:os";
-import { join as join135 } from "node:path";
+import { join as join136 } from "node:path";
 async function contentCommand(options2) {
   const cwd2 = process.cwd();
   const contentLogger = new ContentLogger;
@@ -37342,8 +37351,8 @@ var init_content_command = __esm(() => {
   init_publisher();
   init_review_manager();
   init_state_manager();
-  LOCK_DIR2 = join135(homedir37(), ".sunagentkit", "locks");
-  LOCK_FILE = join135(LOCK_DIR2, "sk-content.lock");
+  LOCK_DIR2 = join136(homedir37(), ".sunagentkit", "locks");
+  LOCK_FILE = join136(LOCK_DIR2, "sk-content.lock");
 });
 
 // src/commands/content/index.ts
@@ -48980,11 +48989,11 @@ async function detectMetadataFormat(claudeDir) {
       };
     }
     if (parsed.name || parsed.version || parsed.files) {
-      let detectedKit = null;
+      let detectedKit = "engineer";
       const nameToCheck = parsed.name || "";
-      if (/\bengineer\b/i.test(nameToCheck)) {
-        detectedKit = "engineer";
-      } else {
+      if (/\bextras\b/i.test(nameToCheck)) {
+        detectedKit = "extras";
+      } else if (/\bengineer\b/i.test(nameToCheck)) {
         detectedKit = "engineer";
       }
       return { format: "legacy", metadata: parsed, detectedKit };
@@ -49278,28 +49287,32 @@ var import_fs_extra6 = __toESM(require_lib(), 1);
 var import_picomatch = __toESM(require_picomatch2(), 1);
 function findFileInMetadata(metadata, path3) {
   if (!metadata)
-    return null;
+    return { tracked: null, ownerKit: null };
   if (metadata.kits) {
-    for (const kitMeta of Object.values(metadata.kits)) {
-      if (kitMeta?.files) {
-        const found = kitMeta.files.find((f3) => f3.path === path3);
-        if (found)
-          return found;
-      }
+    for (const [kitName, kitMeta] of Object.entries(metadata.kits)) {
+      if (!kitMeta?.files)
+        continue;
+      const found = kitMeta.files.find((f3) => f3.path === path3);
+      if (found)
+        return { tracked: found, ownerKit: kitName };
     }
   }
   if (metadata.files) {
     const found = metadata.files.find((f3) => f3.path === path3);
     if (found)
-      return found;
+      return { tracked: found, ownerKit: null };
   }
-  return null;
+  return { tracked: null, ownerKit: null };
 }
-function shouldDeletePath(path3, metadata) {
-  const tracked = findFileInMetadata(metadata, path3);
+function shouldDeletePath(path3, metadata, installingKit) {
+  const { tracked, ownerKit } = findFileInMetadata(metadata, path3);
   if (!tracked)
     return true;
-  return tracked.ownership !== "user";
+  if (tracked.ownership === "user")
+    return false;
+  if (installingKit && ownerKit && ownerKit !== installingKit)
+    return false;
+  return true;
 }
 function collectFilesRecursively(dir, baseDir) {
   const results = [];
@@ -49422,7 +49435,7 @@ async function updateMetadataAfterDeletion(claudeDir, deletedPaths) {
     logger.debug("Failed to write updated metadata.json");
   }
 }
-async function handleDeletions(sourceMetadata, claudeDir) {
+async function handleDeletions(sourceMetadata, claudeDir, installingKit) {
   const deletionPatterns = sourceMetadata.deletions || [];
   if (deletionPatterns.length === 0) {
     return { deletedPaths: [], preservedPaths: [], errors: [] };
@@ -49439,9 +49452,9 @@ async function handleDeletions(sourceMetadata, claudeDir) {
       result.errors.push(path3);
       continue;
     }
-    if (!shouldDeletePath(path3, userMetadata)) {
+    if (!shouldDeletePath(path3, userMetadata, installingKit)) {
       result.preservedPaths.push(path3);
-      logger.verbose(`Preserved user file: ${path3}`);
+      logger.verbose(`Preserved file (cross-kit or user-owned): ${path3}`);
       continue;
     }
     if (existsSync13(fullPath)) {
@@ -52510,14 +52523,17 @@ async function writeManifest(providerRoot, kitName, version3, scope, kitType, tr
         logger.debug(`Could not read existing metadata: ${error}`);
       }
     }
+    const existingKits = existingMetadata.kits || {};
+    const otherKitsExist = Object.keys(existingKits).some((k2) => k2 !== kit);
     const installedAt = new Date().toISOString();
+    const existingKitMeta = existingKits[kit];
     const kitMetadata = {
+      ...existingKitMeta ?? {},
       version: version3,
       installedAt,
+      installState: "complete",
       files: trackedFiles.length > 0 ? trackedFiles : undefined
     };
-    const existingKits = existingMetadata.kits || {};
-    const otherKitsExist = Object.keys(existingKits).some((k2) => k2 !== kit);
     const metadata = {
       kits: {
         ...existingKits,
@@ -52548,6 +52564,69 @@ async function writeManifest(providerRoot, kitName, version3, scope, kitType, tr
     }
   }
 }
+async function writeKitPending(providerRoot, kit, version3, scope) {
+  const metadataPath = join28(providerRoot, "metadata.json");
+  await import_fs_extra10.ensureFile(metadataPath);
+  let release = null;
+  try {
+    release = await import_proper_lockfile4.lock(metadataPath, {
+      retries: { retries: 5, minTimeout: 100, maxTimeout: 1000 },
+      stale: 60000
+    });
+    logger.debug(`Acquired lock on ${metadataPath} for pending-state write`);
+    const migrationResult = await migrateToMultiKit(providerRoot);
+    if (!migrationResult.success) {
+      logger.warning(`Metadata migration warning: ${migrationResult.error}`);
+    }
+    let existingMetadata = { kits: {} };
+    if (await import_fs_extra10.pathExists(metadataPath)) {
+      try {
+        const content = await import_fs_extra10.readFile(metadataPath, "utf-8");
+        const parsed = JSON.parse(content);
+        if (parsed && typeof parsed === "object" && Object.keys(parsed).length > 0) {
+          existingMetadata = parsed;
+        }
+      } catch (error) {
+        logger.debug(`Could not read existing metadata: ${error}`);
+      }
+    }
+    const existingKits = existingMetadata.kits || {};
+    const pendingMetadata = {
+      version: version3,
+      installedAt: new Date().toISOString(),
+      installState: "pending",
+      files: []
+    };
+    const metadata = {
+      ...existingMetadata,
+      kits: {
+        ...existingKits,
+        [kit]: pendingMetadata
+      },
+      scope
+    };
+    const validated = MetadataSchema.parse(metadata);
+    await import_fs_extra10.writeFile(metadataPath, JSON.stringify(validated, null, 2), "utf-8");
+    logger.debug(`Wrote pending-state entry for kit "${kit}"`);
+  } finally {
+    if (release) {
+      await release();
+      logger.debug(`Released lock on ${metadataPath}`);
+    }
+  }
+}
+async function findPendingKits(providerRoot) {
+  const metadata = await readManifest(providerRoot);
+  if (!metadata?.kits)
+    return [];
+  const pending = [];
+  for (const [kitName, kitMeta] of Object.entries(metadata.kits)) {
+    if (kitMeta?.installState === "pending") {
+      pending.push(kitName);
+    }
+  }
+  return pending;
+}
 async function removeKitFromManifest(providerRoot, kit) {
   const metadataPath = join28(providerRoot, "metadata.json");
   if (!await import_fs_extra10.pathExists(metadataPath))
@@ -52749,6 +52828,12 @@ class ManifestWriter {
   async writeManifest(providerRoot, kitName, version3, scope, kitType) {
     return writeManifest(providerRoot, kitName, version3, scope, kitType, this.getTrackedFiles(), this.getUserConfigFiles());
   }
+  static async writeKitPending(providerRoot, kit, version3, scope) {
+    return writeKitPending(providerRoot, kit, version3, scope);
+  }
+  static async findPendingKits(providerRoot) {
+    return findPendingKits(providerRoot);
+  }
   static async readManifest(providerRoot) {
     return readManifest(providerRoot);
   }
@@ -53716,7 +53801,7 @@ async function handleMerge(ctx) {
   }
   try {
     if (sourceMetadata?.deletions && sourceMetadata.deletions.length > 0) {
-      const deletionResult = await handleDeletions(sourceMetadata, ctx.claudeDir);
+      const deletionResult = await handleDeletions(sourceMetadata, ctx.claudeDir, ctx.kitType);
       if (deletionResult.deletedPaths.length > 0) {
         logger.info(`Removed ${deletionResult.deletedPaths.length} deprecated file(s)`);
         for (const path4 of deletionResult.deletedPaths) {
@@ -55543,14 +55628,17 @@ async function handlePostInstall(ctx) {
     }
   }
   const skillsDir = PathResolver.buildSkillsPath(ctx.resolvedDir, ctx.options.global);
-  const depsResult = await promptAndInstallSkillsDeps({
-    skillsDir,
-    isNonInteractive: ctx.isNonInteractive,
-    installSkills: ctx.installSkills,
-    withSudo: ctx.options.withSudo,
-    prompts: ctx.prompts
-  });
-  const installSkills = depsResult.installSkills;
+  let installSkills = ctx.installSkills;
+  if (ctx.isLastKit === undefined || ctx.isLastKit) {
+    const depsResult = await promptAndInstallSkillsDeps({
+      skillsDir,
+      isNonInteractive: ctx.isNonInteractive,
+      installSkills: ctx.installSkills,
+      withSudo: ctx.options.withSudo,
+      prompts: ctx.prompts
+    });
+    installSkills = depsResult.installSkills;
+  }
   if (!ctx.isNonInteractive) {
     const { isGeminiInstalled: isGeminiInstalled2 } = await Promise.resolve().then(() => (init_package_installer(), exports_package_installer));
     const { checkExistingGeminiConfig: checkExistingGeminiConfig2, findMcpConfigPath: findMcpConfigPath2, processGeminiMcpLinking: processGeminiMcpLinking2 } = await Promise.resolve().then(() => (init_gemini_mcp_linker(), exports_gemini_mcp_linker));
@@ -60490,6 +60578,8 @@ var codexInstaller = {
           await copySkillsAuxFiles(sources.skills, codexSkillsDir);
           await copySkillsScriptsDir(ctx.extractDir, codexSkillsDir);
           auxCopySucceeded = true;
+          ctx.codexSkillsDirSeen = codexSkillsDir;
+          ctx.codexAuxCopiedAny = true;
         } catch (error) {
           logger.error(`[init/codex] skills aux copy failed: ${error instanceof Error ? error.message : String(error)}`);
           logger.warning("[init/codex] skipping skills-deps install (aux files unavailable)");
@@ -60502,9 +60592,12 @@ var codexInstaller = {
           logger.debug(`[init/codex] project auto-registration skipped: ${error instanceof Error ? error.message : String(error)}`);
         }
       }
-      if (hasSkills && codexSkillsDir && auxCopySucceeded) {
+      const isLastIteration = ctx.isLastKit === undefined || ctx.isLastKit;
+      const depsTargetDir = codexSkillsDir ?? ctx.codexSkillsDirSeen;
+      const auxAvailable = auxCopySucceeded || ctx.codexAuxCopiedAny === true;
+      if (isLastIteration && depsTargetDir && auxAvailable) {
         const depsResult = await promptAndInstallSkillsDeps({
-          skillsDir: codexSkillsDir,
+          skillsDir: depsTargetDir,
           isNonInteractive: ctx.isNonInteractive,
           installSkills: ctx.installSkills,
           withSudo: ctx.options.withSudo,
@@ -63269,10 +63362,170 @@ async function doctorCommand(options2 = {}) {
   }
 }
 
-// src/domains/sync/config-version-checker.ts
+// src/commands/init/init-command.ts
+import { join as join102 } from "node:path";
+
+// src/domains/ui/prompts.ts
+init_package_installer();
+init_logger();
+
+// src/domains/ui/prompts/agent-selection-prompts.ts
+init_provider_registry();
+
+// src/services/package-installer/agent-cli-detector.ts
+init_process_executor();
+var DETECT_TIMEOUT_MS = 5000;
+var BINARY_CANDIDATES = {
+  "claude-code": process.platform === "win32" ? ["claude.exe", "claude.cmd", "claude"] : ["claude"],
+  codex: process.platform === "win32" ? ["codex.exe", "codex.cmd", "codex"] : ["codex"]
+};
+async function probeBinary(candidates) {
+  for (const bin of candidates) {
+    const needsShell = process.platform === "win32" && /\.(cmd|bat)$/i.test(bin);
+    try {
+      const { stdout } = await execFileAsync5(bin, ["--version"], {
+        timeout: DETECT_TIMEOUT_MS,
+        encoding: "utf8",
+        shell: needsShell
+      });
+      return typeof stdout === "string" ? stdout : String(stdout);
+    } catch {}
+  }
+  return null;
+}
+function extractVersion(stdout) {
+  const match2 = stdout.match(/(\d+\.\d+\.\d+(?:[-+][\w.]+)?)/);
+  return match2 ? match2[1] : undefined;
+}
+async function detectAgentInstallations(providers2) {
+  const probes = providers2.filter((p) => (p in BINARY_CANDIDATES)).map(async (provider) => {
+    const candidates = BINARY_CANDIDATES[provider];
+    if (!candidates) {
+      return [provider, { installed: false }];
+    }
+    const stdout = await probeBinary(candidates);
+    const detection = stdout ? { installed: true, version: extractVersion(stdout) } : { installed: false };
+    return [provider, detection];
+  });
+  const entries = await Promise.all(probes);
+  const result = {};
+  for (const [provider, detection] of entries) {
+    result[provider] = detection;
+  }
+  return result;
+}
+
+// src/domains/ui/prompts/agent-selection-prompts.ts
+function buildDetectionNote(supported, detections) {
+  const lines = supported.map((provider) => {
+    const detection = detections[provider];
+    const label = providers[provider]?.displayName ?? provider;
+    if (detection?.installed) {
+      const version3 = detection.version ? ` v${detection.version}` : "";
+      return `  ✓ ${label}${version3} detected on PATH`;
+    }
+    return `  ✗ ${label} not detected on PATH`;
+  });
+  lines.push("");
+  lines.push("Init writes config files regardless — detection only informs defaults.");
+  return lines.join(`
+`);
+}
+function computeInitialSelection(supported, detections) {
+  if (detections["claude-code"]?.installed)
+    return ["claude-code"];
+  const firstInstalled = supported.find((p) => detections[p]?.installed);
+  return firstInstalled ? [firstInstalled] : [];
+}
+async function promptAgentSelection(supported) {
+  const detections = await detectAgentInstallations(supported);
+  note(buildDetectionNote(supported, detections), "Detected agent CLIs");
+  const options2 = supported.map((provider) => {
+    const detection = detections[provider];
+    const label = providers[provider]?.displayName ?? provider;
+    const hint = detection?.installed ? detection.version ? `installed v${detection.version}` : "installed" : "not detected — config will still be written";
+    return { value: provider, label, hint };
+  });
+  const initialValues = computeInitialSelection(supported, detections);
+  const selected = await ae({
+    message: "Select agent(s) to initialize",
+    options: options2,
+    required: true,
+    initialValues
+  });
+  if (lD(selected))
+    return null;
+  return selected;
+}
+// src/domains/ui/prompts/kit-prompts.ts
+init_logger();
+init_types2();
+async function selectKit(defaultKit, accessibleKits) {
+  const kits = accessibleKits ?? Object.keys(AVAILABLE_KITS);
+  const kit = await ie({
+    message: "Select a Takumi:",
+    options: kits.map((key) => ({
+      value: key,
+      label: AVAILABLE_KITS[key].name,
+      hint: AVAILABLE_KITS[key].description
+    })),
+    initialValue: defaultKit
+  });
+  if (lD(kit)) {
+    throw new Error("Kit selection cancelled");
+  }
+  return kit;
+}
+async function selectKits(accessibleKits, defaults2) {
+  const kits = accessibleKits ?? Object.keys(AVAILABLE_KITS);
+  const options2 = kits.map((key) => {
+    const isBase = key === BASE_KIT;
+    const cfg = AVAILABLE_KITS[key];
+    return {
+      value: key,
+      label: isBase ? `${cfg.name} (base, required)` : cfg.name,
+      hint: cfg.description
+    };
+  });
+  const initialValues = defaults2 && defaults2.length > 0 ? Array.from(new Set([BASE_KIT, ...defaults2])).filter((k2) => kits.includes(k2)) : kits;
+  const selected = await ae({
+    message: "Select kit(s) to install:",
+    options: options2,
+    initialValues,
+    required: true
+  });
+  if (lD(selected)) {
+    throw new Error("Kit selection cancelled");
+  }
+  const result = selected;
+  if (!result.includes(BASE_KIT) && kits.includes(BASE_KIT)) {
+    logger.info(`"${AVAILABLE_KITS[BASE_KIT].name}" is the base kit and was added back automatically.`);
+    result.unshift(BASE_KIT);
+  }
+  const idx = result.indexOf(BASE_KIT);
+  if (idx > 0) {
+    result.splice(idx, 1);
+    result.unshift(BASE_KIT);
+  }
+  return result;
+}
+async function getDirectory(defaultDir = ".") {
+  const dir = await te({
+    message: "Enter target directory:",
+    placeholder: `Press Enter for "${defaultDir}"`,
+    validate: () => {
+      return;
+    }
+  });
+  if (lD(dir)) {
+    throw new Error("Directory input cancelled");
+  }
+  const trimmed = (dir ?? "").trim();
+  return trimmed.length > 0 ? trimmed : defaultDir;
+}
+// src/domains/versioning/version-selector.ts
 init_auth_client();
-import { mkdir as mkdir22, readFile as readFile38, unlink as unlink12, writeFile as writeFile29 } from "node:fs/promises";
-import { join as join86 } from "node:path";
+init_github_client();
 
 // src/domains/installation/release-source.ts
 init_auth_client();
@@ -63383,900 +63636,198 @@ class WorkerSource {
   }
 }
 
-// src/domains/versioning/checking/version-utils.ts
-var import_compare_versions2 = __toESM(require_umd(), 1);
-function isUpdateCheckDisabled() {
-  return process.env.NO_UPDATE_NOTIFIER === "1" || process.env.NO_UPDATE_NOTIFIER === "true" || !process.stdout.isTTY;
-}
-function normalizeVersion(version3) {
-  return version3.replace(/^v/i, "");
-}
-function isPrereleaseVersion(version3) {
-  if (!version3)
-    return false;
-  return /-(beta|alpha|rc|dev)[.\d]/i.test(normalizeVersion(version3));
+// src/domains/installation/release-entry-adapter.ts
+function githubReleaseToEntry(release, kit = "engineer") {
+  const expected = assetNameFor(kit);
+  const expectedAsset = release.assets.find((a3) => a3.name === expected);
+  const fallback2 = release.assets[0];
+  const archive = expectedAsset?.name ?? fallback2?.name ?? expected;
+  return {
+    tag: release.tag_name,
+    version: release.tag_name.replace(/^v/, ""),
+    prerelease: release.prerelease,
+    publishedAt: release.published_at ?? "",
+    archive
+  };
 }
-function parseVersionParts(version3) {
-  const normalized = normalizeVersion(version3);
-  const [base, ...prereleaseParts] = normalized.split("-");
+function releaseEntryToGitHubRelease(entry, kit) {
   return {
-    base,
-    prerelease: prereleaseParts.length > 0 ? prereleaseParts.join("-") : null
+    id: 0,
+    tag_name: entry.tag,
+    name: entry.tag,
+    draft: false,
+    prerelease: entry.prerelease,
+    published_at: entry.publishedAt || undefined,
+    tarball_url: `https://github.com/${kit.owner}/${kit.repo}/archive/refs/tags/${entry.tag}.tar.gz`,
+    zipball_url: `https://github.com/${kit.owner}/${kit.repo}/archive/refs/tags/${entry.tag}.zip`,
+    assets: []
   };
 }
-function isPrereleaseOfSameBase(currentVersion, latestVersion) {
-  const current = parseVersionParts(currentVersion);
-  const latest = parseVersionParts(latestVersion);
-  if (!current.prerelease)
-    return false;
-  if (latest.prerelease !== null)
+
+// src/domains/versioning/version-selector.ts
+init_logger();
+init_dist2();
+init_release_filter();
+var import_picocolors20 = __toESM(require_picocolors(), 1);
+
+// src/domains/versioning/selection/version-filter.ts
+var VERSION_PATTERN = /^v?\d+\.\d+\.\d+(-[a-zA-Z0-9.]+)?$/;
+function isValidVersionFormat(version3) {
+  const trimmed = version3.trim();
+  if (!trimmed)
     return false;
-  return current.base === latest.base;
-}
-function versionsMatch(installed, latest) {
-  return normalizeVersion(installed) === normalizeVersion(latest);
+  return VERSION_PATTERN.test(trimmed);
 }
-function isNewerVersion(currentVersion, latestVersion) {
-  try {
-    const current = normalizeVersion(currentVersion);
-    const latest = normalizeVersion(latestVersion);
-    if (isPrereleaseOfSameBase(current, latest)) {
-      return false;
-    }
-    return import_compare_versions2.compareVersions(latest, current) > 0;
-  } catch {
-    return false;
-  }
+function normalizeVersionTag(version3) {
+  const trimmed = version3.trim();
+  return trimmed.startsWith("v") ? trimmed : `v${trimmed}`;
 }
-
-// src/domains/sync/config-version-checker.ts
+// src/domains/versioning/selection/selection-ui.ts
+init_environment();
 init_logger();
-init_path_resolver();
-var CACHE_TTL_HOURS = 24;
-var DEFAULT_CACHE_TTL_MS = CACHE_TTL_HOURS * 60 * 60 * 1000;
-var MIN_CACHE_TTL_MS = 60 * 1000;
-var MAX_CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
-function parseCacheTtl() {
-  const envValue = process.env.TAKUMI_SYNC_CACHE_TTL;
-  if (!envValue) {
-    return DEFAULT_CACHE_TTL_MS;
-  }
-  const parsed = Number.parseInt(envValue, 10);
-  if (Number.isNaN(parsed) || parsed < 0) {
-    logger.warning(`Invalid TAKUMI_SYNC_CACHE_TTL value "${envValue}", using default (${CACHE_TTL_HOURS}h)`);
-    return DEFAULT_CACHE_TTL_MS;
-  }
-  const ttlMs = parsed * 1000;
-  if (ttlMs < MIN_CACHE_TTL_MS) {
-    logger.warning(`TAKUMI_SYNC_CACHE_TTL too low (${parsed}s), using minimum (60s)`);
-    return MIN_CACHE_TTL_MS;
-  }
-  if (ttlMs > MAX_CACHE_TTL_MS) {
-    logger.warning(`TAKUMI_SYNC_CACHE_TTL too high (${parsed}s), using maximum (7 days)`);
-    return MAX_CACHE_TTL_MS;
-  }
-  return ttlMs;
-}
-var CACHE_TTL_MS = parseCacheTtl();
-var CACHE_FILENAME = "config-update-cache.json";
+init_dist2();
+var import_picocolors19 = __toESM(require_picocolors(), 1);
 
-class ConfigVersionChecker {
-  static getCacheFilePath(kitType, global3) {
-    const cacheDir = PathResolver.getCacheDir(global3);
-    return join86(cacheDir, `${kitType}-${CACHE_FILENAME}`);
-  }
-  static async loadCache(kitType, global3) {
-    try {
-      const cachePath = ConfigVersionChecker.getCacheFilePath(kitType, global3);
-      const data = await readFile38(cachePath, "utf8");
-      const parsed = JSON.parse(data);
-      if (typeof parsed !== "object" || parsed === null || typeof parsed.lastCheck !== "number" || typeof parsed.latestVersion !== "string" || !parsed.latestVersion || parsed.lastCheck < 0 || parsed.lastCheck > Date.now() + 7 * 24 * 60 * 60 * 1000) {
-        logger.debug("Invalid cache structure, ignoring");
-        return null;
+// src/domains/versioning/version-display.ts
+var import_picocolors18 = __toESM(require_picocolors(), 1);
+
+class VersionDisplayFormatter {
+  static createBadges(release) {
+    const badges = [];
+    if (release.isLatestStable) {
+      badges.push(import_picocolors18.default.bold(import_picocolors18.default.yellow("[latest]")));
+    }
+    if (release.prerelease || release.isLatestBeta) {
+      if (release.isLatestBeta) {
+        badges.push(import_picocolors18.default.bold(import_picocolors18.default.magenta("[beta]")));
+      } else {
+        badges.push(import_picocolors18.default.magenta("[prerelease]"));
       }
-      return parsed;
-    } catch {
-      return null;
+    } else if (!release.draft) {
+      badges.push(import_picocolors18.default.blue("[stable]"));
     }
-  }
-  static async saveCache(kitType, global3, cache) {
-    try {
-      const cachePath = ConfigVersionChecker.getCacheFilePath(kitType, global3);
-      const cacheDir = PathResolver.getCacheDir(global3);
-      await mkdir22(cacheDir, { recursive: true });
-      await writeFile29(cachePath, JSON.stringify(cache, null, 2));
-    } catch (error) {
-      logger.debug(`Cache write failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    if (release.draft) {
+      badges.push(import_picocolors18.default.gray("[draft]"));
     }
+    return badges.length > 0 ? ` ${badges.join(" ")}` : "";
   }
-  static async fetchLatestVersion(kitType) {
-    const maxRetries = 3;
-    const baseBackoff = 1000;
-    for (let attempt = 0;attempt < maxRetries; attempt++) {
-      try {
-        const worker = new WorkerSource(getServerUrl(), kitType);
-        const entry = await worker.fetchLatest();
-        const version3 = entry.version.replace(/^v/, "");
-        if (!version3 || version3.length > 256) {
-          logger.debug(`Invalid version format from Worker: ${entry.version}`);
-          return null;
-        }
-        const semverParts = version3.split(/[-+]/);
-        const coreParts = semverParts[0].split(".");
-        if (coreParts.length !== 3 || !coreParts.every((p) => /^\d+$/.test(p))) {
-          logger.debug(`Invalid version format from Worker: ${entry.version}`);
-          return null;
-        }
-        return { version: version3 };
-      } catch (error) {
-        if (error instanceof NotLoggedInError) {
-          logger.debug("Skipping update check (not logged in)");
-          return null;
-        }
-        const isLastAttempt = attempt === maxRetries - 1;
-        if (isLastAttempt) {
-          logger.debug(`Version check failed after ${maxRetries} attempts: ${error}`);
-          return null;
-        }
-        const delay2 = baseBackoff * 2 ** attempt;
-        await new Promise((resolve17) => setTimeout(resolve17, delay2));
-      }
-    }
-    return null;
+  static formatChoiceLabel(release) {
+    const version3 = import_picocolors18.default.green(release.displayVersion);
+    const badges = VersionDisplayFormatter.createBadges(release);
+    const name = release.name || "Release";
+    return `${version3}${badges} ${import_picocolors18.default.dim(name)}`;
   }
-  static async checkForUpdates(kitType, currentVersion, global3 = false) {
-    const normalizedCurrent = currentVersion.replace(/^v/, "");
-    const cache = await ConfigVersionChecker.loadCache(kitType, global3);
-    const now = Date.now();
-    if (cache && now - cache.lastCheck < CACHE_TTL_MS) {
-      const hasUpdates = isNewerVersion(normalizedCurrent, cache.latestVersion);
-      return {
-        hasUpdates,
-        currentVersion: normalizedCurrent,
-        latestVersion: cache.latestVersion,
-        fromCache: true
-      };
+  static formatChoiceHint(release) {
+    const parts = [];
+    if (release.relativeTime && release.relativeTime !== "Unknown") {
+      parts.push(release.relativeTime);
     }
-    const result = await ConfigVersionChecker.fetchLatestVersion(kitType);
-    if (result) {
-      await ConfigVersionChecker.saveCache(kitType, global3, {
-        lastCheck: now,
-        latestVersion: result.version
+    if (release.assetCount > 0) {
+      const assetText = release.assetCount === 1 ? "asset" : "assets";
+      parts.push(`${release.assetCount} ${assetText}`);
+    }
+    if (release.normalizedVersion !== release.displayVersion) {
+      parts.push(`(${release.normalizedVersion})`);
+    }
+    return parts.length > 0 ? parts.join(", ") : "";
+  }
+  static createSpecialOptions(releases) {
+    const options2 = [];
+    const latestStable = releases.find((r2) => r2.isLatestStable && !r2.prerelease);
+    if (latestStable) {
+      options2.push({
+        value: latestStable.tag_name,
+        label: `${import_picocolors18.default.bold(import_picocolors18.default.green("Latest Stable"))} (${latestStable.displayVersion})`,
+        hint: "recommended version",
+        isLatest: true,
+        isPrerelease: false
       });
-      const hasUpdates = isNewerVersion(normalizedCurrent, result.version);
-      return {
-        hasUpdates,
-        currentVersion: normalizedCurrent,
-        latestVersion: result.version,
-        fromCache: false
-      };
     }
-    if (cache) {
-      const hasUpdates = isNewerVersion(normalizedCurrent, cache.latestVersion);
-      return {
-        hasUpdates,
-        currentVersion: normalizedCurrent,
-        latestVersion: cache.latestVersion,
-        fromCache: true
-      };
+    const latestBeta = releases.find((r2) => r2.isLatestBeta || r2.prerelease && !r2.draft);
+    if (latestBeta) {
+      options2.push({
+        value: latestBeta.tag_name,
+        label: `${import_picocolors18.default.bold(import_picocolors18.default.magenta("Latest Beta"))} (${latestBeta.displayVersion})`,
+        hint: "latest features, may be unstable",
+        isLatest: false,
+        isPrerelease: true
+      });
     }
+    return options2;
+  }
+  static createSeparator() {
     return {
-      hasUpdates: false,
-      currentVersion: normalizedCurrent,
-      latestVersion: normalizedCurrent,
-      fromCache: false
+      value: "separator",
+      label: import_picocolors18.default.dim("─".repeat(50)),
+      hint: undefined,
+      isLatest: false,
+      isPrerelease: false
     };
   }
-  static async clearCache(kitType, global3 = false) {
-    const cachePath = ConfigVersionChecker.getCacheFilePath(kitType, global3);
-    try {
-      await unlink12(cachePath);
-      logger.debug(`Cleared sync cache for ${kitType}`);
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw error;
+  static createCancelOption() {
+    return {
+      value: "cancel",
+      label: import_picocolors18.default.red("Cancel"),
+      hint: "exit version selection",
+      isLatest: false,
+      isPrerelease: false
+    };
+  }
+  static formatVersionChoice(release) {
+    return {
+      value: release.tag_name,
+      label: VersionDisplayFormatter.formatChoiceLabel(release),
+      hint: VersionDisplayFormatter.formatChoiceHint(release),
+      isLatest: release.isLatestStable,
+      isPrerelease: release.prerelease
+    };
+  }
+  static formatReleasesToChoices(releases, includeSpecialOptions = true, limit = 30) {
+    const choices = [];
+    if (includeSpecialOptions) {
+      const specialOptions = VersionDisplayFormatter.createSpecialOptions(releases);
+      choices.push(...specialOptions);
+      if (specialOptions.length > 0 && releases.length > 0) {
+        choices.push(VersionDisplayFormatter.createSeparator());
       }
     }
+    const limitedReleases = releases.slice(0, limit);
+    for (const release of limitedReleases) {
+      choices.push(VersionDisplayFormatter.formatVersionChoice(release));
+    }
+    if (includeSpecialOptions) {
+      choices.push(VersionDisplayFormatter.createSeparator());
+      choices.push(VersionDisplayFormatter.createCancelOption());
+    }
+    return choices;
   }
-}
-// src/domains/sync/sync-engine.ts
-import { lstat as lstat6, readFile as readFile39, readlink, realpath as realpath3, stat as stat8 } from "node:fs/promises";
-import { isAbsolute as isAbsolute3, join as join87, normalize as normalize8, relative as relative14 } from "node:path";
-init_logger();
-var MAX_SYNC_FILE_SIZE = 10 * 1024 * 1024;
-var MAX_SYMLINK_DEPTH = 20;
-async function validateSymlinkChain(path8, basePath, maxDepth = MAX_SYMLINK_DEPTH) {
-  let current = path8;
-  let depth = 0;
-  while (depth < maxDepth) {
-    try {
-      const stats = await lstat6(current);
-      if (!stats.isSymbolicLink())
-        break;
-      const target = await readlink(current);
-      const resolvedTarget = isAbsolute3(target) ? target : join87(current, "..", target);
-      const normalizedTarget = normalize8(resolvedTarget);
-      const rel = relative14(basePath, normalizedTarget);
-      if (rel.startsWith("..") || isAbsolute3(rel)) {
-        throw new Error(`Symlink chain escapes base directory at depth ${depth}: ${path8}`);
+  static getDefaultChoiceIndex(choices) {
+    for (let i = 0;i < choices.length; i++) {
+      const choice = choices[i];
+      if (choice.isLatest && !choice.isPrerelease) {
+        return i;
       }
-      current = normalizedTarget;
-      depth++;
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("Symlink chain")) {
-        throw error;
+    }
+    for (let i = 0;i < choices.length; i++) {
+      if (choices[i].value !== "separator") {
+        return i;
       }
-      break;
     }
+    return 0;
   }
-  if (depth >= maxDepth) {
-    throw new Error(`Symlink chain too deep (>${maxDepth}): ${path8}`);
-  }
-}
-async function validateSyncPath(basePath, filePath) {
-  if (!filePath || filePath.trim() === "") {
-    throw new Error("Empty file path not allowed");
-  }
-  if (filePath.includes("\x00")) {
-    throw new Error(`Invalid file path (null byte): ${filePath}`);
-  }
-  if (filePath.length > 1024) {
-    throw new Error(`Path too long: ${filePath.slice(0, 50)}...`);
-  }
-  const normalized = normalize8(filePath);
-  if (isAbsolute3(normalized)) {
-    throw new Error(`Absolute paths not allowed: ${filePath}`);
-  }
-  if (normalized.startsWith("..") || normalized.includes("/../")) {
-    throw new Error(`Path traversal not allowed: ${filePath}`);
-  }
-  const fullPath = join87(basePath, normalized);
-  const rel = relative14(basePath, fullPath);
-  if (rel.startsWith("..") || isAbsolute3(rel)) {
-    throw new Error(`Path escapes base directory: ${filePath}`);
-  }
-  await validateSymlinkChain(fullPath, basePath);
-  try {
-    const resolvedBase = await realpath3(basePath);
-    const resolvedFull = await realpath3(fullPath);
-    const resolvedRel = relative14(resolvedBase, resolvedFull);
-    if (resolvedRel.startsWith("..") || isAbsolute3(resolvedRel)) {
-      throw new Error(`Symlink escapes base directory: ${filePath}`);
-    }
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      const parentPath = join87(fullPath, "..");
-      try {
-        const resolvedBase = await realpath3(basePath);
-        const resolvedParent = await realpath3(parentPath);
-        const resolvedRel = relative14(resolvedBase, resolvedParent);
-        if (resolvedRel.startsWith("..") || isAbsolute3(resolvedRel)) {
-          throw new Error(`Parent symlink escapes base directory: ${filePath}`);
-        }
-      } catch (parentError) {
-        if (parentError.code !== "ENOENT") {
-          throw parentError;
-        }
-      }
-    } else {
-      throw error;
-    }
-  }
-  return fullPath;
-}
-
-class SyncEngine {
-  static async createSyncPlan(trackedFiles, claudeDir, upstreamDir) {
-    const plan = { autoUpdate: [], needsReview: [], skipped: [] };
-    for (const file of trackedFiles) {
-      if (file.ownership === "user") {
-        plan.skipped.push(file);
-        continue;
-      }
-      let upstreamPath;
-      try {
-        upstreamPath = await validateSyncPath(upstreamDir, file.path);
-      } catch (error) {
-        logger.warning(`Skipping invalid path: ${file.path}`);
-        plan.skipped.push(file);
-        continue;
-      }
-      try {
-        await stat8(upstreamPath);
-      } catch {
-        plan.skipped.push(file);
-        continue;
-      }
-      let localPath;
-      try {
-        localPath = await validateSyncPath(claudeDir, file.path);
-      } catch (error) {
-        logger.warning(`Skipping invalid local path: ${file.path}`);
-        plan.skipped.push(file);
-        continue;
-      }
-      try {
-        await stat8(localPath);
-      } catch {
-        plan.autoUpdate.push(file);
-        continue;
-      }
-      if (file.ownership === "takumi") {
-        plan.autoUpdate.push(file);
-        continue;
-      }
-      const currentChecksum = await OwnershipChecker.calculateChecksum(localPath);
-      const baseChecksum = file.baseChecksum || file.checksum;
-      if (currentChecksum === baseChecksum) {
-        plan.autoUpdate.push(file);
-      } else {
-        plan.needsReview.push(file);
-      }
-    }
-    return plan;
-  }
-  static generateHunks(currentContent, newContent, filename, contextLines = 3) {
-    const patch = structuredPatch(filename, filename, currentContent, newContent, "", "", {
-      context: contextLines
-    });
-    return patch.hunks.map((hunk) => ({
-      oldStart: hunk.oldStart,
-      oldLines: hunk.oldLines,
-      newStart: hunk.newStart,
-      newLines: hunk.newLines,
-      lines: hunk.lines
-    }));
-  }
-  static applyHunks(content, hunks, accepted) {
-    const acceptedHunks = hunks.filter((_3, i) => accepted[i]);
-    if (acceptedHunks.length === 0) {
-      return content;
-    }
-    const patchStr = SyncEngine.buildUnifiedDiff(content, acceptedHunks);
-    const result = applyPatch(content, patchStr);
-    if (result === false) {
-      try {
-        return SyncEngine.applyHunksManually(content, acceptedHunks);
-      } catch (fallbackError) {
-        throw new Error(`Failed to apply ${acceptedHunks.length} hunk(s): patch and manual methods both failed. ` + `Manual error: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`);
-      }
-    }
-    return result;
-  }
-  static buildUnifiedDiff(_content, hunks) {
-    let diff = `--- a
-+++ b
-`;
-    for (const hunk of hunks) {
-      diff += `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@
-`;
-      for (const line of hunk.lines) {
-        diff += `${line}
-`;
-      }
-    }
-    return diff;
-  }
-  static applyHunksManually(content, hunks) {
-    const lines = content.split(`
-`);
-    const sortedHunks = [...hunks].sort((a3, b3) => b3.oldStart - a3.oldStart);
-    for (const hunk of sortedHunks) {
-      const startIndex = hunk.oldStart - 1;
-      if (startIndex < 0 || startIndex > lines.length) {
-        logger.warning(`Hunk start ${hunk.oldStart} out of bounds (file has ${lines.length} lines)`);
-        continue;
-      }
-      const newLines = [];
-      let deleteCount = 0;
-      for (const line of hunk.lines) {
-        if (!line || line.length === 0) {
-          continue;
-        }
-        const prefix = line[0];
-        const lineContent = line.slice(1);
-        if (prefix === "-") {
-          deleteCount++;
-        } else if (prefix === "+" || prefix === " ") {
-          newLines.push(lineContent);
-        }
-      }
-      if (startIndex + deleteCount > lines.length) {
-        logger.warning(`Hunk would delete past EOF (start: ${startIndex}, delete: ${deleteCount}, lines: ${lines.length})`);
-        continue;
-      }
-      lines.splice(startIndex, deleteCount, ...newLines);
-    }
-    return lines.join(`
-`);
-  }
-  static isBinaryFile(content) {
-    if (content.length === 0) {
-      return false;
-    }
-    const sampleSize = Math.min(content.length, 8192);
-    let nonPrintableCount = 0;
-    for (let i = 0;i < sampleSize; i++) {
-      const code = content.charCodeAt(i);
-      if (code === 0) {
-        return true;
-      }
-      if (code < 32 && code !== 9 && code !== 10 && code !== 13) {
-        nonPrintableCount++;
-      }
-    }
-    return nonPrintableCount / sampleSize > 0.1;
-  }
-  static async loadFileContent(filePath) {
-    try {
-      const lstats = await lstat6(filePath);
-      if (lstats.isSymbolicLink()) {
-        throw new Error(`Symlink not allowed for sync: ${filePath}`);
-      }
-      if (lstats.size > MAX_SYNC_FILE_SIZE) {
-        throw new Error(`File too large for sync (${Math.round(lstats.size / 1024 / 1024)}MB > ${MAX_SYNC_FILE_SIZE / 1024 / 1024}MB limit)`);
-      }
-      const buffer = await readFile39(filePath);
-      if (buffer.includes(0)) {
-        return { content: "", isBinary: true };
-      }
-      const content = buffer.toString("utf8");
-      if (content.includes("�")) {
-        return { content: "", isBinary: true };
-      }
-      if (SyncEngine.isBinaryFile(content)) {
-        return { content: "", isBinary: true };
-      }
-      return { content, isBinary: false };
-    } catch (error) {
-      const errMsg = error instanceof Error ? error.message : "Unknown error";
-      throw new Error(`Cannot read file for sync: ${filePath} - ${errMsg}`);
-    }
-  }
-}
-// src/domains/sync/deletion-path-filter.ts
-init_path_resolver();
-var import_picomatch2 = __toESM(require_picomatch2(), 1);
-function filterDeletionPaths(trackedFiles, deletions) {
-  if (!deletions || deletions.length === 0) {
-    return trackedFiles;
-  }
-  const exactPaths = new Set;
-  const globMatchers = [];
-  for (const pattern of deletions) {
-    if (PathResolver.isGlobPattern(pattern)) {
-      globMatchers.push(import_picomatch2.default(pattern));
-    } else {
-      exactPaths.add(pattern);
-    }
-  }
-  return trackedFiles.filter((file) => {
-    if (exactPaths.has(file.path))
-      return false;
-    for (const matcher of globMatchers) {
-      if (matcher(file.path))
-        return false;
-    }
-    return true;
-  });
-}
-// src/domains/sync/merge-ui.ts
-init_dist2();
-var import_picocolors18 = __toESM(require_picocolors(), 1);
-var HUNK_SEPARATOR_WIDTH = 50;
-var EXTENDED_CONTEXT_LINES = 10;
-var MAX_LINE_DISPLAY_LENGTH = 120;
-function requireTTY() {
-  if (!process.stdin.isTTY || !process.stdout.isTTY) {
-    throw new Error("Interactive merge requires a TTY terminal. " + "Use --yes flag for non-interactive mode, or run in a terminal.");
-  }
-}
-function truncateLine(line) {
-  if (line.length <= MAX_LINE_DISPLAY_LENGTH)
-    return line;
-  return `${line.slice(0, MAX_LINE_DISPLAY_LENGTH - 3)}...`;
-}
-
-class MergeUI {
-  static async promptHunk(hunk, hunkIndex, totalHunks, _filename) {
-    requireTTY();
-    const lineRange = `${hunk.oldStart}-${hunk.oldStart + hunk.oldLines - 1}`;
-    console.log(import_picocolors18.default.cyan(`
-Hunk ${hunkIndex + 1}/${totalHunks}: Lines ${lineRange}`));
-    console.log(import_picocolors18.default.dim("─".repeat(HUNK_SEPARATOR_WIDTH)));
-    for (const line of hunk.lines) {
-      const displayLine = truncateLine(line);
-      const prefix = line[0];
-      if (prefix === "+") {
-        console.log(import_picocolors18.default.green(displayLine));
-      } else if (prefix === "-") {
-        console.log(import_picocolors18.default.red(displayLine));
-      } else {
-        console.log(import_picocolors18.default.dim(displayLine));
-      }
-    }
-    console.log(import_picocolors18.default.dim("─".repeat(HUNK_SEPARATOR_WIDTH)));
-    const action = await ie({
-      message: "Action?",
-      options: [
-        { value: "accept", label: "[a]ccept - Apply this change" },
-        { value: "reject", label: "[r]eject - Keep current" },
-        { value: "view", label: "[v]iew - More context" },
-        { value: "skip", label: "[s]kip - Skip entire file" }
-      ]
-    });
-    if (lD(action)) {
-      return "skip";
-    }
-    return action;
-  }
-  static showExtendedContext(currentContent, hunk, contextLines = EXTENDED_CONTEXT_LINES) {
-    const lines = currentContent.split(`
-`);
-    const startLine = Math.max(0, hunk.oldStart - 1 - contextLines);
-    const endLine = Math.min(lines.length, hunk.oldStart + hunk.oldLines - 1 + contextLines);
-    console.log(import_picocolors18.default.cyan(`
-Extended context (lines ${startLine + 1}-${endLine}):`));
-    console.log(import_picocolors18.default.dim("─".repeat(HUNK_SEPARATOR_WIDTH)));
-    for (let i = startLine;i < endLine; i++) {
-      const lineNum = String(i + 1).padStart(4, " ");
-      const isInHunk = i >= hunk.oldStart - 1 && i < hunk.oldStart - 1 + hunk.oldLines;
-      const prefix = isInHunk ? import_picocolors18.default.yellow("*") : " ";
-      console.log(`${import_picocolors18.default.dim(lineNum)} ${prefix} ${lines[i]}`);
-    }
-    console.log(import_picocolors18.default.dim("─".repeat(HUNK_SEPARATOR_WIDTH)));
-  }
-  static async mergeFile(filename, currentContent, _newContent, hunks) {
-    console.log(import_picocolors18.default.bold(`
-━━━ ${filename} ━━━`));
-    console.log(import_picocolors18.default.dim(`${hunks.length} change${hunks.length === 1 ? "" : "s"} to review
-`));
-    const decisions = [];
-    for (let i = 0;i < hunks.length; i++) {
-      let action;
-      do {
-        action = await MergeUI.promptHunk(hunks[i], i, hunks.length, filename);
-        if (action === "view") {
-          MergeUI.showExtendedContext(currentContent, hunks[i]);
-        }
-      } while (action === "view");
-      if (action === "skip") {
-        return "skipped";
-      }
-      decisions.push(action === "accept");
-    }
-    const result = SyncEngine.applyHunks(currentContent, hunks, decisions);
-    const applied = decisions.filter(Boolean).length;
-    const rejected = decisions.length - applied;
-    return { result, applied, rejected };
-  }
-  static displayMergeSummary(filename, applied, rejected) {
-    if (applied > 0 && rejected > 0) {
-      console.log(import_picocolors18.default.dim(`  ${filename}: `) + import_picocolors18.default.green(`${applied} applied`) + import_picocolors18.default.dim(", ") + import_picocolors18.default.yellow(`${rejected} rejected`));
-    } else if (applied > 0) {
-      console.log(import_picocolors18.default.dim(`  ${filename}: `) + import_picocolors18.default.green(`${applied} applied`));
-    } else {
-      console.log(import_picocolors18.default.dim(`  ${filename}: `) + import_picocolors18.default.yellow(`${rejected} rejected`));
-    }
-  }
-  static displaySkipped(filename) {
-    console.log(import_picocolors18.default.dim(`  ${filename}: `) + import_picocolors18.default.yellow("skipped"));
-  }
-}
-// src/domains/sync/notification-display.ts
-var import_picocolors19 = __toESM(require_picocolors(), 1);
-import { stdout } from "node:process";
-function createNotificationBox(borderColor, boxWidth) {
-  const contentWidth = boxWidth - 2;
-  const topBorder = borderColor(`╭${"─".repeat(contentWidth)}╮`);
-  const bottomBorder = borderColor(`╰${"─".repeat(contentWidth)}╯`);
-  const emptyLine = borderColor("│") + " ".repeat(contentWidth) + borderColor("│");
-  const padLine = (text, visibleLen) => {
-    const len = visibleLen ?? text.length;
-    const displayText = len > contentWidth ? `${text.slice(0, contentWidth - 3)}...` : text;
-    const actualLen = visibleLen ?? displayText.length;
-    const totalPadding = contentWidth - actualLen;
-    const leftPadding = Math.max(0, Math.floor(totalPadding / 2));
-    const rightPadding = Math.max(0, totalPadding - leftPadding);
-    return borderColor("│") + " ".repeat(leftPadding) + displayText + " ".repeat(rightPadding) + borderColor("│");
-  };
-  return { topBorder, bottomBorder, emptyLine, padLine };
-}
-function displayConfigUpdateNotification(currentVersion, latestVersion, isGlobal = false) {
-  const displayCurrent = currentVersion.replace(/^v/, "");
-  const displayLatest = latestVersion.replace(/^v/, "");
-  const terminalWidth = stdout.columns || 80;
-  const boxWidth = Math.min(52, terminalWidth - 4);
-  const { topBorder, bottomBorder, emptyLine, padLine } = createNotificationBox(import_picocolors19.default.cyan, boxWidth);
-  const headerText = import_picocolors19.default.bold(import_picocolors19.default.yellow("\uD83D\uDCE6 Config Updates Available"));
-  const headerLen = "\uD83D\uDCE6 Config Updates Available".length;
-  const versionText = `${import_picocolors19.default.dim(displayCurrent)} ${import_picocolors19.default.white("→")} ${import_picocolors19.default.green(import_picocolors19.default.bold(displayLatest))}`;
-  const versionLen = displayCurrent.length + 3 + displayLatest.length;
-  const updateCmd = isGlobal ? "tkm init -g --sync" : "tkm init --sync";
-  const commandText = `Run: ${import_picocolors19.default.cyan(import_picocolors19.default.bold(updateCmd))}`;
-  const commandLen = `Run: ${updateCmd}`.length;
-  console.log("");
-  console.log(topBorder);
-  console.log(emptyLine);
-  console.log(padLine(headerText, headerLen));
-  console.log(padLine(versionText, versionLen));
-  console.log(emptyLine);
-  console.log(padLine(commandText, commandLen));
-  console.log(emptyLine);
-  console.log(bottomBorder);
-  console.log("");
-}
-// src/domains/sync/passive-update-check.ts
-init_logger();
-async function maybeShowConfigUpdateNotification(claudeDir, global3) {
-  try {
-    const detection = await detectMetadataFormat(claudeDir);
-    if (detection.format === "none" || !detection.metadata) {
-      logger.debug("No metadata found, skipping update check");
-      return false;
-    }
-    const kitsToCheck = [];
-    if (detection.format === "multi-kit" && detection.metadata.kits) {
-      for (const [kitType, kitInfo] of Object.entries(detection.metadata.kits)) {
-        if (kitInfo?.version) {
-          kitsToCheck.push({ kit: kitType, version: kitInfo.version });
-        }
-      }
-    } else if (detection.format === "legacy" && detection.detectedKit && detection.metadata.version) {
-      kitsToCheck.push({
-        kit: detection.detectedKit,
-        version: detection.metadata.version
-      });
-    }
-    if (kitsToCheck.length === 0) {
-      logger.debug("No kits with versions found, skipping update check");
-      return false;
-    }
-    for (const { kit, version: version3 } of kitsToCheck) {
-      const result = await ConfigVersionChecker.checkForUpdates(kit, version3, global3);
-      if (result.hasUpdates) {
-        displayConfigUpdateNotification(result.currentVersion, result.latestVersion, global3);
-        return true;
-      }
-    }
-    return false;
-  } catch (error) {
-    logger.debug(`Passive update check failed: ${error instanceof Error ? error.message : error}`);
-    return false;
-  }
-}
-// src/domains/ui/prompts.ts
-init_package_installer();
-init_logger();
-
-// src/domains/ui/prompts/kit-prompts.ts
-init_types2();
-async function selectKit(defaultKit, accessibleKits) {
-  const kits = accessibleKits ?? Object.keys(AVAILABLE_KITS);
-  const kit = await ie({
-    message: "Select a Takumi:",
-    options: kits.map((key) => ({
-      value: key,
-      label: AVAILABLE_KITS[key].name,
-      hint: AVAILABLE_KITS[key].description
-    })),
-    initialValue: defaultKit
-  });
-  if (lD(kit)) {
-    throw new Error("Kit selection cancelled");
-  }
-  return kit;
-}
-async function getDirectory(defaultDir = ".") {
-  const dir = await te({
-    message: "Enter target directory:",
-    placeholder: `Press Enter for "${defaultDir}"`,
-    validate: () => {
-      return;
-    }
-  });
-  if (lD(dir)) {
-    throw new Error("Directory input cancelled");
-  }
-  const trimmed = (dir ?? "").trim();
-  return trimmed.length > 0 ? trimmed : defaultDir;
-}
-// src/domains/versioning/version-selector.ts
-init_auth_client();
-init_github_client();
-
-// src/domains/installation/release-entry-adapter.ts
-function githubReleaseToEntry(release, kit = "engineer") {
-  const expected = assetNameFor(kit);
-  const expectedAsset = release.assets.find((a3) => a3.name === expected);
-  const fallback2 = release.assets[0];
-  const archive = expectedAsset?.name ?? fallback2?.name ?? expected;
-  return {
-    tag: release.tag_name,
-    version: release.tag_name.replace(/^v/, ""),
-    prerelease: release.prerelease,
-    publishedAt: release.published_at ?? "",
-    archive
-  };
-}
-function releaseEntryToGitHubRelease(entry, kit) {
-  return {
-    id: 0,
-    tag_name: entry.tag,
-    name: entry.tag,
-    draft: false,
-    prerelease: entry.prerelease,
-    published_at: entry.publishedAt || undefined,
-    tarball_url: `https://github.com/${kit.owner}/${kit.repo}/archive/refs/tags/${entry.tag}.tar.gz`,
-    zipball_url: `https://github.com/${kit.owner}/${kit.repo}/archive/refs/tags/${entry.tag}.zip`,
-    assets: []
-  };
-}
-
-// src/domains/versioning/version-selector.ts
-init_logger();
-init_dist2();
-init_release_filter();
-var import_picocolors22 = __toESM(require_picocolors(), 1);
-
-// src/domains/versioning/selection/version-filter.ts
-var VERSION_PATTERN = /^v?\d+\.\d+\.\d+(-[a-zA-Z0-9.]+)?$/;
-function isValidVersionFormat(version3) {
-  const trimmed = version3.trim();
-  if (!trimmed)
-    return false;
-  return VERSION_PATTERN.test(trimmed);
-}
-function normalizeVersionTag(version3) {
-  const trimmed = version3.trim();
-  return trimmed.startsWith("v") ? trimmed : `v${trimmed}`;
-}
-// src/domains/versioning/selection/selection-ui.ts
-init_environment();
-init_logger();
-init_dist2();
-var import_picocolors21 = __toESM(require_picocolors(), 1);
-
-// src/domains/versioning/version-display.ts
-var import_picocolors20 = __toESM(require_picocolors(), 1);
-
-class VersionDisplayFormatter {
-  static createBadges(release) {
-    const badges = [];
-    if (release.isLatestStable) {
-      badges.push(import_picocolors20.default.bold(import_picocolors20.default.yellow("[latest]")));
-    }
-    if (release.prerelease || release.isLatestBeta) {
-      if (release.isLatestBeta) {
-        badges.push(import_picocolors20.default.bold(import_picocolors20.default.magenta("[beta]")));
-      } else {
-        badges.push(import_picocolors20.default.magenta("[prerelease]"));
-      }
-    } else if (!release.draft) {
-      badges.push(import_picocolors20.default.blue("[stable]"));
-    }
-    if (release.draft) {
-      badges.push(import_picocolors20.default.gray("[draft]"));
-    }
-    return badges.length > 0 ? ` ${badges.join(" ")}` : "";
-  }
-  static formatChoiceLabel(release) {
-    const version3 = import_picocolors20.default.green(release.displayVersion);
-    const badges = VersionDisplayFormatter.createBadges(release);
-    const name = release.name || "Release";
-    return `${version3}${badges} ${import_picocolors20.default.dim(name)}`;
-  }
-  static formatChoiceHint(release) {
-    const parts = [];
-    if (release.relativeTime && release.relativeTime !== "Unknown") {
-      parts.push(release.relativeTime);
-    }
-    if (release.assetCount > 0) {
-      const assetText = release.assetCount === 1 ? "asset" : "assets";
-      parts.push(`${release.assetCount} ${assetText}`);
-    }
-    if (release.normalizedVersion !== release.displayVersion) {
-      parts.push(`(${release.normalizedVersion})`);
-    }
-    return parts.length > 0 ? parts.join(", ") : "";
-  }
-  static createSpecialOptions(releases) {
-    const options2 = [];
-    const latestStable = releases.find((r2) => r2.isLatestStable && !r2.prerelease);
-    if (latestStable) {
-      options2.push({
-        value: latestStable.tag_name,
-        label: `${import_picocolors20.default.bold(import_picocolors20.default.green("Latest Stable"))} (${latestStable.displayVersion})`,
-        hint: "recommended version",
-        isLatest: true,
-        isPrerelease: false
-      });
-    }
-    const latestBeta = releases.find((r2) => r2.isLatestBeta || r2.prerelease && !r2.draft);
-    if (latestBeta) {
-      options2.push({
-        value: latestBeta.tag_name,
-        label: `${import_picocolors20.default.bold(import_picocolors20.default.magenta("Latest Beta"))} (${latestBeta.displayVersion})`,
-        hint: "latest features, may be unstable",
-        isLatest: false,
-        isPrerelease: true
-      });
-    }
-    return options2;
-  }
-  static createSeparator() {
-    return {
-      value: "separator",
-      label: import_picocolors20.default.dim("─".repeat(50)),
-      hint: undefined,
-      isLatest: false,
-      isPrerelease: false
-    };
-  }
-  static createCancelOption() {
-    return {
-      value: "cancel",
-      label: import_picocolors20.default.red("Cancel"),
-      hint: "exit version selection",
-      isLatest: false,
-      isPrerelease: false
-    };
-  }
-  static formatVersionChoice(release) {
-    return {
-      value: release.tag_name,
-      label: VersionDisplayFormatter.formatChoiceLabel(release),
-      hint: VersionDisplayFormatter.formatChoiceHint(release),
-      isLatest: release.isLatestStable,
-      isPrerelease: release.prerelease
-    };
-  }
-  static formatReleasesToChoices(releases, includeSpecialOptions = true, limit = 30) {
-    const choices = [];
-    if (includeSpecialOptions) {
-      const specialOptions = VersionDisplayFormatter.createSpecialOptions(releases);
-      choices.push(...specialOptions);
-      if (specialOptions.length > 0 && releases.length > 0) {
-        choices.push(VersionDisplayFormatter.createSeparator());
-      }
-    }
-    const limitedReleases = releases.slice(0, limit);
-    for (const release of limitedReleases) {
-      choices.push(VersionDisplayFormatter.formatVersionChoice(release));
-    }
-    if (includeSpecialOptions) {
-      choices.push(VersionDisplayFormatter.createSeparator());
-      choices.push(VersionDisplayFormatter.createCancelOption());
-    }
-    return choices;
-  }
-  static getDefaultChoiceIndex(choices) {
-    for (let i = 0;i < choices.length; i++) {
-      const choice = choices[i];
-      if (choice.isLatest && !choice.isPrerelease) {
-        return i;
-      }
-    }
-    for (let i = 0;i < choices.length; i++) {
-      if (choices[i].value !== "separator") {
-        return i;
-      }
-    }
-    return 0;
-  }
-  static isValidVersionChoice(value) {
-    return value !== "separator" && value !== "cancel" && value.trim().length > 0;
+  static isValidVersionChoice(value) {
+    return value !== "separator" && value !== "cancel" && value.trim().length > 0;
   }
   static formatError(message, suggestion) {
-    let output2 = import_picocolors20.default.red(`Error: ${message}`);
+    let output2 = import_picocolors18.default.red(`Error: ${message}`);
     if (suggestion) {
       output2 += `
-${import_picocolors20.default.dim(suggestion)}`;
+${import_picocolors18.default.dim(suggestion)}`;
     }
     return output2;
   }
   static formatSuccess(version3, kitName) {
-    return `${import_picocolors20.default.green("✓")} Selected ${import_picocolors20.default.bold(version3)} for ${import_picocolors20.default.bold(kitName)}`;
+    return `${import_picocolors18.default.green("✓")} Selected ${import_picocolors18.default.bold(version3)} for ${import_picocolors18.default.bold(kitName)}`;
   }
 }
 
@@ -64286,7 +63837,7 @@ async function handleNoReleases(kit, allowManualEntry) {
 This could be due to:
 • No releases published yet
 • Network connectivity issues
-• Repository access permissions`, import_picocolors21.default.yellow("No Releases Available"));
+• Repository access permissions`, import_picocolors19.default.yellow("No Releases Available"));
   if (!allowManualEntry) {
     throw new Error(`No releases available for ${kit.name}`);
   }
@@ -64346,34 +63897,34 @@ async function createVersionPrompt(kit, choices, _defaultIndex, allowManualEntry
   if (latestStable) {
     clackChoices.push({
       value: latestStable.tag_name,
-      label: `${import_picocolors21.default.bold(import_picocolors21.default.green("Latest Stable"))} (${latestStable.displayVersion})`,
+      label: `${import_picocolors19.default.bold(import_picocolors19.default.green("Latest Stable"))} (${latestStable.displayVersion})`,
       hint: "recommended"
     });
   }
   if (allowManualEntry) {
     clackChoices.push({
       value: "manual-entry",
-      label: import_picocolors21.default.cyan("↳ Enter Version Manually"),
+      label: import_picocolors19.default.cyan("↳ Enter Version Manually"),
       hint: "for older versions"
     });
   }
   clackChoices.push({
     value: "cancel",
-    label: import_picocolors21.default.red("✕ Cancel")
+    label: import_picocolors19.default.red("✕ Cancel")
   });
   const versionChoices = choices.filter((choice) => choice.value !== "separator" && choice.value !== "cancel");
   for (const choice of versionChoices) {
     const isCurrentlyInstalled = currentVersion && (choice.value === currentVersion || choice.value === `v${currentVersion}`);
-    const installedMarker = isCurrentlyInstalled ? import_picocolors21.default.cyan(" (installed)") : "";
+    const installedMarker = isCurrentlyInstalled ? import_picocolors19.default.cyan(" (installed)") : "";
     clackChoices.push({
       value: choice.value,
       label: `${choice.label}${installedMarker}`,
       hint: choice.hint
     });
   }
-  const currentVersionHint = currentVersion ? import_picocolors21.default.dim(` (current: ${currentVersion})`) : "";
+  const currentVersionHint = currentVersion ? import_picocolors19.default.dim(` (current: ${currentVersion})`) : "";
   const selected = await ie({
-    message: `Select version for ${import_picocolors21.default.bold(kit.name)}${currentVersionHint}:`,
+    message: `Select version for ${import_picocolors19.default.bold(kit.name)}${currentVersionHint}:`,
     options: clackChoices,
     initialValue: latestStable?.tag_name
   });
@@ -64398,15 +63949,15 @@ async function createVersionPrompt(kit, choices, _defaultIndex, allowManualEntry
 async function handleSelectionError(error, kit, allowManualEntry, retryCallback) {
   logger.error(`Version selection error: ${error.message}`);
   if (error.message.includes("401") || error.message.includes("403")) {
-    le(VersionDisplayFormatter.formatError("Authentication failed", "Please check your GitHub token with: sk auth"), import_picocolors21.default.red("Authentication Error"));
+    le(VersionDisplayFormatter.formatError("Authentication failed", "Please check your GitHub token with: sk auth"), import_picocolors19.default.red("Authentication Error"));
   } else if (error.message.includes("404")) {
-    le(VersionDisplayFormatter.formatError("Repository access denied", "Make sure you have access to the repository"), import_picocolors21.default.red("Access Error"));
+    le(VersionDisplayFormatter.formatError("Repository access denied", "Make sure you have access to the repository"), import_picocolors19.default.red("Access Error"));
   } else if (error.message.includes("rate limit") || error.message.includes("403")) {
-    le(VersionDisplayFormatter.formatError("GitHub API rate limit exceeded", "Please wait a moment and try again"), import_picocolors21.default.yellow("Rate Limited"));
+    le(VersionDisplayFormatter.formatError("GitHub API rate limit exceeded", "Please wait a moment and try again"), import_picocolors19.default.yellow("Rate Limited"));
   } else if (error.message.includes("network") || error.message.includes("ENOTFOUND")) {
-    le(VersionDisplayFormatter.formatError("Network connection failed", "Please check your internet connection"), import_picocolors21.default.yellow("Network Error"));
+    le(VersionDisplayFormatter.formatError("Network connection failed", "Please check your internet connection"), import_picocolors19.default.yellow("Network Error"));
   } else {
-    le(VersionDisplayFormatter.formatError(error.message || "Unknown error occurred", "Please try again or contact support"), import_picocolors21.default.red("Error"));
+    le(VersionDisplayFormatter.formatError(error.message || "Unknown error occurred", "Please try again or contact support"), import_picocolors19.default.red("Error"));
   }
   if (isNonInteractive()) {
     logger.warning("Non-interactive mode: version selection failed, cannot retry");
@@ -64468,7 +64019,7 @@ class VersionSelector {
     } = options2;
     try {
       const loadingSpinner = de();
-      loadingSpinner.start(`Fetching versions for ${import_picocolors22.default.bold(kit.name)}...`);
+      loadingSpinner.start(`Fetching versions for ${import_picocolors20.default.bold(kit.name)}...`);
       let releases;
       if (useGh) {
         releases = await this.githubClient.listReleasesWithCache(kit, {
@@ -64730,6 +64281,9 @@ class PromptsManager {
   async selectKit(defaultKit, accessibleKits) {
     return selectKit(defaultKit, accessibleKits);
   }
+  async selectKits(accessibleKits, defaults2) {
+    return selectKits(accessibleKits, defaults2);
+  }
   async selectVersion(versions, defaultVersion) {
     return selectVersion(versions, defaultVersion);
   }
@@ -64805,6 +64359,9 @@ class PromptsManager {
   async promptSkillsInstallation() {
     return promptSkillsInstallation();
   }
+  async promptAgentSelection(supported) {
+    return promptAgentSelection(supported);
+  }
   showPackageInstallationResults(results) {
     const successfulInstalls = [];
     const failedInstalls = [];
@@ -64868,6 +64425,8 @@ class PromptsManager {
 
 // src/commands/init/init-command.ts
 init_logger();
+init_path_resolver();
+init_types2();
 
 // src/commands/init/context-factory.ts
 function createInitContext(rawOptions, prompts) {
@@ -64959,12 +64518,12 @@ import * as path8 from "node:path";
 // src/domains/github/auth-prompt.ts
 init_dist2();
 init_github_auth();
-var import_picocolors23 = __toESM(require_picocolors(), 1);
+var import_picocolors21 = __toESM(require_picocolors(), 1);
 async function promptForAuth() {
   const hasGit = GitCloneManager.isGitInstalled();
   const hasSshKeys = hasGit && GitCloneManager.hasSshKeys();
   const hasGhCli = AuthManager.isGhCliInstalled();
-  oe(import_picocolors23.default.yellow("No GitHub authentication found"));
+  oe(import_picocolors21.default.yellow("No GitHub authentication found"));
   const options2 = [];
   if (hasGit) {
     const hint = hasSshKeys ? "SSH keys detected" : "Will use HTTPS";
@@ -65017,7 +64576,7 @@ async function promptForAuth() {
       return { method: "cancel" };
     }
     if (typeof token === "string" && token.startsWith("github_pat_")) {
-      le(import_picocolors23.default.yellow(`⚠️  Fine-grained PATs cannot access repos where you're a collaborator.
+      le(import_picocolors21.default.yellow(`⚠️  Fine-grained PATs cannot access repos where you're a collaborator.
 ` + "   If you encounter access issues, use a Classic PAT instead."));
     }
     return { method: "token", token };
@@ -65032,9 +64591,9 @@ init_github_client();
 // src/domains/installation/download-manager.ts
 init_environment();
 init_logger();
-import { mkdir as mkdir27, stat as stat11 } from "node:fs/promises";
+import { mkdir as mkdir26, stat as stat10 } from "node:fs/promises";
 import { tmpdir as tmpdir3 } from "node:os";
-import { join as join93 } from "node:path";
+import { join as join91 } from "node:path";
 
 // src/shared/temp-cleanup.ts
 init_logger();
@@ -65052,13 +64611,13 @@ var import_ignore3 = __toESM(require_ignore(), 1);
 init_logger();
 init_output_manager();
 import { createWriteStream as createWriteStream2, rmSync as rmSync3 } from "node:fs";
-import { mkdir as mkdir23 } from "node:fs/promises";
-import { join as join88 } from "node:path";
+import { mkdir as mkdir22 } from "node:fs/promises";
+import { join as join86 } from "node:path";
 
 // src/shared/progress-bar.ts
 init_output_manager();
 init_terminal_utils();
-var import_picocolors24 = __toESM(require_picocolors(), 1);
+var import_picocolors22 = __toESM(require_picocolors(), 1);
 var BAR_CHARS = {
   unicode: { filled: "█", empty: "░" },
   ascii: { filled: "=", empty: "-" }
@@ -65116,7 +64675,7 @@ class ProgressBar {
     this.clearLine();
     if (message) {
       const symbols = output.getSymbols();
-      console.log(`${import_picocolors24.default.green(symbols.success)} ${message}`);
+      console.log(`${import_picocolors22.default.green(symbols.success)} ${message}`);
     }
   }
   clearLine() {
@@ -65218,13 +64777,13 @@ init_types2();
 // src/domains/installation/utils/path-security.ts
 init_types2();
 import { lstatSync as lstatSync3, realpathSync as realpathSync2 } from "node:fs";
-import { relative as relative15, resolve as resolve17 } from "node:path";
+import { relative as relative14, resolve as resolve17 } from "node:path";
 var MAX_EXTRACTION_SIZE = 500 * 1024 * 1024;
 function isPathSafe(basePath, targetPath) {
   const resolvedBase = resolve17(basePath);
   try {
-    const stat9 = lstatSync3(targetPath);
-    if (stat9.isSymbolicLink()) {
+    const stat8 = lstatSync3(targetPath);
+    if (stat8.isSymbolicLink()) {
       const realTarget = realpathSync2(targetPath);
       if (!realTarget.startsWith(resolvedBase)) {
         return false;
@@ -65232,7 +64791,7 @@ function isPathSafe(basePath, targetPath) {
     }
   } catch {}
   const resolvedTarget = resolve17(targetPath);
-  const relativePath = relative15(resolvedBase, resolvedTarget);
+  const relativePath = relative14(resolvedBase, resolvedTarget);
   return !relativePath.startsWith("..") && !relativePath.startsWith("/") && resolvedTarget.startsWith(resolvedBase);
 }
 
@@ -65263,8 +64822,8 @@ var MAX_DOWNLOAD_SIZE = 500 * 1024 * 1024;
 class FileDownloader {
   async downloadAsset(asset, destDir) {
     try {
-      const destPath = join88(destDir, asset.name);
-      await mkdir23(destDir, { recursive: true });
+      const destPath = join86(destDir, asset.name);
+      await mkdir22(destDir, { recursive: true });
       output.info(`Downloading ${asset.name} (${formatBytes(asset.size)})...`);
       logger.verbose("Download details", {
         url: asset.browser_download_url,
@@ -65348,8 +64907,8 @@ class FileDownloader {
   }
   async downloadFile(params) {
     const { url, name, size, destDir, token } = params;
-    const destPath = join88(destDir, name);
-    await mkdir23(destDir, { recursive: true });
+    const destPath = join86(destDir, name);
+    await mkdir22(destDir, { recursive: true });
     output.info(`Downloading ${name}${size ? ` (${formatBytes(size)})` : ""}...`);
     const headers = {};
     const isTarballUrl = /\/(tarball|zipball)\//.test(url);
@@ -65451,7 +65010,7 @@ init_logger();
 init_types2();
 import { constants as constants3 } from "node:fs";
 import { access as access3, readdir as readdir25 } from "node:fs/promises";
-import { join as join89 } from "node:path";
+import { join as join87 } from "node:path";
 async function validateExtraction(extractDir) {
   try {
     const entries = await readdir25(extractDir, { encoding: "utf8" });
@@ -65463,7 +65022,7 @@ async function validateExtraction(extractDir) {
     const missingPaths = [];
     for (const path8 of criticalPaths) {
       try {
-        await access3(join89(extractDir, path8), constants3.F_OK);
+        await access3(join87(extractDir, path8), constants3.F_OK);
         logger.debug(`Found: ${path8}`);
       } catch {
         logger.warning(`Expected path not found: ${path8}`);
@@ -65484,8 +65043,8 @@ async function validateExtraction(extractDir) {
 
 // src/domains/installation/extraction/tar-extractor.ts
 init_logger();
-import { copyFile as copyFile5, mkdir as mkdir25, readdir as readdir27, rm as rm9, stat as stat9 } from "node:fs/promises";
-import { join as join91 } from "node:path";
+import { copyFile as copyFile5, mkdir as mkdir24, readdir as readdir27, rm as rm9, stat as stat8 } from "node:fs/promises";
+import { join as join89 } from "node:path";
 
 // node_modules/tar/dist/esm/index.min.js
 import Kr from "events";
@@ -68697,8 +68256,8 @@ function decodeFilePath(path8) {
 // src/domains/installation/utils/file-utils.ts
 init_logger();
 init_types2();
-import { copyFile as copyFile4, lstat as lstat7, mkdir as mkdir24, readdir as readdir26 } from "node:fs/promises";
-import { join as join90, relative as relative16 } from "node:path";
+import { copyFile as copyFile4, lstat as lstat6, mkdir as mkdir23, readdir as readdir26 } from "node:fs/promises";
+import { join as join88, relative as relative15 } from "node:path";
 async function withRetry2(fn2, retries = 3) {
   for (let i = 0;i < retries; i++) {
     try {
@@ -68717,12 +68276,12 @@ var isRetryable2 = (e2) => {
 };
 var delay2 = (ms2) => new Promise((r2) => setTimeout(r2, ms2));
 async function moveDirectoryContents(sourceDir, destDir, shouldExclude, sizeTracker) {
-  await mkdir24(destDir, { recursive: true });
+  await mkdir23(destDir, { recursive: true });
   const entries = await readdir26(sourceDir, { encoding: "utf8" });
   for (const entry of entries) {
-    const sourcePath = join90(sourceDir, entry);
-    const destPath = join90(destDir, entry);
-    const relativePath = relative16(sourceDir, sourcePath);
+    const sourcePath = join88(sourceDir, entry);
+    const destPath = join88(destDir, entry);
+    const relativePath = relative15(sourceDir, sourcePath);
     if (!isPathSafe(destDir, destPath)) {
       logger.warning(`Skipping unsafe path: ${relativePath}`);
       throw new ExtractionError(`Path traversal attempt detected: ${relativePath}`);
@@ -68731,7 +68290,7 @@ async function moveDirectoryContents(sourceDir, destDir, shouldExclude, sizeTrac
       logger.debug(`Excluding: ${relativePath}`);
       continue;
     }
-    const entryStat = await lstat7(sourcePath);
+    const entryStat = await lstat6(sourcePath);
     if (entryStat.isDirectory()) {
       await copyDirectory(sourcePath, destPath, shouldExclude, sizeTracker);
     } else if (entryStat.isFile()) {
@@ -68745,12 +68304,12 @@ async function moveDirectoryContents(sourceDir, destDir, shouldExclude, sizeTrac
   }
 }
 async function copyDirectory(sourceDir, destDir, shouldExclude, sizeTracker) {
-  await mkdir24(destDir, { recursive: true });
+  await mkdir23(destDir, { recursive: true });
   const entries = await readdir26(sourceDir, { encoding: "utf8" });
   for (const entry of entries) {
-    const sourcePath = join90(sourceDir, entry);
-    const destPath = join90(destDir, entry);
-    const relativePath = relative16(sourceDir, sourcePath);
+    const sourcePath = join88(sourceDir, entry);
+    const destPath = join88(destDir, entry);
+    const relativePath = relative15(sourceDir, sourcePath);
     if (!isPathSafe(destDir, destPath)) {
       logger.warning(`Skipping unsafe path: ${relativePath}`);
       throw new ExtractionError(`Path traversal attempt detected: ${relativePath}`);
@@ -68759,7 +68318,7 @@ async function copyDirectory(sourceDir, destDir, shouldExclude, sizeTracker) {
       logger.debug(`Excluding: ${relativePath}`);
       continue;
     }
-    const entryStat = await lstat7(sourcePath);
+    const entryStat = await lstat6(sourcePath);
     if (entryStat.isDirectory()) {
       await copyDirectory(sourcePath, destPath, shouldExclude, sizeTracker);
     } else if (entryStat.isFile()) {
@@ -68777,7 +68336,7 @@ async function copyDirectory(sourceDir, destDir, shouldExclude, sizeTracker) {
 class TarExtractor {
   async extract(archivePath, destDir, shouldExclude, sizeTracker) {
     const tempExtractDir = `${destDir}-temp`;
-    await mkdir25(tempExtractDir, { recursive: true });
+    await mkdir24(tempExtractDir, { recursive: true });
     try {
       await co({
         file: archivePath,
@@ -68804,8 +68363,8 @@ class TarExtractor {
       logger.debug(`Root entries: ${entries.join(", ")}`);
       if (entries.length === 1) {
         const rootEntry = entries[0];
-        const rootPath = join91(tempExtractDir, rootEntry);
-        const rootStat = await stat9(rootPath);
+        const rootPath = join89(tempExtractDir, rootEntry);
+        const rootStat = await stat8(rootPath);
         if (rootStat.isDirectory()) {
           const rootContents = await readdir27(rootPath, { encoding: "utf8" });
           logger.debug(`Root directory '${rootEntry}' contains: ${rootContents.join(", ")}`);
@@ -68819,8 +68378,8 @@ class TarExtractor {
             await moveDirectoryContents(tempExtractDir, destDir, shouldExclude, sizeTracker);
           }
         } else {
-          await mkdir25(destDir, { recursive: true });
-          await copyFile5(rootPath, join91(destDir, rootEntry));
+          await mkdir24(destDir, { recursive: true });
+          await copyFile5(rootPath, join89(destDir, rootEntry));
         }
       } else {
         logger.debug("Multiple root entries - moving all");
@@ -68840,14 +68399,14 @@ class TarExtractor {
 // src/domains/installation/extraction/zip-extractor.ts
 init_logger();
 import { createWriteStream as createWriteStream3 } from "node:fs";
-import { chmod as chmod3, copyFile as copyFile6, mkdir as mkdir26, readdir as readdir28, rm as rm10, stat as stat10 } from "node:fs/promises";
-import { dirname as dirname23, join as join92, resolve as resolve18 } from "node:path";
+import { chmod as chmod3, copyFile as copyFile6, mkdir as mkdir25, readdir as readdir28, rm as rm10, stat as stat9 } from "node:fs/promises";
+import { dirname as dirname23, join as join90, resolve as resolve18 } from "node:path";
 import { pipeline } from "node:stream/promises";
 import yauzl from "yauzl-promise";
 class ZipExtractor {
   async extract(archivePath, destDir, shouldExclude, sizeTracker) {
     const tempExtractDir = `${destDir}-temp`;
-    await mkdir26(tempExtractDir, { recursive: true });
+    await mkdir25(tempExtractDir, { recursive: true });
     try {
       await this.extractToDir(archivePath, tempExtractDir);
       logger.debug(`Extracted ZIP to temp: ${tempExtractDir}`);
@@ -68855,8 +68414,8 @@ class ZipExtractor {
       logger.debug(`Root entries: ${entries.join(", ")}`);
       if (entries.length === 1) {
         const rootEntry = entries[0];
-        const rootPath = join92(tempExtractDir, rootEntry);
-        const rootStat = await stat10(rootPath);
+        const rootPath = join90(tempExtractDir, rootEntry);
+        const rootStat = await stat9(rootPath);
         if (rootStat.isDirectory()) {
           const rootContents = await readdir28(rootPath, { encoding: "utf8" });
           logger.debug(`Root directory '${rootEntry}' contains: ${rootContents.join(", ")}`);
@@ -68870,8 +68429,8 @@ class ZipExtractor {
             await moveDirectoryContents(tempExtractDir, destDir, shouldExclude, sizeTracker);
           }
         } else {
-          await mkdir26(destDir, { recursive: true });
-          await copyFile6(rootPath, join92(destDir, rootEntry));
+          await mkdir25(destDir, { recursive: true });
+          await copyFile6(rootPath, join90(destDir, rootEntry));
         }
       } else {
         logger.debug("Multiple root entries - moving all");
@@ -68899,10 +68458,10 @@ class ZipExtractor {
           throw new Error(`Unsafe zip entry path (zip-slip): ${name}`);
         }
         if (name.endsWith("/")) {
-          await mkdir26(outPath, { recursive: true });
+          await mkdir25(outPath, { recursive: true });
           continue;
         }
-        await mkdir26(dirname23(outPath), { recursive: true });
+        await mkdir25(dirname23(outPath), { recursive: true });
         const readStream = await entry.openReadStream();
         await pipeline(readStream, createWriteStream3(outPath));
         const unixMode = entry.externalFileAttributes >>> 16 & 511;
@@ -68961,7 +68520,7 @@ class DownloadManager {
     return this.fileDownloader.downloadFile(params);
   }
   async extractArchive(archivePath, destDir, archiveType) {
-    const archiveStats = await stat11(archivePath);
+    const archiveStats = await stat10(archivePath);
     if (archiveStats.size > MAX_ARCHIVE_SIZE) {
       throw new ExtractionError(`Archive exceeds ${formatBytes(MAX_ARCHIVE_SIZE)} limit: ${formatBytes(archiveStats.size)}`);
     }
@@ -68975,7 +68534,7 @@ class DownloadManager {
     try {
       this.sizeTracker.reset();
       const detectedType = archiveType || detectArchiveType(archivePath);
-      await mkdir27(destDir, { recursive: true });
+      await mkdir26(destDir, { recursive: true });
       if (detectedType === "tar.gz") {
         await this.tarExtractor.extract(archivePath, destDir, this.shouldExclude, this.sizeTracker);
       } else if (detectedType === "zip") {
@@ -69000,9 +68559,9 @@ class DownloadManager {
   async createTempDir() {
     const timestamp = Date.now();
     const counter = DownloadManager.tempDirCounter++;
-    const primaryTempDir = join93(tmpdir3(), `takumi-${timestamp}-${counter}`);
+    const primaryTempDir = join91(tmpdir3(), `takumi-${timestamp}-${counter}`);
     try {
-      await mkdir27(primaryTempDir, { recursive: true });
+      await mkdir26(primaryTempDir, { recursive: true });
       logger.debug(`Created temp directory: ${primaryTempDir}`);
       registerTempDir(primaryTempDir);
       return primaryTempDir;
@@ -69017,9 +68576,9 @@ Solutions:
   2. Set HOME environment variable
   3. Try running from a different directory`);
       }
-      const fallbackTempDir = join93(homeDir, ".sunagentkit", "tmp", `takumi-${timestamp}-${counter}`);
+      const fallbackTempDir = join91(homeDir, ".sunagentkit", "tmp", `takumi-${timestamp}-${counter}`);
       try {
-        await mkdir27(fallbackTempDir, { recursive: true });
+        await mkdir26(fallbackTempDir, { recursive: true });
         logger.debug(`Created temp directory (fallback): ${fallbackTempDir}`);
         logger.warning(`Using fallback temp directory: ${fallbackTempDir}
   (OS temp directory was not accessible)`);
@@ -69060,8 +68619,8 @@ function buildReleaseAllowlist(layout) {
 async function ensureLayoutSourceDir(projectRoot, layout, strict) {
   const sourceDir = path8.join(projectRoot, layout.sourceDir);
   try {
-    const stat12 = await fs11.promises.stat(sourceDir);
-    if (!stat12.isDirectory()) {
+    const stat11 = await fs11.promises.stat(sourceDir);
+    if (!stat11.isDirectory()) {
       throw new Error(`Expected source directory "${layout.sourceDir}" exists but is not a directory.`);
     }
     return sourceDir;
@@ -69302,8 +68861,8 @@ async function useLocalKitPath(kitPath, isMonorepo) {
   output.section("Using local kit");
   const absolutePath = path8.resolve(kitPath);
   try {
-    const stat12 = await fs11.promises.stat(absolutePath);
-    if (!stat12.isDirectory()) {
+    const stat11 = await fs11.promises.stat(absolutePath);
+    if (!stat11.isDirectory()) {
       throw new Error(`--kit-path must point to a directory, not a file.
 
 Provided path: ${absolutePath}
@@ -69341,8 +68900,8 @@ Please verify the path exists and is accessible.`);
   }
   const claudeDir = path8.join(absolutePath, DEFAULT_KIT_LAYOUT.runtimeDir);
   try {
-    const stat12 = await fs11.promises.stat(claudeDir);
-    if (!stat12.isDirectory()) {
+    const stat11 = await fs11.promises.stat(claudeDir);
+    if (!stat11.isDirectory()) {
       logger.warning(`Warning: ${claudeDir} exists but is not a directory.
 This may not be a valid Takumi installation.`);
     }
@@ -69376,15 +68935,15 @@ async function extractLocalArchive(archivePath, exclude) {
   const absolutePath = path8.resolve(archivePath);
   validateArchiveFormat(absolutePath);
   try {
-    const stat12 = await fs11.promises.stat(absolutePath);
-    if (!stat12.isFile()) {
+    const stat11 = await fs11.promises.stat(absolutePath);
+    if (!stat11.isFile()) {
       throw new Error(`--archive must point to a file, not a directory.
 
 Provided path: ${absolutePath}
 
 If you meant to use an extracted kit directory, use --kit-path instead.`);
     }
-    if (stat12.size === 0) {
+    if (stat11.size === 0) {
       throw new Error(`Archive file is empty: ${absolutePath}
 
 The file exists but contains no data. Please verify the archive is not corrupted.`);
@@ -69545,8 +69104,28 @@ async function handleDownload(ctx) {
 // src/commands/init/phases/options-resolver.ts
 init_logger();
 init_types2();
+function parseKitFlag(raw) {
+  const tokens = raw.split(",").map((s3) => s3.trim()).filter((s3) => s3.length > 0);
+  if (tokens.length === 0)
+    return null;
+  if (tokens.length === 1 && tokens[0] === "all") {
+    return Object.keys(AVAILABLE_KITS);
+  }
+  const seen = new Set;
+  const out = [];
+  for (const tok of tokens) {
+    if (!isValidKitType(tok))
+      return null;
+    if (!seen.has(tok)) {
+      seen.add(tok);
+      out.push(tok);
+    }
+  }
+  return out;
+}
 async function resolveOptions(ctx) {
   const explicitDir = ctx.rawOptions.dir !== undefined;
+  const explicitAgents = Array.isArray(ctx.rawOptions.agents) && ctx.rawOptions.agents.length > 0;
   const parsed = UpdateCommandOptionsSchema.parse(ctx.rawOptions);
   const validOptions = {
     kit: parsed.kit,
@@ -69589,8 +69168,6 @@ async function resolveOptions(ctx) {
 ` + "For other agents, run init without --sync to perform a fresh install.");
     }
     validOptions.agents = Array.from(new Set(validOptions.agents));
-  } else {
-    validOptions.agents = ["claude-code"];
   }
   ConfigManager.setGlobalFlag(validOptions.global);
   if (validOptions.global) {
@@ -69635,10 +69212,52 @@ Example: takumi init --use-git --release v2.1.0`);
 Choose one approach.`);
   }
   const isNonInteractive2 = validOptions.yes || !process.stdin.isTTY || process.env.CI === "true" || process.env.NON_INTERACTIVE === "true";
+  if (validOptions.kit) {
+    const parsed2 = parseKitFlag(validOptions.kit);
+    if (!parsed2 || parsed2.length === 0) {
+      throw new Error(`Invalid --kit value: "${validOptions.kit}".
+Valid kits: ${Object.keys(AVAILABLE_KITS).join(", ")}`);
+    }
+    if (!parsed2.includes(BASE_KIT)) {
+      if (isNonInteractive2) {
+        throw new Error(`The "${BASE_KIT}" kit is required when installing additional kits.
+Re-run with explicit base kit, e.g. --kit ${BASE_KIT} --kit ${parsed2.join(" --kit ")}`);
+      }
+      logger.info(`"${BASE_KIT}" is the required base kit — adding it automatically.`);
+      parsed2.unshift(BASE_KIT);
+    } else {
+      const idx = parsed2.indexOf(BASE_KIT);
+      if (idx > 0) {
+        parsed2.splice(idx, 1);
+        parsed2.unshift(BASE_KIT);
+      }
+    }
+    validOptions.selectedKits = parsed2;
+  }
   if (validOptions.yes) {
     logger.info("Running in non-interactive mode (--yes flag)");
   }
   const initialInstallSkills = validOptions.installSkills ? true : undefined;
+  if (!explicitAgents) {
+    if (isNonInteractive2) {
+      validOptions.agents = ["claude-code"];
+    } else {
+      const supported = listSupportedProviders();
+      const selected = await ctx.prompts.promptAgentSelection(supported);
+      if (selected === null) {
+        logger.warning("Agent selection cancelled");
+        return {
+          ...ctx,
+          options: validOptions,
+          explicitDir,
+          isNonInteractive: isNonInteractive2,
+          installSkills: initialInstallSkills,
+          cancelled: true
+        };
+      }
+      validOptions.agents = selected;
+    }
+  }
   return {
     ...ctx,
     options: validOptions,
@@ -69648,8 +69267,8 @@ Choose one approach.`);
   };
 }
 // src/commands/init/phases/selection-handler.ts
-import { mkdir as mkdir28 } from "node:fs/promises";
-import { join as join97, resolve as resolve22 } from "node:path";
+import { mkdir as mkdir27 } from "node:fs/promises";
+import { join as join95, resolve as resolve22 } from "node:path";
 
 // src/commands/shared/agent-selector.ts
 function selectAgents(opts = {}) {
@@ -69730,13 +69349,13 @@ async function runPreflightChecks() {
     errorLines: []
   };
   try {
-    const { stdout: stdout2 } = await execAsync7("gh --version", { timeout: GH_COMMAND_TIMEOUT_MS });
-    const match2 = stdout2.match(/(\d+\.\d+\.\d+)/);
+    const { stdout } = await execAsync7("gh --version", { timeout: GH_COMMAND_TIMEOUT_MS });
+    const match2 = stdout.match(/(\d+\.\d+\.\d+)/);
     if (!match2) {
-      logger.debug(`GitHub CLI version not detected from output: ${stdout2.trim()}`);
+      logger.debug(`GitHub CLI version not detected from output: ${stdout.trim()}`);
       result.ghInstalled = true;
       result.errorLines.push("✗ GitHub CLI installed but version could not be detected");
-      result.errorLines.push(`  Output: ${stdout2.trim().slice(0, 100)}`);
+      result.errorLines.push(`  Output: ${stdout.trim().slice(0, 100)}`);
       result.errorLines.push("  Try running: gh --version");
       return result;
     }
@@ -69794,7 +69413,7 @@ async function runPreflightChecks() {
 
 // src/domains/installation/fresh-installer.ts
 import { existsSync as existsSync45, readdirSync as readdirSync4, rmSync as rmSync4, rmdirSync as rmdirSync2, unlinkSync as unlinkSync4 } from "node:fs";
-import { dirname as dirname26, join as join96, resolve as resolve21 } from "node:path";
+import { dirname as dirname26, join as join94, resolve as resolve21 } from "node:path";
 init_logger();
 var import_fs_extra31 = __toESM(require_lib(), 1);
 var TAKUMI_SUBDIRECTORIES = ["commands", "agents", "skills", "rules", "hooks"];
@@ -69866,7 +69485,7 @@ async function removeFilesByOwnership(claudeDir, analysis, includeModified) {
   const filesToRemove = includeModified ? [...analysis.ckFiles, ...analysis.ckModifiedFiles] : analysis.ckFiles;
   const filesToPreserve = includeModified ? analysis.userFiles : [...analysis.ckModifiedFiles, ...analysis.userFiles];
   for (const file of filesToRemove) {
-    const fullPath = join96(claudeDir, file.path);
+    const fullPath = join94(claudeDir, file.path);
     try {
       if (existsSync45(fullPath)) {
         unlinkSync4(fullPath);
@@ -69891,7 +69510,7 @@ async function removeFilesByOwnership(claudeDir, analysis, includeModified) {
   };
 }
 async function updateMetadataAfterFresh(claudeDir, removedFiles) {
-  const metadataPath = join96(claudeDir, "metadata.json");
+  const metadataPath = join94(claudeDir, "metadata.json");
   if (!await import_fs_extra31.pathExists(metadataPath)) {
     return;
   }
@@ -69934,7 +69553,7 @@ async function removeSubdirectoriesFallback(claudeDir) {
   const removedFiles = [];
   let removedDirCount = 0;
   for (const subdir of TAKUMI_SUBDIRECTORIES) {
-    const subdirPath = join96(claudeDir, subdir);
+    const subdirPath = join94(claudeDir, subdir);
     if (await import_fs_extra31.pathExists(subdirPath)) {
       rmSync4(subdirPath, { recursive: true, force: true });
       removedDirCount++;
@@ -69942,7 +69561,7 @@ async function removeSubdirectoriesFallback(claudeDir) {
       logger.debug(`Removed subdirectory: ${subdir}/`);
     }
   }
-  const metadataPath = join96(claudeDir, "metadata.json");
+  const metadataPath = join94(claudeDir, "metadata.json");
   if (await import_fs_extra31.pathExists(metadataPath)) {
     unlinkSync4(metadataPath);
     removedFiles.push("metadata.json");
@@ -69979,10 +69598,56 @@ async function handleFreshInstallation(claudeDir, prompts) {
     if (result.preservedCount > 0) {
       logger.verbose(`Preserved user files: ${result.preservedFiles.slice(0, 5).join(", ")}${result.preservedFiles.length > 5 ? ` and ${result.preservedFiles.length - 5} more` : ""}`);
     }
-    return true;
-  } catch (error) {
-    spinner.fail("Failed to remove Takumi files");
-    throw new Error(`Failed to remove files: ${error instanceof Error ? error.message : "Unknown error"}`);
+    return true;
+  } catch (error) {
+    spinner.fail("Failed to remove Takumi files");
+    throw new Error(`Failed to remove files: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+
+// src/domains/versioning/checking/version-utils.ts
+var import_compare_versions2 = __toESM(require_umd(), 1);
+function isUpdateCheckDisabled() {
+  return process.env.NO_UPDATE_NOTIFIER === "1" || process.env.NO_UPDATE_NOTIFIER === "true" || !process.stdout.isTTY;
+}
+function normalizeVersion(version3) {
+  return version3.replace(/^v/i, "");
+}
+function isPrereleaseVersion(version3) {
+  if (!version3)
+    return false;
+  return /-(beta|alpha|rc|dev)[.\d]/i.test(normalizeVersion(version3));
+}
+function parseVersionParts(version3) {
+  const normalized = normalizeVersion(version3);
+  const [base, ...prereleaseParts] = normalized.split("-");
+  return {
+    base,
+    prerelease: prereleaseParts.length > 0 ? prereleaseParts.join("-") : null
+  };
+}
+function isPrereleaseOfSameBase(currentVersion, latestVersion) {
+  const current = parseVersionParts(currentVersion);
+  const latest = parseVersionParts(latestVersion);
+  if (!current.prerelease)
+    return false;
+  if (latest.prerelease !== null)
+    return false;
+  return current.base === latest.base;
+}
+function versionsMatch(installed, latest) {
+  return normalizeVersion(installed) === normalizeVersion(latest);
+}
+function isNewerVersion(currentVersion, latestVersion) {
+  try {
+    const current = normalizeVersion(currentVersion);
+    const latest = normalizeVersion(latestVersion);
+    if (isPrereleaseOfSameBase(current, latest)) {
+      return false;
+    }
+    return import_compare_versions2.compareVersions(latest, current) > 0;
+  } catch {
+    return false;
   }
 }
 
@@ -70052,275 +69717,950 @@ async function handleSelection(ctx) {
       return { ...ctx, cancelled: true };
     }
   }
-  let kitType;
-  const kitOption = ctx.options.kit || config.defaults?.kit;
-  if (kitOption) {
+  let selectedKits = ctx.options.selectedKits;
+  if (!selectedKits || selectedKits.length === 0) {
     const allKitTypes = Object.keys(AVAILABLE_KITS);
-    if (kitOption === "all" || kitOption.includes(",")) {
-      const kitsToInstall = accessibleKits ?? allKitTypes;
-      if (kitsToInstall.length === 0) {
-        logger.error("No kits accessible for installation");
+    const kitOption = ctx.options.kit || config.defaults?.kit;
+    if (kitOption) {
+      if (kitOption === "all") {
+        selectedKits = accessibleKits ?? allKitTypes;
+      } else if (!isValidKitType(kitOption)) {
+        logger.error(`Invalid kit: ${kitOption}`);
+        logger.info(`Valid kits: ${allKitTypes.join(", ")}`);
+        return { ...ctx, cancelled: true };
+      } else {
+        selectedKits = [kitOption];
+      }
+    }
+    if (!selectedKits || selectedKits.length === 0) {
+      if (ctx.isNonInteractive) {
+        if (!accessibleKits || accessibleKits.length === 0) {
+          throw new Error("Kit must be specified via --kit flag in non-interactive mode (no accessible kits detected)");
+        }
+        selectedKits = [accessibleKits[0]];
+        logger.info(`Auto-selected: ${AVAILABLE_KITS[selectedKits[0]].name}`);
+      } else if (accessibleKits?.length === 1) {
+        selectedKits = [accessibleKits[0]];
+        logger.info(`Using ${AVAILABLE_KITS[selectedKits[0]].name} (only accessible kit)`);
+      } else {
+        selectedKits = await ctx.prompts.selectKits(accessibleKits);
+      }
+    }
+  }
+  if (accessibleKits) {
+    const inaccessible = selectedKits.filter((k3) => !accessibleKits.includes(k3));
+    if (inaccessible.length > 0) {
+      logger.error(`No access to: ${inaccessible.map((k3) => AVAILABLE_KITS[k3].name).join(", ")}`);
+      logger.info("Request access from your team lead or check your GitHub invitation");
+      return { ...ctx, cancelled: true };
+    }
+  }
+  if (selectedKits.includes(BASE_KIT)) {
+    const idx = selectedKits.indexOf(BASE_KIT);
+    if (idx > 0) {
+      selectedKits.splice(idx, 1);
+      selectedKits.unshift(BASE_KIT);
+    }
+  }
+  const kitType = selectedKits[0];
+  const kit = AVAILABLE_KITS[kitType];
+  if (selectedKits.length > 1) {
+    logger.info(`Selected kits: ${selectedKits.map((k3) => AVAILABLE_KITS[k3].name).join(", ")} (installed in order)`);
+  } else {
+    logger.info(`Selected kit: ${kit.name}`);
+  }
+  let targetDir;
+  if (ctx.explicitDir) {
+    targetDir = ctx.options.dir;
+    logger.info(`Using explicit directory: ${targetDir}`);
+  } else if (ctx.options.global) {
+    const targetAgents = selectAgents({ explicit: ctx.options.agents });
+    targetDir = resolveGlobalTargetDir(targetAgents);
+    logger.info(`Using global kit directory: ${targetDir}`);
+  } else {
+    targetDir = config.defaults?.dir || ".";
+    if (!config.defaults?.dir) {
+      if (ctx.isNonInteractive) {
+        logger.info("Using current directory as target");
+      } else {
+        targetDir = await ctx.prompts.getDirectory(targetDir);
+      }
+    }
+  }
+  const resolvedDir = resolve22(targetDir);
+  logger.info(`Target directory: ${resolvedDir}`);
+  if (!ctx.options.global && isLocalSameAsGlobal(resolvedDir)) {
+    logger.warning("You're at HOME directory. Installing here modifies your GLOBAL Takumi.");
+    if (!ctx.isNonInteractive) {
+      const choice = await ctx.prompts.selectScope();
+      if (choice === "cancel") {
+        return { ...ctx, cancelled: true };
+      }
+      if (choice === "global") {
+        logger.info("Proceeding with global installation");
+      }
+      if (choice === "different") {
+        logger.info("Please run 'takumi init' from a project directory instead.");
+        return { ...ctx, cancelled: true };
+      }
+    } else {
+      logger.error("Cannot use local installation at HOME directory.");
+      logger.info("Use -g/--global flag or run from a project directory.");
+      return { ...ctx, cancelled: true };
+    }
+  }
+  if (!await import_fs_extra32.pathExists(resolvedDir)) {
+    if (ctx.options.global) {
+      await mkdir27(resolvedDir, { recursive: true });
+      logger.info(`Created global directory: ${resolvedDir}`);
+    } else {
+      logger.error(`Directory does not exist: ${resolvedDir}`);
+      logger.info('Use "tkm new" to create a new project');
+      return { ...ctx, cancelled: true };
+    }
+  }
+  if (!ctx.options.fresh) {
+    const prefix = PathResolver.getPathPrefix(ctx.options.global);
+    const claudeDir = prefix ? join95(resolvedDir, prefix) : resolvedDir;
+    try {
+      const existingMetadata = await readManifest(claudeDir);
+      if (existingMetadata?.kits) {
+        const existingKitTypes = Object.keys(existingMetadata.kits);
+        const otherKits = existingKitTypes.filter((k3) => k3 !== kitType);
+        if (otherKits.length > 0) {
+          const kitsRecord = existingMetadata.kits;
+          const existingKitsDisplay = otherKits.map((k3) => `${k3}@${kitsRecord[k3]?.version || "unknown"}`).join(", ");
+          if (!ctx.options.yes && !ctx.isNonInteractive) {
+            try {
+              const confirmAdd = await ctx.prompts.confirm(`${existingKitsDisplay} already installed. Add ${kit.name} alongside?`);
+              if (!confirmAdd) {
+                logger.warning("Multi-kit installation cancelled by user");
+                return { ...ctx, cancelled: true };
+              }
+              logger.info(`Adding ${kit.name} alongside existing kit(s)`);
+            } catch {
+              logger.warning("Prompt cancelled or interrupted");
+              return { ...ctx, cancelled: true };
+            }
+          } else {
+            const reason = ctx.options.yes ? "(--yes flag)" : "(non-interactive mode)";
+            logger.info(`Adding ${kit.name} alongside ${existingKitsDisplay} ${reason}`);
+          }
+        }
+      }
+    } catch (error) {
+      logger.debug(`Metadata read skipped: ${error instanceof Error ? error.message : "unknown error"}`);
+    }
+  }
+  if (ctx.options.fresh) {
+    const prefix = PathResolver.getPathPrefix(ctx.options.global);
+    const claudeDir = prefix ? join95(resolvedDir, prefix) : resolvedDir;
+    const canProceed = await handleFreshInstallation(claudeDir, ctx.prompts);
+    if (!canProceed) {
+      return { ...ctx, cancelled: true };
+    }
+  }
+  const isOfflineMode = !!(ctx.options.kitPath || ctx.options.archive);
+  const github = !isOfflineMode && useLegacyGh ? new GitHubClient : null;
+  let selectedVersion = ctx.options.release;
+  if (!selectedVersion && ctx.isNonInteractive && !ctx.options.yes && !isOfflineMode) {
+    throw new Error("Non-interactive mode requires either: --release <tag> OR --yes (uses latest)");
+  }
+  if (!selectedVersion && ctx.options.yes && !isOfflineMode) {
+    logger.info("Using latest stable version (--yes flag)");
+  }
+  if (!selectedVersion && !ctx.isNonInteractive && !isOfflineMode) {
+    logger.info("Fetching available versions...");
+    let currentVersion = null;
+    try {
+      const prefix = PathResolver.getPathPrefix(ctx.options.global);
+      const claudeDir = prefix ? join95(resolvedDir, prefix) : resolvedDir;
+      const existingMetadata = await readManifest(claudeDir);
+      currentVersion = existingMetadata?.kits?.[kitType]?.version || null;
+      if (currentVersion) {
+        logger.debug(`Current installed version: ${currentVersion}`);
+      }
+    } catch {}
+    try {
+      const versionResult = await ctx.prompts.selectVersionEnhanced({
+        kit,
+        includePrereleases: ctx.options.beta,
+        limit: 10,
+        allowManualEntry: true,
+        forceRefresh: ctx.options.refresh,
+        currentVersion,
+        useGh: useLegacyGh
+      });
+      if (!versionResult) {
+        logger.warning("Version selection cancelled by user");
+        return { ...ctx, cancelled: true };
+      }
+      selectedVersion = versionResult;
+      logger.success(`Selected version: ${selectedVersion}`);
+    } catch (error) {
+      logger.error("Failed to fetch versions, using latest release");
+      logger.debug(`Version selection error: ${error.message}`);
+      selectedVersion = undefined;
+    }
+  }
+  let release;
+  if (isOfflineMode) {
+    release = undefined;
+    logger.verbose("Offline mode - skipping release fetch", {
+      kitPath: ctx.options.kitPath,
+      archive: ctx.options.archive
+    });
+  } else if (ctx.options.useGit && selectedVersion) {
+    release = {
+      id: 0,
+      tag_name: selectedVersion,
+      name: selectedVersion,
+      draft: false,
+      prerelease: selectedVersion.includes("-"),
+      tarball_url: `https://github.com/${kit.owner}/${kit.repo}/archive/refs/tags/${selectedVersion}.tar.gz`,
+      zipball_url: `https://github.com/${kit.owner}/${kit.repo}/archive/refs/tags/${selectedVersion}.zip`,
+      assets: []
+    };
+    logger.verbose("Using git clone mode with tag", { tag: selectedVersion });
+  } else if (selectedVersion && github) {
+    release = await github.getReleaseByTag(kit, selectedVersion);
+  } else if (github) {
+    if (ctx.options.beta) {
+      logger.info("Fetching latest beta release...");
+    } else {
+      logger.info("Fetching latest release...");
+    }
+    release = await github.getLatestRelease(kit, ctx.options.beta);
+    if (release.prerelease) {
+      logger.success(`Found beta: ${release.tag_name}`);
+    } else {
+      logger.success(`Found: ${release.tag_name}`);
+    }
+  } else if (selectedVersion) {
+    const worker = new WorkerSource(getServerUrl(), kitType);
+    const entry = await worker.fetchByTag(selectedVersion);
+    release = releaseEntryToGitHubRelease(entry, kit);
+  } else {
+    if (ctx.options.beta) {
+      logger.info("Fetching latest beta release...");
+    } else {
+      logger.info("Fetching latest release...");
+    }
+    const worker = new WorkerSource(getServerUrl(), kitType);
+    const entry = await worker.fetchLatest(ctx.options.beta);
+    release = releaseEntryToGitHubRelease(entry, kit);
+    if (release.prerelease) {
+      logger.success(`Found beta: ${release.tag_name}`);
+    } else {
+      logger.success(`Found: ${release.tag_name}`);
+    }
+  }
+  if (ctx.options.force && !ctx.options.yes) {
+    logger.info("--force has no effect without --yes (the version-match skip only applies in non-interactive mode)");
+  }
+  const releaseTag = release?.tag_name;
+  if (ctx.options.yes && !ctx.options.fresh && !ctx.options.force && releaseTag && !isOfflineMode) {
+    try {
+      const prefix = PathResolver.getPathPrefix(ctx.options.global);
+      const claudeDir = prefix ? join95(resolvedDir, prefix) : resolvedDir;
+      const existingMetadata = await readManifest(claudeDir);
+      const installedKitVersion = existingMetadata?.kits?.[kitType]?.version;
+      if (installedKitVersion && versionsMatch(installedKitVersion, releaseTag)) {
+        logger.success(`Already at latest version (${kitType}@${installedKitVersion}), skipping reinstall`);
         return { ...ctx, cancelled: true };
       }
-      kitType = kitsToInstall[0];
-      logger.info(`Using kit: ${AVAILABLE_KITS[kitType].name}`);
-    } else {
-      if (!isValidKitType(kitOption)) {
-        logger.error(`Invalid kit: ${kitOption}`);
-        logger.info(`Valid kits: ${allKitTypes.join(", ")}`);
-        return { ...ctx, cancelled: true };
+    } catch (error) {
+      logger.verbose(`Metadata read failed, proceeding with installation: ${error instanceof Error ? error.message : "unknown"}`);
+    }
+  }
+  const releasesByKit = {};
+  if (release)
+    releasesByKit[kitType] = release;
+  const shouldPromptSecondaryVersions = selectedKits.length > 1 && !ctx.isNonInteractive && !ctx.options.yes && !isOfflineMode;
+  if (shouldPromptSecondaryVersions) {
+    for (const secondaryKit of selectedKits) {
+      if (secondaryKit === kitType)
+        continue;
+      const kitConfig = AVAILABLE_KITS[secondaryKit];
+      let currentSecondaryVersion = null;
+      try {
+        const prefix = PathResolver.getPathPrefix(ctx.options.global);
+        const claudeDir = prefix ? join95(resolvedDir, prefix) : resolvedDir;
+        const existingMetadata = await readManifest(claudeDir);
+        currentSecondaryVersion = existingMetadata?.kits?.[secondaryKit]?.version || null;
+      } catch {}
+      let secondaryVersion;
+      try {
+        const versionResult = await ctx.prompts.selectVersionEnhanced({
+          kit: kitConfig,
+          includePrereleases: ctx.options.beta,
+          limit: 10,
+          allowManualEntry: true,
+          forceRefresh: ctx.options.refresh,
+          currentVersion: currentSecondaryVersion,
+          useGh: useLegacyGh
+        });
+        if (!versionResult) {
+          logger.warning(`Version selection cancelled for ${kitConfig.name}`);
+          return { ...ctx, cancelled: true };
+        }
+        secondaryVersion = versionResult;
+        logger.success(`Selected ${kitConfig.name}: ${secondaryVersion}`);
+      } catch (error) {
+        logger.error(`Failed to fetch versions for ${kitConfig.name}, using latest`);
+        logger.debug(`Version selection error: ${error.message}`);
+        secondaryVersion = undefined;
+      }
+      try {
+        let secondaryRelease;
+        if (useLegacyGh) {
+          const ghClient = github ?? new GitHubClient;
+          secondaryRelease = secondaryVersion ? await ghClient.getReleaseByTag(kitConfig, secondaryVersion) : await ghClient.getLatestRelease(kitConfig, ctx.options.beta);
+        } else {
+          const worker = new WorkerSource(getServerUrl(), secondaryKit);
+          const entry = secondaryVersion ? await worker.fetchByTag(secondaryVersion) : await worker.fetchLatest(ctx.options.beta);
+          secondaryRelease = releaseEntryToGitHubRelease(entry, kitConfig);
+        }
+        releasesByKit[secondaryKit] = secondaryRelease;
+      } catch (error) {
+        logger.warning(`Could not pre-fetch release for ${kitConfig.name}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+  return {
+    ...ctx,
+    kit,
+    kitType,
+    selectedKits,
+    resolvedDir,
+    release,
+    selectedVersion,
+    releasesByKit,
+    accessibleKits
+  };
+}
+async function resolveReleaseForKit(ctx, kitType) {
+  const isOfflineMode = !!(ctx.options.kitPath || ctx.options.archive);
+  if (isOfflineMode)
+    return;
+  const kit = AVAILABLE_KITS[kitType];
+  if (ctx.options.useGit) {
+    throw new Error(`--use-git is not supported for multi-kit installs (secondary kit: ${kitType}). Run kits individually.`);
+  }
+  if (ctx.options.useGh) {
+    const github = new GitHubClient;
+    const release = await github.getLatestRelease(kit, ctx.options.beta);
+    return release;
+  }
+  const worker = new WorkerSource(getServerUrl(), kitType);
+  const entry = await worker.fetchLatest(ctx.options.beta);
+  return releaseEntryToGitHubRelease(entry, kit);
+}
+function resolveGlobalTargetDir(targetAgents) {
+  const primary = targetAgents[0];
+  if (primary) {
+    const installer = getInstaller(primary);
+    if (installer) {
+      return installer.globalRoot();
+    }
+  }
+  return getClaudeDir();
+}
+// src/commands/init/phases/sync-handler.ts
+import { copyFile as copyFile7, mkdir as mkdir29, open as open3, readFile as readFile41, rename as rename6, stat as stat12, unlink as unlink13, writeFile as writeFile31 } from "node:fs/promises";
+import { dirname as dirname27, join as join98, resolve as resolve23 } from "node:path";
+
+// src/domains/sync/config-version-checker.ts
+init_auth_client();
+import { mkdir as mkdir28, readFile as readFile39, unlink as unlink12, writeFile as writeFile30 } from "node:fs/promises";
+import { join as join96 } from "node:path";
+init_logger();
+init_path_resolver();
+var CACHE_TTL_HOURS = 24;
+var DEFAULT_CACHE_TTL_MS = CACHE_TTL_HOURS * 60 * 60 * 1000;
+var MIN_CACHE_TTL_MS = 60 * 1000;
+var MAX_CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+function parseCacheTtl() {
+  const envValue = process.env.TAKUMI_SYNC_CACHE_TTL;
+  if (!envValue) {
+    return DEFAULT_CACHE_TTL_MS;
+  }
+  const parsed = Number.parseInt(envValue, 10);
+  if (Number.isNaN(parsed) || parsed < 0) {
+    logger.warning(`Invalid TAKUMI_SYNC_CACHE_TTL value "${envValue}", using default (${CACHE_TTL_HOURS}h)`);
+    return DEFAULT_CACHE_TTL_MS;
+  }
+  const ttlMs = parsed * 1000;
+  if (ttlMs < MIN_CACHE_TTL_MS) {
+    logger.warning(`TAKUMI_SYNC_CACHE_TTL too low (${parsed}s), using minimum (60s)`);
+    return MIN_CACHE_TTL_MS;
+  }
+  if (ttlMs > MAX_CACHE_TTL_MS) {
+    logger.warning(`TAKUMI_SYNC_CACHE_TTL too high (${parsed}s), using maximum (7 days)`);
+    return MAX_CACHE_TTL_MS;
+  }
+  return ttlMs;
+}
+var CACHE_TTL_MS = parseCacheTtl();
+var CACHE_FILENAME = "config-update-cache.json";
+
+class ConfigVersionChecker {
+  static getCacheFilePath(kitType, global3) {
+    const cacheDir = PathResolver.getCacheDir(global3);
+    return join96(cacheDir, `${kitType}-${CACHE_FILENAME}`);
+  }
+  static async loadCache(kitType, global3) {
+    try {
+      const cachePath = ConfigVersionChecker.getCacheFilePath(kitType, global3);
+      const data = await readFile39(cachePath, "utf8");
+      const parsed = JSON.parse(data);
+      if (typeof parsed !== "object" || parsed === null || typeof parsed.lastCheck !== "number" || typeof parsed.latestVersion !== "string" || !parsed.latestVersion || parsed.lastCheck < 0 || parsed.lastCheck > Date.now() + 7 * 24 * 60 * 60 * 1000) {
+        logger.debug("Invalid cache structure, ignoring");
+        return null;
+      }
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  static async saveCache(kitType, global3, cache) {
+    try {
+      const cachePath = ConfigVersionChecker.getCacheFilePath(kitType, global3);
+      const cacheDir = PathResolver.getCacheDir(global3);
+      await mkdir28(cacheDir, { recursive: true });
+      await writeFile30(cachePath, JSON.stringify(cache, null, 2));
+    } catch (error) {
+      logger.debug(`Cache write failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  static async fetchLatestVersion(kitType) {
+    const maxRetries = 3;
+    const baseBackoff = 1000;
+    for (let attempt = 0;attempt < maxRetries; attempt++) {
+      try {
+        const worker = new WorkerSource(getServerUrl(), kitType);
+        const entry = await worker.fetchLatest();
+        const version3 = entry.version.replace(/^v/, "");
+        if (!version3 || version3.length > 256) {
+          logger.debug(`Invalid version format from Worker: ${entry.version}`);
+          return null;
+        }
+        const semverParts = version3.split(/[-+]/);
+        const coreParts = semverParts[0].split(".");
+        if (coreParts.length !== 3 || !coreParts.every((p2) => /^\d+$/.test(p2))) {
+          logger.debug(`Invalid version format from Worker: ${entry.version}`);
+          return null;
+        }
+        return { version: version3 };
+      } catch (error) {
+        if (error instanceof NotLoggedInError) {
+          logger.debug("Skipping update check (not logged in)");
+          return null;
+        }
+        const isLastAttempt = attempt === maxRetries - 1;
+        if (isLastAttempt) {
+          logger.debug(`Version check failed after ${maxRetries} attempts: ${error}`);
+          return null;
+        }
+        const delay3 = baseBackoff * 2 ** attempt;
+        await new Promise((resolve23) => setTimeout(resolve23, delay3));
+      }
+    }
+    return null;
+  }
+  static async checkForUpdates(kitType, currentVersion, global3 = false) {
+    const normalizedCurrent = currentVersion.replace(/^v/, "");
+    const cache = await ConfigVersionChecker.loadCache(kitType, global3);
+    const now = Date.now();
+    if (cache && now - cache.lastCheck < CACHE_TTL_MS) {
+      const hasUpdates = isNewerVersion(normalizedCurrent, cache.latestVersion);
+      return {
+        hasUpdates,
+        currentVersion: normalizedCurrent,
+        latestVersion: cache.latestVersion,
+        fromCache: true
+      };
+    }
+    const result = await ConfigVersionChecker.fetchLatestVersion(kitType);
+    if (result) {
+      await ConfigVersionChecker.saveCache(kitType, global3, {
+        lastCheck: now,
+        latestVersion: result.version
+      });
+      const hasUpdates = isNewerVersion(normalizedCurrent, result.version);
+      return {
+        hasUpdates,
+        currentVersion: normalizedCurrent,
+        latestVersion: result.version,
+        fromCache: false
+      };
+    }
+    if (cache) {
+      const hasUpdates = isNewerVersion(normalizedCurrent, cache.latestVersion);
+      return {
+        hasUpdates,
+        currentVersion: normalizedCurrent,
+        latestVersion: cache.latestVersion,
+        fromCache: true
+      };
+    }
+    return {
+      hasUpdates: false,
+      currentVersion: normalizedCurrent,
+      latestVersion: normalizedCurrent,
+      fromCache: false
+    };
+  }
+  static async clearCache(kitType, global3 = false) {
+    const cachePath = ConfigVersionChecker.getCacheFilePath(kitType, global3);
+    try {
+      await unlink12(cachePath);
+      logger.debug(`Cleared sync cache for ${kitType}`);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+}
+// src/domains/sync/sync-engine.ts
+import { lstat as lstat7, readFile as readFile40, readlink, realpath as realpath3, stat as stat11 } from "node:fs/promises";
+import { isAbsolute as isAbsolute3, join as join97, normalize as normalize8, relative as relative16 } from "node:path";
+init_logger();
+var MAX_SYNC_FILE_SIZE = 10 * 1024 * 1024;
+var MAX_SYMLINK_DEPTH = 20;
+async function validateSymlinkChain(path9, basePath, maxDepth = MAX_SYMLINK_DEPTH) {
+  let current = path9;
+  let depth = 0;
+  while (depth < maxDepth) {
+    try {
+      const stats = await lstat7(current);
+      if (!stats.isSymbolicLink())
+        break;
+      const target = await readlink(current);
+      const resolvedTarget = isAbsolute3(target) ? target : join97(current, "..", target);
+      const normalizedTarget = normalize8(resolvedTarget);
+      const rel = relative16(basePath, normalizedTarget);
+      if (rel.startsWith("..") || isAbsolute3(rel)) {
+        throw new Error(`Symlink chain escapes base directory at depth ${depth}: ${path9}`);
+      }
+      current = normalizedTarget;
+      depth++;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("Symlink chain")) {
+        throw error;
+      }
+      break;
+    }
+  }
+  if (depth >= maxDepth) {
+    throw new Error(`Symlink chain too deep (>${maxDepth}): ${path9}`);
+  }
+}
+async function validateSyncPath(basePath, filePath) {
+  if (!filePath || filePath.trim() === "") {
+    throw new Error("Empty file path not allowed");
+  }
+  if (filePath.includes("\x00")) {
+    throw new Error(`Invalid file path (null byte): ${filePath}`);
+  }
+  if (filePath.length > 1024) {
+    throw new Error(`Path too long: ${filePath.slice(0, 50)}...`);
+  }
+  const normalized = normalize8(filePath);
+  if (isAbsolute3(normalized)) {
+    throw new Error(`Absolute paths not allowed: ${filePath}`);
+  }
+  if (normalized.startsWith("..") || normalized.includes("/../")) {
+    throw new Error(`Path traversal not allowed: ${filePath}`);
+  }
+  const fullPath = join97(basePath, normalized);
+  const rel = relative16(basePath, fullPath);
+  if (rel.startsWith("..") || isAbsolute3(rel)) {
+    throw new Error(`Path escapes base directory: ${filePath}`);
+  }
+  await validateSymlinkChain(fullPath, basePath);
+  try {
+    const resolvedBase = await realpath3(basePath);
+    const resolvedFull = await realpath3(fullPath);
+    const resolvedRel = relative16(resolvedBase, resolvedFull);
+    if (resolvedRel.startsWith("..") || isAbsolute3(resolvedRel)) {
+      throw new Error(`Symlink escapes base directory: ${filePath}`);
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      const parentPath = join97(fullPath, "..");
+      try {
+        const resolvedBase = await realpath3(basePath);
+        const resolvedParent = await realpath3(parentPath);
+        const resolvedRel = relative16(resolvedBase, resolvedParent);
+        if (resolvedRel.startsWith("..") || isAbsolute3(resolvedRel)) {
+          throw new Error(`Parent symlink escapes base directory: ${filePath}`);
+        }
+      } catch (parentError) {
+        if (parentError.code !== "ENOENT") {
+          throw parentError;
+        }
+      }
+    } else {
+      throw error;
+    }
+  }
+  return fullPath;
+}
+
+class SyncEngine {
+  static async createSyncPlan(trackedFiles, claudeDir, upstreamDir) {
+    const plan = { autoUpdate: [], needsReview: [], skipped: [] };
+    for (const file of trackedFiles) {
+      if (file.ownership === "user") {
+        plan.skipped.push(file);
+        continue;
+      }
+      let upstreamPath;
+      try {
+        upstreamPath = await validateSyncPath(upstreamDir, file.path);
+      } catch (error) {
+        logger.warning(`Skipping invalid path: ${file.path}`);
+        plan.skipped.push(file);
+        continue;
+      }
+      try {
+        await stat11(upstreamPath);
+      } catch {
+        plan.skipped.push(file);
+        continue;
+      }
+      let localPath;
+      try {
+        localPath = await validateSyncPath(claudeDir, file.path);
+      } catch (error) {
+        logger.warning(`Skipping invalid local path: ${file.path}`);
+        plan.skipped.push(file);
+        continue;
+      }
+      try {
+        await stat11(localPath);
+      } catch {
+        plan.autoUpdate.push(file);
+        continue;
       }
-      kitType = kitOption;
-      if (accessibleKits && !accessibleKits.includes(kitType)) {
-        logger.error(`No access to ${AVAILABLE_KITS[kitType].name}`);
-        logger.info("Request access from your team lead or check your GitHub invitation");
-        return { ...ctx, cancelled: true };
+      if (file.ownership === "takumi") {
+        plan.autoUpdate.push(file);
+        continue;
+      }
+      const currentChecksum = await OwnershipChecker.calculateChecksum(localPath);
+      const baseChecksum = file.baseChecksum || file.checksum;
+      if (currentChecksum === baseChecksum) {
+        plan.autoUpdate.push(file);
+      } else {
+        plan.needsReview.push(file);
       }
     }
+    return plan;
   }
-  if (!kitType) {
-    if (ctx.isNonInteractive) {
-      if (!accessibleKits || accessibleKits.length === 0) {
-        throw new Error("Kit must be specified via --kit flag in non-interactive mode (no accessible kits detected)");
+  static generateHunks(currentContent, newContent, filename, contextLines = 3) {
+    const patch = structuredPatch(filename, filename, currentContent, newContent, "", "", {
+      context: contextLines
+    });
+    return patch.hunks.map((hunk) => ({
+      oldStart: hunk.oldStart,
+      oldLines: hunk.oldLines,
+      newStart: hunk.newStart,
+      newLines: hunk.newLines,
+      lines: hunk.lines
+    }));
+  }
+  static applyHunks(content, hunks, accepted) {
+    const acceptedHunks = hunks.filter((_4, i) => accepted[i]);
+    if (acceptedHunks.length === 0) {
+      return content;
+    }
+    const patchStr = SyncEngine.buildUnifiedDiff(content, acceptedHunks);
+    const result = applyPatch(content, patchStr);
+    if (result === false) {
+      try {
+        return SyncEngine.applyHunksManually(content, acceptedHunks);
+      } catch (fallbackError) {
+        throw new Error(`Failed to apply ${acceptedHunks.length} hunk(s): patch and manual methods both failed. ` + `Manual error: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`);
       }
-      kitType = accessibleKits[0];
-      logger.info(`Auto-selected: ${AVAILABLE_KITS[kitType].name}`);
-    } else if (accessibleKits?.length === 1) {
-      kitType = accessibleKits[0];
-      logger.info(`Using ${AVAILABLE_KITS[kitType].name} (only accessible kit)`);
-    } else {
-      kitType = await ctx.prompts.selectKit(undefined, accessibleKits);
     }
+    return result;
   }
-  const kit = AVAILABLE_KITS[kitType];
-  logger.info(`Selected kit: ${kit.name}`);
-  let targetDir;
-  if (ctx.explicitDir) {
-    targetDir = ctx.options.dir;
-    logger.info(`Using explicit directory: ${targetDir}`);
-  } else if (ctx.options.global) {
-    const targetAgents = selectAgents({ explicit: ctx.options.agents });
-    targetDir = resolveGlobalTargetDir(targetAgents);
-    logger.info(`Using global kit directory: ${targetDir}`);
-  } else {
-    targetDir = config.defaults?.dir || ".";
-    if (!config.defaults?.dir) {
-      if (ctx.isNonInteractive) {
-        logger.info("Using current directory as target");
-      } else {
-        targetDir = await ctx.prompts.getDirectory(targetDir);
+  static buildUnifiedDiff(_content, hunks) {
+    let diff = `--- a
++++ b
+`;
+    for (const hunk of hunks) {
+      diff += `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@
+`;
+      for (const line of hunk.lines) {
+        diff += `${line}
+`;
       }
     }
+    return diff;
   }
-  const resolvedDir = resolve22(targetDir);
-  logger.info(`Target directory: ${resolvedDir}`);
-  if (!ctx.options.global && isLocalSameAsGlobal(resolvedDir)) {
-    logger.warning("You're at HOME directory. Installing here modifies your GLOBAL Takumi.");
-    if (!ctx.isNonInteractive) {
-      const choice = await ctx.prompts.selectScope();
-      if (choice === "cancel") {
-        return { ...ctx, cancelled: true };
+  static applyHunksManually(content, hunks) {
+    const lines = content.split(`
+`);
+    const sortedHunks = [...hunks].sort((a3, b4) => b4.oldStart - a3.oldStart);
+    for (const hunk of sortedHunks) {
+      const startIndex = hunk.oldStart - 1;
+      if (startIndex < 0 || startIndex > lines.length) {
+        logger.warning(`Hunk start ${hunk.oldStart} out of bounds (file has ${lines.length} lines)`);
+        continue;
       }
-      if (choice === "global") {
-        logger.info("Proceeding with global installation");
+      const newLines = [];
+      let deleteCount = 0;
+      for (const line of hunk.lines) {
+        if (!line || line.length === 0) {
+          continue;
+        }
+        const prefix = line[0];
+        const lineContent = line.slice(1);
+        if (prefix === "-") {
+          deleteCount++;
+        } else if (prefix === "+" || prefix === " ") {
+          newLines.push(lineContent);
+        }
       }
-      if (choice === "different") {
-        logger.info("Please run 'takumi init' from a project directory instead.");
-        return { ...ctx, cancelled: true };
+      if (startIndex + deleteCount > lines.length) {
+        logger.warning(`Hunk would delete past EOF (start: ${startIndex}, delete: ${deleteCount}, lines: ${lines.length})`);
+        continue;
       }
-    } else {
-      logger.error("Cannot use local installation at HOME directory.");
-      logger.info("Use -g/--global flag or run from a project directory.");
-      return { ...ctx, cancelled: true };
+      lines.splice(startIndex, deleteCount, ...newLines);
     }
+    return lines.join(`
+`);
   }
-  if (!await import_fs_extra32.pathExists(resolvedDir)) {
-    if (ctx.options.global) {
-      await mkdir28(resolvedDir, { recursive: true });
-      logger.info(`Created global directory: ${resolvedDir}`);
-    } else {
-      logger.error(`Directory does not exist: ${resolvedDir}`);
-      logger.info('Use "tkm new" to create a new project');
-      return { ...ctx, cancelled: true };
+  static isBinaryFile(content) {
+    if (content.length === 0) {
+      return false;
     }
-  }
-  if (!ctx.options.fresh) {
-    const prefix = PathResolver.getPathPrefix(ctx.options.global);
-    const claudeDir = prefix ? join97(resolvedDir, prefix) : resolvedDir;
-    try {
-      const existingMetadata = await readManifest(claudeDir);
-      if (existingMetadata?.kits) {
-        const existingKitTypes = Object.keys(existingMetadata.kits);
-        const otherKits = existingKitTypes.filter((k3) => k3 !== kitType);
-        if (otherKits.length > 0) {
-          const kitsRecord = existingMetadata.kits;
-          const existingKitsDisplay = otherKits.map((k3) => `${k3}@${kitsRecord[k3]?.version || "unknown"}`).join(", ");
-          if (!ctx.options.yes && !ctx.isNonInteractive) {
-            try {
-              const confirmAdd = await ctx.prompts.confirm(`${existingKitsDisplay} already installed. Add ${kit.name} alongside?`);
-              if (!confirmAdd) {
-                logger.warning("Multi-kit installation cancelled by user");
-                return { ...ctx, cancelled: true };
-              }
-              logger.info(`Adding ${kit.name} alongside existing kit(s)`);
-            } catch {
-              logger.warning("Prompt cancelled or interrupted");
-              return { ...ctx, cancelled: true };
-            }
-          } else {
-            const reason = ctx.options.yes ? "(--yes flag)" : "(non-interactive mode)";
-            logger.info(`Adding ${kit.name} alongside ${existingKitsDisplay} ${reason}`);
-          }
-        }
+    const sampleSize = Math.min(content.length, 8192);
+    let nonPrintableCount = 0;
+    for (let i = 0;i < sampleSize; i++) {
+      const code = content.charCodeAt(i);
+      if (code === 0) {
+        return true;
+      }
+      if (code < 32 && code !== 9 && code !== 10 && code !== 13) {
+        nonPrintableCount++;
       }
-    } catch (error) {
-      logger.debug(`Metadata read skipped: ${error instanceof Error ? error.message : "unknown error"}`);
-    }
-  }
-  if (ctx.options.fresh) {
-    const prefix = PathResolver.getPathPrefix(ctx.options.global);
-    const claudeDir = prefix ? join97(resolvedDir, prefix) : resolvedDir;
-    const canProceed = await handleFreshInstallation(claudeDir, ctx.prompts);
-    if (!canProceed) {
-      return { ...ctx, cancelled: true };
     }
+    return nonPrintableCount / sampleSize > 0.1;
   }
-  const isOfflineMode = !!(ctx.options.kitPath || ctx.options.archive);
-  const github = !isOfflineMode && useLegacyGh ? new GitHubClient : null;
-  let selectedVersion = ctx.options.release;
-  if (!selectedVersion && ctx.isNonInteractive && !ctx.options.yes && !isOfflineMode) {
-    throw new Error("Non-interactive mode requires either: --release <tag> OR --yes (uses latest)");
-  }
-  if (!selectedVersion && ctx.options.yes && !isOfflineMode) {
-    logger.info("Using latest stable version (--yes flag)");
-  }
-  if (!selectedVersion && !ctx.isNonInteractive && !isOfflineMode) {
-    logger.info("Fetching available versions...");
-    let currentVersion = null;
+  static async loadFileContent(filePath) {
     try {
-      const prefix = PathResolver.getPathPrefix(ctx.options.global);
-      const claudeDir = prefix ? join97(resolvedDir, prefix) : resolvedDir;
-      const existingMetadata = await readManifest(claudeDir);
-      currentVersion = existingMetadata?.kits?.[kitType]?.version || null;
-      if (currentVersion) {
-        logger.debug(`Current installed version: ${currentVersion}`);
+      const lstats = await lstat7(filePath);
+      if (lstats.isSymbolicLink()) {
+        throw new Error(`Symlink not allowed for sync: ${filePath}`);
       }
-    } catch {}
-    try {
-      const versionResult = await ctx.prompts.selectVersionEnhanced({
-        kit,
-        includePrereleases: ctx.options.beta,
-        limit: 10,
-        allowManualEntry: true,
-        forceRefresh: ctx.options.refresh,
-        currentVersion,
-        useGh: useLegacyGh
-      });
-      if (!versionResult) {
-        logger.warning("Version selection cancelled by user");
-        return { ...ctx, cancelled: true };
+      if (lstats.size > MAX_SYNC_FILE_SIZE) {
+        throw new Error(`File too large for sync (${Math.round(lstats.size / 1024 / 1024)}MB > ${MAX_SYNC_FILE_SIZE / 1024 / 1024}MB limit)`);
       }
-      selectedVersion = versionResult;
-      logger.success(`Selected version: ${selectedVersion}`);
+      const buffer = await readFile40(filePath);
+      if (buffer.includes(0)) {
+        return { content: "", isBinary: true };
+      }
+      const content = buffer.toString("utf8");
+      if (content.includes("�")) {
+        return { content: "", isBinary: true };
+      }
+      if (SyncEngine.isBinaryFile(content)) {
+        return { content: "", isBinary: true };
+      }
+      return { content, isBinary: false };
     } catch (error) {
-      logger.error("Failed to fetch versions, using latest release");
-      logger.debug(`Version selection error: ${error.message}`);
-      selectedVersion = undefined;
+      const errMsg = error instanceof Error ? error.message : "Unknown error";
+      throw new Error(`Cannot read file for sync: ${filePath} - ${errMsg}`);
     }
   }
-  let release;
-  if (isOfflineMode) {
-    release = undefined;
-    logger.verbose("Offline mode - skipping release fetch", {
-      kitPath: ctx.options.kitPath,
-      archive: ctx.options.archive
-    });
-  } else if (ctx.options.useGit && selectedVersion) {
-    release = {
-      id: 0,
-      tag_name: selectedVersion,
-      name: selectedVersion,
-      draft: false,
-      prerelease: selectedVersion.includes("-"),
-      tarball_url: `https://github.com/${kit.owner}/${kit.repo}/archive/refs/tags/${selectedVersion}.tar.gz`,
-      zipball_url: `https://github.com/${kit.owner}/${kit.repo}/archive/refs/tags/${selectedVersion}.zip`,
-      assets: []
-    };
-    logger.verbose("Using git clone mode with tag", { tag: selectedVersion });
-  } else if (selectedVersion && github) {
-    release = await github.getReleaseByTag(kit, selectedVersion);
-  } else if (github) {
-    if (ctx.options.beta) {
-      logger.info("Fetching latest beta release...");
+}
+// src/domains/sync/deletion-path-filter.ts
+init_path_resolver();
+var import_picomatch2 = __toESM(require_picomatch2(), 1);
+function filterDeletionPaths(trackedFiles, deletions) {
+  if (!deletions || deletions.length === 0) {
+    return trackedFiles;
+  }
+  const exactPaths = new Set;
+  const globMatchers = [];
+  for (const pattern of deletions) {
+    if (PathResolver.isGlobPattern(pattern)) {
+      globMatchers.push(import_picomatch2.default(pattern));
     } else {
-      logger.info("Fetching latest release...");
+      exactPaths.add(pattern);
     }
-    release = await github.getLatestRelease(kit, ctx.options.beta);
-    if (release.prerelease) {
-      logger.success(`Found beta: ${release.tag_name}`);
-    } else {
-      logger.success(`Found: ${release.tag_name}`);
+  }
+  return trackedFiles.filter((file) => {
+    if (exactPaths.has(file.path))
+      return false;
+    for (const matcher of globMatchers) {
+      if (matcher(file.path))
+        return false;
     }
-  } else if (selectedVersion) {
-    const worker = new WorkerSource(getServerUrl(), kitType);
-    const entry = await worker.fetchByTag(selectedVersion);
-    release = releaseEntryToGitHubRelease(entry, kit);
-  } else {
-    if (ctx.options.beta) {
-      logger.info("Fetching latest beta release...");
-    } else {
-      logger.info("Fetching latest release...");
+    return true;
+  });
+}
+// src/domains/sync/merge-ui.ts
+init_dist2();
+var import_picocolors23 = __toESM(require_picocolors(), 1);
+var HUNK_SEPARATOR_WIDTH = 50;
+var EXTENDED_CONTEXT_LINES = 10;
+var MAX_LINE_DISPLAY_LENGTH = 120;
+function requireTTY() {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error("Interactive merge requires a TTY terminal. " + "Use --yes flag for non-interactive mode, or run in a terminal.");
+  }
+}
+function truncateLine(line) {
+  if (line.length <= MAX_LINE_DISPLAY_LENGTH)
+    return line;
+  return `${line.slice(0, MAX_LINE_DISPLAY_LENGTH - 3)}...`;
+}
+
+class MergeUI {
+  static async promptHunk(hunk, hunkIndex, totalHunks, _filename) {
+    requireTTY();
+    const lineRange = `${hunk.oldStart}-${hunk.oldStart + hunk.oldLines - 1}`;
+    console.log(import_picocolors23.default.cyan(`
+Hunk ${hunkIndex + 1}/${totalHunks}: Lines ${lineRange}`));
+    console.log(import_picocolors23.default.dim("─".repeat(HUNK_SEPARATOR_WIDTH)));
+    for (const line of hunk.lines) {
+      const displayLine = truncateLine(line);
+      const prefix = line[0];
+      if (prefix === "+") {
+        console.log(import_picocolors23.default.green(displayLine));
+      } else if (prefix === "-") {
+        console.log(import_picocolors23.default.red(displayLine));
+      } else {
+        console.log(import_picocolors23.default.dim(displayLine));
+      }
     }
-    const worker = new WorkerSource(getServerUrl(), kitType);
-    const entry = await worker.fetchLatest(ctx.options.beta);
-    release = releaseEntryToGitHubRelease(entry, kit);
-    if (release.prerelease) {
-      logger.success(`Found beta: ${release.tag_name}`);
-    } else {
-      logger.success(`Found: ${release.tag_name}`);
+    console.log(import_picocolors23.default.dim("─".repeat(HUNK_SEPARATOR_WIDTH)));
+    const action = await ie({
+      message: "Action?",
+      options: [
+        { value: "accept", label: "[a]ccept - Apply this change" },
+        { value: "reject", label: "[r]eject - Keep current" },
+        { value: "view", label: "[v]iew - More context" },
+        { value: "skip", label: "[s]kip - Skip entire file" }
+      ]
+    });
+    if (lD(action)) {
+      return "skip";
     }
+    return action;
   }
-  if (ctx.options.force && !ctx.options.yes) {
-    logger.info("--force has no effect without --yes (the version-match skip only applies in non-interactive mode)");
+  static showExtendedContext(currentContent, hunk, contextLines = EXTENDED_CONTEXT_LINES) {
+    const lines = currentContent.split(`
+`);
+    const startLine = Math.max(0, hunk.oldStart - 1 - contextLines);
+    const endLine = Math.min(lines.length, hunk.oldStart + hunk.oldLines - 1 + contextLines);
+    console.log(import_picocolors23.default.cyan(`
+Extended context (lines ${startLine + 1}-${endLine}):`));
+    console.log(import_picocolors23.default.dim("─".repeat(HUNK_SEPARATOR_WIDTH)));
+    for (let i = startLine;i < endLine; i++) {
+      const lineNum = String(i + 1).padStart(4, " ");
+      const isInHunk = i >= hunk.oldStart - 1 && i < hunk.oldStart - 1 + hunk.oldLines;
+      const prefix = isInHunk ? import_picocolors23.default.yellow("*") : " ";
+      console.log(`${import_picocolors23.default.dim(lineNum)} ${prefix} ${lines[i]}`);
+    }
+    console.log(import_picocolors23.default.dim("─".repeat(HUNK_SEPARATOR_WIDTH)));
   }
-  const releaseTag = release?.tag_name;
-  if (ctx.options.yes && !ctx.options.fresh && !ctx.options.force && releaseTag && !isOfflineMode) {
-    try {
-      const prefix = PathResolver.getPathPrefix(ctx.options.global);
-      const claudeDir = prefix ? join97(resolvedDir, prefix) : resolvedDir;
-      const existingMetadata = await readManifest(claudeDir);
-      const installedKitVersion = existingMetadata?.kits?.[kitType]?.version;
-      if (installedKitVersion && versionsMatch(installedKitVersion, releaseTag)) {
-        logger.success(`Already at latest version (${kitType}@${installedKitVersion}), skipping reinstall`);
-        return { ...ctx, cancelled: true };
+  static async mergeFile(filename, currentContent, _newContent, hunks) {
+    console.log(import_picocolors23.default.bold(`
+━━━ ${filename} ━━━`));
+    console.log(import_picocolors23.default.dim(`${hunks.length} change${hunks.length === 1 ? "" : "s"} to review
+`));
+    const decisions = [];
+    for (let i = 0;i < hunks.length; i++) {
+      let action;
+      do {
+        action = await MergeUI.promptHunk(hunks[i], i, hunks.length, filename);
+        if (action === "view") {
+          MergeUI.showExtendedContext(currentContent, hunks[i]);
+        }
+      } while (action === "view");
+      if (action === "skip") {
+        return "skipped";
       }
-    } catch (error) {
-      logger.verbose(`Metadata read failed, proceeding with installation: ${error instanceof Error ? error.message : "unknown"}`);
+      decisions.push(action === "accept");
     }
+    const result = SyncEngine.applyHunks(currentContent, hunks, decisions);
+    const applied = decisions.filter(Boolean).length;
+    const rejected = decisions.length - applied;
+    return { result, applied, rejected };
   }
-  return {
-    ...ctx,
-    kit,
-    kitType,
-    resolvedDir,
-    release,
-    selectedVersion,
-    accessibleKits
+  static displayMergeSummary(filename, applied, rejected) {
+    if (applied > 0 && rejected > 0) {
+      console.log(import_picocolors23.default.dim(`  ${filename}: `) + import_picocolors23.default.green(`${applied} applied`) + import_picocolors23.default.dim(", ") + import_picocolors23.default.yellow(`${rejected} rejected`));
+    } else if (applied > 0) {
+      console.log(import_picocolors23.default.dim(`  ${filename}: `) + import_picocolors23.default.green(`${applied} applied`));
+    } else {
+      console.log(import_picocolors23.default.dim(`  ${filename}: `) + import_picocolors23.default.yellow(`${rejected} rejected`));
+    }
+  }
+  static displaySkipped(filename) {
+    console.log(import_picocolors23.default.dim(`  ${filename}: `) + import_picocolors23.default.yellow("skipped"));
+  }
+}
+// src/domains/sync/notification-display.ts
+var import_picocolors24 = __toESM(require_picocolors(), 1);
+import { stdout } from "node:process";
+function createNotificationBox(borderColor, boxWidth) {
+  const contentWidth = boxWidth - 2;
+  const topBorder = borderColor(`╭${"─".repeat(contentWidth)}╮`);
+  const bottomBorder = borderColor(`╰${"─".repeat(contentWidth)}╯`);
+  const emptyLine = borderColor("│") + " ".repeat(contentWidth) + borderColor("│");
+  const padLine = (text, visibleLen) => {
+    const len = visibleLen ?? text.length;
+    const displayText = len > contentWidth ? `${text.slice(0, contentWidth - 3)}...` : text;
+    const actualLen = visibleLen ?? displayText.length;
+    const totalPadding = contentWidth - actualLen;
+    const leftPadding = Math.max(0, Math.floor(totalPadding / 2));
+    const rightPadding = Math.max(0, totalPadding - leftPadding);
+    return borderColor("│") + " ".repeat(leftPadding) + displayText + " ".repeat(rightPadding) + borderColor("│");
   };
+  return { topBorder, bottomBorder, emptyLine, padLine };
 }
-function resolveGlobalTargetDir(targetAgents) {
-  const primary = targetAgents[0];
-  if (primary) {
-    const installer = getInstaller(primary);
-    if (installer) {
-      return installer.globalRoot();
-    }
+function displayConfigUpdateNotification(entries, isGlobal = false) {
+  if (entries.length === 0)
+    return;
+  const lines = entries.map(({ kit, currentVersion, latestVersion }) => {
+    const cur = currentVersion.replace(/^v/, "");
+    const latest = latestVersion.replace(/^v/, "");
+    const text = `${import_picocolors24.default.bold(kit)}: ${import_picocolors24.default.dim(cur)} ${import_picocolors24.default.white("→")} ${import_picocolors24.default.green(import_picocolors24.default.bold(latest))}`;
+    const visibleLen = kit.length + 2 + cur.length + 3 + latest.length;
+    return { text, visibleLen };
+  });
+  const updateCmd = isGlobal ? "tkm init -g --sync" : "tkm init --sync";
+  const commandText = `Run: ${import_picocolors24.default.cyan(import_picocolors24.default.bold(updateCmd))}`;
+  const commandLen = `Run: ${updateCmd}`.length;
+  const headerLabel = "\uD83D\uDCE6 Config Updates Available";
+  const headerText = import_picocolors24.default.bold(import_picocolors24.default.yellow(headerLabel));
+  const longestLine = Math.max(headerLabel.length, commandLen, ...lines.map((l2) => l2.visibleLen));
+  const terminalWidth = stdout.columns || 80;
+  const boxWidth = Math.min(Math.max(longestLine + 6, 52), terminalWidth - 4);
+  const { topBorder, bottomBorder, emptyLine, padLine } = createNotificationBox(import_picocolors24.default.cyan, boxWidth);
+  console.log("");
+  console.log(topBorder);
+  console.log(emptyLine);
+  console.log(padLine(headerText, headerLabel.length));
+  for (const { text, visibleLen } of lines) {
+    console.log(padLine(text, visibleLen));
   }
-  return getClaudeDir();
+  console.log(emptyLine);
+  console.log(padLine(commandText, commandLen));
+  console.log(emptyLine);
+  console.log(bottomBorder);
+  console.log("");
 }
+// src/domains/sync/passive-update-check.ts
+init_logger();
 // src/commands/init/phases/sync-handler.ts
-import { copyFile as copyFile7, mkdir as mkdir29, open as open3, readFile as readFile41, rename as rename6, stat as stat12, unlink as unlink13, writeFile as writeFile31 } from "node:fs/promises";
-import { dirname as dirname27, join as join98, resolve as resolve23 } from "node:path";
 init_logger();
 init_path_resolver();
 var import_fs_extra33 = __toESM(require_lib(), 1);
@@ -70348,7 +70688,7 @@ async function handleSync(ctx) {
 Run 'takumi init' to update.`, "Legacy Installation");
     return { ...ctx, cancelled: true };
   }
-  let kitType = ctx.options.kit;
+  let kitType = ctx.options.selectedKits?.[0];
   if (!kitType) {
     const engineerMeta = await readKitManifest(claudeDir, "engineer");
     if (engineerMeta) {
@@ -70385,7 +70725,13 @@ Run 'takumi init' to update.`, "Legacy Installation");
     ctx.prompts.note(`You're on the latest version (${updateResult.currentVersion})`, "Already Up to Date");
     return { ...ctx, cancelled: true };
   }
-  displayConfigUpdateNotification(updateResult.currentVersion, updateResult.latestVersion, ctx.options.global);
+  displayConfigUpdateNotification([
+    {
+      kit: kitType,
+      currentVersion: updateResult.currentVersion,
+      latestVersion: updateResult.latestVersion
+    }
+  ], ctx.options.global);
   if (!ctx.isNonInteractive) {
     const proceed = await ctx.prompts.confirm("Proceed with config sync?");
     if (!proceed) {
@@ -71181,23 +71527,102 @@ async function executeInit(options2, prompts) {
   ctx = await handleSelection(ctx);
   if (ctx.cancelled)
     return;
-  ctx = await handleDownload(ctx);
-  if (ctx.cancelled)
+  if (ctx.resolvedDir && !isSyncMode) {
+    try {
+      const prefix = PathResolver.getPathPrefix(ctx.options.global);
+      const claudeDir = prefix ? join102(ctx.resolvedDir, prefix) : ctx.resolvedDir;
+      const pending = await ManifestWriter.findPendingKits(claudeDir);
+      if (pending.length > 0) {
+        logger.warning(`Previous install was interrupted for kit(s): ${pending.join(", ")}. Re-running install will overwrite the pending entry.`);
+      }
+    } catch (error) {
+      logger.debug(`Pending-kit check skipped: ${error}`);
+    }
+  }
+  const selectedKits = ctx.selectedKits && ctx.selectedKits.length > 0 ? ctx.selectedKits : ctx.kitType ? [ctx.kitType] : [];
+  if (selectedKits.length === 0) {
+    logger.error("No kits resolved for installation");
     return;
-  if (!isSyncMode) {
-    ctx = await handleTransforms(ctx);
-    if (ctx.cancelled)
-      return;
   }
-  if (isSyncMode) {
-    ctx = await executeSyncMerge(ctx);
-    if (ctx.cancelled)
+  const aggregatedResults = [];
+  let lastCtx = ctx;
+  for (let i = 0;i < selectedKits.length; i++) {
+    const currentKit = selectedKits[i];
+    const isLastKit = i === selectedKits.length - 1;
+    if (i > 0) {
+      let nextRelease = lastCtx.releasesByKit?.[currentKit];
+      if (!nextRelease) {
+        try {
+          nextRelease = await resolveReleaseForKit(lastCtx, currentKit);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          logger.error(`Failed to resolve release for ${currentKit}: ${message}`);
+          aggregatedResults.push({
+            provider: targetAgents[0] ?? "claude-code",
+            success: false,
+            cancelled: false,
+            installedFiles: [],
+            error: `Release fetch failed for kit "${currentKit}": ${message}`
+          });
+          continue;
+        }
+      }
+      logger.info(`Installing kit ${i + 1}/${selectedKits.length}: ${AVAILABLE_KITS[currentKit].name}${nextRelease?.tag_name ? ` (${nextRelease.tag_name})` : ""}`);
+      if (lastCtx.options.release && !lastCtx.releasesByKit?.[currentKit] && !lastCtx.options.kitPath && !lastCtx.options.archive) {
+        logger.info(`Secondary kit "${currentKit}" uses latest channel — --release applies only to the primary kit.`);
+      }
+      const nextReleasesByKit = { ...lastCtx.releasesByKit ?? {} };
+      if (nextRelease)
+        nextReleasesByKit[currentKit] = nextRelease;
+      lastCtx = {
+        ...lastCtx,
+        kit: AVAILABLE_KITS[currentKit],
+        kitType: currentKit,
+        release: nextRelease,
+        selectedVersion: nextRelease?.tag_name,
+        releasesByKit: nextReleasesByKit,
+        tempDir: undefined,
+        extractDir: undefined,
+        archivePath: undefined,
+        isLastKit
+      };
+    } else {
+      if (selectedKits.length > 1) {
+        logger.info(`Installing kit ${i + 1}/${selectedKits.length}: ${AVAILABLE_KITS[currentKit].name}${lastCtx.release?.tag_name ? ` (${lastCtx.release.tag_name})` : ""}`);
+      }
+      lastCtx = { ...lastCtx, isLastKit };
+    }
+    if (lastCtx.resolvedDir && lastCtx.release && !isSyncMode) {
+      try {
+        const prefix = PathResolver.getPathPrefix(lastCtx.options.global);
+        const claudeDir = prefix ? join102(lastCtx.resolvedDir, prefix) : lastCtx.resolvedDir;
+        const scope = lastCtx.options.global ? "global" : "local";
+        await ManifestWriter.writeKitPending(claudeDir, currentKit, lastCtx.release.tag_name, scope);
+      } catch (error) {
+        logger.debug(`writeKitPending skipped: ${error}`);
+      }
+    }
+    lastCtx = await handleDownload(lastCtx);
+    if (lastCtx.cancelled)
+      return;
+    if (!isSyncMode) {
+      lastCtx = await handleTransforms(lastCtx);
+      if (lastCtx.cancelled)
+        return;
+    }
+    if (isSyncMode) {
+      lastCtx = await executeSyncMerge(lastCtx);
+      if (lastCtx.cancelled)
+        return;
+    }
+    const kitResults = await dispatchInstallers(lastCtx, targetAgents);
+    aggregatedResults.push(...kitResults);
+    if (kitResults.some((r2) => r2.cancelled))
       return;
   }
-  const results = await dispatchInstallers(ctx, targetAgents);
+  ctx = lastCtx;
+  const results = aggregatedResults;
   ctx.installerResults = results;
-  if (results.some((r2) => r2.cancelled))
-    return;
   if (targetAgents.length > 1) {
     displayMultiInstallerSummary(results);
   }
@@ -71229,13 +71654,14 @@ ${errorLines.join(`
     return;
   }
   prompts.outro(`Project initialized successfully at ${ctx.resolvedDir}`);
-  const protectedNote = ctx.customClaudeFiles.length > 0 ? `Your project has been initialized with the latest version.
-Protected files (.env, .claude custom files, etc.) were not modified.` : `Your project has been initialized with the latest version.
-Protected files (.env, etc.) were not modified.`;
-  prompts.note(protectedNote, "Initialization complete");
-  if (ctx.resolvedDir) {
-    await maybeShowConfigUpdateNotification(ctx.resolvedDir, ctx.options.global);
-  }
+  const installedSummary = selectedKits.map((k3) => {
+    const tag = ctx.releasesByKit?.[k3]?.tag_name;
+    return tag ? `${k3}@${tag}` : k3;
+  }).join(", ");
+  const installedLine = installedSummary ? `Installed: ${installedSummary}.` : "Project initialized.";
+  const protectedLine = ctx.customClaudeFiles.length > 0 ? "Your local files were left untouched — including .env and any custom files you added under .claude/." : "Your local files were left untouched — Takumi only writes inside .claude/ (and CLAUDE.md), so .env and other project files are never modified.";
+  prompts.note(`${installedLine}
+${protectedLine}`, "Initialization complete");
 }
 async function initCommand(options2) {
   const prompts = new PromptsManager;
@@ -71258,7 +71684,7 @@ async function initCommand(options2) {
 import { existsSync as existsSync47 } from "node:fs";
 import { readFile as readFile45, rm as rm13, unlink as unlink15 } from "node:fs/promises";
 import { homedir as homedir25 } from "node:os";
-import { basename as basename12, join as join102, resolve as resolve26 } from "node:path";
+import { basename as basename12, join as join103, resolve as resolve26 } from "node:path";
 init_dist2();
 var import_picocolors27 = __toESM(require_picocolors(), 1);
 init_logger();
@@ -71740,7 +72166,7 @@ async function executeDeleteAction(action, options2) {
 async function processMetadataDeletions(skillSourcePath, installGlobally) {
   if (!skillSourcePath)
     return;
-  const sourceMetadataPath = join102(resolve26(skillSourcePath, ".."), "metadata.json");
+  const sourceMetadataPath = join103(resolve26(skillSourcePath, ".."), "metadata.json");
   if (!existsSync47(sourceMetadataPath))
     return;
   let sourceMetadata;
@@ -71753,11 +72179,11 @@ async function processMetadataDeletions(skillSourcePath, installGlobally) {
   }
   if (!sourceMetadata.deletions || sourceMetadata.deletions.length === 0)
     return;
-  const claudeDir = installGlobally ? join102(homedir25(), ".claude") : join102(process.cwd(), ".claude");
+  const claudeDir = installGlobally ? join103(homedir25(), ".claude") : join103(process.cwd(), ".claude");
   if (!existsSync47(claudeDir))
     return;
   try {
-    const result = await handleDeletions(sourceMetadata, claudeDir);
+    const result = await handleDeletions(sourceMetadata, claudeDir, undefined);
     if (result.deletedPaths.length > 0) {
       logger.verbose(`[migrate] Cleaned up ${result.deletedPaths.length} deprecated path(s): ${result.deletedPaths.join(", ")}`);
     }
@@ -71901,8 +72327,8 @@ async function migrateCommand(options2) {
     selectedProviders = Array.from(new Set(selectedProviders));
     let installGlobally = options2.global ?? false;
     if (options2.global === undefined && !options2.yes) {
-      const projectTarget = join102(process.cwd(), ".claude");
-      const globalTarget = join102(homedir25(), ".claude");
+      const projectTarget = join103(process.cwd(), ".claude");
+      const globalTarget = join103(homedir25(), ".claude");
       const scopeChoice = await ie({
         message: "Installation scope",
         options: [
@@ -71954,7 +72380,7 @@ async function migrateCommand(options2) {
     }
     const providerNames = selectedProviders.map((prov) => import_picocolors27.default.cyan(providers[prov].displayName)).join(", ");
     f2.message(`  Providers: ${providerNames}`);
-    const targetDir = installGlobally ? join102(homedir25(), ".claude") : join102(process.cwd(), ".claude");
+    const targetDir = installGlobally ? join103(homedir25(), ".claude") : join103(process.cwd(), ".claude");
     f2.message(`  Scope: ${installGlobally ? "Global" : "Project"} ${import_picocolors27.default.dim(`-> ${targetDir}`)}`);
     const cmdProviders = getProvidersSupporting("commands");
     const unsupportedCmd = selectedProviders.filter((pv) => !cmdProviders.includes(pv));
@@ -72464,7 +72890,7 @@ async function handleDirectorySetup(ctx) {
   };
 }
 // src/commands/new/phases/project-creation.ts
-import { join as join103 } from "node:path";
+import { join as join104 } from "node:path";
 init_github_client();
 init_logger();
 init_output_manager();
@@ -72618,7 +73044,7 @@ async function projectCreation(kit, resolvedDir, validOptions, isNonInteractive2
   output.section("Installing");
   logger.verbose("Installation target", { directory: resolvedDir });
   const merger = new FileMerger;
-  const claudeDir = join103(resolvedDir, ".claude");
+  const claudeDir = join104(resolvedDir, ".claude");
   merger.setMultiKitContext(claudeDir, kit);
   if (validOptions.exclude && validOptions.exclude.length > 0) {
     merger.addIgnorePatterns(validOptions.exclude);
@@ -72671,10 +73097,10 @@ async function handleProjectCreation(ctx) {
   };
 }
 // src/commands/new/phases/post-setup.ts
-import { join as join105 } from "node:path";
+import { join as join106 } from "node:path";
 
 // src/domains/installation/setup-wizard.ts
-import { join as join104 } from "node:path";
+import { join as join105 } from "node:path";
 init_logger();
 init_dist2();
 var import_fs_extra36 = __toESM(require_lib(), 1);
@@ -72754,7 +73180,7 @@ async function parseEnvFile(path9) {
   }
 }
 async function checkGlobalConfig() {
-  const globalEnvPath = join104(getClaudeDir(), ".env");
+  const globalEnvPath = join105(getClaudeDir(), ".env");
   if (!await import_fs_extra36.pathExists(globalEnvPath))
     return false;
   const env2 = await parseEnvFile(globalEnvPath);
@@ -72770,7 +73196,7 @@ async function runSetupWizard(options2) {
   let globalEnv = {};
   const hasGlobalConfig = !isGlobal && await checkGlobalConfig();
   if (!isGlobal) {
-    const globalEnvPath = join104(getClaudeDir(), ".env");
+    const globalEnvPath = join105(getClaudeDir(), ".env");
     if (await import_fs_extra36.pathExists(globalEnvPath)) {
       globalEnv = await parseEnvFile(globalEnvPath);
     }
@@ -72833,7 +73259,7 @@ async function runSetupWizard(options2) {
     }
   }
   await generateEnvFile(targetDir, values);
-  f2.success(`Configuration saved to ${join104(targetDir, ".env")}`);
+  f2.success(`Configuration saved to ${join105(targetDir, ".env")}`);
   return true;
 }
 async function promptForAdditionalGeminiKeys(primaryKey) {
@@ -72936,9 +73362,9 @@ async function postSetup(resolvedDir, validOptions, isNonInteractive2, prompts)
       withSudo: validOptions.withSudo
     });
   }
-  const claudeDir = join105(resolvedDir, ".claude");
+  const claudeDir = join106(resolvedDir, ".claude");
   await promptSetupWizardIfNeeded({
-    envPath: join105(claudeDir, ".env"),
+    envPath: join106(claudeDir, ".env"),
     claudeDir,
     isGlobal: false,
     isNonInteractive: isNonInteractive2,
@@ -73015,11 +73441,11 @@ Example: tkm new --use-git --release v2.1.0`);
 // src/commands/plan/plan-command.ts
 init_output_manager();
 import { existsSync as existsSync52, statSync as statSync5 } from "node:fs";
-import { dirname as dirname33, join as join109, parse as parse2, resolve as resolve31 } from "node:path";
+import { dirname as dirname33, join as join110, parse as parse2, resolve as resolve31 } from "node:path";
 
 // src/commands/plan/plan-read-handlers.ts
 import { existsSync as existsSync51, statSync as statSync4 } from "node:fs";
-import { basename as basename15, dirname as dirname32, join as join108, relative as relative20, resolve as resolve29 } from "node:path";
+import { basename as basename15, dirname as dirname32, join as join109, relative as relative20, resolve as resolve29 } from "node:path";
 
 // src/domains/plan-parser/index.ts
 import { dirname as dirname31 } from "node:path";
@@ -73400,12 +73826,12 @@ function parsePlanFile(planFilePath, options2) {
 }
 // src/domains/plan-parser/plan-scanner.ts
 import { existsSync as existsSync48, readdirSync as readdirSync5 } from "node:fs";
-import { join as join106 } from "node:path";
+import { join as join107 } from "node:path";
 function scanPlanDir(dir) {
   if (!existsSync48(dir))
     return [];
   try {
-    return readdirSync5(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join106(dir, entry.name, "plan.md")).filter(existsSync48);
+    return readdirSync5(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join107(dir, entry.name, "plan.md")).filter(existsSync48);
   } catch {
     return [];
   }
@@ -73474,7 +73900,7 @@ function validatePlanFile(filePath, strict = false) {
 var import_gray_matter7 = __toESM(require_gray_matter(), 1);
 import { mkdirSync as mkdirSync3, readFileSync as readFileSync14, writeFileSync as writeFileSync5 } from "node:fs";
 import { existsSync as existsSync50 } from "node:fs";
-import { basename as basename14, dirname as dirname30, join as join107 } from "node:path";
+import { basename as basename14, dirname as dirname30, join as join108 } from "node:path";
 function phaseNameToFilename(id, name) {
   const numMatch = /^(\d+)([a-z]*)$/i.exec(id);
   const num = numMatch ? numMatch[1] : id;
@@ -73582,12 +74008,12 @@ function scaffoldPlan(options2) {
   mkdirSync3(dir, { recursive: true });
   const resolvedPhases = resolvePhaseIds(options2.phases);
   const optionsWithResolved = { ...options2, phases: resolvedPhases };
-  const planFile = join107(dir, "plan.md");
+  const planFile = join108(dir, "plan.md");
   writeFileSync5(planFile, generatePlanMd(optionsWithResolved), "utf8");
   const phaseFiles = [];
   for (const phase of resolvedPhases) {
     const filename = phaseNameToFilename(phase.id, phase.name);
-    const phaseFile = join107(dir, filename);
+    const phaseFile = join108(dir, filename);
     writeFileSync5(phaseFile, generatePhaseTemplate(phase), "utf8");
     phaseFiles.push(phaseFile);
   }
@@ -73667,7 +74093,7 @@ function phaseNameFilenameFromTableRow(body, phaseId, planDir) {
       continue;
     const linkMatch = /\[([^\]]+)\]\(\.\/([^)]+)\)/.exec(row);
     if (linkMatch)
-      return join107(planDir, linkMatch[2]);
+      return join108(planDir, linkMatch[2]);
   }
   return null;
 }
@@ -73748,7 +74174,7 @@ function addPhase(planFile, name, afterId) {
 `);
   }
   writeFileSync5(planFile, import_gray_matter7.default.stringify(updatedBody, frontmatter), "utf8");
-  const phaseFilePath = join107(planDir, filename);
+  const phaseFilePath = join108(planDir, filename);
   writeFileSync5(phaseFilePath, generatePhaseTemplate({ id: phaseId, name }), "utf8");
   return { phaseId, phaseFile: phaseFilePath };
 }
@@ -73852,7 +74278,7 @@ async function handleValidate(target, options2) {
 }
 async function handleStatus(target, options2) {
   const t = target ? resolve29(target) : null;
-  const plansDir = t && existsSync51(t) && statSync4(t).isDirectory() && !existsSync51(join108(t, "plan.md")) ? t : null;
+  const plansDir = t && existsSync51(t) && statSync4(t).isDirectory() && !existsSync51(join109(t, "plan.md")) ? t : null;
   if (plansDir) {
     const planFiles = scanPlanDir(plansDir);
     if (planFiles.length === 0) {
@@ -74087,7 +74513,7 @@ function resolvePlanFile(target) {
     const stat13 = statSync5(t);
     if (stat13.isFile())
       return t;
-    const candidate = join109(t, "plan.md");
+    const candidate = join110(t, "plan.md");
     if (existsSync52(candidate))
       return candidate;
   }
@@ -74095,7 +74521,7 @@ function resolvePlanFile(target) {
     let dir = process.cwd();
     const root = parse2(dir).root;
     while (dir !== root) {
-      const candidate = join109(dir, "plan.md");
+      const candidate = join110(dir, "plan.md");
       if (existsSync52(candidate))
         return candidate;
       dir = dirname33(dir);
@@ -74367,112 +74793,112 @@ var import_picocolors34 = __toESM(require_picocolors(), 1);
 // src/commands/skills/agents.ts
 import { existsSync as existsSync54 } from "node:fs";
 import { homedir as homedir26 } from "node:os";
-import { join as join110 } from "node:path";
+import { join as join111 } from "node:path";
 var home6 = homedir26();
 var agents = {
   "claude-code": {
     name: "claude-code",
     displayName: "Claude Code",
     projectPath: ".claude/skills",
-    globalPath: join110(home6, ".claude/skills"),
-    detect: async () => existsSync54(join110(home6, ".claude"))
+    globalPath: join111(home6, ".claude/skills"),
+    detect: async () => existsSync54(join111(home6, ".claude"))
   },
   cursor: {
     name: "cursor",
     displayName: "Cursor",
     projectPath: ".cursor/skills",
-    globalPath: join110(home6, ".cursor/skills"),
-    detect: async () => existsSync54(join110(home6, ".cursor"))
+    globalPath: join111(home6, ".cursor/skills"),
+    detect: async () => existsSync54(join111(home6, ".cursor"))
   },
   codex: {
     name: "codex",
     displayName: "Codex",
     projectPath: ".codex/skills",
-    globalPath: join110(home6, ".codex/skills"),
-    detect: async () => existsSync54(join110(home6, ".codex"))
+    globalPath: join111(home6, ".codex/skills"),
+    detect: async () => existsSync54(join111(home6, ".codex"))
   },
   opencode: {
     name: "opencode",
     displayName: "OpenCode",
     projectPath: ".opencode/skills",
-    globalPath: join110(home6, ".config/opencode/skills"),
-    detect: async () => existsSync54(join110(home6, ".config/opencode"))
+    globalPath: join111(home6, ".config/opencode/skills"),
+    detect: async () => existsSync54(join111(home6, ".config/opencode"))
   },
   goose: {
     name: "goose",
     displayName: "Goose",
     projectPath: ".goose/skills",
-    globalPath: join110(home6, ".config/goose/skills"),
-    detect: async () => existsSync54(join110(home6, ".config/goose"))
+    globalPath: join111(home6, ".config/goose/skills"),
+    detect: async () => existsSync54(join111(home6, ".config/goose"))
   },
   "gemini-cli": {
     name: "gemini-cli",
     displayName: "Gemini CLI",
     projectPath: ".agents/skills",
-    globalPath: join110(home6, ".agents/skills"),
-    detect: async () => existsSync54(join110(home6, ".gemini"))
+    globalPath: join111(home6, ".agents/skills"),
+    detect: async () => existsSync54(join111(home6, ".gemini"))
   },
   antigravity: {
     name: "antigravity",
     displayName: "Antigravity",
     projectPath: ".agent/skills",
-    globalPath: join110(home6, ".gemini/antigravity/skills"),
-    detect: async () => existsSync54(join110(process.cwd(), ".agent")) || existsSync54(join110(home6, ".gemini/antigravity"))
+    globalPath: join111(home6, ".gemini/antigravity/skills"),
+    detect: async () => existsSync54(join111(process.cwd(), ".agent")) || existsSync54(join111(home6, ".gemini/antigravity"))
   },
   "github-copilot": {
     name: "github-copilot",
     displayName: "GitHub Copilot",
     projectPath: ".github/skills",
-    globalPath: join110(home6, ".copilot/skills"),
-    detect: async () => existsSync54(join110(home6, ".copilot"))
+    globalPath: join111(home6, ".copilot/skills"),
+    detect: async () => existsSync54(join111(home6, ".copilot"))
   },
   amp: {
     name: "amp",
     displayName: "Amp",
     projectPath: ".agents/skills",
-    globalPath: join110(home6, ".config/agents/skills"),
-    detect: async () => existsSync54(join110(home6, ".config/amp"))
+    globalPath: join111(home6, ".config/agents/skills"),
+    detect: async () => existsSync54(join111(home6, ".config/amp"))
   },
   kilo: {
     name: "kilo",
     displayName: "Kilo Code",
     projectPath: ".kilocode/skills",
-    globalPath: join110(home6, ".kilocode/skills"),
-    detect: async () => existsSync54(join110(home6, ".kilocode"))
+    globalPath: join111(home6, ".kilocode/skills"),
+    detect: async () => existsSync54(join111(home6, ".kilocode"))
   },
   roo: {
     name: "roo",
     displayName: "Roo Code",
     projectPath: ".roo/skills",
-    globalPath: join110(home6, ".roo/skills"),
-    detect: async () => existsSync54(join110(home6, ".roo"))
+    globalPath: join111(home6, ".roo/skills"),
+    detect: async () => existsSync54(join111(home6, ".roo"))
   },
   windsurf: {
     name: "windsurf",
     displayName: "Windsurf",
     projectPath: ".windsurf/skills",
-    globalPath: join110(home6, ".codeium/windsurf/skills"),
-    detect: async () => existsSync54(join110(home6, ".codeium/windsurf"))
+    globalPath: join111(home6, ".codeium/windsurf/skills"),
+    detect: async () => existsSync54(join111(home6, ".codeium/windsurf"))
   },
   cline: {
     name: "cline",
     displayName: "Cline",
     projectPath: ".cline/skills",
-    globalPath: join110(home6, ".cline/skills"),
-    detect: async () => existsSync54(join110(home6, ".cline"))
+    globalPath: join111(home6, ".cline/skills"),
+    detect: async () => existsSync54(join111(home6, ".cline"))
   },
   openhands: {
     name: "openhands",
     displayName: "OpenHands",
     projectPath: ".openhands/skills",
-    globalPath: join110(home6, ".openhands/skills"),
-    detect: async () => existsSync54(join110(home6, ".openhands"))
+    globalPath: join111(home6, ".openhands/skills"),
+    detect: async () => existsSync54(join111(home6, ".openhands"))
   }
 };
 function getInstallPath(skillName, agent, options2) {
   const config = agents[agent];
   const basePath = options2.global ? config.globalPath : config.projectPath;
-  return join110(basePath, skillName);
+  return join111(basePath, skillName);
 }
 function isSkillInstalled(skillName, agent, options2) {
   const installPath = getInstallPath(skillName, agent, options2);
@@ -74483,16 +74909,16 @@ function isSkillInstalled(skillName, agent, options2) {
 import { existsSync as existsSync56 } from "node:fs";
 import { cp as cp4, mkdir as mkdir31, rm as rm14, stat as stat13 } from "node:fs/promises";
 import { homedir as homedir28 } from "node:os";
-import { dirname as dirname35, join as join112, resolve as resolve33 } from "node:path";
+import { dirname as dirname35, join as join113, resolve as resolve33 } from "node:path";
 
 // src/commands/skills/skills-registry.ts
 init_zod();
 import { existsSync as existsSync55 } from "node:fs";
 import { mkdir as mkdir30, readFile as readFile47, writeFile as writeFile35 } from "node:fs/promises";
 import { homedir as homedir27 } from "node:os";
-import { dirname as dirname34, join as join111, sep as sep9 } from "node:path";
+import { dirname as dirname34, join as join112, sep as sep9 } from "node:path";
 var home7 = homedir27();
-var REGISTRY_PATH2 = join111(home7, ".sunagentkit", "skill-registry.json");
+var REGISTRY_PATH2 = join112(home7, ".sunagentkit", "skill-registry.json");
 var SkillInstallationSchema = exports_external.object({
   skill: exports_external.string(),
   agent: exports_external.string(),
@@ -74630,7 +75056,7 @@ async function syncRegistry() {
 var LEGACY_SKILL_PATHS = {
   "gemini-cli": {
     project: ".gemini/skills",
-    global: join112(homedir28(), ".gemini/skills")
+    global: join113(homedir28(), ".gemini/skills")
   }
 };
 function isSamePath3(path1, path22) {
@@ -74664,7 +75090,7 @@ async function cleanupLegacySkillPath(skillName, agent, global3) {
   if (!legacy)
     return;
   const legacyBase = global3 ? legacy.global : legacy.project;
-  const legacyPath = join112(legacyBase, skillName);
+  const legacyPath = join113(legacyBase, skillName);
   if (!existsSync56(legacyPath))
     return;
   await rm14(legacyPath, { recursive: true, force: true });
@@ -74674,7 +75100,7 @@ async function cleanupLegacySkillPath(skillName, agent, global3) {
     if (entry.skill === skillName && entry.agent === agent && entry.global === global3) {
       if (entry.path === legacyPath) {
         const newBase = global3 ? agents[agent].globalPath : agents[agent].projectPath;
-        entry.path = join112(newBase, skillName);
+        entry.path = join113(newBase, skillName);
         changed = true;
       }
     }
@@ -74759,7 +75185,7 @@ function getInstallPreview(skill, targetAgents, options2) {
 // src/commands/skills/skills-uninstaller.ts
 import { existsSync as existsSync57 } from "node:fs";
 import { rm as rm15 } from "node:fs/promises";
-import { join as join113 } from "node:path";
+import { join as join114 } from "node:path";
 async function uninstallSkillFromAgent(skill, agent, global3) {
   const agentConfig = agents[agent];
   const registry = await readRegistry();
@@ -74807,7 +75233,7 @@ async function uninstallSkillFromAgent(skill, agent, global3) {
 async function forceUninstallSkill(skill, agent, global3) {
   const agentConfig = agents[agent];
   const basePath = global3 ? agentConfig.globalPath : agentConfig.projectPath;
-  const path9 = join113(basePath, skill);
+  const path9 = join114(basePath, skill);
   if (!existsSync57(path9)) {
     return {
       skill,
@@ -75312,12 +75738,12 @@ init_logger();
 // src/commands/telemetry/shared.ts
 import { existsSync as existsSync58, readFileSync as readFileSync15, readdirSync as readdirSync6 } from "node:fs";
 import { homedir as homedir29 } from "node:os";
-import { join as join114 } from "node:path";
+import { join as join115 } from "node:path";
 init_token_store();
-var USER_CACHE_PATH = join114(homedir29(), ".claude", "sk-user.json");
-var EVENT_BUFFER_DIR = join114(homedir29(), ".claude", "sk-events");
-var RATE_STATE_PATH = join114(homedir29(), ".claude", "sk-rate-state.json");
-var METADATA_PATH = join114(homedir29(), ".claude", "metadata.json");
+var USER_CACHE_PATH = join115(homedir29(), ".claude", "sk-user.json");
+var EVENT_BUFFER_DIR = join115(homedir29(), ".claude", "sk-events");
+var RATE_STATE_PATH = join115(homedir29(), ".claude", "sk-rate-state.json");
+var METADATA_PATH = join115(homedir29(), ".claude", "metadata.json");
 var TELEMETRY_HOOK_FIELD = "hooks.telemetry";
 var TOKEN_PLACEHOLDER = "__INJECT_AT_RELEASE__";
 function readUserCache() {
@@ -75404,7 +75830,7 @@ async function handleDisable() {
 // src/commands/telemetry/phases/purge-local-handler.ts
 init_logger();
 import { existsSync as existsSync59, readdirSync as readdirSync7, unlinkSync as unlinkSync5 } from "node:fs";
-import { join as join115 } from "node:path";
+import { join as join116 } from "node:path";
 function removeIfExists(path9) {
   try {
     if (!existsSync59(path9))
@@ -75424,7 +75850,7 @@ function removeBufferFiles() {
       if (!file.endsWith(".jsonl"))
         continue;
       try {
-        unlinkSync5(join115(EVENT_BUFFER_DIR, file));
+        unlinkSync5(join116(EVENT_BUFFER_DIR, file));
         count += 1;
       } catch {}
     }
@@ -75650,13 +76076,13 @@ async function detectInstallations() {
 
 // src/commands/uninstall/removal-handler.ts
 import { readdirSync as readdirSync9, rmSync as rmSync6 } from "node:fs";
-import { join as join117, resolve as resolve34, sep as sep10 } from "node:path";
+import { join as join118, resolve as resolve34, sep as sep10 } from "node:path";
 init_logger();
 var import_fs_extra38 = __toESM(require_lib(), 1);
 
 // src/commands/uninstall/analysis-handler.ts
 import { readdirSync as readdirSync8, rmSync as rmSync5 } from "node:fs";
-import { dirname as dirname36, join as join116 } from "node:path";
+import { dirname as dirname36, join as join117 } from "node:path";
 init_logger();
 var import_picocolors35 = __toESM(require_picocolors(), 1);
 function classifyFileByOwnership(ownership, forceOverwrite, deleteReason) {
@@ -75703,7 +76129,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
   if (uninstallManifest.isMultiKit && kit && metadata?.kits?.[kit]) {
     const kitFiles = metadata.kits[kit].files || [];
     for (const trackedFile of kitFiles) {
-      const filePath = join116(installation.path, trackedFile.path);
+      const filePath = join117(installation.path, trackedFile.path);
       if (uninstallManifest.filesToPreserve.includes(trackedFile.path)) {
         result.toPreserve.push({ path: trackedFile.path, reason: "shared with other kit" });
         continue;
@@ -75733,7 +76159,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
     return result;
   }
   for (const trackedFile of allTrackedFiles) {
-    const filePath = join116(installation.path, trackedFile.path);
+    const filePath = join117(installation.path, trackedFile.path);
     const ownershipResult = await OwnershipChecker.checkOwnership(filePath, metadata, installation.path);
     if (!ownershipResult.exists)
       continue;
@@ -75830,7 +76256,7 @@ async function removeInstallations(installations, options2) {
       let removedCount = 0;
       let cleanedDirs = 0;
       for (const item of analysis.toDelete) {
-        const filePath = join117(installation.path, item.path);
+        const filePath = join118(installation.path, item.path);
         if (!await import_fs_extra38.pathExists(filePath))
           continue;
         if (!await isPathSafeToRemove(filePath, installation.path)) {
@@ -76032,7 +76458,7 @@ ${import_picocolors36.default.yellow("User modifications will be permanently del
 // src/commands/update-cli.ts
 init_takumi_config_manager();
 import { exec as exec8, spawn as spawn2 } from "node:child_process";
-import { join as join118 } from "node:path";
+import { join as join119 } from "node:path";
 import { promisify as promisify14 } from "node:util";
 
 // src/domains/github/npm-registry.ts
@@ -76199,7 +76625,7 @@ var import_fs_extra39 = __toESM(require_lib(), 1);
 // package.json
 var package_default = {
   name: "@sunasteriskrnd/takumi",
-  version: "0.5.0",
+  version: "0.7.0",
   description: "CLI tool for bootstrapping and managing Takumi projects",
   type: "module",
   repository: {
@@ -76222,6 +76648,7 @@ var package_default = {
     build: `bun build src/index.ts --outdir dist --target node --external @octokit/rest --external better-sqlite3 --external yauzl-promise --external @node-rs/crc32 && node -e "const fs=require('fs'),f='dist/index.js',c=fs.readFileSync(f,'utf-8');fs.writeFileSync(f,c.replace(/^#!.*\\n\\/\\/ @bun\\n/,''))"`,
     "verify:package": "node scripts/prepublish-check.js",
     test: "bun test",
+    "test:ci": "NON_INTERACTIVE=true CI_SAFE_MODE=true bun test",
     "test:integration": "CK_RUN_CLI_INTEGRATION=1 bun test tests/integration/cli.test.ts",
     "test:watch": "bun test --watch",
     "test:quick": "./scripts/dev-quick-start.sh test",
@@ -76383,7 +76810,7 @@ function selectKitForUpdate(params) {
   };
 }
 async function readMetadataFile(claudeDir) {
-  const metadataPath = join118(claudeDir, "metadata.json");
+  const metadataPath = join119(claudeDir, "metadata.json");
   try {
     if (!await import_fs_extra39.pathExists(metadataPath)) {
       return null;
@@ -76884,7 +77311,7 @@ init_logger();
 import { existsSync as existsSync65 } from "node:fs";
 import { rm as rm16 } from "node:fs/promises";
 import { homedir as homedir31 } from "node:os";
-import { join as join125 } from "node:path";
+import { join as join126 } from "node:path";
 var import_picocolors38 = __toESM(require_picocolors(), 1);
 
 // src/commands/watch/phases/implementation-runner.ts
@@ -77394,7 +77821,7 @@ function spawnAndCollect3(command, args) {
 
 // src/commands/watch/phases/issue-processor.ts
 import { mkdir as mkdir32, writeFile as writeFile37 } from "node:fs/promises";
-import { join as join121 } from "node:path";
+import { join as join122 } from "node:path";
 
 // src/commands/watch/phases/approval-detector.ts
 init_logger();
@@ -77769,9 +78196,9 @@ async function checkAwaitingApproval(state, setup, options2, watchLog, projectDi
 
 // src/commands/watch/phases/plan-dir-finder.ts
 import { readdir as readdir32, stat as stat14 } from "node:fs/promises";
-import { join as join120 } from "node:path";
+import { join as join121 } from "node:path";
 async function findRecentPlanDir(cwd2, issueNumber, watchLog) {
-  const plansRoot = join120(cwd2, "plans");
+  const plansRoot = join121(cwd2, "plans");
   try {
     const entries = await readdir32(plansRoot);
     const tenMinAgo = Date.now() - 10 * 60 * 1000;
@@ -77780,14 +78207,14 @@ async function findRecentPlanDir(cwd2, issueNumber, watchLog) {
     for (const entry of entries) {
       if (entry === "watch" || entry === "reports" || entry === "visuals")
         continue;
-      const dirPath = join120(plansRoot, entry);
+      const dirPath = join121(plansRoot, entry);
       const dirStat = await stat14(dirPath);
       if (!dirStat.isDirectory())
         continue;
       if (dirStat.mtimeMs < tenMinAgo)
         continue;
       try {
-        await stat14(join120(dirPath, "plan.md"));
+        await stat14(join121(dirPath, "plan.md"));
       } catch {
         continue;
       }
@@ -78018,13 +78445,13 @@ 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 = join121(detectedPlanDir, "plan.md");
+      state.activeIssues[numStr].planPath = join122(detectedPlanDir, "plan.md");
       watchLog.info(`Plan directory detected: ${detectedPlanDir}`);
     } else {
       try {
-        const planDir = join121(projectDir, "plans", "watch");
+        const planDir = join122(projectDir, "plans", "watch");
         await mkdir32(planDir, { recursive: true });
-        const planFilePath = join121(planDir, `issue-${issue.number}-plan.md`);
+        const planFilePath = join122(planDir, `issue-${issue.number}-plan.md`);
         await writeFile37(planFilePath, planResult.planText, "utf-8");
         state.activeIssues[numStr].planPath = planFilePath;
         watchLog.info(`Plan saved (fallback) to ${planFilePath}`);
@@ -78329,18 +78756,18 @@ init_logger();
 import { spawnSync as spawnSync5 } from "node:child_process";
 import { existsSync as existsSync62 } from "node:fs";
 import { readdir as readdir33, stat as stat15 } from "node:fs/promises";
-import { join as join122 } from "node:path";
+import { join as join123 } from "node:path";
 async function scanForRepos(parentDir) {
   const repos = [];
   const entries = await readdir33(parentDir);
   for (const entry of entries) {
     if (entry.startsWith("."))
       continue;
-    const fullPath = join122(parentDir, entry);
+    const fullPath = join123(parentDir, entry);
     const entryStat = await stat15(fullPath);
     if (!entryStat.isDirectory())
       continue;
-    const gitDir = join122(fullPath, ".git");
+    const gitDir = join123(fullPath, ".git");
     if (!existsSync62(gitDir))
       continue;
     const result = spawnSync5("gh", ["repo", "view", "--json", "owner,name"], {
@@ -78367,7 +78794,7 @@ init_logger();
 import { spawnSync as spawnSync6 } from "node:child_process";
 import { existsSync as existsSync63 } from "node:fs";
 import { homedir as homedir30 } from "node:os";
-import { join as join123 } from "node:path";
+import { join as join124 } from "node:path";
 async function validateSetup(cwd2) {
   const workDir = cwd2 ?? process.cwd();
   const ghVersion = spawnSync6("gh", ["--version"], { encoding: "utf-8", timeout: 1e4 });
@@ -78398,7 +78825,7 @@ Run this command from a directory with a GitHub remote.`);
   } catch {
     throw new Error(`Failed to parse repository info: ${ghRepo.stdout}`);
   }
-  const skillsPath = join123(homedir30(), ".claude", "skills");
+  const skillsPath = join124(homedir30(), ".claude", "skills");
   const skillsAvailable = existsSync63(skillsPath);
   if (!skillsAvailable) {
     logger.warning(`Takumi Engineer skills not found at ${skillsPath}`);
@@ -78417,7 +78844,7 @@ init_path_resolver();
 import { createWriteStream as createWriteStream4, statSync as statSync6 } from "node:fs";
 import { existsSync as existsSync64 } from "node:fs";
 import { mkdir as mkdir34, rename as rename9 } from "node:fs/promises";
-import { join as join124 } from "node:path";
+import { join as join125 } from "node:path";
 
 class WatchLogger {
   logStream = null;
@@ -78425,7 +78852,7 @@ class WatchLogger {
   logPath = null;
   maxBytes;
   constructor(logDir, maxBytes = 0) {
-    this.logDir = logDir ?? join124(PathResolver.getTakumiDir(), "logs");
+    this.logDir = logDir ?? join125(PathResolver.getTakumiDir(), "logs");
     this.maxBytes = maxBytes;
   }
   async init() {
@@ -78434,7 +78861,7 @@ class WatchLogger {
         await mkdir34(this.logDir, { recursive: true });
       }
       const dateStr = formatDate(new Date);
-      this.logPath = join124(this.logDir, `watch-${dateStr}.log`);
+      this.logPath = join125(this.logDir, `watch-${dateStr}.log`);
       this.logStream = createWriteStream4(this.logPath, { flags: "a", mode: 384 });
     } catch (error) {
       logger.warning(`Cannot create watch log file: ${error instanceof Error ? error.message : "Unknown"}`);
@@ -78614,7 +79041,7 @@ async function watchCommand(options2) {
 }
 async function discoverRepos(options2, watchLog) {
   const cwd2 = process.cwd();
-  const isGitRepo = existsSync65(join125(cwd2, ".git"));
+  const isGitRepo = existsSync65(join126(cwd2, ".git"));
   if (options2.force) {
     await forceRemoveLock(watchLog);
   }
@@ -78684,7 +79111,7 @@ async function resetState(state, projectDir, watchLog) {
   watchLog.info(`Watch state reset (--force) for ${projectDir}`);
 }
 async function forceRemoveLock(watchLog) {
-  const lockPath = join125(homedir31(), ".sunagentkit", "locks", `${LOCK_NAME}.lock`);
+  const lockPath = join126(homedir31(), ".sunagentkit", "locks", `${LOCK_NAME}.lock`);
   try {
     await rm16(lockPath, { recursive: true, force: true });
     watchLog.info("Removed existing lock file (--force)");
@@ -78728,13 +79155,13 @@ function sleep2(ms2) {
 // src/cli/command-registry.ts
 init_logger();
 function registerCommands(cli) {
-  cli.command("new", "Bootstrap a new Takumi project (with interactive version selection)").option("--dir <dir>", "Target directory (default: .)").option("--kit <kit>", "Kit to use (engineer)").option("-r, --release <version>", "Skip version selection, use specific version (e.g., latest, v1.0.0)").option("--force", "Overwrite existing files without confirmation").option("--exclude <pattern>", "Exclude files matching glob pattern (can be used multiple times)").option("--opencode", "Install OpenCode CLI package (non-interactive mode)").option("--gemini", "Install Google Gemini CLI package (non-interactive mode)").option("--install-skills", "Install skills dependencies (non-interactive mode)").option("--with-sudo", "Include system packages requiring sudo (Linux: ffmpeg, imagemagick)").option("--prefix", "Add /sk: prefix to all slash commands by moving them to commands/sk/ subdirectory").option("--beta", "Show beta versions in selection prompt").option("--refresh", "Bypass release cache to fetch latest versions from GitHub").option("--docs-dir <name>", "Custom docs folder name (default: docs)").option("--plans-dir <name>", "Custom plans folder name (default: plans)").option("-y, --yes", "Non-interactive mode with sensible defaults (skip all prompts)").option("--use-git", "Use git clone instead of GitHub API (uses SSH/HTTPS credentials)").option("--archive <path>", "Use local archive file instead of downloading (zip/tar.gz)").option("--kit-path <path>", "Use local kit directory instead of downloading").option("--local", "Use local monorepo as kit source (auto-detects from CLI location)").option("--use-gh", "Force GitHub release source (bypass Worker R2 proxy; default uses Worker)").action(async (options2) => {
+  cli.command("new", "Bootstrap a new Takumi project (with interactive version selection)").option("--dir <dir>", "Target directory (default: .)").option("--kit <kit>", "Kit(s) to install (engineer, extras). Repeat the flag to install multiple kits, e.g. --kit engineer --kit extras.").option("-r, --release <version>", "Skip version selection, use specific version (e.g., latest, v1.0.0)").option("--force", "Overwrite existing files without confirmation").option("--exclude <pattern>", "Exclude files matching glob pattern (can be used multiple times)").option("--opencode", "Install OpenCode CLI package (non-interactive mode)").option("--gemini", "Install Google Gemini CLI package (non-interactive mode)").option("--install-skills", "Install skills dependencies (non-interactive mode)").option("--with-sudo", "Include system packages requiring sudo (Linux: ffmpeg, imagemagick)").option("--prefix", "Add /sk: prefix to all slash commands by moving them to commands/sk/ subdirectory").option("--beta", "Show beta versions in selection prompt").option("--refresh", "Bypass release cache to fetch latest versions from GitHub").option("--docs-dir <name>", "Custom docs folder name (default: docs)").option("--plans-dir <name>", "Custom plans folder name (default: plans)").option("-y, --yes", "Non-interactive mode with sensible defaults (skip all prompts)").option("--use-git", "Use git clone instead of GitHub API (uses SSH/HTTPS credentials)").option("--archive <path>", "Use local archive file instead of downloading (zip/tar.gz)").option("--kit-path <path>", "Use local kit directory instead of downloading").option("--local", "Use local monorepo as kit source (auto-detects from CLI location)").option("--use-gh", "Force GitHub release source (bypass Worker R2 proxy; default uses Worker)").action(async (options2) => {
     if (options2.exclude && !Array.isArray(options2.exclude)) {
       options2.exclude = [options2.exclude];
     }
     await newCommand(options2);
   });
-  cli.command("init", "Initialize or update Takumi project (with interactive version selection)").option("--dir <dir>", "Target directory (default: .)").option("--kit <kit>", "Kit to use (engineer)").option("-r, --release <version>", "Skip version selection, use specific version (e.g., latest, v1.0.0)").option("--exclude <pattern>", "Exclude files matching glob pattern (can be used multiple times)").option("--only <pattern>", "Include only files matching glob pattern (can be used multiple times)").option("-g, --global", "Use platform-specific user configuration directory").option("--fresh", "Full reset: remove SK files, replace settings.json and CLAUDE.md, reinstall from scratch").option("--force", "Force reinstall even if already at latest version (use with --yes; re-onboards missing files without full reset)").option("--install-skills", "Install skills dependencies (non-interactive mode)").option("--with-sudo", "Include system packages requiring sudo (Linux: ffmpeg, imagemagick)").option("--prefix", "Add /sk: prefix to all slash commands by moving them to commands/sk/ subdirectory").option("--beta", "Show beta versions in selection prompt").option("--refresh", "Bypass release cache to fetch latest versions from GitHub").option("--dry-run", "Preview changes without applying them (requires --prefix)").option("--force-overwrite", "Override ownership protections and delete user-modified files (requires --prefix)").option("--force-overwrite-settings", "Fully replace settings.json instead of selective merge (destroys user customizations)").option("--skip-setup", "Skip interactive configuration wizard").option("--docs-dir <name>", "Custom docs folder name (default: docs)").option("--plans-dir <name>", "Custom plans folder name (default: plans)").option("-y, --yes", "Non-interactive mode with sensible defaults (skip all prompts)").option("--sync", "Sync config files from upstream with interactive hunk-by-hunk merge").option("--use-git", "Use git clone instead of GitHub API (uses SSH/HTTPS credentials)").option("--archive <path>", "Use local archive file instead of downloading (zip/tar.gz)").option("--kit-path <path>", "Use local kit directory instead of downloading").option("--local", "Use local monorepo as kit source (auto-detects from CLI location)").option("--use-gh", "Force GitHub release source (bypass Worker R2 proxy; default uses Worker)").option("-a, --agent <agents...>", "Target agents (claude-code, codex). Default: claude-code").action(async (options2) => {
+  cli.command("init", "Initialize or update Takumi project (with interactive version selection)").option("--dir <dir>", "Target directory (default: .)").option("--kit <kit>", "Kit(s) to install (engineer, extras). Repeat the flag to install multiple kits, e.g. --kit engineer --kit extras.").option("-r, --release <version>", "Skip version selection, use specific version (e.g., latest, v1.0.0)").option("--exclude <pattern>", "Exclude files matching glob pattern (can be used multiple times)").option("--only <pattern>", "Include only files matching glob pattern (can be used multiple times)").option("-g, --global", "Use platform-specific user configuration directory").option("--fresh", "Full reset: remove SK files, replace settings.json and CLAUDE.md, reinstall from scratch").option("--force", "Force reinstall even if already at latest version (use with --yes; re-onboards missing files without full reset)").option("--install-skills", "Install skills dependencies (non-interactive mode)").option("--with-sudo", "Include system packages requiring sudo (Linux: ffmpeg, imagemagick)").option("--prefix", "Add /sk: prefix to all slash commands by moving them to commands/sk/ subdirectory").option("--beta", "Show beta versions in selection prompt").option("--refresh", "Bypass release cache to fetch latest versions from GitHub").option("--dry-run", "Preview changes without applying them (requires --prefix)").option("--force-overwrite", "Override ownership protections and delete user-modified files (requires --prefix)").option("--force-overwrite-settings", "Fully replace settings.json instead of selective merge (destroys user customizations)").option("--skip-setup", "Skip interactive configuration wizard").option("--docs-dir <name>", "Custom docs folder name (default: docs)").option("--plans-dir <name>", "Custom plans folder name (default: plans)").option("-y, --yes", "Non-interactive mode with sensible defaults (skip all prompts)").option("--sync", "Sync config files from upstream with interactive hunk-by-hunk merge").option("--use-git", "Use git clone instead of GitHub API (uses SSH/HTTPS credentials)").option("--archive <path>", "Use local archive file instead of downloading (zip/tar.gz)").option("--kit-path <path>", "Use local kit directory instead of downloading").option("--local", "Use local monorepo as kit source (auto-detects from CLI location)").option("--use-gh", "Force GitHub release source (bypass Worker R2 proxy; default uses Worker)").option("-a, --agent <agents...>", "Target agents (claude-code, codex). Default: claude-code").action(async (options2) => {
     if (options2.exclude && !Array.isArray(options2.exclude)) {
       options2.exclude = [options2.exclude];
     }
@@ -78747,6 +79174,9 @@ function registerCommands(cli) {
     if (options2.agent) {
       options2.agents = options2.agent;
     }
+    if (options2.kit && Array.isArray(options2.kit)) {
+      options2.kit = options2.kit.join(",");
+    }
     await initCommand(options2);
   });
   cli.command("update", "Update Takumi CLI to the latest version").option("-r, --release <version>", "Update to a specific version").option("--check", "Check for updates without installing").option("-y, --yes", "Non-interactive mode with sensible defaults (skip all prompts)").option("-d, --dev", "Update to the latest dev version").option("--beta", "Alias for --dev (deprecated)").option("--registry <url>", "Custom npm registry URL").option("--kit <kit>", "[DEPRECATED] Use 'takumi init --kit <kit>' instead").option("-g, --global", "[DEPRECATED] Use 'takumi init --global' instead").action(async (options2) => {
@@ -78886,7 +79316,7 @@ function registerCommands(cli) {
 
 // src/cli/version-display.ts
 import { existsSync as existsSync77, readFileSync as readFileSync20 } from "node:fs";
-import { join as join137 } from "node:path";
+import { join as join138 } from "node:path";
 init_help_banner();
 // src/domains/versioning/checking/kit-version-checker.ts
 init_github_client();
@@ -78898,14 +79328,14 @@ init_logger();
 init_path_resolver();
 import { existsSync as existsSync76 } from "node:fs";
 import { mkdir as mkdir35, readFile as readFile52, writeFile as writeFile40 } from "node:fs/promises";
-import { join as join136 } from "node:path";
+import { join as join137 } 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 join136(cacheDir, VersionCacheManager.CACHE_FILENAME);
+    return join137(cacheDir, VersionCacheManager.CACHE_FILENAME);
   }
   static async load() {
     const cacheFile = VersionCacheManager.getCacheFile();
@@ -79198,8 +79628,8 @@ async function displayVersion() {
     const localSubdir = PROVIDER_LOCAL_SUBDIRS[provider];
     if (!localSubdir)
       continue;
-    const localMeta = join137(process.cwd(), localSubdir, "metadata.json");
-    if (localMeta === join137(inst.globalRoot(), "metadata.json"))
+    const localMeta = join138(process.cwd(), localSubdir, "metadata.json");
+    if (localMeta === join138(inst.globalRoot(), "metadata.json"))
       continue;
     if (!existsSync77(localMeta))
       continue;
@@ -79224,7 +79654,7 @@ async function displayVersion() {
   }
   const singleInstall = detectedGlobals.length === 1 && detectedGlobals[0]?.provider === "claude-code";
   for (const { provider, path: installPath } of detectedGlobals) {
-    const metadataPath = join137(installPath, "metadata.json");
+    const metadataPath = join138(installPath, "metadata.json");
     if (existsSync77(metadataPath)) {
       try {
         const rawMetadata = JSON.parse(readFileSync20(metadataPath, "utf-8"));