ai-project-manage-cli 8.1.21 → 8.1.23

package/dist/index.js

@@ -289,22 +289,6 @@ var requestConfig = {
       method: "POST",
       path: "/cli/webide/pull-requests/merge"
     }),
-    getProjectDocumentManifest: defineEndpoint({
-      method: "GET",
-      path: "/cli/project-documents/manifest"
-    }),
-    listProjectDocuments: defineEndpoint({
-      method: "GET",
-      path: "/cli/project-documents"
-    }),
-    upsertProjectDocument: defineEndpoint({
-      method: "PUT",
-      path: "/cli/project-documents/upsert"
-    }),
-    removeProjectDocument: defineEndpoint({
-      method: "DELETE",
-      path: "/cli/project-documents"
-    }),
     getApmLogStorage: defineEndpoint({
       method: "GET",
       path: "/cli/apm-log-storage"
@@ -423,9 +407,6 @@ async function ensureLoggedConfig() {
   }
   return cfg;
 }
-async function ensureDirExists(dir) {
-  mkdirSync2(dir, { recursive: true });
-}
 async function ensureWorkspaceApmDirForInit(cwd = resolveWorkdirPath()) {
   const dir = workspaceApmDir(cwd);
   const fsDir = toFsPath(dir);
@@ -838,360 +819,11 @@ async function runUpdateSkills() {
   await syncWorkspaceSkills(resolveWorkdirPath());
 }
 
-// src/utils/project-documents.ts
-import {
-  existsSync as existsSync5,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync4,
-  rmSync,
-  writeFileSync as writeFileSync3
-} from "fs";
-import { createHash } from "crypto";
-import { dirname as dirname2, join as join6, relative, sep } from "path";
-
-// src/utils/git.ts
-import { execFile as execFile2 } from "child_process";
-import { promisify as promisify2 } from "util";
-
-// src/utils/git-remote.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
-
-// src/utils/git.ts
-var execFileAsync2 = promisify2(execFile2);
-function gitExecEnv() {
-  const existing = process.env.GIT_SSH_COMMAND?.trim();
-  const acceptNew = "-o StrictHostKeyChecking=accept-new";
-  let gitSshCommand;
-  if (!existing) {
-    gitSshCommand = `ssh ${acceptNew}`;
-  } else if (/\bStrictHostKeyChecking=/.test(existing)) {
-    gitSshCommand = existing;
-  } else {
-    gitSshCommand = `${existing} ${acceptNew}`;
-  }
-  return { ...process.env, GIT_SSH_COMMAND: gitSshCommand };
-}
-async function execGit(cwd, args, quiet = false) {
-  try {
-    const { stdout, stderr } = await execFileAsync2("git", args, {
-      cwd,
-      env: gitExecEnv(),
-      encoding: "utf8",
-      maxBuffer: 10 * 1024 * 1024
-    });
-    if (!quiet && stderr.trim()) {
-      process.stderr.write(stderr);
-    }
-    return stdout;
-  } catch (err) {
-    const e = err;
-    const detail = (e.stderr ?? e.message ?? String(err)).trim();
-    throw new Error(
-      `[apm] git ${args.join(" ")} \u5931\u8D25${detail ? `: ${detail}` : ""}`
-    );
-  }
-}
-async function getCurrentBranch(cwd) {
-  return (await execGit(cwd, ["rev-parse", "--abbrev-ref", "HEAD"], true)).trim();
-}
-async function resolveGitRepoRoot(cwd) {
-  return (await execGit(cwd, ["rev-parse", "--show-toplevel"], true)).trim();
-}
-var FEATURE_BRANCH_RE = /^feat\/task-(.+)$/;
-function taskIdFromFeatureBranch(branch) {
-  const name = branch.trim().replace(/^origin\//, "");
-  const match = name.match(FEATURE_BRANCH_RE);
-  const id = match?.[1]?.trim() ?? "";
-  return id || null;
-}
-
-// src/utils/project-documents.ts
-var MANIFEST_FILE = "manifest.json";
-function normalizeProjectIdForPath(projectId) {
-  const id = projectId.trim();
-  if (!id) {
-    throw new Error("projectId \u4E0D\u80FD\u4E3A\u7A7A");
-  }
-  if (id.includes("..") || id.includes("/") || id.includes("\\") || id.includes("\0")) {
-    throw new Error(`\u975E\u6CD5 projectId: ${projectId}`);
-  }
-  return id;
-}
-function projectDocumentsDir(apmRoot, projectId) {
-  const id = normalizeProjectIdForPath(projectId);
-  return join6(apmRoot ?? workspaceApmDir(), "project", id);
-}
-function projectDocumentLocalPath(apmRoot, projectId, documentPath) {
-  const normalized = normalizeLocalDocumentPath(documentPath);
-  return join6(
-    projectDocumentsDir(apmRoot, projectId),
-    ...normalized.split("/")
-  );
-}
-function normalizeLocalDocumentPath(path) {
-  const trimmed = path.trim().replace(/\\/g, "/");
-  if (!trimmed || trimmed.startsWith("/") || /^[a-zA-Z]:/.test(trimmed)) {
-    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path}`);
-  }
-  const segments = trimmed.split("/").filter(Boolean);
-  if (segments.some((segment) => segment === ".." || segment === ".")) {
-    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path}`);
-  }
-  return segments.join("/");
-}
-function hashLocalFileContent(content) {
-  return createHash("sha256").update(content, "utf8").digest("hex");
-}
-function readLocalManifest(apmRoot, projectId) {
-  const manifestPath = join6(
-    projectDocumentsDir(apmRoot, projectId),
-    MANIFEST_FILE
-  );
-  if (!existsSync5(manifestPath)) {
-    return null;
-  }
-  try {
-    return JSON.parse(
-      readFileSync4(manifestPath, "utf8")
-    );
-  } catch {
-    return null;
-  }
-}
-function listLocalDocumentPaths(apmRoot, projectId) {
-  const root = projectDocumentsDir(apmRoot, projectId);
-  if (!existsSync5(root)) {
-    return [];
-  }
-  const paths = [];
-  const walk = (dir) => {
-    for (const entry of readdirSync3(dir, { withFileTypes: true })) {
-      const abs = join6(dir, entry.name);
-      if (entry.isDirectory()) {
-        walk(abs);
-        continue;
-      }
-      if (entry.isFile() && entry.name === MANIFEST_FILE) {
-        continue;
-      }
-      const rel = relative(root, abs).split(sep).join("/");
-      paths.push(rel);
-    }
-  };
-  walk(root);
-  return paths.sort();
-}
-function diffManifestPaths(remote, local) {
-  const remoteMap = new Map(
-    (remote?.documents ?? []).map((doc) => [doc.path, doc.contentHash])
-  );
-  const localMap = new Map(
-    (local?.documents ?? []).map((doc) => [doc.path, doc.contentHash])
-  );
-  const download = [];
-  for (const [path, hash] of remoteMap) {
-    if (localMap.get(path) !== hash) {
-      download.push(path);
-    }
-  }
-  const deleteLocal = [];
-  for (const path of localMap.keys()) {
-    if (!remoteMap.has(path)) {
-      deleteLocal.push(path);
-    }
-  }
-  return { download, deleteLocal };
-}
-async function resolveProjectIdForSync(api, workdirPath, options) {
-  const explicit = options?.projectId?.trim();
-  if (explicit) {
-    return { projectId: explicit, diagnostic: null };
-  }
-  try {
-    const gitRoot = await resolveGitRepoRoot(workdirPath);
-    const current = await getCurrentBranch(gitRoot);
-    const taskId = taskIdFromFeatureBranch(current);
-    if (!taskId) {
-      return {
-        projectId: null,
-        diagnostic: `\u5F53\u524D\u5206\u652F ${current} \u4E0D\u662F feat/task-*\uFF0C\u65E0\u6CD5\u89E3\u6790\u6240\u5C5E\u9879\u76EE\u3002
-\u8BF7\u5728\u7279\u6027\u5206\u652F\u4E0A\u6267\u884C\uFF0C\u6216\u663E\u5F0F\u6307\u5B9A projectId\u3002`
-      };
-    }
-    const baseline = await api.cli.projectBaseBranch({ taskId });
-    const projectId = baseline.projectId?.trim() || null;
-    if (!projectId) {
-      return {
-        projectId: null,
-        diagnostic: `\u4EFB\u52A1 ${taskId} \u672A\u5173\u8054\u9879\u76EE\uFF0C\u65E0\u6CD5\u540C\u6B65\u9879\u76EE\u6587\u6863\u3002`
-      };
-    }
-    return { projectId, diagnostic: null };
-  } catch (err) {
-    const detail = err instanceof Error ? err.message : String(err);
-    return {
-      projectId: null,
-      diagnostic: detail.replace(/^\[apm\]\s*/, "")
-    };
-  }
-}
-async function syncProjectDocumentsPull(workdirPath, apmDir, options) {
-  const empty = {
-    synced: false,
-    projectId: null,
-    downloaded: 0,
-    deleted: 0
-  };
-  const cfg = await tryReadApmConfig();
-  if (!cfg || !resolveApiKey(cfg)) {
-    console.log(
-      "[apm] \u672A\u68C0\u6D4B\u5230\u767B\u5F55\u4FE1\u606F\uFF0C\u8DF3\u8FC7\u9879\u76EE\u6587\u6863\u540C\u6B65\u3002\n[apm] \u8BF7\u5148\u6267\u884C apm login\u3002"
-    );
-    return empty;
-  }
-  const api = createApmApiClient(cfg);
-  const { projectId, diagnostic } = await resolveProjectIdForSync(
-    api,
-    workdirPath,
-    options
-  );
-  if (!projectId) {
-    console.log(`[apm] \u672A\u80FD\u540C\u6B65\u9879\u76EE\u6587\u6863\u3002
-${diagnostic ?? ""}`);
-    return empty;
-  }
-  const targetApmDir = apmDir ?? workspaceApmDir(workdirPath);
-  const docsDir = projectDocumentsDir(targetApmDir, projectId);
-  await ensureDirExists(docsDir);
-  const { manifest: remoteManifest } = await api.cli.getProjectDocumentManifest(
-    { projectId }
-  );
-  if (!remoteManifest) {
-    console.log(`[apm] \u9879\u76EE ${projectId} \u65E0\u9879\u76EE\u6587\u6863 manifest\uFF0C\u8DF3\u8FC7\u540C\u6B65\u3002`);
-    return { ...empty, projectId };
-  }
-  const localManifest = readLocalManifest(targetApmDir, projectId);
-  const { download, deleteLocal } = diffManifestPaths(
-    remoteManifest,
-    localManifest
-  );
-  let downloaded = 0;
-  if (download.length > 0) {
-    const { list } = await api.cli.listProjectDocuments({
-      projectId,
-      paths: download.join(",")
-    });
-    for (const doc of list) {
-      const absPath = toFsPath(
-        projectDocumentLocalPath(targetApmDir, projectId, doc.path)
-      );
-      await ensureDirExists(dirname2(absPath));
-      writeFileSync3(absPath, doc.content, "utf8");
-      downloaded += 1;
-    }
-  }
-  let deleted = 0;
-  for (const path of deleteLocal) {
-    const absPath = toFsPath(
-      projectDocumentLocalPath(targetApmDir, projectId, path)
-    );
-    if (existsSync5(absPath)) {
-      rmSync(absPath, { force: true });
-      deleted += 1;
-    }
-  }
-  writeFileSync3(
-    toFsPath(join6(docsDir, MANIFEST_FILE)),
-    `${JSON.stringify(remoteManifest, null, 2)}
-`,
-    "utf8"
-  );
-  console.log(
-    `[apm] \u5DF2\u540C\u6B65\u9879\u76EE\u6587\u6863: projectId=${projectId} \u4E0B\u8F7D ${downloaded}\uFF0C\u5220\u9664\u672C\u5730 ${deleted} \u2192 .apm/project/${projectId}/`
-  );
-  return {
-    synced: true,
-    projectId,
-    downloaded,
-    deleted
-  };
-}
-async function syncProjectDocumentsPush(cfg, workdirPath, apmRoot, options) {
-  const api = createApmApiClient(cfg);
-  const { projectId } = await resolveProjectIdForSync(
-    api,
-    workdirPath,
-    options
-  );
-  if (!projectId) {
-    return 0;
-  }
-  const targetApmDir = apmRoot ?? workspaceApmDir(workdirPath);
-  const localPaths = listLocalDocumentPaths(targetApmDir, projectId);
-  if (localPaths.length === 0) {
-    console.log("[apm] \u9879\u76EE\u6587\u6863\u65E0\u672C\u5730\u6587\u4EF6\uFF0C\u8DF3\u8FC7\u63A8\u9001");
-    return 0;
-  }
-  const remoteManifest = (await api.cli.getProjectDocumentManifest({ projectId })).manifest ?? null;
-  const remoteHashByPath = new Map(
-    (remoteManifest?.documents ?? []).map((doc) => [doc.path, doc.contentHash])
-  );
-  const remoteDescriptionByPath = new Map(
-    (remoteManifest?.documents ?? []).map((doc) => [doc.path, doc.description])
-  );
-  let synced = 0;
-  for (const path of localPaths) {
-    const absPath = toFsPath(
-      projectDocumentLocalPath(targetApmDir, projectId, path)
-    );
-    const content = readFileSync4(absPath, "utf8");
-    const contentHash = hashLocalFileContent(content);
-    if (remoteHashByPath.get(path) === contentHash) {
-      continue;
-    }
-    await api.cli.upsertProjectDocument({
-      projectId,
-      path,
-      content,
-      description: remoteDescriptionByPath.get(path) ?? void 0
-    });
-    synced += 1;
-    console.log(`[apm] \u5DF2\u540C\u6B65\u9879\u76EE\u6587\u6863: ${path}`);
-  }
-  if (synced === 0) {
-    console.log("[apm] \u9879\u76EE\u6587\u6863\u65E0\u53D8\u5316\uFF0C\u8DF3\u8FC7\u63A8\u9001");
-  }
-  return synced;
-}
-
-// src/commands/sync-project-documents.ts
-async function runSyncProjectDocuments(options) {
-  const workdir = resolveWorkdirPath();
-  const apmRoot = workspaceApmDir(workdir);
-  const doPush = Boolean(options.push);
-  const doPull = Boolean(options.pull) || !doPush;
-  if (doPull) {
-    await syncProjectDocumentsPull(workdir, apmRoot);
-  }
-  if (doPush) {
-    const cfg = await tryReadApmConfig();
-    if (!cfg) {
-      throw new Error("[apm] \u672A\u68C0\u6D4B\u5230\u767B\u5F55\u4FE1\u606F\uFF0C\u8BF7\u5148\u6267\u884C apm login");
-    }
-    await syncProjectDocumentsPush(cfg, workdir, apmRoot);
-  }
-}
-
 // src/commands/connect.ts
 import WebSocket from "ws";
-import { setTimeout as delay } from "node:timers/promises";
+import { setTimeout as delay2 } from "node:timers/promises";
 
 // src/ws/protocol.ts
-function isWebIdeStartProjectTarget(value) {
-  return value === "frontend" || value === "backend" || value === "mobile";
-}
 function nonEmptyString(v) {
   return typeof v === "string" && v.trim().length > 0;
 }
@@ -1202,18 +834,6 @@ function parseAgentWsMessage(raw) {
     return null;
   }
 }
