@arcships/morula-runtime 0.1.0-alpha.2 → 0.1.0-alpha.3

package/dist/morula.js

@@ -0,0 +1,2749 @@
+#!/usr/bin/env node
+
+// ../morula-cli-core/dist/errors.js
+var EXIT = {
+  OK: 0,
+  OTHER: 1,
+  USAGE: 2,
+  NOT_FOUND: 3,
+  UNAUTHENTICATED: 4,
+  FORBIDDEN: 5,
+  CONFLICT: 6,
+  UPSTREAM: 7
+};
+var CliError = class extends Error {
+  code;
+  exitCode;
+  retryable;
+  hint;
+  didYouMean;
+  constructor(code, exitCode, message, retryable = false, details = {}) {
+    super(message);
+    this.code = code;
+    this.exitCode = exitCode;
+    this.retryable = retryable;
+    this.name = "CliError";
+    this.hint = details.hint;
+    this.didYouMean = details.didYouMean;
+  }
+};
+function usage(message, details = {}) {
+  return new CliError("USAGE", EXIT.USAGE, message, false, details);
+}
+
+// ../morula-cli-core/dist/args.js
+var GLOBAL_FLAG_NAMES = ["env", "url", "token", "help", "version", "json"];
+var SHORT_FLAG_ALIASES = {
+  h: "help",
+  v: "version"
+};
+function parseArgs(argv) {
+  const positionals = [];
+  const flags = {};
+  const bareFlags = [];
+  let positionalOnly = false;
+  for (let index = 0; index < argv.length; index += 1) {
+    const value = argv[index];
+    if (positionalOnly) {
+      positionals.push(value);
+      continue;
+    }
+    if (value === "--") {
+      positionalOnly = true;
+      continue;
+    }
+    if (!value.startsWith("--")) {
+      if (value.length === 2 && value.startsWith("-") && SHORT_FLAG_ALIASES[value[1]]) {
+        flags[SHORT_FLAG_ALIASES[value[1]]] = true;
+        continue;
+      }
+      positionals.push(value);
+      continue;
+    }
+    const equal = value.indexOf("=");
+    if (equal > 2) {
+      flags[value.slice(2, equal)] = value.slice(equal + 1);
+      continue;
+    }
+    const key = value.slice(2);
+    if (!key)
+      throw usage("invalid empty flag");
+    const next = argv[index + 1];
+    if (next !== void 0 && !next.startsWith("--")) {
+      flags[key] = next;
+      index += 1;
+    } else {
+      flags[key] = true;
+      bareFlags.push(key);
+    }
+  }
+  return {
+    command: positionals.shift(),
+    action: positionals.shift(),
+    positionals,
+    flags,
+    bareFlags
+  };
+}
+function flagString(flags, ...names) {
+  for (const name of names) {
+    const value = flags[name];
+    if (typeof value === "string" && value.trim())
+      return value.trim();
+  }
+  return void 0;
+}
+function flagBoolean(flags, name) {
+  const value = flags[name];
+  return value === true || value === "true" || value === "1";
+}
+function flagNumber(flags, name) {
+  const raw = flagString(flags, name);
+  if (raw === void 0)
+    return void 0;
+  const value = Number(raw);
+  if (!Number.isFinite(value))
+    throw usage(`--${name} must be a number`);
+  return value;
+}
+function requireFlag(flags, name) {
+  const value = flagString(flags, name);
+  if (!value)
+    throw usage(`missing required flag --${name}`);
+  return value;
+}
+function rejectUnknownFlags(flags, allowed) {
+  const known = /* @__PURE__ */ new Set([...GLOBAL_FLAG_NAMES, ...allowed]);
+  const unknown = Object.keys(flags).find((flag) => !known.has(flag));
+  if (unknown)
+    throw usage(`unknown flag --${unknown}`);
+}
+
+// ../morula-cli-core/dist/auth/browser.js
+import { spawn } from "node:child_process";
+function openBrowser(url, env = process.env) {
+  if (env.MORULA_NO_BROWSER === "1")
+    return false;
+  const platform = process.platform;
+  let command;
+  let args;
+  let detached = true;
+  if (platform === "win32") {
+    const statement = `Start-Process '${url.replace(/'/g, "''")}'`;
+    command = `${env.SYSTEMROOT ?? env.windir ?? "C:\\Windows"}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+    args = ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-EncodedCommand", Buffer.from(statement, "utf16le").toString("base64")];
+    detached = false;
+  } else {
+    command = platform === "darwin" ? "open" : "xdg-open";
+    args = [url];
+  }
+  try {
+    const child = spawn(command, args, {
+      detached,
+      stdio: "ignore",
+      windowsHide: true,
+      windowsVerbatimArguments: platform === "win32"
+    });
+    child.on("error", () => {
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ../morula-cli-core/dist/auth/callback-server.js
+import { createServer } from "node:http";
+async function startCallbackServer(expectedState) {
+  let settleCode;
+  let rejectCode;
+  let settled = false;
+  const codePromise = new Promise((resolve, reject) => {
+    settleCode = resolve;
+    rejectCode = reject;
+  });
+  const server = createServer((request, response) => {
+    const url = new URL(request.url ?? "/", "http://127.0.0.1");
+    response.setHeader("content-type", "text/html; charset=utf-8");
+    response.setHeader("cache-control", "no-store");
+    response.setHeader("x-content-type-options", "nosniff");
+    if (url.pathname !== "/callback") {
+      response.statusCode = 404;
+      response.end("Not found");
+      return;
+    }
+    const state = url.searchParams.get("state");
+    if (state !== expectedState) {
+      response.statusCode = 400;
+      response.end(page(false, "\u767B\u5F55\u56DE\u8C03\u6821\u9A8C\u5931\u8D25\uFF0C\u8BF7\u8FD4\u56DE\u7EC8\u7AEF\u91CD\u8BD5\u3002"));
+      return;
+    }
+    if (settled) {
+      response.statusCode = 409;
+      response.end(page(false, "\u8BE5\u767B\u5F55\u56DE\u8C03\u5DF2\u5904\u7406\uFF0C\u8BF7\u8FD4\u56DE\u7EC8\u7AEF\u3002"));
+      return;
+    }
+    const error = url.searchParams.get("error");
+    const code = url.searchParams.get("code");
+    settled = true;
+    if (error) {
+      response.statusCode = 400;
+      response.end(page(false, "SkyDoor \u767B\u5F55\u672A\u5B8C\u6210\uFF0C\u8BF7\u8FD4\u56DE\u7EC8\u7AEF\u91CD\u8BD5\u3002"));
+      rejectCode(new CliError("LOGIN_FAILED", EXIT.OTHER, "SkyDoor login failed"));
+      return;
+    }
+    if (!code) {
+      response.statusCode = 400;
+      response.end(page(false, "\u767B\u5F55\u56DE\u8C03\u7F3A\u5C11\u6388\u6743\u7801\uFF0C\u8BF7\u8FD4\u56DE\u7EC8\u7AEF\u91CD\u8BD5\u3002"));
+      rejectCode(new CliError("LOGIN_FAILED", EXIT.OTHER, "invalid login callback (missing code)"));
+      return;
+    }
+    response.statusCode = 200;
+    response.end(page(true, "\u8EAB\u4EFD\u9A8C\u8BC1\u5DF2\u5B8C\u6210\uFF0C\u6388\u6743\u7ED3\u679C\u5DF2\u7ECF\u5B89\u5168\u53D1\u9001\u81F3 Morula CLI\u3002"));
+    settleCode(code);
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", resolve);
+  });
+  const port = server.address().port;
+  return {
+    redirectUri: `http://127.0.0.1:${port}/callback`,
+    waitForCode(timeoutMs = 3e5) {
+      if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
+        return Promise.reject(new CliError("LOGIN_TIMEOUT", EXIT.OTHER, "login timeout must be a positive number"));
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new CliError("LOGIN_TIMEOUT", EXIT.OTHER, "timed out waiting for browser login")), timeoutMs);
+        timer.unref?.();
+        codePromise.then((code) => {
+          clearTimeout(timer);
+          resolve(code);
+        }, (error) => {
+          clearTimeout(timer);
+          reject(error);
+        });
+      });
+    },
+    close() {
+      return new Promise((resolve) => server.close(() => resolve()));
+    }
+  };
+}
+function escapeHtml(value) {
+  const entities = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;"
+  };
+  return value.replace(/[&<>"']/g, (character) => entities[character] ?? character);
+}
+function page(ok, message) {
+  const safeMessage = escapeHtml(message);
+  const statusLight = ok ? "oklch(0.42 0.085 183)" : "oklch(0.577 0.245 27.325)";
+  const statusDark = ok ? "oklch(0.72 0.09 183)" : "oklch(0.704 0.191 22.216)";
+  const statusIcon = ok ? '<svg viewBox="0 0 24 24" aria-hidden="true"><path class="status-path" d="m5 12.5 4.25 4.25L19 7"/></svg>' : '<svg viewBox="0 0 24 24" aria-hidden="true"><path class="status-path" d="M18 6 6 18"/><path class="status-path status-path-delay" d="m6 6 12 12"/></svg>';
+  const terminalIcon = '<svg viewBox="0 0 24 24" aria-hidden="true"><path d="m5 7 4 4-4 4"/><path d="M11 17h8"/></svg>';
+  return `<!doctype html>
+<html lang="zh-CN">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<meta name="color-scheme" content="light dark">
+<title>${ok ? "\u6D4F\u89C8\u5668\u9A8C\u8BC1\u5B8C\u6210" : "\u767B\u5F55\u9A8C\u8BC1\u672A\u5B8C\u6210"} \xB7 Morula CLI</title>
+<style>
+  :root {
+    color-scheme: light;
+    --background: oklch(0.982 0.006 95);
+    --foreground: oklch(0.205 0.012 248);
+    --card: oklch(0.997 0.002 95);
+    --primary: oklch(0.42 0.085 183);
+    --primary-foreground: oklch(0.985 0.006 95);
+    --muted: oklch(0.944 0.009 95);
+    --muted-foreground: oklch(0.48 0.018 248);
+    --accent: oklch(0.925 0.018 183);
+    --border: oklch(0.91 0.005 95);
+    --status: ${statusLight};
+    --status-soft: color-mix(in oklch, var(--status) 10%, var(--card));
+    --shadow-card: 0 0 0 1px hsl(210 18% 16% / 0.06), 0 14px 28px -18px hsl(210 18% 16% / 0.28);
+    --radius: 8px;
+  }
+
+  *, *::before, *::after { box-sizing: border-box; }
+  * { margin: 0; }
+
+  html, body { min-height: 100%; }
+
+  body {
+    min-width: 320px;
+    background: var(--background);
+    color: var(--foreground);
+    font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif;
+    font-feature-settings: "cv02", "cv03", "cv04", "cv11";
+    text-rendering: optimizeLegibility;
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+  }
+
+  .shell {
+    display: grid;
+    grid-template-columns: minmax(420px, 1.08fr) minmax(480px, 0.92fr);
+    min-height: 100vh;
+    min-height: 100svh;
+  }
+
+  .brand-panel {
+    position: relative;
+    display: flex;
+    min-height: 100vh;
+    min-height: 100svh;
+    flex-direction: column;
+    justify-content: space-between;
+    overflow: hidden;
+    border-right: 1px solid color-mix(in oklch, var(--border) 60%, transparent);
+    background: var(--card);
+    padding: clamp(40px, 4vw, 64px);
+  }
+
+  .brand-panel::before {
+    position: absolute;
+    inset: 0;
+    background: linear-gradient(180deg, color-mix(in oklch, var(--accent) 45%, transparent), transparent 42%);
+    content: "";
+    pointer-events: none;
+  }
+
+  .brand-panel::after {
+    position: absolute;
+    top: 40px;
+    right: 0;
+    bottom: 40px;
+    width: 1px;
+    background: linear-gradient(to bottom, transparent, var(--border), transparent);
+    content: "";
+    pointer-events: none;
+  }
+
+  .brand, .brand-copy, .brand-footer { position: relative; z-index: 1; }
+
+  .brand {
+    display: inline-flex;
+    align-items: center;
+    gap: 12px;
+    width: fit-content;
+  }
+
+  .brand-logo {
+    display: grid;
+    width: 40px;
+    height: 40px;
+    place-items: center;
+    border-radius: var(--radius);
+    background: var(--primary);
+    color: var(--primary-foreground);
+    font-size: 18px;
+    font-weight: 800;
+    letter-spacing: -0.02em;
+  }
+
+  .brand-name { font-size: 20px; font-weight: 600; line-height: 1.15; }
+
+  .brand-product {
+    margin-top: 4px;
+    color: var(--muted-foreground);
+    font-size: 12px;
+    font-weight: 500;
+    letter-spacing: 0.12em;
+    text-transform: uppercase;
+  }
+
+  .brand-copy { width: min(100%, 580px); }
+
+  .brand-kicker {
+    display: inline-flex;
+    align-items: center;
+    min-height: 32px;
+    border: 1px solid color-mix(in oklch, var(--border) 60%, transparent);
+    border-radius: 6px;
+    background: color-mix(in oklch, var(--muted) 45%, transparent);
+    padding: 6px 12px;
+    color: var(--muted-foreground);
+    font-size: 14px;
+    font-weight: 550;
+  }
+
+  .brand-headline {
+    margin-top: 28px;
+    max-width: 560px;
+    font-size: clamp(42px, 4vw, 60px);
+    font-weight: 600;
+    letter-spacing: -0.035em;
+    line-height: 1.12;
+    text-wrap: balance;
+  }
+
+  .brand-description {
+    margin-top: 20px;
+    max-width: 530px;
+    color: var(--muted-foreground);
+    font-size: 17px;
+    line-height: 1.8;
+    text-wrap: pretty;
+  }
+
+  .connection {
+    display: flex;
+    width: min(100%, 530px);
+    align-items: center;
+    gap: 12px;
+    margin-top: 32px;
+    border: 1px solid color-mix(in oklch, var(--border) 60%, transparent);
+    border-radius: var(--radius);
+    background: var(--card);
+    padding: 14px 16px;
+    box-shadow: 0 1px 3px hsl(210 18% 16% / 0.05);
+  }
+
+  .connection-icon, .next-step-icon {
+    display: grid;
+    flex: 0 0 auto;
+    place-items: center;
+    border-radius: 6px;
+    background: var(--muted);
+    color: var(--muted-foreground);
+  }
+
+  .connection-icon { width: 36px; height: 36px; }
+  .connection-icon svg, .next-step-icon svg { width: 18px; height: 18px; fill: none; stroke: currentColor; stroke-width: 1.8; stroke-linecap: round; stroke-linejoin: round; }
+
+  .connection-copy { min-width: 0; }
+  .connection-copy span { display: block; color: var(--muted-foreground); font-size: 11px; font-weight: 600; letter-spacing: 0.08em; text-transform: uppercase; }
+  .connection-copy strong { display: block; margin-top: 3px; font-size: 14px; font-weight: 600; }
+
+  .secure-label {
+    margin-left: auto;
+    border-radius: 999px;
+    background: var(--accent);
+    padding: 5px 9px;
+    color: var(--primary);
+    font-size: 12px;
+    font-weight: 600;
+    white-space: nowrap;
+  }
+
+  .brand-footer { color: var(--muted-foreground); font-size: 13px; font-weight: 500; }
+
+  .result-panel {
+    display: grid;
+    min-height: 100vh;
+    min-height: 100svh;
+    place-items: center;
+    background: var(--background);
+    padding: clamp(28px, 5vw, 72px);
+  }
+
+  .result-wrap { width: min(100%, 448px); }
+
+  .mobile-brand {
+    display: none;
+    align-items: center;
+    gap: 10px;
+    margin-bottom: 24px;
+  }
+
+  .mobile-brand .brand-logo { width: 36px; height: 36px; font-size: 16px; }
+  .mobile-brand .brand-name { font-size: 17px; }
+
+  .status-card {
+    width: 100%;
+    overflow: hidden;
+    border: 1px solid color-mix(in oklch, var(--border) 60%, transparent);
+    border-radius: var(--radius);
+    background: var(--card);
+    box-shadow: var(--shadow-card);
+    animation: card-in 420ms cubic-bezier(0.23, 1, 0.32, 1) both;
+  }
+
+  .status-content { padding: 32px; }
+
+  .status-header {
+    display: flex;
+    align-items: center;
+    gap: 14px;
+  }
+
+  .status-icon {
+    display: grid;
+    width: 52px;
+    height: 52px;
+    flex: 0 0 auto;
+    place-items: center;
+    border-radius: 10px;
+    background: var(--status-soft);
+    color: var(--status);
+  }
+
+  .status-icon svg {
+    width: 26px;
+    height: 26px;
+    fill: none;
+    stroke: currentColor;
+    stroke-width: 2.25;
+    stroke-linecap: round;
+    stroke-linejoin: round;
+  }
+
+  .status-path {
+    stroke-dasharray: 30;
+    stroke-dashoffset: 30;
+    animation: draw-path 380ms 180ms cubic-bezier(0.23, 1, 0.32, 1) forwards;
+  }
+
+  .status-path-delay { animation-delay: 260ms; }
+
+  .status-eyebrow {
+    color: var(--muted-foreground);
+    font-size: 11px;
+    font-weight: 600;
+    letter-spacing: 0.1em;
+    text-transform: uppercase;
+  }
+
+  .status-label { margin-top: 5px; color: var(--status); font-size: 14px; font-weight: 600; }
+
+  h1 {
+    margin-top: 28px;
+    font-size: 28px;
+    font-weight: 600;
+    letter-spacing: -0.022em;
+    line-height: 1.25;
+    text-wrap: balance;
+  }
+
+  .message {
+    margin-top: 12px;
+    color: var(--muted-foreground);
+    font-size: 15px;
+    line-height: 1.75;
+    text-wrap: pretty;
+  }
+
+  .next-step {
+    display: flex;
+    gap: 12px;
+    margin-top: 28px;
+    border: 1px solid color-mix(in oklch, var(--border) 60%, transparent);
+    border-radius: var(--radius);
+    background: color-mix(in oklch, var(--muted) 52%, transparent);
+    padding: 16px;
+  }
+
+  .next-step-icon { width: 36px; height: 36px; background: var(--card); color: var(--foreground); }
+  .next-step-copy { min-width: 0; }
+  .next-step-copy span, .next-step-copy strong { display: block; }
+  .next-step-copy span { color: var(--muted-foreground); font-size: 12px; line-height: 1.55; }
+  .next-step-copy strong { margin: 2px 0 4px; font-size: 14px; font-weight: 600; }
+
+  .status-footer {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    border-top: 1px solid color-mix(in oklch, var(--border) 60%, transparent);
+    padding: 16px 32px;
+    color: var(--muted-foreground);
+    font-size: 12px;
+    font-weight: 500;
+  }
+
+  .status-dot { width: 7px; height: 7px; border-radius: 50%; background: var(--status); box-shadow: 0 0 0 4px var(--status-soft); }
+
+  @keyframes card-in {
+    from { opacity: 0; transform: translateY(10px); }
+    to { opacity: 1; transform: translateY(0); }
+  }
+
+  @keyframes draw-path { to { stroke-dashoffset: 0; } }
+
+  @media (max-width: 1023px) {
+    .shell { display: block; }
+    .brand-panel { display: none; }
+    .result-panel { padding: 32px 20px; }
+    .mobile-brand { display: flex; }
+  }
+
+  @media (max-width: 420px) {
+    .result-panel { align-items: center; padding: 24px 16px; }
+    .status-content { padding: 26px 24px; }
+    .status-footer { padding: 15px 24px; }
+    h1 { font-size: 25px; }
+    .message { font-size: 14px; }
+    .next-step { margin-top: 24px; padding: 14px; }
+  }
+
+  @media (prefers-color-scheme: dark) {
+    :root {
+      color-scheme: dark;
+      --background: oklch(0.165 0.008 248);
+      --foreground: oklch(0.948 0.006 95);
+      --card: oklch(0.205 0.01 248);
+      --primary: oklch(0.72 0.09 183);
+      --primary-foreground: oklch(0.16 0.014 248);
+      --muted: oklch(0.255 0.012 248);
+      --muted-foreground: oklch(0.69 0.012 248);
+      --accent: oklch(0.29 0.025 183);
+      --border: oklch(0.275 0.01 248);
+      --status: ${statusDark};
+      --status-soft: color-mix(in oklch, var(--status) 12%, var(--card));
+      --shadow-card: 0 0 0 1px hsl(0 0% 100% / 0.085);
+    }
+    .connection { box-shadow: 0 0 0 1px hsl(0 0% 100% / 0.04); }
+  }
+
+  @media (prefers-reduced-motion: reduce) {
+    *, *::before, *::after {
+      scroll-behavior: auto !important;
+      animation-duration: 0.01ms !important;
+      animation-delay: 0ms !important;
+      animation-iteration-count: 1 !important;
+      transition-duration: 0.01ms !important;
+    }
+  }
+</style>
+</head>
+<body>
+<div class="shell">
+  <aside class="brand-panel" aria-label="Morula \u54C1\u724C\u4ECB\u7ECD">
+    <div class="brand">
+      <div class="brand-logo" aria-hidden="true">S</div>
+      <div>
+        <div class="brand-name">Morula</div>
+        <div class="brand-product">Project OS</div>
+      </div>
+    </div>
+
+    <div class="brand-copy">
+      <div class="brand-kicker">\u9762\u5411\u56E2\u961F\u7684\u8F7B\u91CF\u9879\u76EE\u534F\u540C\u5E73\u53F0</div>
+      <p class="brand-headline">\u8BA9\u9879\u76EE\u63A8\u8FDB<br>\u66F4\u6E05\u6670\u3001\u66F4\u4ECE\u5BB9</p>
+      <p class="brand-description">\u7EDF\u4E00\u7A7A\u95F4\u3001\u4EFB\u52A1\u3001\u6210\u5458\u4E0E\u8FDB\u5EA6\u4E0A\u4E0B\u6587\uFF0C\u628A\u56E2\u961F\u534F\u4F5C\u4ECE\u96F6\u6563\u6C9F\u901A\u5E26\u56DE\u53EF\u8FFD\u8E2A\u7684\u5DE5\u4F5C\u6D41\u3002</p>
+      <div class="connection">
+        <div class="connection-icon">${terminalIcon}</div>
+        <div class="connection-copy">
+          <span>\u8FDE\u63A5\u65B9\u5F0F</span>
+          <strong>Morula CLI</strong>
+        </div>
+        <div class="secure-label">\u5B89\u5168\u8BA4\u8BC1</div>
+      </div>
+    </div>
+
+    <div class="brand-footer">\xA9 ${(/* @__PURE__ */ new Date()).getFullYear()} Morula \u9879\u76EE\u534F\u540C\u5E73\u53F0</div>
+  </aside>
+
+  <main class="result-panel" aria-labelledby="result-title">
+    <div class="result-wrap">
+      <div class="mobile-brand">
+        <div class="brand-logo" aria-hidden="true">S</div>
+        <div>
+          <div class="brand-name">Morula</div>
+          <div class="brand-product">\u9879\u76EE\u534F\u540C\u5E73\u53F0</div>
+        </div>
+      </div>
+
+      <section class="status-card">
+        <div class="status-content">
+          <div class="status-header">
+            <div class="status-icon">${statusIcon}</div>
+            <div>
+              <div class="status-eyebrow">Morula CLI</div>
+              <div class="status-label">${ok ? "\u8EAB\u4EFD\u8BA4\u8BC1\u5DF2\u786E\u8BA4" : "\u8EAB\u4EFD\u8BA4\u8BC1\u672A\u5B8C\u6210"}</div>
+            </div>
+          </div>
+
+          <h1 id="result-title">${ok ? "\u6D4F\u89C8\u5668\u9A8C\u8BC1\u5B8C\u6210" : "\u672A\u80FD\u5B8C\u6210\u9A8C\u8BC1"}</h1>
+          <p class="message">${safeMessage}</p>
+
+          <div class="next-step">
+            <div class="next-step-icon">${terminalIcon}</div>
+            <div class="next-step-copy">
+              <span>\u4E0B\u4E00\u6B65</span>
+              <strong>${ok ? "\u8FD4\u56DE Morula CLI" : "\u56DE\u5230\u7EC8\u7AEF\u91CD\u65B0\u767B\u5F55"}</strong>
+              <span>${ok ? "\u7EC8\u7AEF\u5C06\u7EE7\u7EED\u5B8C\u6210\u767B\u5F55\uFF0C\u5E76\u663E\u793A\u6700\u7EC8\u7ED3\u679C\u3002" : "\u8BF7\u56DE\u5230\u7EC8\u7AEF\u91CD\u65B0\u8FD0\u884C\u767B\u5F55\u547D\u4EE4\uFF08auth login\uFF09\uFF0C\u518D\u6B21\u5B8C\u6210\u6D4F\u89C8\u5668\u9A8C\u8BC1\u3002"}</span>
+            </div>
+          </div>
+        </div>
+
+        <div class="status-footer">
+          <span class="status-dot" aria-hidden="true"></span>
+          ${ok ? "\u6388\u6743\u56DE\u8C03\u5DF2\u8FD4\u56DE\u672C\u5730\u7EC8\u7AEF" : "\u672C\u6B21\u6388\u6743\u56DE\u8C03\u672A\u88AB\u63A5\u53D7"}
+        </div>
+      </section>
+    </div>
+  </main>
+</div>
+</body>
+</html>`;
+}
+
+// ../morula-cli-core/dist/build-env.js
+var BUILD_VERSION = "0.1.0-alpha.3";
+var BUILD_ID = "20260914094501.nogit";
+var BUILD_CONTEXTS = {
+  "local": "http://localhost:8080/api",
+  "test": "https://morula.basecastle.com/api",
+  "prod": "https://morula.fazhiplus.com/api"
+};
+var BUILD_DEFAULT_CONTEXT = "prod";
+
+// ../morula-api-client/dist/attachment.js
+var AttachmentApi = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /** 获取 TUS 上传签名 */
+  getUploadSignature() {
+    return this.client.post("/attachments/upload-signature");
+  }
+  /**
+   * 智能体通用文件上传：上传本机文件字节并挂附件。
+   * 走 multipart/form-data，服务端接收后上传存储并创建附件记录。
+   * 智能归并：不传 resourceType/resourceId 时，服务端按任务绑定对象决定——有 object 挂 object，纯对话挂 Chat 会话最新消息(ag_message)。
+   */
+  upload(input) {
+    const form = new FormData();
+    const blob = input.file instanceof Blob ? input.file : new Blob([input.file], { type: input.fileType });
+    form.append("file", blob, input.fileName);
+    if (input.resourceType)
+      form.append("resourceType", input.resourceType);
+    if (input.resourceId)
+      form.append("resourceId", input.resourceId);
+    if (input.taskId)
+      form.append("taskId", input.taskId);
+    if (input.isInline !== void 0)
+      form.append("isInline", input.isInline ? "true" : "false");
+    return this.client.post("/agent/attachments/upload", form);
+  }
+  /** 创建附件记录（上传完成后调用） */
+  create(input) {
+    return this.client.post("/attachments", input);
+  }
+  /** 按资源查询附件列表 */
+  list(query) {
+    return this.client.get("/attachments", query);
+  }
+  /** 获取附件详情 */
+  get(id) {
+    return this.client.get(`/attachments/${encodeURIComponent(id)}`);
+  }
+  /** 获取附件下载 URL */
+  getDownloadUrl(id) {
+    return this.client.get(`/attachments/${encodeURIComponent(id)}/download-url`);
+  }
+  /** 更新附件关联的资源 ID */
+  updateResourceId(id, resourceId) {
+    return this.client.patch(`/attachments/${encodeURIComponent(id)}`, { resourceId });
+  }
+  /** 删除附件 */
+  delete(id) {
+    return this.client.delete(`/attachments/${encodeURIComponent(id)}`);
+  }
+};
+
+// ../morula-api-client/dist/auth.js
+var AuthApi = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  authorize(query) {
+    return this.client.get("/auth/cli/authorize", query);
+  }
+  exchangeToken(input) {
+    return this.client.post("/auth/cli/token", input);
+  }
+  revokeCliToken() {
+    return this.client.post("/auth/cli/logout");
+  }
+  profile() {
+    return this.client.get("/auth/profile");
+  }
+};
+
+// ../morula-api-client/dist/client.js
+var EXIT_CODE = {
+  OK: 0,
+  OTHER: 1,
+  USAGE: 2,
+  NOT_FOUND: 3,
+  UNAUTHENTICATED: 4,
+  FORBIDDEN: 5,
+  CONFLICT: 6,
+  UPSTREAM: 7
+};
+var MorulaApiError = class extends Error {
+  code;
+  exitCode;
+  status;
+  retryable;
+  details;
+  name = "MorulaApiError";
+  constructor(code, message, exitCode, status2, retryable = false, details) {
+    super(message);
+    this.code = code;
+    this.exitCode = exitCode;
+    this.status = status2;
+    this.retryable = retryable;
+    this.details = details;
+  }
+};
+var CLI_BUILD_HEADER = "X-Morula-Cli-Build";
+var CLI_CAPS_HEADER = "X-Morula-Cli-Caps";
+var CLI_BUILD_MAX_LENGTH = 64;
+var CLI_CAPS_MAX_LENGTH = 255;
+var DEFAULT_TIMEOUT_MS = 3e4;
+var MorulaApiClient = class {
+  baseUrl;
+  token;
+  timeoutMs;
+  fetchImpl;
+  defaultHeaders;
+  constructor(options) {
+    const baseUrl = options.baseUrl.trim().replace(/\/+$/, "");
+    if (!baseUrl) {
+      throw new TypeError("baseUrl is required");
+    }
+    let parsed;
+    try {
+      parsed = new URL(baseUrl);
+    } catch {
+      throw new TypeError(`baseUrl must be an absolute URL: ${baseUrl}`);
+    }
+    if (!["http:", "https:"].includes(parsed.protocol)) {
+      throw new TypeError("baseUrl must use http or https");
+    }
+    this.baseUrl = parsed.toString().replace(/\/+$/, "");
+    this.token = options.token;
+    this.timeoutMs = positiveTimeout(options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+    if (typeof this.fetchImpl !== "function") {
+      throw new TypeError("fetch is unavailable; provide options.fetch");
+    }
+    const build = sanitizeHeaderValue(options.clientBuild, CLI_BUILD_MAX_LENGTH);
+    const caps = sanitizeHeaderValue(options.clientCaps, CLI_CAPS_MAX_LENGTH);
+    this.defaultHeaders = {
+      // CLI 身份头（P0-③）：仅当调用方声明时注入——未声明的调用方（runtime/测试/第三方复用）
+      // 发出的请求不带这两个头，服务端按「未知」处理，不误报陈旧构建。
+      ...build ? { [CLI_BUILD_HEADER]: build } : {},
+      ...caps ? { [CLI_CAPS_HEADER]: caps } : {},
+      // 显式 headers 优先级最高（更具体的调用方可以覆盖默认值）
+      ...options.headers
+    };
+  }
+  buildUrl(path, query) {
+    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+    const url = new URL(`${this.baseUrl}${normalizedPath}`);
+    if (!query)
+      return url;
+    for (const [key, raw] of Object.entries(query)) {
+      const values = Array.isArray(raw) ? raw : [raw];
+      for (const value of values) {
+        if (value !== void 0 && value !== null && value !== "") {
+          url.searchParams.append(key, String(value));
+        }
+      }
+    }
+    return url;
+  }
+  async request(path, options = {}) {
+    const method = options.method ?? "GET";
+    const url = this.buildUrl(path, options.query);
+    const headers = {
+      Accept: "application/json",
+      ...this.defaultHeaders,
+      ...options.headers
+    };
+    const token = options.token === void 0 ? this.token : options.token;
+    if (token)
+      headers.Authorization = `Bearer ${token}`;
+    let body;
+    if (options.body !== void 0) {
+      if (typeof FormData !== "undefined" && options.body instanceof FormData) {
+        delete headers["Content-Type"];
+        body = options.body;
+      } else {
+        headers["Content-Type"] ??= "application/json";
+        body = JSON.stringify(options.body);
+      }
+    }
+    const controller = new AbortController();
+    const timeoutMs = positiveTimeout(options.timeoutMs ?? this.timeoutMs);
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    timer.unref?.();
+    try {
+      const response = await this.fetchImpl(url, {
+        method,
+        headers,
+        body,
+        signal: controller.signal
+      });
+      const raw = await response.text();
+      const parsed = parseBody(raw);
+      if (!response.ok) {
+        throw errorFromResponse(response.status, parsed, raw);
+      }
+      return unwrapEnvelope(parsed, response.status);
+    } catch (error) {
+      if (error instanceof MorulaApiError)
+        throw error;
+      if (controller.signal.aborted) {
+        throw new MorulaApiError("TIMEOUT", `request timed out after ${timeoutMs}ms`, EXIT_CODE.UPSTREAM, void 0, true);
+      }
+      throw new MorulaApiError("NETWORK", `request failed: ${error instanceof Error ? error.message : String(error)}`, EXIT_CODE.UPSTREAM, void 0, true);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  get(path, query) {
+    return this.request(path, { query });
+  }
+  post(path, body, query) {
+    return this.request(path, { method: "POST", body, query });
+  }
+  patch(path, body, query) {
+    return this.request(path, { method: "PATCH", body, query });
+  }
+  delete(path, query) {
+    return this.request(path, { method: "DELETE", query });
+  }
+};
+function sanitizeHeaderValue(raw, maxLength) {
+  if (!raw)
+    return void 0;
+  let value = "";
+  for (const char of raw) {
+    const code = char.codePointAt(0) ?? 0;
+    if (code <= 31 || code === 127)
+      continue;
+    value += char;
+  }
+  value = value.trim();
+  return value ? value.slice(0, maxLength) : void 0;
+}
+function positiveTimeout(value) {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new TypeError("timeoutMs must be a positive number");
+  }
+  return value;
+}
+function parseBody(raw) {
+  if (!raw)
+    return void 0;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function unwrapEnvelope(value, status2 = 200) {
+  if (isEnvelope(value)) {
+    if (value.success === false || value.code >= 400) {
+      throw errorFromResponse(value.code || status2, value, JSON.stringify(value));
+    }
+    return value.data;
+  }
+  return value;
+}
+function isEnvelope(value) {
+  return !!value && typeof value === "object" && "data" in value && "code" in value && "message" in value && "success" in value;
+}
+function errorFromResponse(status2, parsed, raw) {
+  const message = extractMessage(parsed, raw, status2);
+  const details = isEnvelope(parsed) ? parsed.data : parsed;
+  if (status2 === 400 || status2 === 422) {
+    return new MorulaApiError("BAD_REQUEST", message, EXIT_CODE.USAGE, status2, false, details);
+  }
+  if (status2 === 401) {
+    return new MorulaApiError("UNAUTHENTICATED", message, EXIT_CODE.UNAUTHENTICATED, status2, false, details);
+  }
+  if (status2 === 403) {
+    return new MorulaApiError("FORBIDDEN", message, EXIT_CODE.FORBIDDEN, status2, false, details);
+  }
+  if (status2 === 404) {
+    return new MorulaApiError("NOT_FOUND", message, EXIT_CODE.NOT_FOUND, status2, false, details);
+  }
+  if (status2 === 409) {
+    return new MorulaApiError("CONFLICT", message, EXIT_CODE.CONFLICT, status2, false, details);
+  }
+  if (status2 === 429) {
+    return new MorulaApiError("RATE_LIMITED", message, EXIT_CODE.UPSTREAM, status2, true, details);
+  }
+  if (status2 >= 500) {
+    return new MorulaApiError("UPSTREAM", message, EXIT_CODE.UPSTREAM, status2, true, details);
+  }
+  return new MorulaApiError("HTTP_ERROR", message, EXIT_CODE.OTHER, status2, false, details);
+}
+function extractMessage(parsed, raw, status2) {
+  if (parsed && typeof parsed === "object" && "message" in parsed) {
+    const message = parsed.message;
+    if (typeof message === "string" && message)
+      return message;
+    if (Array.isArray(message) && message.length)
+      return message.map(String).join(", ");
+  }
+  if (typeof parsed === "string" && parsed)
+    return parsed.slice(0, 500);
+  if (raw)
+    return raw.slice(0, 500);
+  return `HTTP ${status2}`;
+}
+
+// ../morula-api-client/dist/comment.js
+var CommentApi = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  list(objectId, query = {}) {
+    const params = { ...query };
+    if (objectId)
+      params.objectId = objectId;
+    return this.client.get("/comments", params);
+  }
+  get(id) {
+    return this.client.get(`/comments/${encodeURIComponent(requiredId(id))}`);
+  }
+  create(input) {
+    return this.client.post("/comments", input);
+  }
+  update(id, input) {
+    return this.client.patch(`/comments/${encodeURIComponent(requiredId(id))}`, input);
+  }
+  delete(id) {
+    return this.client.delete(`/comments/${encodeURIComponent(requiredId(id))}`);
+  }
+};
+function requiredId(id) {
+  const normalized = id.trim();
+  if (!normalized)
+    throw new TypeError("comment id is required");
+  return normalized;
+}
+
+// ../morula-api-client/dist/report.js
+var ReportApi = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  create(input) {
+    return this.client.post("/agent-reports", input);
+  }
+  get(id) {
+    return this.client.get(`/agent-reports/${encodeURIComponent(requiredId2(id))}`);
+  }
+  listByAutopilot(autopilotId, query = {}) {
+    return this.client.get(`/agent-autopilots/${encodeURIComponent(requiredId2(autopilotId, "autopilot"))}/reports`, { ...query });
+  }
+  archive(id) {
+    return this.client.patch(`/agent-reports/${encodeURIComponent(requiredId2(id))}`, { status: "archived" });
+  }
+};
+function requiredId2(id, label = "report") {
+  const normalized = id.trim();
+  if (!normalized)
+    throw new TypeError(`${label} id is required`);
+  return normalized;
+}
+
+// ../morula-api-client/dist/space-member.js
+var SpaceMemberApi = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  list(spaceId, query = {}) {
+    return this.client.get("/space-members", { spaceId, ...query });
+  }
+  get(id) {
+    return this.client.get(`/space-members/${encodeURIComponent(requiredId3(id))}`);
+  }
+  create(input) {
+    return this.client.post("/space-members", input);
+  }
+  update(id, input) {
+    return this.client.patch(`/space-members/${encodeURIComponent(requiredId3(id))}`, input);
+  }
+  delete(id) {
+    return this.client.delete(`/space-members/${encodeURIComponent(requiredId3(id))}`);
+  }
+};
+function requiredId3(id) {
+  const normalized = id.trim();
+  if (!normalized)
+    throw new TypeError("space member id is required");
+  return normalized;
+}
+
+// ../morula-api-client/dist/space.js
+var SpaceApi = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  list(query = {}) {
+    return this.client.get("/spaces", query);
+  }
+  get(id) {
+    return this.client.get(`/spaces/${encodeURIComponent(requiredId4(id))}`);
+  }
+  create(input) {
+    return this.client.post("/spaces", input);
+  }
+  update(id, input) {
+    return this.client.patch(`/spaces/${encodeURIComponent(requiredId4(id))}`, input);
+  }
+  delete(id) {
+    return this.client.delete(`/spaces/${encodeURIComponent(requiredId4(id))}`);
+  }
+};
+function requiredId4(id) {
+  const normalized = id.trim();
+  if (!normalized)
+    throw new TypeError("space id is required");
+  return normalized;
+}
+
+// ../morula-api-client/dist/task.js
+var TaskApi = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  list(query = {}) {
+    return this.client.get("/objects", query);
+  }
+  get(id) {
+    return this.client.get(`/objects/${encodeURIComponent(requiredId5(id))}`);
+  }
+  create(input) {
+    return this.client.post("/objects", input);
+  }
+  update(id, input) {
+    return this.client.patch(`/objects/${encodeURIComponent(requiredId5(id))}`, input);
+  }
+  delete(id) {
+    return this.client.delete(`/objects/${encodeURIComponent(requiredId5(id))}`);
+  }
+  /** 查询空间字段模板（字段 key → id 映射、options） */
+  getSchemaFields(spaceId) {
+    return this.client.get("/schemas", { spaceId }).then((result) => {
+      const rows = Array.isArray(result) ? result : result.data;
+      const fields = [];
+      for (const row of rows ?? []) {
+        for (const f of row.fields ?? []) {
+          if (f.status !== "archived")
+            fields.push(f);
+        }
+      }
+      return fields;
+    });
+  }
+  /** 获取对象自定义字段值 */
+  getFieldValues(objectId) {
+    return this.client.get(`/object-field-values?objectId=${encodeURIComponent(objectId)}`);
+  }
+  /** 创建或更新对象自定义字段值（upsert） */
+  upsertFieldValue(input) {
+    return this.client.post("/object-field-values", input);
+  }
+  /** 删除对象自定义字段值（清空语义） */
+  deleteFieldValue(objectId, schemaFieldId) {
+    return this.client.delete(`/object-field-values`, { objectId, schemaFieldId });
+  }
+};
+function requiredId5(id) {
+  const normalized = id.trim();
+  if (!normalized)
+    throw new TypeError("task id is required");
+  return normalized;
+}
+
+// ../morula-api-client/dist/webhook.js
+var WebhookApi = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  list(query = {}) {
+    return this.client.get("/webhooks", query);
+  }
+  create(input) {
+    return this.client.post("/webhooks", input);
+  }
+};
+
+// ../morula-api-client/dist/index.js
+var MorulaClient = class {
+  http;
+  attachments;
+  auth;
+  comments;
+  reports;
+  tasks;
+  spaces;
+  spaceMembers;
+  webhooks;
+  constructor(options) {
+    this.http = new MorulaApiClient(options);
+    this.attachments = new AttachmentApi(this.http);
+    this.auth = new AuthApi(this.http);
+    this.comments = new CommentApi(this.http);
+    this.reports = new ReportApi(this.http);
+    this.tasks = new TaskApi(this.http);
+    this.spaces = new SpaceApi(this.http);
+    this.spaceMembers = new SpaceMemberApi(this.http);
+    this.webhooks = new WebhookApi(this.http);
+  }
+};
+function createMorulaClient(options) {
+  return new MorulaClient(options);
+}
+
+// ../morula-cli-core/dist/help.js
+var HELP_SCHEMA_VERSION = 1;
+function actionUsage(action) {
+  const args = (action.args ?? []).map((a) => a.required ? `<${a.name}>` : `[<${a.name}>]`);
+  const flags = (action.flags ?? []).map((f) => {
+    if (f.type === "boolean")
+      return `[--${f.name}]`;
+    return `[--${f.name} ${f.valueHint ?? "<value>"}]`;
+  });
+  return [action.action, ...args, ...flags].join(" ");
+}
+function renderResourceHelp(base, resource) {
+  return {
+    // 兼容字段：commands 只含该 resource（键格式与顶层一致），消费方按 resource 取用不受影响
+    commands: { [resource.resource]: renderCommandEntries(resource) },
+    schemaVersion: HELP_SCHEMA_VERSION,
+    resource: resource.resource,
+    summary: resource.summary,
+    actions: resource.actions.map((a) => ({
+      action: a.action,
+      usage: actionUsage(a),
+      summary: a.summary,
+      writes: a.writes ?? "none",
+      interactive: a.interactive ?? false
+    })),
+    ...resource.notes?.length ? { notes: resource.notes } : {},
+    globalFlags: base.globalFlags,
+    exitCodes: base.exitCodes
+  };
+}
+function renderActionHelp(base, resource, action) {
+  return {
+    schemaVersion: HELP_SCHEMA_VERSION,
+    resource: resource.resource,
+    action: action.action,
+    summary: action.summary,
+    args: (action.args ?? []).map((a) => ({
+      name: a.name,
+      required: a.required ?? false,
+      description: a.description
+    })),
+    flags: (action.flags ?? []).map((f) => ({
+      name: f.name,
+      type: f.type,
+      description: f.description,
+      ...f.valueHint ? { valueHint: f.valueHint } : {},
+      required: f.required ?? false,
+      ...f.enum ? { enum: f.enum } : {},
+      ...f.default !== void 0 ? { default: f.default } : {}
+    })),
+    examples: action.examples ?? [],
+    writes: action.writes ?? "none",
+    interactive: action.interactive ?? false,
+    idempotent: action.idempotent ?? false,
+    emits: action.emits ?? [],
+    globalFlags: base.globalFlags,
+    exitCodes: base.exitCodes
+  };
+}
+function renderCommandEntries(resource) {
+  const entries = {};
+  for (const action of resource.actions) {
+    const notes = [action.summary];
+    if (action.writes === "local")
+      notes.push("writes local state");
+    else if (action.writes === "remote")
+      notes.push("writes remote state");
+    if (action.interactive)
+      notes.push("interactive (blocks until you finish in the browser)");
+    entries[actionUsage(action)] = notes.join("; ");
+  }
+  return entries;
+}
+function renderTopLevelCommands(spec) {
+  const commands = {};
+  for (const resource of spec.resources)
+    commands[resource.resource] = renderCommandEntries(resource);
+  return commands;
+}
+function renderResourceIndex(spec) {
+  return spec.resources.map((r) => ({
+    resource: r.resource,
+    summary: r.summary,
+    actions: r.actions.map((a) => ({
+      action: a.action,
+      usage: actionUsage(a),
+      summary: a.summary,
+      writes: a.writes ?? "none",
+      interactive: a.interactive ?? false
+    }))
+  }));
+}
+function renderLegacyResourceHelp(base, resource) {
+  const entries = base.commands[resource];
+  if (!entries)
+    return {};
+  return {
+    commands: { [resource]: entries },
+    schemaVersion: HELP_SCHEMA_VERSION,
+    resource,
+    actions: Object.entries(entries).map(([usage2, summary]) => ({
+      action: usage2.split(" ")[0],
+      usage: usage2,
+      summary,
+      // legacy 命令面没有契约声明：如实标 unknown，而不是假装 none（避免智能体误判只读）
+      writes: "unknown",
+      interactive: false
+    })),
+    globalFlags: base.globalFlags,
+    exitCodes: base.exitCodes
+  };
+}
+
+// ../morula-cli-core/dist/spec.js
+var GLOBAL_FLAG_NAMES2 = GLOBAL_FLAG_NAMES;
+var GLOBAL_FLAGS = [
+  { name: "env", type: "string", valueHint: "<context>", description: "select test or a saved context" },
+  { name: "url", type: "string", valueHint: "<baseUrl>", description: "override API base URL" },
+  { name: "token", type: "string", valueHint: "<token>", description: "override token for this invocation (not persisted)" },
+  { name: "help", type: "boolean", description: "print this machine-readable command surface" },
+  { name: "version", type: "boolean", description: "print version JSON" },
+  // 习惯吸收：输出本来就只有 JSON，`--json` 是 no-op 别名（智能体/脚本的第一直觉动作，此前报 unknown flag）
+  { name: "json", type: "boolean", description: "no-op: output is always JSON (accepted for familiarity)" }
+];
+function usageLine(resource, action) {
+  const parts = action.args?.length ? action.args.map((a) => a.required ? `<${a.name}>` : `[<${a.name}>]`).join(" ") : "";
+  const flagParts = (action.flags ?? []).map((f) => {
+    if (f.type === "boolean")
+      return `[--${f.name}]`;
+    return `[--${f.name} ${f.valueHint ?? "<value>"}]`;
+  });
+  return [action.action, parts, ...flagParts].filter(Boolean).join(" ");
+}
+function suggest(input, candidates) {
+  let best;
+  let bestScore = Number.POSITIVE_INFINITY;
+  for (const candidate of candidates) {
+    const distance = editDistance(input.toLowerCase(), candidate.toLowerCase());
+    const threshold = Math.max(1, Math.floor(candidate.length / 3));
+    if (distance <= threshold && distance < bestScore) {
+      bestScore = distance;
+      best = candidate;
+    }
+  }
+  return best;
+}
+function editDistance(a, b) {
+  if (a === b)
+    return 0;
+  const rows = a.length + 1;
+  const cols = b.length + 1;
+  const d = Array.from({ length: rows }, () => Array.from({ length: cols }).fill(0));
+  for (let i = 0; i < rows; i += 1)
+    d[i][0] = i;
+  for (let j = 0; j < cols; j += 1)
+    d[0][j] = j;
+  for (let i = 1; i < rows; i += 1) {
+    for (let j = 1; j < cols; j += 1) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1])
+        d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
+    }
+  }
+  return d[a.length][b.length];
+}
+function validateArgs(resource, action, parsed, options = {}) {
+  const declaredFlags = action.flags ?? [];
+  const declaredNames = new Set(declaredFlags.map((f) => f.name));
+  const knownNames = [...declaredNames, ...GLOBAL_FLAG_NAMES2];
+  const usageHint = [options.cliName, resource.resource, usageLine(resource, action)].filter(Boolean).join(" ");
+  for (const flag of Object.keys(parsed.flags)) {
+    if (knownNames.includes(flag))
+      continue;
+    const near = suggest(flag, knownNames);
+    throw usage(`unknown flag --${flag}`, {
+      hint: usageHint,
+      ...near ? { didYouMean: `--${near}` } : {}
+    });
+  }
+  for (const flag of parsed.bareFlags) {
+    const spec = declaredFlags.find((f) => f.name === flag);
+    if (!spec || spec.type === "boolean")
+      continue;
+    const valuePart = spec.valueHint ?? "<value>";
+    throw usage(`missing value for --${flag}`, {
+      hint: `${usageHint}  (e.g. --${flag} ${valuePart})`
+    });
+  }
+  for (const spec of declaredFlags) {
+    if (!spec.required)
+      continue;
+    if (flagString(parsed.flags, spec.name) === void 0)
+      throw usage(`missing required flag --${spec.name}`, { hint: usageHint });
+  }
+  for (const spec of declaredFlags) {
+    const raw = flagString(parsed.flags, spec.name);
+    if (raw === void 0)
+      continue;
+    if (spec.type === "number" && !Number.isFinite(Number(raw)))
+      throw usage(`--${spec.name} must be a number (got "${raw}")`, { hint: usageHint });
+    if (spec.enum && !spec.enum.includes(raw)) {
+      throw usage(`--${spec.name} must be one of: ${spec.enum.join(" | ")} (got "${raw}")`, {
+        hint: usageHint
+      });
+    }
+  }
+  if (action.allowExtraPositionals)
+    return;
+  const declaredArgs = action.args ?? [];
+  const required = declaredArgs.filter((a) => a.required).length;
+  const total = declaredArgs.length;
+  const given = parsed.positionals.length;
+  if (given < required) {
+    const missing = declaredArgs.slice(given).filter((a) => a.required).map((a) => `<${a.name}>`).join(" ");
+    throw usage(`missing required argument ${missing}`, { hint: usageHint });
+  }
+  if (given > total) {
+    const extra = parsed.positionals.slice(total).join(" ");
+    throw usage(`unexpected extra argument "${extra}"`, { hint: usageHint });
+  }
+}
+function findResource(spec, resource) {
+  return spec.resources.find((r) => r.resource === resource);
+}
+function findAction(resource, action) {
+  return resource.actions.find((a) => a.action === action);
+}
+
+// ../morula-cli-core/dist/utils/config.js
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { dump, load } from "js-yaml";
+var FileConfigStore = class {
+  path;
+  constructor(path, env = process.env) {
+    this.path = path ?? env.MORULA_CONFIG ?? join(env.MORULA_CONFIG_DIR ?? join(homedir(), ".morula-cli"), "config.yaml");
+  }
+  load() {
+    if (!existsSync(this.path))
+      return {};
+    try {
+      const value = load(readFileSync(this.path, "utf8"));
+      if (!isConfig(value))
+        throw new Error("expected a context configuration object");
+      return value;
+    } catch (error) {
+      throw new CliError("INVALID_CONFIG", EXIT.OTHER, `failed to read config ${this.path}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  save(config) {
+    const dir = dirname(this.path);
+    mkdirSync(dir, { recursive: true, mode: 448 });
+    chmodSync(dir, 448);
+    writeFileSync(this.path, dump(config, { noRefs: true, lineWidth: -1 }), { mode: 384 });
+    chmodSync(this.path, 384);
+  }
+  clear() {
+    rmSync(this.path, { force: true });
+  }
+};
+function isConfig(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const config = value;
+  if (config.currentContext !== void 0 && typeof config.currentContext !== "string")
+    return false;
+  if (config.contexts === void 0)
+    return true;
+  if (!config.contexts || typeof config.contexts !== "object" || Array.isArray(config.contexts))
+    return false;
+  return Object.values(config.contexts).every((context) => {
+    return !!context && typeof context === "object" && typeof context.url === "string" && (context.token === void 0 || typeof context.token === "string");
+  });
+}
+function resolveRuntime(flags, env, store, options = {}) {
+  const config = store.load();
+  const explicitUrl = flagString(flags, "url") ?? env.MORULA_API_URL;
+  let context;
+  if (flagString(flags, "env")) {
+    context = flagString(flags, "env");
+  } else if (env.MORULA_ENV) {
+    context = env.MORULA_ENV;
+  } else if (explicitUrl) {
+    context = contextFromUrl(explicitUrl);
+  } else {
+    context = config.currentContext ?? BUILD_DEFAULT_CONTEXT;
+  }
+  const saved = config.contexts?.[context];
+  const baseUrl = normalizeBaseUrl(explicitUrl ?? saved?.url ?? BUILD_CONTEXTS[context]);
+  if (!baseUrl) {
+    throw usage(`unknown environment "${context}"; pass --url or use one of: ${Object.keys(BUILD_CONTEXTS).join(", ")}`);
+  }
+  const { token, tokenSource } = resolveToken(flags, env, context, baseUrl, saved, options);
+  return {
+    context,
+    baseUrl,
+    token,
+    tokenSource
+  };
+}
+function resolveToken(flags, env, context, baseUrl, saved, options) {
+  const explicitToken = flagString(flags, "token");
+  if (explicitToken)
+    return { token: explicitToken, tokenSource: "flag" };
+  if (!options.excludeTaskToken && env.MORULA_TASK_TOKEN)
+    return { token: env.MORULA_TASK_TOKEN, tokenSource: "env:MORULA_TASK_TOKEN" };
+  if (env.MORULA_TOKEN)
+    return { token: env.MORULA_TOKEN, tokenSource: "env:MORULA_TOKEN" };
+  const savedToken = saved?.url && normalizeBaseUrl(saved.url) === baseUrl ? saved.token : void 0;
+  if (savedToken)
+    return { token: savedToken, tokenSource: `config:${context}` };
+  return { token: void 0, tokenSource: null };
+}
+function saveContext(store, name, patch) {
+  const current = store.load();
+  const contexts = { ...current.contexts, [name]: { ...current.contexts?.[name], ...patch } };
+  store.save({ ...current, currentContext: name, contexts });
+}
+function clearContextToken(store, name) {
+  const current = store.load();
+  const existing = current.contexts?.[name];
+  if (!existing)
+    return;
+  store.save({
+    ...current,
+    contexts: { ...current.contexts, [name]: { url: existing.url } }
+  });
+}
+function normalizeBaseUrl(value) {
+  if (!value)
+    return void 0;
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw usage("server URL must be an absolute http(s) URL");
+  }
+  if (!["http:", "https:"].includes(url.protocol))
+    throw usage("server URL must use http or https");
+  url.hash = "";
+  url.search = "";
+  return url.toString().replace(/\/+$/, "");
+}
+function contextFromUrl(raw) {
+  try {
+    const hostname = new URL(raw).hostname;
+    if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]")
+      return "local";
+    return hostname;
+  } catch {
+    return BUILD_DEFAULT_CONTEXT;
+  }
+}
+
+// ../morula-cli-core/dist/cli.js
+var CLI_CAPABILITIES = [
+  "server-mr",
+  "target-project",
+  "analysis-verdict"
+];
+async function run(argv, deps = {}) {
+  const out = deps.out ?? ((line) => console.log(line));
+  const err = deps.err ?? ((line) => console.error(line));
+  const help = deps.help;
+  const commands = deps.commands ?? {};
+  const spec = deps.spec;
+  let requestedExit;
+  const setExitCode = (code) => {
+    requestedExit = code;
+  };
+  let parsed;
+  try {
+    parsed = parseArgs(argv);
+    if (flagBoolean(parsed.flags, "version")) {
+      out(JSON.stringify(help?.build ? { version: help.version, build: help.build } : { version: help?.version }));
+      return EXIT.OK;
+    }
+    if (!parsed.command || parsed.command === "help" || flagBoolean(parsed.flags, "help")) {
+      out(JSON.stringify(renderHelp(deps, parsed.command, parsed.action), null, 2));
+      return EXIT.OK;
+    }
+    const handler = commands[parsed.command];
+    if (!handler) {
+      const near = suggestCommand(parsed.command, Object.keys(commands));
+      throw new CliError("USAGE", EXIT.USAGE, `unknown command: ${parsed.command}`, false, {
+        hint: `${help?.name ?? "cli"} --help`,
+        ...near ? { didYouMean: near } : {}
+      });
+    }
+    if (spec) {
+      const resource = findResource(spec, parsed.command);
+      if (resource && parsed.action) {
+        const action = findAction(resource, parsed.action);
+        if (action)
+          validateArgs(resource, action, parsed, { cliName: spec.name });
+      }
+    }
+    const env = deps.env ?? process.env;
+    const store = deps.store ?? new FileConfigStore(void 0, env);
+    const runtime = resolveRuntime(parsed.flags, env, store);
+    const client = createMorulaClient({
+      baseUrl: runtime.baseUrl,
+      token: runtime.token,
+      fetch: deps.fetch,
+      // CLI 身份上报（P0-③）：构建标识 + 能力清单随每个请求到达服务端，
+      // 服务端把「执行该任务的 CLI」记到任务上（陈旧构建由此可查、可告警）。
+      clientBuild: BUILD_ID,
+      clientCaps: CLI_CAPABILITIES.join(",")
+    });
+    const result = await handler({ parsed, client, store, runtime, env, err, setExitCode });
+    out(JSON.stringify(result, null, 2));
+    return requestedExit ?? EXIT.OK;
+  } catch (error) {
+    if (error instanceof CliError || error instanceof MorulaApiError) {
+      err(JSON.stringify({
+        code: error.code,
+        message: error.message,
+        ...error.retryable ? { retryable: true } : {},
+        // 新增字段（可选）：可执行的下一步 + typo 建议
+        ...error instanceof CliError && error.hint ? { hint: error.hint } : {},
+        ...error instanceof CliError && error.didYouMean ? { didYouMean: error.didYouMean } : {}
+      }));
+      return error.exitCode;
+    }
+    err(JSON.stringify({ code: "ERROR", message: error instanceof Error ? error.message : String(error) }));
+    return EXIT.OTHER;
+  }
+}
+function renderHelp(deps, resource, action) {
+  const help = deps.help;
+  const spec = deps.spec;
+  const scope = {};
+  if (resource && resource !== "help")
+    scope.resource = resource;
+  if (action)
+    scope.action = action;
+  if (spec) {
+    if (scope.resource) {
+      const found = findResource(spec, scope.resource);
+      if (found) {
+        if (scope.action) {
+          const act = findAction(found, scope.action);
+          if (act && help)
+            return renderActionHelp(help, found, act);
+        }
+        if (help)
+          return renderResourceHelp(help, found);
+      }
+      const near = suggestCommand(scope.resource, spec.resources.map((r) => r.resource));
+      return {
+        ...renderTopLevel(spec, help),
+        error: `unknown resource: ${scope.resource}`,
+        ...near ? { didYouMean: near } : { hint: "resources \u5B57\u6BB5\u5217\u51FA\u5168\u90E8\u53EF\u7528 resource" }
+      };
+    }
+    return renderTopLevel(spec, help);
+  }
+  if (help && scope.resource) {
+    const sub = renderLegacyResourceHelp(help, scope.resource);
+    if (Object.keys(sub).length > 0)
+      return sub;
+  }
+  return help;
+}
+function renderTopLevel(spec, help) {
+  return {
+    ...help ?? {},
+    // spec 路径下 commands 由契约渲染（键格式与 legacy 完全一致），其余字段沿用入口注入的 HELP
+    commands: renderTopLevelCommands(spec),
+    globalFlags: help?.globalFlags ?? flagsToRecord(GLOBAL_FLAGS),
+    schemaVersion: 1,
+    resources: renderResourceIndex(spec)
+  };
+}
+function flagsToRecord(flags) {
+  return Object.fromEntries(flags.map((f) => [`--${f.name}`, f.description]));
+}
+function suggestCommand(input, candidates) {
+  return suggest(input, candidates);
+}
+async function runEntry(deps = {}) {
+  const argv = process.argv.slice(2);
+  if (argv[0] === "--")
+    argv.shift();
+  run(argv, deps).then((code) => {
+    process.exitCode = code;
+  }).catch((error) => {
+    console.error(JSON.stringify({ code: "ERROR", message: error instanceof Error ? error.message : String(error) }));
+    process.exitCode = 1;
+  });
+}
+
+// ../morula-cli-core/dist/commands/auth.js
+import { createHash, randomBytes } from "node:crypto";
+async function authCommand(context) {
+  const { action } = context.parsed;
+  if (action === "login")
+    return login(context);
+  if (action === "logout")
+    return logout(context);
+  if (action === "status")
+    return status(context);
+  throw usage("usage: morula auth <login|logout|status>");
+}
+async function login(context) {
+  rejectUnknownFlags(context.parsed.flags, ["url"]);
+  const verifier = randomBytes(32).toString("base64url");
+  const challenge = createHash("sha256").update(verifier).digest("base64url");
+  const state = randomBytes(16).toString("base64url");
+  const loopback = await startCallbackServer(state);
+  try {
+    const response = await context.client.auth.authorize({
+      response_type: "code",
+      code_challenge: challenge,
+      code_challenge_method: "S256",
+      redirect_uri: loopback.redirectUri,
+      state
+    });
+    if (!response.authorizeUrl)
+      throw new CliError("LOGIN_FAILED", EXIT.OTHER, "server returned no authorizeUrl");
+    context.err(`Opening browser for SkyDoor login\u2026
+If it does not open, visit:
+  ${response.authorizeUrl}`);
+    openBrowser(response.authorizeUrl, context.env);
+    const timeout = Number(context.env.MORULA_LOGIN_TIMEOUT_MS) || 3e5;
+    const code = await loopback.waitForCode(timeout);
+    const token = await context.client.auth.exchangeToken({ code, code_verifier: verifier });
+    if (!token.access_token)
+      throw new CliError("LOGIN_FAILED", EXIT.OTHER, "server returned no access_token");
+    saveContext(context.store, context.runtime.context, { url: context.runtime.baseUrl, token: token.access_token });
+    return { loggedIn: true, context: context.runtime.context, baseUrl: context.runtime.baseUrl, expiresIn: token.expires_in };
+  } finally {
+    await loopback.close();
+  }
+}
+async function logout(context) {
+  rejectUnknownFlags(context.parsed.flags, []);
+  if (context.runtime.token) {
+    try {
+      await context.client.auth.revokeCliToken();
+    } catch (error) {
+      if (!(error instanceof MorulaApiError) || error.exitCode !== EXIT.UNAUTHENTICATED)
+        throw error;
+    }
+  }
+  clearContextToken(context.store, context.runtime.context);
+  return { loggedIn: false, context: context.runtime.context };
+}
+async function status(context) {
+  rejectUnknownFlags(context.parsed.flags, []);
+  if (!context.runtime.token) {
+    return { loggedIn: false, context: context.runtime.context, baseUrl: context.runtime.baseUrl };
+  }
+  try {
+    const user = await context.client.auth.profile();
+    return { loggedIn: true, context: context.runtime.context, baseUrl: context.runtime.baseUrl, user };
+  } catch (error) {
+    if (typeof error === "object" && error && "exitCode" in error && error.exitCode === EXIT.UNAUTHENTICATED) {
+      return { loggedIn: false, context: context.runtime.context, baseUrl: context.runtime.baseUrl, expired: true };
+    }
+    throw error;
+  }
+}
+
+// ../morula-cli/src/commands/attachment.ts
+import { readFile } from "node:fs/promises";
+import { basename, extname } from "node:path";
+var MIME_BY_EXT = {
+  ".pdf": "application/pdf",
+  ".doc": "application/msword",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xls": "application/vnd.ms-excel",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".ppt": "application/vnd.ms-powerpoint",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".md": "text/markdown",
+  ".txt": "text/plain",
+  ".csv": "text/csv",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".zip": "application/zip"
+};
+function inferMimeType(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  return MIME_BY_EXT[ext] ?? "application/octet-stream";
+}
+async function attachmentCommand(context) {
+  const { action, positionals, flags } = context.parsed;
+  if (!context.runtime.token)
+    throw new CliError("UNAUTHENTICATED", EXIT.UNAUTHENTICATED, "\u8BF7\u5148\u8FD0\u884C morula auth login");
+  if (action === "upload") {
+    rejectUnknownFlags(flags, ["object", "comment", "ag-message", "task", "inline"]);
+    const filePath = positionals[0]?.trim();
+    if (!filePath)
+      throw usage("usage: morula attachment upload <file> [--object <objectId>] [--comment <commentId>] [--ag-message] [--task <agentTaskId>] [--inline]");
+    const objectId = flagString(flags, "object");
+    const commentId = flagString(flags, "comment");
+    const isAgMessage = flagBoolean(flags, "ag-message");
+    const isInline = flagBoolean(flags, "inline");
+    const taskId = flagString(flags, "task");
+    const targets = [objectId, commentId, isAgMessage ? "ag-message" : void 0].filter(Boolean);
+    if (targets.length > 1)
+      throw usage("--object / --comment / --ag-message \u53EA\u80FD\u6307\u5B9A\u4E00\u4E2A");
+    const buffer = await readFile(filePath);
+    const resourceType = objectId ? "object" : commentId ? "comment" : isAgMessage ? "ag_message" : void 0;
+    return context.client.attachments.upload({
+      file: new Blob([buffer], { type: inferMimeType(filePath) }),
+      fileName: basename(filePath),
+      fileType: inferMimeType(filePath),
+      resourceType,
+      resourceId: objectId ?? commentId,
+      taskId,
+      isInline
+    });
+  }
+  if (action === "list") {
+    rejectUnknownFlags(flags, ["object"]);
+    const objectId = requireFlag(flags, "object");
+    return context.client.attachments.list({ resourceType: "object", resourceId: objectId });
+  }
+  if (action === "get") {
+    rejectUnknownFlags(flags, []);
+    return context.client.attachments.get(requireId(positionals, "attachment get"));
+  }
+  if (action === "download-url") {
+    rejectUnknownFlags(flags, []);
+    return context.client.attachments.getDownloadUrl(requireId(positionals, "attachment download-url"));
+  }
+  if (action === "delete") {
+    rejectUnknownFlags(flags, []);
+    return context.client.attachments.delete(requireId(positionals, "attachment delete"));
+  }
+  throw usage("usage: morula attachment <upload|list|get|download-url|delete>");
+}
+function requireId(positionals, command) {
+  const id = positionals[0]?.trim();
+  if (!id)
+    throw usage(`usage: morula ${command} <id>`);
+  return id;
+}
+
+// ../morula-cli/src/commands/comment.ts
+function detectCommentFormat(text) {
+  if (!text)
+    return "plain";
+  if (/<[a-z][\s\S]*>/i.test(text))
+    return "richtext";
+  if (/^(?:#{1,6}\s|[-*+]\s|\d+\.\s|>\s|```|~~)/m.test(text))
+    return "markdown";
+  if (/\*\*.+\*\*/.test(text))
+    return "markdown";
+  if (/\[[^\]]+\]\([^)]+\)/.test(text.trim()))
+    return "markdown";
+  if (/\|.+\|.+\|/.test(text))
+    return "markdown";
+  return "plain";
+}
+async function commentCommand(context) {
+  if (!context.runtime.token)
+    throw new CliError("UNAUTHENTICATED", EXIT.UNAUTHENTICATED, "\u8BF7\u5148\u8FD0\u884C morula auth login");
+  const { action, positionals, flags } = context.parsed;
+  if (action === "list") {
+    rejectUnknownFlags(flags, ["object"]);
+    const objectId = requireFlag(flags, "object");
+    return context.client.comments.list(objectId);
+  }
+  if (action === "get") {
+    rejectUnknownFlags(flags, []);
+    const id = positionals[0]?.trim();
+    if (!id)
+      throw usage("usage: morula comment get <id>");
+    return context.client.comments.get(id);
+  }
+  if (action === "add") {
+    rejectUnknownFlags(flags, ["object", "content", "parent", "format"]);
+    const objectId = requireFlag(flags, "object");
+    const content = requireFlag(flags, "content");
+    const formatFlag = flagString(flags, "format");
+    const format = formatFlag === "markdown" || formatFlag === "plain" || formatFlag === "richtext" ? formatFlag : detectCommentFormat(content);
+    const input = compact({
+      objectId,
+      content,
+      parentCommentId: flagString(flags, "parent"),
+      contentFormat: format
+    });
+    return context.client.comments.create(input);
+  }
+  if (action === "update") {
+    rejectUnknownFlags(flags, ["content"]);
+    const id = positionals[0]?.trim();
+    if (!id)
+      throw usage("usage: morula comment update <id>");
+    const content = flagString(flags, "content");
+    if (!content)
+      throw usage("comment update requires --content");
+    return context.client.comments.update(id, { content });
+  }
+  if (action === "delete") {
+    rejectUnknownFlags(flags, []);
+    const id = positionals[0]?.trim();
+    if (!id)
+      throw usage("usage: morula comment delete <id>");
+    return context.client.comments.delete(id);
+  }
+  throw usage("usage: morula comment <list|get|add|update|delete>");
+}
+function compact(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0));
+}
+
+// ../morula-cli/src/commands/repo.ts
+import { execFileSync } from "node:child_process";
+async function repoCommand(context) {
+  if (!context.runtime.token)
+    throw new CliError("UNAUTHENTICATED", EXIT.UNAUTHENTICATED, "\u8BF7\u5148\u8FD0\u884C morula auth login");
+  const { action, positionals, flags } = context.parsed;
+  if (action === "list") {
+    rejectUnknownFlags(flags, ["space"]);
+    const spaceId = flagString(flags, "space");
+    if (!spaceId)
+      throw usage("usage: morula repo list --space <id>\uFF08\u9700\u6307\u5B9A\u4EFB\u52A1\u6240\u5728\u7A7A\u95F4\uFF09");
+    const conns = await context.client.http.get(
+      "/vcs/connections",
+      { spaceId }
+    );
+    return conns.filter((c) => c.status === "active").map((c) => ({ id: c.id, repoFullName: c.repoFullName, provider: c.provider }));
+  }
+  if (action === "checkout") {
+    rejectUnknownFlags(flags, ["ref"]);
+    const taskId = positionals[0]?.trim();
+    const repoFullName = positionals[1]?.trim();
+    if (!taskId || !repoFullName)
+      throw usage("usage: morula repo checkout <taskId> <repoFullName> [--ref <branch|sha>]");
+    const local = await tryLocalCheckout(taskId, repoFullName, flagString(flags, "ref"));
+    if (local)
+      return local;
+    const runtimeId = context.env.MORULA_RUNTIME_ID;
+    if (!runtimeId)
+      throw usage("repo checkout \u9700\u8981 MORULA_RUNTIME_ID\uFF08\u7531 daemon \u6CE8\u5165\uFF1Bagent \u4E0D\u624B\u52A8\u6307\u5B9A\uFF09");
+    const result = await context.client.http.post(
+      `/agent-tasks/${taskId}/repo-checkout`,
+      {
+        repoFullName,
+        ref: flagString(flags, "ref"),
+        runtimeId
+      }
+    );
+    if (result?.ok === false)
+      throw new CliError(result.code ?? "REPO_CHECKOUT_FAILED", EXIT.OTHER, `repo checkout \u5931\u8D25: ${result.code ?? "\u672A\u77E5\u539F\u56E0"}`);
+    return result;
+  }
+  if (action === "prepare") {
+    rejectUnknownFlags(flags, []);
+    const taskId = positionals[0]?.trim();
+    const repoFullName = positionals[1]?.trim();
+    if (!taskId || !repoFullName)
+      throw usage("usage: morula repo prepare <taskId> <repoFullName>");
+    const local = await tryLocalPrepare(taskId, repoFullName);
+    if (local)
+      return local;
+    const runtimeId = context.env.MORULA_RUNTIME_ID;
+    if (!runtimeId)
+      throw usage("repo prepare \u9700\u8981 MORULA_RUNTIME_ID\uFF08\u7531 daemon \u6CE8\u5165\uFF1Bagent \u4E0D\u624B\u52A8\u6307\u5B9A\uFF09");
+    const result = await context.client.http.post(
+      `/agent-tasks/${taskId}/repos/prepare`,
+      { repoFullName, runtimeId }
+    );
+    if (result?.ok === false)
+      throw new CliError(result.code ?? "REPO_PREPARE_FAILED", EXIT.OTHER, `repo prepare \u5931\u8D25: ${result.code ?? "\u672A\u77E5\u539F\u56E0"}`);
+    return { ...result, hint: "\u670D\u52A1\u7AEF\u5DF2\u767B\u8BB0 workContext\uFF1B\u672C\u5730\u7269\u5316\u9700 daemon \u672C\u5730\u7AEF\u70B9\uFF08\u672C\u8F6E\u65E0 .morula/checkout.json\uFF09\uFF0C\u4E0B\u4E00\u8F6E\u4EFB\u52A1\u6267\u884C\u65F6\u751F\u6548" };
+  }
+  if (action === "mr" && positionals[0] === "create") {
+    return mrCreate(context, flags);
+  }
+  if (action === "mr" && positionals[0] === "list") {
+    return mrList(context, flags);
+  }
+  throw usage("usage: morula repo <list|checkout|prepare|mr create|mr list>");
+}
+function resolveMrBase(flagBase, env = process.env) {
+  return env.MORULA_BASE_BRANCH?.trim() || flagBase?.trim() || "main";
+}
+async function mrCreate(context, flags) {
+  rejectUnknownFlags(flags, ["branch", "base", "task-code"]);
+  const repoFullName = context.parsed.positionals[1]?.trim();
+  const branch = flagString(flags, "branch");
+  const base = resolveMrBase(flagString(flags, "base"));
+  const taskCode = flagString(flags, "task-code");
+  if (!repoFullName || !branch)
+    throw usage("usage: morula repo mr create <repoFullName> --branch <branch> [--base <base>] [--task-code <code>]");
+  const taskId = await resolveTaskId(context);
+  if (taskId)
+    return mrCreateViaServer(context, { taskId, repoFullName, branch, base, taskCode });
+  return mrCreateViaPushOptions({ repoFullName, branch, base, taskCode });
+}
+async function resolveCheckoutConfigPath(startDir) {
+  const { existsSync: existsSync2 } = await import("node:fs");
+  const { dirname: dirname2, join: join2, resolve } = await import("node:path");
+  let current = resolve(startDir ?? process.cwd());
+  while (true) {
+    const candidate = join2(current, ".morula", "checkout.json");
+    if (existsSync2(candidate))
+      return candidate;
+    const parent = dirname2(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+async function resolveTaskId(context) {
+  const fromEnv = context.env.MORULA_TASK_ID?.trim();
+  if (fromEnv)
+    return fromEnv;
+  try {
+    const { readFileSync: readFileSync2 } = await import("node:fs");
+    const cfgPath = await resolveCheckoutConfigPath();
+    if (!cfgPath)
+      return null;
+    const raw = JSON.parse(readFileSync2(cfgPath, "utf8"));
+    return raw.taskId?.trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function mrCreateViaServer(context, input) {
+  const title = input.taskCode ? `${input.taskCode}: ${input.branch}` : void 0;
+  const result = await context.client.http.post(`/agent-tasks/${input.taskId}/mr`, {
+    repoFullName: input.repoFullName,
+    branch: input.branch,
+    base: input.base,
+    ...title ? { title } : {}
+  });
+  if (result?.ok === false) {
+    throw new CliError(
+      result.code ?? "MR_CREATE_FAILED",
+      EXIT.UPSTREAM,
+      `\u670D\u52A1\u7AEF\u5EFA MR \u5931\u8D25: ${result.message ?? result.code ?? "\u672A\u77E5\u539F\u56E0"}`
+    );
+  }
+  return {
+    ok: true,
+    repoFullName: result.repoFullName ?? input.repoFullName,
+    branch: result.branch ?? input.branch,
+    base: result.base ?? input.base,
+    prNumber: result.prNumber,
+    prUrl: result.prUrl,
+    reused: result.reused ?? false,
+    linked: result.linked ?? false
+  };
+}
+async function mrCreateViaPushOptions(input) {
+  const { repoFullName, branch, base, taskCode } = input;
+  const title = taskCode ? `${taskCode}: ${branch}` : branch;
+  const description = taskCode ? `Closes ${taskCode}` : "\uFF08morula \u672C\u5730\u521B\u5EFA\uFF09";
+  const pushOpts = [
+    "-o",
+    `merge_request.create`,
+    "-o",
+    `merge_request.target=${base}`,
+    // 显式目标项目：fork 仓库默认会把 MR 建到上游，必须锁定到绑定仓库
+    "-o",
+    `merge_request.target_project=${repoFullName}`,
+    "-o",
+    `merge_request.title=${title}`,
+    "-o",
+    `merge_request.description=${description}`
+  ];
+  let pushOutput = "";
+  try {
+    pushOutput = execFileSync("git", ["push", "origin", branch, ...pushOpts], { encoding: "utf8" });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    throw new CliError("MR_CREATE_FAILED", EXIT.UPSTREAM, `git push \u521B\u5EFA MR \u5931\u8D25: ${msg.slice(0, 300)}`);
+  }
+  const mrUrlMatch = pushOutput.match(/View merge request for \S+:\s*\n?(\S*merge_requests\/\d+)/);
+  const url2 = pushOutput.match(/(https?:\/\/\S+\/merge_requests\/\d+)/)?.[1];
+  const mrUrl = mrUrlMatch?.[1]?.trim() || url2;
+  if (mrUrl)
+    return { ok: true, repoFullName, branch, base, taskCode, title, mrUrl };
+  const gitlabToken = process.env.MORULA_GITLAB_TOKEN;
+  const gitlabBase = process.env.MORULA_GITLAB_URL;
+  if (gitlabToken && gitlabBase) {
+    try {
+      const projectId = encodeURIComponent(repoFullName);
+      const q = new URLSearchParams({ source_branch: branch, state: "opened" });
+      const listRes = await fetch(`${gitlabBase}/api/v4/projects/${projectId}/merge_requests?${q}`, {
+        headers: { "PRIVATE-TOKEN": gitlabToken }
+      });
+      const list = listRes.ok ? await listRes.json().catch(() => null) : null;
+      const existing = Array.isArray(list) ? list[0] : null;
+      if (existing?.iid) {
+        console.log("[morula-cli] mr create \u5206\u652F\u5DF2\u6709 opened MR\uFF0C\u590D\u7528\u73B0\u6709 MR");
+        return { ok: true, repoFullName, branch, base, taskCode, title, mrUrl: existing.web_url ?? `${gitlabBase}/${repoFullName}/-/merge_requests/${existing.iid}` };
+      }
+      if (listRes.ok) {
+        const created = await fetch(`${gitlabBase}/api/v4/projects/${projectId}/merge_requests`, {
+          method: "POST",
+          headers: { "PRIVATE-TOKEN": gitlabToken, "Content-Type": "application/json" },
+          body: JSON.stringify({
+            source_branch: branch,
+            target_branch: base,
+            title,
+            description,
+            remove_source_branch: false
+          })
+        });
+        if (created.ok) {
+          const mr = await created.json().catch(() => null);
+          if (mr?.iid) {
+            return { ok: true, repoFullName, branch, base, taskCode, title, mrUrl: mr.web_url ?? `${gitlabBase}/${repoFullName}/-/merge_requests/${mr.iid}` };
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const hint = pushOutput.split("\n").filter((l) => l.trim()).slice(-3).join(" | ").slice(0, 300);
+  throw new CliError("MR_CREATE_FAILED", EXIT.UPSTREAM, `git push \u6210\u529F\u4F46\u672A\u68C0\u6D4B\u5230 MR \u521B\u5EFA\u8F93\u51FA\uFF08\u5206\u652F\u53EF\u80FD\u5DF2\u5B58\u5728\u6216 push options \u672A\u751F\u6548\uFF09\u3002\u8F93\u51FA\u5C3E\u90E8: ${hint}`);
+}
+async function mrList(context, flags) {
+  rejectUnknownFlags(flags, ["state", "limit"]);
+  const taskId = context.parsed.positionals[1]?.trim();
+  if (!taskId)
+    throw usage("usage: morula repo mr list <taskId> [--state opened|all|merged|closed] [--limit <n>]");
+  const state = flagString(flags, "state") ?? "opened";
+  const limit = flagNumber(flags, "limit");
+  const result = await context.client.http.get(
+    `/agent-tasks/${taskId}/vcs/mr-list`,
+    {
+      state,
+      ...limit ? { limit } : {}
+    }
+  );
+  if (result?.ok === false)
+    throw new CliError(result.code ?? "MR_QUERY_FAILED", EXIT.OTHER, `MR \u5217\u8868\u67E5\u8BE2\u5931\u8D25: ${result.message ?? result.code ?? "\u672A\u77E5\u539F\u56E0"}`);
+  return result;
+}
+async function tryLocalCheckout(taskId, repoFullName, ref) {
+  try {
+    const { readFileSync: readFileSync2 } = await import("node:fs");
+    const cfgPath = await resolveCheckoutConfigPath();
+    if (!cfgPath)
+      return null;
+    const raw = JSON.parse(readFileSync2(cfgPath, "utf8"));
+    if (raw.taskId !== taskId || typeof raw.port !== "number" || !raw.checkToken)
+      return null;
+    const res = await fetch(`http://127.0.0.1:${raw.port}/repo/checkout`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ taskId, repoFullName, ref, checkToken: raw.checkToken })
+    });
+    const body = await res.json().catch(() => null);
+    if (!body)
+      return null;
+    if (body?.ok === false)
+      throw new CliError(body.code ?? "REPO_CHECKOUT_FAILED", EXIT.OTHER, `\u672C\u5730 repo checkout \u5931\u8D25: ${body.error ?? body.code ?? "\u672A\u77E5\u539F\u56E0"}`);
+    return { ok: true, local: true, path: body?.path, headSha: body?.headSha, branchName: body?.branchName ?? null };
+  } catch (error) {
+    if (error instanceof CliError)
+      throw error;
+    return null;
+  }
+}
+async function tryLocalPrepare(taskId, repoFullName) {
+  try {
+    const { readFileSync: readFileSync2 } = await import("node:fs");
+    const cfgPath = await resolveCheckoutConfigPath();
+    if (!cfgPath)
+      return null;
+    const raw = JSON.parse(readFileSync2(cfgPath, "utf8"));
+    if (raw.taskId !== taskId || typeof raw.port !== "number" || !raw.checkToken)
+      return null;
+    const res = await fetch(`http://127.0.0.1:${raw.port}/repo/prepare`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ taskId, repoFullName, checkToken: raw.checkToken })
+    });
+    const body = await res.json().catch(() => null);
+    if (!body)
+      return null;
+    if (body?.ok === false)
+      throw new CliError(body.code ?? "REPO_PREPARE_FAILED", EXIT.OTHER, `\u672C\u5730 repo prepare \u5931\u8D25: ${body.error ?? body.code ?? "\u672A\u77E5\u539F\u56E0"}`);
+    return { ok: true, local: true, path: body?.path, headSha: body?.headSha, baseBranch: body?.baseBranch ?? null, workContextId: body?.workContextId, created: body?.created ?? false };
+  } catch (error) {
+    if (error instanceof CliError)
+      throw error;
+    return null;
+  }
+}
+
+// ../morula-cli/src/commands/report.ts
+import { readFile as readFile2 } from "node:fs/promises";
+var REPORT_STATUSES = ["ready", "archived"];
+async function reportCommand(context) {
+  if (!context.runtime.token)
+    throw new CliError("UNAUTHENTICATED", EXIT.UNAUTHENTICATED, "\u8BF7\u5148\u8FD0\u884C morula auth login");
+  const { action, positionals, flags } = context.parsed;
+  if (action === "create") {
+    rejectUnknownFlags(flags, ["title", "content", "content-file", "space", "autopilot"]);
+    const title = requireFlag(flags, "title");
+    const content = await resolveContent(flags);
+    const input = { title, content };
+    const spaceId = flagString(flags, "space");
+    if (spaceId)
+      input.spaceId = spaceId;
+    const autopilotId = flagString(flags, "autopilot");
+    if (autopilotId)
+      input.autopilotId = autopilotId;
+    return context.client.reports.create(input);
+  }
+  if (action === "get") {
+    rejectUnknownFlags(flags, []);
+    const id = positionals[0]?.trim();
+    if (!id)
+      throw usage("usage: morula report get <id>");
+    return context.client.reports.get(id);
+  }
+  if (action === "list") {
+    rejectUnknownFlags(flags, ["autopilot", "page", "page-size", "status"]);
+    const autopilotId = flagString(flags, "autopilot");
+    if (!autopilotId)
+      throw usage("usage: morula report list --autopilot <id> [--page <n>] [--page-size <n>] [--status ready|archived]");
+    const status2 = flagString(flags, "status");
+    const query = {
+      page: flagNumber(flags, "page"),
+      pageSize: flagNumber(flags, "page-size")
+    };
+    if (status2) {
+      if (!isReportStatus(status2))
+        throw usage("--status \u5FC5\u987B\u662F ready / archived");
+      query.status = status2;
+    }
+    return context.client.reports.listByAutopilot(autopilotId, query);
+  }
+  if (action === "archive") {
+    rejectUnknownFlags(flags, []);
+    const id = positionals[0]?.trim();
+    if (!id)
+      throw usage("usage: morula report archive <id>");
+    return context.client.reports.archive(id);
+  }
+  throw usage(`usage: morula report <create|get|list|archive>
+
+  create  \u4EA7\u51FA\u62A5\u544A\uFF08\u81EA\u52A8\u5316\u6267\u884C\u7684\u7ED3\u8BBA\u578B\u5185\u5BB9\uFF1B--autopilot \u53EF\u7701\u7565\uFF0C\u670D\u52A1\u7AEF\u6309\u5F53\u524D\u4EFB\u52A1\u53CD\u67E5\u6240\u5C5E\u81EA\u52A8\u5316\uFF09
+  get     \u67E5\u770B\u62A5\u544A\u8BE6\u60C5\uFF08\u542B Markdown \u6B63\u6587\uFF09
+  list    \u5217\u51FA\u67D0\u81EA\u52A8\u5316\u7684\u62A5\u544A\uFF08\u9ED8\u8BA4\u4E0D\u542B\u5DF2\u5F52\u6863\uFF1B--status archived \u67E5\u770B\u5F52\u6863\uFF09
+  archive \u5F52\u6863\u62A5\u544A\uFF08\u5F52\u6863\u540E\u9ED8\u8BA4\u5217\u8868\u4E0D\u518D\u5C55\u793A\uFF09`);
+}
+async function resolveContent(flags) {
+  const inline = flagString(flags, "content");
+  const filePath = flagString(flags, "content-file");
+  if (inline && filePath)
+    throw usage("--content \u4E0E --content-file \u53EA\u80FD\u6307\u5B9A\u4E00\u4E2A");
+  if (!inline && !filePath)
+    throw usage("\u62A5\u544A\u6B63\u6587\u5FC5\u586B\uFF1A--content <markdown> \u6216 --content-file <path>");
+  let content = inline;
+  if (filePath) {
+    try {
+      content = await readFile2(filePath, "utf8");
+    } catch (error) {
+      throw new CliError(
+        "CONTENT_FILE_UNREADABLE",
+        EXIT.OTHER,
+        `\u8BFB\u53D6 --content-file \u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  if (!content?.trim())
+    throw usage("\u62A5\u544A\u6B63\u6587\u4E0D\u80FD\u4E3A\u7A7A");
+  return content;
+}
+function isReportStatus(value) {
+  return REPORT_STATUSES.includes(value);
+}
+
+// ../morula-cli/src/commands/review.ts
+async function reviewCommand(context) {
+  if (!context.runtime.token)
+    throw new CliError("UNAUTHENTICATED", EXIT.UNAUTHENTICATED, "\u8BF7\u5148\u8FD0\u884C morula auth login");
+  const { action, positionals, flags } = context.parsed;
+  if (action === "submit") {
+    rejectUnknownFlags(flags, ["verdict", "details", "pr-number"]);
+    const objectId = positionals[0]?.trim();
+    const verdict = flagString(flags, "verdict");
+    if (!objectId)
+      throw usage(`usage: morula review submit <objectId> --verdict <approved|changes_requested|commented> [--details <text>] [--pr-number <n>]
+
+\u8BC4\u5BA1\u4EFB\u52A1\u673A\u5668\u534F\u8BAE\uFF08\u53EA\u8BFB\u8BC4\u5BA1\u4EFB\u52A1\u4F7F\u7528\uFF09\uFF1A\u5BF9\u5F00\u53D1\u63D0\u4EA4\u7684\u6539\u52A8\u4E0B\u7ED3\u8BBA\uFF0C\u670D\u52A1\u7AEF\u6821\u9A8C\u8C03\u7528\u8005 = \u8BC4\u5BA1\u4EFB\u52A1\u540E\u843D\u5E93\u5E76\u9A71\u52A8\u56DE\u73AF\u3002
+  --objectId        \u8BC4\u5BA1\u5BF9\u8C61 ID\uFF08\u7CFB\u7EDF\u63D0\u793A\u300C\u8BC4\u5BA1\u5BF9\u8C61\u300D\uFF1B\u7F3A\u5931\u65F6\u7528 morula task get <taskId> \u67E5\u8BE2\uFF09
+  --verdict         approved=\u901A\u8FC7 / changes_requested=\u4E0D\u901A\u8FC7\uFF08\u5FC5\u987B\u7ED9 --details \u5177\u4F53\u610F\u89C1\uFF0C\u5426\u5219\u5F00\u53D1\u65E0\u6CD5\u4FEE\u590D\uFF09/ commented=\u6709\u610F\u89C1\u4F46\u4E0D\u963B\u585E
+  --details         \u8BC4\u5BA1\u610F\u89C1\u6587\u672C\uFF08changes_requested \u5FC5\u586B\uFF1A\u6587\u4EF6/\u884C/\u95EE\u9898/\u5EFA\u8BAE\uFF09
+  --pr-number       \u8BC4\u5BA1\u5BF9\u8C61\u7684 PR \u7F16\u53F7\uFF08\u6709\u5219\u586B\uFF09
+\u7981\u6B62\uFF1A\u4FEE\u6539\u4EE3\u7801\u3001\u5EFA\u5206\u652F\u3001\u5408\u5E76 MR\u3001\u8BC4\u5BA1\u81EA\u5DF1\u5F00\u53D1\u7684\u4EFB\u52A1\u3002`);
+    if (!["approved", "changes_requested", "commented"].includes(verdict ?? ""))
+      throw usage("--verdict \u5FC5\u987B\u662F approved / changes_requested / commented");
+    const details = flagString(flags, "details");
+    if (verdict === "changes_requested" && !details?.trim())
+      throw usage("changes_requested \u5FC5\u987B\u63D0\u4F9B --details\uFF08\u5177\u4F53\u4FEE\u6539\u610F\u89C1\uFF09");
+    const body = { objectId, verdict };
+    if (details?.trim())
+      body.details = details.trim();
+    const prNumber = flagNumber(flags, "pr-number");
+    if (prNumber)
+      body.prNumber = prNumber;
+    const result = await context.client.http.post(
+      "/agent-collaborations/review/submit",
+      body
+    );
+    if (result?.ok === false)
+      throw new CliError(result.code ?? "REVIEW_SUBMIT_FAILED", EXIT.OTHER, `\u8BC4\u5BA1\u63D0\u4EA4\u5931\u8D25: ${result.message ?? "\u672A\u77E5\u539F\u56E0"}`);
+    return { ok: true, reviewRound: result.reviewRound, verdict: result.verdict, reverted: result.reverted };
+  }
+  throw usage(`usage: morula review <submit>
+
+  submit  \u63D0\u4EA4\u8BC4\u5BA1\u7ED3\u8BBA\uFF08\u8BC4\u5BA1\u4EFB\u52A1\u673A\u5668\u534F\u8BAE\uFF1B\u7528\u6CD5\u4E0E\u53C2\u6570\u89C1 morula review submit --help\uFF09`);
+}
+
+// ../morula-cli/src/commands/space-member.ts
+async function spaceMemberCommand(context) {
+  if (!context.runtime.token)
+    throw new CliError("UNAUTHENTICATED", EXIT.UNAUTHENTICATED, "\u8BF7\u5148\u8FD0\u884C morula auth login");
+  const { action, positionals, flags } = context.parsed;
+  if (action === "list") {
+    rejectUnknownFlags(flags, ["space"]);
+    const spaceId = requireFlag(flags, "space");
+    return context.client.spaceMembers.list(spaceId);
+  }
+  if (action === "add") {
+    rejectUnknownFlags(flags, ["space", "principal", "role"]);
+    const spaceId = requireFlag(flags, "space");
+    const principalId = requireFlag(flags, "principal");
+    const input = compact2({
+      spaceId,
+      principalId,
+      roleCode: flagString(flags, "role")
+    });
+    return context.client.spaceMembers.create(input);
+  }
+  if (action === "remove") {
+    rejectUnknownFlags(flags, []);
+    const id = positionals[0]?.trim();
+    if (!id)
+      throw usage("usage: morula space-member remove <member-id>");
+    return context.client.spaceMembers.delete(id);
+  }
+  if (action === "update") {
+    rejectUnknownFlags(flags, ["role"]);
+    const id = positionals[0]?.trim();
+    if (!id)
+      throw usage("usage: morula space-member update <member-id>");
+    const role = flagString(flags, "role");
+    if (!role)
+      throw usage("space-member update requires --role");
+    return context.client.spaceMembers.update(id, { roleCode: role });
+  }
+  throw usage("usage: morula space-member <list|add|update|remove>");
+}
+function compact2(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0));
+}
+
+// ../morula-cli/src/commands/space.ts
+async function spaceCommand(context) {
+  if (!context.runtime.token)
+    throw new CliError("UNAUTHENTICATED", EXIT.UNAUTHENTICATED, "\u8BF7\u5148\u8FD0\u884C morula auth login");
+  const { action, positionals, flags } = context.parsed;
+  if (action === "list") {
+    rejectUnknownFlags(flags, ["page", "page-size", "keyword"]);
+    return context.client.spaces.list({
+      page: flagNumber(flags, "page"),
+      pageSize: flagNumber(flags, "page-size"),
+      keyword: flagString(flags, "keyword")
+    });
+  }
+  if (action === "get") {
+    rejectUnknownFlags(flags, []);
+    const id = positionals[0]?.trim();
+    if (!id)
+      throw usage("usage: morula space get <id>");
+    return context.client.spaces.get(id);
+  }
+  throw usage("usage: morula space <list|get>");
+}
+
+// ../morula-cli/src/commands/task.ts
+var LIST_FLAGS = ["space", "page", "page-size", "search", "priority", "state", "assignee", "principal", "sort", "order", "mine", "field"];
+var WRITE_FLAGS = ["title", "description", "space", "priority", "state", "owner", "assignee", "visibility", "estimate-hours", "schema", "sort-order", "field"];
+function parseFieldFlags(raw) {
+  if (!raw)
+    return [];
+  const specs = [];
+  for (const pair of raw.split(",")) {
+    const eq = pair.indexOf("=");
+    if (eq > 0) {
+      specs.push({ key: pair.slice(0, eq).trim(), value: pair.slice(eq + 1).trim() });
+    } else {
+      throw usage(`--field \u683C\u5F0F\u5E94\u4E3A key=value\uFF0C\u6536\u5230 "${pair}"`);
+    }
+  }
+  return specs.filter((f) => f.key);
+}
+async function resolveFieldIds(context, spaceId, specs) {
+  if (specs.length === 0)
+    return [];
+  const fields = await context.client.tasks.getSchemaFields(spaceId);
+  const resolved = [];
+  for (const spec of specs) {
+    const field = fields.find((f) => f.fieldKey === spec.key || f.fieldName === spec.key);
+    if (!field)
+      throw usage(`\u81EA\u5B9A\u4E49\u5B57\u6BB5\u4E0D\u5B58\u5728\uFF1A${spec.key}\uFF08\u7A7A\u95F4 ${spaceId} \u7684\u5B57\u6BB5\u6A21\u677F\u4E2D\u672A\u627E\u5230\uFF09`);
+    resolved.push({ schemaFieldId: field.id, value: spec.value });
+  }
+  return resolved;
+}
+function detectDescriptionFormat(text) {
+  if (!text)
+    return "plain";
+  if (/<[a-z][\s\S]*>/i.test(text))
+    return "richtext";
+  if (/^(?:#{1,6}\s|[-*+]\s|\d+\.\s|>\s|```|~~)/m.test(text))
+    return "markdown";
+  if (/\*\*.+\*\*/.test(text))
+    return "markdown";
+  if (/\[[^\]]+\]\([^)]+\)/.test(text.trim()))
+    return "markdown";
+  if (/\|.+\|.+\|/.test(text))
+    return "markdown";
+  return "plain";
+}
+async function taskCommand(context) {
+  const { action, positionals, flags } = context.parsed;
+  if (!context.runtime.token)
+    throw unauthenticated();
+  if (action === "list") {
+    rejectUnknownFlags(flags, LIST_FLAGS);
+    const mine = flagBoolean(flags, "mine");
+    if (mine && flagString(flags, "assignee"))
+      throw usage("--mine \u4E0E --assignee \u4E92\u65A5\uFF0C\u8BF7\u4E8C\u9009\u4E00");
+    let assigneePrincipalId = flagString(flags, "assignee");
+    if (mine) {
+      const profile = await context.client.auth.profile();
+      if (!profile.principalId)
+        throw usage("--mine \u65E0\u6CD5\u89E3\u6790\u5F53\u524D\u7528\u6237 principalId\uFF08profile \u7F3A\u5931\uFF09");
+      assigneePrincipalId = profile.principalId;
+    }
+    const query = compact3({
+      spaceId: flagString(flags, "space"),
+      page: flagNumber(flags, "page"),
+      pageSize: flagNumber(flags, "page-size"),
+      search: flagString(flags, "search"),
+      priority: flagString(flags, "priority"),
+      currentStateId: flagString(flags, "state"),
+      assigneePrincipalId,
+      principalId: flagString(flags, "principal"),
+      sort: flagString(flags, "sort"),
+      order: flagString(flags, "order"),
+      includeFieldValues: true
+    });
+    const fieldSpecs = parseFieldFlags(flagString(flags, "field"));
+    if (fieldSpecs.length > 0) {
+      const spaceId = flagString(flags, "space");
+      if (!spaceId)
+        throw usage("--field \u9700\u8981\u914D\u5408 --space \u6307\u5B9A\u7A7A\u95F4\uFF08\u7528\u4E8E\u89E3\u6790\u5B57\u6BB5\u6A21\u677F\uFF09");
+      const resolved = await resolveFieldIds(context, spaceId, fieldSpecs);
+      query.fieldFilters = JSON.stringify(resolved.map((r) => ({ schemaFieldId: r.schemaFieldId, op: "eq", value: r.value })));
+    }
+    return context.client.tasks.list(query);
+  }
+  if (action === "get") {
+    rejectUnknownFlags(flags, []);
+    if (!positionals[0]?.trim()) {
+      const taskId = await resolveTaskId(context);
+      if (!taskId)
+        throw usage(`morula task get\uFF08\u65E0\u53C2\uFF09\u9700\u8981\u4EFB\u52A1\u4E0A\u4E0B\u6587\uFF1A\u5F53\u524D\u76EE\u5F55\u627E\u4E0D\u5230 .morula/checkout.json \u4E14\u672A\u8BBE\u7F6E MORULA_TASK_ID\u3002
+
+\u7528\u6CD5:
+  morula task get                 # \u5F53\u524D AgentTask \u8BE6\u60C5\uFF08daemon \u4EFB\u52A1\u5DE5\u4F5C\u533A\u5185\uFF1B\u8FD4\u56DE code/objectId/taskPrompt/contextSnapshot\uFF09
+  morula task get <objectId>      # \u4E1A\u52A1\u4EFB\u52A1\uFF08Object\uFF09\u8BE6\u60C5\uFF08\u542B\u81EA\u5B9A\u4E49\u5B57\u6BB5\u503C\uFF09`);
+      return context.client.http.get(`/agent-tasks/${encodeURIComponent(taskId)}`);
+    }
+    const id = requireId2(positionals, "task get");
+    const task = await context.client.tasks.get(id);
+    if (!task)
+      return null;
+    try {
+      const fieldValues = await context.client.tasks.getFieldValues(id);
+      task.fieldValues = fieldValues;
+    } catch {
+    }
+    return task;
+  }
+  if (action === "create") {
+    rejectUnknownFlags(flags, WRITE_FLAGS);
+    const input = taskInput(flags, true);
+    const fieldSpecs = parseFieldFlags(flagString(flags, "field"));
+    const created = await context.client.tasks.create(input);
+    if (fieldSpecs.length > 0 && created) {
+      const spaceId = input.spaceId ?? created.spaceId;
+      const resolved = await resolveFieldIds(context, spaceId, fieldSpecs);
+      for (const r of resolved) {
+        if (r.value) {
+          await context.client.tasks.upsertFieldValue({
+            objectId: created.id,
+            schemaFieldId: r.schemaFieldId,
+            valueText: r.value
+          });
+        }
+      }
+      ;
+      created.fieldValues = resolved.filter((r) => r.value).map((r) => ({ schemaFieldId: r.schemaFieldId, valueText: r.value }));
+    }
+    return created;
+  }
+  if (action === "update") {
+    rejectUnknownFlags(flags, WRITE_FLAGS.filter((flag) => flag !== "space" && flag !== "owner"));
+    const id = requireId2(positionals, "task update");
+    const input = taskInput(flags, false);
+    const fieldSpecs = parseFieldFlags(flagString(flags, "field"));
+    if (!Object.keys(input).length && !flagString(flags, "field"))
+      throw usage("task update requires at least one field flag");
+    const updated = await context.client.tasks.update(id, input);
+    if (fieldSpecs.length > 0) {
+      const task = updated ?? await context.client.tasks.get(id);
+      const spaceId = task?.spaceId;
+      if (!spaceId)
+        throw usage(`--field \u65E0\u6CD5\u89E3\u6790\u4EFB\u52A1 ${id} \u6240\u5C5E\u7A7A\u95F4`);
+      const resolved = await resolveFieldIds(context, spaceId, fieldSpecs);
+      for (const r of resolved) {
+        if (r.value) {
+          await context.client.tasks.upsertFieldValue({
+            objectId: id,
+            schemaFieldId: r.schemaFieldId,
+            valueText: r.value
+          });
+        } else {
+          await context.client.tasks.deleteFieldValue(id, r.schemaFieldId).catch(() => void 0);
+        }
+      }
+      const values = await context.client.tasks.getFieldValues(id).catch(() => []);
+      if (updated)
+        updated.fieldValues = values;
+    }
+    return updated;
+  }
+  if (action === "delete") {
+    rejectUnknownFlags(flags, []);
+    const id = requireId2(positionals, "task delete");
+    return context.client.tasks.delete(id);
+  }
+  if (action === "branch") {
+    rejectUnknownFlags(flags, ["name", "repo"]);
+    const id = requireId2(positionals, "task branch");
+    const branchName = requireFlag(flags, "name");
+    const runtimeId = context.env.MORULA_RUNTIME_ID;
+    if (!runtimeId)
+      throw usage("task branch \u9700\u8981 MORULA_RUNTIME_ID\uFF08\u7531 daemon \u6CE8\u5165\uFF1Bagent \u4E0D\u624B\u52A8\u6307\u5B9A\uFF09");
+    const repoFullName = flagString(flags, "repo")?.trim();
+    return context.client.http.post(`/agent-tasks/${id}/branch`, {
+      branchName,
+      runtimeId,
+      ...repoFullName ? { repoFullName } : {}
+    });
+  }
+  if (action === "state") {
+    rejectUnknownFlags(flags, ["state"]);
+    const id = requireId2(positionals, "task state");
+    const stateCode = requireFlag(flags, "state");
+    const runtimeId = context.env.MORULA_RUNTIME_ID;
+    if (!runtimeId)
+      throw usage(`task state \u9700\u8981 MORULA_RUNTIME_ID\uFF08\u7531 daemon \u6CE8\u5165\uFF1Bagent \u4E0D\u624B\u52A8\u6307\u5B9A\uFF09
+
+\u7528\u6CD5: morula task state <taskId> --state <in_progress|review>
+\u8BF4\u660E: \u4EFB\u52A1\u72B6\u6001\u63A8\u8FDB\u7531\u670D\u52A1\u7AEF\u9A71\u52A8\uFF08\u6D3E\u5355\u65F6\u6309\u9636\u6BB5\u5BF9\u9F50\u3001PR \u4E8B\u4EF6\u81EA\u52A8\u6D41\u8F6C\uFF09\uFF1B\u4EC5\u5E73\u53F0\u660E\u786E\u8981\u6C42 agent \u81EA\u63A8\u72B6\u6001\u65F6\u4F7F\u7528\u3002`);
+    return context.client.http.post(`/agent-tasks/${id}/state`, { stateCode, runtimeId });
+  }
+  if (action === "analysis-verdict") {
+    rejectUnknownFlags(flags, ["verdict", "reason"]);
+    const id = requireId2(positionals, "task analysis-verdict");
+    const verdict = requireFlag(flags, "verdict");
+    if (verdict !== "ready" && verdict !== "blocked")
+      throw usage(`--verdict \u5FC5\u987B\u662F ready / blocked
+
+\u7528\u6CD5: morula task analysis-verdict <taskId> --verdict <ready|blocked> [--reason <\u6587\u672C>]
+\u4EFB\u52A1\u5206\u6790\u673A\u5668\u534F\u8BAE\uFF08\u4EC5\u300C\u4EFB\u52A1\u5206\u6790\u300D\u4EFB\u52A1\u9002\u7528\uFF09: ready=\u9700\u6C42\u6E05\u6670\u53EF\u5F00\u53D1\uFF08\u670D\u52A1\u7AEF\u81EA\u52A8\u8FDB\u5165\u5F00\u53D1\u5E76\u6D3E\u53D1\uFF09\uFF1Bblocked=\u4E0D\u53EF\u505A/\u9700\u6F84\u6E05\uFF08\u4EFB\u52A1\u505C\u5206\u6790\uFF0Creason \u5199\u6E05\u963B\u585E\u70B9\u4E0E\u5F85\u6F84\u6E05\u95EE\u9898\uFF09\u3002
+\u6F0F\u62A5\u4F1A\u8BA9\u4EFB\u52A1\u505C\u5728\u300C\u4EFB\u52A1\u5206\u6790\u300D\uFF1B\u540C\u4E00\u4EFB\u52A1\u53EA\u4E0A\u62A5\u4E00\u6B21\uFF08\u91CD\u590D\u4E0A\u62A5\u4EE5\u9996\u6B21\u4E3A\u51C6\uFF09\u3002`);
+    const body = { verdict };
+    const reason = flagString(flags, "reason");
+    if (reason?.trim())
+      body.reason = reason.trim();
+    const result = await context.client.http.post(
+      `/agent-tasks/${id}/analysis-verdict`,
+      body
+    );
+    if (result?.ok === false)
+      throw new CliError(result.code ?? "ANALYSIS_VERDICT_FAILED", EXIT.OTHER, `\u5206\u6790\u7ED3\u8BBA\u4E0A\u62A5\u5931\u8D25: ${result.message ?? "\u672A\u77E5\u539F\u56E0"}`);
+    return { ok: true, verdict: result.verdict, alreadyReported: result.alreadyReported ?? false };
+  }
+  throw usage("usage: morula task <list|create|get|update|delete|branch|state|analysis-verdict>");
+}
+function taskInput(flags, create) {
+  const description = flagString(flags, "description");
+  const values = compact3({
+    spaceId: flagString(flags, "space"),
+    title: flagString(flags, "title"),
+    description,
+    descriptionFormat: description !== void 0 ? detectDescriptionFormat(description) : void 0,
+    priority: flagString(flags, "priority"),
+    currentStateId: flagString(flags, "state"),
+    ownerPrincipalId: flagString(flags, "owner"),
+    assigneePrincipalId: flagString(flags, "assignee"),
+    visibility: flagString(flags, "visibility"),
+    estimateHours: flagNumber(flags, "estimate-hours"),
+    schemaId: flagString(flags, "schema"),
+    sortOrder: flagNumber(flags, "sort-order")
+  });
+  if (create) {
+    values.spaceId = requireFlag(flags, "space");
+    values.title = requireFlag(flags, "title");
+  }
+  return values;
+}
+function requireId2(positionals, command) {
+  const id = positionals[0]?.trim();
+  if (!id)
+    throw usage(`usage: morula ${command} <id>`);
+  return id;
+}
+function compact3(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0));
+}
+function unauthenticated() {
+  return new CliError("UNAUTHENTICATED", EXIT.UNAUTHENTICATED, "\u8BF7\u5148\u8FD0\u884C morula auth login");
+}
+
+// ../morula-cli/src/commands/registry.ts
+var COMMANDS = {
+  "attachment": attachmentCommand,
+  "auth": authCommand,
+  "comment": commentCommand,
+  "report": reportCommand,
+  "repo": repoCommand,
+  "review": reviewCommand,
+  "task": taskCommand,
+  "space": spaceCommand,
+  "space-member": spaceMemberCommand
+};
+var HELP = {
+  name: "morula",
+  version: BUILD_VERSION,
+  build: BUILD_ID,
+  summary: "Agent-first CLI for Morula task management. Success output is JSON on stdout; errors are JSON on stderr.",
+  usage: "morula <resource> <action> [id] [--flags]",
+  commands: {
+    "auth": {
+      login: "browser SkyDoor SSO using PKCE and loopback callback",
+      logout: "remove the current context token",
+      status: "show context, endpoint, and authentication state"
+    },
+    "task": {
+      "list [--space <id>] [--mine] [--assignee <id>] [--page <n>] [--page-size <n>] [--search <text>] [--priority <low|medium|high|urgent>] [--state <id>]": "list tasks (--mine: \u4EC5\u6211\u8D1F\u8D23\u7684)",
+      "create --space <id> --title <text> [--priority <value>] [--assignee <id>]": "create task",
+      "get [id]": "get task details. No argument = the current AgentTask (id resolved from MORULA_TASK_ID / .morula/checkout.json). With an id = the business Object (title/description)",
+      "update <id> [--title <text>] [--state <id>] [--priority <value>] [--sort-order <n>]": "update task (--state here is the business Object state id, NOT the AgentTask state code \u2014 see `task state`)",
+      "delete <id>": "hard delete task",
+      "branch <id> --name <name> [--repo <owner/name>]": "report the final branch name for an agent task (machine protocol; agent naming, runtimeId from env; --repo: secondary repo in a multi-repo task)",
+      "state <id> --state <code>": "self-transition task state (machine protocol; agent drives todo\u2192in_progress\u2192review, runtimeId from env)",
+      "analysis-verdict <taskId> --verdict <ready|blocked> [--reason <text>]": "report the task-analysis verdict (machine protocol; ready \u2192 platform auto-starts development, blocked \u2192 task stays in analysis)"
+    },
+    "space": {
+      "list [--page <n>] [--page-size <n>] [--keyword <text>]": "list visible spaces",
+      "get <id>": "get space details"
+    },
+    "space-member": {
+      "list --space <id>": "list space members",
+      "add --space <id> --principal <id> [--role <admin|member>]": "add member to space",
+      "update <member-id> --role <admin|member>": "update member role",
+      "remove <member-id>": "remove member from space"
+    },
+    "comment": {
+      "list --object <id>": "list comments for an object",
+      "get <id>": "get comment details",
+      "add --object <id> --content <text> [--parent <id>] [--format markdown|plain|richtext]": "add comment (format auto-detected; use markdown for agent final summaries)",
+      "update <id> --content <text>": "update comment",
+      "delete <id>": "hard delete comment"
+    },
+    "review": {
+      "submit <objectId> --verdict <approved|changes_requested|commented> [--details <text>] [--pr-number <n>]": "submit Code Review verdict (machine protocol; review task token)"
+    },
+    "report": {
+      "create --title <text> [--content <markdown> | --content-file <path>] [--space <id>] [--autopilot <id>]": "create an autopilot report (\u6B63\u6587\u4E8C\u9009\u4E00\uFF1A--content \u77ED\u6B63\u6587 / --content-file \u957F Markdown\uFF1B--autopilot \u7701\u7565\u65F6\u6309\u5F53\u524D\u4EFB\u52A1\u53CD\u67E5\u6240\u5C5E\u81EA\u52A8\u5316)",
+      "get <id>": "get report details (\u542B Markdown \u6B63\u6587)",
+      "list --autopilot <id> [--page <n>] [--page-size <n>] [--status ready|archived]": "list reports of an autopilot",
+      "archive <id>": "archive report (\u5F52\u6863\u540E\u9ED8\u8BA4\u5217\u8868\u4E0D\u518D\u5C55\u793A)"
+    },
+    "repo": {
+      "list --space <id>": "list task-space VCS connections (available repos; note: the system prompt already lists them for a task \u2014 you rarely need this)",
+      "checkout <taskId> <repoFullName> [--ref <branch|sha>]": "materialize a repo into the task workdir (local daemon endpoint preferred, works same-turn; falls back to server machine protocol which resolves scope + workContext)",
+      "prepare <taskId> <repoFullName>": "materialize a secondary repo into the task workdir (same level as the primary repo dir)",
+      "mr create <repoFullName> --branch <branch> [--base <base>] [--task-code <code>]": "create a GitLab MR for the task via the server channel (target project forced to the bound repo, PR linked immediately; push the branch first)",
+      "mr list <taskId> [--state opened|closed|merged] [--limit <n>]": "list the task-space repos' merge requests (read-only; never approves/merges)"
+    },
+    "attachment": {
+      "upload <file> [--object <id>] [--comment <id>] [--ag-message] [--task <agentTaskId>] [--inline]": "upload a local file and attach it to a task (--object) / comment (--comment) / chat message (--ag-message); for pure chat tasks pass --task <agentTaskId> to attach to the chat session; omit target to auto-merge (object if bound, else chat message)",
+      "list --object <id>": "list attachments for an object",
+      "get <id>": "get attachment details",
+      "download-url <id>": "get signed download URL for an attachment",
+      "delete <id>": "delete attachment"
+    }
+  },
+  globalFlags: {
+    "--env <context>": "select test or a saved context",
+    "--url <baseUrl>": "override API base URL",
+    "--token <token>": "override token for this invocation (not persisted)",
+    "--help": "print this machine-readable command surface",
+    "--version": "print version JSON"
+  },
+  exitCodes: {
+    0: "success",
+    1: "other error",
+    2: "usage error",
+    3: "not found",
+    4: "unauthenticated",
+    5: "forbidden",
+    6: "conflict",
+    7: "upstream/network error"
+  }
+};
+
+// ../morula-cli/src/index.ts
+runEntry({ commands: COMMANDS, help: HELP });