@my-life-buddies/cli 0.1.2 → 0.2.0

package/dist/bin/core.js

@@ -1,27 +1,28 @@
 // packages/cli-core/src/index.ts
-import { lstat as lstat8 } from "node:fs/promises";
-import { join as join8, resolve as resolve11 } from "node:path";
+import { lstat as lstat9 } from "node:fs/promises";
+import { join as join10, resolve as resolve11 } from "node:path";
 
 // packages/cli-core/src/config/index.ts
 import {
   link,
-  lstat,
-  mkdir,
-  open,
-  readFile,
+  lstat as lstat3,
+  mkdir as mkdir2,
+  open as open2,
+  readFile as readFile2,
   readdir,
   rename,
-  unlink
+  unlink as unlink2
 } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
-import { isAbsolute, join, resolve, win32 } from "node:path";
+import { isAbsolute, join as join2, resolve as resolve2, win32 } from "node:path";
+import { isDeepStrictEqual } from "node:util";
 import { Ajv2020 } from "ajv/dist/2020.js";
 
 // packages/cli-core/src/config/buddy.agent.schema.json
 var buddy_agent_schema_default = {
   $schema: "https://json-schema.org/draft/2020-12/schema",
   title: "buddy.agent.json",
-  description: "\u642D\u642D\u9879\u76EE\u8EAB\u4EFD\u4E0E Agent \u53EF\u8FD0\u884C\u5DE5\u7A0B\u5B9A\u4E49\uFF1B\u5F00\u53D1\u51C6\u5907\u9636\u6BB5\u53EF\u53EA\u5305\u542B buddyId",
+  description: "\u642D\u642D\u9879\u76EE\u8EAB\u4EFD\u3001\u6A21\u578B\u9009\u62E9\u4E0E\u6570\u636E\u8BBF\u95EE\u9700\u6C42\uFF1B\u5DE5\u7A0B\u662F\u5426\u53EF\u8FD0\u884C\u7531\u5B9E\u9645\u6587\u4EF6\u5224\u65AD",
   type: "object",
   additionalProperties: false,
   required: [
@@ -46,26 +47,211 @@ var buddy_agent_schema_default = {
       pattern: "^[^\\s\\u0000-\\u001f\\u007f]+$",
       description: "\u4ECE buddy-cli models \u67E5\u8BE2\u7684\u6A21\u578B ID"
     },
-    runtime: {
-      type: "object",
-      additionalProperties: false,
-      required: [
-        "language"
-      ],
-      properties: {
-        language: {
-          const: "node"
+    datasets: {
+      type: "array",
+      description: "\u672C\u642D\u5B50\u7533\u8BF7\u7684\u6570\u636E\u96C6\u53CA\u7528\u9014\uFF1B\u7701\u7565\u6216\u7A7A\u6570\u7EC4\u8868\u793A\u4E0D\u7533\u8BF7\u6570\u636E\uFF0C\u58F0\u660E\u4E0D\u4EE3\u8868\u7528\u6237\u5DF2\u6388\u6743",
+      default: [],
+      maxItems: 8,
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["id", "purpose"],
+        properties: {
+          id: {
+            type: "string",
+            enum: [
+              "health.sleep",
+              "health.workouts",
+              "health.distance",
+              "health.heartRate",
+              "health.hrv",
+              "health.respiratoryRate",
+              "health.oxygenSaturation",
+              "health.environmentalAudioExposure"
+            ]
+          },
+          purpose: {
+            type: "string",
+            minLength: 1,
+            maxLength: 200,
+            pattern: "\\S",
+            description: "\u5411\u7528\u6237\u8BF4\u660E\u8FD9\u53EA\u642D\u5B50\u4E3A\u4F55\u9700\u8981\u8BE5\u6570\u636E"
+          }
         }
       }
     }
-  },
-  dependentRequired: {
-    model: [
-      "runtime"
-    ]
   }
 };
 
+// packages/cli-core/src/project-files.ts
+import { lstat as lstat2 } from "node:fs/promises";
+import { join } from "node:path";
+
+// packages/cli-core/src/init/scaffold.ts
+import { lstat, mkdir, open, readFile, rmdir, unlink } from "node:fs/promises";
+import { resolve } from "node:path";
+var BUDDY_PLATFORM_AGENT_ENTRY = "agent.md";
+var BUDDY_PLATFORM_FACTORY_ENTRY = "src/buddy.mjs";
+var BUDDY_PLATFORM_PACKAGE_JSON = "package.json";
+var BUDDY_PLATFORM_PACKAGE_LOCK = "package-lock.json";
+var BUDDY_PLATFORM_START_ENTRY = "start.mjs";
+var PLATFORM_DIRECTORIES = ["src", "src/tools", "src/hooks", "src/services", "resources", "widgets"];
+function promptFor(name) {
+  const safeName = name.trim() || "\u642D\u642D";
+  return `\u4F60\u662F${safeName}\u3002\u8BF7\u7406\u89E3\u7528\u6237\u7684\u771F\u5B9E\u9700\u6C42\uFF0C\u7ED9\u51FA\u81EA\u7136\u3001\u51C6\u786E\u4E14\u6709\u5E2E\u52A9\u7684\u5B8C\u6574\u56DE\u590D\u3002`;
+}
+function platformAgentTemplate(name) {
+  return `${promptFor(name)}
+`;
+}
+function platformFactoryTemplate() {
+  return `import { readFileSync } from "node:fs";
+
+const systemPrompt = readFileSync(new URL("../agent.md", import.meta.url), "utf8").trim();
+if (!systemPrompt) throw new Error("agent.md must contain the Buddy system prompt");
+
+/**
+ * Called when the Runtime creates an agent for a conversation.
+ * Import tools from ./tools/ and hooks from ./hooks/, then register them below.
+ * Shared business code can live in ./services/; directories do not enable capabilities.
+ * Use conversation.memory / dataAccess / widgets / proactive for platform capabilities.
+ * Place widget assets in ../widgets/<type-id>/index.html and schema.json.
+ * Runtime uploads these files before connecting to MLB; upload failures stop startup.
+ * Select widget_* in platformTools to expose widget tools to the model.
+ * Use platform APIs only; do not call third-party services directly.
+ */
+export default function createBuddy(_conversation) {
+  return {
+    initialState: {
+      systemPrompt,
+      thinkingLevel: "off",
+      tools: [],
+    },
+  };
+}
+`;
+}
+function platformStartTemplate() {
+  return `// Generated startup: local DEV and hosted execution use the same Buddy Runtime.
+import { readFileSync } from "node:fs";
+import { BuddyServer } from "@my-life-buddies/buddy-runtime";
+import createBuddy from "./src/buddy.mjs";
+
+const config = JSON.parse(readFileSync(new URL("./buddy.agent.json", import.meta.url), "utf8"));
+if (!config || config.schemaVersion !== 1 || typeof config.buddyId !== "string" || !config.buddyId) {
+  throw new Error("buddy.agent.json is not a complete Buddy project");
+}
+if (process.env.MLB_BUDDY_ID && process.env.MLB_BUDDY_ID !== config.buddyId) {
+  throw new Error("MLB_BUDDY_ID does not match buddy.agent.json");
+}
+const model = typeof config.model === "string" && config.model ? config.model : "kimi-k2.6";
+
+const lifecycle = new AbortController();
+const stop = () => lifecycle.abort();
+process.on("SIGINT", stop);
+process.on("SIGTERM", stop);
+let runtime;
+try {
+  runtime = await BuddyServer.start({ model, buddy: createBuddy });
+  if (!lifecycle.signal.aborted) {
+    await new Promise((resolve) => lifecycle.signal.addEventListener("abort", resolve, { once: true }));
+  }
+} catch (error) {
+  if (!lifecycle.signal.aborted) {
+    console.error("buddy-agent:", error instanceof Error ? error.message : "Startup failed");
+    process.exitCode = 1;
+  }
+} finally {
+  await runtime?.stop();
+  process.off("SIGINT", stop);
+  process.off("SIGTERM", stop);
+}
+`;
+}
+async function scaffoldPlatformAgent(projectRoot, name) {
+  const path = resolve(projectRoot, BUDDY_PLATFORM_AGENT_ENTRY);
+  const hasAlternateLockfile = (await Promise.all(["pnpm-lock.yaml", "yarn.lock"].map(async (name2) => {
+    try {
+      if (!(await lstat(resolve(projectRoot, name2))).isFile()) {
+        throw new TypeError(`\u4F9D\u8D56\u9501\u6587\u4EF6\u5FC5\u987B\u662F\u666E\u901A\u6587\u4EF6\uFF1A${name2}`);
+      }
+      return true;
+    } catch (cause) {
+      if (cause.code === "ENOENT") return false;
+      throw cause;
+    }
+  }))).some(Boolean);
+  const files = [
+    { path, content: platformAgentTemplate(name) },
+    { path: resolve(projectRoot, BUDDY_PLATFORM_FACTORY_ENTRY), content: platformFactoryTemplate() },
+    { path: resolve(projectRoot, BUDDY_PLATFORM_PACKAGE_JSON), content: await readFile(new URL("../../resources/agent-template/package.json", import.meta.url), "utf8") },
+    ...hasAlternateLockfile ? [] : [{ path: resolve(projectRoot, BUDDY_PLATFORM_PACKAGE_LOCK), content: await readFile(new URL("../../resources/agent-template/package-lock.json", import.meta.url), "utf8") }],
+    { path: resolve(projectRoot, BUDDY_PLATFORM_START_ENTRY), content: platformStartTemplate() }
+  ];
+  const handles = [];
+  const createdDirectories = [];
+  try {
+    for (const directory of PLATFORM_DIRECTORIES) {
+      const directoryPath = resolve(projectRoot, directory);
+      try {
+        await mkdir(directoryPath, { mode: 448 });
+        createdDirectories.push(directoryPath);
+      } catch (cause) {
+        if (cause.code !== "EEXIST") throw cause;
+      }
+      if (!(await lstat(directoryPath)).isDirectory()) {
+        throw new TypeError(`\u5B98\u65B9\u5DE5\u7A0B\u76EE\u5F55\u5FC5\u987B\u662F\u666E\u901A\u76EE\u5F55\uFF0C\u4E0D\u80FD\u4F7F\u7528\u6587\u4EF6\u6216\u7B26\u53F7\u94FE\u63A5\uFF1A${directoryPath}`);
+      }
+    }
+    for (const file of files) {
+      try {
+        handles.push({ path: file.path, handle: await open(file.path, "wx", 384) });
+      } catch (cause) {
+        if (cause.code !== "EEXIST") throw cause;
+        if (!(await lstat(file.path)).isFile()) {
+          throw new TypeError(`\u5B98\u65B9\u5DE5\u7A0B\u6587\u4EF6\u5FC5\u987B\u662F\u666E\u901A\u6587\u4EF6\uFF0C\u4E0D\u80FD\u4F7F\u7528\u76EE\u5F55\u6216\u7B26\u53F7\u94FE\u63A5\uFF1A${file.path}`);
+        }
+      }
+    }
+    for (const { path: filePath, handle } of handles) {
+      const file = files.find((candidate) => candidate.path === filePath);
+      await handle.writeFile(file.content, "utf8");
+      await handle.sync();
+    }
+    return Object.freeze({ path, created: handles.length > 0 || createdDirectories.length > 0 });
+  } catch (cause) {
+    await Promise.all(handles.map(({ handle }) => handle.close().catch(() => void 0)));
+    await Promise.all(handles.map(({ path: createdPath }) => unlink(createdPath).catch(() => void 0)));
+    for (const directory of createdDirectories.reverse()) {
+      await rmdir(directory).catch(() => void 0);
+    }
+    throw cause;
+  } finally {
+    await Promise.all(handles.map(({ handle }) => handle.close().catch(() => void 0)));
+  }
+}
+
+// packages/cli-core/src/project-files.ts
+async function missingBuddyAgentFiles(projectRoot) {
+  const entries = [
+    ["src", "directory"],
+    [BUDDY_PLATFORM_AGENT_ENTRY, "file"],
+    [BUDDY_PLATFORM_FACTORY_ENTRY, "file"],
+    [BUDDY_PLATFORM_PACKAGE_JSON, "file"],
+    [BUDDY_PLATFORM_START_ENTRY, "file"]
+  ];
+  const missing = await Promise.all(entries.map(async ([path, kind]) => {
+    try {
+      const entry = await lstat2(join(projectRoot, path));
+      return (kind === "directory" ? entry.isDirectory() : entry.isFile()) ? void 0 : path;
+    } catch (cause) {
+      if (["ENOENT", "ENOTDIR"].includes(cause.code ?? "")) return path;
+      throw cause;
+    }
+  }));
+  return missing.filter((path) => path !== void 0);
+}
+
 // packages/cli-core/src/config/index.ts
 var BUDDY_AGENT_FILENAME = "buddy.agent.json";
 var BUDDY_AGENT_SCHEMA = buddy_agent_schema_default;
@@ -124,15 +310,18 @@ function validateBuddyProjectManifest(value) {
   if (!validateAgentSchema(value)) {
     return { ok: false, issues: schemaIssues(validateAgentSchema.errors) };
   }
-  return { ok: true, value };
+  const manifest = value;
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, dataset] of (manifest.datasets ?? []).entries()) {
+    if (seen.has(dataset.id)) {
+      return { ok: false, issues: [{ path: `/datasets/${index}/id`, message: `\u6570\u636E\u96C6\u4E0D\u80FD\u91CD\u590D\u58F0\u660E\uFF1A${dataset.id}` }] };
+    }
+    seen.add(dataset.id);
+  }
+  return { ok: true, value: manifest };
 }
 function validateBuddyAgentConfig(value) {
-  const result = validateBuddyProjectManifest(value);
-  if (!result.ok) return result;
-  if (!("runtime" in result.value)) {
-    return { ok: false, issues: [{ path: "/runtime", message: "Agent \u5DE5\u7A0B\u5C1A\u672A\u5B8C\u6210\uFF0C\u8BF7\u8FD0\u884C init --mode direct \u8865\u9F50 Runtime \u5DE5\u7A0B" }] };
-  }
-  return { ok: true, value: result.value };
+  return validateBuddyProjectManifest(value);
 }
 function assertBuddyAgentConfig(value) {
   const result = validateBuddyAgentConfig(value);
@@ -148,12 +337,7 @@ function parseBuddyProjectManifest(source) {
   return result.value;
 }
 function serializeBuddyDraftConfig(config) {
-  const result = validateBuddyProjectManifest(config);
-  if (!result.ok || "runtime" in result.value) {
-    throw new BuddyConfigValidationError(result.ok ? [{ path: "/runtime", message: "\u5FC5\u987B\u662F\u672A\u5B8C\u6210\u7684\u521B\u4F5C\u9879\u76EE" }] : result.issues);
-  }
-  return `${JSON.stringify(result.value, null, 2)}
-`;
+  return serializeBuddyAgentConfig(config);
 }
 function serializeBuddyAgentConfig(config) {
   return `${JSON.stringify(assertBuddyAgentConfig(config), null, 2)}
@@ -169,14 +353,14 @@ function combineBuddyProject(config) {
 function createBuddyConfig(options) {
   return assertBuddyConfig({
     buddyId: options.buddyId,
-    runtime: { language: "node" },
-    ...options.model === void 0 ? {} : { model: options.model }
+    ...options.model === void 0 ? {} : { model: options.model },
+    datasets: options.datasets ?? []
   });
 }
 var ProjectInitializationError = class extends Error {
-  constructor(code, message, targetPath, options) {
+  constructor(code2, message, targetPath, options) {
     super(message, options);
-    this.code = code;
+    this.code = code2;
     this.targetPath = targetPath;
     this.name = "ProjectInitializationError";
   }
@@ -185,7 +369,7 @@ var ProjectInitializationError = class extends Error {
 };
 async function pathState(targetPath) {
   try {
-    const entry = await lstat(targetPath);
+    const entry = await lstat3(targetPath);
     if (!entry.isDirectory() || entry.isSymbolicLink()) return { kind: "other" };
     return { kind: "directory", identity: `${entry.dev}:${entry.ino}` };
   } catch (cause) {
@@ -205,7 +389,7 @@ function entryIdentity(entry) {
 }
 async function fileIdentity(targetPath) {
   try {
-    const entry = await lstat(targetPath);
+    const entry = await lstat3(targetPath);
     return entry.isFile() && !entry.isSymbolicLink() ? entryIdentity(entry) : void 0;
   } catch (cause) {
     if (cause.code === "ENOENT") return void 0;
@@ -214,11 +398,11 @@ async function fileIdentity(targetPath) {
 }
 async function unlinkMatchingFile(targetPath, expectedIdentity) {
   try {
-    const entry = await lstat(targetPath);
+    const entry = await lstat3(targetPath);
     if (!entry.isFile() || entry.isSymbolicLink() || entryIdentity(entry) !== expectedIdentity) {
       return false;
     }
-    await unlink(targetPath);
+    await unlink2(targetPath);
     return true;
   } catch (cause) {
     return cause.code === "ENOENT";
@@ -252,7 +436,7 @@ async function readExistingManifest(agentConfigPath) {
       agentConfigPath
     );
   }
-  const entry = await lstat(agentConfigPath);
+  const entry = await lstat3(agentConfigPath);
   if (!entry.isFile() || entry.isSymbolicLink()) {
     throw new ProjectInitializationError(
       "TARGET_CHANGED",
@@ -261,7 +445,7 @@ async function readExistingManifest(agentConfigPath) {
     );
   }
   try {
-    return parseBuddyProjectManifest(await readFile(agentConfigPath, "utf8"));
+    return parseBuddyProjectManifest(await readFile2(agentConfigPath, "utf8"));
   } catch (cause) {
     throw new ProjectInitializationError(
       "TARGET_CHANGED",
@@ -272,8 +456,8 @@ async function readExistingManifest(agentConfigPath) {
   }
 }
 async function planBuddyDraftInitialization(directory) {
-  const rootDirectory = resolve(directory);
-  const agentConfigPath = join(rootDirectory, BUDDY_AGENT_FILENAME);
+  const rootDirectory = resolve2(directory);
+  const agentConfigPath = join2(rootDirectory, BUDDY_AGENT_FILENAME);
   const state2 = await pathState(rootDirectory);
   if (state2.kind === "other") {
     throw new ProjectInitializationError(
@@ -283,7 +467,7 @@ async function planBuddyDraftInitialization(directory) {
     );
   }
   const existingManifest = state2.kind === "directory" ? await readExistingManifest(agentConfigPath) : void 0;
-  if (existingManifest !== void 0 && "runtime" in existingManifest) {
+  if (existingManifest !== void 0 && (await missingBuddyAgentFiles(rootDirectory)).length === 0) {
     throw new ProjectInitializationError(
       "ALREADY_INITIALIZED",
       `\u9879\u76EE\u5DF2\u7ECF\u662F\u5B8C\u6574 Agent \u5DE5\u7A0B\uFF0C\u4E0D\u9700\u8981\u91CD\u65B0\u8FDB\u5165\u521B\u4F5C\u521D\u59CB\u5316\u3002`,
@@ -300,8 +484,8 @@ async function planBuddyDraftInitialization(directory) {
   };
 }
 async function planBuddyProjectInitialization(options) {
-  const rootDirectory = resolve(options.directory);
-  const agentConfigPath = resolve(rootDirectory, BUDDY_AGENT_FILENAME);
+  const rootDirectory = resolve2(options.directory);
+  const agentConfigPath = resolve2(rootDirectory, BUDDY_AGENT_FILENAME);
   const state2 = await pathState(rootDirectory);
   if (state2.kind === "other") {
     throw new ProjectInitializationError(
@@ -330,7 +514,7 @@ async function planBuddyProjectInitialization(options) {
 async function prepareInitializationDirectory(plan) {
   if (plan.createRootDirectory) {
     if ((await pathState(plan.rootDirectory)).kind !== "missing") throw targetChanged(plan);
-    const firstCreatedDirectory = await mkdir(plan.rootDirectory, { recursive: true });
+    const firstCreatedDirectory = await mkdir2(plan.rootDirectory, { recursive: true });
     if (firstCreatedDirectory === void 0) throw targetChanged(plan);
     const created = await pathState(plan.rootDirectory);
     if (created.kind !== "directory") throw targetChanged(plan);
@@ -345,14 +529,14 @@ async function prepareInitializationDirectory(plan) {
 async function publishNewFile(options) {
   let temporaryHandle;
   let publishedHandle;
-  const temporaryPath = join(
+  const temporaryPath = join2(
     options.rootDirectory,
     `.${options.temporaryLabel}.${process.pid}.${randomUUID()}.tmp`
   );
   let temporaryIdentity;
   let publishedIdentity;
   try {
-    temporaryHandle = await open(temporaryPath, "wx");
+    temporaryHandle = await open2(temporaryPath, "wx");
     temporaryIdentity = entryIdentity(await temporaryHandle.stat());
     await temporaryHandle.writeFile(options.contents, "utf8");
     await temporaryHandle.sync();
@@ -369,13 +553,13 @@ async function publishNewFile(options) {
       await link(temporaryPath, options.targetPath);
       publishedIdentity = temporaryIdentity;
     } catch (cause) {
-      const code = cause.code;
-      if (!code || !HARD_LINK_UNSUPPORTED_CODES.has(code)) throw cause;
+      const code2 = cause.code;
+      if (!code2 || !HARD_LINK_UNSUPPORTED_CODES.has(code2)) throw cause;
       const fallbackBeforeOpen = await pathState(options.rootDirectory);
       if (fallbackBeforeOpen.kind !== "directory" || fallbackBeforeOpen.identity !== options.directoryIdentity) {
         throw targetChanged({ rootDirectory: options.rootDirectory });
       }
-      publishedHandle = await open(options.targetPath, "wx");
+      publishedHandle = await open2(options.targetPath, "wx");
       publishedIdentity = entryIdentity(await publishedHandle.stat());
       const fallbackRoot = await pathState(options.rootDirectory);
       if (fallbackRoot.kind !== "directory" || fallbackRoot.identity !== options.directoryIdentity) {
@@ -389,7 +573,7 @@ async function publishNewFile(options) {
     const afterPublish = await pathState(options.rootDirectory);
     const publishedFileIdentity = await fileIdentity(options.targetPath);
     const temporaryFileIdentity = await fileIdentity(temporaryPath);
-    const publishedContents = publishedFileIdentity ? await readFile(options.targetPath, "utf8") : void 0;
+    const publishedContents = publishedFileIdentity ? await readFile2(options.targetPath, "utf8") : void 0;
     if (afterPublish.kind !== "directory" || afterPublish.identity !== options.directoryIdentity || !publishedIdentity || publishedFileIdentity !== publishedIdentity || temporaryFileIdentity !== temporaryIdentity || publishedContents !== options.contents) {
       if (afterPublish.kind === "directory" && afterPublish.identity === options.directoryIdentity && publishedIdentity) {
         await unlinkMatchingFile(options.targetPath, publishedIdentity);
@@ -416,11 +600,11 @@ async function publishNewFile(options) {
   }
 }
 async function replaceExistingFile(options) {
-  const temporaryPath = join(
+  const temporaryPath = join2(
     options.rootDirectory,
     `.${options.temporaryLabel}.${process.pid}.${randomUUID()}.tmp`
   );
-  const handle = await open(temporaryPath, "wx", 384);
+  const handle = await open2(temporaryPath, "wx", 384);
   try {
     await handle.writeFile(options.contents, "utf8");
     await handle.sync();
@@ -431,11 +615,11 @@ async function replaceExistingFile(options) {
     const root = await pathState(options.rootDirectory);
     if (root.kind !== "directory" || root.identity !== options.directoryIdentity || await fileIdentity(options.targetPath) !== options.expectedFileIdentity) throw targetChanged({ rootDirectory: options.rootDirectory });
     await rename(temporaryPath, options.targetPath);
-    if (await readFile(options.targetPath, "utf8") !== options.contents) {
+    if (await readFile2(options.targetPath, "utf8") !== options.contents) {
       throw targetChanged({ rootDirectory: options.rootDirectory });
     }
   } finally {
-    await unlink(temporaryPath).catch((cause) => {
+    await unlink2(temporaryPath).catch((cause) => {
       if (cause.code !== "ENOENT") throw cause;
     });
   }
@@ -445,14 +629,14 @@ async function applyBuddyDraftInitialization(plan, draft) {
   const directoryIdentity = await prepareInitializationDirectory(plan);
   if (plan.existingManifest !== void 0) {
     const current = await readExistingManifest(plan.agentConfigPath);
-    if (current === void 0 || "runtime" in current || current.buddyId !== draft.buddyId) {
+    if (current === void 0 || current.buddyId !== draft.buddyId || (await missingBuddyAgentFiles(plan.rootDirectory)).length === 0) {
       throw new ProjectInitializationError(
         "ALREADY_INITIALIZED",
         `\u5DF2\u6709 ${BUDDY_AGENT_FILENAME} \u7ED1\u5B9A\u7684 buddyId \u4E0E\u672C\u6B21\u4E91\u7AEF\u642D\u5B50\u4E0D\u4E00\u81F4\u3002`,
         plan.agentConfigPath
       );
     }
-    return { rootDirectory: plan.rootDirectory, agentConfigPath: plan.agentConfigPath, manifest: draft };
+    return { rootDirectory: plan.rootDirectory, agentConfigPath: plan.agentConfigPath, manifest: current };
   }
   try {
     const published = await publishNewFile({
@@ -487,15 +671,16 @@ async function applyBuddyDraftInitialization(plan, draft) {
   }
 }
 async function applyBuddyProjectInitialization(plan, config) {
-  const agentConfig = buddyAgentConfig(config);
-  const contents = serializeBuddyAgentConfig(agentConfig);
-  if (plan.existingManifest !== void 0 && plan.existingManifest.buddyId !== agentConfig.buddyId) {
+  const requestedConfig = buddyAgentConfig(config);
+  if (plan.existingManifest !== void 0 && plan.existingManifest.buddyId !== requestedConfig.buddyId) {
     throw new ProjectInitializationError(
       "ALREADY_INITIALIZED",
-      `\u5DF2\u6709 ${BUDDY_AGENT_FILENAME} \u7ED1\u5B9A\u7684\u662F ${plan.existingManifest.buddyId}\uFF0C\u4E0D\u80FD\u6539\u6210 ${agentConfig.buddyId}\u3002`,
+      `\u5DF2\u6709 ${BUDDY_AGENT_FILENAME} \u7ED1\u5B9A\u7684\u662F ${plan.existingManifest.buddyId}\uFF0C\u4E0D\u80FD\u6539\u6210 ${requestedConfig.buddyId}\u3002`,
       plan.agentConfigPath
     );
   }
+  const agentConfig = { ...requestedConfig, ...plan.existingManifest };
+  const contents = serializeBuddyAgentConfig(agentConfig);
   const directoryIdentity = await prepareInitializationDirectory(plan);
   if (plan.existingManifest !== void 0) {
     const currentManifest = await readExistingManifest(plan.agentConfigPath);
@@ -504,7 +689,7 @@ async function applyBuddyProjectInitialization(plan, config) {
     }
   }
   try {
-    if (plan.existingManifest !== void 0 && "runtime" in plan.existingManifest) {
+    if (plan.existingManifest !== void 0 && isDeepStrictEqual(plan.existingManifest, agentConfig)) {
       return { rootDirectory: plan.rootDirectory, agentConfigPath: plan.agentConfigPath };
     }
     let warning2;
@@ -555,167 +740,23 @@ async function initializeBuddyProject(options) {
   return applyBuddyProjectInitialization(plan, options.config);
 }
 async function readBuddyProjectManifest(projectRoot) {
-  const rootDirectory = resolve(projectRoot);
-  return parseBuddyProjectManifest(await readFile(resolve(rootDirectory, BUDDY_AGENT_FILENAME), "utf8"));
+  const rootDirectory = resolve2(projectRoot);
+  return parseBuddyProjectManifest(await readFile2(resolve2(rootDirectory, BUDDY_AGENT_FILENAME), "utf8"));
 }
 async function readBuddyAgentConfig(projectRoot) {
-  const rootDirectory = resolve(projectRoot);
-  const source = await readFile(resolve(rootDirectory, BUDDY_AGENT_FILENAME), "utf8");
+  const rootDirectory = resolve2(projectRoot);
+  const source = await readFile2(resolve2(rootDirectory, BUDDY_AGENT_FILENAME), "utf8");
   return parseBuddyAgentConfig(source);
 }
 async function readBuddyConfig(projectRoot) {
-  const rootDirectory = resolve(projectRoot);
+  const rootDirectory = resolve2(projectRoot);
   return combineBuddyProject(await readBuddyAgentConfig(rootDirectory));
 }
 
-// packages/cli-core/src/init/scaffold.ts
-import { lstat as lstat2, mkdir as mkdir2, open as open2, readFile as readFile2, rmdir, unlink as unlink2 } from "node:fs/promises";
-import { resolve as resolve2 } from "node:path";
-var BUDDY_PLATFORM_AGENT_ENTRY = "agent.md";
-var BUDDY_PLATFORM_FACTORY_ENTRY = "src/buddy.mjs";
-var BUDDY_PLATFORM_PACKAGE_JSON = "package.json";
-var BUDDY_PLATFORM_PACKAGE_LOCK = "package-lock.json";
-var BUDDY_PLATFORM_START_ENTRY = "start.mjs";
-var PLATFORM_DIRECTORIES = ["src", "src/tools", "src/hooks", "src/services", "resources", "widgets"];
-function promptFor(name) {
-  const safeName = name.trim() || "\u642D\u642D";
-  return `\u4F60\u662F${safeName}\u3002\u8BF7\u7406\u89E3\u7528\u6237\u7684\u771F\u5B9E\u9700\u6C42\uFF0C\u7ED9\u51FA\u81EA\u7136\u3001\u51C6\u786E\u4E14\u6709\u5E2E\u52A9\u7684\u5B8C\u6574\u56DE\u590D\u3002`;
-}
-function platformAgentTemplate(name) {
-  return `${promptFor(name)}
-`;
-}
-function platformFactoryTemplate() {
-  return `import { readFileSync } from "node:fs";
-
-const systemPrompt = readFileSync(new URL("../agent.md", import.meta.url), "utf8").trim();
-if (!systemPrompt) throw new Error("agent.md must contain the Buddy system prompt");
-
-/**
- * Called when the Runtime creates an agent for a conversation.
- * Import tools from ./tools/ and hooks from ./hooks/, then register them below.
- * Shared business code can live in ./services/; directories do not enable capabilities.
- * Use conversation.memory / dataAccess / widgets / proactive for platform capabilities.
- * Place widget assets in ../widgets/<type-id>/index.html and schema.json.
- * Runtime uploads these files before connecting to MLB; upload failures stop startup.
- * Select widget_* in platformTools to expose widget tools to the model.
- * Use platform APIs only; do not call third-party services directly.
- */
-export default function createBuddy(_conversation) {
-  return {
-    initialState: {
-      systemPrompt,
-      thinkingLevel: "off",
-      tools: [],
-    },
-  };
-}
-`;
-}
-function platformStartTemplate() {
-  return `// Generated startup: local DEV and hosted execution use the same Buddy Runtime.
-import { readFileSync } from "node:fs";
-import { BuddyServer } from "@my-life-buddies/buddy-runtime";
-import createBuddy from "./src/buddy.mjs";
-
-const config = JSON.parse(readFileSync(new URL("./buddy.agent.json", import.meta.url), "utf8"));
-if (!config || config.schemaVersion !== 1 || typeof config.buddyId !== "string" || !config.buddyId || config.runtime?.language !== "node") {
-  throw new Error("buddy.agent.json is not a complete Buddy project");
-}
-if (process.env.MLB_BUDDY_ID && process.env.MLB_BUDDY_ID !== config.buddyId) {
-  throw new Error("MLB_BUDDY_ID does not match buddy.agent.json");
-}
-const model = typeof config.model === "string" && config.model ? config.model : "kimi-k2.6";
-
-const lifecycle = new AbortController();
-const stop = () => lifecycle.abort();
-process.on("SIGINT", stop);
-process.on("SIGTERM", stop);
-let runtime;
-try {
-  runtime = await BuddyServer.start({ model, buddy: createBuddy });
-  if (!lifecycle.signal.aborted) {
-    await new Promise((resolve) => lifecycle.signal.addEventListener("abort", resolve, { once: true }));
-  }
-} catch (error) {
-  if (!lifecycle.signal.aborted) {
-    console.error("buddy-agent:", error instanceof Error ? error.message : "Startup failed");
-    process.exitCode = 1;
-  }
-} finally {
-  await runtime?.stop();
-  process.off("SIGINT", stop);
-  process.off("SIGTERM", stop);
-}
-`;
-}
-async function scaffoldPlatformAgent(projectRoot, name) {
-  const path = resolve2(projectRoot, BUDDY_PLATFORM_AGENT_ENTRY);
-  const hasAlternateLockfile = (await Promise.all(["pnpm-lock.yaml", "yarn.lock"].map(async (name2) => {
-    try {
-      if (!(await lstat2(resolve2(projectRoot, name2))).isFile()) {
-        throw new TypeError(`\u4F9D\u8D56\u9501\u6587\u4EF6\u5FC5\u987B\u662F\u666E\u901A\u6587\u4EF6\uFF1A${name2}`);
-      }
-      return true;
-    } catch (cause) {
-      if (cause.code === "ENOENT") return false;
-      throw cause;
-    }
-  }))).some(Boolean);
-  const files = [
-    { path, content: platformAgentTemplate(name) },
-    { path: resolve2(projectRoot, BUDDY_PLATFORM_FACTORY_ENTRY), content: platformFactoryTemplate() },
-    { path: resolve2(projectRoot, BUDDY_PLATFORM_PACKAGE_JSON), content: await readFile2(new URL("../../resources/agent-template/package.json", import.meta.url), "utf8") },
-    ...hasAlternateLockfile ? [] : [{ path: resolve2(projectRoot, BUDDY_PLATFORM_PACKAGE_LOCK), content: await readFile2(new URL("../../resources/agent-template/package-lock.json", import.meta.url), "utf8") }],
-    { path: resolve2(projectRoot, BUDDY_PLATFORM_START_ENTRY), content: platformStartTemplate() }
-  ];
-  const handles = [];
-  const createdDirectories = [];
-  try {
-    for (const directory of PLATFORM_DIRECTORIES) {
-      const directoryPath = resolve2(projectRoot, directory);
-      try {
-        await mkdir2(directoryPath, { mode: 448 });
-        createdDirectories.push(directoryPath);
-      } catch (cause) {
-        if (cause.code !== "EEXIST") throw cause;
-      }
-      if (!(await lstat2(directoryPath)).isDirectory()) {
-        throw new TypeError(`\u5B98\u65B9\u5DE5\u7A0B\u76EE\u5F55\u5FC5\u987B\u662F\u666E\u901A\u76EE\u5F55\uFF0C\u4E0D\u80FD\u4F7F\u7528\u6587\u4EF6\u6216\u7B26\u53F7\u94FE\u63A5\uFF1A${directoryPath}`);
-      }
-    }
-    for (const file of files) {
-      try {
-        handles.push({ path: file.path, handle: await open2(file.path, "wx", 384) });
-      } catch (cause) {
-        if (cause.code !== "EEXIST") throw cause;
-        if (!(await lstat2(file.path)).isFile()) {
-          throw new TypeError(`\u5B98\u65B9\u5DE5\u7A0B\u6587\u4EF6\u5FC5\u987B\u662F\u666E\u901A\u6587\u4EF6\uFF0C\u4E0D\u80FD\u4F7F\u7528\u76EE\u5F55\u6216\u7B26\u53F7\u94FE\u63A5\uFF1A${file.path}`);
-        }
-      }
-    }
-    for (const { path: filePath, handle } of handles) {
-      const file = files.find((candidate) => candidate.path === filePath);
-      await handle.writeFile(file.content, "utf8");
-      await handle.sync();
-    }
-    return Object.freeze({ path, created: handles.length > 0 || createdDirectories.length > 0 });
-  } catch (cause) {
-    await Promise.all(handles.map(({ handle }) => handle.close().catch(() => void 0)));
-    await Promise.all(handles.map(({ path: createdPath }) => unlink2(createdPath).catch(() => void 0)));
-    for (const directory of createdDirectories.reverse()) {
-      await rmdir(directory).catch(() => void 0);
-    }
-    throw cause;
-  } finally {
-    await Promise.all(handles.map(({ handle }) => handle.close().catch(() => void 0)));
-  }
-}
-
 // packages/cli-core/src/init/creator.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { link as link2, lstat as lstat3, mkdir as mkdir3, readFile as readFile3, unlink as unlink3, writeFile } from "node:fs/promises";
-import { join as join2 } from "node:path";
+import { link as link2, lstat as lstat4, mkdir as mkdir3, readFile as readFile3, unlink as unlink3, writeFile } from "node:fs/promises";
+import { join as join3 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // packages/cli-core/src/init/development-handoff.ts
@@ -769,7 +810,7 @@ Creator \u8FD4\u56DE\u6709\u6548\u7684 \`completion.manualPath\` \u540E\uFF0C\u8
 
 | \u4F4D\u7F6E | \u804C\u8D23\u4E0E\u751F\u6210\u65F6\u673A |
 | --- | --- |
-| \`buddy.agent.json\` | \u9ED8\u8BA4\u751F\u6210\uFF0C\u4FDD\u5B58\u5E73\u53F0\u8EAB\u4EFD\u3001\u8FD0\u884C\u8BED\u8A00\u548C\u53EF\u9009\u6A21\u578B\uFF0C\u4E0D\u653E\u4E1A\u52A1\u51FD\u6570 |
+| \`buddy.agent.json\` | \u9ED8\u8BA4\u751F\u6210\uFF0C\u4FDD\u5B58\u5E73\u53F0\u8EAB\u4EFD\u3001\u53EF\u9009\u6A21\u578B\u548C\u6570\u636E\u9700\u6C42 datasets\uFF0C\u4E0D\u653E\u4E1A\u52A1\u51FD\u6570 |
 | \`agent.md\` | \u9ED8\u8BA4\u751F\u6210\uFF0C\u4FDD\u5B58\u7CFB\u7EDF Prompt |
 | \`start.mjs\` | \u9ED8\u8BA4\u751F\u6210\uFF0C\u8BFB\u53D6\u542F\u52A8\u914D\u7F6E\u3001\u542F\u52A8 Runtime \u5E76\u5904\u7406\u9000\u51FA |
 | \`package.json\`\u3001\`package-lock.json\` | \u9ED8\u8BA4\u751F\u6210\uFF0C\u58F0\u660E\u542F\u52A8\u547D\u4EE4\u3001\u51C6\u786E Runtime \u7248\u672C\u5E76\u9501\u5B9A\u4F9D\u8D56 |
@@ -790,6 +831,8 @@ Widget \u5DE5\u7A0B\u7EA6\u5B9A\uFF1A\u4E00\u7EA7\u76EE\u5F55\u540D\u5C31\u662F\
 
 \u5E73\u53F0\u80FD\u529B\u8981\u4EE5\u5B9E\u9645\u63A5\u5165\u4E3A\u51C6\u3002\u5F53\u524D Runtime \u63D0\u4F9B\u4F1A\u8BDD\u6D88\u606F\u3001Memory\u3001\u6388\u6743\u6570\u636E\u3001\u5C0F\u6302\u4EF6\u548C\u672C\u5730 Markdown \u8D44\u6599\u80FD\u529B\uFF1B\u6CA1\u6709\u63A5\u901A\u7684 Files\u3001Knowledge \u4E0D\u80FD\u56E0\u624B\u518C\u63D0\u5230\u5C31\u5BA3\u79F0\u53EF\u7528\u3002\u666E\u901A Tool \u4E5F\u4E0D\u4EE3\u8868\u5DF2\u7ECF\u63D0\u4F9B\u5B9A\u65F6\u3001\u957F\u671F\u4EFB\u52A1\u3001\u540E\u53F0\u8C03\u5EA6\u6216\u4E3B\u52A8\u89E6\u8FBE\u3002\u624B\u518C\u63CF\u8FF0\u7684\u4ED8\u8D39\u3001\u53D1\u5E03\u7B49\u670D\u52A1\u8BBE\u8BA1\u4E5F\u4E0D\u6784\u6210\u6267\u884C\u6536\u8D39\u6216\u53D1\u5E03\u52A8\u4F5C\u7684\u6388\u6743\u3002
 
+\u9700\u8981\u7528\u6237\u6570\u636E\u65F6\uFF0C\u5728 \`buddy.agent.json.datasets\` \u5199\u660E\u6240\u9700\u7684 \`id\` \u548C \`purpose\`\uFF0C\u540C\u4E00 ID \u53EA\u5199\u4E00\u6B21\uFF0C\u7528\u9014\u4E0D\u80FD\u4E3A\u7A7A\u4E14\u6700\u591A 200 \u5B57\uFF1B\u65E0\u6570\u636E\u9700\u6C42\u65F6\u4FDD\u7559\u7A7A\u6570\u7EC4\u3002\u5F53\u524D\u63A5\u53D7 \`health.sleep\`\u3001\`health.workouts\`\u3001\`health.distance\`\u3001\`health.heartRate\`\u3001\`health.hrv\`\u3001\`health.respiratoryRate\`\u3001\`health.oxygenSaturation\` \u548C \`health.environmentalAudioExposure\`\u3002CLI \u6821\u9A8C\u5E76\u968F\u5305\u4E0A\u4F20\u58F0\u660E\uFF0C\u670D\u52A1\u7AEF\u89E3\u6790\u5305\u4E0E App \u6388\u6743\u94FE\u8DEF\u4ECD\u5F85\u63A5\u5165\uFF1B\u4E0D\u80FD\u628A\u586B\u5199\u914D\u7F6E\u8BF4\u6210\u7528\u6237\u5DF2\u7ECF\u6388\u6743\u3002Runtime \u4ECD\u8BFB\u53D6\u5E73\u53F0\u5DF2\u751F\u6548\u7684\u58F0\u660E\uFF1B\u6A21\u578B\u76F4\u63A5\u67E5\u6570\u636E\u9700\u5728 \`src/buddy.mjs\` \u663E\u5F0F\u542F\u7528 \`data_access_query\`\uFF0C\u4E1A\u52A1 Tool \u4E5F\u53EF\u8C03\u7528 \`conversation.dataAccess.query\`\u3002
+
 ### \u53EA\u6709\u5173\u952E\u7F3A\u53E3\u624D\u8865\u95EE
 
 \u80FD\u4ECE\u624B\u518C\u548C\u73B0\u6709\u4EE3\u7801\u786E\u5B9A\u7684\u76F4\u63A5\u5B9E\u73B0\uFF0C\u5305\u62EC\u9009\u62E9\u54EA\u4E2A\u51FD\u6570\u3001\u6587\u4EF6\u3001Tool \u6216\u5DF2\u6709\u9ED8\u8BA4\u80FD\u529B\uFF1B\u4E0D\u8981\u628A\u6280\u672F\u6620\u5C04\u518D\u4EA4\u7ED9\u5F00\u53D1\u8005\u51B3\u5B9A\uFF0C\u4E0D\u8981\u6C42\u5BF9\u6574\u4EFD\u5B9E\u73B0\u65B9\u6848\u91CD\u65B0\u7B7E\u5B57\u3002
@@ -832,7 +875,7 @@ var REQUIRED = [
 var CreatorPreparationError = class extends Error {
 };
 async function state(path) {
-  return lstat3(path).catch((cause) => {
+  return lstat4(path).catch((cause) => {
     if (cause.code === "ENOENT") return void 0;
     throw cause;
   });
@@ -841,7 +884,7 @@ async function safeDirectory(path) {
   await mkdir3(path, { mode: 448 }).catch((cause) => {
     if (cause.code !== "EEXIST") throw cause;
   });
-  if (!(await lstat3(path)).isDirectory()) {
+  if (!(await lstat4(path)).isDirectory()) {
     throw new CreatorPreparationError(`\u521B\u4F5C\u76EE\u5F55\u5FC5\u987B\u662F\u666E\u901A\u76EE\u5F55\uFF0C\u4E0D\u80FD\u4F7F\u7528\u7B26\u53F7\u94FE\u63A5\uFF1A${path}`);
   }
 }
@@ -866,17 +909,17 @@ async function writeOnce(path, bytes) {
 }
 async function bundledSkill(root) {
   for (const path of REQUIRED) {
-    if (!(await state(join2(root, path)))?.isFile()) {
+    if (!(await state(join3(root, path)))?.isFile()) {
       throw new CreatorPreparationError(`CLI \u5185\u7F6E Creator Skill \u4E0D\u5B8C\u6574\uFF0C\u8BF7\u91CD\u65B0\u5B89\u88C5 CLI\uFF08\u7F3A\u5C11 ${path}\uFF09\u3002\u4E0D\u4F1A\u5C1D\u8BD5\u5728\u7EBF\u4E0B\u8F7D\u6216\u8986\u76D6\u9879\u76EE\u8D44\u6599\u3002`);
     }
   }
   return root;
 }
 function handoffMarkdown(context, skillRoot, session, workspacePath) {
-  const contextPath = join2(context.projectRoot, ".buddy", "creator", "initial-context.json");
+  const contextPath = join3(context.projectRoot, ".buddy", "creator", "initial-context.json");
   const openArgs = [
     "-B",
-    join2(skillRoot, "scripts/buddy.py"),
+    join3(skillRoot, "scripts/buddy.py"),
     "open",
     "--workspace",
     workspacePath,
@@ -906,7 +949,7 @@ function handoffMarkdown(context, skillRoot, session, workspacePath) {
 
 ## \u73B0\u5728\u7531 Coding Agent \u6267\u884C
 
-1. \u5B8C\u6574\u8BFB\u53D6 ${JSON.stringify(join2(skillRoot, "SKILL.md"))} \u53CA\u5176\u6307\u5B9A\u7684 references\u3002\u4FDD\u7559\u539F\u6709\u56DB\u9636\u6BB5\u89C4\u5219\uFF0C\u7531\u5F53\u524D\u4E3B\u5BF9\u8BDD\u5B8C\u6210\u91C7\u8BBF\uFF1B\u65E0\u9700\u53E6\u8D77 Sub-agent \u6216\u8FD0\u884C\u91C7\u8BBF\u6A21\u578B\u670D\u52A1\u3002
+1. \u5B8C\u6574\u8BFB\u53D6 ${JSON.stringify(join3(skillRoot, "SKILL.md"))} \u53CA\u5176\u6307\u5B9A\u7684 references\u3002\u4FDD\u7559\u539F\u6709\u56DB\u9636\u6BB5\u89C4\u5219\uFF0C\u7531\u5F53\u524D\u4E3B\u5BF9\u8BDD\u5B8C\u6210\u91C7\u8BBF\uFF1B\u65E0\u9700\u53E6\u8D77 Sub-agent \u6216\u8FD0\u884C\u91C7\u8BBF\u6A21\u578B\u670D\u52A1\u3002
 2. \u67E5\u627E\u5BBF\u4E3B\u6216\u7CFB\u7EDF\u5B9E\u9645\u53EF\u7528\u7684 Python 3.9+\uFF0C\u68C0\u67E5\u7248\u672C\uFF0C\u4FDD\u5B58\u5176\u7EDD\u5BF9\u8DEF\u5F84\u3002\u4E0D\u8981\u5199\u6B7B\u672C\u673A\u8DEF\u5F84\uFF0C\u4E0D\u5B89\u88C5 pip/npm \u4F9D\u8D56\u3002\u6CA1\u6709 Python \u65F6\u62A5\u544A\u7F3A\u53E3\uFF0C\u4FDD\u7559\u672C\u5730\u9879\u76EE\u3002\u6240\u6709 Python \u8C03\u7528\u5747\u52A0 -B\uFF0C\u5E76\u8BBE\u7F6E\u8FDB\u7A0B\u73AF\u5883\u53D8\u91CF PYTHONDONTWRITEBYTECODE=1\uFF08\u7531\u9884\u89C8\u5B50\u8FDB\u7A0B\u7EE7\u627F\uFF09\uFF0C\u907F\u514D\u5411 CLI \u5B89\u88C5\u76EE\u5F55\u5199\u5165\u5B57\u8282\u7801\u7F13\u5B58\u3002
 3. \u4F7F\u7528\u5DE5\u5177\u4F20\u9012\u72EC\u7ACB\u53C2\u6570\uFF0C\u4E0D\u62FC\u63A5 shell \u5B57\u7B26\u4E32\u3002\u5DE5\u4F5C\u76EE\u5F55\u4E3A ${JSON.stringify(context.projectRoot)}\uFF1B\u4EE5\u5B9E\u9645 Python \u8DEF\u5F84\u4E3A executable\uFF0C\u9996\u6B21\u6253\u5F00\u7684 argv \u5982\u4E0B\uFF1A
 
@@ -943,11 +986,11 @@ ${DEVELOPMENT_HANDOFF}
 `;
 }
 async function prepareCreatorSkill(context, io, options = {}) {
-  const root = join2(context.projectRoot, ".buddy", "creator");
+  const root = join3(context.projectRoot, ".buddy", "creator");
   try {
-    await safeDirectory(join2(context.projectRoot, ".buddy"));
+    await safeDirectory(join3(context.projectRoot, ".buddy"));
     await safeDirectory(root);
-    const sessionPath = join2(root, "session.json");
+    const sessionPath = join3(root, "session.json");
     await writeOnce(sessionPath, JSON.stringify({
       schemaVersion: 1,
       platformBuddyId: context.buddyId,
@@ -959,11 +1002,11 @@ async function prepareCreatorSkill(context, io, options = {}) {
     }
     options.signal?.throwIfAborted();
     const skillRoot = await bundledSkill(options.bundledSkillRoot ?? BUNDLED_CREATOR_SKILL_ROOT);
-    await safeDirectory(join2(root, "workspaces"));
-    const workspacePath = join2(root, "workspaces", session.creationKey);
+    await safeDirectory(join3(root, "workspaces"));
+    const workspacePath = join3(root, "workspaces", session.creationKey);
     const workspace = await state(workspacePath);
     if (workspace && !workspace.isDirectory()) throw new CreatorPreparationError("\u5DF2\u6709\u521B\u4F5C\u5DE5\u4F5C\u533A\u4E0D\u662F\u666E\u901A\u76EE\u5F55\u3002");
-    const contextPath = join2(root, "initial-context.json");
+    const contextPath = join3(root, "initial-context.json");
     await writeOnce(contextPath, JSON.stringify({
       source: "platform_meta",
       name: context.appName,
@@ -979,7 +1022,7 @@ async function prepareCreatorSkill(context, io, options = {}) {
     } catch {
       throw new CreatorPreparationError(`\u5DF2\u6709\u521D\u59CB\u80CC\u666F\u65E0\u6548\uFF0C\u5DF2\u4FDD\u7559\u539F\u6587\u4EF6\uFF0C\u8BF7\u68C0\u67E5\uFF1A${contextPath}`);
     }
-    const handoffPath = join2(root, "HANDOFF.md");
+    const handoffPath = join3(root, "HANDOFF.md");
     const handoff = handoffMarkdown({
       ...context,
       appName: initial.name,
@@ -990,11 +1033,11 @@ async function prepareCreatorSkill(context, io, options = {}) {
     if ((await safeRead(handoffPath))?.toString("utf8") !== handoff) {
       throw new CreatorPreparationError(`\u5DF2\u6709\u63A5\u7EED\u8BF4\u660E\u88AB\u4FEE\u6539\u6216\u9879\u76EE\u8DEF\u5F84\u5DF2\u53D8\u5316\uFF0C\u5DF2\u4FDD\u7559\u539F\u6587\u4EF6\u3002\u8BF7\u5907\u4EFD\u79FB\u8D70\u8BE5\u8BF4\u660E\u540E\u91CD\u8BD5\uFF1A${handoffPath}`);
     }
-    io.write(`\u4F7F\u7528 CLI \u5185\u7F6E Creator Skill\uFF0C\u65E0\u9700\u989D\u5916\u4E0B\u8F7D\uFF1A${join2(skillRoot, "SKILL.md")}`);
+    io.write(`\u4F7F\u7528 CLI \u5185\u7F6E Creator Skill\uFF0C\u65E0\u9700\u989D\u5916\u4E0B\u8F7D\uFF1A${join3(skillRoot, "SKILL.md")}`);
     io.write(`\u4E0B\u4E00\u6B65\u4EA4\u7ED9 Codex / Claude Code \u7B49 Coding Agent\uFF1A\u8BF7\u8BFB\u53D6 ${JSON.stringify(handoffPath)}\uFF0C\u6309\u5F53\u524D\u9636\u6BB5\u63A5\u7EED\uFF1BCreator \u5B8C\u6210\u540E\u8FD4\u56DE CLI \u5F00\u53D1\u6D41\u7A0B\u3002`);
     io.write(DEVELOPMENT_HANDOFF_SUMMARY);
     io.write("\u672C\u547D\u4EE4\u53EA\u8D1F\u8D23\u8EAB\u4EFD\u767B\u8BB0\u548C Skill \u51C6\u5907\uFF0C\u4E0D\u4EE3\u8868\u91C7\u8BBF\u3001Booklet \u6216 Agent \u5DF2\u5B8C\u6210\u3002\u8BF7\u6309\u5DF2\u6709\u4F5C\u54C1\u8FDB\u5EA6\u63A5\u7EED\uFF0C\u624B\u518C\u786E\u8BA4\u540E\u518D\u8865\u9F50\u5B98\u65B9 Runtime \u5DE5\u7A0B\uFF1B\u91CD\u590D create \u4F1A\u590D\u7528\u540C\u4E00\u4F5C\u54C1\u3002");
-    return { exitCode: 0, creator: { skillPath: join2(skillRoot, "SKILL.md"), handoffPath, workspacePath } };
+    return { exitCode: 0, creator: { skillPath: join3(skillRoot, "SKILL.md"), handoffPath, workspacePath } };
   } catch (cause) {
     const message = cause instanceof CreatorPreparationError ? cause.message : "\u5185\u7F6E\u8D44\u6E90\u8BFB\u53D6\u6216\u672C\u5730\u5199\u5165\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5 CLI \u5B89\u88C5\u548C\u76EE\u5F55\u6743\u9650\u3002";
     io.writeError(`Creator Skill \u51C6\u5907\u5931\u8D25\uFF1A${message}`);
@@ -1005,9 +1048,9 @@ async function prepareCreatorSkill(context, io, options = {}) {
 
 // packages/cli-core/src/cloud/errors.ts
 var CloudLifecycleError = class extends Error {
-  constructor(code, message, details = {}) {
+  constructor(code2, message, details = {}) {
     super(message);
-    this.code = code;
+    this.code = code2;
     this.name = "CloudLifecycleError";
     this.details = Object.freeze({ ...details });
   }
@@ -1345,9 +1388,9 @@ function buildAgentEnvironment(options) {
 }
 
 // packages/cli-core/src/dev/orchestrator.ts
-import { createHash } from "node:crypto";
-import { readFile as readFile4 } from "node:fs/promises";
-import { join as join3, resolve as resolve4 } from "node:path";
+import { createHash as createHash2 } from "node:crypto";
+import { readFile as readFile5 } from "node:fs/promises";
+import { join as join5, resolve as resolve4 } from "node:path";
 
 // packages/cli-core/src/dev/launch.ts
 import { lstatSync, readFileSync } from "node:fs";
@@ -1443,9 +1486,9 @@ var NodeAgentProcessLauncher = class {
           resolve12({ code: null, signal: null, error: error2 });
         }
       });
-      child.once("exit", (code, signal) => {
+      child.once("exit", (code2, signal) => {
         hasExited = true;
-        resolve12({ code, signal });
+        resolve12({ code: code2, signal });
       });
     });
     child.stdout?.on("data", (chunk) => {
@@ -1604,6 +1647,106 @@ function processTreeControllerFor(platform) {
   });
 }
 
+// packages/cli-core/src/dev/instance-lock.ts
+import { createHash, randomUUID as randomUUID3 } from "node:crypto";
+import { mkdir as mkdir4, readFile as readFile4, readdir as readdir2, rename as rename2, rmdir as rmdir2, unlink as unlink4, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join as join4 } from "node:path";
+function alreadyRunningError() {
+  const message = "\u8FD9\u4E2A\u642D\u5B50\u5DF2\u6709 DEV \u5B9E\u4F8B\u5728\u8FD0\u884C\u3002\u8BF7\u5148\u5728\u539F\u9884\u89C8\u9875\u70B9\u51FB\u300C\u505C\u6B62 DEV\u300D\uFF0C\u6216\u5728\u8FD0\u884C dev \u7684\u7EC8\u7AEF\u6309 Ctrl+C\uFF0C\u518D\u542F\u52A8\u3002";
+  return Object.assign(new BuddyDevError({ code: "DEV_ALREADY_RUNNING", phase: "launch", message }), { publicMessage: message });
+}
+function alive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error2) {
+    return error2.code !== "ESRCH";
+  }
+}
+function validPid(pid) {
+  return Number.isSafeInteger(pid) && pid > 0;
+}
+function code(error2) {
+  return error2?.code;
+}
+async function acquireDevInstanceLock(options) {
+  const root = options.directory ?? join4(homedir(), ".buddy", "dev-locks");
+  const key = createHash("sha256").update(`${new URL(options.gatewayUrl).origin}
+${options.devAgentId}`).digest("hex");
+  const path = join4(root, key);
+  const ownerName = `owner-${randomUUID3()}.json`;
+  const candidate = join4(root, `.pending-${randomUUID3()}`);
+  const owner = { pid: process.pid };
+  await mkdir4(root, { recursive: true, mode: 448 });
+  await mkdir4(candidate, { mode: 448 });
+  await writeFile2(join4(candidate, ownerName), JSON.stringify(owner), { mode: 384, flag: "wx" });
+  try {
+    for (let attempt = 0; ; attempt++) {
+      try {
+        await rename2(candidate, path);
+        break;
+      } catch (error2) {
+        if (!["EEXIST", "ENOTEMPTY"].includes(code(error2) ?? "")) throw error2;
+        if (attempt >= 8) throw alreadyRunningError();
+      }
+      let names;
+      try {
+        names = await readdir2(path);
+      } catch (error2) {
+        if (code(error2) === "ENOENT") continue;
+        throw error2;
+      }
+      if (names.length === 0) continue;
+      if (names.length !== 1 || !/^owner-[a-f0-9-]+\.json$/u.test(names[0])) throw alreadyRunningError();
+      const previousPath = join4(path, names[0]);
+      let previous;
+      try {
+        previous = JSON.parse(await readFile4(previousPath, "utf8"));
+      } catch (error2) {
+        if (code(error2) === "ENOENT") continue;
+        throw alreadyRunningError();
+      }
+      if (!validPid(previous.pid) || previous.runtimePid !== void 0 && !validPid(previous.runtimePid) || alive(previous.pid) || previous.runtimePid !== void 0 && alive(previous.runtimePid)) throw alreadyRunningError();
+      try {
+        await unlink4(previousPath);
+      } catch (error2) {
+        if (code(error2) === "ENOENT") continue;
+        throw error2;
+      }
+      await rmdir2(path).catch((error2) => {
+        if (!["ENOENT", "ENOTEMPTY", "EEXIST"].includes(code(error2) ?? "")) throw error2;
+      });
+    }
+  } finally {
+    await unlink4(join4(candidate, ownerName)).catch(() => void 0);
+    await rmdir2(candidate).catch(() => void 0);
+  }
+  let released = false;
+  return {
+    async attachRuntime(pid) {
+      if (!validPid(pid)) throw new TypeError("Runtime PID is invalid");
+      const temporary = join4(root, `.update-${randomUUID3()}`);
+      try {
+        await writeFile2(temporary, JSON.stringify({ ...owner, runtimePid: pid }), { mode: 384, flag: "wx" });
+        await rename2(temporary, join4(path, ownerName));
+      } finally {
+        await unlink4(temporary).catch(() => void 0);
+      }
+    },
+    async release() {
+      if (released) return;
+      released = true;
+      await unlink4(join4(path, ownerName)).catch((error2) => {
+        if (code(error2) !== "ENOENT") throw error2;
+      });
+      await rmdir2(path).catch((error2) => {
+        if (!["ENOENT", "ENOTEMPTY", "EEXIST"].includes(code(error2) ?? "")) throw error2;
+      });
+    }
+  };
+}
+
 // packages/cli-core/src/dev/orchestrator.ts
 var DEFAULT_ONLINE_TIMEOUT_MS = 3e4;
 var DEFAULT_POLL_INTERVAL_MS = 200;
@@ -1740,6 +1883,7 @@ var ReadyBuddyDevHandle = class {
   completion;
   #process;
   #processTree;
+  #instanceLock;
   #lifecycle;
   #stopGracePeriodMs;
   #onStateChange;
@@ -1755,6 +1899,7 @@ var ReadyBuddyDevHandle = class {
     this.gatewayUrl = new URL(options.gatewayUrl);
     this.#process = options.process;
     this.#processTree = options.processTree;
+    this.#instanceLock = options.instanceLock;
     this.#lifecycle = options.lifecycle;
     this.#stopGracePeriodMs = options.stopGracePeriodMs;
     this.#signal = options.signal;
@@ -1785,6 +1930,7 @@ var ReadyBuddyDevHandle = class {
     this.#lifecycle.abort(new Error("DEV session stopped"));
     try {
       await this.#processTree.terminate(this.#process, { gracePeriodMs: this.#stopGracePeriodMs });
+      await this.#instanceLock.release();
       this.#emit("stopped");
       this.#finish({ state: "stopped" });
     } catch (cause) {
@@ -1805,7 +1951,7 @@ var ReadyBuddyDevHandle = class {
     this.#lifecycle.abort(error2);
     await this.#processTree.terminate(this.#process, {
       gracePeriodMs: Math.min(this.#stopGracePeriodMs, 1e3)
-    }).catch(() => void 0);
+    }).then(() => this.#instanceLock.release()).catch(() => void 0);
     this.#finish({ state: "failed", error: error2 });
   }
   #emit(state2) {
@@ -1838,6 +1984,7 @@ async function startBuddyDev(options) {
   const signal = options.signal === void 0 ? lifecycle.signal : AbortSignal.any([lifecycle.signal, options.signal]);
   let agentProcess;
   let processTree;
+  let instanceLock;
   const emit = (state2) => {
     try {
       options.onStateChange?.(state2);
@@ -1850,7 +1997,7 @@ async function startBuddyDev(options) {
     let config;
     let configSource;
     try {
-      configSource = await readFile4(join3(projectRoot, BUDDY_AGENT_FILENAME), "utf8");
+      configSource = await readFile5(join5(projectRoot, BUDDY_AGENT_FILENAME), "utf8");
       config = combineBuddyProject(parseBuddyAgentConfig(configSource));
     } catch (cause) {
       throw new BuddyDevError({
@@ -1865,10 +2012,20 @@ async function startBuddyDev(options) {
       client: options.registrationClient,
       devAgentId,
       configSource,
-      configDigest: `sha256:${createHash("sha256").update(configSource).digest("hex")}`,
+      configDigest: `sha256:${createHash2("sha256").update(configSource).digest("hex")}`,
       signal
     });
     throwIfDevAborted(signal);
+    instanceLock = await acquireDevInstanceLock({
+      gatewayUrl: registration.appServerUrl,
+      devAgentId,
+      directory: options.instanceLockDirectory
+    });
+    const online = await options.registrationClient.listOnline({
+      signal: AbortSignal.any([signal, AbortSignal.timeout(onlineTimeoutMs)])
+    });
+    if (online.some((item) => item.devAgentId === devAgentId && item.online)) throw alreadyRunningError();
+    throwIfDevAborted(signal);
     const environment = buildAgentEnvironment({
       parentEnv: options.parentEnv ?? process.env,
       buddyId: devAgentId,
@@ -1889,6 +2046,7 @@ async function startBuddyDev(options) {
         onStderr: (text) => options.onLog?.({ source: "agent.stderr", text })
       }
     });
+    await instanceLock.attachRuntime(agentProcess.pid);
     const exited = agentProcess.exit.then((exit) => {
       throw agentExitedError(exit);
     });
@@ -1910,6 +2068,7 @@ async function startBuddyDev(options) {
       gatewayUrl: new URL(environment.MLB_GATEWAY_URL),
       process: agentProcess,
       processTree,
+      instanceLock,
       lifecycle,
       stopGracePeriodMs,
       ...options.signal === void 0 ? {} : { signal: options.signal },
@@ -1920,7 +2079,9 @@ async function startBuddyDev(options) {
     const aborted = options.signal?.aborted || isAbortLike(cause) || cause instanceof BuddyDevError && cause.code === "DEV_ABORTED";
     if (agentProcess !== void 0 || aborted) emit("stopping");
     if (agentProcess !== void 0 && processTree !== void 0) {
-      await processTree.terminate(agentProcess, { gracePeriodMs: stopGracePeriodMs }).catch(() => void 0);
+      await processTree.terminate(agentProcess, { gracePeriodMs: stopGracePeriodMs }).then(() => instanceLock?.release()).catch(() => void 0);
+    } else {
+      await instanceLock?.release();
     }
     if (aborted) {
       emit("stopped");
@@ -1959,12 +2120,12 @@ function createBuddyDevStarter(options = {}) {
 }
 
 // packages/cli-core/src/project-context.ts
-import { lstat as lstat4, realpath } from "node:fs/promises";
-import { dirname as dirname2, join as join4, resolve as resolve6 } from "node:path";
+import { lstat as lstat5, realpath } from "node:fs/promises";
+import { dirname as dirname2, join as join6, resolve as resolve6 } from "node:path";
 var BuddyProjectContextError = class extends Error {
-  constructor(code, message, targetPath, options) {
+  constructor(code2, message, targetPath, options) {
     super(message, options);
-    this.code = code;
+    this.code = code2;
     this.targetPath = targetPath;
     this.name = "BuddyProjectContextError";
   }
@@ -1975,7 +2136,7 @@ async function existingDirectory(target) {
   const requested = resolve6(target);
   let entry;
   try {
-    entry = await lstat4(requested);
+    entry = await lstat5(requested);
   } catch (cause) {
     if (cause.code === "ENOENT") {
       throw new BuddyProjectContextError(
@@ -1997,9 +2158,9 @@ async function existingDirectory(target) {
   return realpath(requested);
 }
 async function projectFileState(directory, filename) {
-  const configPath = join4(directory, filename);
+  const configPath = join6(directory, filename);
   try {
-    const entry = await lstat4(configPath);
+    const entry = await lstat5(configPath);
     if (!entry.isFile() || entry.isSymbolicLink()) {
       throw new BuddyProjectContextError(
         "PROJECT_CONFIG_INVALID",
@@ -2040,15 +2201,17 @@ async function requireBuddyProjectRoot(startDirectory) {
 }
 async function requireBuddyAgentProjectRoot(startDirectory) {
   const root = await requireBuddyProjectRoot(startDirectory);
-  const agentPath = join4(root, BUDDY_AGENT_FILENAME);
+  const agentPath = join6(root, BUDDY_AGENT_FILENAME);
   try {
     await readBuddyAgentConfig(root);
+    const missing = await missingBuddyAgentFiles(root);
+    if (missing.length > 0) throw new Error(`\u5DE5\u7A0B\u7F3A\u5C11\u6709\u6548\u6587\u4EF6\uFF1A${missing.join("\u3001")}`);
     return root;
   } catch (cause) {
     throw new BuddyProjectContextError(
       "PROJECT_NOT_FOUND",
       [
-        `\u5F53\u524D ${BUDDY_AGENT_FILENAME} \u5C1A\u672A\u5F62\u6210\u53EF\u8FD0\u884C\u7684 Agent \u5DE5\u7A0B\u5B9A\u4E49\u3002`,
+        `\u5F53\u524D buddy.agent.json \u6240\u5728\u5DE5\u7A0B\u5C1A\u4E0D\u53EF\u8FD0\u884C\uFF1A${cause instanceof Error ? cause.message : "\u8BF7\u68C0\u67E5 buddy.agent.json \u4E0E\u5DE5\u7A0B\u6587\u4EF6"}`,
         "\u8BF7\u5148\u8FD0\u884C buddy-cli init --mode direct \u8865\u9F50\u5B98\u65B9 Runtime \u5DE5\u7A0B\uFF0C\u518D\u8FD0\u884C dev\u3001preview \u6216 push\u3002"
       ].join("\n"),
       agentPath,
@@ -2060,7 +2223,7 @@ async function nearestExistingDirectory(target) {
   let candidate = resolve6(target);
   while (true) {
     try {
-      const entry = await lstat4(candidate);
+      const entry = await lstat5(candidate);
       if (!entry.isDirectory()) {
         throw new BuddyProjectContextError(
           "PROJECT_DIRECTORY_INVALID",
@@ -2109,7 +2272,7 @@ async function assertInitializableBuddyTarget(target) {
     } catch (cause) {
       throw new BuddyProjectContextError(
         "PROJECT_CONFIG_INVALID",
-        `${join4(projectRoot, BUDDY_AGENT_FILENAME)} \u4E0D\u662F\u6709\u6548\u7684\u9879\u76EE\u6E05\u5355\u3002`,
+        `${join6(projectRoot, BUDDY_AGENT_FILENAME)} \u4E0D\u662F\u6709\u6548\u7684\u9879\u76EE\u6E05\u5355\u3002`,
         requested,
         { cause }
       );
@@ -2261,7 +2424,7 @@ async function runDevCommand(args, io, options = {}) {
 import { resolve as resolve8 } from "node:path";
 
 // packages/cli-core/src/cloud/auth.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 
 // packages/cli-core/src/cloud/validation.ts
 function record(value, path = "request") {
@@ -2329,7 +2492,7 @@ var CloudAuthenticator = class {
     this.#adapter = adapter;
     this.#store = store;
     this.#now = options.now ?? Date.now;
-    this.#createState = options.createState ?? randomUUID3;
+    this.#createState = options.createState ?? randomUUID4;
     this.#minimumValidityMs = options.minimumValidityMs ?? 3e4;
     if (!Number.isSafeInteger(this.#minimumValidityMs) || this.#minimumValidityMs < 0) {
       throw new TypeError("minimumValidityMs must be a non-negative safe integer");
@@ -2548,8 +2711,8 @@ async function boundedJson(response) {
 function serverError(response, body) {
   const source = typeof body === "object" && body !== null && !Array.isArray(body) ? body : void 0;
   const message = typeof source?.error === "string" && source.error.trim() ? source.error.slice(0, 8 * 1024) : `\u5E73\u53F0\u8BF7\u6C42\u5931\u8D25\uFF08HTTP ${response.status}\uFF09`;
-  const code = response.status === 401 ? "AUTH_TOKEN_EXPIRED" : response.status === 404 ? "APP_NOT_FOUND" : response.status >= 500 ? "PLATFORM_UNAVAILABLE" : "INVALID_REQUEST";
-  return new CloudLifecycleError(code, message, {
+  const code2 = response.status === 401 ? "AUTH_TOKEN_EXPIRED" : response.status === 404 ? "APP_NOT_FOUND" : response.status >= 500 ? "PLATFORM_UNAVAILABLE" : "INVALID_REQUEST";
+  return new CloudLifecycleError(code2, message, {
     httpStatus: response.status,
     retryable: response.status === 408 || response.status === 429 || response.status >= 500
   });
@@ -2703,7 +2866,7 @@ var HttpDeveloperPlatformClient = class {
 };
 
 // packages/cli-core/src/cloud/browser-login.ts
-import { createHash as createHash2, randomBytes } from "node:crypto";
+import { createHash as createHash3, randomBytes } from "node:crypto";
 import { spawn } from "node:child_process";
 import { createServer } from "node:http";
 
@@ -2766,7 +2929,7 @@ async function openExternalUrl(url) {
   await new Promise((resolve12, reject) => {
     const child = spawn(launch.command, launch.args, { shell: false, stdio: "ignore", windowsHide: true });
     child.once("error", reject);
-    child.once("exit", (code) => code === 0 ? resolve12() : reject(new Error(`browser launcher exited with ${code ?? "unknown"}`)));
+    child.once("exit", (code2) => code2 === 0 ? resolve12() : reject(new Error(`browser launcher exited with ${code2 ?? "unknown"}`)));
   });
 }
 async function write(res, status, title, message, webUrl, tone = "error") {
@@ -2811,7 +2974,7 @@ var LoopbackBrowserLoginAdapter = class {
     if (request.signal?.aborted) throw request.signal.reason;
     const callbackSecret = randomBytes(24).toString("hex");
     const codeVerifier = randomBytes(32).toString("base64url");
-    const codeChallenge = createHash2("sha256").update(codeVerifier).digest("base64url");
+    const codeChallenge = createHash3("sha256").update(codeVerifier).digest("base64url");
     let requestId = "";
     let settle;
     let reject;
@@ -2895,15 +3058,15 @@ var LoopbackBrowserLoginAdapter = class {
       await write(res, 200, "\u5DF2\u53D6\u6D88\u6388\u6743", "\u6CA1\u6709\u5411 buddy-cli \u63D0\u4F9B\u8D26\u53F7\u6743\u9650\uFF0C\u53EF\u4EE5\u5173\u95ED\u8FD9\u4E2A\u9875\u9762\u3002", this.#developerWebUrl, "neutral");
       throw new CloudLifecycleError("AUTH_LOGIN_CANCELLED", "\u7528\u6237\u53D6\u6D88\u4E86 CLI \u6388\u6743");
     }
-    const code = url.searchParams.get("code");
-    if (!code || !AUTH_CODE.test(code) || !expected.requestId) {
+    const code2 = url.searchParams.get("code");
+    if (!code2 || !AUTH_CODE.test(code2) || !expected.requestId) {
       await write(res, 400, "\u767B\u5F55\u6CA1\u6709\u5B8C\u6210", "\u6388\u6743\u7ED3\u679C\u65E0\u6548\uFF0C\u8BF7\u56DE\u5230\u7EC8\u7AEF\u91CD\u8BD5\u3002", this.#developerWebUrl);
       throw new CloudLifecycleError("PLATFORM_RESPONSE_INVALID", "\u642D\u642D\u521B\u4F5C\u8005\u5E73\u53F0\u8FD4\u56DE\u4E86\u65E0\u6548\u6388\u6743\u7801");
     }
     try {
       const exchanged = await this.#post("api/cli/exchange", {
         requestId: expected.requestId,
-        code,
+        code: code2,
         codeVerifier: expected.codeVerifier
       });
       if (exchanged.platformOrigin !== this.#platformUrl.origin || typeof exchanged.token !== "string" || typeof exchanged.userId !== "string" || !Number.isSafeInteger(exchanged.expiresAt)) {
@@ -3006,8 +3169,8 @@ async function runCredentialCommand(input) {
     child.stdout.on("data", (chunk) => collect(stdout, chunk));
     child.stderr.on("data", (chunk) => collect(stderr, chunk));
     child.once("error", reject);
-    child.once("close", (code) => resolve12({
-      code: code ?? 1,
+    child.once("close", (code2) => resolve12({
+      code: code2 ?? 1,
       stdout: Buffer.concat(stdout).toString("utf8"),
       stderr: Buffer.concat(stderr).toString("utf8")
     }));
@@ -3360,8 +3523,8 @@ async function runCloudCommand(command, args, io, options = {}) {
 var CLOUD_COMMAND_HELP = HELP;
 
 // packages/cli-core/src/migration/index.ts
-import { lstat as lstat5, open as open3, readdir as readdir2, realpath as realpath2, stat } from "node:fs/promises";
-import { extname, isAbsolute as isAbsolute2, join as join5, relative, resolve as resolve9, sep, win32 as win322 } from "node:path";
+import { lstat as lstat6, open as open3, readdir as readdir3, realpath as realpath2, stat } from "node:fs/promises";
+import { extname, isAbsolute as isAbsolute2, join as join7, relative, resolve as resolve9, sep, win32 as win322 } from "node:path";
 var DEFAULT_SKILL_SCAN_LIMITS = Object.freeze({
   maxFiles: 128,
   maxFileBytes: 256 * 1024,
@@ -3404,20 +3567,20 @@ var KNOWN_HOST_TOOLS = [
   "WebSearch",
   "Write"
 ];
-function issue(code, path, line, severity, message) {
-  return Object.freeze({ code, path, line, severity, message });
+function issue(code2, path, line, severity, message) {
+  return Object.freeze({ code: code2, path, line, severity, message });
 }
-function rejectScan(code, path, message, cause) {
+function rejectScan(code2, path, message, cause) {
   throw new SkillPortabilityScanError(
-    issue(code, path, 1, "error", message),
+    issue(code2, path, 1, "error", message),
     cause === void 0 ? void 0 : { cause }
   );
 }
-function addFinding(state2, code, path, line, severity, message) {
-  const key = `${code}\0${path}\0${line}\0${message}`;
+function addFinding(state2, code2, path, line, severity, message) {
+  const key = `${code2}\0${path}\0${line}\0${message}`;
   if (state2.issueKeys.has(key)) return;
   state2.issueKeys.add(key);
-  state2.issues.push(issue(code, path, line, severity, message));
+  state2.issues.push(issue(code2, path, line, severity, message));
 }
 function compareText(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
@@ -3530,9 +3693,9 @@ async function existingProjectRoot(value) {
   }
 }
 async function existingSkillRoot(projectRoot, skillPath) {
-  const candidate = skillPath === "." ? projectRoot : join5(projectRoot, ...skillPath.split("/"));
+  const candidate = skillPath === "." ? projectRoot : join7(projectRoot, ...skillPath.split("/"));
   try {
-    await lstat5(candidate);
+    await lstat6(candidate);
   } catch (cause) {
     if (filesystemCode(cause) === "ENOENT") {
       return rejectScan("SKILL_ROOT_NOT_FOUND", skillPath, "\u627E\u4E0D\u5230\u6307\u5B9A\u7684 Skill \u76EE\u5F55\u3002");
@@ -3567,9 +3730,9 @@ async function existingSkillRoot(projectRoot, skillPath) {
 }
 async function assertEntrypoint(context) {
   const entryPath = reportChild(context.skillPath, "SKILL.md");
-  const candidate = join5(context.skillRoot, "SKILL.md");
+  const candidate = join7(context.skillRoot, "SKILL.md");
   try {
-    await lstat5(candidate);
+    await lstat6(candidate);
     const target = await realpath2(candidate);
     if (!isWithin(context.projectRoot, target) || !isWithin(context.skillRoot, target)) {
       rejectScan(
@@ -3634,7 +3797,7 @@ async function walkDirectory(actualDirectory, reportDirectory, ancestors, contex
   nextAncestors.add(directoryKey);
   let entries;
   try {
-    entries = await readdir2(directory, { withFileTypes: true, encoding: "utf8" });
+    entries = await readdir3(directory, { withFileTypes: true, encoding: "utf8" });
   } catch (cause) {
     return rejectScan("SKILL_SCAN_IO_ERROR", reportDirectory, "\u65E0\u6CD5\u5217\u51FA Skill \u5B50\u76EE\u5F55\u3002", cause);
   }
@@ -3671,7 +3834,7 @@ async function walkDirectory(actualDirectory, reportDirectory, ancestors, contex
   }
   for (const entry of entries) {
     const childReportPath = reportChild(reportDirectory, entry.name);
-    const childPath = join5(directory, entry.name);
+    const childPath = join7(directory, entry.name);
     let target;
     try {
       target = await realpath2(childPath);
@@ -4125,9 +4288,9 @@ async function scanExternalSkillPortability(options) {
 }
 
 // packages/cli-core/src/push/preflight.ts
-import { createHash as createHash3 } from "node:crypto";
-import { lstat as lstat6, open as open4, readdir as readdir3, realpath as realpath3 } from "node:fs/promises";
-import { isAbsolute as isAbsolute3, join as join6, relative as relative2, resolve as resolve10, sep as sep2, win32 as win323 } from "node:path";
+import { createHash as createHash4 } from "node:crypto";
+import { lstat as lstat7, open as open4, readdir as readdir4, realpath as realpath3 } from "node:fs/promises";
+import { isAbsolute as isAbsolute3, join as join8, relative as relative2, resolve as resolve10, sep as sep2, win32 as win323 } from "node:path";
 
 // packages/cli-core/src/push/errors.ts
 var PushPreflightError = class extends Error {
@@ -4225,7 +4388,7 @@ function error(options) {
   throw new PushPreflightError(options);
 }
 function sha256(value) {
-  return `sha256:${createHash3("sha256").update(value).digest("hex")}`;
+  return `sha256:${createHash4("sha256").update(value).digest("hex")}`;
 }
 function positiveLimit(value, name, hardMaximum) {
   if (!Number.isSafeInteger(value) || value < 1 || value > hardMaximum) {
@@ -4318,7 +4481,7 @@ async function canonicalProjectRoot(projectRoot) {
   const absolute = resolve10(projectRoot);
   let entry;
   try {
-    entry = await lstat6(absolute);
+    entry = await lstat7(absolute);
   } catch (cause) {
     error({
       code: "PUSH_PROJECT_INVALID",
@@ -4346,10 +4509,10 @@ async function canonicalProjectRoot(projectRoot) {
   }
 }
 async function captureConfigWithinLimit(projectRoot, maxFileBytes, filename) {
-  const path = join6(projectRoot, filename);
+  const path = join8(projectRoot, filename);
   let entry;
   try {
-    entry = await lstat6(path);
+    entry = await lstat7(path);
   } catch (cause) {
     error({
       code: "PUSH_CONFIG_INVALID",
@@ -4416,7 +4579,7 @@ function parseCapturedProject(agentFile) {
 async function selectLockfile(projectRoot) {
   let names;
   try {
-    names = await readdir3(projectRoot);
+    names = await readdir4(projectRoot);
   } catch (cause) {
     error({
       code: "PUSH_PROJECT_INVALID",
@@ -4471,7 +4634,7 @@ async function hashRegularFile(options) {
         message: `\u751F\u6210\u6E05\u5355\u65F6\u6587\u4EF6\u53D1\u751F\u53D8\u5316\uFF1A${options.portablePath}`
       });
     }
-    const hash = createHash3("sha256");
+    const hash = createHash4("sha256");
     const captured = [];
     const buffer = Buffer.allocUnsafe(READ_BUFFER_BYTES);
     let bytes = 0;
@@ -4525,7 +4688,7 @@ async function createManifest(options) {
     }
     let names;
     try {
-      names = await readdir3(directory);
+      names = await readdir4(directory);
     } catch (cause) {
       error({
         code: "PUSH_PROJECT_INVALID",
@@ -4549,10 +4712,10 @@ async function createManifest(options) {
         sensitiveEntriesExcluded += 1;
         continue;
       }
-      const absolutePath = join6(directory, name);
+      const absolutePath = join8(directory, name);
       let entry;
       try {
-        entry = await lstat6(absolutePath);
+        entry = await lstat7(absolutePath);
       } catch (cause) {
         error({
           code: "PUSH_FILE_CHANGED",
@@ -4739,8 +4902,8 @@ function bundleDigest(files) {
   });
   return sha256(`buddy-push-bundle-v1\0${descriptor}`);
 }
-function warning(code, message) {
-  return Object.freeze({ code, message });
+function warning(code2, message) {
+  return Object.freeze({ code: code2, message });
 }
 function assertOfficialProjectIncluded(files) {
   for (const path of OFFICIAL_RUNTIME_INPUTS) {
@@ -4801,8 +4964,8 @@ async function assertCapturedConfigStable(options) {
   }
   let current;
   try {
-    const path = join6(options.projectRoot, options.filename);
-    const entry = await lstat6(path);
+    const path = join8(options.projectRoot, options.filename);
+    const entry = await lstat7(path);
     if (!entry.isFile() || entry.isSymbolicLink()) {
       error({
         code: "PUSH_FILE_CHANGED",
@@ -4844,7 +5007,7 @@ async function createPushPreflight(options) {
     limits.maxFileBytes,
     BUDDY_AGENT_FILENAME
   );
-  const initialConfig = parseCapturedProject(initialAgentEntry);
+  parseCapturedProject(initialAgentEntry);
   const lockfile = await selectLockfile(projectRoot);
   assertBookletIsNotRequiredInput(bookletPath, lockfile);
   const manifest = await createManifest({
@@ -4902,7 +5065,7 @@ async function createPushPreflight(options) {
     schemaVersion: "1",
     assurance: "preflight-only",
     projectRoot,
-    runtimeLanguage: initialConfig.runtime.language,
+    runtimeLanguage: "node",
     ...bookletPath === void 0 ? {} : { bookletPath },
     lockfile,
     limits,
@@ -4916,16 +5079,16 @@ async function createPushPreflight(options) {
 }
 
 // packages/cli-core/src/push/bundle.ts
-import { createHash as createHash4 } from "node:crypto";
-import { lstat as lstat7, readFile as readFile5, realpath as realpath4 } from "node:fs/promises";
-import { join as join7, relative as relative3, sep as sep3, win32 as win324 } from "node:path";
+import { createHash as createHash5 } from "node:crypto";
+import { lstat as lstat8, readFile as readFile6, realpath as realpath4 } from "node:fs/promises";
+import { join as join9, relative as relative3, sep as sep3, win32 as win324 } from "node:path";
 import { Writable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createGzip } from "node:zlib";
 import { pack } from "tar-stream";
 var MEDIA_TYPE = "application/gzip";
 function digest(bytes) {
-  return `sha256:${createHash4("sha256").update(bytes).digest("hex")}`;
+  return `sha256:${createHash5("sha256").update(bytes).digest("hex")}`;
 }
 function changed(path, message, cause) {
   throw new PushPreflightError({
@@ -4940,15 +5103,15 @@ function inside(root, target) {
   return path === "" || path !== ".." && !path.startsWith(`..${sep3}`) && !path.startsWith("/") && !win324.isAbsolute(path);
 }
 async function capture(root, file) {
-  const absolute = join7(root, ...file.path.split("/"));
+  const absolute = join9(root, ...file.path.split("/"));
   try {
-    const entry = await lstat7(absolute);
+    const entry = await lstat8(absolute);
     if (!entry.isFile() || entry.isSymbolicLink() || entry.size !== file.bytes) {
       changed(file.path, `\u63D0\u4EA4\u524D\u6587\u4EF6\u53D1\u751F\u53D8\u5316\uFF1A${file.path}`);
     }
     const canonical = await realpath4(absolute);
     if (!inside(root, canonical)) changed(file.path, `\u63D0\u4EA4\u6587\u4EF6\u8D8A\u8FC7\u9879\u76EE\u6839\u76EE\u5F55\uFF1A${file.path}`);
-    const contents = await readFile5(absolute);
+    const contents = await readFile6(absolute);
     if (contents.byteLength !== file.bytes || digest(contents) !== file.digest) {
       changed(file.path, `\u63D0\u4EA4\u524D\u6587\u4EF6\u5185\u5BB9\u53D1\u751F\u53D8\u5316\uFF1A${file.path}`);
     }
@@ -4974,7 +5137,7 @@ async function createPushSourceBundle(plan) {
     schemaVersion: "1",
     files: files.map((file) => ({ path: file.path, bytes: file.bytes, digest: file.digest }))
   });
-  const calculatedBundleDigest = `sha256:${createHash4("sha256").update(`buddy-push-bundle-v1\0${descriptor}`).digest("hex")}`;
+  const calculatedBundleDigest = `sha256:${createHash5("sha256").update(`buddy-push-bundle-v1\0${descriptor}`).digest("hex")}`;
   if (calculatedBundleDigest !== plan.bundleDigest) {
     changed(plan.projectRoot, "\u63D0\u4EA4\u6E05\u5355\u8EAB\u4EFD\u5728\u6253\u5305\u524D\u53D1\u751F\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C push");
   }
@@ -5370,7 +5533,7 @@ async function resumeProjectArguments(args, cwd, options) {
   await assertInitializableBuddyTarget(root);
   let entry;
   try {
-    entry = await lstat8(join8(root, "buddy.agent.json"));
+    entry = await lstat9(join10(root, "buddy.agent.json"));
   } catch (cause) {
     if (cause.code === "ENOENT") return;
     throw cause;