-function serializeAgentWsMessage(msg) {
-  return JSON.stringify(msg);
-}
-function validateHeartbeat(o) {
-  if (o.type !== "heartbeat") {
-    return { ok: false, reason: "\u671F\u671B heartbeat" };
-  }
-  if (!nonEmptyString(o.userId)) {
-    return { ok: false, reason: "heartbeat \u7F3A\u5C11 userId" };
-  }
-  return { ok: true, data: { type: "heartbeat", userId: o.userId.trim() } };
-}
 function validateWebIdeMessagePush(o) {
   if (o.type !== "webide-message") {
     return { ok: false, reason: "\u671F\u671B webide-message" };
@@ -1292,89 +912,21 @@ function validateSteer(o) {
     }
   };
 }
-function validateWebIdeStopTerminals(o) {
-  if (o.type !== "webide-stop-terminals") {
-    return { ok: false, reason: "\u671F\u671B webide-stop-terminals" };
-  }
-  if (!nonEmptyString(o.taskId)) {
-    return { ok: false, reason: "webide-stop-terminals \u7F3A\u5C11 taskId" };
-  }
-  return {
-    ok: true,
-    data: {
-      type: "webide-stop-terminals",
-      taskId: o.taskId.trim()
-    }
-  };
-}
-function validateWebIdeStartProjectPush(o) {
-  if (o.type !== "webide-start-project") {
-    return { ok: false, reason: "\u671F\u671B webide-start-project" };
-  }
-  if (!nonEmptyString(o.taskId)) {
-    return { ok: false, reason: "webide-start-project \u7F3A\u5C11 taskId" };
-  }
-  if (!nonEmptyString(o.messageId)) {
-    return { ok: false, reason: "webide-start-project \u7F3A\u5C11 messageId" };
-  }
-  if (!isWebIdeStartProjectTarget(o.target)) {
-    return { ok: false, reason: "webide-start-project \u7F3A\u5C11\u6709\u6548 target" };
-  }
-  if (!nonEmptyString(o.content)) {
-    return { ok: false, reason: "webide-start-project \u7F3A\u5C11 content" };
-  }
-  if (!nonEmptyString(o.model)) {
-    return { ok: false, reason: "webide-start-project \u7F3A\u5C11 model" };
-  }
-  if (!nonEmptyString(o.apiKey)) {
-    return { ok: false, reason: "webide-start-project \u7F3A\u5C11 apiKey" };
-  }
-  if (!nonEmptyString(o.workdir)) {
-    return { ok: false, reason: "webide-start-project \u7F3A\u5C11 workdir" };
-  }
-  if (!nonEmptyString(o.user)) {
-    return { ok: false, reason: "webide-start-project \u7F3A\u5C11 user" };
-  }
-  return {
-    ok: true,
-    data: {
-      type: "webide-start-project",
-      taskId: o.taskId.trim(),
-      messageId: o.messageId.trim(),
-      target: o.target,
-      restart: o.restart === true,
-      content: o.content,
-      model: o.model.trim(),
-      apiKey: o.apiKey.trim(),
-      workdir: o.workdir.trim(),
-      user: o.user.trim()
-    }
-  };
-}
-function validateAgentWsMessage(value, kind) {
+function validateAgentWsMessage(value, _kind = "outbound") {
   if (typeof value !== "object" || value === null) {
     return { ok: false, reason: "\u6D88\u606F\u4F53\u4E0D\u662F JSON \u5BF9\u8C61" };
   }
   const o = value;
   const type = o.type;
-  if (type !== "heartbeat" && type !== "webide-message" && type !== "cancel" && type !== "steer" && type !== "webide-start-project" && type !== "webide-stop-terminals") {
+  if (type !== "webide-message" && type !== "cancel" && type !== "steer") {
     return { ok: false, reason: `\u672A\u77E5 type: ${String(type)}` };
   }
-  if (kind === "heartbeat" || type === "heartbeat") {
-    return validateHeartbeat(o);
-  }
   if (type === "cancel") {
     return validateCancel(o);
   }
   if (type === "steer") {
     return validateSteer(o);
   }
-  if (type === "webide-start-project") {
-    return validateWebIdeStartProjectPush(o);
-  }
-  if (type === "webide-stop-terminals") {
-    return validateWebIdeStopTerminals(o);
-  }
   return validateWebIdeMessagePush(o);
 }
 
@@ -1409,7 +961,7 @@ function handleSteerAction(payload, ctx) {
 }
 
 // src/commands/connect/core/worker/worker.ts
-import { dirname as dirname3, join as join7 } from "path";
+import { dirname as dirname2, join as join6 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { Worker } from "node:worker_threads";
 
@@ -1435,8 +987,8 @@ function resolveWebIdeWorkerHeapMb(env = process.env, totalMemoryBytes = totalme
 }
 
 // src/commands/connect/core/worker/worker.ts
-var workerFile = join7(
-  dirname3(fileURLToPath2(import.meta.url)),
+var workerFile = join6(
+  dirname2(fileURLToPath2(import.meta.url)),
   "worker-script.js"
 );
 var ActionWorker = class {
@@ -1455,8 +1007,8 @@ var ActionWorker = class {
     }
     this.msg = msg;
     this.apmClient = createApmApiClient(cfg);
-    this.promise = new Promise((resolve3, reject) => {
-      this.resolve = resolve3;
+    this.promise = new Promise((resolve5, reject) => {
+      this.resolve = resolve5;
       this.reject = reject;
     });
     this.worker = new Worker(workerFile, {
@@ -1584,148 +1136,9 @@ function handleWebIdeMessageAction(payload, ctx) {
   trackActionTask(ctx, task);
 }
 
-// src/commands/connect/actions/start-project.ts
-function handleStartProjectAction(payload, ctx) {
-  const perMessageController = new AbortController();
-  ctx.activeRuns.set(payload.messageId, perMessageController);
-  if (ctx.pendingCancels.has(payload.messageId)) {
-    ctx.activeRuns.delete(payload.messageId);
-    ctx.pendingCancels.delete(payload.messageId);
-    const cancelTask = (async () => {
-      try {
-        const api = createApmApiClient(ctx.cfg);
-        await api.cli.webideUpdateMessageStatus({
-          id: payload.messageId,
-          status: "CANCELLED"
-        });
-      } catch (err) {
-        console.error(
-          `[apm] webide-start-project \u9884\u53D6\u6D88\u5199\u7EC8\u6001\u5931\u8D25 messageId=${payload.messageId}:`,
-          err instanceof Error ? err.message : err
-        );
-      }
-    })();
-    trackActionTask(ctx, cancelTask);
-    return;
-  }
-  const task = (async () => {
-    const handle = new ActionWorker(payload);
-    registerRunSteer(ctx, payload.messageId, handle);
-    const onAbort = () => handle.cancel(payload.messageId);
-    perMessageController.signal.addEventListener("abort", onAbort, {
-      once: true
-    });
-    try {
-      await handle.done;
-    } finally {
-      perMessageController.signal.removeEventListener("abort", onAbort);
-      unregisterRunSteer(ctx, payload.messageId);
-      ctx.activeRuns.delete(payload.messageId);
-    }
-  })();
-  trackActionTask(ctx, task);
-}
-
-// src/commands/connect/mcps/pty-session-mcp.ts
-var DEFAULT_PTY_SESSION_PORT = "7788";
-function resolvePtySessionBaseUrl(env = process.env) {
-  const explicit = env.LOCAL_TERMINAL_URL?.trim();
-  if (explicit) return explicit.replace(/\/+$/, "");
-  const port = env.LOCAL_TERMINAL_PORT?.trim() || DEFAULT_PTY_SESSION_PORT;
-  return `http://127.0.0.1:${port}`;
-}
-function asSessionList(data) {
-  if (Array.isArray(data)) return data;
-  if (data && typeof data === "object") {
-    const sessions = data.sessions;
-    if (Array.isArray(sessions)) return sessions;
-  }
-  return [];
-}
-async function requestPtyJson(url, token, init) {
-  const res = await fetch(url, {
-    ...init,
-    headers: {
-      Authorization: `Bearer ${token}`,
-      ...init?.headers ?? {}
-    }
-  });
-  if (!res.ok) {
-    throw new Error(`pty-session HTTP ${res.status}`);
-  }
-  try {
-    return await res.json();
-  } catch {
-    return null;
-  }
-}
-async function killAllPtySessions(cfg) {
-  const token = resolveApiKey(cfg);
-  if (!token) return 0;
-  const baseUrl = resolvePtySessionBaseUrl();
-  let body;
-  try {
-    body = await requestPtyJson(`${baseUrl}/sessions`, token);
-  } catch (err) {
-    console.warn(
-      "[apm] \u5217\u51FA PTY \u4F1A\u8BDD\u5931\u8D25:",
-      err instanceof Error ? err.message : err
-    );
-    return 0;
-  }
-  const payload = body;
-  if (payload && typeof payload === "object" && payload.ok === false) {
-    return 0;
-  }
-  const data = payload && typeof payload === "object" && "data" in payload ? payload.data : body;
-  const sessions = asSessionList(data);
-  let killed = 0;
-  for (const session of sessions) {
-    const id = session.id?.trim();
-    if (!id) continue;
-    if (session.running === false) continue;
-    try {
-      await requestPtyJson(
-        `${baseUrl}/sessions/${encodeURIComponent(id)}`,
-        token,
-        {
-          method: "DELETE"
-        }
-      );
-      killed += 1;
-    } catch (err) {
-      console.warn(
-        `[apm] \u7ED3\u675F PTY \u4F1A\u8BDD\u5931\u8D25 id=${id}:`,
-        err instanceof Error ? err.message : err
-      );
-    }
-  }
-  return killed;
-}
-
-// src/commands/connect/actions/stop-terminals.ts
-function handleStopTerminalsAction(payload, ctx) {
-  const task = (async () => {
-    try {
-      const killed = await killAllPtySessions(ctx.cfg);
-      console.log(
-        `[apm] webide-stop-terminals taskId=${payload.taskId} killed=${killed}`
-      );
-    } catch (err) {
-      console.warn(
-        `[apm] webide-stop-terminals \u5931\u8D25 taskId=${payload.taskId}:`,
-        err instanceof Error ? err.message : err
-      );
-    }
-  })();
-  trackActionTask(ctx, task);
-}
-
 // src/commands/connect/actions/index.ts
 function dispatchConnectAction(payload, ctx) {
   switch (payload.type) {
-    case "heartbeat":
-      return;
     case "cancel":
       handleCancelAction(payload, ctx);
       return;
@@ -1735,25 +1148,22 @@ function dispatchConnectAction(payload, ctx) {
     case "webide-message":
       handleWebIdeMessageAction(payload, ctx);
       return;
-    case "webide-start-project":
-      handleStartProjectAction(payload, ctx);
-      return;
-    case "webide-stop-terminals":
-      handleStopTerminalsAction(payload, ctx);
-      return;
   }
 }
 
 // src/commands/connect-lock.ts
 import {
-  existsSync as existsSync6,
+  existsSync as existsSync5,
   mkdirSync as mkdirSync4,
-  readFileSync as readFileSync5,
+  readFileSync as readFileSync4,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync3
 } from "fs";
-import { join as join8 } from "path";
-var CONNECT_LOCK_PATH = join8(APM_CONFIG_DIR, "connect.lock");
+import { setTimeout as delay } from "node:timers/promises";
+import { join as join7 } from "path";
+var CONNECT_LOCK_PATH = join7(APM_CONFIG_DIR, "connect.lock");
+var ACQUIRE_RETRY_MS = 5e3;
+var ACQUIRE_RETRY_INTERVAL_MS = 200;
 function isProcessAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   try {
@@ -1764,9 +1174,9 @@ function isProcessAlive(pid) {
   }
 }
 function readConnectLock() {
-  if (!existsSync6(CONNECT_LOCK_PATH)) return null;
+  if (!existsSync5(CONNECT_LOCK_PATH)) return null;
   try {
-    const raw = readFileSync5(CONNECT_LOCK_PATH, "utf8");
+    const raw = readFileSync4(CONNECT_LOCK_PATH, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.pid !== "number" || typeof parsed.startedAt !== "string") {
       return null;
@@ -1788,27 +1198,44 @@ function pruneStaleConnectLock() {
   } catch {
   }
 }
-function acquireConnectLock() {
-  pruneStaleConnectLock();
-  const existing = readConnectLock();
-  if (existing && isProcessAlive(existing.pid)) {
-    if (existing.pid === process.pid) {
-      return;
-    }
-    console.error(`[apm] \u5DF2\u6709 apm connect \u5728\u8FD0\u884C (pid=${existing.pid})`);
-    process.exit(1);
-  }
+function writeConnectLock() {
   mkdirSync4(APM_CONFIG_DIR, { recursive: true });
   const lock = {
     pid: process.pid,
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  writeFileSync4(
+  writeFileSync3(
     CONNECT_LOCK_PATH,
     JSON.stringify(lock, null, 2) + "\n",
     "utf8"
   );
 }
+async function acquireConnectLock() {
+  const deadline = Date.now() + ACQUIRE_RETRY_MS;
+  let loggedWait = false;
+  for (; ; ) {
+    pruneStaleConnectLock();
+    const existing = readConnectLock();
+    if (!existing || !isProcessAlive(existing.pid)) {
+      writeConnectLock();
+      return;
+    }
+    if (existing.pid === process.pid) {
+      return;
+    }
+    if (Date.now() >= deadline) {
+      console.error(`[apm] \u5DF2\u6709 apm connect \u5728\u8FD0\u884C (pid=${existing.pid})`);
+      process.exit(1);
+    }
+    if (!loggedWait) {
+      console.log(
+        `[apm] \u7B49\u5F85\u65E7 connect \u91CA\u653E\u9501 (pid=${existing.pid})\u2026`
+      );
+      loggedWait = true;
+    }
+    await delay(ACQUIRE_RETRY_INTERVAL_MS);
+  }
+}
 function releaseConnectLock() {
   const lock = readConnectLock();
   if (lock?.pid !== process.pid) return;
@@ -1819,36 +1246,20 @@ function releaseConnectLock() {
 }
 
 // src/commands/connect.ts
-var HEARTBEAT_MS = 3e4;
 var RECONNECT_MIN_MS = 1e3;
 var RECONNECT_MAX_MS = 6e4;
 var SHUTDOWN_DRAIN_MS = 3e3;
 function interruptibleSleep(ms, signal) {
   if (signal.aborted) return Promise.resolve();
-  return new Promise((resolve3) => {
-    const timer = setTimeout(resolve3, ms);
+  return new Promise((resolve5) => {
+    const timer = setTimeout(resolve5, ms);
     const onAbort = () => {
       clearTimeout(timer);
-      resolve3();
+      resolve5();
     };
     signal.addEventListener("abort", onAbort, { once: true });
   });
 }
-function startHeartbeat(ws, clientMachineId) {
-  const send = () => {
-    if (ws.readyState === WebSocket.OPEN) {
-      ws.send(
-        serializeAgentWsMessage({
-          type: "heartbeat",
-          userId: clientMachineId
-        })
-      );
-    }
-  };
-  send();
-  const timer = setInterval(send, HEARTBEAT_MS);
-  return () => clearInterval(timer);
-}
 function attachWsHandlers(ws, ctx, onOpen) {
   const { isShuttingDown } = ctx;
   ws.on("open", () => {
@@ -1863,9 +1274,6 @@ function attachWsHandlers(ws, ctx, onOpen) {
       console.error("[apm] \u6536\u5230\u65E0\u6548 JSON");
       return;
     }
-    if (typeof parsed === "object" && parsed !== null && parsed.type === "heartbeat") {
-      return;
-    }
     const validated = validateAgentWsMessage(parsed, "outbound");
     if (!validated.ok) {
       console.error(`[apm] \u6536\u5230\u65E0\u6548 WS \u5305: ${validated.reason}`);
@@ -1875,15 +1283,13 @@ function attachWsHandlers(ws, ctx, onOpen) {
   });
 }
 function connectOnce(url, ctx, connectionAbort, onConnected) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve5, reject) => {
     const ws = new WebSocket(url);
-    let stopHeartbeat;
     let settled = false;
     const finish = (fn) => {
       if (settled) return;
       settled = true;
       connectionAbort.removeEventListener("abort", onConnectionAbort);
-      stopHeartbeat?.();
       fn();
     };
     const onConnectionAbort = () => {
@@ -1892,10 +1298,7 @@ function connectOnce(url, ctx, connectionAbort, onConnected) {
       }
     };
     connectionAbort.addEventListener("abort", onConnectionAbort);
-    attachWsHandlers(ws, ctx, () => {
-      stopHeartbeat = startHeartbeat(ws, ctx.clientMachineId);
-      onConnected();
-    });
+    attachWsHandlers(ws, ctx, onConnected);
     ws.on("close", (code, reason) => {
       console.log(
         `[apm] \u8FDE\u63A5\u5DF2\u65AD\u5F00 code=${code}${reason ? ` reason=${reason.toString()}` : ""}`
@@ -1904,7 +1307,7 @@ function connectOnce(url, ctx, connectionAbort, onConnected) {
         finish(() => reject(new Error("shutdown")));
         return;
       }
-      finish(resolve3);
+      finish(resolve5);
     });
     ws.on("error", (err) => {
       console.error("[apm] WebSocket \u9519\u8BEF:", err.message);
@@ -1937,7 +1340,7 @@ async function runConnect(options) {
     console.error("[apm] config \u7F3A\u5C11 clientMachineId\uFF0C\u8BF7\u91CD\u65B0 apm login");
     process.exit(1);
   }
-  acquireConnectLock();
+  await acquireConnectLock();
   process.on("exit", releaseConnectLock);
   let shuttingDown = false;
   let shutdownPromise = null;
@@ -1964,11 +1367,11 @@ async function runConnect(options) {
     lifecycleAbort.abort();
     currentConnectionAbort?.abort();
     shutdownAbort.abort();
+    releaseConnectLock();
     try {
-      await Promise.race([Promise.all(activeTasks), delay(drainMs)]);
+      await Promise.race([Promise.all(activeTasks), delay2(drainMs)]);
     } catch {
     }
-    releaseConnectLock();
     process.exit(code);
   };
   const shutdown = (code = 0) => {
@@ -2027,6 +1430,461 @@ async function runConnect(options) {
   }
 }
 
+// src/utils/git.ts
+import { execFile } from "child_process";
+import { dirname as dirname3, join as join8 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var GIT_NETWORK_TIMEOUT_MS = 9e4;
+var GIT_PUSH_TIMEOUT_MS = 12e4;
+var GIT_LOCAL_TIMEOUT_MS = 6e4;
+var GIT_NETWORK_CMDS = /* @__PURE__ */ new Set([
+  "fetch",
+  "push",
+  "ls-remote",
+  "clone",
+  "pull"
+]);
+function mergeGitSshCommand(existing) {
+  const base = existing?.trim() || "ssh";
+  const extras = [];
+  if (!/\bStrictHostKeyChecking=/.test(base)) {
+    extras.push("-o", "StrictHostKeyChecking=accept-new");
+  }
+  if (!/\bBatchMode=/.test(base)) {
+    extras.push("-o", "BatchMode=yes");
+  }
+  if (!/\bConnectTimeout=/.test(base)) {
+    extras.push("-o", "ConnectTimeout=20");
+  }
+  if (!/\bServerAliveInterval=/.test(base)) {
+    extras.push("-o", "ServerAliveInterval=10");
+  }
+  if (!/\bServerAliveCountMax=/.test(base)) {
+    extras.push("-o", "ServerAliveCountMax=3");
+  }
+  return extras.length ? `${base} ${extras.join(" ")}` : base;
+}
+function gitExecEnv() {
+  return {
+    ...process.env,
+    GIT_SSH_COMMAND: mergeGitSshCommand(process.env.GIT_SSH_COMMAND),
+    // 避免 credential helper / askpass 在无 TTY 时挂起
+    GIT_TERMINAL_PROMPT: "0"
+  };
+}
+function defaultGitTimeoutMs(args) {
+  const cmd = args[0] ?? "";
+  if (cmd === "push") return GIT_PUSH_TIMEOUT_MS;
+  if (GIT_NETWORK_CMDS.has(cmd)) return GIT_NETWORK_TIMEOUT_MS;
+  return GIT_LOCAL_TIMEOUT_MS;
+}
+async function execGit(cwd, args, quietOrOptions = false) {
+  const options = typeof quietOrOptions === "boolean" ? { quiet: quietOrOptions } : quietOrOptions;
+  const quiet = options.quiet ?? false;
+  const timeoutMs = options.timeoutMs === void 0 ? defaultGitTimeoutMs(args) : options.timeoutMs;
+  try {
+    const { stdout, stderr } = await execFileAsync("git", args, {
+      cwd,
+      env: gitExecEnv(),
+      encoding: "utf8",
+      maxBuffer: 10 * 1024 * 1024,
+      ...timeoutMs > 0 ? { timeout: timeoutMs, killSignal: "SIGTERM" } : {}
+    });
+    if (!quiet && stderr.trim()) {
+      process.stderr.write(stderr);
+    }
+    return stdout;
+  } catch (err) {
+    const e = err;
+    if (e.killed || e.signal === "SIGTERM" || e.code === "ETIMEDOUT") {
+      throw new Error(
+        `[apm] git ${args.join(" ")} \u8D85\u65F6\uFF08>${timeoutMs}ms\uFF09\uFF0C\u8BF7\u68C0\u67E5\u5230\u8FDC\u7A0B\u7684\u7F51\u7EDC/SSH\uFF1B\u53EF\u7A0D\u540E\u91CD\u8BD5`
+      );
+    }
+    const detail = (e.stderr ?? e.message ?? String(err)).trim();
+    throw new Error(
+      `[apm] git ${args.join(" ")} \u5931\u8D25${detail ? `: ${detail}` : ""}`
+    );
+  }
+}
+async function ensureGitRepo(cwd) {
+  await execGit(cwd, ["rev-parse", "--git-dir"], true);
+}
+async function resolveGitRepoRoot(cwd) {
+  return (await execGit(cwd, ["rev-parse", "--show-toplevel"], true)).trim();
+}
+function resolveGitScript(name) {
+  return join8(dirname3(fileURLToPath3(import.meta.url)), "scripts", name);
+}
+async function runGitScript(name, options) {
+  const skipCode = options.skipCode ?? 2;
+  const timeoutMs = options.timeoutMs ?? GIT_NETWORK_TIMEOUT_MS;
+  const script = resolveGitScript(name);
+  const args = [script, ...options.args ?? []];
+  try {
+    const { stdout, stderr } = await execFileAsync("bash", args, {
+      cwd: options.cwd,
+      env: gitExecEnv(),
+      encoding: "utf8",
+      maxBuffer: 10 * 1024 * 1024,
+      timeout: timeoutMs,
+      killSignal: "SIGTERM"
+    });
+    if (stdout.trim()) process.stdout.write(stdout);
+    if (stderr.trim()) process.stderr.write(stderr);
+    return true;
+  } catch (err) {
+    const e = err;
+    if (e.stdout?.trim()) process.stdout.write(e.stdout);
+    if (e.stderr?.trim()) process.stderr.write(e.stderr);
+    if (e.code === skipCode) {
+      return false;
+    }
+    if (e.killed || e.signal === "SIGTERM" || e.code === "ETIMEDOUT") {
+      throw new Error(
+        `[apm] ${name} \u8D85\u65F6\uFF08>${timeoutMs}ms\uFF09\uFF0C\u8BF7\u68C0\u67E5\u5230\u8FDC\u7A0B\u7684\u7F51\u7EDC/SSH\uFF1B\u53EF\u7A0D\u540E\u91CD\u8BD5`
+      );
+    }
+    const detail = (e.stderr ?? e.message ?? String(err)).trim();
+    throw new Error(`[apm] ${name} \u5931\u8D25${detail ? `: ${detail}` : ""}`);
+  }
+}
+async function commitWorkingTreeIfDirty(cwd, message) {
+  await ensureGitRepo(cwd);
+  return runGitScript("commit_if_dirty.sh", {
+    cwd,
+    args: message?.trim() ? [message.trim()] : [],
+    timeoutMs: GIT_LOCAL_TIMEOUT_MS
+  });
+}
+async function ensureFeatureBranch(cwd, branch, baselineBranch) {
+  await runGitScript("ensure_feature_branch.sh", {
+    cwd,
+    args: [branch, baselineBranch],
+    timeoutMs: GIT_PUSH_TIMEOUT_MS
+  });
+}
+async function pushCurrentBranch(cwd) {
+  return runGitScript("push_code.sh", {
+    cwd,
+    timeoutMs: GIT_PUSH_TIMEOUT_MS
+  });
+}
+
+// src/utils/home-repository.ts
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { join as join9, resolve as resolve3 } from "path";
+var DEFAULT_REPOS_MANIFEST = "/home/repository.json";
+function isSimpleChildDirName(name) {
+  if (!name || name === "." || name === "..") return false;
+  if (name.includes("/") || name.includes("\\")) return false;
+  return true;
+}
+function resolveReposManifestPath(explicit) {
+  const fromOpt = explicit?.trim() || "";
+  if (fromOpt) return fromOpt;
+  const fromEnv = process.env.APM_REPOS_MANIFEST?.trim() || "";
+  if (fromEnv) return fromEnv;
+  return DEFAULT_REPOS_MANIFEST;
+}
+function loadHomeRepositoryEntries(manifestPath) {
+  const label = manifestPath.trim() || DEFAULT_REPOS_MANIFEST;
+  const path = toFsPath(label);
+  if (!existsSync6(path)) {
+    throw new Error(`[apm] \u672A\u627E\u5230\u591A\u4ED3\u6E05\u5355 ${label}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync5(path, "utf8"));
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    throw new Error(`[apm] \u89E3\u6790 ${label} \u5931\u8D25: ${detail}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(
+      `[apm] ${label} \u987B\u4E3A\u5BF9\u8C61\uFF1Akey=\u4E0B\u7EA7\u76EE\u5F55\uFF0Cvalue=git \u5730\u5740`
+    );
+  }
+  const entries = [];
+  for (const [rawKey, rawVal] of Object.entries(
+    parsed
+  )) {
+    const pathKey = rawKey.trim();
+    if (!isSimpleChildDirName(pathKey)) {
+      throw new Error(
+        `[apm] ${label} \u975E\u6CD5\u76EE\u5F55 key: ${JSON.stringify(rawKey)}\uFF08\u987B\u4E3A\u5F53\u524D\u4E0B\u7EA7\u76EE\u5F55\u540D\uFF09`
+      );
+    }
+    if (typeof rawVal !== "string" || !rawVal.trim()) {
+      throw new Error(
+        `[apm] ${label}[${pathKey}] \u987B\u4E3A\u975E\u7A7A git \u5730\u5740\u5B57\u7B26\u4E32`
+      );
+    }
+    entries.push({ path: pathKey, remoteUrl: rawVal.trim() });
+  }
+  entries.sort((a, b) => a.path.localeCompare(b.path));
+  if (entries.length === 0) {
+    throw new Error(`[apm] ${label} \u4E3A\u7A7A\uFF0C\u65E0\u4ED3\u5E93\u53EF\u786E\u8BA4`);
+  }
+  return entries;
+}
+function resolveHomeRepositoryAbsolutePaths(workdirInput, entries) {
+  const workdir = resolveWorkdirPath(workdirInput);
+  return entries.map((entry) => resolve3(join9(workdir, entry.path)));
+}
+
+// src/utils/workspace-repos.ts
+import { basename, dirname as dirname4, join as join10, relative, resolve as resolve4 } from "path";
+
+// src/utils/git-remote.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+
+// src/utils/workspace-repos.ts
+function toRelativeRepoPath(workdir, repoAbs) {
+  return relative(workdir, repoAbs).replace(/\\/g, "/");
+}
+function formatRepoLabel(workdir, repoAbs) {
+  const rel = toRelativeRepoPath(resolveWorkdirPath(workdir), repoAbs);
+  return rel || basename(repoAbs) || repoAbs;
+}
+
+// src/commands/branch.ts
+var TASK_BRANCH_PREFIX = "feat/task-";
+async function syncTaskRepos(workdir, options = {}) {
+  const opts = typeof options === "string" ? { message: options } : options;
+  const workdirPath = resolveWorkdirPath(workdir);
+  const repoRoots = resolveTaskBranchRepoRoots(
+    workdirPath,
+    opts.reposManifest
+  );
+  let committed = 0;
+  let commitSkipped = 0;
+  let pushed = 0;
+  let pushSkipped = 0;
+  const failed = [];
+  const message = opts.message;
+  for (const gitRoot of repoRoots) {
+    const label = formatRepoLabel(workdirPath, gitRoot);
+    try {
+      const didCommit = await commitWorkingTreeIfDirty(gitRoot, message);
+      if (didCommit) {
+        committed += 1;
+        console.log(`[apm] \u5DF2\u63D0\u4EA4 @ ${label}`);
+      } else {
+        commitSkipped += 1;
+      }
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      console.error(`[apm] \u4ED3\u5E93 ${label} \u63D0\u4EA4\u5931\u8D25\uFF08\u7EE7\u7EED\u5176\u5B83\u4ED3\uFF09: ${detail}`);
+      failed.push(label);
+      continue;
+    }
+    try {
+      const didPush = await pushCurrentBranch(gitRoot);
+      if (didPush) {
+        pushed += 1;
+        console.log(`[apm] \u5DF2 push @ ${label}`);
+      } else {
+        pushSkipped += 1;
+      }
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      console.error(`[apm] \u4ED3\u5E93 ${label} push \u5931\u8D25\uFF08\u7EE7\u7EED\u5176\u5B83\u4ED3\uFF09: ${detail}`);
+      failed.push(label);
+    }
+  }
+  return {
+    committed,
+    commitSkipped,
+    pushed,
+    pushSkipped,
+    failed,
+    repos: repoRoots
+  };
+}
+function branchNameForTask(taskId) {
+  const id = taskId.trim();
+  if (!id) {
+    throw new Error("[apm] \u4EFB\u52A1 ID \u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  if (/[\s/\\]/.test(id)) {
+    throw new Error(
+      "[apm] \u4EFB\u52A1 ID \u4E0D\u80FD\u5305\u542B\u7A7A\u767D\u6216\u8DEF\u5F84\u5206\u9694\u7B26\uFF0C\u8BF7\u4F7F\u7528\u5B57\u6BCD\u3001\u6570\u5B57\u3001._- \u7B49"
+    );
+  }
+  return `${TASK_BRANCH_PREFIX}${id}`;
+}
+async function ensureTaskFeatureBranch(branch, projectId, options) {
+  const cwd = options.cwd ?? process.cwd();
+  const gitRoot = await resolveGitRepoRoot(cwd);
+  await ensureFeatureBranch(gitRoot, branch, projectId);
+  return branch;
+}
+function resolveTaskBranchRepoRoots(workdirPath, reposManifest) {
+  const manifestPath = resolveReposManifestPath(reposManifest);
+  const entries = loadHomeRepositoryEntries(manifestPath);
+  const roots = resolveHomeRepositoryAbsolutePaths(workdirPath, entries);
+  console.log(
+    `[apm] \u8BFB\u53D6 ${manifestPath} repos=${entries.map((e) => `${e.path}\u2192${e.remoteUrl}`).join(", ")}`
+  );
+  return roots;
+}
+async function runTaskBranch(taskId, projectId, options = {}) {
+  const trimmedTaskId = taskId.trim();
+  if (!trimmedTaskId) {
+    throw new Error("[apm] taskId \u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  const trimmedProjectId = projectId.trim();
+  if (!trimmedProjectId) {
+    throw new Error("[apm] projectId\uFF08\u9879\u76EE ID\uFF09\u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  if (/[\s\\]/.test(trimmedProjectId) || trimmedProjectId.includes("..")) {
+    throw new Error("[apm] \u9879\u76EE ID \u975E\u6CD5");
+  }
+  const cwd = options.cwd ?? process.cwd();
+  const workdirPath = resolveWorkdirPath(cwd);
+  const repoRoots = resolveTaskBranchRepoRoots(
+    workdirPath,
+    options.reposManifest
+  );
+  if (repoRoots.length === 0) {
+    throw new Error("[apm] \u5DE5\u4F5C\u533A\u4ED3\u5E93\u6E05\u5355\u4E3A\u7A7A\uFF0C\u65E0\u6CD5\u786E\u8BA4\u7279\u6027\u5206\u652F");
+  }
+  const branch = branchNameForTask(trimmedTaskId);
+  const repoLabels = repoRoots.map(
+    (gitRoot) => formatRepoLabel(workdirPath, gitRoot)
+  );
+  console.log(
+    `[apm] \u591A\u4ED3\u786E\u8BA4\u7279\u6027\u5206\u652F ${branch} projectId=${trimmedProjectId} repos=${repoLabels.join(",")}`
+  );
+  for (const gitRoot of repoRoots) {
+    const label = formatRepoLabel(workdirPath, gitRoot);
+    console.log(
+      `[apm] \u4EFB\u52A1\u5206\u652F ${branch} @ ${label} (projectId=${trimmedProjectId})`
+    );
+    try {
+      await ensureTaskFeatureBranch(branch, trimmedProjectId, {
+        ...options,
+        cwd: gitRoot
+      });
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      throw new Error(
+        `[apm] \u4ED3\u5E93 ${label} \u786E\u8BA4\u7279\u6027\u5206\u652F\u5931\u8D25\uFF08\u591A\u4ED3\u4EFB\u4E00\u5931\u8D25\u5219\u6574\u6B21\u5931\u8D25\uFF09: ${detail}`
+      );
+    }
+  }
+  return {
+    branch,
+    projectId: trimmedProjectId,
+    kind: "multi",
+    repos: repoRoots
+  };
+}
+
+// src/commands/ensure-task-branch.ts
+async function runEnsureTaskBranchCli(options = {}) {
+  const workdir = resolveWorkdirPath(options.cwd ?? process.cwd());
+  const taskId = options.taskId?.trim() || "";
+  const projectId = options.projectId?.trim() || "";
+  if (!taskId) {
+    throw new Error("[apm] \u7F3A\u5C11 taskId\uFF1A\u8BF7\u4F20\u5165\u53C2\u6570");
+  }
+  if (!projectId) {
+    throw new Error("[apm] \u7F3A\u5C11 projectId\uFF1A\u8BF7\u4F20\u5165\u53C2\u6570");
+  }
+  const result = await runTaskBranch(taskId, projectId, {
+    cwd: workdir,
+    reposManifest: options.reposManifest
+  });
+  console.log(
+    `[apm] \u7279\u6027\u5206\u652F\u5DF2\u5C31\u7EEA\uFF08\u5168\u90E8 ${result.repos.length} \u4E2A\u4ED3\uFF09 branch=${result.branch} projectId=${result.projectId}`
+  );
+}
+
+// src/utils/user-prompt-cache.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { join as join11 } from "path";
+import { tmpdir } from "os";
+var CACHE_ROOT = join11(tmpdir(), "apm-hooks");
+var PROMPT_FILE = "user-prompt.txt";
+var COMMIT_SUBJECT_MAX_LEN = 100;
+function workdirKey(workdir) {
+  return createHash("sha256").update(resolveWorkdirPath(workdir)).digest("hex").slice(0, 16);
+}
+function userPromptCachePath(workdirInput) {
+  const workdir = resolveWorkdirPath(workdirInput);
+  return join11(CACHE_ROOT, workdirKey(workdir), PROMPT_FILE);
+}
+function formatUserPromptAsCommitMessage(prompt) {
+  const oneLine = prompt.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n").map((l) => l.trim()).find((l) => l.length > 0);
+  if (!oneLine) return "";
+  const cleaned = oneLine.replace(/\s+/g, " ").trim();
+  if (cleaned.length <= COMMIT_SUBJECT_MAX_LEN) return cleaned;
+  return `${cleaned.slice(0, COMMIT_SUBJECT_MAX_LEN - 1)}\u2026`;
+}
+function loadUserPromptCommitMessage(workdirInput) {
+  const path = toFsPath(userPromptCachePath(workdirInput));
+  if (!existsSync7(path)) return null;
+  try {
+    const raw = readFileSync6(path, "utf8");
+    const msg = formatUserPromptAsCommitMessage(raw);
+    return msg || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/commit-task-repos.ts
+function resolveCommitTaskMessage(workdir, explicit) {
+  const fromOpt = explicit?.trim() ?? "";
+  if (fromOpt) return fromOpt;
+  const fromPrompt = loadUserPromptCommitMessage(workdir);
+  if (fromPrompt) return fromPrompt;
+  const taskId = process.env.APM_TASK_ID?.trim() || "";
+  const projectId = process.env.APM_PROJECT_ID?.trim() || "";
+  if (taskId) {
+    let branch = "";
+    try {
+      branch = branchNameForTask(taskId);
+    } catch {
+      branch = `feat/task-${taskId}`;
+    }
+    if (projectId) {
+      return `chore(apm): sync ${branch} (project ${projectId})`;
+    }
+    return `chore(apm): sync ${branch}`;
+  }
+  if (projectId) {
+    return `chore(apm): sync workspace (project ${projectId})`;
+  }
+  return void 0;
+}
+async function runCommitTaskReposCli(options = {}) {
+  const workdir = resolveWorkdirPath(options.cwd ?? process.cwd());
+  const message = resolveCommitTaskMessage(workdir, options.message);
+  if (message) {
+    console.log(`[apm] commit message: ${message}`);
+  }
+  const result = await syncTaskRepos(workdir, {
+    message,
+    reposManifest: options.reposManifest
+  });
+  console.log(
+    `[apm] \u591A\u4ED3\u6536\u5C3E\u5B8C\u6210 committed=${result.committed} commitSkipped=${result.commitSkipped} pushed=${result.pushed} pushSkipped=${result.pushSkipped} failed=${result.failed.length} repos=${result.repos.length}`
+  );
+  if (result.failed.length > 0) {
+    throw new Error(
+      `[apm] \u4EE5\u4E0B\u4ED3\u5E93 commit/push \u5931\u8D25: ${result.failed.join(", ")}`
+    );
+  }
+}
+
 // src/index.ts
 function buildProgram() {
   const program = new Command();
@@ -2063,10 +1921,38 @@ function buildProgram() {
   program.command("update-skills").description("\u4ECE\u5E73\u53F0\u540C\u6B65 .apm/ \u4E0B\u7684 WebIDE \u6307\u5357\u4E0E\u89C4\u5219").action(async () => {
     await runUpdateSkills();
   });
-  program.command("sync-project-documents").description(
-    "\u540C\u6B65\u9879\u76EE\u6587\u6863\uFF1A\u9ED8\u8BA4 pull \u5230 .apm/project/<\u9879\u76EEID>/\uFF1B\u52A0 --push \u5C06\u672C\u5730\u53D8\u66F4\u63A8\u9001\u5230\u5E73\u53F0"
-  ).option("--push", "\u63A8\u9001\u672C\u5730 .apm/project/<\u9879\u76EEID>/ \u5230\u5E73\u53F0").option("--pull", "\u4ECE\u5E73\u53F0\u62C9\u53D6\u5230 .apm/project/<\u9879\u76EEID>/").action(async (opts) => {
-    await runSyncProjectDocuments(opts);
+  program.command("ensure-task-branch").description(
+    "\u6309\u591A\u4ED3\u6E05\u5355\u786E\u4FDD\u5404\u4ED3\u4F4D\u4E8E feat/task-<\u4EFB\u52A1ID>\uFF08\u4E0D\u5B58\u5728\u5219\u57FA\u4E8E\u9879\u76EE\u5206\u652F\u4ECE\u8FDC\u7A0B\u521B\u5EFA\uFF09\u3002ACP \u4E0D\u4F1A\u8DD1 Cursor hooks\uFF0C\u5F00\u59CB\u4EFB\u52A1\u65F6\u7531\u670D\u52A1\u7AEF\u6216\u624B\u52A8\u8C03\u7528\u672C\u547D\u4EE4"
+  ).argument("<taskId>", "\u4EFB\u52A1 ID\uFF08\u521B\u5EFA/\u5207\u6362\u5206\u652F\uFF09").argument(
+    "<projectId>",
+    "\u9879\u76EE ID\uFF08\u4EC5\u521B\u5EFA\u65F6\u7528\uFF1B\u89C4\u8303\u4E0E\u9879\u76EE\u5206\u652F\u540C\u540D\uFF09"
+  ).option("--cwd <dir>", "\u5DE5\u4F5C\u533A\u6839\u76EE\u5F55\uFF08\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55\uFF09").option(
+    "--repos <file>",
+    "\u591A\u4ED3\u6E05\u5355 JSON\uFF08key=\u4E0B\u7EA7\u76EE\u5F55\uFF0Cvalue=git \u5730\u5740\uFF09\uFF1B\u7701\u7565\u65F6\u8BFB APM_REPOS_MANIFEST\uFF0C\u518D\u9ED8\u8BA4 /home/repository.json"
+  ).action(
+    async (taskId, projectId, opts) => {
+      await runEnsureTaskBranchCli({
+        taskId,
+        projectId,
+        cwd: opts.cwd,
+        reposManifest: opts.repos
+      });
+    }
+  );
+  program.command("commit-task-repos").description(
+    "\u6267\u884C\u7ED3\u675F\u6536\u5C3E\uFF1A\u591A\u4ED3\u6E05\u5355\u5404\u4ED3\u6709\u53D8\u66F4\u624D commit\uFF0C\u518D push\uFF08\u65E0\u53D8\u66F4\u4E0D\u7A7A\u63D0\u4EA4\uFF09"
+  ).option("--cwd <dir>", "\u5DE5\u4F5C\u533A\u6839\u76EE\u5F55\uFF08\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55\uFF09").option(
+    "--repos <file>",
+    "\u591A\u4ED3\u6E05\u5355 JSON\uFF1B\u7701\u7565\u65F6\u8BFB APM_REPOS_MANIFEST\uFF0C\u518D\u9ED8\u8BA4 /home/repository.json"
+  ).option(
+    "-m, --message <msg>",
+    "commit message\uFF1B\u7701\u7565\u5219\u4F18\u5148\u7528\u6237\u95EE\u9898\u7F13\u5B58\uFF0C\u5426\u5219\u6309 APM_TASK_ID / APM_PROJECT_ID \u751F\u6210"
+  ).action(async (opts) => {
+    await runCommitTaskReposCli({
+      cwd: opts.cwd,
+      reposManifest: opts.repos,
+      message: opts.message
+    });
   });
   program.command("connect").description(
     "\u8FDE\u63A5\u524D\u68C0\u6D4B\u5E76\u66F4\u65B0\u5230\u5F53\u524D\u5927\u7248\u672C\u6700\u65B0 CLI\uFF0C\u518D\u8FDE\u63A5\u5E73\u53F0 WebSocket\uFF08/ws/agent\uFF09"