lee-spec-kit 0.6.4 → 0.6.5

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import path17 from 'path';
+import path18 from 'path';
 import { fileURLToPath } from 'url';
 import { program } from 'commander';
-import fs15 from 'fs-extra';
+import fs14 from 'fs-extra';
 import prompts from 'prompts';
 import chalk6 from 'chalk';
 import { glob } from 'glob';
@@ -11,10 +11,10 @@ import { createHash } from 'crypto';
 import os from 'os';
 
 var getFilename = () => fileURLToPath(import.meta.url);
-var getDirname = () => path17.dirname(getFilename());
+var getDirname = () => path18.dirname(getFilename());
 var __dirname$1 = /* @__PURE__ */ getDirname();
 async function copyTemplates(src, dest) {
-  await fs15.copy(src, dest, {
+  await fs14.copy(src, dest, {
     overwrite: true,
     errorOnExist: false
   });
@@ -30,22 +30,22 @@ function applyReplacements(content, replacements) {
 async function replaceInFiles(dir, replacements) {
   const files = await glob("**/*.md", { cwd: dir, absolute: true });
   for (const file of files) {
-    let content = await fs15.readFile(file, "utf-8");
+    let content = await fs14.readFile(file, "utf-8");
     content = applyReplacements(content, replacements);
-    await fs15.writeFile(file, content, "utf-8");
+    await fs14.writeFile(file, content, "utf-8");
   }
   const shFiles = await glob("**/*.sh", { cwd: dir, absolute: true });
   for (const file of shFiles) {
-    let content = await fs15.readFile(file, "utf-8");
+    let content = await fs14.readFile(file, "utf-8");
     content = applyReplacements(content, replacements);
-    await fs15.writeFile(file, content, "utf-8");
+    await fs14.writeFile(file, content, "utf-8");
   }
 }
 var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path17.dirname(__filename2);
+var __dirname2 = path18.dirname(__filename2);
 function getTemplatesDir() {
-  const rootDir = path17.resolve(__dirname2, "..");
-  return path17.join(rootDir, "templates");
+  const rootDir = path18.resolve(__dirname2, "..");
+  return path18.join(rootDir, "templates");
 }
 
 // src/utils/i18n.ts
@@ -1203,17 +1203,17 @@ function sleep(ms) {
   return new Promise((resolve) => globalThis.setTimeout(resolve, ms));
 }
 function getDocsLockPath(docsDir) {
-  return path17.join(docsDir, ".lee-spec-kit.lock");
+  return path18.join(docsDir, ".lee-spec-kit.lock");
 }
 function getInitLockPath(targetDir) {
-  return path17.join(
-    path17.dirname(targetDir),
-    `.lee-spec-kit.${path17.basename(targetDir)}.lock`
+  return path18.join(
+    path18.dirname(targetDir),
+    `.lee-spec-kit.${path18.basename(targetDir)}.lock`
   );
 }
 async function isStaleLock(lockPath, staleMs) {
   try {
-    const stat = await fs15.stat(lockPath);
+    const stat = await fs14.stat(lockPath);
     if (Date.now() - stat.mtimeMs <= staleMs) {
       return false;
     }
@@ -1228,7 +1228,7 @@ async function isStaleLock(lockPath, staleMs) {
 }
 async function readLockPayload(lockPath) {
   try {
-    const raw = await fs15.readFile(lockPath, "utf8");
+    const raw = await fs14.readFile(lockPath, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") return null;
     return parsed;
@@ -1250,17 +1250,17 @@ function isProcessAlive(pid) {
   }
 }
 async function tryAcquire(lockPath, owner) {
-  await fs15.ensureDir(path17.dirname(lockPath));
+  await fs14.ensureDir(path18.dirname(lockPath));
   try {
-    const fd = await fs15.open(lockPath, "wx");
+    const fd = await fs14.open(lockPath, "wx");
     const payload = JSON.stringify(
       { pid: process.pid, owner: owner ?? "unknown", createdAt: (/* @__PURE__ */ new Date()).toISOString() },
       null,
       2
     );
-    await fs15.writeFile(fd, `${payload}
+    await fs14.writeFile(fd, `${payload}
 `, { encoding: "utf8" });
-    await fs15.close(fd);
+    await fs14.close(fd);
     return true;
   } catch (error) {
     if (error.code === "EEXIST") {
@@ -1274,9 +1274,9 @@ async function waitForLockRelease(lockPath, options = {}) {
   const pollMs = options.pollMs ?? DEFAULT_POLL_MS;
   const staleMs = options.staleMs ?? DEFAULT_STALE_MS;
   const startedAt = Date.now();
-  while (await fs15.pathExists(lockPath)) {
+  while (await fs14.pathExists(lockPath)) {
     if (await isStaleLock(lockPath, staleMs)) {
-      await fs15.remove(lockPath);
+      await fs14.remove(lockPath);
       break;
     }
     if (Date.now() - startedAt > timeoutMs) {
@@ -1294,7 +1294,7 @@ async function withFileLock(lockPath, task, options = {}) {
     const acquired = await tryAcquire(lockPath, options.owner);
     if (acquired) break;
     if (await isStaleLock(lockPath, staleMs)) {
-      await fs15.remove(lockPath);
+      await fs14.remove(lockPath);
       continue;
     }
     if (Date.now() - startedAt > timeoutMs) {
@@ -1308,7 +1308,7 @@ async function withFileLock(lockPath, task, options = {}) {
   try {
     return await task();
   } finally {
-    await fs15.remove(lockPath).catch(() => {
+    await fs14.remove(lockPath).catch(() => {
     });
   }
 }
@@ -1327,30 +1327,30 @@ var ENGINE_MANAGED_AGENT_FILES = [
   "pr-template.md"
 ];
 var ENGINE_MANAGED_AGENT_DIRS = ["skills"];
-var ENGINE_MANAGED_FEATURE_PATH = path17.join(
+var ENGINE_MANAGED_FEATURE_PATH = path18.join(
   "features",
   "feature-base"
 );
 async function pruneEngineManagedDocs(docsDir) {
   const removed = [];
   for (const file of ENGINE_MANAGED_AGENT_FILES) {
-    const target = path17.join(docsDir, "agents", file);
-    if (await fs15.pathExists(target)) {
-      await fs15.remove(target);
-      removed.push(path17.relative(docsDir, target));
+    const target = path18.join(docsDir, "agents", file);
+    if (await fs14.pathExists(target)) {
+      await fs14.remove(target);
+      removed.push(path18.relative(docsDir, target));
     }
   }
   for (const dir of ENGINE_MANAGED_AGENT_DIRS) {
-    const target = path17.join(docsDir, "agents", dir);
-    if (await fs15.pathExists(target)) {
-      await fs15.remove(target);
-      removed.push(path17.relative(docsDir, target));
+    const target = path18.join(docsDir, "agents", dir);
+    if (await fs14.pathExists(target)) {
+      await fs14.remove(target);
+      removed.push(path18.relative(docsDir, target));
     }
   }
-  const featureBasePath = path17.join(docsDir, ENGINE_MANAGED_FEATURE_PATH);
-  if (await fs15.pathExists(featureBasePath)) {
-    await fs15.remove(featureBasePath);
-    removed.push(path17.relative(docsDir, featureBasePath));
+  const featureBasePath = path18.join(docsDir, ENGINE_MANAGED_FEATURE_PATH);
+  if (await fs14.pathExists(featureBasePath)) {
+    await fs14.remove(featureBasePath);
+    removed.push(path18.relative(docsDir, featureBasePath));
   }
   return removed;
 }
@@ -1403,7 +1403,7 @@ ${tr(lang2, "cli", "common.canceled")}`)
 }
 async function runInit(options) {
   const cwd = process.cwd();
-  const defaultName = path17.basename(cwd);
+  const defaultName = path18.basename(cwd);
   let projectName = options.name || defaultName;
   let projectType = options.type;
   let components = parseComponentsOption(options.components);
@@ -1413,7 +1413,7 @@ async function runInit(options) {
   let pushDocs = typeof options.pushDocs === "boolean" ? options.pushDocs : void 0;
   let docsRemote = options.docsRemote;
   let projectRoot;
-  const targetDir = path17.resolve(cwd, options.dir || "./docs");
+  const targetDir = path18.resolve(cwd, options.dir || "./docs");
   const skipPrompts = !!options.yes || !!options.nonInteractive;
   if (options.docsRepo && !["embedded", "standalone"].includes(options.docsRepo)) {
     throw createCliError(
@@ -1731,8 +1731,8 @@ async function runInit(options) {
   await withFileLock(
     initLockPath,
     async () => {
-      if (await fs15.pathExists(targetDir)) {
-        const files = await fs15.readdir(targetDir);
+      if (await fs14.pathExists(targetDir)) {
+        const files = await fs14.readdir(targetDir);
         if (files.length > 0) {
           if (options.force) {
           } else if (options.nonInteractive) {
@@ -1768,28 +1768,28 @@ async function runInit(options) {
       );
       console.log();
       const templatesDir = getTemplatesDir();
-      const commonPath = path17.join(templatesDir, lang, "common");
+      const commonPath = path18.join(templatesDir, lang, "common");
       const templateProjectType = toTemplateProjectType(projectType);
-      const typePath = path17.join(templatesDir, lang, templateProjectType);
-      if (await fs15.pathExists(commonPath)) {
+      const typePath = path18.join(templatesDir, lang, templateProjectType);
+      if (await fs14.pathExists(commonPath)) {
         await copyTemplates(commonPath, targetDir);
       }
-      if (!await fs15.pathExists(typePath)) {
+      if (!await fs14.pathExists(typePath)) {
         throw new Error(
           tr(lang, "cli", "init.error.templateNotFound", { path: typePath })
         );
       }
       await copyTemplates(typePath, targetDir);
       if (projectType === "multi" && !isDefaultFullstackComponents(components)) {
-        const featuresRoot = path17.join(targetDir, "features");
-        await fs15.remove(path17.join(featuresRoot, "fe"));
-        await fs15.remove(path17.join(featuresRoot, "be"));
+        const featuresRoot = path18.join(targetDir, "features");
+        await fs14.remove(path18.join(featuresRoot, "fe"));
+        await fs14.remove(path18.join(featuresRoot, "be"));
         for (const component of components) {
-          const componentDir = path17.join(featuresRoot, component);
-          await fs15.ensureDir(componentDir);
-          const readmePath = path17.join(componentDir, "README.md");
-          if (!await fs15.pathExists(readmePath)) {
-            await fs15.writeFile(
+          const componentDir = path18.join(featuresRoot, component);
+          await fs14.ensureDir(componentDir);
+          const readmePath = path18.join(componentDir, "README.md");
+          if (!await fs14.pathExists(readmePath)) {
+            await fs14.writeFile(
               readmePath,
               `# ${component.toUpperCase()} Features
 
@@ -1838,8 +1838,8 @@ Store ${component} feature specs here.
           config.projectRoot = projectRoot;
         }
       }
-      const configPath = path17.join(targetDir, ".lee-spec-kit.json");
-      await fs15.writeJson(configPath, config, { spaces: 2 });
+      const configPath = path18.join(targetDir, ".lee-spec-kit.json");
+      await fs14.writeJson(configPath, config, { spaces: 2 });
       console.log(chalk6.green(tr(lang, "cli", "init.log.docsCreated")));
       console.log();
       await initGit(cwd, targetDir, docsRepo, lang, pushDocs, docsRemote);
@@ -1907,7 +1907,7 @@ async function initGit(cwd, targetDir, docsRepo, lang, pushDocs, docsRemote) {
       console.log(chalk6.blue(tr(lang, "cli", "init.log.gitInit")));
       runGit(["init"], cwd);
     }
-    const relativePath = path17.relative(cwd, targetDir);
+    const relativePath = path18.relative(cwd, targetDir);
     const stagedBeforeAdd = getCachedStagedFiles(cwd);
     if (relativePath === "." && stagedBeforeAdd && stagedBeforeAdd.length > 0) {
       console.log(
@@ -1964,17 +1964,17 @@ async function initGit(cwd, targetDir, docsRepo, lang, pushDocs, docsRemote) {
 }
 function getAncestorDirs(startDir) {
   const dirs = [];
-  let current = path17.resolve(startDir);
+  let current = path18.resolve(startDir);
   while (true) {
     dirs.push(current);
-    const parent = path17.dirname(current);
+    const parent = path18.dirname(current);
     if (parent === current) break;
     current = parent;
   }
   return dirs;
 }
 function hasWorkspaceBoundary(dir) {
-  return fs15.existsSync(path17.join(dir, "package.json")) || fs15.existsSync(path17.join(dir, ".git"));
+  return fs14.existsSync(path18.join(dir, "package.json")) || fs14.existsSync(path18.join(dir, ".git"));
 }
 function getSearchBaseDirs(cwd) {
   const ancestors = getAncestorDirs(cwd);
@@ -1987,24 +1987,24 @@ function getSearchBaseDirs(cwd) {
 async function getConfig(cwd) {
   const explicitDocsDir = (process.env.LEE_SPEC_KIT_DOCS_DIR || "").trim();
   const baseDirs = [
-    ...explicitDocsDir ? [path17.resolve(explicitDocsDir)] : [],
+    ...explicitDocsDir ? [path18.resolve(explicitDocsDir)] : [],
     ...getSearchBaseDirs(cwd)
   ];
   const visitedBaseDirs = /* @__PURE__ */ new Set();
   const visitedDocsDirs = /* @__PURE__ */ new Set();
   for (const baseDir of baseDirs) {
-    const resolvedBaseDir = path17.resolve(baseDir);
+    const resolvedBaseDir = path18.resolve(baseDir);
     if (visitedBaseDirs.has(resolvedBaseDir)) continue;
     visitedBaseDirs.add(resolvedBaseDir);
-    const possibleDocsDirs = [path17.join(resolvedBaseDir, "docs"), resolvedBaseDir];
+    const possibleDocsDirs = [path18.join(resolvedBaseDir, "docs"), resolvedBaseDir];
     for (const docsDir of possibleDocsDirs) {
-      const resolvedDocsDir = path17.resolve(docsDir);
+      const resolvedDocsDir = path18.resolve(docsDir);
       if (visitedDocsDirs.has(resolvedDocsDir)) continue;
       visitedDocsDirs.add(resolvedDocsDir);
-      const configPath = path17.join(resolvedDocsDir, ".lee-spec-kit.json");
-      if (await fs15.pathExists(configPath)) {
+      const configPath = path18.join(resolvedDocsDir, ".lee-spec-kit.json");
+      if (await fs14.pathExists(configPath)) {
         try {
-          const configFile = await fs15.readJson(configPath);
+          const configFile = await fs14.readJson(configPath);
           const projectType = normalizeProjectType(configFile.projectType);
           const components = resolveProjectComponents(
             projectType,
@@ -2027,22 +2027,22 @@ async function getConfig(cwd) {
         } catch {
         }
       }
-      const agentsPath = path17.join(resolvedDocsDir, "agents");
-      const featuresPath = path17.join(resolvedDocsDir, "features");
-      if (await fs15.pathExists(agentsPath) && await fs15.pathExists(featuresPath)) {
-        const bePath = path17.join(featuresPath, "be");
-        const fePath = path17.join(featuresPath, "fe");
-        const projectType = await fs15.pathExists(bePath) || await fs15.pathExists(fePath) ? "multi" : "single";
+      const agentsPath = path18.join(resolvedDocsDir, "agents");
+      const featuresPath = path18.join(resolvedDocsDir, "features");
+      if (await fs14.pathExists(agentsPath) && await fs14.pathExists(featuresPath)) {
+        const bePath = path18.join(featuresPath, "be");
+        const fePath = path18.join(featuresPath, "fe");
+        const projectType = await fs14.pathExists(bePath) || await fs14.pathExists(fePath) ? "multi" : "single";
         const components = projectType === "multi" ? resolveProjectComponents("multi", ["fe", "be"]) : void 0;
         const langProbeCandidates = [
-          path17.join(agentsPath, "custom.md"),
-          path17.join(agentsPath, "constitution.md"),
-          path17.join(agentsPath, "agents.md")
+          path18.join(agentsPath, "custom.md"),
+          path18.join(agentsPath, "constitution.md"),
+          path18.join(agentsPath, "agents.md")
         ];
         let lang = "en";
         for (const candidate of langProbeCandidates) {
-          if (!await fs15.pathExists(candidate)) continue;
-          const content = await fs15.readFile(candidate, "utf-8");
+          if (!await fs14.pathExists(candidate)) continue;
+          const content = await fs14.readFile(candidate, "utf-8");
           if (/[가-힣]/.test(content)) {
             lang = "ko";
             break;
@@ -2088,14 +2088,14 @@ function sanitizeTasksForLocal(content, lang) {
   return normalizeTrailingBlankLines(next);
 }
 async function patchMarkdownIfExists(filePath, transform) {
-  if (!await fs15.pathExists(filePath)) return;
-  const content = await fs15.readFile(filePath, "utf-8");
-  await fs15.writeFile(filePath, transform(content), "utf-8");
+  if (!await fs14.pathExists(filePath)) return;
+  const content = await fs14.readFile(filePath, "utf-8");
+  await fs14.writeFile(filePath, transform(content), "utf-8");
 }
 async function applyLocalWorkflowTemplateToFeatureDir(featureDir, lang) {
-  await patchMarkdownIfExists(path17.join(featureDir, "spec.md"), sanitizeSpecForLocal);
+  await patchMarkdownIfExists(path18.join(featureDir, "spec.md"), sanitizeSpecForLocal);
   await patchMarkdownIfExists(
-    path17.join(featureDir, "tasks.md"),
+    path18.join(featureDir, "tasks.md"),
     (content) => sanitizeTasksForLocal(content, lang)
   );
 }
@@ -2245,29 +2245,29 @@ async function runFeature(name, options) {
       }
       let featuresDir;
       if (projectType === "multi") {
-        featuresDir = path17.join(docsDir, "features", component);
+        featuresDir = path18.join(docsDir, "features", component);
       } else {
-        featuresDir = path17.join(docsDir, "features");
+        featuresDir = path18.join(docsDir, "features");
       }
       const featureFolderName = `${featureId}-${name}`;
-      const featureDir = path17.join(featuresDir, featureFolderName);
-      if (await fs15.pathExists(featureDir)) {
+      const featureDir = path18.join(featuresDir, featureFolderName);
+      if (await fs14.pathExists(featureDir)) {
         throw createCliError(
           "INVALID_ARGUMENT",
           tr(lang, "cli", "feature.folderExists", { path: featureDir })
         );
       }
-      const featureBasePath = path17.join(
+      const featureBasePath = path18.join(
         getTemplatesDir(),
         lang,
         toTemplateProjectType(projectType),
         "features",
         "feature-base"
       );
-      if (!await fs15.pathExists(featureBasePath)) {
+      if (!await fs14.pathExists(featureBasePath)) {
         throw createCliError("DOCS_NOT_FOUND", tr(lang, "cli", "feature.baseNotFound"));
       }
-      await fs15.copy(featureBasePath, featureDir);
+      await fs14.copy(featureBasePath, featureDir);
       const idNumber = featureId.replace("F", "");
       const repoName = projectType === "multi" ? `{{projectName}}-${component}` : "{{projectName}}";
       const replacements = {
@@ -2314,7 +2314,7 @@ async function runFeature(name, options) {
         featureName: name,
         component: projectType === "multi" ? component : void 0,
         featurePath: featureDir,
-        featurePathFromDocs: path17.relative(docsDir, featureDir)
+        featurePathFromDocs: path18.relative(docsDir, featureDir)
       };
     },
     { owner: "feature" }
@@ -2326,9 +2326,9 @@ function sleep2(ms) {
 async function waitForConfigAfterInit(cwd, timeoutMs = 8e3) {
   const explicitDocsDir = (process.env.LEE_SPEC_KIT_DOCS_DIR || "").trim();
   const candidates = [
-    ...explicitDocsDir ? [path17.resolve(explicitDocsDir)] : [],
-    path17.resolve(cwd, "docs"),
-    path17.resolve(cwd)
+    ...explicitDocsDir ? [path18.resolve(explicitDocsDir)] : [],
+    path18.resolve(cwd, "docs"),
+    path18.resolve(cwd)
   ];
   const endAt = Date.now() + timeoutMs;
   while (Date.now() < endAt) {
@@ -2339,7 +2339,7 @@ async function waitForConfigAfterInit(cwd, timeoutMs = 8e3) {
       const initLockPath = getInitLockPath(dir);
       const docsLockPath = getDocsLockPath(dir);
       for (const lockPath of [initLockPath, docsLockPath]) {
-        if (await fs15.pathExists(lockPath)) {
+        if (await fs14.pathExists(lockPath)) {
           sawLock = true;
           await waitForLockRelease(lockPath, {
             timeoutMs: Math.max(200, endAt - Date.now()),
@@ -2355,17 +2355,17 @@ async function waitForConfigAfterInit(cwd, timeoutMs = 8e3) {
   return getConfig(cwd);
 }
 async function getNextFeatureId(docsDir, projectType, components) {
-  const featuresDir = path17.join(docsDir, "features");
+  const featuresDir = path18.join(docsDir, "features");
   let max = 0;
   const scanDirs = [];
   if (projectType === "multi") {
-    scanDirs.push(...components.map((component) => path17.join(featuresDir, component)));
+    scanDirs.push(...components.map((component) => path18.join(featuresDir, component)));
   } else {
     scanDirs.push(featuresDir);
   }
   for (const dir of scanDirs) {
-    if (!await fs15.pathExists(dir)) continue;
-    const entries = await fs15.readdir(dir, { withFileTypes: true });
+    if (!await fs14.pathExists(dir)) continue;
+    const entries = await fs14.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const match = entry.name.match(/^F(\d+)-/);
@@ -3133,6 +3133,59 @@ function getGitStatusPorcelain(cwd, relativePaths) {
     return void 0;
   }
 }
+function normalizeInputPath(value) {
+  return value.replace(/\\/g, "/").replace(/^\.\/+/, "").replace(/\/+$/, "");
+}
+function toUniqueNormalizedPaths(relativePaths) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of relativePaths) {
+    const normalized = normalizeInputPath(value);
+    if (!normalized) continue;
+    if (seen.has(normalized)) continue;
+    seen.add(normalized);
+    out.push(normalized);
+  }
+  return out;
+}
+function getTrackedGitPaths(cwd, relativePaths) {
+  const inputs = toUniqueNormalizedPaths(relativePaths);
+  if (inputs.length === 0) return /* @__PURE__ */ new Set();
+  try {
+    const out = execFileSync("git", ["ls-files", "--", ...inputs], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return new Set(
+      out.split("\n").map((line) => normalizeInputPath(line)).filter(Boolean)
+    );
+  } catch {
+    return void 0;
+  }
+}
+function getIgnoredGitPaths(cwd, relativePaths) {
+  const inputs = toUniqueNormalizedPaths(relativePaths);
+  if (inputs.length === 0) return /* @__PURE__ */ new Set();
+  try {
+    const out = execFileSync("git", ["check-ignore", "--stdin"], {
+      cwd,
+      encoding: "utf-8",
+      input: `${inputs.join("\n")}
+`,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return new Set(
+      out.split("\n").map((line) => normalizeInputPath(line)).filter(Boolean)
+    );
+  } catch (error) {
+    if (error && typeof error === "object" && "status" in error) {
+      const status = error.status;
+      if (status === 1) return /* @__PURE__ */ new Set();
+    }
+    return void 0;
+  }
+}
 function getLastCommitForPath(cwd, relativePath) {
   try {
     const out = execSync(`git rev-list -n 1 HEAD -- "${relativePath}"`, {
@@ -3280,13 +3333,13 @@ function parsePrLink(value) {
   return trimmed;
 }
 function normalizeGitPath(value) {
-  return value.split(path17.sep).join("/");
+  return value.split(path18.sep).join("/");
 }
 function resolveProjectStatusPaths(projectGitCwd, docsDir) {
-  const relativeDocsDir = path17.relative(projectGitCwd, docsDir);
+  const relativeDocsDir = path18.relative(projectGitCwd, docsDir);
   if (!relativeDocsDir) return [];
-  if (path17.isAbsolute(relativeDocsDir)) return [];
-  if (relativeDocsDir === ".." || relativeDocsDir.startsWith(`..${path17.sep}`)) {
+  if (path18.isAbsolute(relativeDocsDir)) return [];
+  if (relativeDocsDir === ".." || relativeDocsDir.startsWith(`..${path18.sep}`)) {
     return [];
   }
   const normalizedDocsDir = normalizeGitPath(relativeDocsDir).replace(/\/+$/, "");
@@ -3305,6 +3358,8 @@ function uniqueNormalizedPaths(values) {
   }
   return out;
 }
+var PROJECT_DIRTY_STATUS_CACHE = /* @__PURE__ */ new Map();
+var COMPONENT_STATUS_PATH_CACHE = /* @__PURE__ */ new Map();
 async function resolveComponentStatusPaths(projectGitCwd, component, workflow) {
   const configured = workflow?.componentPaths?.[component];
   const configuredCandidates = Array.isArray(configured) ? configured.map((value) => String(value).trim()).filter(Boolean) : [];
@@ -3318,19 +3373,27 @@ async function resolveComponentStatusPaths(projectGitCwd, component, workflow) {
   const normalizedCandidates = uniqueNormalizedPaths(
     candidates.map((candidate) => {
       if (!candidate) return "";
-      if (!path17.isAbsolute(candidate)) return candidate;
-      const relative = path17.relative(projectGitCwd, candidate);
+      if (!path18.isAbsolute(candidate)) return candidate;
+      const relative = path18.relative(projectGitCwd, candidate);
       if (!relative) return "";
-      if (relative === ".." || relative.startsWith(`..${path17.sep}`)) return "";
+      if (relative === ".." || relative.startsWith(`..${path18.sep}`)) return "";
       return relative;
     }).filter(Boolean)
   );
+  const cacheKey = JSON.stringify({
+    projectGitCwd,
+    component,
+    normalizedCandidates
+  });
+  const cached = COMPONENT_STATUS_PATH_CACHE.get(cacheKey);
+  if (cached) return [...cached];
   const existing = [];
   for (const candidate of normalizedCandidates) {
-    if (await fs15.pathExists(path17.join(projectGitCwd, candidate))) {
+    if (await fs14.pathExists(path18.join(projectGitCwd, candidate))) {
       existing.push(candidate);
     }
   }
+  COMPONENT_STATUS_PATH_CACHE.set(cacheKey, [...existing]);
   return existing;
 }
 function parseTasks(content) {
@@ -3390,31 +3453,31 @@ async function parseFeature(featurePath, type, context, options) {
   const lang = options.lang;
   const workflowPolicy = resolveWorkflowPolicy(options.workflow);
   const prePrReviewPolicy = resolvePrePrReviewPolicy(options.workflow);
-  const folderName = path17.basename(featurePath);
+  const folderName = path18.basename(featurePath);
   const match = folderName.match(/^(F\d+)-(.+)$/);
   const id = match?.[1];
   const slug = match?.[2] || folderName;
-  const specPath = path17.join(featurePath, "spec.md");
-  const planPath = path17.join(featurePath, "plan.md");
-  const tasksPath = path17.join(featurePath, "tasks.md");
+  const specPath = path18.join(featurePath, "spec.md");
+  const planPath = path18.join(featurePath, "plan.md");
+  const tasksPath = path18.join(featurePath, "tasks.md");
   let specStatus;
   let issueNumber;
-  const specExists = await fs15.pathExists(specPath);
+  const specExists = await fs14.pathExists(specPath);
   if (specExists) {
-    const content = await fs15.readFile(specPath, "utf-8");
+    const content = await fs14.readFile(specPath, "utf-8");
     const statusValue = extractFirstSpecValue(content, ["\uC0C1\uD0DC", "Status"]);
     specStatus = parseDocStatus(statusValue);
     const issueValue = extractFirstSpecValue(content, ["\uC774\uC288 \uBC88\uD638", "Issue Number", "Issue"]);
     issueNumber = parseIssueNumber(issueValue);
   }
   let planStatus;
-  const planExists = await fs15.pathExists(planPath);
+  const planExists = await fs14.pathExists(planPath);
   if (planExists) {
-    const content = await fs15.readFile(planPath, "utf-8");
+    const content = await fs14.readFile(planPath, "utf-8");
     const statusValue = extractFirstSpecValue(content, ["\uC0C1\uD0DC", "Status"]);
     planStatus = parseDocStatus(statusValue);
   }
-  const tasksExists = await fs15.pathExists(tasksPath);
+  const tasksExists = await fs14.pathExists(tasksPath);
   const tasksSummary = { total: 0, todo: 0, doing: 0, done: 0 };
   let activeTask;
   let nextTodoTask;
@@ -3428,7 +3491,7 @@ async function parseFeature(featurePath, type, context, options) {
   let prStatusFieldExists = false;
   let prePrReviewFieldExists = false;
   if (tasksExists) {
-    const content = await fs15.readFile(tasksPath, "utf-8");
+    const content = await fs14.readFile(tasksPath, "utf-8");
     const { summary, activeTask: active, nextTodoTask: nextTodo } = parseTasks(content);
     tasksSummary.total = summary.total;
     tasksSummary.todo = summary.todo;
@@ -3470,44 +3533,77 @@ async function parseFeature(featurePath, type, context, options) {
     slug,
     folderName
   );
-  const relativeFeaturePathFromDocs = path17.relative(context.docsDir, featurePath);
-  const docsPathIgnored = isGitPathIgnored(
-    context.docsGitCwd,
-    relativeFeaturePathFromDocs
-  );
-  const docsStatus = getGitStatusPorcelain(context.docsGitCwd, [relativeFeaturePathFromDocs]);
-  const docsHasUncommittedChanges = docsStatus === void 0 ? true : docsStatus.trim().length > 0;
-  const dirtyScopePolicy = resolveCodeDirtyScopePolicy(options.workflow, options.projectType);
-  let projectStatusPaths = [];
-  if (context.projectGitCwd) {
-    if (dirtyScopePolicy === "component" && type !== "single") {
-      const componentStatusPaths = await resolveComponentStatusPaths(
-        context.projectGitCwd,
-        type,
-        options.workflow
-      );
-      projectStatusPaths = componentStatusPaths.length > 0 ? componentStatusPaths : resolveProjectStatusPaths(context.projectGitCwd, context.docsDir);
+  const relativeFeaturePathFromDocs = path18.relative(context.docsDir, featurePath);
+  const normalizedFeaturePathFromDocs = normalizeGitPath(relativeFeaturePathFromDocs);
+  const docsPathIgnored = typeof context.docsPathIgnored === "boolean" ? context.docsPathIgnored : isGitPathIgnored(context.docsGitCwd, normalizedFeaturePathFromDocs);
+  let docsHasUncommittedChanges = typeof context.docsHasUncommittedChanges === "boolean" ? context.docsHasUncommittedChanges : false;
+  let docsEverCommitted = typeof context.docsEverCommitted === "boolean" ? context.docsEverCommitted : false;
+  let docsGitUnavailable = !!context.docsGitUnavailable;
+  if (typeof context.docsHasUncommittedChanges !== "boolean") {
+    const docsStatus = getGitStatusPorcelain(context.docsGitCwd, [normalizedFeaturePathFromDocs]);
+    if (docsStatus === void 0) {
+      docsGitUnavailable = true;
+      docsHasUncommittedChanges = true;
+    } else {
+      docsHasUncommittedChanges = docsStatus.trim().length > 0;
+    }
+  }
+  if (typeof context.docsEverCommitted !== "boolean") {
+    const docsLastCommit = getLastCommitForPath(
+      context.docsGitCwd,
+      normalizedFeaturePathFromDocs
+    );
+    docsEverCommitted = !!docsLastCommit;
+  }
+  let projectHasUncommittedChanges = typeof context.projectHasUncommittedChanges === "boolean" ? context.projectHasUncommittedChanges : false;
+  let projectStatusUnavailable = !!context.projectStatusUnavailable;
+  if (typeof context.projectHasUncommittedChanges !== "boolean" && context.projectGitCwd) {
+    const dirtyScopePolicy = resolveCodeDirtyScopePolicy(options.workflow, options.projectType);
+    const projectCacheKey = JSON.stringify({
+      projectGitCwd: context.projectGitCwd,
+      docsDir: context.docsDir,
+      type,
+      dirtyScopePolicy,
+      componentPaths: options.workflow?.componentPaths?.[type] || []
+    });
+    const cachedStatus = PROJECT_DIRTY_STATUS_CACHE.get(projectCacheKey);
+    if (cachedStatus) {
+      projectHasUncommittedChanges = cachedStatus.hasUncommittedChanges;
+      projectStatusUnavailable = cachedStatus.statusUnavailable;
     } else {
-      projectStatusPaths = resolveProjectStatusPaths(
+      let projectStatusPaths = [];
+      if (dirtyScopePolicy === "component" && type !== "single") {
+        const componentStatusPaths = await resolveComponentStatusPaths(
+          context.projectGitCwd,
+          type,
+          options.workflow
+        );
+        projectStatusPaths = componentStatusPaths.length > 0 ? componentStatusPaths : resolveProjectStatusPaths(context.projectGitCwd, context.docsDir);
+      } else {
+        projectStatusPaths = resolveProjectStatusPaths(
+          context.projectGitCwd,
+          context.docsDir
+        );
+      }
+      const projectStatus = getGitStatusPorcelain(
         context.projectGitCwd,
-        context.docsDir
+        projectStatusPaths
       );
+      projectStatusUnavailable = projectStatus === void 0;
+      projectHasUncommittedChanges = projectStatus === void 0 ? false : projectStatus.trim().length > 0;
+      PROJECT_DIRTY_STATUS_CACHE.set(projectCacheKey, {
+        hasUncommittedChanges: projectHasUncommittedChanges,
+        statusUnavailable: projectStatusUnavailable
+      });
     }
   }
-  const projectStatus = context.projectGitCwd ? getGitStatusPorcelain(context.projectGitCwd, projectStatusPaths) : void 0;
-  const projectHasUncommittedChanges = projectStatus === void 0 ? false : projectStatus.trim().length > 0;
-  const docsLastCommit = getLastCommitForPath(
-    context.docsGitCwd,
-    relativeFeaturePathFromDocs
-  );
-  const docsEverCommitted = !!docsLastCommit;
-  if (docsStatus === void 0) {
+  if (docsGitUnavailable) {
     warnings.push(tr(lang, "warnings", "docsGitUnavailable"));
   }
   if (docsPathIgnored === true) {
     warnings.push(
       tr(lang, "warnings", "docsPathIgnored", {
-        path: relativeFeaturePathFromDocs
+        path: normalizedFeaturePathFromDocs
       })
     );
   }
@@ -3612,90 +3708,181 @@ async function parseFeature(featurePath, type, context, options) {
   );
   return { ...featureState, currentStep, actions, nextAction, warnings };
 }
+function normalizeRelPath(value) {
+  return value.replace(/\\/g, "/").replace(/^\.\/+/, "").replace(/\/+$/, "");
+}
+function parsePorcelainChangedPaths(porcelain) {
+  const changed = [];
+  for (const rawLine of porcelain.split("\n")) {
+    if (!rawLine.trim()) continue;
+    const payload = rawLine.slice(3).trim();
+    if (!payload) continue;
+    const pathCandidate = payload.includes(" -> ") ? payload.split(" -> ").at(-1) || "" : payload;
+    const normalized = normalizeRelPath(pathCandidate.replace(/^"+|"+$/g, ""));
+    if (!normalized) continue;
+    changed.push(normalized);
+  }
+  return changed;
+}
+function findFeaturePathPrefix(normalizedPath, relativeFeaturePaths) {
+  for (const featurePath of relativeFeaturePaths) {
+    if (normalizedPath === featurePath) return featurePath;
+    if (normalizedPath.startsWith(`${featurePath}/`)) return featurePath;
+    const nestedPrefix = `/${featurePath}`;
+    if (normalizedPath.endsWith(nestedPrefix)) return featurePath;
+    if (normalizedPath.includes(`${nestedPrefix}/`)) return featurePath;
+  }
+  return void 0;
+}
+function buildDefaultDocsFeatureGitMeta(relativeFeaturePaths) {
+  const map = /* @__PURE__ */ new Map();
+  for (const featurePath of relativeFeaturePaths) {
+    map.set(featurePath, {
+      docsPathIgnored: false,
+      docsHasUncommittedChanges: false,
+      docsEverCommitted: false,
+      docsGitUnavailable: false
+    });
+  }
+  return map;
+}
+function buildDocsFeatureGitMeta(docsGitCwd, relativeFeaturePaths) {
+  const normalizedFeaturePaths = relativeFeaturePaths.map(
+    (value) => normalizeRelPath(value)
+  );
+  const map = buildDefaultDocsFeatureGitMeta(normalizedFeaturePaths);
+  if (normalizedFeaturePaths.length === 0) return map;
+  const docsStatus = getGitStatusPorcelain(docsGitCwd, normalizedFeaturePaths);
+  if (docsStatus === void 0) {
+    for (const featurePath of normalizedFeaturePaths) {
+      const current = map.get(featurePath);
+      if (!current) continue;
+      current.docsGitUnavailable = true;
+      current.docsHasUncommittedChanges = true;
+    }
+  } else {
+    const changedPaths = parsePorcelainChangedPaths(docsStatus);
+    for (const changedPath of changedPaths) {
+      const featurePath = findFeaturePathPrefix(changedPath, normalizedFeaturePaths);
+      if (!featurePath) continue;
+      const current = map.get(featurePath);
+      if (!current) continue;
+      current.docsHasUncommittedChanges = true;
+    }
+  }
+  const trackedPaths = getTrackedGitPaths(docsGitCwd, normalizedFeaturePaths);
+  if (trackedPaths) {
+    for (const trackedPath of trackedPaths) {
+      const featurePath = findFeaturePathPrefix(
+        normalizeRelPath(trackedPath),
+        normalizedFeaturePaths
+      );
+      if (!featurePath) continue;
+      const current = map.get(featurePath);
+      if (!current) continue;
+      current.docsEverCommitted = true;
+    }
+  }
+  const ignoredPaths = getIgnoredGitPaths(docsGitCwd, normalizedFeaturePaths);
+  if (ignoredPaths) {
+    for (const ignoredPath of ignoredPaths) {
+      const featurePath = findFeaturePathPrefix(
+        normalizeRelPath(ignoredPath),
+        normalizedFeaturePaths
+      );
+      if (!featurePath) continue;
+      const current = map.get(featurePath);
+      if (!current) continue;
+      current.docsPathIgnored = true;
+    }
+  }
+  return map;
+}
 async function scanFeatures(config) {
   const features = [];
   const warnings = [];
   const stepDefinitions = getStepDefinitions(config.lang, config.workflow);
   const docsBranch = getCurrentBranch(config.docsDir);
   const projectBranches = {};
+  const projectGitCwds = {};
   let singleProject;
   if (config.projectType === "single") {
     singleProject = resolveProjectGitCwd(config, "single", config.lang);
     if (singleProject.warning) warnings.push(singleProject.warning);
     projectBranches.single = singleProject.cwd ? getCurrentBranch(singleProject.cwd) : "";
+    projectGitCwds.single = singleProject.cwd ?? void 0;
   } else {
     const components = resolveProjectComponents(config.projectType, config.components);
     for (const component of components) {
       const project = resolveProjectGitCwd(config, component, config.lang);
       if (project.warning) warnings.push(project.warning);
       projectBranches[component] = project.cwd ? getCurrentBranch(project.cwd) : "";
+      projectGitCwds[component] = project.cwd ?? void 0;
     }
   }
+  const allFeatureDirs = [];
+  const componentFeatureDirs = /* @__PURE__ */ new Map();
   if (config.projectType === "single") {
     const featureDirs = await glob("features/*/", {
       cwd: config.docsDir,
       absolute: true,
       ignore: ["**/feature-base/**"]
     });
-    for (const dir of featureDirs) {
-      if ((await fs15.stat(dir)).isDirectory()) {
-        features.push(
-          await parseFeature(
-            dir,
-            "single",
-            {
-              projectBranch: projectBranches.single,
-              docsBranch,
-              docsGitCwd: config.docsDir,
-              projectGitCwd: singleProject?.cwd ?? void 0,
-              docsDir: config.docsDir,
-              projectBranchAvailable: Boolean(singleProject?.cwd)
-            },
-            {
-              lang: config.lang,
-              stepDefinitions,
-              approval: config.approval,
-              workflow: config.workflow,
-              projectType: config.projectType
-            }
-          )
-        );
-      }
-    }
+    componentFeatureDirs.set("single", featureDirs);
+    allFeatureDirs.push(...featureDirs);
   } else {
     const components = resolveProjectComponents(config.projectType, config.components);
     for (const component of components) {
-      const project = resolveProjectGitCwd(config, component, config.lang);
       const componentDirs = await glob(`features/${component}/*/`, {
         cwd: config.docsDir,
         absolute: true
       });
-      for (const dir of componentDirs) {
-        if (!(await fs15.stat(dir)).isDirectory()) continue;
-        features.push(
-          await parseFeature(
-            dir,
-            component,
-            {
-              projectBranch: projectBranches[component] || "",
-              docsBranch,
-              docsGitCwd: config.docsDir,
-              projectGitCwd: project.cwd ?? void 0,
-              docsDir: config.docsDir,
-              projectBranchAvailable: Boolean(project.cwd)
-            },
-            {
-              lang: config.lang,
-              stepDefinitions,
-              approval: config.approval,
-              workflow: config.workflow,
-              projectType: config.projectType
-            }
-          )
-        );
-      }
+      componentFeatureDirs.set(component, componentDirs);
+      allFeatureDirs.push(...componentDirs);
     }
   }
+  const relativeFeaturePaths = allFeatureDirs.map(
+    (dir) => normalizeRelPath(path18.relative(config.docsDir, dir))
+  );
+  const docsGitMeta = buildDocsFeatureGitMeta(config.docsDir, relativeFeaturePaths);
+  const parseTargets = config.projectType === "single" ? [{ type: "single", dirs: componentFeatureDirs.get("single") || [] }] : resolveProjectComponents(config.projectType, config.components).map((component) => ({
+    type: component,
+    dirs: componentFeatureDirs.get(component) || []
+  }));
+  for (const target of parseTargets) {
+    const parsed = await Promise.all(
+      target.dirs.map(async (dir) => {
+        const relativeFeaturePathFromDocs = normalizeRelPath(
+          path18.relative(config.docsDir, dir)
+        );
+        const docsMeta = docsGitMeta.get(relativeFeaturePathFromDocs);
+        return parseFeature(
+          dir,
+          target.type,
+          {
+            projectBranch: projectBranches[target.type] || "",
+            docsBranch,
+            docsGitCwd: config.docsDir,
+            projectGitCwd: projectGitCwds[target.type],
+            docsDir: config.docsDir,
+            projectBranchAvailable: Boolean(projectGitCwds[target.type]),
+            docsPathIgnored: docsMeta?.docsPathIgnored,
+            docsHasUncommittedChanges: docsMeta?.docsHasUncommittedChanges,
+            docsEverCommitted: docsMeta?.docsEverCommitted,
+            docsGitUnavailable: docsMeta?.docsGitUnavailable
+          },
+          {
+            lang: config.lang,
+            stepDefinitions,
+            approval: config.approval,
+            workflow: config.workflow,
+            projectType: config.projectType
+          }
+        );
+      })
+    );
+    features.push(...parsed);
+  }
   return {
     features,
     branches: {
@@ -3735,13 +3922,13 @@ async function runStatus(options) {
     );
   }
   const { docsDir, projectType, projectName, lang } = config;
-  const featuresDir = path17.join(docsDir, "features");
+  const featuresDir = path18.join(docsDir, "features");
   const scan = await scanFeatures(config);
   const features = [];
   const idMap = /* @__PURE__ */ new Map();
   for (const f of scan.features) {
     const id = f.id || "UNKNOWN";
-    const relPath = path17.relative(docsDir, f.path);
+    const relPath = path18.relative(docsDir, f.path);
     if (!idMap.has(id)) idMap.set(id, []);
     idMap.get(id).push(relPath);
     if (!f.docs.specExists || !f.docs.tasksExists) continue;
@@ -3822,7 +4009,7 @@ async function runStatus(options) {
   }
   console.log();
   if (options.write) {
-    const outputPath = path17.join(featuresDir, "status.md");
+    const outputPath = path18.join(featuresDir, "status.md");
     const date = getLocalDateString();
     const content = [
       "# Feature Status",
@@ -3837,7 +4024,7 @@ async function runStatus(options) {
       ),
       ""
     ].join("\n");
-    await fs15.writeFile(outputPath, content, "utf-8");
+    await fs14.writeFile(outputPath, content, "utf-8");
     console.log(
       chalk6.green(
         tr(lang, "cli", "status.wrote", { path: outputPath })
@@ -3850,9 +4037,9 @@ function escapeRegExp2(value) {
 }
 async function getFeatureNameFromSpec(featureDir, fallbackSlug, fallbackFolderName) {
   try {
-    const specPath = path17.join(featureDir, "spec.md");
-    if (!await fs15.pathExists(specPath)) return fallbackSlug;
-    const content = await fs15.readFile(specPath, "utf-8");
+    const specPath = path18.join(featureDir, "spec.md");
+    if (!await fs14.pathExists(specPath)) return fallbackSlug;
+    const content = await fs14.readFile(specPath, "utf-8");
     const keys = ["\uAE30\uB2A5\uBA85", "Feature Name"];
     for (const key of keys) {
       const regex = new RegExp(
@@ -3931,17 +4118,17 @@ async function runUpdate(options) {
           console.log(chalk6.blue(tr(lang, "cli", "update.updatingAgents")));
         }
         if (agentsMode === "all") {
-          const commonAgentsBase = path17.join(templatesDir, lang, "common", "agents");
-          const typeAgentsBase = path17.join(
+          const commonAgentsBase = path18.join(templatesDir, lang, "common", "agents");
+          const typeAgentsBase = path18.join(
             templatesDir,
             lang,
             toTemplateProjectType(projectType),
             "agents"
           );
-          const targetAgentsBase = path17.join(docsDir, "agents");
-          const commonAgents = agentsMode === "skills" ? path17.join(commonAgentsBase, "skills") : commonAgentsBase;
-          const typeAgents = agentsMode === "skills" ? path17.join(typeAgentsBase, "skills") : typeAgentsBase;
-          const targetAgents = agentsMode === "skills" ? path17.join(targetAgentsBase, "skills") : targetAgentsBase;
+          const targetAgentsBase = path18.join(docsDir, "agents");
+          const commonAgents = agentsMode === "skills" ? path18.join(commonAgentsBase, "skills") : commonAgentsBase;
+          const typeAgents = agentsMode === "skills" ? path18.join(typeAgentsBase, "skills") : typeAgentsBase;
+          const targetAgents = agentsMode === "skills" ? path18.join(targetAgentsBase, "skills") : targetAgentsBase;
           const featurePath = projectType === "multi" ? isDefaultFullstackComponents(config.components || []) ? "docs/features/{be|fe}" : "docs/features/{component}" : "docs/features";
           const projectName = config.projectName ?? "{{projectName}}";
           const commonReplacements = {
@@ -3951,7 +4138,7 @@ async function runUpdate(options) {
           const typeReplacements = {
             "{{projectName}}": projectName
           };
-          if (await fs15.pathExists(commonAgents)) {
+          if (await fs14.pathExists(commonAgents)) {
             const count = await updateFolder(
               commonAgents,
               targetAgents,
@@ -3969,7 +4156,7 @@ async function runUpdate(options) {
             );
             updatedCount += count;
           }
-          if (await fs15.pathExists(typeAgents)) {
+          if (await fs14.pathExists(typeAgents)) {
             const count = await updateFolder(
               typeAgents,
               targetAgents,
@@ -4019,24 +4206,24 @@ async function runUpdate(options) {
 async function updateFolder(sourceDir, targetDir, force, replacements, lang = DEFAULT_LANG, options = {}) {
   const protectedFiles = options.protectedFiles ?? /* @__PURE__ */ new Set(["custom.md", "constitution.md"]);
   const skipDirectories = options.skipDirectories ?? /* @__PURE__ */ new Set();
-  await fs15.ensureDir(targetDir);
-  const files = await fs15.readdir(sourceDir);
+  await fs14.ensureDir(targetDir);
+  const files = await fs14.readdir(sourceDir);
   let updatedCount = 0;
   for (const file of files) {
-    const sourcePath = path17.join(sourceDir, file);
-    const targetPath = path17.join(targetDir, file);
-    const stat = await fs15.stat(sourcePath);
+    const sourcePath = path18.join(sourceDir, file);
+    const targetPath = path18.join(targetDir, file);
+    const stat = await fs14.stat(sourcePath);
     if (stat.isFile()) {
       if (protectedFiles.has(file)) {
         continue;
       }
-      let sourceContent = await fs15.readFile(sourcePath, "utf-8");
+      let sourceContent = await fs14.readFile(sourcePath, "utf-8");
       if (replacements) {
         sourceContent = applyReplacements(sourceContent, replacements);
       }
       let shouldUpdate = true;
-      if (await fs15.pathExists(targetPath)) {
-        const targetContent = await fs15.readFile(targetPath, "utf-8");
+      if (await fs14.pathExists(targetPath)) {
+        const targetContent = await fs14.readFile(targetPath, "utf-8");
         if (sourceContent === targetContent) {
           continue;
         }
@@ -4050,7 +4237,7 @@ async function updateFolder(sourceDir, targetDir, force, replacements, lang = DE
         }
       }
       if (shouldUpdate) {
-        await fs15.writeFile(targetPath, sourceContent);
+        await fs14.writeFile(targetPath, sourceContent);
         console.log(
           chalk6.gray(`  \u{1F4C4} ${tr(lang, "cli", "update.fileUpdated", { file })}`)
         );
@@ -4107,7 +4294,7 @@ function extractPorcelainPaths(line) {
 function getDocsPorcelainStatus(docsDir, ignoredAbsPaths = []) {
   const top = getGitTopLevel2(docsDir);
   if (!top) return null;
-  const rel = path17.relative(top, docsDir) || ".";
+  const rel = path18.relative(top, docsDir) || ".";
   try {
     const output = execFileSync("git", ["status", "--porcelain=v1", "--", rel], {
       cwd: top,
@@ -4119,7 +4306,7 @@ function getDocsPorcelainStatus(docsDir, ignoredAbsPaths = []) {
     }
     const ignoredRelPaths = new Set(
       ignoredAbsPaths.map(
-        (absPath) => normalizeGitPath2(path17.relative(top, absPath) || ".")
+        (absPath) => normalizeGitPath2(path18.relative(top, absPath) || ".")
       )
     );
     const filtered = output.split("\n").filter((line) => {
@@ -4176,7 +4363,7 @@ ${tr(lang2, "cli", "common.canceled")}`));
 }
 async function runConfig(options) {
   const cwd = process.cwd();
-  const targetCwd = options.dir ? path17.resolve(cwd, options.dir) : cwd;
+  const targetCwd = options.dir ? path18.resolve(cwd, options.dir) : cwd;
   const config = await getConfig(targetCwd);
   if (!config) {
     throw createCliError(
@@ -4184,7 +4371,7 @@ async function runConfig(options) {
       tr(DEFAULT_LANG, "cli", "common.configNotFound")
     );
   }
-  const configPath = path17.join(config.docsDir, ".lee-spec-kit.json");
+  const configPath = path18.join(config.docsDir, ".lee-spec-kit.json");
   if (!options.projectRoot) {
     console.log();
     console.log(chalk6.blue(tr(config.lang, "cli", "config.currentTitle")));
@@ -4195,7 +4382,7 @@ async function runConfig(options) {
       )
     );
     console.log();
-    const configFile = await fs15.readJson(configPath);
+    const configFile = await fs14.readJson(configPath);
     console.log(JSON.stringify(configFile, null, 2));
     console.log();
     return;
@@ -4203,7 +4390,7 @@ async function runConfig(options) {
   await withFileLock(
     getDocsLockPath(config.docsDir),
     async () => {
-      const configFile = await fs15.readJson(configPath);
+      const configFile = await fs14.readJson(configPath);
       if (configFile.docsRepo !== "standalone") {
         console.log(
           chalk6.yellow(tr(config.lang, "cli", "config.projectRootStandaloneOnly"))
@@ -4282,7 +4469,7 @@ async function runConfig(options) {
           )
         );
       }
-      await fs15.writeJson(configPath, configFile, { spaces: 2 });
+      await fs14.writeJson(configPath, configFile, { spaces: 2 });
       console.log();
     },
     { owner: "config" }
@@ -4536,42 +4723,42 @@ var BUILTIN_DOC_DEFINITIONS = [
   {
     id: "agents",
     title: { ko: "\uC5D0\uC774\uC804\uD2B8 \uC6B4\uC601 \uADDC\uCE59", en: "Agent Operating Rules" },
-    relativePath: (projectType, lang) => path17.join(lang, toTemplateProjectType(projectType), "agents", "agents.md")
+    relativePath: (projectType, lang) => path18.join(lang, toTemplateProjectType(projectType), "agents", "agents.md")
   },
   {
     id: "git-workflow",
     title: { ko: "Git \uC6CC\uD06C\uD50C\uB85C\uC6B0", en: "Git Workflow" },
-    relativePath: (_, lang) => path17.join(lang, "common", "agents", "git-workflow.md")
+    relativePath: (_, lang) => path18.join(lang, "common", "agents", "git-workflow.md")
   },
   {
     id: "issue-template",
     title: { ko: "Issue \uD15C\uD50C\uB9BF", en: "Issue Template" },
-    relativePath: (_, lang) => path17.join(lang, "common", "agents", "issue-template.md")
+    relativePath: (_, lang) => path18.join(lang, "common", "agents", "issue-template.md")
   },
   {
     id: "pr-template",
     title: { ko: "PR \uD15C\uD50C\uB9BF", en: "PR Template" },
-    relativePath: (_, lang) => path17.join(lang, "common", "agents", "pr-template.md")
+    relativePath: (_, lang) => path18.join(lang, "common", "agents", "pr-template.md")
   },
   {
     id: "create-feature",
     title: { ko: "create-feature \uC2A4\uD0AC", en: "create-feature skill" },
-    relativePath: (_, lang) => path17.join(lang, "common", "agents", "skills", "create-feature.md")
+    relativePath: (_, lang) => path18.join(lang, "common", "agents", "skills", "create-feature.md")
   },
   {
     id: "execute-task",
     title: { ko: "execute-task \uC2A4\uD0AC", en: "execute-task skill" },
-    relativePath: (_, lang) => path17.join(lang, "common", "agents", "skills", "execute-task.md")
+    relativePath: (_, lang) => path18.join(lang, "common", "agents", "skills", "execute-task.md")
   },
   {
     id: "create-issue",
     title: { ko: "create-issue \uC2A4\uD0AC", en: "create-issue skill" },
-    relativePath: (_, lang) => path17.join(lang, "common", "agents", "skills", "create-issue.md")
+    relativePath: (_, lang) => path18.join(lang, "common", "agents", "skills", "create-issue.md")
   },
   {
     id: "create-pr",
     title: { ko: "create-pr \uC2A4\uD0AC", en: "create-pr skill" },
-    relativePath: (_, lang) => path17.join(lang, "common", "agents", "skills", "create-pr.md")
+    relativePath: (_, lang) => path18.join(lang, "common", "agents", "skills", "create-pr.md")
   }
 ];
 var DOC_FOLLOWUPS = {
@@ -4655,7 +4842,7 @@ function listBuiltinDocs(projectType, lang) {
       id: doc.id,
       title: doc.title[lang],
       relativePath,
-      absolutePath: path17.join(templatesDir, relativePath)
+      absolutePath: path18.join(templatesDir, relativePath)
     };
   });
 }
@@ -4664,7 +4851,7 @@ async function getBuiltinDoc(docId, projectType, lang) {
   if (!entry) {
     throw new Error(`Unknown builtin doc: ${docId}`);
   }
-  const content = await fs15.readFile(entry.absolutePath, "utf-8");
+  const content = await fs14.readFile(entry.absolutePath, "utf-8");
   const hash = createHash("sha256").update(content).digest("hex").slice(0, 12);
   return {
     entry,
@@ -4749,7 +4936,7 @@ function getCommandExecutionLockPath(action, config) {
   if (action.scope === "docs") {
     return getDocsLockPath(config.docsDir);
   }
-  return path17.join(action.cwd, ".lee-spec-kit.project.lock");
+  return path18.join(action.cwd, ".lee-spec-kit.project.lock");
 }
 function contextCommand(program2) {
   program2.command("context [feature-name]").description("Show current feature context and next actions").option("--json", "Output in JSON format for agents").option("--repo <repo>", "Component name for multi projects").option("--component <component>", "Component name for multi projects").option("--all", "Include completed features when auto-detecting").option("--done", "Show completed (workflow-done) features only").option("--approve <reply>", "Approve one labeled option: A or A OK").option("--execute", "Execute approved option when it is a command").option(
@@ -5143,7 +5330,7 @@ async function runContext(featureName, options) {
   if (f.issueNumber) {
     console.log(`   \u2022 Issue: #${f.issueNumber}`);
   }
-  console.log(`   \u2022 Path: ${path17.relative(cwd, f.path)}`);
+  console.log(`   \u2022 Path: ${path18.relative(cwd, f.path)}`);
   if (f.git.projectBranch) {
     console.log(`   \u2022 Project Branch: ${f.git.projectBranch}`);
   }
@@ -5397,7 +5584,7 @@ var FIXABLE_ISSUE_CODES = /* @__PURE__ */ new Set([
 ]);
 function formatPath(cwd, p) {
   if (!p) return "";
-  return path17.isAbsolute(p) ? path17.relative(cwd, p) : p;
+  return path18.isAbsolute(p) ? path18.relative(cwd, p) : p;
 }
 function detectPlaceholders(content) {
   const patterns = [
@@ -5540,7 +5727,7 @@ async function applyDoctorFixes(config, cwd, features, dryRun) {
     const placeholderContext = {
       projectName: config.projectName,
       featureName: f.slug,
-      featurePath: f.docs.featurePathFromDocs || path17.relative(config.docsDir, f.path),
+      featurePath: f.docs.featurePathFromDocs || path18.relative(config.docsDir, f.path),
       repoType: f.type,
       featureNumber
     };
@@ -5550,9 +5737,9 @@ async function applyDoctorFixes(config, cwd, features, dryRun) {
       "tasks.md"
     ];
     for (const file of files) {
-      const fullPath = path17.join(f.path, file);
-      if (!await fs15.pathExists(fullPath)) continue;
-      const original = await fs15.readFile(fullPath, "utf-8");
+      const fullPath = path18.join(f.path, file);
+      if (!await fs14.pathExists(fullPath)) continue;
+      const original = await fs14.readFile(fullPath, "utf-8");
       let next = original;
       const changes = [];
       const placeholderFix = applyPlaceholderFixes(next, placeholderContext, config.lang);
@@ -5576,7 +5763,7 @@ async function applyDoctorFixes(config, cwd, features, dryRun) {
       }
       if (next === original) continue;
       if (!dryRun) {
-        await fs15.writeFile(fullPath, next, "utf-8");
+        await fs14.writeFile(fullPath, next, "utf-8");
       }
       entries.push({
         path: formatPath(cwd, fullPath),
@@ -5595,8 +5782,8 @@ async function checkDocsStructure(config, cwd) {
   const issues = [];
   const requiredDirs = ["agents", "features", "prd", "designs", "ideas"];
   for (const dir of requiredDirs) {
-    const p = path17.join(config.docsDir, dir);
-    if (!await fs15.pathExists(p)) {
+    const p = path18.join(config.docsDir, dir);
+    if (!await fs14.pathExists(p)) {
       issues.push({
         level: "error",
         code: "missing_dir",
@@ -5605,8 +5792,8 @@ async function checkDocsStructure(config, cwd) {
       });
     }
   }
-  const configPath = path17.join(config.docsDir, ".lee-spec-kit.json");
-  if (!await fs15.pathExists(configPath)) {
+  const configPath = path18.join(config.docsDir, ".lee-spec-kit.json");
+  if (!await fs14.pathExists(configPath)) {
     issues.push({
       level: "warn",
       code: "missing_config",
@@ -5628,7 +5815,7 @@ async function checkFeatures(config, cwd, features, decisionsPlaceholderMode) {
   }
   const idMap = /* @__PURE__ */ new Map();
   for (const f of features) {
-    const rel = f.docs.featurePathFromDocs || path17.relative(config.docsDir, f.path);
+    const rel = f.docs.featurePathFromDocs || path18.relative(config.docsDir, f.path);
     const id = f.id || "UNKNOWN";
     if (!idMap.has(id)) idMap.set(id, []);
     idMap.get(id).push(rel);
@@ -5636,9 +5823,9 @@ async function checkFeatures(config, cwd, features, decisionsPlaceholderMode) {
     if (!isInitialTemplateState) {
       const featureDocs = ["spec.md", "plan.md", "tasks.md"];
       for (const file of featureDocs) {
-        const p = path17.join(f.path, file);
-        if (!await fs15.pathExists(p)) continue;
-        const content = await fs15.readFile(p, "utf-8");
+        const p = path18.join(f.path, file);
+        if (!await fs14.pathExists(p)) continue;
+        const content = await fs14.readFile(p, "utf-8");
         const placeholders = detectPlaceholders(content);
         if (placeholders.length === 0) continue;
         issues.push({
@@ -5651,9 +5838,9 @@ async function checkFeatures(config, cwd, features, decisionsPlaceholderMode) {
         });
       }
       if (decisionsPlaceholderMode !== "off") {
-        const decisionsPath = path17.join(f.path, "decisions.md");
-        if (await fs15.pathExists(decisionsPath)) {
-          const content = await fs15.readFile(decisionsPath, "utf-8");
+        const decisionsPath = path18.join(f.path, "decisions.md");
+        if (await fs14.pathExists(decisionsPath)) {
+          const content = await fs14.readFile(decisionsPath, "utf-8");
           const placeholders = detectPlaceholders(content);
           if (placeholders.length > 0) {
             issues.push({
@@ -5680,7 +5867,7 @@ async function checkFeatures(config, cwd, features, decisionsPlaceholderMode) {
         level: "warn",
         code: "spec_status_unset",
         message: tr(config.lang, "cli", "doctor.issue.specStatusUnset"),
-        path: formatPath(cwd, path17.join(f.path, "spec.md"))
+        path: formatPath(cwd, path18.join(f.path, "spec.md"))
       });
     }
     if (f.docs.planExists && !f.planStatus && !isInitialTemplateState) {
@@ -5688,7 +5875,7 @@ async function checkFeatures(config, cwd, features, decisionsPlaceholderMode) {
         level: "warn",
         code: "plan_status_unset",
         message: tr(config.lang, "cli", "doctor.issue.planStatusUnset"),
-        path: formatPath(cwd, path17.join(f.path, "plan.md"))
+        path: formatPath(cwd, path18.join(f.path, "plan.md"))
       });
     }
     if (f.docs.tasksExists && f.tasks.total === 0 && !isInitialTemplateState) {
@@ -5696,7 +5883,7 @@ async function checkFeatures(config, cwd, features, decisionsPlaceholderMode) {
         level: "warn",
         code: "tasks_empty",
         message: tr(config.lang, "cli", "doctor.issue.tasksEmpty"),
-        path: formatPath(cwd, path17.join(f.path, "tasks.md"))
+        path: formatPath(cwd, path18.join(f.path, "tasks.md"))
       });
     }
     if (f.docs.tasksExists && !f.docs.tasksDocStatusFieldExists && !isInitialTemplateState) {
@@ -5704,7 +5891,7 @@ async function checkFeatures(config, cwd, features, decisionsPlaceholderMode) {
         level: "warn",
         code: "tasks_doc_status_missing",
         message: tr(config.lang, "cli", "doctor.issue.tasksDocStatusMissing"),
-        path: formatPath(cwd, path17.join(f.path, "tasks.md"))
+        path: formatPath(cwd, path18.join(f.path, "tasks.md"))
       });
     }
     if (f.docs.tasksExists && f.docs.tasksDocStatusFieldExists && !f.tasksDocStatus && !isInitialTemplateState) {
@@ -5712,7 +5899,7 @@ async function checkFeatures(config, cwd, features, decisionsPlaceholderMode) {
         level: "warn",
         code: "tasks_doc_status_unset",
         message: tr(config.lang, "cli", "doctor.issue.tasksDocStatusUnset"),
-        path: formatPath(cwd, path17.join(f.path, "tasks.md"))
+        path: formatPath(cwd, path18.join(f.path, "tasks.md"))
       });
     }
   }
@@ -5736,7 +5923,7 @@ async function checkFeatures(config, cwd, features, decisionsPlaceholderMode) {
       level: "warn",
       code: "missing_feature_id",
       message: tr(config.lang, "cli", "doctor.issue.missingFeatureId"),
-      path: formatPath(cwd, path17.join(config.docsDir, p))
+      path: formatPath(cwd, path18.join(config.docsDir, p))
     });
   }
   return issues;
@@ -5858,7 +6045,7 @@ function doctorCommand(program2) {
       }
       console.log();
       console.log(chalk6.bold(tr(lang, "cli", "doctor.title")));
-      console.log(chalk6.gray(`- Docs: ${path17.relative(cwd, docsDir)}`));
+      console.log(chalk6.gray(`- Docs: ${path18.relative(cwd, docsDir)}`));
       console.log(chalk6.gray(`- Type: ${projectType}`));
       console.log(chalk6.gray(`- Lang: ${lang}`));
       console.log();
@@ -6037,7 +6224,7 @@ async function runView(featureName, options) {
   }
   console.log();
   console.log(chalk6.bold("\u{1F4CA} Workflow View"));
-  console.log(chalk6.gray(`- Docs: ${path17.relative(cwd, config.docsDir)}`));
+  console.log(chalk6.gray(`- Docs: ${path18.relative(cwd, config.docsDir)}`));
   console.log(
     chalk6.gray(
       `- Features: ${state.features.length} (open ${state.openFeatures.length} / done ${state.doneFeatures.length})`
@@ -6387,40 +6574,40 @@ function tg(lang, key, vars = {}) {
 }
 function detectGithubCliLangSync(cwd) {
   const explicitDocsDir = (process.env.LEE_SPEC_KIT_DOCS_DIR || "").trim();
-  const startDirs = [explicitDocsDir ? path17.resolve(explicitDocsDir) : "", path17.resolve(cwd)].filter(Boolean);
+  const startDirs = [explicitDocsDir ? path18.resolve(explicitDocsDir) : "", path18.resolve(cwd)].filter(Boolean);
   const scanOrder = [];
   const seen = /* @__PURE__ */ new Set();
   for (const start of startDirs) {
     let current = start;
     while (true) {
-      const abs = path17.resolve(current);
+      const abs = path18.resolve(current);
       if (!seen.has(abs)) {
         scanOrder.push(abs);
         seen.add(abs);
       }
-      const parent = path17.dirname(abs);
+      const parent = path18.dirname(abs);
       if (parent === abs) break;
       current = parent;
     }
   }
   for (const base of scanOrder) {
-    for (const docsDir of [path17.join(base, "docs"), base]) {
-      const configPath = path17.join(docsDir, ".lee-spec-kit.json");
-      if (fs15.existsSync(configPath)) {
+    for (const docsDir of [path18.join(base, "docs"), base]) {
+      const configPath = path18.join(docsDir, ".lee-spec-kit.json");
+      if (fs14.existsSync(configPath)) {
         try {
-          const parsed = fs15.readJsonSync(configPath);
+          const parsed = fs14.readJsonSync(configPath);
           if (parsed?.lang === "ko" || parsed?.lang === "en") return parsed.lang;
         } catch {
         }
       }
-      const agentsPath = path17.join(docsDir, "agents");
-      const featuresPath = path17.join(docsDir, "features");
-      if (!fs15.existsSync(agentsPath) || !fs15.existsSync(featuresPath)) continue;
+      const agentsPath = path18.join(docsDir, "agents");
+      const featuresPath = path18.join(docsDir, "features");
+      if (!fs14.existsSync(agentsPath) || !fs14.existsSync(featuresPath)) continue;
       for (const probe of ["custom.md", "constitution.md", "agents.md"]) {
-        const file = path17.join(agentsPath, probe);
-        if (!fs15.existsSync(file)) continue;
+        const file = path18.join(agentsPath, probe);
+        if (!fs14.existsSync(file)) continue;
         try {
-          const content = fs15.readFileSync(file, "utf-8");
+          const content = fs14.readFileSync(file, "utf-8");
           if (/[가-힣]/.test(content)) return "ko";
         } catch {
         }
@@ -6521,7 +6708,7 @@ function ensureSections(body, sections, kind, lang) {
 }
 function ensureDocsExist(docsDir, relativePaths, lang) {
   const missing = relativePaths.filter(
-    (relativePath) => !fs15.existsSync(path17.join(docsDir, relativePath))
+    (relativePath) => !fs14.existsSync(path18.join(docsDir, relativePath))
   );
   if (missing.length > 0) {
     throw createCliError(
@@ -6531,13 +6718,13 @@ function ensureDocsExist(docsDir, relativePaths, lang) {
   }
 }
 function buildDefaultBodyFileName(kind, docsDir, component) {
-  const key = `${path17.resolve(docsDir)}::${component.trim().toLowerCase()}`;
+  const key = `${path18.resolve(docsDir)}::${component.trim().toLowerCase()}`;
   const digest = createHash("sha1").update(key).digest("hex").slice(0, 12);
   return `lee-spec-kit.${digest}.${kind}.md`;
 }
 function toBodyFilePath(raw, kind, docsDir, component) {
-  const selected = raw?.trim() || path17.join(os.tmpdir(), buildDefaultBodyFileName(kind, docsDir, component));
-  return path17.resolve(selected);
+  const selected = raw?.trim() || path18.join(os.tmpdir(), buildDefaultBodyFileName(kind, docsDir, component));
+  return path18.resolve(selected);
 }
 function toProjectRootDocsPath(relativePathFromDocs) {
   const normalized = relativePathFromDocs.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
@@ -7264,10 +7451,10 @@ function insertFieldInGithubIssueSection(content, key, value) {
   return { content: lines.join("\n"), changed: true };
 }
 function syncTasksPrMetadata(tasksPath, prUrl, nextStatus, lang) {
-  if (!fs15.existsSync(tasksPath)) {
+  if (!fs14.existsSync(tasksPath)) {
     throw createCliError("DOCS_NOT_FOUND", tg(lang, "tasksNotFound", { path: tasksPath }));
   }
-  const original = fs15.readFileSync(tasksPath, "utf-8");
+  const original = fs14.readFileSync(tasksPath, "utf-8");
   let next = original;
   let changed = false;
   const prReplaced = replaceListField(next, ["PR", "Pull Request"], prUrl);
@@ -7291,7 +7478,7 @@ function syncTasksPrMetadata(tasksPath, prUrl, nextStatus, lang) {
     changed = changed || inserted.changed;
   }
   if (changed) {
-    fs15.writeFileSync(tasksPath, next, "utf-8");
+    fs14.writeFileSync(tasksPath, next, "utf-8");
   }
   return { changed, path: tasksPath };
 }
@@ -7319,7 +7506,7 @@ function ensureCleanWorktree(cwd, lang) {
   }
 }
 function commitAndPushPath(cwd, absPath, message, lang) {
-  const relativePath = path17.relative(cwd, absPath) || absPath;
+  const relativePath = path18.relative(cwd, absPath) || absPath;
   const status = runProcessOrThrow(
     "git",
     ["status", "--porcelain=v1", "--", relativePath],
@@ -7451,9 +7638,9 @@ function githubCommand(program2) {
         [paths.specPath, paths.planPath, paths.tasksPath],
         config.lang
       );
-      const specContent = await fs15.readFile(path17.join(config.docsDir, paths.specPath), "utf-8");
-      const planContent = await fs15.readFile(path17.join(config.docsDir, paths.planPath), "utf-8");
-      const tasksContent = await fs15.readFile(path17.join(config.docsDir, paths.tasksPath), "utf-8");
+      const specContent = await fs14.readFile(path18.join(config.docsDir, paths.specPath), "utf-8");
+      const planContent = await fs14.readFile(path18.join(config.docsDir, paths.planPath), "utf-8");
+      const tasksContent = await fs14.readFile(path18.join(config.docsDir, paths.tasksPath), "utf-8");
       const overview = resolveOverviewFromSpec(specContent, feature, config.lang);
       const title = options.title?.trim() || tg(config.lang, "issueDefaultTitle", {
         slug: feature.slug,
@@ -7482,8 +7669,8 @@ function githubCommand(program2) {
       );
       const explicitBodyFile = (options.bodyFile || "").trim();
       let body = generatedBody;
-      if (options.create && explicitBodyFile && await fs15.pathExists(bodyFile)) {
-        body = await fs15.readFile(bodyFile, "utf-8");
+      if (options.create && explicitBodyFile && await fs14.pathExists(bodyFile)) {
+        body = await fs14.readFile(bodyFile, "utf-8");
         ensureSections(
           body,
           getRequiredIssueSections(config.lang),
@@ -7491,8 +7678,8 @@ function githubCommand(program2) {
           config.lang
         );
       } else {
-        await fs15.ensureDir(path17.dirname(bodyFile));
-        await fs15.writeFile(bodyFile, generatedBody, "utf-8");
+        await fs14.ensureDir(path18.dirname(bodyFile));
+        await fs14.writeFile(bodyFile, generatedBody, "utf-8");
       }
       let issueUrl;
       if (options.create) {
@@ -7589,10 +7776,10 @@ function githubCommand(program2) {
       const labels = parseLabels(options.labels, config.lang);
       const paths = getFeatureDocPaths(feature);
       ensureDocsExist(config.docsDir, [paths.specPath, paths.tasksPath], config.lang);
-      const specContent = await fs15.readFile(path17.join(config.docsDir, paths.specPath), "utf-8");
-      const planPath = path17.join(config.docsDir, paths.planPath);
-      const planContent = await fs15.pathExists(planPath) ? await fs15.readFile(planPath, "utf-8") : "";
-      const tasksContent = await fs15.readFile(path17.join(config.docsDir, paths.tasksPath), "utf-8");
+      const specContent = await fs14.readFile(path18.join(config.docsDir, paths.specPath), "utf-8");
+      const planPath = path18.join(config.docsDir, paths.planPath);
+      const planContent = await fs14.pathExists(planPath) ? await fs14.readFile(planPath, "utf-8") : "";
+      const tasksContent = await fs14.readFile(path18.join(config.docsDir, paths.tasksPath), "utf-8");
       const overview = resolveOverviewFromSpec(specContent, feature, config.lang);
       const defaultTitle = feature.issueNumber ? tg(config.lang, "prDefaultTitleWithIssue", {
         issue: feature.issueNumber,
@@ -7626,8 +7813,8 @@ function githubCommand(program2) {
       );
       const explicitBodyFile = (options.bodyFile || "").trim();
       let body = generatedBody;
-      if (options.create && explicitBodyFile && await fs15.pathExists(bodyFile)) {
-        body = await fs15.readFile(bodyFile, "utf-8");
+      if (options.create && explicitBodyFile && await fs14.pathExists(bodyFile)) {
+        body = await fs14.readFile(bodyFile, "utf-8");
         ensureSections(
           body,
           getRequiredPrSections(config.lang),
@@ -7635,8 +7822,8 @@ function githubCommand(program2) {
           config.lang
         );
       } else {
-        await fs15.ensureDir(path17.dirname(bodyFile));
-        await fs15.writeFile(bodyFile, generatedBody, "utf-8");
+        await fs14.ensureDir(path18.dirname(bodyFile));
+        await fs14.writeFile(bodyFile, generatedBody, "utf-8");
       }
       const retryCount = toRetryCount(options.retry, config.lang);
       let prUrl = options.pr?.trim() || "";
@@ -7688,7 +7875,7 @@ function githubCommand(program2) {
       }
       if (prUrl && options.syncTasks !== false) {
         const synced = syncTasksPrMetadata(
-          path17.join(config.docsDir, paths.tasksPath),
+          path18.join(config.docsDir, paths.tasksPath),
           prUrl,
           "Review",
           config.lang
@@ -7909,7 +8096,7 @@ function docsCommand(program2) {
         );
         return;
       }
-      const relativeFromCwd = path17.relative(process.cwd(), loaded.entry.absolutePath);
+      const relativeFromCwd = path18.relative(process.cwd(), loaded.entry.absolutePath);
       console.log();
       console.log(chalk6.bold(`\u{1F4C4} ${loaded.entry.id}: ${loaded.entry.title}`));
       console.log(
@@ -7999,13 +8186,13 @@ ${version}
   }
   return `${ascii}${footer}`;
 }
-var CACHE_FILE = path17.join(os.homedir(), ".lee-spec-kit-version-cache.json");
+var CACHE_FILE = path18.join(os.homedir(), ".lee-spec-kit-version-cache.json");
 var CHECK_INTERVAL = 24 * 60 * 60 * 1e3;
 function getCurrentVersion() {
   try {
-    const packageJsonPath = path17.join(__dirname$1, "..", "package.json");
-    if (fs15.existsSync(packageJsonPath)) {
-      const pkg = fs15.readJsonSync(packageJsonPath);
+    const packageJsonPath = path18.join(__dirname$1, "..", "package.json");
+    if (fs14.existsSync(packageJsonPath)) {
+      const pkg = fs14.readJsonSync(packageJsonPath);
       return pkg.version;
     }
   } catch {
@@ -8014,8 +8201,8 @@ function getCurrentVersion() {
 }
 function readCache() {
   try {
-    if (fs15.existsSync(CACHE_FILE)) {
-      return fs15.readJsonSync(CACHE_FILE);
+    if (fs14.existsSync(CACHE_FILE)) {
+      return fs14.readJsonSync(CACHE_FILE);
     }
   } catch {
   }
@@ -8103,9 +8290,9 @@ function shouldCheckForUpdates() {
 if (shouldCheckForUpdates()) checkForUpdates();
 function getCliVersion() {
   try {
-    const packageJsonPath = path17.join(__dirname$1, "..", "package.json");
-    if (fs15.existsSync(packageJsonPath)) {
-      const pkg = fs15.readJsonSync(packageJsonPath);
+    const packageJsonPath = path18.join(__dirname$1, "..", "package.json");
+    if (fs14.existsSync(packageJsonPath)) {
+      const pkg = fs14.readJsonSync(packageJsonPath);
       if (pkg?.version) return String(pkg.version);
     }
   } catch {