mano-coding 0.1.30 → 0.1.31

package/dist/bin.js

@@ -14962,49 +14962,49 @@ var require_fast_uri = __commonJS({
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
-    function resolveComponent(base, relative8, options, skipNormalization) {
+    function resolveComponent(base, relative9, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
         base = parse(serialize(base, options), options);
-        relative8 = parse(serialize(relative8, options), options);
+        relative9 = parse(serialize(relative9, options), options);
       }
       options = options || {};
-      if (!options.tolerant && relative8.scheme) {
-        target.scheme = relative8.scheme;
-        target.userinfo = relative8.userinfo;
-        target.host = relative8.host;
-        target.port = relative8.port;
-        target.path = removeDotSegments(relative8.path || "");
-        target.query = relative8.query;
+      if (!options.tolerant && relative9.scheme) {
+        target.scheme = relative9.scheme;
+        target.userinfo = relative9.userinfo;
+        target.host = relative9.host;
+        target.port = relative9.port;
+        target.path = removeDotSegments(relative9.path || "");
+        target.query = relative9.query;
       } else {
-        if (relative8.userinfo !== void 0 || relative8.host !== void 0 || relative8.port !== void 0) {
-          target.userinfo = relative8.userinfo;
-          target.host = relative8.host;
-          target.port = relative8.port;
-          target.path = removeDotSegments(relative8.path || "");
-          target.query = relative8.query;
+        if (relative9.userinfo !== void 0 || relative9.host !== void 0 || relative9.port !== void 0) {
+          target.userinfo = relative9.userinfo;
+          target.host = relative9.host;
+          target.port = relative9.port;
+          target.path = removeDotSegments(relative9.path || "");
+          target.query = relative9.query;
         } else {
-          if (!relative8.path) {
+          if (!relative9.path) {
             target.path = base.path;
-            if (relative8.query !== void 0) {
-              target.query = relative8.query;
+            if (relative9.query !== void 0) {
+              target.query = relative9.query;
             } else {
               target.query = base.query;
             }
           } else {
-            if (relative8.path[0] === "/") {
-              target.path = removeDotSegments(relative8.path);
+            if (relative9.path[0] === "/") {
+              target.path = removeDotSegments(relative9.path);
             } else {
               if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
-                target.path = "/" + relative8.path;
+                target.path = "/" + relative9.path;
               } else if (!base.path) {
-                target.path = relative8.path;
+                target.path = relative9.path;
               } else {
-                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative8.path;
+                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative9.path;
               }
               target.path = removeDotSegments(target.path);
             }
-            target.query = relative8.query;
+            target.query = relative9.query;
           }
           target.userinfo = base.userinfo;
           target.host = base.host;
@@ -15012,7 +15012,7 @@ var require_fast_uri = __commonJS({
         }
         target.scheme = base.scheme;
       }
-      target.fragment = relative8.fragment;
+      target.fragment = relative9.fragment;
       return target;
     }
     function equal(uriA, uriB, options) {
@@ -23352,10 +23352,10 @@ async function persistGitCheckout(workDir, targetDir) {
   return targetDir;
 }
 async function copyGitCheckout(src, dest) {
-  const { readdir: readdir10, mkdir: mkdir18, copyFile: copyFile2 } = await import("node:fs/promises");
+  const { readdir: readdir11, mkdir: mkdir19, copyFile: copyFile2 } = await import("node:fs/promises");
   const { join: joinPath } = await import("node:path");
-  await mkdir18(dest, { recursive: true });
-  const entries = await readdir10(src, { withFileTypes: true });
+  await mkdir19(dest, { recursive: true });
+  const entries = await readdir11(src, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === ".git") continue;
     const srcPath = joinPath(src, entry.name);
@@ -23548,8 +23548,8 @@ var init_git_resolver = __esm({
           }
           const cacheBase = join6(cacheRoot, "git", encodePackageId(packageId));
           try {
-            const { readdir: readdir10 } = await import("node:fs/promises");
-            const commits = await readdir10(cacheBase, { withFileTypes: true });
+            const { readdir: readdir11 } = await import("node:fs/promises");
+            const commits = await readdir11(cacheBase, { withFileTypes: true });
             for (const entry of commits) {
               if (!entry.isDirectory()) continue;
               const cacheDir = join6(cacheBase, entry.name);
@@ -26934,10 +26934,10 @@ var init_tarball_loader = __esm({
         return targetDir;
       }
       async copyDirRecursive(src, dest) {
-        const { readdir: readdir10, mkdir: mkdir18, copyFile: copyFile2 } = await import("node:fs/promises");
+        const { readdir: readdir11, mkdir: mkdir19, copyFile: copyFile2 } = await import("node:fs/promises");
         const { join: joinPath } = await import("node:path");
-        await mkdir18(dest, { recursive: true });
-        const entries = await readdir10(src, { withFileTypes: true });
+        await mkdir19(dest, { recursive: true });
+        const entries = await readdir11(src, { withFileTypes: true });
         for (const entry of entries) {
           const srcPath = joinPath(src, entry.name);
           const destPath = joinPath(dest, entry.name);
@@ -26996,18 +26996,18 @@ var init_tarball_loader = __esm({
       }
       async findAndReadManifest(workDir, packageId, version) {
         const packageRoot = await this.findPackageRoot(workDir, packageId, version);
-        const { readFile: readFile33 } = await import("node:fs/promises");
-        return readFile33(join7(packageRoot, "manifest.yaml"), "utf-8");
+        const { readFile: readFile34 } = await import("node:fs/promises");
+        return readFile34(join7(packageRoot, "manifest.yaml"), "utf-8");
       }
       async findPackageRoot(workDir, packageId, version) {
-        const { access: access12, readdir: readdir10 } = await import("node:fs/promises");
+        const { access: access12, readdir: readdir11 } = await import("node:fs/promises");
         const { resolve: resolvePath10 } = await import("node:path");
         const candidates = [
           resolvePath10(workDir),
           resolvePath10(workDir, "package")
         ];
         try {
-          const entries = await readdir10(workDir, { withFileTypes: true });
+          const entries = await readdir11(workDir, { withFileTypes: true });
           for (const entry of entries) {
             if (entry.isDirectory()) {
               candidates.push(resolvePath10(workDir, entry.name));
@@ -28735,11 +28735,11 @@ var init_claude_code_adapter = __esm({
           return diagnostics;
         }
         const { capability, content, packageRoot } = request;
-        const { readFile: readFile33 } = await import("node:fs/promises");
+        const { readFile: readFile34 } = await import("node:fs/promises");
         const { resolve: resolvePath10 } = await import("node:path");
         const variantPath = resolvePath10(packageRoot, content.path);
         try {
-          const raw = await readFile33(variantPath, "utf-8");
+          const raw = await readFile34(variantPath, "utf-8");
           switch (capability.type) {
             case "rule":
               if (!variantPath.endsWith(".md")) {
@@ -28899,7 +28899,7 @@ var init_codex_adapter = __esm({
           return diagnostics;
         }
         const { capability, content, packageRoot } = request;
-        const { readFile: readFile33 } = await import("node:fs/promises");
+        const { readFile: readFile34 } = await import("node:fs/promises");
         const { resolve: resolvePath10 } = await import("node:path");
         const variantPath = resolvePath10(packageRoot, content.path);
         switch (capability.type) {
@@ -28925,7 +28925,7 @@ var init_codex_adapter = __esm({
               });
             }
             try {
-              const raw = await readFile33(variantPath, "utf-8");
+              const raw = await readFile34(variantPath, "utf-8");
               if (!raw.trim()) {
                 diagnostics.push({
                   severity: "error",
@@ -28940,7 +28940,7 @@ var init_codex_adapter = __esm({
             break;
           case "mcp":
             try {
-              const raw = await readFile33(variantPath, "utf-8");
+              const raw = await readFile34(variantPath, "utf-8");
               if (!raw.trim()) {
                 diagnostics.push({
                   severity: "error",
@@ -29067,7 +29067,7 @@ var init_opencode_adapter = __esm({
           return diagnostics;
         }
         const { capability, content, packageRoot } = request;
-        const { readFile: readFile33 } = await import("node:fs/promises");
+        const { readFile: readFile34 } = await import("node:fs/promises");
         const { resolve: resolvePath10 } = await import("node:path");
         const variantPath = resolvePath10(packageRoot, content.path);
         switch (capability.type) {
@@ -29104,7 +29104,7 @@ var init_opencode_adapter = __esm({
             break;
           case "mcp":
             try {
-              const raw = await readFile33(variantPath, "utf-8");
+              const raw = await readFile34(variantPath, "utf-8");
               JSON.parse(raw);
             } catch {
               diagnostics.push({
@@ -29241,11 +29241,11 @@ var init_codebuddy_adapter = __esm({
           return diagnostics;
         }
         const { capability, content, packageRoot } = request;
-        const { readFile: readFile33 } = await import("node:fs/promises");
+        const { readFile: readFile34 } = await import("node:fs/promises");
         const { resolve: resolvePath10 } = await import("node:path");
         const variantPath = resolvePath10(packageRoot, content.path);
         try {
-          const raw = await readFile33(variantPath, "utf-8");
+          const raw = await readFile34(variantPath, "utf-8");
           switch (capability.type) {
             case "rule":
               if (!variantPath.endsWith(".mdc")) {
@@ -29403,11 +29403,11 @@ var init_trae_adapter = __esm({
           return diagnostics;
         }
         const { capability, content, packageRoot } = request;
-        const { readFile: readFile33 } = await import("node:fs/promises");
+        const { readFile: readFile34 } = await import("node:fs/promises");
         const { resolve: resolvePath10 } = await import("node:path");
         const variantPath = resolvePath10(packageRoot, content.path);
         try {
-          const raw = await readFile33(variantPath, "utf-8");
+          const raw = await readFile34(variantPath, "utf-8");
           switch (capability.type) {
             case "rule":
               if (!variantPath.endsWith(".md")) {
@@ -29798,11 +29798,11 @@ var init_host_packages = __esm({
 import { resolve as resolve9 } from "node:path";
 import { pathToFileURL } from "node:url";
 async function loadAdapterModule(packageRoot) {
-  const { readFile: readFile33 } = await import("node:fs/promises");
+  const { readFile: readFile34 } = await import("node:fs/promises");
   const packageJsonPath = resolve9(packageRoot, "package.json");
   let packageJson;
   try {
-    const raw = await readFile33(packageJsonPath, "utf-8");
+    const raw = await readFile34(packageJsonPath, "utf-8");
     packageJson = JSON.parse(raw);
   } catch {
     throw new AdapterLoaderError(
@@ -31496,7 +31496,11 @@ function validateTaskVariables(tasks, ctx) {
         if (ctx.targets && ctx.targets.length > 1) {
           errors.push(`\u4EFB\u52A1 '${taskId}' \u7684 ${field} \u5F15\u7528\u4E86\u5355\u503C '\${target}'\uFF0C\u4F46\u5F53\u524D\u9009\u62E9\u4E86\u591A\u4E2A target: [${ctx.targets.join(", ")}]\u3002\u8BF7\u5728 manifest \u4E2D\u4F7F\u7528 '\${targets}' \u6216\u4EC5\u9009\u62E9\u5355\u4E2A target`);
         }
-      } else if (varName === "projectName" || varName === "projectDir" || varName === "projectParentDir" || varName === "templateDir" || varName === "stagingDir" || varName === "targets" || varName === "operation" || varName === "version" || varName === "previousVersion" || varName.startsWith("inputs.")) {
+      } else if (varName === "stagingDir") {
+        if (!ctx.stagingDir) {
+          errors.push(`\u4EFB\u52A1 '${taskId}' \u7684 ${field} \u4E2D\u5F15\u7528\u4E86 '\${stagingDir}'\uFF0C\u4F46\u5F53\u524D\u64CD\u4F5C\u4E0A\u4E0B\u6587\u4E2D\u672A\u5206\u914D stagingDir\uFF08\u4EC5\u5728 before:create \u94A9\u5B50\u4E2D\u53EF\u7528\uFF09`);
+        }
+      } else if (varName === "projectName" || varName === "projectDir" || varName === "projectParentDir" || varName === "templateDir" || varName === "targets" || varName === "operation" || varName === "version" || varName === "previousVersion" || varName.startsWith("inputs.")) {
       } else {
         errors.push(`\u4EFB\u52A1 '${taskId}' \u7684 ${field} \u4E2D\u5F15\u7528\u4E86\u672A\u77E5\u53D8\u91CF '\${${varName}}'`);
       }
@@ -31522,7 +31526,15 @@ function interpolateString(template, ctx, allowEnv = false) {
     if (varName === "projectDir") return ctx.projectDir;
     if (varName === "projectParentDir") return ctx.projectParentDir;
     if (varName === "templateDir") return ctx.templateDir;
-    if (varName === "stagingDir") return ctx.stagingDir ?? "";
+    if (varName === "stagingDir") {
+      if (!ctx.stagingDir) {
+        throw new TaskExecutionError(
+          `\u4EFB\u52A1\u5F15\u7528\u4E86 '\${stagingDir}'\uFF0C\u4F46\u5F53\u524D\u64CD\u4F5C\u4E0A\u4E0B\u6587\u4E2D\u672A\u5206\u914D stagingDir\u3002\u8BE5\u53D8\u91CF\u4EC5\u5728 before:create \u94A9\u5B50\u4E2D\u53EF\u7528\u3002`,
+          1
+        );
+      }
+      return ctx.stagingDir;
+    }
     if (varName === "operation") return ctx.operation ?? "";
     if (varName === "version") return ctx.version ?? "";
     if (varName === "previousVersion") return ctx.previousVersion ?? "";
@@ -33215,6 +33227,68 @@ var init_staging_manager = __esm({
   }
 });
 
+// packages/core/src/orchestrator/staging-scanner.ts
+import { readFile as readFile23, readdir as readdir8, stat as stat6 } from "node:fs/promises";
+import { join as join18, relative as relative7 } from "node:path";
+async function scanStagingDirectory(options) {
+  const { stagingDir, packageId, ownerKind = "template" } = options;
+  const ignoredDirs = /* @__PURE__ */ new Set([...DEFAULT_IGNORED_DIRS, ...options.ignoredDirs ?? []]);
+  const intents = [];
+  async function walk(currentDir) {
+    let entries;
+    try {
+      entries = await readdir8(currentDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join18(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        if (ignoredDirs.has(entry.name)) {
+          continue;
+        }
+        await walk(fullPath);
+      } else if (entry.isFile()) {
+        const relPath = relative7(stagingDir, fullPath).replaceAll("\\", "/");
+        if (relPath === "aicoding-lock.yaml" || relPath === "mano-lock.yaml") {
+          continue;
+        }
+        const fileStat = await stat6(fullPath);
+        const content = await readFile23(fullPath);
+        const executable = Boolean(fileStat.mode & 73);
+        intents.push({
+          action: "upsert",
+          type: "file",
+          path: relPath,
+          content,
+          executable: executable ? true : void 0,
+          packageId,
+          ownerKind,
+          assetType: "project-seed"
+        });
+      }
+    }
+  }
+  await walk(stagingDir);
+  return {
+    intents,
+    fileCount: intents.length
+  };
+}
+var DEFAULT_IGNORED_DIRS;
+var init_staging_scanner = __esm({
+  "packages/core/src/orchestrator/staging-scanner.ts"() {
+    "use strict";
+    DEFAULT_IGNORED_DIRS = /* @__PURE__ */ new Set([
+      ".git",
+      "node_modules",
+      ".pnpm-store",
+      ".turbo",
+      ".cache"
+    ]);
+  }
+});
+
 // packages/core/src/orchestrator/qualification.ts
 function inspectPackageFacts(resolution) {
   const manifest = resolution.manifest;
@@ -33305,7 +33379,8 @@ var init_qualification = __esm({
 
 // packages/core/src/orchestrator/lifecycle-orchestrator.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
-import { basename as basename3, dirname as dirname14 } from "node:path";
+import { writeFile as writeFile7, mkdir as mkdir15 } from "node:fs/promises";
+import { basename as basename3, dirname as dirname14, join as join19 } from "node:path";
 function resolveStringInputs(globalInputs, packageInputs, packageId) {
   const merged = {};
   const raw = {
@@ -33342,6 +33417,7 @@ var init_lifecycle_orchestrator = __esm({
     init_journal();
     init_task_runner();
     init_staging_manager();
+    init_staging_scanner();
     init_qualification();
     OrchestratorError = class extends Error {
       code;
@@ -33395,6 +33471,7 @@ var init_lifecycle_orchestrator = __esm({
             options.resolutions,
             options.targets
           );
+          const stagingIntents = [];
           if (hasBeforeCreate) {
             options.onProgress?.("bootstrap-plan", "\u51C6\u5907\u4E24\u9636\u6BB5 Bootstrap Plan");
             for (const res of options.resolutions) {
@@ -33417,6 +33494,17 @@ var init_lifecycle_orchestrator = __esm({
                 await executeTasks(beforeTasks, ctx);
               }
             }
+            for (const res of options.resolutions) {
+              const stagingDir = this.stagingManager.getStagingDir(res.packageId);
+              if (stagingDir) {
+                const scanRes = await scanStagingDirectory({
+                  stagingDir,
+                  packageId: res.packageId,
+                  ownerKind: "template"
+                });
+                stagingIntents.push(...scanRes.intents);
+              }
+            }
           }
           options.onProgress?.("materialized-plan", "\u8BA1\u7B97 Materialized Plan \u5E76\u9A8C\u8BC1\u51B2\u7A81");
           const validation = validatePlan(planResult.plan);
@@ -33438,12 +33526,21 @@ var init_lifecycle_orchestrator = __esm({
               success: true,
               operationId,
               plan: planResult.plan,
-              intents: []
+              intents: stagingIntents
             };
           }
           options.onProgress?.("commit-core", "\u8FDB\u5165\u4E8B\u52A1\u6267\u884C\u6838\u5FC3\u8D44\u6E90\u5199\u5165");
           const journal = await createJournal(options.userDataDir, options.projectRoot, { operationId });
           let executingJournal = await updateJournal(journal, "executing");
+          if (stagingIntents.length > 0) {
+            for (const intent of stagingIntents) {
+              if (intent.action === "upsert" && intent.type === "file") {
+                const targetPath = join19(options.projectRoot, intent.path);
+                await mkdir15(dirname14(targetPath), { recursive: true });
+                await writeFile7(targetPath, intent.content);
+              }
+            }
+          }
           if (options.operation !== "create") {
             const beforeHookName = `before:${options.operation}`;
             for (const res of options.resolutions) {
@@ -33492,6 +33589,7 @@ var init_orchestrator = __esm({
     "use strict";
     init_types5();
     init_staging_manager();
+    init_staging_scanner();
     init_qualification();
     init_lifecycle_orchestrator();
   }
@@ -33684,6 +33782,7 @@ __export(src_exports, {
   sanitizeEnvValue: () => sanitizeEnvValue,
   sanitizeUrl: () => sanitizeUrl,
   scanJournals: () => scanJournals,
+  scanStagingDirectory: () => scanStagingDirectory,
   scanTemplateDirectoryContract: () => scanTemplateDirectoryContract,
   selectRelease: () => selectRelease,
   serializeTomlValue: () => serializeTomlValue,
@@ -43623,7 +43722,7 @@ var require_dist3 = __commonJS({
 });
 
 // packages/cli/src/commands/extension-pipeline.ts
-import { readFile as readFile23, writeFile as writeFile7 } from "node:fs/promises";
+import { readFile as readFile24, writeFile as writeFile8 } from "node:fs/promises";
 import { existsSync as existsSync5 } from "node:fs";
 import { resolve as resolve14 } from "node:path";
 function generateGitlabCiYaml(packageId) {
@@ -43705,7 +43804,7 @@ async function executeExtensionPipeline(directory, options) {
   if (!packageId) {
     if (existsSync5(manifestPath)) {
       try {
-        const manifestContent = await readFile23(manifestPath, "utf-8");
+        const manifestContent = await readFile24(manifestPath, "utf-8");
         const parsed = import_yaml4.default.parse(manifestContent);
         if (parsed && typeof parsed.id === "string") {
           packageId = parsed.id;
@@ -43715,7 +43814,7 @@ async function executeExtensionPipeline(directory, options) {
     }
     if (!packageId && existsSync5(pkgJsonPath)) {
       try {
-        const pkgContent = await readFile23(pkgJsonPath, "utf-8");
+        const pkgContent = await readFile24(pkgJsonPath, "utf-8");
         const parsed = JSON.parse(pkgContent);
         if (parsed && typeof parsed.name === "string") {
           packageId = parsed.name;
@@ -43756,16 +43855,16 @@ async function executeExtensionPipeline(directory, options) {
     }
   }
   const ciContent = generateGitlabCiYaml(packageId);
-  await writeFile7(ciFilePath, ciContent, "utf-8");
+  await writeFile8(ciFilePath, ciContent, "utf-8");
   let addedReleaseScript = false;
   if (existsSync5(pkgJsonPath)) {
     try {
-      const pkgContent = await readFile23(pkgJsonPath, "utf-8");
+      const pkgContent = await readFile24(pkgJsonPath, "utf-8");
       const parsed = JSON.parse(pkgContent);
       parsed.scripts = parsed.scripts || {};
       if (!parsed.scripts.release) {
         parsed.scripts.release = "npm version patch";
-        await writeFile7(pkgJsonPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+        await writeFile8(pkgJsonPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
         addedReleaseScript = true;
       }
     } catch {
@@ -43809,7 +43908,7 @@ var init_extension_pipeline = __esm({
 });
 
 // packages/cli/src/commands/extension-create.ts
-import { mkdir as mkdir15, writeFile as writeFile8, readdir as readdir8 } from "node:fs/promises";
+import { mkdir as mkdir16, writeFile as writeFile9, readdir as readdir9 } from "node:fs/promises";
 import { basename as basename4, resolve as resolve15 } from "node:path";
 function createExtensionCreateCommand() {
   const cmd = new Command("create");
@@ -43858,7 +43957,7 @@ async function executeExtensionCreate(directory, options) {
   const dirBase = basename4(targetDir);
   const isInteractive = !options.yes && !options.json && Boolean(process.stdin.isTTY);
   try {
-    const entries = await readdir8(targetDir);
+    const entries = await readdir9(targetDir);
     if (entries.length > 0) {
       if (output.json) {
         emitFailureJson(
@@ -43922,7 +44021,7 @@ async function executeExtensionCreate(directory, options) {
       default: true
     });
   }
-  await mkdir15(targetDir, { recursive: true });
+  await mkdir16(targetDir, { recursive: true });
   const scripts = {
     test: "vitest"
   };
@@ -43948,7 +44047,7 @@ async function executeExtensionCreate(directory, options) {
       vitest: "^3.0.5"
     }
   };
-  await writeFile8(resolve15(targetDir, "package.json"), JSON.stringify(pkgJson, null, 2) + "\n", "utf-8");
+  await writeFile9(resolve15(targetDir, "package.json"), JSON.stringify(pkgJson, null, 2) + "\n", "utf-8");
   const manifestLines = [
     `id: "${packageId}"`,
     "version: 0.1.0",
@@ -43970,7 +44069,7 @@ async function executeExtensionCreate(directory, options) {
     manifestLines.push("    on:");
     manifestLines.push("      - after:create");
   }
-  await writeFile8(resolve15(targetDir, "manifest.yaml"), manifestLines.join("\n") + "\n", "utf-8");
+  await writeFile9(resolve15(targetDir, "manifest.yaml"), manifestLines.join("\n") + "\n", "utf-8");
   const agentsMdContent = `# ${templateName} Agent \u6307\u5357
 
 \u672C\u9879\u76EE\u57FA\u4E8E ${templateName} \u6A21\u677F\u6784\u5EFA\u3002\u5728\u8FDB\u884C AI \u8F85\u52A9\u7F16\u7801\u65F6\uFF0C\u8BF7\u9075\u5FAA\u4EE5\u4E0B\u6838\u5FC3\u539F\u5219\u4E0E\u7EA6\u5B9A\uFF1A
@@ -43982,9 +44081,9 @@ async function executeExtensionCreate(directory, options) {
 ## 2. \u4EA4\u4E92\u4E0E\u6CE8\u91CA
 - \u4EE3\u7801\u6CE8\u91CA\u4E0E\u56DE\u7B54\u8BF7\u59CB\u7EC8\u4F7F\u7528\u7B80\u4F53\u4E2D\u6587\u3002
 `;
-  await writeFile8(resolve15(targetDir, "AGENTS.md"), agentsMdContent, "utf-8");
+  await writeFile9(resolve15(targetDir, "AGENTS.md"), agentsMdContent, "utf-8");
   const skillDir = resolve15(targetDir, "skills", "example-skill");
-  await mkdir15(skillDir, { recursive: true });
+  await mkdir16(skillDir, { recursive: true });
   const skillContent = `---
 name: example-skill
 description: ${templateName} \u793A\u4F8B Agent \u6280\u80FD\uFF0C\u6307\u5BFC AI \u6309\u7167\u6700\u4F73\u5B9E\u8DF5\u5B8C\u6210\u7279\u5B9A\u4EFB\u52A1
@@ -44000,9 +44099,9 @@ description: ${templateName} \u793A\u4F8B Agent \u6280\u80FD\uFF0C\u6307\u5BFC A
 2. \u9075\u5FAA\u672C\u9879\u76EE\u7684\u67B6\u6784\u8BBE\u8BA1\u539F\u5219\u5B9E\u73B0\u4EE3\u7801\u3002
 3. \u7F16\u5199\u5BF9\u5E94\u6D4B\u8BD5\u5E76\u9A8C\u8BC1\u3002
 `;
-  await writeFile8(resolve15(skillDir, "SKILL.md"), skillContent, "utf-8");
+  await writeFile9(resolve15(skillDir, "SKILL.md"), skillContent, "utf-8");
   const cursorRulesDir = resolve15(targetDir, "rules", "cursor");
-  await mkdir15(cursorRulesDir, { recursive: true });
+  await mkdir16(cursorRulesDir, { recursive: true });
   const cursorRuleContent = `---
 description: ${templateName} Cursor \u7F16\u7801\u89C4\u5219
 globs: *
@@ -44014,17 +44113,17 @@ alwaysApply: false
 - \u4F18\u5148\u4F7F\u7528\u73B0\u6709\u7684\u8BBE\u8BA1\u7CFB\u7EDF\u548C\u516C\u5171\u7EC4\u4EF6\u3002
 - \u4FDD\u6301\u51FD\u6570\u4E0E\u6A21\u5757\u7B80\u6D01\uFF0C\u5355\u4E00\u804C\u8D23\u3002
 `;
-  await writeFile8(resolve15(cursorRulesDir, "example-rule.mdc"), cursorRuleContent, "utf-8");
+  await writeFile9(resolve15(cursorRulesDir, "example-rule.mdc"), cursorRuleContent, "utf-8");
   const codebuddyRulesDir = resolve15(targetDir, "rules", "codebuddy");
-  await mkdir15(codebuddyRulesDir, { recursive: true });
+  await mkdir16(codebuddyRulesDir, { recursive: true });
   const codebuddyRuleContent = `# ${templateName} \u7F16\u7801\u89C4\u5219 (CodeBuddy)
 
 - \u9075\u5FAA\u4EE3\u7801\u8BBE\u8BA1\u539F\u5219\u3002
 - \u5355\u5143\u6D4B\u8BD5\u8986\u76D6\u6838\u5FC3\u903B\u8F91\u5206\u652F\u3002
 `;
-  await writeFile8(resolve15(codebuddyRulesDir, "example-rule.md"), codebuddyRuleContent, "utf-8");
+  await writeFile9(resolve15(codebuddyRulesDir, "example-rule.md"), codebuddyRuleContent, "utf-8");
   const mcpDir = resolve15(targetDir, "mcp");
-  await mkdir15(mcpDir, { recursive: true });
+  await mkdir16(mcpDir, { recursive: true });
   const mcpJsonContent = {
     mcpServers: {
       "example-server": {
@@ -44033,9 +44132,9 @@ alwaysApply: false
       }
     }
   };
-  await writeFile8(resolve15(mcpDir, "mcp.json"), JSON.stringify(mcpJsonContent, null, 2) + "\n", "utf-8");
+  await writeFile9(resolve15(mcpDir, "mcp.json"), JSON.stringify(mcpJsonContent, null, 2) + "\n", "utf-8");
   const testDir = resolve15(targetDir, "test");
-  await mkdir15(testDir, { recursive: true });
+  await mkdir16(testDir, { recursive: true });
   const testContent = `import { describe, expect, it } from 'vitest';
 import { readFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
@@ -44048,7 +44147,7 @@ describe('${packageId} template manifest', () => {
   });
 });
 `;
-  await writeFile8(resolve15(testDir, "manifest.test.ts"), testContent, "utf-8");
+  await writeFile9(resolve15(testDir, "manifest.test.ts"), testContent, "utf-8");
   const createdFiles = [
     "manifest.yaml",
     "AGENTS.md",
@@ -44061,7 +44160,7 @@ describe('${packageId} template manifest', () => {
     "test/manifest.test.ts"
   ];
   if (withPipeline) {
-    await writeFile8(
+    await writeFile9(
       resolve15(targetDir, ".gitlab-ci.yml"),
       generateGitlabCiYaml(packageId),
       "utf-8"
@@ -44075,7 +44174,7 @@ describe('${packageId} template manifest', () => {
     withTasks: Boolean(withTasks),
     withPipeline: Boolean(withPipeline)
   });
-  await writeFile8(resolve15(targetDir, "README.md"), readmeContent, "utf-8");
+  await writeFile9(resolve15(targetDir, "README.md"), readmeContent, "utf-8");
   if (output.json) {
     emitSuccessJson("extension create", {
       directory: targetDir,
@@ -44380,9 +44479,9 @@ var init_shared_options = __esm({
 });
 
 // packages/cli/src/commands/extension-dev.ts
-import { mkdtemp as mkdtemp6, readFile as readFile24 } from "node:fs/promises";
+import { mkdtemp as mkdtemp6, readFile as readFile25 } from "node:fs/promises";
 import { tmpdir as tmpdir6 } from "node:os";
-import { join as join18, resolve as resolvePath9, relative as relative7, isAbsolute as isAbsolute6, sep as sep4 } from "node:path";
+import { join as join20, resolve as resolvePath9, relative as relative8, isAbsolute as isAbsolute6, sep as sep4 } from "node:path";
 function createExtensionDevCommand() {
   const cmd = new Command("dev");
   cmd.description(t("extension.dev.description")).argument("[package-directory]", t("extension.dev.argPackageDirectory"), ".").requiredOption("--project <fixture-directory>", t("extension.dev.optionProject")).option("--operation <create|apply|sync|remove>", t("extension.dev.optionOperation"), "apply").option("--target <id>", t("mutation.target"), collectString2, []).option("--set <name=value>", t("mutation.set"), collectString2, []).option("--dry-run", t("mutation.dryRun")).option("--yes", t("mutation.yes")).option("--allow <permission>", t("mutation.allow"), collectString2, []).option("--watch", t("extension.dev.optionWatch")).action(async (packageDirectory, opts) => {
@@ -44436,7 +44535,7 @@ async function executeExtensionDev(packageDirectory, options) {
     return ExitCode.SchemaInvalid;
   }
   const effectiveDryRun = options.dryRun || options.watch;
-  const isolatedUserData = await mkdtemp6(join18(tmpdir6(), "aicoding-dev-userdata-"));
+  const isolatedUserData = await mkdtemp6(join20(tmpdir6(), "aicoding-dev-userdata-"));
   const prevUserData = process.env["AICODING_USER_DATA"];
   process.env["AICODING_USER_DATA"] = isolatedUserData;
   try {
@@ -44497,7 +44596,7 @@ async function readPackageId(packageDirectory) {
   const manifestPath = resolvePath9(process.cwd(), packageDirectory, "manifest.yaml");
   let content;
   try {
-    content = await readFile24(manifestPath, "utf-8");
+    content = await readFile25(manifestPath, "utf-8");
   } catch {
     throw new CliError(`\u672A\u5728 '${packageDirectory}' \u4E0B\u627E\u5230 manifest.yaml`, ExitCode.ResolveFailed, "DEV_MANIFEST_NOT_FOUND");
   }
@@ -44510,7 +44609,7 @@ async function readPackageId(packageDirectory) {
 function getProjectRelativeSourcePath(packageDirectory, project) {
   const packageAbs = resolvePath9(process.cwd(), packageDirectory);
   const projectAbs = resolvePath9(process.cwd(), project);
-  const relativePath = relative7(projectAbs, packageAbs).split(sep4).join("/");
+  const relativePath = relative8(projectAbs, packageAbs).split(sep4).join("/");
   if (relativePath === ".." || relativePath.startsWith("../") || isAbsolute6(relativePath)) {
     throw new CliError(
       `\u6269\u5C55\u5305\u76EE\u5F55\u5FC5\u987B\u5728 fixture \u9879\u76EE\u76EE\u5F55\u5185\uFF08local \u6E90\u8DEF\u5F84\u9700\u4E3A\u9879\u76EE\u76F8\u5BF9\u8DEF\u5F84\uFF09\u3002\u8BF7\u5C06 '${packageDirectory}' \u79FB\u52A8\u6216\u94FE\u63A5\u5230 '${project}' \u5185\u3002`,
@@ -44532,7 +44631,7 @@ var init_extension_dev = __esm({
 });
 
 // packages/cli/src/commands/extension-test.ts
-import { readFile as readFile25 } from "node:fs/promises";
+import { readFile as readFile26 } from "node:fs/promises";
 import { resolve as resolve16 } from "node:path";
 import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
@@ -44597,7 +44696,7 @@ async function executeExtensionTest(packageDirectory, options, cliVersion) {
   let hasTestScript = false;
   let isNpmPackage = false;
   try {
-    const pkgJsonContent = await readFile25(resolve16(pkgDir, "package.json"), "utf-8");
+    const pkgJsonContent = await readFile26(resolve16(pkgDir, "package.json"), "utf-8");
     const pkgJson = JSON.parse(pkgJsonContent);
     hasTestScript = Boolean(pkgJson.scripts?.test);
     isNpmPackage = Boolean(pkgJson.name);
@@ -44676,8 +44775,8 @@ var init_extension_test = __esm({
 });
 
 // packages/cli/src/commands/extension-pack.ts
-import { readFile as readFile26, mkdir as mkdir16 } from "node:fs/promises";
-import { resolve as resolve17, join as join19, dirname as dirname15 } from "node:path";
+import { readFile as readFile27, mkdir as mkdir17 } from "node:fs/promises";
+import { resolve as resolve17, join as join21, dirname as dirname15 } from "node:path";
 import { execFile as execFile4 } from "node:child_process";
 import { promisify as promisify5 } from "node:util";
 import { createHash as createHash13 } from "node:crypto";
@@ -44747,7 +44846,7 @@ async function executeExtensionPack(packageDirectory, options, cliVersion) {
   let pkgJson;
   let pkgJsonRaw;
   try {
-    pkgJsonRaw = await readFile26(resolve17(pkgDir, "package.json"), "utf-8");
+    pkgJsonRaw = await readFile27(resolve17(pkgDir, "package.json"), "utf-8");
     pkgJson = JSON.parse(pkgJsonRaw);
   } catch {
     if (output.json) {
@@ -44826,11 +44925,11 @@ async function executeExtensionPack(packageDirectory, options, cliVersion) {
     }
   }
   const outputDir = options.output ? resolve17(options.output) : resolve17(pkgDir, "dist-package");
-  await mkdir16(outputDir, { recursive: true });
+  await mkdir17(outputDir, { recursive: true });
   let tarballName;
   let tarballPath;
   tarballName = `${pkgName.replace(/^@/, "").replace(/\//g, "-")}-${pkgVersion}.tgz`;
-  tarballPath = join19(outputDir, tarballName);
+  tarballPath = join21(outputDir, tarballName);
   try {
     await packWithNpm(pkgDir, outputDir);
   } catch (err) {
@@ -44847,7 +44946,7 @@ async function executeExtensionPack(packageDirectory, options, cliVersion) {
   let sri = "";
   let manifestDigest = "";
   try {
-    const tarballContent = await readFile26(tarballPath);
+    const tarballContent = await readFile27(tarballPath);
     sri = "sha512-" + createHash13("sha512").update(tarballContent).digest("base64");
   } catch {
     if (output.json) {
@@ -44859,7 +44958,7 @@ async function executeExtensionPack(packageDirectory, options, cliVersion) {
     return ExitCode.ExecuteFailed;
   }
   try {
-    const manifestContent = await readFile26(resolve17(pkgDir, "manifest.yaml"));
+    const manifestContent = await readFile27(resolve17(pkgDir, "manifest.yaml"));
     manifestDigest = createHash13("sha256").update(manifestContent).digest("hex");
   } catch {
   }
@@ -44899,7 +44998,7 @@ var init_extension_pack = __esm({
 });
 
 // packages/cli/src/commands/extension-submit.ts
-import { readFile as readFile27 } from "node:fs/promises";
+import { readFile as readFile28 } from "node:fs/promises";
 import { resolve as resolve18 } from "node:path";
 function createExtensionSubmitCommand(cliVersion) {
   const cmd = new Command("submit");
@@ -44962,7 +45061,7 @@ async function executeExtensionSubmit(packageDirectory, options, cliVersion) {
   let pkgName = "";
   let pkgVersion = "";
   try {
-    const pkgJsonRaw = await readFile27(resolve18(pkgDir, "package.json"), "utf-8");
+    const pkgJsonRaw = await readFile28(resolve18(pkgDir, "package.json"), "utf-8");
     const pkgJson = JSON.parse(pkgJsonRaw);
     pkgName = pkgJson.name ?? "";
     pkgVersion = pkgJson.version ?? "";
@@ -45070,7 +45169,7 @@ var init_extension_submit = __esm({
 });
 
 // packages/cli/src/commands/extension-adapter.ts
-import { readFile as readFile28, mkdir as mkdir17 } from "node:fs/promises";
+import { readFile as readFile29, mkdir as mkdir18 } from "node:fs/promises";
 import { dirname as dirname16, resolve as resolve19 } from "node:path";
 import { execFile as execFile5 } from "node:child_process";
 import { promisify as promisify6 } from "node:util";
@@ -45293,7 +45392,7 @@ async function executeAdapterTest(packageDirectory, options) {
   }
   let hasTestScript = false;
   try {
-    const pkgJsonRaw = await readFile28(resolve19(pkgDir, "package.json"), "utf-8");
+    const pkgJsonRaw = await readFile29(resolve19(pkgDir, "package.json"), "utf-8");
     const pkgJson = JSON.parse(pkgJsonRaw);
     hasTestScript = Boolean(pkgJson.scripts?.test);
   } catch {
@@ -45381,7 +45480,7 @@ async function executeAdapterPack(packageDirectory, options) {
   let pkgVersion = "";
   let files = [];
   try {
-    const pkgJsonRaw = await readFile28(resolve19(pkgDir, "package.json"), "utf-8");
+    const pkgJsonRaw = await readFile29(resolve19(pkgDir, "package.json"), "utf-8");
     const pkgJson = JSON.parse(pkgJsonRaw);
     pkgName = pkgJson.name ?? "";
     pkgVersion = pkgJson.version ?? "";
@@ -45414,7 +45513,7 @@ async function executeAdapterPack(packageDirectory, options) {
     return ExitCode.SchemaInvalid;
   }
   const outputDir = options.output ? resolve19(options.output) : resolve19(pkgDir, "dist-package");
-  await mkdir17(outputDir, { recursive: true });
+  await mkdir18(outputDir, { recursive: true });
   const tarballName = `${pkgName.replace(/^@/, "").replace(/\//g, "-")}-${pkgVersion}.tgz`;
   const tarballPath = resolve19(outputDir, tarballName);
   try {
@@ -45429,7 +45528,7 @@ async function executeAdapterPack(packageDirectory, options) {
     }
     return ExitCode.ExecuteFailed;
   }
-  const tarballContent = await readFile28(tarballPath);
+  const tarballContent = await readFile29(tarballPath);
   const sri = "sha512-" + createHash14("sha512").update(tarballContent).digest("base64");
   if (output.json) {
     emitSuccessJson("extension adapter pack", {
@@ -45615,7 +45714,7 @@ var init_journal_helper = __esm({
 
 // packages/cli/src/commands/service-locator.ts
 import { homedir as homedir2 } from "node:os";
-import { join as join20, resolve as resolve20 } from "node:path";
+import { join as join22, resolve as resolve20 } from "node:path";
 var ServiceLocator;
 var init_service_locator = __esm({
   "packages/cli/src/commands/service-locator.ts"() {
@@ -45649,13 +45748,13 @@ var init_service_locator = __esm({
         return `mano-coding@${this.config.cliVersion}`;
       }
       getUserDataDir() {
-        return this.config.userDataDir ?? process.env["MANO_USER_DATA"] ?? process.env["AICODING_USER_DATA"] ?? join20(homedir2(), ".mano-coding");
+        return this.config.userDataDir ?? process.env["MANO_USER_DATA"] ?? process.env["AICODING_USER_DATA"] ?? join22(homedir2(), ".mano-coding");
       }
       getRegistryUrl() {
         return this.config.registryUrl || process.env["MANO_REGISTRY"] || process.env["AICODING_REGISTRY"] || DEFAULT_PUBLIC_REGISTRY_URL;
       }
       getCacheRoot() {
-        return this.config.cacheRoot ?? join20(this.getUserDataDir(), "cache");
+        return this.config.cacheRoot ?? join22(this.getUserDataDir(), "cache");
       }
       getRegistryClient() {
         if (!this._registryClient) {
@@ -45810,8 +45909,8 @@ var init_service_locator = __esm({
 });
 
 // packages/cli/src/commands/plan-execution.ts
-import { readFile as readFile29, readdir as readdir9, stat as stat6 } from "node:fs/promises";
-import { join as join21, resolve as resolve21 } from "node:path";
+import { readFile as readFile30, readdir as readdir10, stat as stat7 } from "node:fs/promises";
+import { join as join23, resolve as resolve21 } from "node:path";
 import { createHash as createHash15 } from "node:crypto";
 async function buildIntentsFromPlan(_plan, resolutions, service, projectTargets, _userInstallationKeys, options) {
   const adapterRegistry = service.getAdapterRegistry();
@@ -45920,14 +46019,14 @@ async function executeUserCapabilityInstallations(_resolutions, _service, _input
 }
 async function collectAssetIntents(packageRoot, source, destination, metadata) {
   const sourcePath = resolve21(packageRoot, source);
-  const sourceStat = await stat6(sourcePath);
+  const sourceStat = await stat7(sourcePath);
   if (sourceStat.isFile()) {
-    return [{ action: "upsert", type: "file", path: destination, content: await readFile29(sourcePath), executable: metadata.executable, packageId: metadata.packageId, ownerKind: metadata.ownerKind }];
+    return [{ action: "upsert", type: "file", path: destination, content: await readFile30(sourcePath), executable: metadata.executable, packageId: metadata.packageId, ownerKind: metadata.ownerKind }];
   }
   if (!sourceStat.isDirectory()) throw new Error(`Asset '${source}' \u65E2\u4E0D\u662F\u6587\u4EF6\u4E5F\u4E0D\u662F\u76EE\u5F55`);
   const intents = [];
-  for (const entry of await readdir9(sourcePath, { withFileTypes: true })) {
-    intents.push(...await collectAssetIntents(packageRoot, join21(source, entry.name), join21(destination, entry.name).replaceAll("\\", "/"), metadata));
+  for (const entry of await readdir10(sourcePath, { withFileTypes: true })) {
+    intents.push(...await collectAssetIntents(packageRoot, join23(source, entry.name), join23(destination, entry.name).replaceAll("\\", "/"), metadata));
   }
   return intents;
 }
@@ -46764,243 +46863,300 @@ ${taskValidation.missingInputs.map((k2) => `--input ${pkgId}:${k2}=<value>`).joi
     await service.registerThirdPartyAdapters(
       allResolutions.map((r) => ({ manifest: r.manifest, resolution: r }))
     );
-    const planStartedAt = Date.now();
-    const planBuilder = service.getPlanBuilder();
-    let planResult = planBuilder.build(
-      "create",
-      service.projectRoot,
-      allResolutions,
-      projectTargets
-    );
-    const userInstallationKeys = /* @__PURE__ */ new Set();
-    const intents = await withSpinner(
-      "\u6B63\u5728\u8BA1\u7B97\u53D7\u7BA1\u8D44\u6E90\u5E76\u751F\u6210\u6267\u884C\u8BA1\u5212...",
-      () => buildIntentsFromPlan(planResult.plan, allResolutions, service, projectTargets, userInstallationKeys),
-      {
-        enabled: spinnerEnabled,
-        successText: (res) => `\u2714 \u6267\u884C\u8BA1\u5212\u5DF2\u5C31\u7EEA (\u5171 ${res.length} \u9879\u8D44\u6E90\u53D8\u66F4)`,
-        failText: "\u2716 \u6267\u884C\u8BA1\u5212\u751F\u6210\u5931\u8D25"
-      }
-    );
-    planResult = materializePlan(planResult.plan, intents);
-    events.report("plan", "success", Date.now() - planStartedAt, { planDigest: planResult.plan.planDigest, details: { intentCount: intents.length } });
-    if (planResult.conflicts.length > 0) {
-      events.report("plan", "failure", 0, { errorCode: "PLAN_CONFLICT", planDigest: planResult.plan.planDigest });
-      const conflictDiags = planResult.conflicts.flatMap((c) => c.diagnostics);
-      writeDiagnostics(conflictDiags, output);
-      if (output.json) {
-        emitFailureJson(
-          "create",
-          "PLAN_CONFLICT",
-          t("create.planConflict"),
-          { conflicts: planResult.conflicts.map((c) => ({ type: c.type, resourceKey: c.resourceKey })) },
-          [],
-          conflictDiags,
-          jsonEvents()
-        );
-      } else {
-        process.stderr.write(`error: PLAN_CONFLICT: ${t("create.planConflict")}
-`);
+    const stagingManager = new StagingManager();
+    try {
+      const hasBeforeCreate = allResolutions.some((res) => {
+        const tasks = res.manifest.tasks ?? [];
+        return filterTasksByHook2(tasks, "before:create").length > 0;
+      });
+      const stagingDirMap = /* @__PURE__ */ new Map();
+      if (hasBeforeCreate) {
+        for (const res of allResolutions) {
+          const tasks = res.manifest.tasks ?? [];
+          if (filterTasksByHook2(tasks, "before:create").length > 0) {
+            const sDir = await stagingManager.getOrCreateStagingDir(res.manifest.id);
+            stagingDirMap.set(res.manifest.id, sDir);
+          }
+        }
       }
-      return ExitCode.ConflictOrDrift;
-    }
-    let grantedPermissions = [];
-    if (!options.dryRun && !options.yes) {
-      if (options.noInput || !process.stdin.isTTY) {
-        events.report("authorize", "failure", 0, { errorCode: "NEEDS_CONFIRMATION", planDigest: planResult.plan.planDigest });
+      const planStartedAt = Date.now();
+      const planBuilder = service.getPlanBuilder();
+      let planResult = planBuilder.build(
+        "create",
+        service.projectRoot,
+        allResolutions,
+        projectTargets
+      );
+      const userInstallationKeys = /* @__PURE__ */ new Set();
+      let staticIntents = await withSpinner(
+        "\u6B63\u5728\u8BA1\u7B97\u53D7\u7BA1\u8D44\u6E90\u5E76\u751F\u6210\u6267\u884C\u8BA1\u5212...",
+        () => buildIntentsFromPlan(planResult.plan, allResolutions, service, projectTargets, userInstallationKeys),
+        {
+          enabled: spinnerEnabled,
+          successText: (res) => `\u2714 \u6267\u884C\u8BA1\u5212\u5DF2\u5C31\u7EEA (\u5171 ${res.length} \u9879\u8D44\u6E90\u53D8\u66F4)`,
+          failText: "\u2716 \u6267\u884C\u8BA1\u5212\u751F\u6210\u5931\u8D25"
+        }
+      );
+      planResult = materializePlan(planResult.plan, staticIntents);
+      events.report("plan", "success", Date.now() - planStartedAt, { planDigest: planResult.plan.planDigest, details: { intentCount: staticIntents.length } });
+      if (planResult.conflicts.length > 0) {
+        events.report("plan", "failure", 0, { errorCode: "PLAN_CONFLICT", planDigest: planResult.plan.planDigest });
+        const conflictDiags = planResult.conflicts.flatMap((c) => c.diagnostics);
+        writeDiagnostics(conflictDiags, output);
         if (output.json) {
           emitFailureJson(
             "create",
-            "NEEDS_CONFIRMATION",
-            t("create.needsConfirmation"),
-            { planDigest: planResult.plan.planDigest },
-            [],
+            "PLAN_CONFLICT",
+            t("create.planConflict"),
+            { conflicts: planResult.conflicts.map((c) => ({ type: c.type, resourceKey: c.resourceKey })) },
             [],
+            conflictDiags,
             jsonEvents()
           );
         } else {
-          process.stderr.write(
-            `error: NEEDS_CONFIRMATION: ${t("create.needsConfirmation")}
+          process.stderr.write(`error: PLAN_CONFLICT: ${t("create.planConflict")}
+`);
+        }
+        return ExitCode.ConflictOrDrift;
+      }
+      let grantedPermissions = [];
+      if (!options.dryRun && !options.yes) {
+        if (options.noInput || !process.stdin.isTTY) {
+          events.report("authorize", "failure", 0, { errorCode: "NEEDS_CONFIRMATION", planDigest: planResult.plan.planDigest });
+          if (output.json) {
+            emitFailureJson(
+              "create",
+              "NEEDS_CONFIRMATION",
+              t("create.needsConfirmation"),
+              { planDigest: planResult.plan.planDigest },
+              [],
+              [],
+              jsonEvents()
+            );
+          } else {
+            process.stderr.write(
+              `error: NEEDS_CONFIRMATION: ${t("create.needsConfirmation")}
 `
-          );
+            );
+          }
+          return ExitCode.NeedsInputOrDenied;
         }
-        return ExitCode.NeedsInputOrDenied;
+        const { confirmPlanInteractive: confirmPlanInteractive2 } = await Promise.resolve().then(() => (init_tty_confirm(), tty_confirm_exports));
+        const confirmResult = await confirmPlanInteractive2({
+          output,
+          command: "create",
+          plan: planResult.plan,
+          allowedPermissions: options.allow
+        });
+        if (!confirmResult.confirmed) {
+          events.report("authorize", "failure", 0, { errorCode: "PERMISSION_DENIED", planDigest: planResult.plan.planDigest });
+          if (output.json) {
+            emitFailureJson("create", "PERMISSION_DENIED", t("create.userDeclined"), { planDigest: planResult.plan.planDigest }, [], [], jsonEvents());
+          } else {
+            process.stderr.write(`error: PERMISSION_DENIED: ${t("create.userDeclined")}
+`);
+          }
+          return ExitCode.NeedsInputOrDenied;
+        }
+        events.report("authorize", "success", 0, { planDigest: planResult.plan.planDigest });
+        grantedPermissions = confirmResult.granted;
       }
-      const { confirmPlanInteractive: confirmPlanInteractive2 } = await Promise.resolve().then(() => (init_tty_confirm(), tty_confirm_exports));
-      const confirmResult = await confirmPlanInteractive2({
-        output,
-        command: "create",
-        plan: planResult.plan,
-        allowedPermissions: options.allow
-      });
-      if (!confirmResult.confirmed) {
-        events.report("authorize", "failure", 0, { errorCode: "PERMISSION_DENIED", planDigest: planResult.plan.planDigest });
+      if (options.dryRun) {
+        events.report("authorize", "skipped", 0, { planDigest: planResult.plan.planDigest });
+        events.report("execute", "skipped", 0, { planDigest: planResult.plan.planDigest });
+        events.report("record", "skipped", 0, { planDigest: planResult.plan.planDigest });
+        const summary2 = summarizePlan(planResult.plan);
         if (output.json) {
-          emitFailureJson("create", "PERMISSION_DENIED", t("create.userDeclined"), { planDigest: planResult.plan.planDigest }, [], [], jsonEvents());
+          emitSuccessJson("create", { dryRun: true, ...summary2 }, [], [], jsonEvents());
         } else {
-          process.stderr.write(`error: PERMISSION_DENIED: ${t("create.userDeclined")}
-`);
+          printPlanSummary(summary2);
         }
-        return ExitCode.NeedsInputOrDenied;
-      }
-      events.report("authorize", "success", 0, { planDigest: planResult.plan.planDigest });
-      grantedPermissions = confirmResult.granted;
-    }
-    if (options.dryRun) {
-      events.report("authorize", "skipped", 0, { planDigest: planResult.plan.planDigest });
-      events.report("execute", "skipped", 0, { planDigest: planResult.plan.planDigest });
-      events.report("record", "skipped", 0, { planDigest: planResult.plan.planDigest });
-      const summary2 = summarizePlan(planResult.plan);
-      if (output.json) {
-        emitSuccessJson("create", { dryRun: true, ...summary2 }, [], [], jsonEvents());
-      } else {
-        printPlanSummary(summary2);
+        return ExitCode.Success;
       }
-      return ExitCode.Success;
-    }
-    const { basename: basename8, dirname: dirname20 } = await import("node:path");
-    for (let pkgIdx = 0; pkgIdx < allResolutions.length; pkgIdx++) {
-      const resolution = allResolutions[pkgIdx];
-      const pkgTasks = filterTasksByHook2(resolution.manifest.tasks ?? [], "before:create");
-      if (pkgTasks.length > 0) {
-        const templateDir = service.getPackageRoot(resolution) ?? service.projectRoot;
-        const taskContext = {
-          projectName: basename8(service.projectRoot),
-          projectDir: service.projectRoot,
-          projectParentDir: dirname20(service.projectRoot),
-          templateDir,
-          inputs: { ...inputValues, ...packageValues[resolution.manifest.id] ?? {} },
-          target: projectTargets[0]?.id,
-          targets: projectTargets.map((t2) => t2.id),
-          operation: "create",
-          version: resolution.manifest.version
-        };
-        if (!output.json) {
-          writeHumanOutput(`
+      const { basename: basename8, dirname: dirname20 } = await import("node:path");
+      const dynamicIntents = [];
+      for (let pkgIdx = 0; pkgIdx < allResolutions.length; pkgIdx++) {
+        const resolution = allResolutions[pkgIdx];
+        const pkgTasks = filterTasksByHook2(resolution.manifest.tasks ?? [], "before:create");
+        if (pkgTasks.length > 0) {
+          const templateDir = service.getPackageRoot(resolution) ?? service.projectRoot;
+          const stagingDir = stagingDirMap.get(resolution.manifest.id);
+          const taskContext = {
+            projectName: basename8(service.projectRoot),
+            projectDir: service.projectRoot,
+            projectParentDir: dirname20(service.projectRoot),
+            templateDir,
+            stagingDir,
+            inputs: { ...inputValues, ...packageValues[resolution.manifest.id] ?? {} },
+            target: projectTargets[0]?.id,
+            targets: projectTargets.map((t2) => t2.id),
+            operation: "create",
+            version: resolution.manifest.version
+          };
+          if (!output.json) {
+            writeHumanOutput(`
 \u6B63\u5728\u6267\u884C\u524D\u7F6E\u521B\u5EFA\u4EFB\u52A1 (before:create) [${pkgIdx + 1}/${allResolutions.length}] (${resolution.manifest.id}):
 `);
-        }
-        try {
-          await executeTasks2(pkgTasks, taskContext, {
-            onProgress: (msg) => {
-              if (!output.json) writeHumanOutput(`> ${msg}
+          }
+          try {
+            await executeTasks2(pkgTasks, taskContext, {
+              onProgress: (msg) => {
+                if (!output.json) writeHumanOutput(`> ${msg}
 `);
-            },
-            stdio: output.json ? "ignore" : "inherit"
-          });
-        } catch (err) {
-          if (err instanceof Error) {
-            throw new CliError(err.message, ExitCode.ExecuteFailed, "TASK_EXECUTION_FAILED");
+              },
+              stdio: output.json ? "ignore" : "inherit"
+            });
+          } catch (err) {
+            if (err instanceof Error) {
+              throw new CliError(err.message, ExitCode.ExecuteFailed, "TASK_EXECUTION_FAILED");
+            }
+            throw err;
+          }
+          if (stagingDir) {
+            const scanRes = await scanStagingDirectory({
+              stagingDir,
+              packageId: resolution.manifest.id,
+              ownerKind: "template"
+            });
+            dynamicIntents.push(...scanRes.intents);
           }
-          throw err;
         }
       }
-    }
-    const executor = service.getExecutor();
-    const executeStartedAt = Date.now();
-    if (!output.json) writeHumanOutput(t("create.writingResources", intents.length));
-    const { journal, result: executeResult } = await withJournalTransaction(service, async (journal2) => {
-      await prepareJournalRecovery(journal2, service.projectRoot, intents, ["aicoding-lock.yaml"]);
-      return executor.execute(
-        planResult.plan,
-        intents,
-        {
-          projectRoot: service.projectRoot,
-          dryRun: false,
-          deferCommit: true
+      let intents = staticIntents;
+      if (hasBeforeCreate && dynamicIntents.length > 0) {
+        const mergedIntents = deduplicateIntents([...staticIntents, ...dynamicIntents]);
+        planResult = materializePlan(planResult.plan, mergedIntents);
+        if (planResult.conflicts.length > 0) {
+          events.report("plan", "failure", 0, { errorCode: "PLAN_CONFLICT", planDigest: planResult.plan.planDigest });
+          const conflictDiags = planResult.conflicts.flatMap((c) => c.diagnostics);
+          writeDiagnostics(conflictDiags, output);
+          if (output.json) {
+            emitFailureJson(
+              "create",
+              "PLAN_CONFLICT",
+              t("create.planConflict"),
+              { conflicts: planResult.conflicts.map((c) => ({ type: c.type, resourceKey: c.resourceKey })) },
+              [],
+              conflictDiags,
+              jsonEvents()
+            );
+          } else {
+            process.stderr.write(`error: PLAN_CONFLICT: ${t("create.planConflict")}
+`);
+          }
+          return ExitCode.ConflictOrDrift;
         }
-      );
-    });
-    if (!executeResult.success) {
-      events.report("execute", "failure", Date.now() - executeStartedAt, { errorCode: "EXECUTE_FAILED", planDigest: planResult.plan.planDigest });
-      writeDiagnostics(executeResult.diagnostics, output);
-      if (output.json) {
-        emitFailureJson(
-          "create",
-          "EXECUTE_FAILED",
-          t("create.executionFailed"),
-          { planDigest: planResult.plan.planDigest, operationId: journal.operationId },
-          [],
-          executeResult.diagnostics,
-          jsonEvents()
+        intents = mergedIntents;
+      }
+      const executor = service.getExecutor();
+      const executeStartedAt = Date.now();
+      if (!output.json) writeHumanOutput(t("create.writingResources", intents.length));
+      const { journal, result: executeResult } = await withJournalTransaction(service, async (journal2) => {
+        await prepareJournalRecovery(journal2, service.projectRoot, intents, ["aicoding-lock.yaml"]);
+        return executor.execute(
+          planResult.plan,
+          intents,
+          {
+            projectRoot: service.projectRoot,
+            dryRun: false,
+            deferCommit: true
+          }
         );
-      } else {
-        process.stderr.write(`error: EXECUTE_FAILED: ${t("create.executionFailedShort")}
+      });
+      if (!executeResult.success) {
+        events.report("execute", "failure", Date.now() - executeStartedAt, { errorCode: "EXECUTE_FAILED", planDigest: planResult.plan.planDigest });
+        writeDiagnostics(executeResult.diagnostics, output);
+        if (output.json) {
+          emitFailureJson(
+            "create",
+            "EXECUTE_FAILED",
+            t("create.executionFailed"),
+            { planDigest: planResult.plan.planDigest, operationId: journal.operationId },
+            [],
+            executeResult.diagnostics,
+            jsonEvents()
+          );
+        } else {
+          process.stderr.write(`error: EXECUTE_FAILED: ${t("create.executionFailedShort")}
 `);
-      }
-      return ExitCode.ExecuteFailed;
-    }
-    events.report("execute", "success", Date.now() - executeStartedAt, { planDigest: planResult.plan.planDigest, details: { intentCount: intents.length } });
-    if (!output.json) writeHumanOutput(t("create.wroteResources", formatElapsed(executeStartedAt)));
-    const previousLock = await lockRepo.read().catch(() => void 0);
-    const recordStartedAt = Date.now();
-    await commitExecution(executor, executeResult, async (addRollback) => {
-      const userInstallationStartedAt = Date.now();
-      if (!output.json && userInstallationKeys.size > 0) writeHumanOutput(t("create.installingUserTools", userInstallationKeys.size));
-      const userLifecycle = await executeUserCapabilityInstallations(
-        allResolutions,
-        service,
-        inputValues,
-        [...options.allow, ...grantedPermissions],
-        userInstallationKeys,
-        journal,
-        output.json ? void 0 : (progress) => writeUserInstallationProgress(progress)
-      );
-      if (!output.json && userInstallationKeys.size > 0) writeHumanOutput(t("create.userToolsInstalled", formatElapsed(userInstallationStartedAt)));
-      addRollback(userLifecycle.rollback);
-      const lock = await buildLock("create", templateResolution, addonResolutions, projectTargets, planResult.plan, service.cliVersion, inputValues, service, intents, userInstallationKeys);
-      await lockRepo.write(lock);
-      addRollback(async () => previousLock ? lockRepo.write(previousLock) : unlink9(lockRepo.path).catch(() => void 0));
-      await userLifecycle.addReferences(lock);
-      await finishJournal(journal);
-    });
-    events.report("record", "success", Date.now() - recordStartedAt, { planDigest: planResult.plan.planDigest });
-    for (let pkgIdx = 0; pkgIdx < allResolutions.length; pkgIdx++) {
-      const resolution = allResolutions[pkgIdx];
-      const pkgTasks = filterTasksByHook2(resolution.manifest.tasks ?? [], "after:create");
-      if (pkgTasks.length > 0) {
-        const templateDir = service.getPackageRoot(resolution) ?? service.projectRoot;
-        const taskContext = {
-          projectName: basename8(service.projectRoot),
-          projectDir: service.projectRoot,
-          projectParentDir: dirname20(service.projectRoot),
-          templateDir,
-          inputs: { ...inputValues, ...packageValues[resolution.manifest.id] ?? {} },
-          target: projectTargets[0]?.id,
-          targets: projectTargets.map((t2) => t2.id),
-          operation: "create",
-          version: resolution.manifest.version
-        };
-        if (!output.json) {
-          writeHumanOutput(`
+        }
+        return ExitCode.ExecuteFailed;
+      }
+      events.report("execute", "success", Date.now() - executeStartedAt, { planDigest: planResult.plan.planDigest, details: { intentCount: intents.length } });
+      if (!output.json) writeHumanOutput(t("create.wroteResources", formatElapsed(executeStartedAt)));
+      const previousLock = await lockRepo.read().catch(() => void 0);
+      const recordStartedAt = Date.now();
+      await commitExecution(executor, executeResult, async (addRollback) => {
+        const userInstallationStartedAt = Date.now();
+        if (!output.json && userInstallationKeys.size > 0) writeHumanOutput(t("create.installingUserTools", userInstallationKeys.size));
+        const userLifecycle = await executeUserCapabilityInstallations(
+          allResolutions,
+          service,
+          inputValues,
+          [...options.allow, ...grantedPermissions],
+          userInstallationKeys,
+          journal,
+          output.json ? void 0 : (progress) => writeUserInstallationProgress(progress)
+        );
+        if (!output.json && userInstallationKeys.size > 0) writeHumanOutput(t("create.userToolsInstalled", formatElapsed(userInstallationStartedAt)));
+        addRollback(userLifecycle.rollback);
+        const lock = await buildLock("create", templateResolution, addonResolutions, projectTargets, planResult.plan, service.cliVersion, inputValues, service, intents, userInstallationKeys);
+        await lockRepo.write(lock);
+        addRollback(async () => previousLock ? lockRepo.write(previousLock) : unlink9(lockRepo.path).catch(() => void 0));
+        await userLifecycle.addReferences(lock);
+        await finishJournal(journal);
+      });
+      events.report("record", "success", Date.now() - recordStartedAt, { planDigest: planResult.plan.planDigest });
+      for (let pkgIdx = 0; pkgIdx < allResolutions.length; pkgIdx++) {
+        const resolution = allResolutions[pkgIdx];
+        const pkgTasks = filterTasksByHook2(resolution.manifest.tasks ?? [], "after:create");
+        if (pkgTasks.length > 0) {
+          const templateDir = service.getPackageRoot(resolution) ?? service.projectRoot;
+          const taskContext = {
+            projectName: basename8(service.projectRoot),
+            projectDir: service.projectRoot,
+            projectParentDir: dirname20(service.projectRoot),
+            templateDir,
+            inputs: { ...inputValues, ...packageValues[resolution.manifest.id] ?? {} },
+            target: projectTargets[0]?.id,
+            targets: projectTargets.map((t2) => t2.id),
+            operation: "create",
+            version: resolution.manifest.version
+          };
+          if (!output.json) {
+            writeHumanOutput(`
 \u6B63\u5728\u6267\u884C\u540E\u7F6E\u521D\u59CB\u5316\u4EFB\u52A1 (after:create) [${pkgIdx + 1}/${allResolutions.length}] (${resolution.manifest.id}):
 `);
-        }
-        try {
-          await executeTasks2(pkgTasks, taskContext, {
-            onProgress: (msg) => {
-              if (!output.json) writeHumanOutput(`> [${resolution.manifest.id}] ${msg}
+          }
+          try {
+            await executeTasks2(pkgTasks, taskContext, {
+              onProgress: (msg) => {
+                if (!output.json) writeHumanOutput(`> [${resolution.manifest.id}] ${msg}
 `);
-            },
-            stdio: output.json ? "ignore" : "inherit"
-          });
-        } catch (err) {
-          if (err instanceof Error) {
-            throw new CliError(err.message, ExitCode.ExecuteFailed, "TASK_EXECUTION_FAILED");
+              },
+              stdio: output.json ? "ignore" : "inherit"
+            });
+          } catch (err) {
+            if (err instanceof Error) {
+              throw new CliError(err.message, ExitCode.ExecuteFailed, "TASK_EXECUTION_FAILED");
+            }
+            throw err;
           }
-          throw err;
         }
       }
+      const summary = summarizePlan(planResult.plan);
+      if (output.json) {
+        emitSuccessJson("create", { dryRun: false, ...summary, lockPath: lockRepo.path, operationId: journal.operationId }, [], [], jsonEvents());
+      } else {
+        printPlanSummary(summary);
+        writeHumanOutput(t("create.createdProject", service.projectRoot) + "\n");
+        writeHumanOutput(t("create.lockFile", lockRepo.path) + "\n");
+      }
+      return ExitCode.Success;
+    } finally {
+      await stagingManager.cleanup().catch(() => {
+      });
     }
-    const summary = summarizePlan(planResult.plan);
-    if (output.json) {
-      emitSuccessJson("create", { dryRun: false, ...summary, lockPath: lockRepo.path, operationId: journal.operationId }, [], [], jsonEvents());
-    } else {
-      printPlanSummary(summary);
-      writeHumanOutput(t("create.createdProject", service.projectRoot) + "\n");
-      writeHumanOutput(t("create.lockFile", lockRepo.path) + "\n");
-    }
-    return ExitCode.Success;
   });
 }
 function formatElapsed(startedAt) {
@@ -47052,7 +47208,6 @@ var init_create = __esm({
     init_src2();
     init_resolve_helper();
     init_journal_helper();
-    init_src2();
     init_shared_options();
     init_cli_output();
     init_service_locator();
@@ -47984,8 +48139,8 @@ var init_config = __esm({
 
 // packages/cli/src/commands/remove.ts
 import { randomUUID as randomUUID9 } from "node:crypto";
-import { unlink as unlink11, readFile as readFile30 } from "node:fs/promises";
-import { basename as basename6, dirname as dirname18, join as join22, resolve as resolve23 } from "node:path";
+import { unlink as unlink11, readFile as readFile31 } from "node:fs/promises";
+import { basename as basename6, dirname as dirname18, join as join24, resolve as resolve23 } from "node:path";
 function createRemoveCommand(cliVersion) {
   const cmd = new Command("remove");
   cmd.description(t("remove.description")).option("--package <package-id>", t("remove.optionPackage")).action(async (opts) => {
@@ -48162,7 +48317,7 @@ async function executeRemove(packageId, options, cliVersion, events) {
         templateDir = service.projectRoot;
       }
       try {
-        const manifestContent = await readFile30(join22(templateDir, "manifest.yaml"), "utf-8");
+        const manifestContent = await readFile31(join24(templateDir, "manifest.yaml"), "utf-8");
         const parsed = parseManifest(manifestContent);
         if (parsed.manifest) {
           packageManifests.push({
@@ -48735,7 +48890,7 @@ var init_inspect = __esm({
 // packages/cli/src/commands/doctor.ts
 import { execFile as execFile6 } from "node:child_process";
 import { createHash as createHash16 } from "node:crypto";
-import { access as access11, readFile as readFile31 } from "node:fs/promises";
+import { access as access11, readFile as readFile32 } from "node:fs/promises";
 import { resolve as resolve25 } from "node:path";
 import { promisify as promisify7 } from "node:util";
 function createDoctorCommand(cliVersion) {
@@ -48809,7 +48964,7 @@ async function checkSecretReferences(findings, projectRoot, lock) {
       const sourcePath = pkg.source.path ?? ".";
       const manifestPath = resolve25(projectRoot, sourcePath, "manifest.yaml");
       try {
-        const manifestContent = await readFile31(manifestPath, "utf-8");
+        const manifestContent = await readFile32(manifestPath, "utf-8");
         const manifest = parseManifest(manifestContent).manifest;
         if (!manifest.capabilities) continue;
         for (const cap of manifest.capabilities) {
@@ -49191,7 +49346,7 @@ async function executeDoctor(projectRoot, repair, drift, yes, online, offline, c
     });
   }
   try {
-    const stateLock = JSON.parse(await readFile31(`${lockRepo.path}.lock`, "utf8"));
+    const stateLock = JSON.parse(await readFile32(`${lockRepo.path}.lock`, "utf8"));
     findings.push({ severity: "warning", code: "DOCTOR_TRANSACTION_LOCK", message: `\u53D1\u73B0\u672A\u91CA\u653E\u7684\u72B6\u6001\u9501 (pid=${String(stateLock.pid ?? "unknown")})`, category: "transaction", path: `${lockRepo.path}.lock`, fix: "\u786E\u8BA4\u5BF9\u5E94\u8FDB\u7A0B\u5DF2\u9000\u51FA\u540E\u518D\u6B21\u5199\u5165\uFF0C\u7CFB\u7EDF\u4F1A\u6E05\u7406\u5931\u6548\u9501" });
   } catch (error) {
     if (error.code !== "ENOENT") findings.push({ severity: "warning", code: "DOCTOR_TRANSACTION_LOCK_INVALID", message: "\u72B6\u6001\u9501\u6587\u4EF6\u65E0\u6CD5\u89E3\u6790", category: "transaction" });
@@ -49634,8 +49789,8 @@ var init_upgrade = __esm({
 
 // packages/cli/src/commands/cache.ts
 import { homedir as homedir3 } from "node:os";
-import { join as join23, resolve as resolve26 } from "node:path";
-import { rm as rm7, stat as stat7 } from "node:fs/promises";
+import { join as join25, resolve as resolve26 } from "node:path";
+import { rm as rm7, stat as stat8 } from "node:fs/promises";
 function createCacheCommand(cliVersion) {
   const cmd = new Command("cache");
   cmd.description(t("cache.description"));
@@ -49676,7 +49831,7 @@ function createCacheCommand(cliVersion) {
   return cmd;
 }
 function getUserDataDir() {
-  return process.env["MANO_USER_DATA"] ?? process.env["AICODING_USER_DATA"] ?? join23(homedir3(), ".mano-coding");
+  return process.env["MANO_USER_DATA"] ?? process.env["AICODING_USER_DATA"] ?? join25(homedir3(), ".mano-coding");
 }
 function parsePositiveInt(value, name) {
   if (value === void 0) return void 0;
@@ -49821,7 +49976,7 @@ async function executeGc(opts, cliVersion) {
       continue;
     }
     try {
-      const stats = await stat7(rootPath);
+      const stats = await stat8(rootPath);
       if (!stats.isDirectory()) {
         failedRoots.push(`${rootPath} (${t("cache.notDirectory")})`);
         continue;
@@ -49878,8 +50033,8 @@ async function executeClean(opts, cliVersion) {
       throw new CliError(t("cache.cleanRequiresYes"), ExitCode.NeedsInputOrDenied, "NEEDS_CONFIRMATION");
     }
     if (cleanRegistry && !dryRun) await updateCache.clear();
-    if (cleanAudit && !dryRun) await rm7(join23(userDataDir, "audit"), { recursive: true, force: true });
-    if (!dryRun) await rm7(join23(userDataDir, "cache"), { recursive: true, force: true });
+    if (cleanAudit && !dryRun) await rm7(join25(userDataDir, "audit"), { recursive: true, force: true });
+    if (!dryRun) await rm7(join25(userDataDir, "cache"), { recursive: true, force: true });
     if (json) {
       emitSuccessJson("cache clean", { dryRun, cleanedLeases: 0, clearedUpdateCache: cleanRegistry, clearedAudit: cleanAudit, message: t("cache.noInstallationsClean") });
     } else {
@@ -49894,8 +50049,8 @@ async function executeClean(opts, cliVersion) {
       throw new CliError(t("cache.cleanRequiresYes"), ExitCode.NeedsInputOrDenied, "NEEDS_CONFIRMATION");
     }
     if (cleanRegistry && !dryRun) await updateCache.clear();
-    if (cleanAudit && !dryRun) await rm7(join23(userDataDir, "audit"), { recursive: true, force: true });
-    if (!dryRun) await rm7(join23(userDataDir, "cache"), { recursive: true, force: true });
+    if (cleanAudit && !dryRun) await rm7(join25(userDataDir, "audit"), { recursive: true, force: true });
+    if (!dryRun) await rm7(join25(userDataDir, "cache"), { recursive: true, force: true });
     if (json) {
       emitSuccessJson("cache clean", { dryRun, cleanedLeases: 0, clearedUpdateCache: cleanRegistry, clearedAudit: cleanAudit, message: t("cache.noInstallationsClean") });
     } else {
@@ -49940,8 +50095,8 @@ async function executeClean(opts, cliVersion) {
     totalCleaned += cleaned;
   }
   if (cleanRegistry && !dryRun) await updateCache.clear();
-  if (cleanAudit && !dryRun) await rm7(join23(userDataDir, "audit"), { recursive: true, force: true });
-  if (!dryRun) await rm7(join23(userDataDir, "cache"), { recursive: true, force: true });
+  if (cleanAudit && !dryRun) await rm7(join25(userDataDir, "audit"), { recursive: true, force: true });
+  if (!dryRun) await rm7(join25(userDataDir, "cache"), { recursive: true, force: true });
   if (json) {
     emitSuccessJson("cache clean", { dryRun: false, cleanedLeases: totalCleaned, clearedUpdateCache: cleanRegistry, clearedAudit: cleanAudit });
   } else {
@@ -49963,7 +50118,7 @@ var init_cache = __esm({
 // packages/cli/src/commands/launch.ts
 import { spawn as spawn2 } from "node:child_process";
 import { homedir as homedir4 } from "node:os";
-import { join as join24 } from "node:path";
+import { join as join26 } from "node:path";
 function createLaunchCommand() {
   const cmd = new Command("_launch");
   cmd.description(t("launch.description")).option("--kind <kind>", t("launch.optionKind")).option("--package <package-id>", t("launch.optionPackage")).option("--id <id>", t("launch.optionId")).option("--version <version>", t("launch.optionVersion")).option("--command <name>", t("launch.optionCommand")).allowUnknownOption(true).allowExcessArguments(true).action(async (_opts, command) => {
@@ -49996,7 +50151,7 @@ function createLaunchCommand() {
   return cmd;
 }
 function getUserDataDir2() {
-  return process.env["AICODING_USER_DATA"] ?? join24(homedir4(), ".aicoding");
+  return process.env["AICODING_USER_DATA"] ?? join26(homedir4(), ".aicoding");
 }
 async function executeLaunch(launcherArgs) {
   const userDataDir = getUserDataDir2();
@@ -50047,9 +50202,9 @@ var init_launch = __esm({
 
 // packages/cli/src/commands/self-upgrade.ts
 import { spawn as spawn3 } from "node:child_process";
-import { readFile as readFile32, realpath as realpath2 } from "node:fs/promises";
+import { readFile as readFile33, realpath as realpath2 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
-import { extname, join as join25, resolve as resolve27 } from "node:path";
+import { extname, join as join27, resolve as resolve27 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline/promises";
 import { stdin, stderr } from "node:process";
 function createSelfUpgradeCommand(cliVersion) {
@@ -50111,7 +50266,7 @@ async function executeSelfUpgrade(options, cliVersion) {
   });
   await auditLog.prune().catch(() => void 0);
   try {
-    const result = await withStateLock(join25(userDataDir, "cli-update"), async () => {
+    const result = await withStateLock(join27(userDataDir, "cli-update"), async () => {
       const target = await resolveTarget(options, cacheRepository, registry);
       ensureTargetAllowed(target.version, installation.currentVersion, options.allowDowngrade);
       if (!isCliVersionCompatible(process.version, target.enginesNode)) {
@@ -50163,7 +50318,7 @@ function validateOptions(options) {
   }
 }
 function getUserDataDir3() {
-  return process.env["AICODING_USER_DATA"] ?? join25(homedir5(), ".aicoding");
+  return process.env["AICODING_USER_DATA"] ?? join27(homedir5(), ".aicoding");
 }
 function getRegistryUrl() {
   const raw = process.env["AICODING_NPM_REGISTRY"] || DEFAULT_NPM_REGISTRY;
@@ -50276,13 +50431,13 @@ async function detectGlobalCliInstallation(cliPath = process.argv[1], runner = r
 }
 async function isWindowsCmdShimFor(shimPath, expectedBin) {
   if (process.platform !== "win32" || extname(shimPath).toLowerCase() !== ".cmd") return false;
-  const shim = await readFile32(shimPath, "utf8").catch(() => void 0);
+  const shim = await readFile33(shimPath, "utf8").catch(() => void 0);
   if (!shim) return false;
   return shim.replaceAll("/", "\\").toLowerCase().includes(expectedBin.replaceAll("/", "\\").toLowerCase());
 }
 async function readPackageJson(root) {
   try {
-    const value = JSON.parse(await readFile32(join25(root, "package.json"), "utf8"));
+    const value = JSON.parse(await readFile33(join27(root, "package.json"), "utf8"));
     if (!value || typeof value !== "object") return void 0;
     const item = value;
     return typeof item["name"] === "string" && typeof item["version"] === "string" ? { name: item["name"], version: item["version"], bin: item["bin"] } : void 0;
@@ -50347,11 +50502,11 @@ var init_self_upgrade = __esm({
 
 // packages/cli/src/commands/update-notice.ts
 import { homedir as homedir6 } from "node:os";
-import { join as join26 } from "node:path";
+import { join as join28 } from "node:path";
 async function getCachedUpdateNotice(argv, currentVersion) {
   const json = argv.includes("--json");
   const disabled = argv.includes("--offline") || argv[2] === "self-upgrade" || Boolean(process.env["AICODING_NO_UPDATE_CHECK"]) || Boolean(process.env["CI"]);
-  const repository = new CliUpdateCacheRepository(process.env["AICODING_USER_DATA"] ?? join26(homedir6(), ".aicoding"));
+  const repository = new CliUpdateCacheRepository(process.env["AICODING_USER_DATA"] ?? join28(homedir6(), ".aicoding"));
   if (disabled || !json && !process.stdout.isTTY) return { json, markNotified: async () => void 0 };
   const cache = await repository.read();
   const notifiedAt = cache?.lastNotifiedAt ? Date.parse(cache.lastNotifiedAt) : Number.NaN;
@@ -50383,7 +50538,7 @@ import { createRequire as createRequire2 } from "node:module";
 import { readFileSync as readFileSync4 } from "node:fs";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function resolveVersion() {
-  if (true) return "0.1.30";
+  if (true) return "0.1.31";
   const candidates = [
     new URL("../package.json", import.meta.url),
     new URL("../../package.json", import.meta.url),