ai-project-manage-cli 7.1.12 → 7.1.15

package/dist/index.js

@@ -1,15 +1,23 @@
 #!/usr/bin/env node
-
-// src/index.ts
-import { Command } from "commander";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/config.ts
 import { mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
-var APM_CONFIG_DIR = join(homedir(), ".config", "apm");
-var APM_CONFIG_PATH = join(APM_CONFIG_DIR, "config.json");
-var DEFAULT_BASE_URL = "http://127.0.0.1:3000";
 function resolveClientMachineId(cfg) {
   return (cfg.clientMachineId ?? cfg.userId ?? "").trim();
 }
@@ -78,12 +86,1018 @@ function buildAgentWsUrl(httpBase, apiKey) {
   const q = new URLSearchParams({ apiKey });
   return `${origin}/ws/agent?${q.toString()}`;
 }
+var APM_CONFIG_DIR, APM_CONFIG_PATH, DEFAULT_BASE_URL;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    APM_CONFIG_DIR = join(homedir(), ".config", "apm");
+    APM_CONFIG_PATH = join(APM_CONFIG_DIR, "config.json");
+    DEFAULT_BASE_URL = "http://127.0.0.1:3000";
+  }
+});
+
+// src/api/request-config.ts
+import { defineEndpoint } from "listpage-http";
+var requestConfig;
+var init_request_config = __esm({
+  "src/api/request-config.ts"() {
+    "use strict";
+    requestConfig = {
+      cli: {
+        me: defineEndpoint(
+          {
+            method: "GET",
+            path: "/cli/me"
+          }
+        ),
+        sessionDetail: defineEndpoint({
+          method: "GET",
+          path: "/cli/sessions/detail"
+        }),
+        sessionMembers: defineEndpoint({
+          method: "GET",
+          path: "/cli/sessions/members"
+        }),
+        listSessionMessages: defineEndpoint({
+          method: "GET",
+          path: "/cli/messages"
+        }),
+        listDocuments: defineEndpoint({
+          method: "GET",
+          path: "/cli/documents"
+        }),
+        getDevGate: defineEndpoint({
+          method: "GET",
+          path: "/cli/dev-gate"
+        }),
+        listAttachments: defineEndpoint(
+          {
+            method: "GET",
+            path: "/cli/attachments"
+          }
+        ),
+        upsertDocument: defineEndpoint({
+          method: "PUT",
+          path: "/cli/documents/upsert"
+        }),
+        appendMessageContent: defineEndpoint({
+          method: "PUT",
+          path: "/cli/messages/content"
+        }),
+        setMessageError: defineEndpoint({
+          method: "PUT",
+          path: "/cli/messages/error"
+        }),
+        upsertCursorMessageLog: defineEndpoint({
+          method: "PUT",
+          path: "/cli/cursor-message-logs"
+        }),
+        updateMessageStatus: defineEndpoint({
+          method: "PUT",
+          path: "/cli/messages/status"
+        }),
+        webideAppendMessageContent: defineEndpoint({
+          method: "PUT",
+          path: "/cli/webide/messages/content"
+        }),
+        webideEnsureMessageContent: defineEndpoint({
+          method: "PUT",
+          path: "/cli/webide/messages/ensure-content"
+        }),
+        webideSetMessageError: defineEndpoint({
+          method: "PUT",
+          path: "/cli/webide/messages/error"
+        }),
+        webideUpdateMessageStatus: defineEndpoint({
+          method: "PUT",
+          path: "/cli/webide/messages/status"
+        }),
+        webideUpsertMessageLog: defineEndpoint({
+          method: "PUT",
+          path: "/cli/webide/message-logs"
+        }),
+        webideReplaceAssumptions: defineEndpoint({
+          method: "PUT",
+          path: "/cli/webide/assumptions"
+        }),
+        webideListAssumptions: defineEndpoint({
+          method: "GET",
+          path: "/cli/webide/assumptions"
+        }),
+        webideRecommendPlan: defineEndpoint({
+          method: "PUT",
+          path: "/cli/webide/plan-recommendation"
+        }),
+        webideUpsertPlan: defineEndpoint({
+          method: "PUT",
+          path: "/cli/webide/plan"
+        }),
+        webideReplaceTestCases: defineEndpoint({
+          method: "PUT",
+          path: "/cli/webide/test-cases"
+        }),
+        webideListTerminals: defineEndpoint({
+          method: "GET",
+          path: "/cli/webide/terminals"
+        }),
+        webideUpsertTerminal: defineEndpoint({
+          method: "POST",
+          path: "/cli/webide/terminals"
+        }),
+        webideUpdateTerminalStatus: defineEndpoint({
+          method: "PUT",
+          path: "/cli/webide/terminals/status"
+        }),
+        webideUpdateTerminalMeta: defineEndpoint({
+          method: "PUT",
+          path: "/cli/webide/terminals/meta"
+        }),
+        acquireSteelBrowser: defineEndpoint({
+          method: "POST",
+          path: "/cli/steel-browser/acquire"
+        }),
+        branchBaseline: defineEndpoint({
+          method: "GET",
+          path: "/cli/tasks/branch-baseline"
+        }),
+        projectBaseBranch: defineEndpoint({
+          method: "GET",
+          path: "/cli/tasks/project-base-branch"
+        }),
+        listSessionsForBranchCleanup: defineEndpoint({
+          method: "GET",
+          path: "/cli/sessions/branch-cleanup"
+        }),
+        workspaceBaseline: defineEndpoint({
+          method: "GET",
+          path: "/cli/workspaces/baseline"
+        }),
+        getDeploymentConfiguration: defineEndpoint({
+          method: "GET",
+          path: "/cli/deployment-configurations"
+        }),
+        matchRepository: defineEndpoint({
+          method: "GET",
+          path: "/cli/repositories/match"
+        }),
+        listSkills: defineEndpoint({
+          method: "GET",
+          path: "/cli/skills"
+        }),
+        listRules: defineEndpoint({
+          method: "GET",
+          path: "/cli/rules"
+        }),
+        createPullRequest: defineEndpoint({
+          method: "POST",
+          path: "/cli/pull-requests"
+        }),
+        createWebIdeDraftPullRequest: defineEndpoint({
+          method: "POST",
+          path: "/cli/webide/draft-pull-requests"
+        }),
+        webideMergePullRequests: defineEndpoint({
+          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"
+        }),
+        createTaskDeployment: defineEndpoint({
+          method: "POST",
+          path: "/cli/task-deployments"
+        }),
+        updateTaskDeploymentStatus: defineEndpoint({
+          method: "PUT",
+          path: "/cli/task-deployments/status"
+        }),
+        syncTaskDeploymentLog: defineEndpoint({
+          method: "PUT",
+          path: "/cli/task-deployments/log"
+        }),
+        completeTaskDeployment: defineEndpoint({
+          method: "PUT",
+          path: "/cli/task-deployments/complete"
+        }),
+        getDeployArtifactStorage: defineEndpoint(
+          {
+            method: "GET",
+            path: "/cli/deploy-artifact-storage"
+          }
+        ),
+        attachTaskDeploymentArtifact: defineEndpoint({
+          method: "PUT",
+          path: "/cli/task-deployments/artifact"
+        })
+      }
+    };
+  }
+});
+
+// src/api/client.ts
+import { createApiClient } from "listpage-http";
+function createApmApiClient(cfg) {
+  const baseURL = `${cfg.baseUrl.trim().replace(/\/+$/, "")}/api/v1`;
+  return createApiClient(requestConfig, {
+    baseURL,
+    getToken: () => resolveApiKey(cfg) || void 0,
+    successCodes: [0],
+    unauthorizedCodes: [401]
+  });
+}
+var init_client = __esm({
+  "src/api/client.ts"() {
+    "use strict";
+    init_request_config();
+    init_config();
+  }
+});
+
+// src/commands/deploy/internal/minio.ts
+import { statSync as statSync5 } from "node:fs";
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import * as Minio from "minio";
+async function isDirectoryPath(dir) {
+  try {
+    const st = statSync5(dir);
+    return st.isDirectory();
+  } catch {
+    return false;
+  }
+}
+function sanitizeRelativePath(rel) {
+  const norm = rel.replace(/\\/g, "/").replace(/^\/+/, "");
+  const segments = norm.split("/").filter(Boolean);
+  for (const s of segments) {
+    if (s === "." || s === "..") {
+      throw new Error(`\u975E\u6CD5\u76F8\u5BF9\u8DEF\u5F84\u7247\u6BB5\uFF1A${s}`);
+    }
+  }
+  return segments.join("/");
+}
+async function collectFiles(root) {
+  const out = [];
+  async function walk(dir, prefix) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const e of entries) {
+      const name = e.name;
+      if (name === "." || name === "..") {
+        continue;
+      }
+      const abs = path.join(dir, name);
+      const rel = prefix ? `${prefix}/${name}` : name;
+      if (e.isDirectory()) {
+        await walk(abs, rel);
+      } else if (e.isFile()) {
+        const st = statSync5(abs);
+        out.push({
+          absPath: abs,
+          relativePath: rel.replace(/\\/g, "/"),
+          size: st.size
+        });
+      }
+    }
+  }
+  await walk(root, "");
+  out.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+  return out;
+}
+async function readArtifactFile(absPath) {
+  return readFile(absPath);
+}
+function toMB(bytes) {
+  return Math.round(bytes / (1024 * 1024) * 1e3) / 1e3;
+}
+function detectMimeType(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return MIME[ext] ?? "";
+}
+var DEFAULT_MAX_FILE_SIZE_MB, MIME, MinioClient;
+var init_minio = __esm({
+  "src/commands/deploy/internal/minio.ts"() {
+    "use strict";
+    DEFAULT_MAX_FILE_SIZE_MB = 50;
+    MIME = {
+      ".html": "text/html; charset=utf-8",
+      ".css": "text/css; charset=utf-8",
+      ".js": "application/javascript; charset=utf-8",
+      ".json": "application/json; charset=utf-8",
+      ".svg": "image/svg+xml",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".webp": "image/webp",
+      ".woff": "font/woff",
+      ".woff2": "font/woff2",
+      ".ttf": "font/ttf",
+      ".ico": "image/x-icon",
+      ".txt": "text/plain; charset=utf-8",
+      ".map": "application/json"
+    };
+    MinioClient = class {
+      inner;
+      constructor(opts) {
+        const endPoint = opts.endPoint.replace(/^https?:\/\//i, "").split("/")[0] ?? opts.endPoint;
+        this.inner = new Minio.Client({
+          endPoint,
+          port: opts.port,
+          useSSL: opts.useSSL,
+          accessKey: opts.accessKey,
+          secretKey: opts.secretKey
+        });
+      }
+      async ensureBucket(bucket) {
+        const exists = await this.inner.bucketExists(bucket);
+        if (!exists) {
+          await this.inner.makeBucket(bucket);
+        }
+      }
+      async deleteObjectsByPrefix(bucket, prefix) {
+        const objectsStream = this.inner.listObjectsV2(bucket, prefix, true);
+        const keys = [];
+        await new Promise((resolve7, reject) => {
+          objectsStream.on("data", (obj) => {
+            if (obj.name) {
+              keys.push(obj.name);
+            }
+          });
+          objectsStream.on("error", reject);
+          objectsStream.on("end", resolve7);
+        });
+        const chunkSize = 500;
+        for (let i = 0; i < keys.length; i += chunkSize) {
+          const chunk = keys.slice(i, i + chunkSize);
+          await this.inner.removeObjects(
+            bucket,
+            chunk.map((name) => name)
+          );
+        }
+      }
+      async putObject(bucket, objectKey, body, meta) {
+        await this.inner.putObject(bucket, objectKey, body, body.length, meta);
+      }
+      /** 匿名可读当前桶全部对象（便于静态站点直链） */
+      async setBucketPublicRead(bucket) {
+        const policy = {
+          Version: "2012-10-17",
+          Statement: [
+            {
+              Effect: "Allow",
+              Principal: { AWS: ["*"] },
+              Action: ["s3:GetObject"],
+              Resource: [`arn:aws:s3:::${bucket}/*`]
+            }
+          ]
+        };
+        await this.inner.setBucketPolicy(bucket, JSON.stringify(policy));
+      }
+    };
+  }
+});
+
+// src/commands/deploy/internal/deploy-artifact-minio.ts
+import { readFile as readFile2 } from "node:fs/promises";
+function formatDeployArtifactTimestamp(date = /* @__PURE__ */ new Date()) {
+  const pad2 = (n) => String(n).padStart(2, "0");
+  return `${date.getFullYear()}${pad2(date.getMonth() + 1)}${pad2(date.getDate())}${pad2(date.getHours())}${pad2(date.getMinutes())}${pad2(date.getSeconds())}`;
+}
+function sanitizeDeployProjectName(name) {
+  const trimmed = name.trim().replace(/\\/g, "/");
+  const base = trimmed.split("/").filter(Boolean).pop() ?? trimmed;
+  try {
+    return sanitizeRelativePath(base.replace(/[/\\:*?"<>|]/g, "_"));
+  } catch {
+    return "project";
+  }
+}
+function buildDeployArtifactFileName(kind, projectName, timestamp = formatDeployArtifactTimestamp()) {
+  const safeName = sanitizeDeployProjectName(projectName);
+  const suffix = kind === "frontend" ? "dist.zip" : "jar.zip";
+  return `${timestamp}-${safeName}.${suffix}`;
+}
+function buildDeployArtifactObjectKey(projectName, fileName) {
+  const safeProject = sanitizeDeployProjectName(projectName);
+  return `deploy/${safeProject}/${fileName}`;
+}
+function resolveDeploymentRunIdFromEnv() {
+  const raw = process.env[APM_DEPLOYMENT_RUN_ID_ENV]?.trim();
+  return raw || null;
+}
+async function fetchDeployArtifactStorage(api) {
+  return api.cli.getDeployArtifactStorage(void 0);
+}
+async function uploadDeployArtifactZip(options) {
+  const deploymentRunId = options.deploymentRunId ?? resolveDeploymentRunIdFromEnv();
+  if (!deploymentRunId && !options.uploadWithoutRunId) {
+    return null;
+  }
+  const cfg = await tryReadApmConfig();
+  if (!cfg || !resolveApiKey(cfg)) {
+    console.warn("[apm] \u672A\u767B\u5F55\uFF0C\u8DF3\u8FC7 MinIO \u90E8\u7F72\u4EA7\u7269\u5F52\u6863");
+    return null;
+  }
+  const api = options.api ?? createApmApiClient(cfg);
+  let storage;
+  try {
+    storage = await fetchDeployArtifactStorage(api);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    console.warn(`[apm] \u83B7\u53D6 MinIO \u914D\u7F6E\u5931\u8D25\uFF0C\u8DF3\u8FC7\u90E8\u7F72\u4EA7\u7269\u5F52\u6863: ${detail}`);
+    return null;
+  }
+  const fileName = buildDeployArtifactFileName(
+    options.kind,
+    options.projectName,
+    options.timestamp
+  );
+  const objectKey = buildDeployArtifactObjectKey(options.projectName, fileName);
+  let body;
+  try {
+    body = await readFile2(options.zipPath);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    console.warn(`[apm] \u8BFB\u53D6\u90E8\u7F72\u4EA7\u7269 zip \u5931\u8D25\uFF0C\u8DF3\u8FC7 MinIO \u5F52\u6863: ${detail}`);
+    return null;
+  }
+  try {
+    const client = new MinioClient({
+      endPoint: storage.endpoint,
+      port: storage.port,
+      useSSL: storage.useSsl,
+      accessKey: storage.accessKey,
+      secretKey: storage.secretKey
+    });
+    await client.ensureBucket(storage.bucket);
+    await client.putObject(storage.bucket, objectKey, body, {
+      "Content-Type": "application/zip"
+    });
+    console.error(
+      `[apm] \u672C\u5730\u76F4\u4F20 MinIO\uFF08\u4E0D\u7ECF\u5E73\u53F0\u670D\u52A1\u5668\uFF09: ${storage.endpoint}:${storage.port}/${storage.bucket}/${objectKey} (${(body.length / 1024 / 1024).toFixed(
+        2
+      )} MB)`
+    );
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    console.warn(`[apm] MinIO \u90E8\u7F72\u4EA7\u7269\u5F52\u6863\u5931\u8D25: ${detail}`);
+    return null;
+  }
+  if (deploymentRunId) {
+    try {
+      await api.cli.attachTaskDeploymentArtifact({
+        id: deploymentRunId,
+        artifactObjectKey: objectKey,
+        artifactFileName: fileName
+      });
+      console.error(
+        `[apm] \u5DF2\u7ED1\u5B9A\u90E8\u7F72\u4EA7\u7269\u5230\u8BB0\u5F55 id=${deploymentRunId} file=${fileName}`
+      );
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      console.warn(`[apm] \u7ED1\u5B9A\u90E8\u7F72\u4EA7\u7269\u5230\u8BB0\u5F55\u5931\u8D25: ${detail}`);
+      return null;
+    }
+  }
+  return {
+    objectKey,
+    fileName,
+    bucket: storage.bucket
+  };
+}
+var APM_DEPLOYMENT_RUN_ID_ENV;
+var init_deploy_artifact_minio = __esm({
+  "src/commands/deploy/internal/deploy-artifact-minio.ts"() {
+    "use strict";
+    init_client();
+    init_config();
+    init_minio();
+    init_minio();
+    APM_DEPLOYMENT_RUN_ID_ENV = "APM_DEPLOYMENT_RUN_ID";
+  }
+});
+
+// src/commands/connect/webide-terminal-registry.ts
+var webide_terminal_registry_exports = {};
+__export(webide_terminal_registry_exports, {
+  WEBIDE_TERMINAL_LINES_PER_CHUNK: () => WEBIDE_TERMINAL_LINES_PER_CHUNK,
+  WebIdeTerminalRegistry: () => WebIdeTerminalRegistry,
+  getWebIdeTerminalRegistry: () => getWebIdeTerminalRegistry
+});
+import { spawn } from "node:child_process";
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
+function taskKey(taskId, key) {
+  return `${taskId}\0${key}`;
+}
+function chunkKey(prefix, chunkIndex) {
+  return `${prefix}chunks/${String(chunkIndex).padStart(6, "0")}.json`;
+}
+function extractPortsAndUrl(text) {
+  const ports = /* @__PURE__ */ new Set();
+  let primaryUrl = null;
+  let m;
+  const re = new RegExp(PORT_URL_RE.source, "gi");
+  while ((m = re.exec(text)) !== null) {
+    const urlCandidate = m[2];
+    if (urlCandidate) {
+      primaryUrl = primaryUrl ?? urlCandidate.replace(/[),.;]+$/, "");
+      try {
+        const u = new URL(primaryUrl);
+        if (u.port) ports.add(Number(u.port));
+        else if (u.protocol === "https:") ports.add(443);
+        else ports.add(80);
+      } catch {
+      }
+    }
+    for (const g of [m[1], m[3], m[4]]) {
+      if (g) {
+        const p = Number(g);
+        if (p > 0 && p < 65536) ports.add(p);
+      }
+    }
+  }
+  const httpMatch = text.match(/https?:\/\/[^\s)'"]+/i);
+  if (httpMatch && !primaryUrl) {
+    primaryUrl = httpMatch[0].replace(/[),.;]+$/, "");
+  }
+  return { ports: [...ports].sort((a, b) => a - b), primaryUrl };
+}
+function killProcessTree(pid) {
+  try {
+    process.kill(-pid, "SIGTERM");
+  } catch {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+    }
+  }
+}
+function forceKillProcessTree(pid) {
+  try {
+    process.kill(-pid, "SIGKILL");
+  } catch {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
+}
+async function listProcessTreePids(rootPid) {
+  const pids = [rootPid];
+  const queue = [rootPid];
+  while (queue.length > 0) {
+    const parent = queue.shift();
+    try {
+      const { stdout } = await execFileAsync3("pgrep", ["-P", String(parent)], {
+        timeout: 2e3
+      });
+      for (const line of stdout.split("\n")) {
+        const child = Number(line.trim());
+        if (child > 0 && !pids.includes(child)) {
+          pids.push(child);
+          queue.push(child);
+        }
+      }
+    } catch {
+    }
+  }
+  return pids;
+}
+async function probeListenPorts(pid) {
+  try {
+    const treePids = await listProcessTreePids(pid);
+    const { stdout } = await execFileAsync3(
+      "lsof",
+      ["-nP", "-a", `-p${treePids.join(",")}`, "-iTCP", "-sTCP:LISTEN"],
+      { timeout: 3e3, maxBuffer: 1024 * 1024 }
+    );
+    const ports = /* @__PURE__ */ new Set();
+    for (const line of stdout.split("\n")) {
+      const m = line.match(/:(\d+)\s+\(LISTEN\)/);
+      if (m) {
+        const p = Number(m[1]);
+        if (p > 0 && p < 65536) ports.add(p);
+      }
+    }
+    return [...ports].sort((a, b) => a - b);
+  } catch {
+    return [];
+  }
+}
+function getWebIdeTerminalRegistry(cfg) {
+  if (!registrySingleton) {
+    registrySingleton = new WebIdeTerminalRegistry(cfg);
+  }
+  return registrySingleton;
+}
+var execFileAsync3, WEBIDE_TERMINAL_LINES_PER_CHUNK, SYNC_INTERVAL_MS, PORT_PROBE_INTERVAL_MS, STOP_SIGKILL_MS, PORT_URL_RE, WebIdeTerminalRegistry, registrySingleton;
+var init_webide_terminal_registry = __esm({
+  "src/commands/connect/webide-terminal-registry.ts"() {
+    "use strict";
+    init_client();
+    init_deploy_artifact_minio();
+    init_minio();
+    execFileAsync3 = promisify3(execFile3);
+    WEBIDE_TERMINAL_LINES_PER_CHUNK = 50;
+    SYNC_INTERVAL_MS = 400;
+    PORT_PROBE_INTERVAL_MS = 2e3;
+    STOP_SIGKILL_MS = 5e3;
+    PORT_URL_RE = /(?:https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0)(?::(\d+))?|(?:Local|Network):\s*(https?:\/\/\S+)|listening\s+(?:on\s+)?(?:port\s+)?(\d+)|(?:port|PORT)\s*[:=]\s*(\d+))/gi;
+    WebIdeTerminalRegistry = class {
+      constructor(cfg) {
+        this.cfg = cfg;
+      }
+      cfg;
+      byId = /* @__PURE__ */ new Map();
+      byTaskKey = /* @__PURE__ */ new Map();
+      minio;
+      bucket = "";
+      async ensureMinio() {
+        if (this.minio) return;
+        const storage = await fetchDeployArtifactStorage(
+          createApmApiClient(this.cfg)
+        );
+        this.minio = new MinioClient({
+          endPoint: storage.endpoint,
+          port: storage.port,
+          useSSL: storage.useSsl,
+          accessKey: storage.accessKey,
+          secretKey: storage.secretKey
+        });
+        this.bucket = storage.bucket;
+        await this.minio.ensureBucket(this.bucket);
+      }
+      listLocal(taskId) {
+        const alive = [
+          "STARTING",
+          "RUNNING",
+          "READY",
+          "STOPPING"
+        ];
+        const sessions = [...this.byId.values()].filter(
+          (s) => alive.includes(s.status)
+        );
+        return (taskId ? sessions.filter((s) => s.taskId === taskId) : sessions).map((s) => ({
+          id: s.id,
+          taskId: s.taskId,
+          key: s.key,
+          name: s.name,
+          status: s.status,
+          pid: s.pid,
+          ports: s.ports,
+          primaryUrl: s.primaryUrl,
+          nextSeq: s.nextSeq,
+          command: s.command,
+          cwd: s.cwd
+        }));
+      }
+      async start(opts) {
+        const key = opts.key.trim();
+        const existingId = this.byTaskKey.get(taskKey(opts.taskId, key));
+        const existing = existingId ? this.byId.get(existingId) : void 0;
+        if (existing?.child && (existing.status === "RUNNING" || existing.status === "READY" || existing.status === "STARTING")) {
+          return {
+            ok: true,
+            idempotent: true,
+            terminalId: existing.id,
+            status: existing.status,
+            pid: existing.pid,
+            ports: existing.ports,
+            primaryUrl: existing.primaryUrl
+          };
+        }
+        const api = createApmApiClient(this.cfg);
+        const upserted = await api.cli.webideUpsertTerminal({
+          taskId: opts.taskId,
+          key,
+          name: opts.name ?? key,
+          cwd: opts.cwd,
+          command: opts.command,
+          readyPattern: opts.readyPattern,
+          portsHint: opts.portsHint
+        });
+        const terminalId = upserted.id;
+        const objectPrefix = upserted.objectPrefix?.trim() || `terminals/${opts.taskId}/${terminalId}/`;
+        if (existing?.child) {
+          await this.stop(terminalId, { reason: "restart" });
+        }
+        const session = {
+          id: terminalId,
+          taskId: opts.taskId,
+          key,
+          name: (opts.name ?? key).trim() || key,
+          cwd: opts.cwd,
+          command: opts.command,
+          readyPattern: opts.readyPattern?.trim() || null,
+          status: "STARTING",
+          pid: null,
+          ports: opts.portsHint ? [...opts.portsHint] : [],
+          primaryUrl: null,
+          nextSeq: typeof upserted.nextSeq === "number" ? upserted.nextSeq : 0,
+          chunkCount: typeof upserted.chunkCount === "number" ? upserted.chunkCount : 0,
+          objectPrefix,
+          child: null,
+          stopping: false,
+          pendingLines: [],
+          syncChain: Promise.resolve()
+        };
+        this.byId.set(terminalId, session);
+        this.byTaskKey.set(taskKey(opts.taskId, key), terminalId);
+        this.pushSystemLine(
+          session,
+          `[apm] starting: ${opts.command} (cwd=${opts.cwd})`
+        );
+        const child = spawn(opts.command, {
+          cwd: opts.cwd,
+          shell: true,
+          detached: true,
+          env: process.env,
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        session.child = child;
+        session.pid = child.pid ?? null;
+        session.status = "RUNNING";
+        await api.cli.webideUpdateTerminalStatus({
+          id: terminalId,
+          status: "RUNNING",
+          pid: session.pid,
+          ports: session.ports,
+          primaryUrl: null
+        });
+        const onData = (stream) => (buf) => {
+          const text = buf.toString("utf8");
+          for (const line of text.split(/\r?\n/)) {
+            if (!line.length && text.endsWith("\n") === false) continue;
+            if (line.length === 0) continue;
+            this.pushLine(session, stream, line);
+          }
+          this.scheduleSync(session);
+          this.maybeUpdatePortsFromText(session, text);
+        };
+        child.stdout?.on("data", onData("stdout"));
+        child.stderr?.on("data", onData("stderr"));
+        child.on("exit", (code, signal) => {
+          void this.onExit(session, code, signal);
+        });
+        session.portTimer = setInterval(() => {
+          void this.probePorts(session);
+        }, PORT_PROBE_INTERVAL_MS);
+        this.scheduleSync(session);
+        return {
+          ok: true,
+          idempotent: false,
+          terminalId,
+          status: session.status,
+          pid: session.pid,
+          ports: session.ports,
+          primaryUrl: session.primaryUrl
+        };
+      }
+      async stop(terminalId, opts) {
+        const session = this.byId.get(terminalId);
+        const api = createApmApiClient(this.cfg);
+        if (!session) {
+          const pid2 = opts?.pid;
+          if (typeof pid2 === "number" && pid2 > 0) {
+            killProcessTree(pid2);
+            setTimeout(() => forceKillProcessTree(pid2), STOP_SIGKILL_MS);
+          }
+          try {
+            await api.cli.webideUpdateTerminalStatus({
+              id: terminalId,
+              status: "EXITED",
+              lastError: opts?.reason ?? "stopped"
+            });
+          } catch {
+          }
+          return { ok: true, terminalId, status: "EXITED" };
+        }
+        if (session.status === "EXITED" || session.status === "FAILED" || session.stopping) {
+          return { ok: true, terminalId, status: session.status };
+        }
+        session.stopping = true;
+        session.status = "STOPPING";
+        this.pushSystemLine(
+          session,
+          `[apm] stopping${opts?.reason ? `: ${opts.reason}` : ""}`
+        );
+        this.scheduleSync(session);
+        try {
+          await api.cli.webideUpdateTerminalStatus({
+            id: terminalId,
+            status: "STOPPING",
+            pid: session.pid
+          });
+        } catch {
+        }
+        const pid = session.pid ?? opts?.pid ?? null;
+        if (session.child && !session.child.killed) {
+          try {
+            if (session.child.pid) killProcessTree(session.child.pid);
+          } catch {
+          }
+        } else if (typeof pid === "number" && pid > 0) {
+          killProcessTree(pid);
+        }
+        const killPid = session.child?.pid ?? pid;
+        if (typeof killPid === "number" && killPid > 0) {
+          setTimeout(() => {
+            if (session.child && !session.child.killed) {
+              forceKillProcessTree(killPid);
+            }
+          }, STOP_SIGKILL_MS);
+        }
+        return { ok: true, terminalId, status: "STOPPING" };
+      }
+      async stopAllForTask(taskId, reason = "cache-cleanup") {
+        const ids = [...this.byId.values()].filter((s) => s.taskId === taskId).map((s) => s.id);
+        for (const id of ids) {
+          await this.stop(id, { reason });
+        }
+        return { ok: true, stopped: ids.length };
+      }
+      pushSystemLine(session, text) {
+        this.pushLine(session, "system", text);
+      }
+      pushLine(session, stream, text) {
+        session.nextSeq += 1;
+        session.pendingLines.push({
+          seq: session.nextSeq,
+          stream,
+          text,
+          ts: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+      maybeUpdatePortsFromText(session, text) {
+        const { ports, primaryUrl } = extractPortsAndUrl(text);
+        let changed = false;
+        for (const p of ports) {
+          if (!session.ports.includes(p)) {
+            session.ports.push(p);
+            changed = true;
+          }
+        }
+        session.ports.sort((a, b) => a - b);
+        if (primaryUrl && !session.primaryUrl) {
+          session.primaryUrl = primaryUrl;
+          changed = true;
+        }
+        if (changed) {
+          void this.syncStatus(session);
+        }
+        if (session.readyPattern && session.status === "RUNNING" && new RegExp(session.readyPattern).test(text)) {
+          session.status = "READY";
+          void this.syncStatus(session);
+        } else if (session.status === "RUNNING" && (session.ports.length > 0 || session.primaryUrl)) {
+          session.status = "READY";
+          void this.syncStatus(session);
+        }
+      }
+      async probePorts(session) {
+        if (session.status !== "RUNNING" && session.status !== "STARTING" && session.status !== "READY") {
+          return;
+        }
+        if (!session.pid) return;
+        const ports = await probeListenPorts(session.pid);
+        if (ports.length === 0) return;
+        const same = ports.length === session.ports.length && ports.every((p, i) => p === session.ports[i]);
+        if (same) return;
+        session.ports = ports;
+        if (!session.primaryUrl && session.ports[0]) {
+          session.primaryUrl = `http://127.0.0.1:${session.ports[0]}`;
+        }
+        if (session.status === "RUNNING" || session.status === "STARTING") {
+          session.status = "READY";
+        }
+        void this.syncStatus(session);
+      }
+      async syncStatus(session) {
+        const api = createApmApiClient(this.cfg);
+        try {
+          await api.cli.webideUpdateTerminalStatus({
+            id: session.id,
+            status: session.status,
+            pid: session.pid,
+            ports: session.ports,
+            primaryUrl: session.primaryUrl
+          });
+        } catch (err) {
+          console.warn(
+            "[apm] terminal status sync failed:",
+            err instanceof Error ? err.message : err
+          );
+        }
+      }
+      scheduleSync(session) {
+        if (session.syncTimer) return;
+        session.syncTimer = setTimeout(() => {
+          session.syncTimer = void 0;
+          session.syncChain = session.syncChain.then(() => this.flushPending(session)).catch((err) => {
+            console.warn(
+              "[apm] terminal log flush failed:",
+              err instanceof Error ? err.message : err
+            );
+          });
+        }, SYNC_INTERVAL_MS);
+      }
+      async flushPending(session) {
+        if (session.pendingLines.length === 0) return;
+        const batch = session.pendingLines.splice(0, session.pendingLines.length);
+        await this.ensureMinio();
+        const seqStart = batch[0].seq;
+        const seqEnd = batch.at(-1).seq;
+        const ci = session.chunkCount;
+        const key = chunkKey(session.objectPrefix, ci);
+        const body = Buffer.from(
+          JSON.stringify({ seqStart, seqEnd, lines: batch }),
+          "utf8"
+        );
+        await this.minio.putObject(this.bucket, key, body, {
+          "Content-Type": "application/json"
+        });
+        session.chunkCount = ci + 1;
+        const api = createApmApiClient(this.cfg);
+        await api.cli.webideUpdateTerminalMeta({
+          id: session.id,
+          nextSeq: session.nextSeq,
+          chunkCount: session.chunkCount
+        });
+        if (!session.stopping && (session.status === "RUNNING" || session.status === "READY")) {
+          try {
+            const listed = await api.cli.webideListTerminals({
+              taskId: session.taskId
+            });
+            const remote = listed.terminals?.find((t) => t.id === session.id);
+            if (remote?.status === "STOPPING") {
+              await this.stop(session.id, {
+                pid: remote.pid ?? session.pid,
+                reason: "server STOPPING"
+              });
+            }
+          } catch {
+          }
+        }
+      }
+      async onExit(session, code, signal) {
+        if (session.portTimer) {
+          clearInterval(session.portTimer);
+          session.portTimer = void 0;
+        }
+        session.child = null;
+        const exitCode = code ?? (signal ? 1 : 0);
+        session.status = session.stopping || exitCode === 0 ? "EXITED" : "FAILED";
+        this.pushSystemLine(
+          session,
+          `[apm] exited code=${exitCode}${signal ? ` signal=${signal}` : ""}`
+        );
+        await session.syncChain;
+        await this.flushPending(session);
+        const api = createApmApiClient(this.cfg);
+        try {
+          await api.cli.webideUpdateTerminalStatus({
+            id: session.id,
+            status: session.status,
+            pid: session.pid,
+            exitCode,
+            ports: session.ports,
+            primaryUrl: session.primaryUrl
+          });
+        } catch (err) {
+          console.warn(
+            "[apm] terminal exit status sync failed:",
+            err instanceof Error ? err.message : err
+          );
+        }
+      }
+    };
+    registrySingleton = null;
+  }
+});
+
+// src/index.ts
+import { Command } from "commander";
+init_config();
 
 // src/commands/init.ts
 import { join as join5 } from "path";
 import { readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "fs";
 
 // src/command-utils.ts
+init_config();
 import {
   copyFileSync,
   existsSync,
@@ -367,204 +1381,10 @@ async function copyTemplateFiles(targetDir, workdir = resolveWorkdirPath()) {
 }
 
 // src/deployment-config-sync.ts
+init_client();
 import { join as join3 } from "path";
 import { writeFileSync as writeFileSync3 } from "fs";
 
-// src/api/client.ts
-import { createApiClient } from "listpage-http";
-
-// src/api/request-config.ts
-import { defineEndpoint } from "listpage-http";
-var requestConfig = {
-  cli: {
-    me: defineEndpoint(
-      {
-        method: "GET",
-        path: "/cli/me"
-      }
-    ),
-    sessionDetail: defineEndpoint({
-      method: "GET",
-      path: "/cli/sessions/detail"
-    }),
-    sessionMembers: defineEndpoint({
-      method: "GET",
-      path: "/cli/sessions/members"
-    }),
-    listSessionMessages: defineEndpoint({
-      method: "GET",
-      path: "/cli/messages"
-    }),
-    listDocuments: defineEndpoint({
-      method: "GET",
-      path: "/cli/documents"
-    }),
-    getDevGate: defineEndpoint({
-      method: "GET",
-      path: "/cli/dev-gate"
-    }),
-    listAttachments: defineEndpoint(
-      {
-        method: "GET",
-        path: "/cli/attachments"
-      }
-    ),
-    upsertDocument: defineEndpoint({
-      method: "PUT",
-      path: "/cli/documents/upsert"
-    }),
-    appendMessageContent: defineEndpoint({
-      method: "PUT",
-      path: "/cli/messages/content"
-    }),
-    setMessageError: defineEndpoint({
-      method: "PUT",
-      path: "/cli/messages/error"
-    }),
-    upsertCursorMessageLog: defineEndpoint({
-      method: "PUT",
-      path: "/cli/cursor-message-logs"
-    }),
-    updateMessageStatus: defineEndpoint({
-      method: "PUT",
-      path: "/cli/messages/status"
-    }),
-    webideAppendMessageContent: defineEndpoint({
-      method: "PUT",
-      path: "/cli/webide/messages/content"
-    }),
-    webideEnsureMessageContent: defineEndpoint({
-      method: "PUT",
-      path: "/cli/webide/messages/ensure-content"
-    }),
-    webideSetMessageError: defineEndpoint({
-      method: "PUT",
-      path: "/cli/webide/messages/error"
-    }),
-    webideUpdateMessageStatus: defineEndpoint({
-      method: "PUT",
-      path: "/cli/webide/messages/status"
-    }),
-    webideUpsertMessageLog: defineEndpoint({
-      method: "PUT",
-      path: "/cli/webide/message-logs"
-    }),
-    webideReplaceAssumptions: defineEndpoint({
-      method: "PUT",
-      path: "/cli/webide/assumptions"
-    }),
-    webideListAssumptions: defineEndpoint({
-      method: "GET",
-      path: "/cli/webide/assumptions"
-    }),
-    webideRecommendPlan: defineEndpoint({
-      method: "PUT",
-      path: "/cli/webide/plan-recommendation"
-    }),
-    webideUpsertPlan: defineEndpoint({
-      method: "PUT",
-      path: "/cli/webide/plan"
-    }),
-    webideReplaceTestCases: defineEndpoint({
-      method: "PUT",
-      path: "/cli/webide/test-cases"
-    }),
-    branchBaseline: defineEndpoint({
-      method: "GET",
-      path: "/cli/tasks/branch-baseline"
-    }),
-    listSessionsForBranchCleanup: defineEndpoint({
-      method: "GET",
-      path: "/cli/sessions/branch-cleanup"
-    }),
-    workspaceBaseline: defineEndpoint({
-      method: "GET",
-      path: "/cli/workspaces/baseline"
-    }),
-    getDeploymentConfiguration: defineEndpoint({
-      method: "GET",
-      path: "/cli/deployment-configurations"
-    }),
-    matchRepository: defineEndpoint({
-      method: "GET",
-      path: "/cli/repositories/match"
-    }),
-    listSkills: defineEndpoint({
-      method: "GET",
-      path: "/cli/skills"
-    }),
-    listRules: defineEndpoint({
-      method: "GET",
-      path: "/cli/rules"
-    }),
-    createPullRequest: defineEndpoint({
-      method: "POST",
-      path: "/cli/pull-requests"
-    }),
-    createWebIdeDraftPullRequest: defineEndpoint({
-      method: "POST",
-      path: "/cli/webide/draft-pull-requests"
-    }),
-    webideMergePullRequests: defineEndpoint({
-      method: "POST",
-      path: "/cli/webide/pull-requests/merge"
-    }),
-    getRepositoryProjectDocumentManifest: defineEndpoint({
-      method: "GET",
-      path: "/cli/repository-project-documents/manifest"
-    }),
-    listRepositoryProjectDocuments: defineEndpoint({
-      method: "GET",
-      path: "/cli/repository-project-documents"
-    }),
-    upsertRepositoryProjectDocument: defineEndpoint({
-      method: "PUT",
-      path: "/cli/repository-project-documents/upsert"
-    }),
-    removeRepositoryProjectDocument: defineEndpoint({
-      method: "DELETE",
-      path: "/cli/repository-project-documents"
-    }),
-    createTaskDeployment: defineEndpoint({
-      method: "POST",
-      path: "/cli/task-deployments"
-    }),
-    updateTaskDeploymentStatus: defineEndpoint({
-      method: "PUT",
-      path: "/cli/task-deployments/status"
-    }),
-    syncTaskDeploymentLog: defineEndpoint({
-      method: "PUT",
-      path: "/cli/task-deployments/log"
-    }),
-    completeTaskDeployment: defineEndpoint({
-      method: "PUT",
-      path: "/cli/task-deployments/complete"
-    }),
-    getDeployArtifactStorage: defineEndpoint(
-      {
-        method: "GET",
-        path: "/cli/deploy-artifact-storage"
-      }
-    ),
-    attachTaskDeploymentArtifact: defineEndpoint({
-      method: "PUT",
-      path: "/cli/task-deployments/artifact"
-    })
-  }
-};
-
-// src/api/client.ts
-function createApmApiClient(cfg) {
-  const baseURL = `${cfg.baseUrl.trim().replace(/\/+$/, "")}/api/v1`;
-  return createApiClient(requestConfig, {
-    baseURL,
-    getToken: () => resolveApiKey(cfg) || void 0,
-    successCodes: [0],
-    unauthorizedCodes: [401]
-  });
-}
-
 // src/git-remote.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
@@ -769,6 +1589,7 @@ async function resolveBranchBaseline(api, sessionId, workdirPath) {
 }
 
 // src/deployment-config-sync.ts
+init_config();
 var TEMPLATE_HINT = "\u4FDD\u7559\u6A21\u677F .apm/apm.config.json";
 var SYNC_HINT = "\u767B\u8BB0\u5DE5\u4F5C\u7A7A\u95F4\u8DEF\u5F84\u3001\u7ED1\u5B9A\u4ED3\u5E93\u540E\uFF0C\u53EF\u6267\u884C: apm sync-deploy-config";
 async function resolveRepositoryIdForSync(api, workdirPath) {
@@ -831,7 +1652,9 @@ ${diagnostic ?? ""}
   return { synced: true, repositoryId, configName: config.name };
 }
 
-// src/repository-project-documents-sync.ts
+// src/project-documents-sync.ts
+init_client();
+init_config();
 import {
   existsSync as existsSync2,
   readdirSync as readdirSync2,
@@ -843,7 +1666,7 @@ import { createHash } from "crypto";
 import { dirname as dirname2, join as join4, relative, sep } from "path";
 var MANIFEST_FILE = "manifest.json";
 function projectDocumentsDir(apmRoot) {
-  return join4(apmRoot ?? workspaceApmDir(), "project");
+  return join4(apmRoot ?? workspaceApmDir(), "docs");
 }
 function projectDocumentLocalPath(apmRoot, documentPath) {
   const normalized = normalizeLocalDocumentPath(documentPath);
@@ -918,43 +1741,67 @@ function diffManifestPaths(remote, local) {
       deleteLocal.push(path19);
     }
   }
-  return { download, deleteLocal };
+  return { download, deleteLocal };
+}
+async function resolveProjectIdForSync(api, workdirPath) {
+  try {
+    const baseline = await api.cli.workspaceBaseline({ workdirPath });
+    const projectId = baseline.projectId?.trim() || null;
+    if (projectId) {
+      return { projectId, diagnostic: null };
+    }
+    const projectIds = baseline.projectIds ?? [];
+    if (projectIds.length === 0) {
+      return {
+        projectId: null,
+        diagnostic: baseline.diagnostic?.message ?? `\u5DE5\u4F5C\u7A7A\u95F4\u672A\u5173\u8054\u9879\u76EE\uFF0C\u65E0\u6CD5\u540C\u6B65\u9879\u76EE\u6587\u6863\uFF08\u76EE\u5F55\uFF1A${workdirPath}\uFF09\u3002
+\u8BF7\u5728\u5E73\u53F0\u5C06\u5DE5\u4F5C\u7A7A\u95F4\u5173\u8054\u5230\u552F\u4E00\u9879\u76EE\u3002`
+      };
+    }
+    return {
+      projectId: null,
+      diagnostic: `\u5DE5\u4F5C\u7A7A\u95F4\u5173\u8054\u4E86 ${projectIds.length} \u4E2A\u9879\u76EE\uFF0C\u65E0\u6CD5\u786E\u5B9A\u540C\u6B65\u76EE\u6807\u3002
+\u8BF7\u786E\u4FDD\u8BE5\u5DE5\u4F5C\u7A7A\u95F4\u53EA\u5173\u8054\u4E00\u4E2A\u9879\u76EE\u540E\u518D\u540C\u6B65\u9879\u76EE\u6587\u6863\u3002`
+    };
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    return {
+      projectId: null,
+      diagnostic: detail.replace(/^\[apm\]\s*/, "")
+    };
+  }
 }
-async function syncRepositoryProjectDocumentsPull(workdirPath, apmDir) {
+async function syncProjectDocumentsPull(workdirPath, apmDir) {
   const empty = {
     synced: false,
-    repositoryId: null,
+    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\u4ED3\u5E93\u9879\u76EE\u6587\u6863\u540C\u6B65\u3002\n[apm] \u8BF7\u5148\u6267\u884C apm login\u3002"
+      "[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 { repositoryId, diagnostic } = await resolveRepositoryIdForSync(
+  const { projectId, diagnostic } = await resolveProjectIdForSync(
     api,
     workdirPath
   );
-  if (!repositoryId) {
-    console.log(
-      `[apm] \u672A\u80FD\u540C\u6B65\u4ED3\u5E93\u9879\u76EE\u6587\u6863\u3002
-${diagnostic ?? ""}`
-    );
+  if (!projectId) {
+    console.log(`[apm] \u672A\u80FD\u540C\u6B65\u9879\u76EE\u6587\u6863\u3002
+${diagnostic ?? ""}`);
     return empty;
   }
   const targetApmDir = apmDir ?? workspaceApmDir(workdirPath);
-  const projectDir = projectDocumentsDir(targetApmDir);
-  await ensureDirExists(projectDir);
-  const { manifest: remoteManifest } = await api.cli.getRepositoryProjectDocumentManifest({ repositoryId });
+  const docsDir = projectDocumentsDir(targetApmDir);
+  await ensureDirExists(docsDir);
+  const { manifest: remoteManifest } = await api.cli.getProjectDocumentManifest({ projectId });
   if (!remoteManifest) {
-    console.log(
-      `[apm] \u4ED3\u5E93 ${repositoryId} \u65E0\u9879\u76EE\u6587\u6863 manifest\uFF0C\u8DF3\u8FC7\u540C\u6B65\u3002`
-    );
-    return { ...empty, repositoryId };
+    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);
   const { download, deleteLocal } = diffManifestPaths(
@@ -963,12 +1810,14 @@ ${diagnostic ?? ""}`
   );
   let downloaded = 0;
   if (download.length > 0) {
-    const { list } = await api.cli.listRepositoryProjectDocuments({
-      repositoryId,
+    const { list } = await api.cli.listProjectDocuments({
+      projectId,
       paths: download.join(",")
     });
     for (const doc of list) {
-      const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, doc.path));
+      const absPath = toFsPath(
+        projectDocumentLocalPath(targetApmDir, doc.path)
+      );
       await ensureDirExists(dirname2(absPath));
       writeFileSync4(absPath, doc.content, "utf8");
       downloaded += 1;
@@ -983,34 +1832,34 @@ ${diagnostic ?? ""}`
     }
   }
   writeFileSync4(
-    toFsPath(join4(projectDir, MANIFEST_FILE)),
+    toFsPath(join4(docsDir, MANIFEST_FILE)),
     `${JSON.stringify(remoteManifest, null, 2)}
 `,
     "utf8"
   );
   console.log(
-    `[apm] \u5DF2\u540C\u6B65\u4ED3\u5E93\u9879\u76EE\u6587\u6863: \u4E0B\u8F7D ${downloaded}\uFF0C\u5220\u9664\u672C\u5730 ${deleted}`
+    `[apm] \u5DF2\u540C\u6B65\u9879\u76EE\u6587\u6863: \u4E0B\u8F7D ${downloaded}\uFF0C\u5220\u9664\u672C\u5730 ${deleted}`
   );
   return {
     synced: true,
-    repositoryId,
+    projectId,
     downloaded,
     deleted
   };
 }
-async function syncRepositoryProjectDocumentsPush(cfg, workdirPath, apmRoot) {
+async function syncProjectDocumentsPush(cfg, workdirPath, apmRoot) {
   const api = createApmApiClient(cfg);
-  const { repositoryId } = await resolveRepositoryIdForSync(api, workdirPath);
-  if (!repositoryId) {
+  const { projectId } = await resolveProjectIdForSync(api, workdirPath);
+  if (!projectId) {
     return 0;
   }
   const targetApmDir = apmRoot ?? workspaceApmDir(workdirPath);
   const localPaths = listLocalDocumentPaths(targetApmDir);
   if (localPaths.length === 0) {
-    console.log("[apm] \u4ED3\u5E93\u9879\u76EE\u6587\u6863\u65E0\u672C\u5730\u6587\u4EF6\uFF0C\u8DF3\u8FC7\u63A8\u9001");
+    console.log("[apm] \u9879\u76EE\u6587\u6863\u65E0\u672C\u5730\u6587\u4EF6\uFF0C\u8DF3\u8FC7\u63A8\u9001");
     return 0;
   }
-  const remoteManifest = (await api.cli.getRepositoryProjectDocumentManifest({ repositoryId })).manifest ?? null;
+  const remoteManifest = (await api.cli.getProjectDocumentManifest({ projectId })).manifest ?? null;
   const remoteHashByPath = new Map(
     (remoteManifest?.documents ?? []).map((doc) => [doc.path, doc.contentHash])
   );
@@ -1028,17 +1877,17 @@ async function syncRepositoryProjectDocumentsPush(cfg, workdirPath, apmRoot) {
     if (remoteHashByPath.get(path19) === contentHash) {
       continue;
     }
-    await api.cli.upsertRepositoryProjectDocument({
-      repositoryId,
+    await api.cli.upsertProjectDocument({
+      projectId,
       path: path19,
       content,
       description: remoteDescriptionByPath.get(path19) ?? void 0
     });
     synced += 1;
-    console.log(`[apm] \u5DF2\u540C\u6B65\u4ED3\u5E93\u9879\u76EE\u6587\u6863: ${path19}`);
+    console.log(`[apm] \u5DF2\u540C\u6B65\u9879\u76EE\u6587\u6863: ${path19}`);
   }
   if (synced === 0) {
-    console.log("[apm] \u4ED3\u5E93\u9879\u76EE\u6587\u6863\u65E0\u53D8\u5316\uFF0C\u8DF3\u8FC7\u63A8\u9001");
+    console.log("[apm] \u9879\u76EE\u6587\u6863\u65E0\u53D8\u5316\uFF0C\u8DF3\u8FC7\u63A8\u9001");
   }
   return synced;
 }
@@ -1059,7 +1908,7 @@ async function ensureWorkspaceInitialized(workdir, options) {
   const apmDir = workspaceApmDir(workdir);
   await copyTemplateFiles(apmDir, workdir);
   const syncResult = await syncRemoteDeploymentConfig(workdir, apmDir);
-  await syncRepositoryProjectDocumentsPull(workdir, apmDir);
+  await syncProjectDocumentsPull(workdir, apmDir);
   const trimmedName = options?.name?.trim();
   if (trimmedName) {
     const apmConfigPath = toFsPath(join5(apmDir, "apm.config.json"));
@@ -1097,6 +1946,8 @@ async function runInit(name) {
 }
 
 // src/commands/login.ts
+init_config();
+init_client();
 import { existsSync as existsSync3 } from "fs";
 import { ApiError } from "listpage-http";
 async function runLogin(opts) {
@@ -1158,6 +2009,7 @@ async function runLogin(opts) {
 }
 
 // src/commands/branch.ts
+init_client();
 var SESSION_BRANCH_PREFIX = "feat/session-";
 function branchNameForSession(sessionId) {
   const id = sessionId.trim();
@@ -1281,6 +2133,9 @@ async function runBranch(sessionId, options = {}) {
   return ensureFeatureBranch(branch, baseline.defaultBranch, options);
 }
 
+// src/commands/clean-branches.ts
+init_client();
+
 // src/commands/session-branch-prune.ts
 var TASK_STATUS_LABEL = {
   OPEN: "\u5F85\u5F00\u59CB",
@@ -1603,6 +2458,7 @@ async function runCleanBranches(options = {}) {
 }
 
 // src/commands/pull.ts
+init_client();
 import { writeFileSync as writeFileSync9 } from "fs";
 import { join as join9 } from "path";
 import { stringify as yamlStringify } from "yaml";
@@ -1713,6 +2569,7 @@ async function syncSessionAttachments(cfg, sessionId, attachments, apmRoot) {
 }
 
 // src/rules-sync.ts
+init_client();
 import { basename as basename2, extname as extname2, join as join8 } from "path";
 import { existsSync as existsSync6, readFileSync as readFileSync6, rmSync as rmSync3, writeFileSync as writeFileSync8 } from "fs";
 
@@ -1965,7 +2822,7 @@ async function runPull(sessionId, remoteWorkdir) {
   await syncSessionAttachments(cfg, trimmedId, attachments, apmRoot);
   await syncPlatformRules(cfg, trimmedId, workdir, apmRoot);
   await syncRemoteDeploymentConfig(workdir, apmRoot);
-  await syncRepositoryProjectDocumentsPull(workdir, apmRoot);
+  await syncProjectDocumentsPull(workdir, apmRoot);
   console.log(`[apm] \u5DF2\u540C\u6B65\u4F1A\u8BDD\u5DE5\u4F5C\u533A: ${dir}`);
   return dir;
 }
@@ -2135,6 +2992,7 @@ async function runUpdate(options = {}) {
 }
 
 // src/commands/update-skills.ts
+init_client();
 import { existsSync as existsSync7, mkdirSync as mkdirSync4, statSync as statSync3 } from "fs";
 import { join as join11 } from "path";
 async function syncWorkspaceSkills(cfg, workdir) {
@@ -2217,17 +3075,21 @@ async function runSyncDeployConfig() {
 }
 
 // src/commands/sync-project-documents.ts
+init_config();
 async function runSyncProjectDocuments(options) {
-  const pull = options?.pull ?? !options?.push;
-  const push = options?.push ?? false;
   const workdir = resolveWorkdirPath();
   const apmRoot = workspaceApmDir(workdir);
-  if (pull) {
-    await syncRepositoryProjectDocumentsPull(workdir, apmRoot);
+  const doPush = Boolean(options.push);
+  const doPull = Boolean(options.pull) || !doPush;
+  if (doPull) {
+    await syncProjectDocumentsPull(workdir, apmRoot);
   }
-  if (push) {
-    const cfg = await ensureLoggedConfig();
-    await syncRepositoryProjectDocumentsPush(cfg, 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);
   }
 }
 
@@ -2398,7 +3260,11 @@ function validateAssumptionsMarkdown(markdown, source) {
   };
 }
 
+// src/commands/sync-document.ts
+init_client();
+
 // src/commands/sync-session-documents.ts
+init_client();
 import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync8 } from "fs";
 import { join as join12 } from "path";
 function listLocalMarkdownFiles(docsDir) {
@@ -2519,6 +3385,7 @@ async function runSyncDocument(sessionId, options) {
 }
 
 // src/commands/dev-gate.ts
+init_client();
 async function runDevGate(sessionId, source) {
   const trimmedId = sessionId.trim();
   if (!trimmedId) {
@@ -2538,6 +3405,7 @@ async function runDevGate(sessionId, source) {
 }
 
 // src/commands/append-message.ts
+init_client();
 async function appendMessageContent(cfg, messageId, content) {
   const trimmedId = messageId.trim();
   if (!trimmedId) {
@@ -2566,6 +3434,7 @@ async function runAppendMessage(options) {
 }
 
 // src/commands/update-message-status.ts
+init_client();
 var VALID_STATUSES = [
   "CREATED",
   "QUEUED",
@@ -2594,8 +3463,10 @@ async function runUpdateMessageStatus(options) {
 }
 
 // src/commands/connect.ts
+init_client();
 import WebSocket from "ws";
 import { setTimeout as delay3 } from "node:timers/promises";
+init_config();
 
 // src/ws/protocol.ts
 function nonEmptyString(v) {
@@ -2777,13 +3648,38 @@ function validateWebIdeCacheCleanupPush(o) {
     }
   };
 }
+function validateWebIdeTerminalStopPush(o) {
+  if (o.type !== "webide-terminal-stop") {
+    return { ok: false, reason: "\u671F\u671B webide-terminal-stop" };
+  }
+  if (!nonEmptyString(o.taskId)) {
+    return { ok: false, reason: "webide-terminal-stop \u7F3A\u5C11 taskId" };
+  }
+  if (!nonEmptyString(o.terminalId)) {
+    return { ok: false, reason: "webide-terminal-stop \u7F3A\u5C11 terminalId" };
+  }
+  if (!nonEmptyString(o.key)) {
+    return { ok: false, reason: "webide-terminal-stop \u7F3A\u5C11 key" };
+  }
+  const pid = typeof o.pid === "number" && Number.isFinite(o.pid) ? Math.trunc(o.pid) : o.pid === null ? null : void 0;
+  return {
+    ok: true,
+    data: {
+      type: "webide-terminal-stop",
+      taskId: o.taskId.trim(),
+      terminalId: o.terminalId.trim(),
+      key: o.key.trim(),
+      ...pid !== void 0 ? { pid } : {}
+    }
+  };
+}
 function validateAgentWsMessage(value, kind) {
   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 !== "message" && type !== "webide-message" && type !== "cancel" && type !== "deploy" && type !== "session-cache-cleanup" && type !== "webide-cache-cleanup") {
+  if (type !== "heartbeat" && type !== "message" && type !== "webide-message" && type !== "cancel" && type !== "deploy" && type !== "session-cache-cleanup" && type !== "webide-cache-cleanup" && type !== "webide-terminal-stop") {
     return { ok: false, reason: `\u672A\u77E5 type: ${String(type)}` };
   }
   if (kind === "heartbeat" || type === "heartbeat") {
@@ -2801,12 +3697,18 @@ function validateAgentWsMessage(value, kind) {
   if (type === "webide-cache-cleanup") {
     return validateWebIdeCacheCleanupPush(o);
   }
+  if (type === "webide-terminal-stop") {
+    return validateWebIdeTerminalStopPush(o);
+  }
   if (type === "webide-message") {
     return validateWebIdeMessagePush(o);
   }
   return validateMessagePush(o);
 }
 
+// src/commands/connect/deploy-run.ts
+init_client();
+
 // src/commands/deploy/deploy-execute.ts
 import path11 from "node:path";
 
@@ -3054,366 +3956,119 @@ function resolveWisdomBackendPackOnlyFromApmConfig(cfg) {
     mavenLocalRepoSourceDetail: mavenLocalRepo.sourceDetail,
     mode: resolveWisdomDeployMode(w.mode)
   };
-}
-function resolveWisdomBackendDeployFromApmConfig(cfg) {
-  const projectName = reqTopLevelName(cfg);
-  const w = cfg.wisdomDeploy ?? {};
-  const h = cfg.healthCheck ?? {};
-  const jarPath = req(w.jarPath, "jarPath", "wisdomDeploy").trim();
-  const remoteAppDir = posixDirname(jarPath);
-  const healthPort = Number(req(h.port, "port", "healthCheck"));
-  const healthTimeout = Number(req(h.timeout, "timeout", "healthCheck"));
-  if (!Number.isFinite(healthPort) || !Number.isInteger(healthPort) || healthPort < 1) {
-    console.error("apm.config.json \u4E2D healthCheck.port \u987B\u4E3A\u6B63\u6574\u6570");
-    process.exit(1);
-  }
-  if (!Number.isFinite(healthTimeout) || !Number.isInteger(healthTimeout) || healthTimeout < 1) {
-    console.error("apm.config.json \u4E2D healthCheck.timeout \u987B\u4E3A\u6B63\u6574\u6570");
-    process.exit(1);
-  }
-  const mavenLocalRepo = resolveMavenLocalRepoWithSource();
-  return {
-    projectName,
-    host: req(w.host, "host", "wisdomDeploy").trim(),
-    port: reqPositiveInt(w.port, "port", "wisdomDeploy"),
-    username: req(w.username, "username", "wisdomDeploy").trim(),
-    password: req(w.password, "password", "wisdomDeploy").trim(),
-    remoteVueDistDir: req(w.remotePath, "remotePath", "wisdomDeploy").trim(),
-    remoteAppDir,
-    remoteLibDir: `${remoteAppDir}/lib`,
-    startupJar: posixBasename(jarPath),
-    packageName: `${projectName}.jar.zip`,
-    mavenLocalRepo: mavenLocalRepo.path,
-    mavenLocalRepoSource: mavenLocalRepo.source,
-    mavenLocalRepoSourceDetail: mavenLocalRepo.sourceDetail,
-    healthCheckPort: healthPort,
-    healthCheckContext: req(h.context, "context", "healthCheck").trim(),
-    healthCheckTimeout: healthTimeout,
-    mode: resolveWisdomDeployMode(w.mode)
-  };
-}
-
-// src/commands/deploy/internal/apm-config.ts
-function loadApmConfig(options) {
-  const p = resolve4(
-    process.cwd(),
-    options?.configPath ?? resolve4(workspaceApmDir(), "apm.config.json")
-  );
-  if (!existsSync12(p)) {
-    console.error(`\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF1A${p}`);
-    process.exit(1);
-  }
-  try {
-    const raw = readFileSync11(p, "utf8");
-    return JSON.parse(raw);
-  } catch (e) {
-    console.error(`\u65E0\u6CD5\u89E3\u6790 apm.config.json\uFF1A${p}`, e);
-    process.exit(1);
-  }
-}
-
-// src/commands/deploy/internal/deploy-hints.ts
-function isProductionDeployEnv(env) {
-  const normalized = env.trim().toLowerCase();
-  return normalized === "online" || normalized === "production" || normalized === "prod";
-}
-function formatMissingWisdomDeployLines() {
-  return [
-    "[apm] \u65E0\u6CD5\u6267\u884C apm deploy\uFF1A\u8BF7\u5728 apm.config.json \u4E2D\u914D\u7F6E wisdomDeploy\uFF08host\u3001remotePath\uFF09"
-  ];
-}
-function formatWisdomFrontendBuildNotConfiguredLines(env, packageJsonPath) {
-  if (isProductionDeployEnv(env)) {
-    return [
-      `[apm] \u65E0\u6CD5\u6267\u884C\u524D\u7AEF\u90E8\u7F72\uFF1A${packageJsonPath} \u4E2D\u672A\u627E\u5230 build:${env} \u6216 build \u811A\u672C`,
-      "[apm] \u8BF7\u914D\u7F6E npm run build:online \u6216 npm run build \u540E\u518D\u8BD5"
-    ];
-  }
-  return [
-    `[apm] \u65E0\u6CD5\u6267\u884C\u524D\u7AEF\u90E8\u7F72\uFF1A${packageJsonPath} \u4E2D\u672A\u627E\u5230 build:${env} \u811A\u672C`,
-    "[apm] \u8BF7\u914D\u7F6E npm run build:test \u540E\u518D\u8BD5"
-  ];
-}
-
-// src/commands/deploy/deploy-errors.ts
-var DeployExecutionError = class extends Error {
-  exitCode;
-  output;
-  constructor(message, exitCode, output = "") {
-    super(message);
-    this.name = "DeployExecutionError";
-    this.exitCode = exitCode;
-    this.output = output;
-  }
-};
-
-// src/commands/deploy/deploy-debug-log.ts
-import { spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync16 } from "node:fs";
-import { dirname as dirname5, join as join17 } from "node:path";
-
-// src/commands/deploy/internal/deploy-artifact-minio.ts
-import { readFile as readFile2 } from "node:fs/promises";
-
-// src/commands/deploy/internal/minio.ts
-import { statSync as statSync5 } from "node:fs";
-import { readdir, readFile } from "node:fs/promises";
-import path from "node:path";
-import * as Minio from "minio";
-var DEFAULT_MAX_FILE_SIZE_MB = 50;
-async function isDirectoryPath(dir) {
-  try {
-    const st = statSync5(dir);
-    return st.isDirectory();
-  } catch {
-    return false;
-  }
-}
-function sanitizeRelativePath(rel) {
-  const norm = rel.replace(/\\/g, "/").replace(/^\/+/, "");
-  const segments = norm.split("/").filter(Boolean);
-  for (const s of segments) {
-    if (s === "." || s === "..") {
-      throw new Error(`\u975E\u6CD5\u76F8\u5BF9\u8DEF\u5F84\u7247\u6BB5\uFF1A${s}`);
-    }
-  }
-  return segments.join("/");
-}
-async function collectFiles(root) {
-  const out = [];
-  async function walk(dir, prefix) {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const e of entries) {
-      const name = e.name;
-      if (name === "." || name === "..") {
-        continue;
-      }
-      const abs = path.join(dir, name);
-      const rel = prefix ? `${prefix}/${name}` : name;
-      if (e.isDirectory()) {
-        await walk(abs, rel);
-      } else if (e.isFile()) {
-        const st = statSync5(abs);
-        out.push({
-          absPath: abs,
-          relativePath: rel.replace(/\\/g, "/"),
-          size: st.size
-        });
-      }
-    }
-  }
-  await walk(root, "");
-  out.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
-  return out;
-}
-async function readArtifactFile(absPath) {
-  return readFile(absPath);
-}
-function toMB(bytes) {
-  return Math.round(bytes / (1024 * 1024) * 1e3) / 1e3;
-}
-var MIME = {
-  ".html": "text/html; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".js": "application/javascript; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".svg": "image/svg+xml",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-  ".ttf": "font/ttf",
-  ".ico": "image/x-icon",
-  ".txt": "text/plain; charset=utf-8",
-  ".map": "application/json"
-};
-function detectMimeType(filePath) {
-  const ext = path.extname(filePath).toLowerCase();
-  return MIME[ext] ?? "";
-}
-var MinioClient = class {
-  inner;
-  constructor(opts) {
-    const endPoint = opts.endPoint.replace(/^https?:\/\//i, "").split("/")[0] ?? opts.endPoint;
-    this.inner = new Minio.Client({
-      endPoint,
-      port: opts.port,
-      useSSL: opts.useSSL,
-      accessKey: opts.accessKey,
-      secretKey: opts.secretKey
-    });
-  }
-  async ensureBucket(bucket) {
-    const exists = await this.inner.bucketExists(bucket);
-    if (!exists) {
-      await this.inner.makeBucket(bucket);
-    }
-  }
-  async deleteObjectsByPrefix(bucket, prefix) {
-    const objectsStream = this.inner.listObjectsV2(bucket, prefix, true);
-    const keys = [];
-    await new Promise((resolve7, reject) => {
-      objectsStream.on("data", (obj) => {
-        if (obj.name) {
-          keys.push(obj.name);
-        }
-      });
-      objectsStream.on("error", reject);
-      objectsStream.on("end", resolve7);
-    });
-    const chunkSize = 500;
-    for (let i = 0; i < keys.length; i += chunkSize) {
-      const chunk = keys.slice(i, i + chunkSize);
-      await this.inner.removeObjects(
-        bucket,
-        chunk.map((name) => name)
-      );
-    }
-  }
-  async putObject(bucket, objectKey, body, meta) {
-    await this.inner.putObject(bucket, objectKey, body, body.length, meta);
-  }
-  /** 匿名可读当前桶全部对象（便于静态站点直链） */
-  async setBucketPublicRead(bucket) {
-    const policy = {
-      Version: "2012-10-17",
-      Statement: [
-        {
-          Effect: "Allow",
-          Principal: { AWS: ["*"] },
-          Action: ["s3:GetObject"],
-          Resource: [`arn:aws:s3:::${bucket}/*`]
-        }
-      ]
-    };
-    await this.inner.setBucketPolicy(bucket, JSON.stringify(policy));
-  }
-};
-
-// src/commands/deploy/internal/deploy-artifact-minio.ts
-var APM_DEPLOYMENT_RUN_ID_ENV = "APM_DEPLOYMENT_RUN_ID";
-function formatDeployArtifactTimestamp(date = /* @__PURE__ */ new Date()) {
-  const pad2 = (n) => String(n).padStart(2, "0");
-  return `${date.getFullYear()}${pad2(date.getMonth() + 1)}${pad2(date.getDate())}${pad2(date.getHours())}${pad2(date.getMinutes())}${pad2(date.getSeconds())}`;
-}
-function sanitizeDeployProjectName(name) {
-  const trimmed = name.trim().replace(/\\/g, "/");
-  const base = trimmed.split("/").filter(Boolean).pop() ?? trimmed;
-  try {
-    return sanitizeRelativePath(base.replace(/[/\\:*?"<>|]/g, "_"));
-  } catch {
-    return "project";
-  }
-}
-function buildDeployArtifactFileName(kind, projectName, timestamp = formatDeployArtifactTimestamp()) {
-  const safeName = sanitizeDeployProjectName(projectName);
-  const suffix = kind === "frontend" ? "dist.zip" : "jar.zip";
-  return `${timestamp}-${safeName}.${suffix}`;
-}
-function buildDeployArtifactObjectKey(projectName, fileName) {
-  const safeProject = sanitizeDeployProjectName(projectName);
-  return `deploy/${safeProject}/${fileName}`;
-}
-function resolveDeploymentRunIdFromEnv() {
-  const raw = process.env[APM_DEPLOYMENT_RUN_ID_ENV]?.trim();
-  return raw || null;
-}
-async function fetchDeployArtifactStorage(api) {
-  return api.cli.getDeployArtifactStorage(void 0);
-}
-async function uploadDeployArtifactZip(options) {
-  const deploymentRunId = options.deploymentRunId ?? resolveDeploymentRunIdFromEnv();
-  if (!deploymentRunId && !options.uploadWithoutRunId) {
-    return null;
-  }
-  const cfg = await tryReadApmConfig();
-  if (!cfg || !resolveApiKey(cfg)) {
-    console.warn("[apm] \u672A\u767B\u5F55\uFF0C\u8DF3\u8FC7 MinIO \u90E8\u7F72\u4EA7\u7269\u5F52\u6863");
-    return null;
+}
+function resolveWisdomBackendDeployFromApmConfig(cfg) {
+  const projectName = reqTopLevelName(cfg);
+  const w = cfg.wisdomDeploy ?? {};
+  const h = cfg.healthCheck ?? {};
+  const jarPath = req(w.jarPath, "jarPath", "wisdomDeploy").trim();
+  const remoteAppDir = posixDirname(jarPath);
+  const healthPort = Number(req(h.port, "port", "healthCheck"));
+  const healthTimeout = Number(req(h.timeout, "timeout", "healthCheck"));
+  if (!Number.isFinite(healthPort) || !Number.isInteger(healthPort) || healthPort < 1) {
+    console.error("apm.config.json \u4E2D healthCheck.port \u987B\u4E3A\u6B63\u6574\u6570");
+    process.exit(1);
   }
-  const api = options.api ?? createApmApiClient(cfg);
-  let storage;
-  try {
-    storage = await fetchDeployArtifactStorage(api);
-  } catch (error) {
-    const detail = error instanceof Error ? error.message : String(error);
-    console.warn(`[apm] \u83B7\u53D6 MinIO \u914D\u7F6E\u5931\u8D25\uFF0C\u8DF3\u8FC7\u90E8\u7F72\u4EA7\u7269\u5F52\u6863: ${detail}`);
-    return null;
+  if (!Number.isFinite(healthTimeout) || !Number.isInteger(healthTimeout) || healthTimeout < 1) {
+    console.error("apm.config.json \u4E2D healthCheck.timeout \u987B\u4E3A\u6B63\u6574\u6570");
+    process.exit(1);
   }
-  const fileName = buildDeployArtifactFileName(
-    options.kind,
-    options.projectName,
-    options.timestamp
+  const mavenLocalRepo = resolveMavenLocalRepoWithSource();
+  return {
+    projectName,
+    host: req(w.host, "host", "wisdomDeploy").trim(),
+    port: reqPositiveInt(w.port, "port", "wisdomDeploy"),
+    username: req(w.username, "username", "wisdomDeploy").trim(),
+    password: req(w.password, "password", "wisdomDeploy").trim(),
+    remoteVueDistDir: req(w.remotePath, "remotePath", "wisdomDeploy").trim(),
+    remoteAppDir,
+    remoteLibDir: `${remoteAppDir}/lib`,
+    startupJar: posixBasename(jarPath),
+    packageName: `${projectName}.jar.zip`,
+    mavenLocalRepo: mavenLocalRepo.path,
+    mavenLocalRepoSource: mavenLocalRepo.source,
+    mavenLocalRepoSourceDetail: mavenLocalRepo.sourceDetail,
+    healthCheckPort: healthPort,
+    healthCheckContext: req(h.context, "context", "healthCheck").trim(),
+    healthCheckTimeout: healthTimeout,
+    mode: resolveWisdomDeployMode(w.mode)
+  };
+}
+
+// src/commands/deploy/internal/apm-config.ts
+function loadApmConfig(options) {
+  const p = resolve4(
+    process.cwd(),
+    options?.configPath ?? resolve4(workspaceApmDir(), "apm.config.json")
   );
-  const objectKey = buildDeployArtifactObjectKey(options.projectName, fileName);
-  let body;
-  try {
-    body = await readFile2(options.zipPath);
-  } catch (error) {
-    const detail = error instanceof Error ? error.message : String(error);
-    console.warn(`[apm] \u8BFB\u53D6\u90E8\u7F72\u4EA7\u7269 zip \u5931\u8D25\uFF0C\u8DF3\u8FC7 MinIO \u5F52\u6863: ${detail}`);
-    return null;
+  if (!existsSync12(p)) {
+    console.error(`\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF1A${p}`);
+    process.exit(1);
   }
   try {
-    const client = new MinioClient({
-      endPoint: storage.endpoint,
-      port: storage.port,
-      useSSL: storage.useSsl,
-      accessKey: storage.accessKey,
-      secretKey: storage.secretKey
-    });
-    await client.ensureBucket(storage.bucket);
-    await client.putObject(storage.bucket, objectKey, body, {
-      "Content-Type": "application/zip"
-    });
-    console.error(
-      `[apm] \u672C\u5730\u76F4\u4F20 MinIO\uFF08\u4E0D\u7ECF\u5E73\u53F0\u670D\u52A1\u5668\uFF09: ${storage.endpoint}:${storage.port}/${storage.bucket}/${objectKey} (${(body.length / 1024 / 1024).toFixed(
-        2
-      )} MB)`
-    );
-  } catch (error) {
-    const detail = error instanceof Error ? error.message : String(error);
-    console.warn(`[apm] MinIO \u90E8\u7F72\u4EA7\u7269\u5F52\u6863\u5931\u8D25: ${detail}`);
-    return null;
+    const raw = readFileSync11(p, "utf8");
+    return JSON.parse(raw);
+  } catch (e) {
+    console.error(`\u65E0\u6CD5\u89E3\u6790 apm.config.json\uFF1A${p}`, e);
+    process.exit(1);
   }
-  if (deploymentRunId) {
-    try {
-      await api.cli.attachTaskDeploymentArtifact({
-        id: deploymentRunId,
-        artifactObjectKey: objectKey,
-        artifactFileName: fileName
-      });
-      console.error(
-        `[apm] \u5DF2\u7ED1\u5B9A\u90E8\u7F72\u4EA7\u7269\u5230\u8BB0\u5F55 id=${deploymentRunId} file=${fileName}`
-      );
-    } catch (error) {
-      const detail = error instanceof Error ? error.message : String(error);
-      console.warn(`[apm] \u7ED1\u5B9A\u90E8\u7F72\u4EA7\u7269\u5230\u8BB0\u5F55\u5931\u8D25: ${detail}`);
-      return null;
-    }
+}
+
+// src/commands/deploy/internal/deploy-hints.ts
+function isProductionDeployEnv(env) {
+  const normalized = env.trim().toLowerCase();
+  return normalized === "online" || normalized === "production" || normalized === "prod";
+}
+function formatMissingWisdomDeployLines() {
+  return [
+    "[apm] \u65E0\u6CD5\u6267\u884C apm deploy\uFF1A\u8BF7\u5728 apm.config.json \u4E2D\u914D\u7F6E wisdomDeploy\uFF08host\u3001remotePath\uFF09"
+  ];
+}
+function formatWisdomFrontendBuildNotConfiguredLines(env, packageJsonPath) {
+  if (isProductionDeployEnv(env)) {
+    return [
+      `[apm] \u65E0\u6CD5\u6267\u884C\u524D\u7AEF\u90E8\u7F72\uFF1A${packageJsonPath} \u4E2D\u672A\u627E\u5230 build:${env} \u6216 build \u811A\u672C`,
+      "[apm] \u8BF7\u914D\u7F6E npm run build:online \u6216 npm run build \u540E\u518D\u8BD5"
+    ];
   }
-  return {
-    objectKey,
-    fileName,
-    bucket: storage.bucket
-  };
+  return [
+    `[apm] \u65E0\u6CD5\u6267\u884C\u524D\u7AEF\u90E8\u7F72\uFF1A${packageJsonPath} \u4E2D\u672A\u627E\u5230 build:${env} \u811A\u672C`,
+    "[apm] \u8BF7\u914D\u7F6E npm run build:test \u540E\u518D\u8BD5"
+  ];
 }
 
+// src/commands/deploy/deploy-errors.ts
+var DeployExecutionError = class extends Error {
+  exitCode;
+  output;
+  constructor(message, exitCode, output = "") {
+    super(message);
+    this.name = "DeployExecutionError";
+    this.exitCode = exitCode;
+    this.output = output;
+  }
+};
+
+// src/commands/deploy/deploy-debug-log.ts
+init_deploy_artifact_minio();
+import { spawnSync as spawnSync4 } from "node:child_process";
+import { existsSync as existsSync16 } from "node:fs";
+import { dirname as dirname5, join as join17 } from "node:path";
+
 // src/commands/deploy/internal/deploy-shell-env.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
 import { existsSync as existsSync15 } from "node:fs";
 import { dirname as dirname4, join as join16 } from "node:path";
 
 // src/commands/daemon.ts
+init_config();
 import { spawnSync as spawnSync2 } from "child_process";
 import { setTimeout as delay } from "node:timers/promises";
 import { existsSync as existsSync14, mkdirSync as mkdirSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync11 } from "fs";
 import { join as join15 } from "path";
 
 // src/commands/connect-lock.ts
+init_config();
 import {
   existsSync as existsSync13,
   mkdirSync as mkdirSync5,
@@ -4548,6 +5203,7 @@ function runDeployShellCommand(command, cwd, captureOutput) {
 
 // src/commands/deploy/internal/wisdom-backend/index.ts
 import path9 from "node:path";
+init_deploy_artifact_minio();
 
 // src/commands/deploy/internal/wisdom-backend/jar-incremental.ts
 import {
@@ -4616,6 +5272,8 @@ import SftpClient from "ssh2-sftp-client";
 import { readdir as readdir2, readFile as readFile3, unlink, writeFile } from "node:fs/promises";
 import path3 from "node:path";
 import JSZip from "jszip";
+init_deploy_artifact_minio();
+init_minio();
 async function addDirToZip(dir, zipFolder) {
   const entries = await readdir2(dir, { withFileTypes: true });
   for (const entry of entries) {
@@ -4704,6 +5362,7 @@ async function packDirectoryWithMinioArchive(input) {
 }
 
 // src/commands/deploy/internal/wisdom-sftp.ts
+init_deploy_artifact_minio();
 var SFTP_UPLOAD_MAX_ATTEMPTS = 3;
 var SFTP_FAST_PUT_OPTIONS = {
   chunkSize: 64 * 1024,
@@ -5703,6 +6362,8 @@ async function executeWisdomDeploy(options) {
 }
 
 // src/commands/deploy/internal/deploy-baseline-sync.ts
+init_client();
+init_config();
 var LOG_PREFIX2 = "[apm] \u90E8\u7F72\u524D\u57FA\u7EBF\u540C\u6B65:";
 function formatGitError(error) {
   return error instanceof Error ? error.message : String(error);
@@ -5910,6 +6571,9 @@ function printDeployExecutionError(error) {
   console.error(error.message);
 }
 
+// src/commands/deploy/platform/deploy-run-coordinator.ts
+init_deploy_artifact_minio();
+
 // src/commands/deploy/platform/deploy-console-capture.ts
 function captureDeployConsole(logSyncer) {
   const chunks = [];
@@ -6638,6 +7302,7 @@ function clearSessionAgentId(workdir, sessionId, user) {
 }
 
 // src/commands/connect/cursor-message-log.ts
+init_client();
 var CURSOR_MESSAGE_LOG_SYNC_INTERVAL_MS = 2e3;
 function createThrottledCursorMessageLogSync(cfg, ctx, onError) {
   let lastRunAt = 0;
@@ -6806,16 +7471,17 @@ ${payload}`;
 }
 
 // src/commands/connect/webide-merge-tools.ts
+init_client();
 function createMergeWebIdePullRequestsTool(options) {
   const { cfg, taskId } = options;
   return {
-    description: "Merge all open pull requests for this WebIDE task after conflicts are resolved locally and pushed. Call once with no arguments. Do NOT call if conflicts contradict the task requirements \u2014 report the conflict and fail instead.",
+    description: "Merge all open pull requests for this WebIDE task. Call once with confirmedConflictFree=true. No baseline sync or review is required before calling.",
     inputSchema: {
       type: "object",
       properties: {
         confirmedConflictFree: {
           type: "boolean",
-          description: "Must be true: you have checked each repo, resolved mergeable conflicts consistently with requirements, and pushed. If conflicts contradict requirements, do not call this tool."
+          description: "Must be true to confirm you intend to merge this task's open PRs now."
         }
       },
       required: ["confirmedConflictFree"]
@@ -6823,7 +7489,7 @@ function createMergeWebIdePullRequestsTool(options) {
     execute: async (args) => {
       if (args.confirmedConflictFree !== true) {
         throw new Error(
-          "MergeWebIdePullRequests \u8981\u6C42 confirmedConflictFree=true\u3002\u82E5\u5B58\u5728\u4E0E\u9700\u6C42\u76F8\u6096\u7684\u51B2\u7A81\uFF0C\u8BF7\u52FF\u8C03\u7528\u672C\u5DE5\u5177\uFF0C\u7528 AppendMessage \u8BF4\u660E\u5E76\u5931\u8D25\u7ED3\u675F\u3002"
+          "MergeWebIdePullRequests \u8981\u6C42 confirmedConflictFree=true\u3002"
         );
       }
       const api = createApmApiClient(cfg);
@@ -6835,6 +7501,7 @@ function createMergeWebIdePullRequestsTool(options) {
 }
 
 // src/commands/connect/webide-plan-tools.ts
+init_client();
 function asString(value) {
   return typeof value === "string" ? value.trim() : "";
 }
@@ -6877,7 +7544,7 @@ function createRecommendPlanTool(options) {
 function createUpsertWebIdePlanTool(options) {
   const { cfg, taskId } = options;
   return {
-    description: "Persist the implementation plan markdown for this WebIDE task and mark the plan as ready for human confirmation. Call once with the full plan document.",
+    description: "Persist or replace the implementation plan markdown for this WebIDE task and mark it ready for human confirmation. Call with the full plan document (not a diff). Use after generating or revising the plan.",
     inputSchema: {
       type: "object",
       properties: {
@@ -6904,6 +7571,7 @@ function createUpsertWebIdePlanTool(options) {
 }
 
 // src/commands/connect/webide-test-case-tools.ts
+init_client();
 function asString2(value) {
   return typeof value === "string" ? value.trim() : "";
 }
@@ -6988,6 +7656,165 @@ function createUpsertWebIdeTestCasesTool(options) {
   };
 }
 
+// src/commands/connect/webide-terminal-tools.ts
+init_client();
+function asString3(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function asPorts(value) {
+  if (!Array.isArray(value)) return void 0;
+  const ports = value.map((p) => typeof p === "number" ? p : Number(p)).filter((p) => Number.isFinite(p) && p > 0 && p < 65536).map((p) => Math.trunc(p));
+  return ports.length ? ports : void 0;
+}
+function createWebIdeTerminalTools(options) {
+  const { cfg, taskId, workdir, rpc } = options;
+  const StartWebIdeTerminal = {
+    description: "Start a long-running WebIDE terminal (e.g. frontend/backend dev server). Process outlives this message. Same key already RUNNING/READY returns idempotently. Do NOT use Shell for long-lived dev servers. Returns terminalId, pid, ports.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        key: {
+          type: "string",
+          description: "Stable key, e.g. frontend / backend"
+        },
+        name: { type: "string", description: "Display name" },
+        cwd: {
+          type: "string",
+          description: "Working directory (absolute or under workspace)"
+        },
+        command: {
+          type: "string",
+          description: "Shell command to run, e.g. pnpm dev"
+        },
+        readyPattern: {
+          type: "string",
+          description: "Optional regex; when matched in logs, status becomes READY"
+        },
+        portsHint: {
+          type: "array",
+          items: { type: "number" },
+          description: "Optional expected listen ports"
+        }
+      },
+      required: ["key", "cwd", "command"]
+    },
+    execute: async (args) => {
+      const key = asString3(args.key);
+      const cwd = asString3(args.cwd) || workdir;
+      const command = asString3(args.command);
+      if (!key || !command) {
+        return {
+          content: [{ type: "text", text: "key / command \u4E0D\u80FD\u4E3A\u7A7A" }],
+          isError: true
+        };
+      }
+      try {
+        const result = rpc ? await rpc.start({
+          taskId,
+          key,
+          name: asString3(args.name) || void 0,
+          cwd,
+          command,
+          readyPattern: asString3(args.readyPattern) || void 0,
+          portsHint: asPorts(args.portsHint)
+        }) : await (async () => {
+          throw new Error("Terminal RPC \u4E0D\u53EF\u7528\uFF08\u9700\u5728 connect \u4E3B\u8FDB\u7A0B\uFF09");
+        })();
+        return JSON.stringify(result, null, 2);
+      } catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `\u542F\u52A8\u7EC8\u7AEF\u5931\u8D25: ${detail}` }],
+          isError: true
+        };
+      }
+    }
+  };
+  const StopWebIdeTerminal = {
+    description: "Stop a WebIDE terminal and kill its process tree. Soft-terminates (status EXITED, record kept).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        key: { type: "string", description: "Terminal key" },
+        terminalId: { type: "string", description: "Server terminal id" }
+      }
+    },
+    execute: async (args) => {
+      const key = asString3(args.key) || void 0;
+      const terminalId = asString3(args.terminalId) || void 0;
+      if (!key && !terminalId) {
+        return {
+          content: [{ type: "text", text: "\u9700\u8981 key \u6216 terminalId" }],
+          isError: true
+        };
+      }
+      try {
+        const result = rpc ? await rpc.stop({ taskId, key, terminalId }) : await (async () => {
+          throw new Error("Terminal RPC \u4E0D\u53EF\u7528\uFF08\u9700\u5728 connect \u4E3B\u8FDB\u7A0B\uFF09");
+        })();
+        return JSON.stringify(result, null, 2);
+      } catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `\u505C\u6B62\u7EC8\u7AEF\u5931\u8D25: ${detail}` }],
+          isError: true
+        };
+      }
+    }
+  };
+  const StopAllWebIdeTerminals = {
+    description: "Stop all living WebIDE terminals for the current task (kill process trees). Use before re-running local dev to avoid port conflicts. Soft-terminates records.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    },
+    execute: async () => {
+      try {
+        const result = rpc ? await rpc.stopAll({ taskId }) : await (async () => {
+          throw new Error("Terminal RPC \u4E0D\u53EF\u7528\uFF08\u9700\u5728 connect \u4E3B\u8FDB\u7A0B\uFF09");
+        })();
+        return JSON.stringify(result, null, 2);
+      } catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `\u5168\u90E8\u505C\u6B62\u5931\u8D25: ${detail}` }],
+          isError: true
+        };
+      }
+    }
+  };
+  const ListWebIdeTerminals = {
+    description: "List living WebIDE terminals for the current task (STARTING/RUNNING/READY/STOPPING only). Does NOT include EXITED/FAILED. Returns id, key, status, pid, ports.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    },
+    execute: async () => {
+      try {
+        if (rpc) {
+          const result2 = await rpc.list({ taskId });
+          return JSON.stringify(result2, null, 2);
+        }
+        const api = createApmApiClient(cfg);
+        const result = await api.cli.webideListTerminals({ taskId });
+        return JSON.stringify(result, null, 2);
+      } catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `\u5217\u51FA\u7EC8\u7AEF\u5931\u8D25: ${detail}` }],
+          isError: true
+        };
+      }
+    }
+  };
+  return {
+    StartWebIdeTerminal,
+    StopWebIdeTerminal,
+    StopAllWebIdeTerminals,
+    ListWebIdeTerminals
+  };
+}
+
 // src/commands/connect/cursor-custom-tools.ts
 var PLAN_MODE_ASK_QUESTION_HINT = `[SDK \u73AF\u5883\u8BF4\u660E]
 AskQuestion \u5DF2\u901A\u8FC7 MCP \u670D\u52A1\u5668 custom-user-tools \u6CE8\u518C\uFF0C\u5DE5\u5177\u540D\u4E3A AskQuestion\u3002
@@ -7025,6 +7852,17 @@ function createCursorCustomTools(cfg, messageId, options) {
       cfg,
       taskId: options.taskId
     });
+    if (options.workdir) {
+      Object.assign(
+        tools,
+        createWebIdeTerminalTools({
+          cfg,
+          taskId: options.taskId,
+          workdir: options.workdir,
+          rpc: options.terminalRpc
+        })
+      );
+    }
   }
   return tools;
 }
@@ -7093,8 +7931,8 @@ async function obtainAgent(ctx) {
         settingSources: ["project"]
       } : {}
     },
-    ...ctx.mode ? { mode: ctx.mode } : {}
-    // mcpServers: createPlaywrightMcpServers(),
+    ...ctx.mode ? { mode: ctx.mode } : {},
+    ...ctx.mcpServers ? { mcpServers: ctx.mcpServers } : {}
   };
   const explicitAgentId = ctx.resumeAgentId?.trim();
   const savedAgentId = explicitAgentId || (ctx.user ? loadSessionAgentId(ctx.workdir, ctx.sessionId, ctx.user) : void 0);
@@ -7148,7 +7986,9 @@ async function runCursorAgent(cfg, ctx, options) {
     appendMessageContent: options?.appendMessageContent,
     askQuestionExecute: options?.askQuestionExecute,
     enableWebIdePlanTools: options?.enableWebIdePlanTools,
-    taskId: options?.taskId
+    taskId: options?.taskId,
+    workdir,
+    terminalRpc: options?.terminalRpc
   });
   const enableSandbox = Boolean(options?.enableSandbox);
   let prompt = withPlanModeToolHint(ctx.prompt, ctx.mode);
@@ -7189,7 +8029,6 @@ async function runCursorAgent(cfg, ctx, options) {
   try {
     const run = await agent.send(prompt, {
       ...ctx.mode ? { mode: ctx.mode } : {},
-      // mcpServers: createPlaywrightMcpServers(),
       local: {
         ...options?.forceSend ? { force: true } : {},
         customTools
@@ -7290,6 +8129,7 @@ async function runCursorAgent(cfg, ctx, options) {
 }
 
 // src/commands/connect/ensure-message-reply.ts
+init_client();
 var DEFAULT_REPLY = "\u4EFB\u52A1\u5DF2\u5B8C\u6210\u3002";
 function resolveMessageReplyFallback(fallback) {
   for (const candidate of [
@@ -7433,6 +8273,7 @@ function createRunSlotPool(maxConcurrent = DEFAULT_MAX_CONCURRENT, options = {})
 }
 
 // src/commands/connect/webide-worker-pool.ts
+init_webide_terminal_registry();
 import { Worker } from "node:worker_threads";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { dirname as dirname7, join as join20 } from "node:path";
@@ -7444,23 +8285,78 @@ function spawnWebIdeMessageWorker(cfg, msg) {
   const worker = new Worker(workerFile, {
     workerData: { cfg, msg }
   });
+  const registry = getWebIdeTerminalRegistry(cfg);
   let resolveDone;
   const done = new Promise((resolve7) => {
     resolveDone = resolve7;
   });
-  worker.on(
-    "message",
-    (m) => {
-      if (m?.type === "done" || m?.type === "error") {
-        if (m.type === "error") {
-          console.error(
-            `[apm] webide worker error messageId=${m.messageId}: ${m.error}`
-          );
+  worker.on("message", (m) => {
+    if (m?.type === "terminal-rpc") {
+      const rpc = m;
+      void (async () => {
+        try {
+          let result;
+          if (rpc.op === "start") {
+            result = await registry.start({
+              taskId: String(rpc.args.taskId ?? msg.taskId),
+              key: String(rpc.args.key ?? ""),
+              name: typeof rpc.args.name === "string" ? rpc.args.name : void 0,
+              cwd: String(rpc.args.cwd ?? msg.workdir),
+              command: String(rpc.args.command ?? ""),
+              readyPattern: typeof rpc.args.readyPattern === "string" ? rpc.args.readyPattern : void 0,
+              portsHint: Array.isArray(rpc.args.portsHint) ? rpc.args.portsHint : void 0
+            });
+          } else if (rpc.op === "stop") {
+            const terminalId = typeof rpc.args.terminalId === "string" ? rpc.args.terminalId : void 0;
+            const key = typeof rpc.args.key === "string" ? rpc.args.key : void 0;
+            const taskId = String(rpc.args.taskId ?? msg.taskId);
+            let id = terminalId;
+            if (!id && key) {
+              const local = registry.listLocal(taskId).find((t) => t.key === key);
+              id = local?.id;
+            }
+            if (!id) {
+              throw new Error("\u672A\u627E\u5230\u7EC8\u7AEF");
+            }
+            result = await registry.stop(id, { reason: "ai-stop" });
+          } else if (rpc.op === "stopAll") {
+            result = await registry.stopAllForTask(
+              String(rpc.args.taskId ?? msg.taskId),
+              "ai-stop-all"
+            );
+          } else {
+            result = {
+              terminals: registry.listLocal(
+                String(rpc.args.taskId ?? msg.taskId)
+              )
+            };
+          }
+          worker.postMessage({
+            type: "terminal-rpc-result",
+            id: rpc.id,
+            ok: true,
+            result
+          });
+        } catch (err) {
+          worker.postMessage({
+            type: "terminal-rpc-result",
+            id: rpc.id,
+            ok: false,
+            error: err instanceof Error ? err.message : String(err)
+          });
         }
-        void worker.terminate().finally(() => resolveDone());
+      })();
+      return;
+    }
+    if (m?.type === "done" || m?.type === "error") {
+      if (m.type === "error") {
+        console.error(
+          `[apm] webide worker error messageId=${m.messageId}: ${m.error}`
+        );
       }
+      void worker.terminate().finally(() => resolveDone());
     }
-  );
+  });
   worker.on("error", (err) => {
     console.error("[apm] webide worker crashed:", err);
     resolveDone();
@@ -7565,7 +8461,7 @@ async function handleInboundMessage(cfg, msg, signal, ctx) {
     if (!pullRan) {
       await runStep(
         "sync-project-documents-pull",
-        () => syncRepositoryProjectDocumentsPull(workdir, apmRoot)
+        () => syncProjectDocumentsPull(workdir, apmRoot)
       );
     }
     const agentResult = await runStep(
@@ -7598,7 +8494,7 @@ async function handleInboundMessage(cfg, msg, signal, ctx) {
     );
     await runStep(
       "sync-project-documents",
-      () => syncRepositoryProjectDocumentsPush(cfg, workdir, apmRoot)
+      () => syncProjectDocumentsPush(cfg, workdir, apmRoot)
     );
     await runStep(
       "commit-files",
@@ -7737,6 +8633,11 @@ function attachWsHandlers(ws, ctx, onOpen) {
       const msg2 = validated.data;
       const task2 = (async () => {
         const workdir = requireRemoteWorkdir(msg2.workdir);
+        const { getWebIdeTerminalRegistry: getWebIdeTerminalRegistry2 } = await Promise.resolve().then(() => (init_webide_terminal_registry(), webide_terminal_registry_exports));
+        await getWebIdeTerminalRegistry2(cfg).stopAllForTask(
+          msg2.taskId,
+          "cache-cleanup"
+        );
         cleanWebIdeWorkspaceCache(msg2.taskId, workdir);
       })();
       activeTasks.add(task2);
@@ -7745,6 +8646,21 @@ function attachWsHandlers(ws, ctx, onOpen) {
       });
       return;
     }
+    if (validated.data.type === "webide-terminal-stop") {
+      const msg2 = validated.data;
+      const task2 = (async () => {
+        const { getWebIdeTerminalRegistry: getWebIdeTerminalRegistry2 } = await Promise.resolve().then(() => (init_webide_terminal_registry(), webide_terminal_registry_exports));
+        await getWebIdeTerminalRegistry2(cfg).stop(msg2.terminalId, {
+          pid: msg2.pid,
+          reason: "web-stop"
+        });
+      })();
+      activeTasks.add(task2);
+      void task2.finally(() => {
+        activeTasks.delete(task2);
+      });
+      return;
+    }
     if (validated.data.type === "webide-message") {
       const msg2 = validated.data;
       const perMessageController2 = new AbortController();
@@ -8009,6 +8925,10 @@ async function runConnect(options) {
   }
 }
 
+// src/commands/create-pr.ts
+init_client();
+init_config();
+
 // src/commands/create-pr-errors.ts
 import { ApiError as ApiError2 } from "listpage-http";
 function extractMessage(error) {
@@ -8136,6 +9056,8 @@ async function runCreatePr(options) {
 }
 
 // src/commands/deploy/deploy-tracking.ts
+init_client();
+init_config();
 function normalizeDeployEnvironment(env) {
   const normalized = env.trim().toLowerCase();
   if (normalized === "test") return "TEST";
@@ -8805,6 +9727,7 @@ function registerDeployBackendCommands(program) {
 // src/commands/deploy/frontend.ts
 import { copyFile, readdir as readdir3, stat } from "node:fs/promises";
 import path17 from "node:path";
+init_minio();
 function artifactObjectKey(namePrefix, branchSegment, relativePath) {
   const base = sanitizeRelativePath(namePrefix);
   const rel = sanitizeRelativePath(relativePath);
@@ -8982,6 +9905,7 @@ function registerDeployFrontendCommands(program) {
 
 // src/commands/deploy/sftp.ts
 import path18 from "node:path";
+init_minio();
 function registerDeploySftpCommands(program) {
   program.command("deploy-sftp").description(
     "\u5C06\u6307\u5B9A\u76EE\u5F55\u538B\u7F29\u4E3A zip \u540E\u901A\u8FC7 SFTP \u4E0A\u4F20\u5230\u8FDC\u7A0B\u670D\u52A1\u5668\uFF08\u8FDE\u63A5\u4FE1\u606F\u89C1 apm.config.json wisdomDeploy\uFF09"
@@ -9107,12 +10031,12 @@ function buildProgram() {
     await runSyncDeployConfig();
   });
   program.command("sync-project-documents").description(
-    "\u540C\u6B65\u4ED3\u5E93\u9879\u76EE\u6587\u6863\uFF1A\u9ED8\u8BA4 pull \u5230 .apm/project/\uFF1B\u52A0 --push \u5C06\u672C\u5730\u53D8\u66F4\u63A8\u9001\u5230\u5E73\u53F0"
-  ).option("--push", "\u63A8\u9001\u672C\u5730 .apm/project/ \u5230\u5E73\u53F0").option("--pull", "\u4ECE\u5E73\u53F0\u62C9\u53D6\u5230 .apm/project/").action(async (opts) => {
+    "\u540C\u6B65\u9879\u76EE\u6587\u6863\uFF1A\u9ED8\u8BA4 pull \u5230 .apm/docs/\uFF1B\u52A0 --push \u5C06\u672C\u5730\u53D8\u66F4\u63A8\u9001\u5230\u5E73\u53F0"
+  ).option("--push", "\u63A8\u9001\u672C\u5730 .apm/docs/ \u5230\u5E73\u53F0").option("--pull", "\u4ECE\u5E73\u53F0\u62C9\u53D6\u5230 .apm/docs/").action(async (opts) => {
     await runSyncProjectDocuments(opts);
   });
   program.command("pull").description(
-    "\u62C9\u53D6\u6C9F\u901A\u7FA4\u6570\u636E\u5230 .apm/sessions/<sessionId>/\uFF0C\u5E76\u540C\u6B65\u90E8\u7F72\u914D\u7F6E\u4E0E\u4ED3\u5E93\u9879\u76EE\u6587\u6863\u5230 .apm/project/"
+    "\u62C9\u53D6\u6C9F\u901A\u7FA4\u6570\u636E\u5230 .apm/sessions/<sessionId>/\uFF0C\u5E76\u540C\u6B65\u90E8\u7F72\u914D\u7F6E\u4E0E\u9879\u76EE\u6587\u6863\u5230 .apm/docs/"
   ).argument("<sessionId>", "\u6C9F\u901A\u7FA4 ID").action(async (sessionId) => {
     await runPull(sessionId);
   });