@arcships/morula-runtime 0.1.0-alpha.1 → 0.1.0-alpha.10

package/dist/morula.js

@@ -0,0 +1,4393 @@
+#!/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 = [];
+  const valueOccurrences = {};
+  const recordValue = (key, value) => {
+    flags[key] = value;
+    (valueOccurrences[key] ??= []).push(value);
+  };
+  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) {
+      recordValue(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("--")) {
+      recordValue(key, next);
+      index += 1;
+    } else {
+      flags[key] = true;
+      bareFlags.push(key);
+    }
+  }
+  const repeatedFlags = {};
+  for (const [key, values] of Object.entries(valueOccurrences)) {
+    if (values.length > 1)
+      repeatedFlags[key] = values;
+  }
+  return {
+    command: positionals.shift(),
+    action: positionals.shift(),
+    positionals,
+    flags,
+    bareFlags,
+    repeatedFlags
+  };
+}
+function flagStrings(parsed, name) {
+  const repeated = parsed.repeatedFlags[name];
+  if (repeated?.length)
+    return repeated;
+  const single = flagString(parsed.flags, name);
+  return single === void 0 ? [] : [single];
+}
+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.10";
+var BUILD_ID = "20260922054915.d5e2cc87";
+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/agent-task.js
+var AgentTaskApi = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /** 列出 AgentTask（objectId 必填；status/page/pageSize 可选） */
+  list(query = {}) {
+    return this.client.get("/agent-tasks", query);
+  }
+  /**
+   * 取消执行。
+   *
+   * 服务端语义（`agent-task.controller.ts` cancel，2026-09-20 起）：
+   * - 成功 → 200 `{ ok: true, message: 'Task cancelled' }`；
+   * - 任务不存在 → **404** `NOT_FOUND`；
+   * - 状态不允许（`completed` / `cancelled`）→ **409** `CONFLICT`（带可读原因）。
+   *
+   * 即：**失败会 reject**（不再 200 假成功，见 issues/agent-task-cancel-returns-200-on-failure.md）——
+   * 调用方按异常/退出码判断，不要假定「调用返回了就是已取消」。
+   */
+  cancel(id) {
+    return this.client.post(`/agent-tasks/${encodeURIComponent(requiredId(id))}/cancel`);
+  }
+  /** 重跑失败/已取消的执行（服务端复制原任务重新入队，返回**新** taskId） */
+  rerun(id) {
+    return this.client.post(`/agent-tasks/${encodeURIComponent(requiredId(id))}/rerun`);
+  }
+};
+function requiredId(id) {
+  const normalized = id.trim();
+  if (!normalized)
+    throw new TypeError("agent task id is required");
+  return normalized;
+}
+
+// ../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`);
+  }
+  /**
+   * 读取附件的解析产物全文（MinerU markdown）。
+   * 未解析/解析中/解析失败由服务端在返回体里说明，不当作 HTTP 错误。
+   */
+  content(id, maxChars) {
+    return this.client.get(`/attachments/${encodeURIComponent(id)}/content`, { maxChars });
+  }
+  /** 更新附件关联的资源 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/autopilot.js
+var AutopilotApi = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  list(query = {}) {
+    return this.client.get("/agent-autopilots", query);
+  }
+  create(input) {
+    return this.client.post("/agent-autopilots", input);
+  }
+};
+
+// ../morula-api-client/dist/ci.js
+var CiApi = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /** 任务面 CI 视图（本任务关联的流水线运行 + 部署记录 + 归属依据） */
+  taskView(taskId, query = {}) {
+    return this.client.get(`/agent-tasks/${encodeURIComponent(requiredId2(taskId, "task id"))}/vcs/ci`, query);
+  }
+  /** 任务面部署记录（D3：仅展示，不驱动流转） */
+  taskDeployments(taskId) {
+    return this.client.get(`/agent-tasks/${encodeURIComponent(requiredId2(taskId, "task id"))}/vcs/ci/deployments`);
+  }
+  /** 空间面 CI 巡检视图（管家主入口；`ref` / `failed` / `limit` 为服务端过滤） */
+  spaceView(spaceId, query = {}) {
+    return this.client.get(`/vcs/spaces/${encodeURIComponent(requiredId2(spaceId, "space id"))}/ci`, query);
+  }
+  /** 空间面部署记录（D3：仅展示） */
+  spaceDeployments(spaceId) {
+    return this.client.get(`/vcs/spaces/${encodeURIComponent(requiredId2(spaceId, "space id"))}/ci/deployments`);
+  }
+  /**
+   * job 日志（按 job id；服务端反查所属运行）。
+   *
+   * 两个面共用本端点：任务凭证按 tenantId 收敛，会话凭证按 `connection.spaceId === scopeId` 收敛。
+   * `truncated` 显式返回——日志被尾部截断时调用方必须知道（不能把截断当全文）。
+   */
+  jobLog(jobId, query = {}) {
+    return this.client.get(`/vcs/jobs/${encodeURIComponent(requiredId2(jobId, "job id"))}/log`, query);
+  }
+  /** 失败用例清单（平台可选能力：GitLab test_report 有、GitHub 无 → `CAPABILITY_UNSUPPORTED`） */
+  testReport(runId) {
+    return this.client.get(`/vcs/runs/${encodeURIComponent(requiredId2(runId, "run id"))}/test-report`);
+  }
+  /**
+   * 重跑整条流水线的失败 job（Phase 3；开放面 = 人 + 管家）。
+   *
+   * 只允许 failure / cancelled 的运行，其余状态服务端回 `CI_RETRY_NOT_ALLOWED`（不是 4xx）。
+   * **非幂等**：每次调用都会在平台上产生一次新的重跑，重复调用不会去重。
+   */
+  retryRun(runId) {
+    return this.client.post(`/vcs/runs/${encodeURIComponent(requiredId2(runId, "run id"))}/retry`);
+  }
+  /**
+   * 重跑单个 job（Phase 3；开放面 = 人 + 管家）。
+   *
+   * 服务端按 jobId 反查所属运行（`CI_JOB_NOT_FOUND` 覆盖「job 不存在」与「反查不到运行」两种情况）；
+   * 状态门禁与 `retryRun` 相同。非幂等。
+   */
+  retryJob(jobId) {
+    return this.client.post(`/vcs/jobs/${encodeURIComponent(requiredId2(jobId, "job id"))}/retry`);
+  }
+};
+function requiredId2(id, label) {
+  const normalized = id.trim();
+  if (!normalized)
+    throw new TypeError(`${label} is required`);
+  return normalized;
+}
+
+// ../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;
+  errorCode;
+  name = "MorulaApiError";
+  constructor(code, message, exitCode, status2, retryable = false, details, errorCode) {
+    super(message);
+    this.code = code;
+    this.exitCode = exitCode;
+    this.status = status2;
+    this.retryable = retryable;
+    this.details = details;
+    this.errorCode = errorCode;
+  }
+};
+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 CAUSE_DETAIL_MAX_LENGTH = 200;
+function describeFetchFailure(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const detail = formatFetchCause(error?.cause);
+  return detail ? `${message} (cause: ${detail})` : message;
+}
+function formatFetchCause(cause) {
+  if (cause === void 0 || cause === null)
+    return "";
+  if (cause instanceof Error) {
+    const detail = cause;
+    const parts = [
+      typeof detail.code === "string" ? detail.code : "",
+      typeof detail.errno === "number" || typeof detail.errno === "string" ? `errno=${detail.errno}` : "",
+      typeof detail.syscall === "string" ? `syscall=${detail.syscall}` : "",
+      // cause 的 message 常与外层重复（'fetch failed'），只有不同才带
+      detail.message && detail.message !== "fetch failed" ? detail.message : ""
+    ].filter(Boolean);
+    return parts.join(" ").slice(0, CAUSE_DETAIL_MAX_LENGTH);
+  }
+  return String(cause).slice(0, CAUSE_DETAIL_MAX_LENGTH);
+}
+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: ${describeFetchFailure(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;
+  const errorCode = extractErrorCode(parsed);
+  if (status2 === 400 || status2 === 422) {
+    return new MorulaApiError("BAD_REQUEST", message, EXIT_CODE.USAGE, status2, false, details, errorCode);
+  }
+  if (status2 === 401) {
+    return new MorulaApiError("UNAUTHENTICATED", message, EXIT_CODE.UNAUTHENTICATED, status2, false, details, errorCode);
+  }
+  if (status2 === 403) {
+    return new MorulaApiError("FORBIDDEN", message, EXIT_CODE.FORBIDDEN, status2, false, details, errorCode);
+  }
+  if (status2 === 404) {
+    return new MorulaApiError("NOT_FOUND", message, EXIT_CODE.NOT_FOUND, status2, false, details, errorCode);
+  }
+  if (status2 === 409) {
+    return new MorulaApiError("CONFLICT", message, EXIT_CODE.CONFLICT, status2, false, details, errorCode);
+  }
+  if (status2 === 429) {
+    return new MorulaApiError("RATE_LIMITED", message, EXIT_CODE.UPSTREAM, status2, true, details, errorCode);
+  }
+  if (status2 >= 500) {
+    return new MorulaApiError("UPSTREAM", message, EXIT_CODE.UPSTREAM, status2, true, details, errorCode);
+  }
+  return new MorulaApiError("HTTP_ERROR", message, EXIT_CODE.OTHER, status2, false, details, errorCode);
+}
+function extractErrorCode(parsed) {
+  if (!parsed || typeof parsed !== "object")
+    return void 0;
+  const value = parsed.errorCode;
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+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(requiredId3(id))}`);
+  }
+  create(input) {
+    return this.client.post("/comments", input);
+  }
+  update(id, input) {
+    return this.client.patch(`/comments/${encodeURIComponent(requiredId3(id))}`, input);
+  }
+  delete(id) {
+    return this.client.delete(`/comments/${encodeURIComponent(requiredId3(id))}`);
+  }
+};
+function requiredId3(id) {
+  const normalized = id.trim();
+  if (!normalized)
+    throw new TypeError("comment id is required");
+  return normalized;
+}
+
+// ../morula-api-client/dist/dashboard.js
+var DashboardApi = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  get(spaceId) {
+    return this.client.get(`/spaces/${encodeURIComponent(requiredId4(spaceId))}/dashboard`);
+  }
+  statistics(spaceId) {
+    return this.client.get(`/spaces/${encodeURIComponent(requiredId4(spaceId))}/statistics`);
+  }
+  workload(spaceId) {
+    return this.client.get(`/spaces/${encodeURIComponent(requiredId4(spaceId))}/workload`);
+  }
+};
+function requiredId4(id) {
+  const normalized = id.trim();
+  if (!normalized)
+    throw new TypeError("space id is required");
+  return normalized;
+}
+
+// ../morula-api-client/dist/document.js
+var DocumentApi = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  list(query = {}) {
+    return this.client.get("/documents", query);
+  }
+  get(id) {
+    return this.client.get(`/documents/${encodeURIComponent(requiredId5(id))}`);
+  }
+  /** 已解析归档的文档内容（Markdown 正文等） */
+  artifacts(id) {
+    return this.client.get(`/documents/${encodeURIComponent(requiredId5(id))}/artifacts`);
+  }
+};
+function requiredId5(id) {
+  const normalized = String(id).trim();
+  if (!normalized)
+    throw new TypeError("document id is required");
+  return normalized;
+}
+
+// ../morula-api-client/dist/object-meta.js
+var ObjectMetaApi = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  list(objectId) {
+    return this.client.get(`/objects/${encodeURIComponent(requiredId6(objectId))}/agent-meta`);
+  }
+  set(objectId, key, value) {
+    return this.client.request(`/objects/${encodeURIComponent(requiredId6(objectId))}/agent-meta/${encodeURIComponent(requiredKey(key))}`, { method: "PUT", body: { value } });
+  }
+};
+function requiredId6(id) {
+  const normalized = id.trim();
+  if (!normalized)
+    throw new TypeError("object id is required");
+  return normalized;
+}
+function requiredKey(key) {
+  const normalized = key.trim();
+  if (!normalized)
+    throw new TypeError("meta key is required");
+  return normalized;
+}
+
+// ../morula-api-client/dist/repo.js
+var RepoApi = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /** 目录清单（path 缺省 = 仓库根） */
+  files(spaceId, query = {}) {
+    return this.client.get(`/spaces/${encodeURIComponent(requiredId7(spaceId))}/repo/files`, query);
+  }
+  /** 单文件内容（path 必填） */
+  read(spaceId, query) {
+    return this.client.get(`/spaces/${encodeURIComponent(requiredId7(spaceId))}/repo/file`, query);
+  }
+};
+function requiredId7(id) {
+  const normalized = id.trim();
+  if (!normalized)
+    throw new TypeError("space 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(requiredId8(id))}`);
+  }
+  listByAutopilot(autopilotId, query = {}) {
+    return this.client.get(`/agent-autopilots/${encodeURIComponent(requiredId8(autopilotId, "autopilot"))}/reports`, { ...query });
+  }
+};
+function requiredId8(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(requiredId9(id))}`);
+  }
+  create(input) {
+    return this.client.post("/space-members", input);
+  }
+  update(id, input) {
+    return this.client.patch(`/space-members/${encodeURIComponent(requiredId9(id))}`, input);
+  }
+  delete(id) {
+    return this.client.delete(`/space-members/${encodeURIComponent(requiredId9(id))}`);
+  }
+};
+function requiredId9(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(requiredId10(id))}`);
+  }
+  create(input) {
+    return this.client.post("/spaces", input);
+  }
+  update(id, input) {
+    return this.client.patch(`/spaces/${encodeURIComponent(requiredId10(id))}`, input);
+  }
+  delete(id) {
+    return this.client.delete(`/spaces/${encodeURIComponent(requiredId10(id))}`);
+  }
+};
+function requiredId10(id) {
+  const normalized = id.trim();
+  if (!normalized)
+    throw new TypeError("space id is required");
+  return normalized;
+}
+
+// ../morula-api-client/dist/steward.js
+var StewardApi = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /** 管家信息（未接管的空间返回 null） */
+  get(projectId) {
+    return this.client.get(`/stewards/projects/${encodeURIComponent(requiredId11(projectId))}`);
+  }
+  /** 派单：建任务并派发（目标状态由 state 决定，backlog 不派发执行） */
+  dispatch(projectId, input) {
+    return this.client.post(`/stewards/projects/${encodeURIComponent(requiredId11(projectId))}/dispatch`, input);
+  }
+};
+function requiredId11(id) {
+  const normalized = id.trim();
+  if (!normalized)
+    throw new TypeError("project 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(requiredId12(id))}`);
+  }
+  create(input) {
+    return this.client.post("/objects", input);
+  }
+  update(id, input) {
+    return this.client.patch(`/objects/${encodeURIComponent(requiredId12(id))}`, input);
+  }
+  delete(id) {
+    return this.client.delete(`/objects/${encodeURIComponent(requiredId12(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 requiredId12(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;
+  agentTasks;
+  attachments;
+  auth;
+  autopilots;
+  ci;
+  comments;
+  dashboard;
+  documents;
+  objectMeta;
+  reports;
+  repos;
+  tasks;
+  spaces;
+  spaceMembers;
+  stewards;
+  webhooks;
+  constructor(options) {
+    this.http = new MorulaApiClient(options);
+    this.agentTasks = new AgentTaskApi(this.http);
+    this.attachments = new AttachmentApi(this.http);
+    this.auth = new AuthApi(this.http);
+    this.autopilots = new AutopilotApi(this.http);
+    this.ci = new CiApi(this.http);
+    this.comments = new CommentApi(this.http);
+    this.dashboard = new DashboardApi(this.http);
+    this.documents = new DocumentApi(this.http);
+    this.objectMeta = new ObjectMetaApi(this.http);
+    this.reports = new ReportApi(this.http);
+    this.repos = new RepoApi(this.http);
+    this.tasks = new TaskApi(this.http);
+    this.spaces = new SpaceApi(this.http);
+    this.spaceMembers = new SpaceMemberApi(this.http);
+    this.stewards = new StewardApi(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 } : {},
+      ...f.repeatable ? { repeatable: true } : {}
+    })),
+    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 [name, values] of Object.entries(parsed.repeatedFlags)) {
+    if (values.length < 2)
+      continue;
+    const spec = declaredFlags.find((f) => f.name === name);
+    if (spec?.repeatable)
+      continue;
+    throw usage(`duplicate flag --${name} (given ${values.length} times; only the last value would be used)`, {
+      hint: usageHint
+    });
+  }
+  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 (!options.excludeTaskToken && env.MORULA_SESSION_TOKEN)
+    return { token: env.MORULA_SESSION_TOKEN, tokenSource: "env:MORULA_SESSION_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 } : {},
+        // 服务端业务错误码（如 SESSION_SCOPE_DENIED）：`code` 是按 HTTP 状态派生的粗档位，
+        // 行为契约要判断的是业务码——不打印出来，契约就永远不可执行
+        // （issues/api-client-drops-business-error-code.md）。退出码仍由 `error.exitCode` 决定。
+        ...error instanceof MorulaApiError && error.errorCode ? { errorCode: error.errorCode } : {},
+        // 新增字段（可选）：可执行的下一步 + 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 === "content") {
+    rejectUnknownFlags(flags, ["max-chars"]);
+    return context.client.attachments.content(
+      requireId(positionals, "attachment content"),
+      flagNumber(flags, "max-chars")
+    );
+  }
+  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/autopilot.ts
+async function autopilotCommand(context) {
+  if (!context.runtime.token)
+    throw new CliError("UNAUTHENTICATED", EXIT.UNAUTHENTICATED, "\u8BF7\u5148\u8FD0\u884C morula auth login");
+  const { action, flags } = context.parsed;
+  if (action === "list") {
+    rejectUnknownFlags(flags, ["space", "page", "page-size"]);
+    return context.client.autopilots.list({
+      spaceId: flagString(flags, "space"),
+      page: flagNumber(flags, "page"),
+      pageSize: flagNumber(flags, "page-size")
+    });
+  }
+  if (action === "create") {
+    rejectUnknownFlags(flags, ["space", "name", "runbook", "executor", "description", "cron", "vcs-connection"]);
+    const spaceId = requireFlag(flags, "space");
+    const name = requireFlag(flags, "name");
+    const runbook = requireFlag(flags, "runbook");
+    const executorKey = requireFlag(flags, "executor");
+    const description = flagString(flags, "description");
+    const cronExpr = flagString(flags, "cron");
+    const vcsConnectionId = flagString(flags, "vcs-connection");
+    return context.client.autopilots.create({
+      spaceId,
+      name,
+      runbook,
+      executorKey,
+      ...description !== void 0 ? { description } : {},
+      ...cronExpr !== void 0 ? { cronExpr } : {},
+      ...vcsConnectionId !== void 0 ? { vcsConnectionId } : {}
+    });
+  }
+  throw usage("usage: morula autopilot <list|create>");
+}
+
+// ../morula-cli/src/commands/ci.ts
+async function ciCommand(context) {
+  if (!context.runtime.token)
+    throw new CliError("UNAUTHENTICATED", EXIT.UNAUTHENTICATED, "\u8BF7\u5148\u8FD0\u884C morula auth login");
+  const { action } = context.parsed;
+  if (action === "status")
+    return ciStatus(context);
+  if (action === "log")
+    return ciLog(context);
+  if (action === "deployments")
+    return ciDeployments(context);
+  if (action === "test-report")
+    return ciTestReport(context);
+  if (action === "retry")
+    return ciRetry(context);
+  throw usage("usage: morula ci <status|log|deployments|test-report|retry>");
+}
+async function ciStatus(context) {
+  const { positionals, flags } = context.parsed;
+  rejectUnknownFlags(flags, ["space", "repo", "ref", "failed", "limit"]);
+  const repo = flagString(flags, "repo");
+  const ref = flagString(flags, "ref");
+  const failed = flagBoolean(flags, "failed");
+  const limit = flagNumber(flags, "limit");
+  if (limit != null && (!Number.isInteger(limit) || limit <= 0))
+    throw usage("--limit \u5FC5\u987B\u662F\u6B63\u6574\u6570");
+  const face = resolveFace(context, "usage: morula ci status <taskId> [--repo <owner/name>] [--limit <n>] | morula ci status --space <spaceId> [--ref <branch>] [--failed] [--limit <n>]");
+  if (face.kind === "space") {
+    if (repo)
+      throw usage("--repo \u53EA\u5728\u4EFB\u52A1\u9762\u53EF\u7528\uFF1A\u7A7A\u95F4\u9762\u8BF7\u7528 --ref \u8FC7\u6EE4\u5206\u652F\uFF08\u670D\u52A1\u7AEF\u4E0D\u652F\u6301\u6309\u4ED3\u5E93\u8FC7\u6EE4\uFF09");
+    const result2 = await context.client.ci.spaceView(face.spaceId, {
+      ...ref ? { ref } : {},
+      ...failed ? { failed: true } : {},
+      ...limit ? { limit } : {}
+    });
+    if (result2.ok === false)
+      throw ciFailure(result2);
+    return result2;
+  }
+  const result = await context.client.ci.taskView(face.taskId, { ...limit ? { limit } : {} });
+  if (result.ok === false)
+    throw ciFailure(result);
+  if (!repo)
+    return result;
+  const runs = result.runs.filter((run2) => run2.repoFullName === repo);
+  return { ...result, runs, repoFilter: { repo, total: result.runs.length, matched: runs.length } };
+}
+async function ciLog(context) {
+  const { flags } = context.parsed;
+  rejectUnknownFlags(flags, ["space", "job", "tail"]);
+  const jobId = flagString(flags, "job");
+  if (!jobId)
+    throw usage("usage: morula ci log <taskId> --job <jobId> [--tail <n>] | morula ci log --space <spaceId> --job <jobId> [--tail <n>]");
+  const tail = flagNumber(flags, "tail");
+  if (tail != null && (!Number.isInteger(tail) || tail <= 0))
+    throw usage("--tail \u5FC5\u987B\u662F\u6B63\u6574\u6570\uFF08\u4FDD\u7559\u7684\u65E5\u5FD7\u5C3E\u90E8\u5B57\u8282\u6570\uFF09");
+  resolveFace(context, "usage: morula ci log <taskId> --job <jobId> [--tail <n>] | morula ci log --space <spaceId> --job <jobId> [--tail <n>]");
+  const result = await context.client.ci.jobLog(jobId, { ...tail ? { tail } : {} });
+  if (result.ok === false)
+    throw ciFailure(result);
+  return result;
+}
+async function ciDeployments(context) {
+  const { flags } = context.parsed;
+  rejectUnknownFlags(flags, ["space"]);
+  const face = resolveFace(context, "usage: morula ci deployments <taskId> | morula ci deployments --space <spaceId>");
+  const result = face.kind === "space" ? await context.client.ci.spaceDeployments(face.spaceId) : await context.client.ci.taskDeployments(face.taskId);
+  if (result.ok === false)
+    throw ciFailure(result);
+  return result;
+}
+async function ciTestReport(context) {
+  const { flags } = context.parsed;
+  rejectUnknownFlags(flags, ["space", "run"]);
+  const runFlag = flagString(flags, "run");
+  const face = resolveFace(context, "usage: morula ci test-report <taskId> [--run <runId>] | morula ci test-report --space <spaceId> [--run <runId>]");
+  let runId = runFlag;
+  if (!runId) {
+    const view = face.kind === "space" ? await context.client.ci.spaceView(face.spaceId) : await context.client.ci.taskView(face.taskId);
+    if (view.ok === false)
+      throw ciFailure(view);
+    runId = view.runs[0]?.id;
+    if (!runId) {
+      throw new CliError(
+        "CI_RUN_NOT_FOUND",
+        EXIT.NOT_FOUND,
+        face.kind === "space" ? "\u8BE5\u7A7A\u95F4\u6CA1\u6709\u6D41\u6C34\u7EBF\u8FD0\u884C\u8BB0\u5F55\uFF0C\u53D6\u4E0D\u5230\u5931\u8D25\u7528\u4F8B\u6E05\u5355\uFF08\u53EF\u5148\u7528 morula ci status --space <id> \u786E\u8BA4\uFF09" : "\u672C\u4EFB\u52A1\u6CA1\u6709\u6D41\u6C34\u7EBF\u8FD0\u884C\u8BB0\u5F55\uFF0C\u53D6\u4E0D\u5230\u5931\u8D25\u7528\u4F8B\u6E05\u5355\uFF08\u53EF\u5148\u7528 morula ci status <taskId> \u786E\u8BA4\uFF09"
+      );
+    }
+  }
+  const result = await context.client.ci.testReport(runId);
+  if (result.ok === false)
+    throw ciFailure(result);
+  return result;
+}
+async function ciRetry(context) {
+  const { positionals, flags } = context.parsed;
+  rejectUnknownFlags(flags, ["space", "run", "job"]);
+  const usageHint = "usage: morula ci retry --space <spaceId> [--run <runId>] [--job <jobId>]";
+  if (positionals.length)
+    throw usage(`\u91CD\u8DD1\u53EA\u5728\u7A7A\u95F4\u9762\u5F00\u653E\uFF1A\u8BF7\u7528 --space <spaceId>\uFF08\u4EFB\u52A1\u9762\u4E0D\u63D0\u4F9B retry\uFF09\u3002${usageHint}`);
+  const runId = flagString(flags, "run");
+  const jobId = flagString(flags, "job");
+  if (runId && jobId)
+    throw usage(`--run \u4E0E --job \u4E92\u65A5\uFF0C\u53EA\u80FD\u7ED9\u4E00\u4E2A\uFF08${usageHint}\uFF09`);
+  const spaceId = flagString(flags, "space");
+  if (!spaceId)
+    throw usage(usageHint);
+  if (jobId) {
+    const result2 = await context.client.ci.retryJob(jobId);
+    if (result2.ok === false)
+      throw ciFailure(result2, "\u64CD\u4F5C");
+    return result2;
+  }
+  let targetRunId = runId;
+  if (!targetRunId) {
+    const view = await context.client.ci.spaceView(spaceId, { failed: true });
+    if (view.ok === false)
+      throw ciFailure(view);
+    targetRunId = view.runs[0]?.id;
+    if (!targetRunId) {
+      throw new CliError(
+        "CI_RUN_NOT_FOUND",
+        EXIT.NOT_FOUND,
+        `\u7A7A\u95F4 ${spaceId} \u6CA1\u6709\u5931\u8D25\u7684\u6D41\u6C34\u7EBF\u8FD0\u884C\u53EF\u91CD\u8DD1\uFF08\u53EF\u5148\u7528 morula ci status --space ${spaceId} --failed \u786E\u8BA4\uFF09`
+      );
+    }
+  }
+  const result = await context.client.ci.retryRun(targetRunId);
+  if (result.ok === false)
+    throw ciFailure(result, "\u64CD\u4F5C");
+  return result;
+}
+function resolveFace(context, usageHint) {
+  const taskId = context.parsed.positionals[0]?.trim();
+  const spaceId = flagString(context.parsed.flags, "space");
+  if (taskId && spaceId)
+    throw usage(`<taskId> \u4E0E --space \u4E92\u65A5\uFF0C\u53EA\u80FD\u7ED9\u4E00\u4E2A\uFF08${usageHint}\uFF09`);
+  if (!taskId && !spaceId)
+    throw usage(usageHint);
+  return taskId ? { kind: "task", taskId } : { kind: "space", spaceId };
+}
+function ciFailure(failure, verb = "\u67E5\u8BE2") {
+  return new CliError(
+    failure.code,
+    exitForCiCode(failure.code),
+    `CI ${verb}\u5931\u8D25: ${failure.message || "\u672A\u77E5\u539F\u56E0"}\uFF08${failure.code}\uFF09`
+  );
+}
+function exitForCiCode(code) {
+  if (code === "CI_RETRY_NOT_ALLOWED" || code === "CI_JOB_NOT_MANUAL")
+    return EXIT.CONFLICT;
+  if (code === "CI_JOB_NOT_FOUND" || code === "CI_RUN_NOT_FOUND" || code === "TASK_NOT_FOUND" || code === "OBJECT_NOT_FOUND")
+    return EXIT.NOT_FOUND;
+  return EXIT.OTHER;
+}
+
+// ../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", "mention"]);
+    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 mentions = parseMentions(flagStrings(context.parsed, "mention"));
+    const input = compact({
+      objectId,
+      content,
+      parentCommentId: flagString(flags, "parent"),
+      contentFormat: format,
+      // 无 --mention 时**不带** mentions 字段（服务端按缺省处理，不发任何通知）
+      ...mentions.length ? { mentions } : {}
+    });
+    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));
+}
+function parseMentions(rawValues) {
+  const seen = /* @__PURE__ */ new Set();
+  const mentions = [];
+  for (const raw of rawValues) {
+    for (const part of raw.split(",")) {
+      const principalId = part.trim();
+      if (!principalId || seen.has(principalId))
+        continue;
+      seen.add(principalId);
+      mentions.push({ type: "member", principalId });
+    }
+  }
+  return mentions;
+}
+
+// ../morula-cli/src/commands/dashboard.ts
+async function dashboardCommand(context) {
+  if (!context.runtime.token)
+    throw new CliError("UNAUTHENTICATED", EXIT.UNAUTHENTICATED, "\u8BF7\u5148\u8FD0\u884C morula auth login");
+  const { action, flags } = context.parsed;
+  if (action === "get") {
+    rejectUnknownFlags(flags, ["space"]);
+    return context.client.dashboard.get(requireFlag(flags, "space"));
+  }
+  if (action === "statistics") {
+    rejectUnknownFlags(flags, ["space"]);
+    return context.client.dashboard.statistics(requireFlag(flags, "space"));
+  }
+  if (action === "workload") {
+    rejectUnknownFlags(flags, ["space"]);
+    return context.client.dashboard.workload(requireFlag(flags, "space"));
+  }
+  throw usage("usage: morula dashboard <get|statistics|workload>");
+}
+
+// ../morula-cli/src/commands/document.ts
+async function documentCommand(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"]);
+    return context.client.documents.list({
+      page: flagNumber(flags, "page"),
+      pageSize: flagNumber(flags, "page-size")
+    });
+  }
+  if (action === "get") {
+    rejectUnknownFlags(flags, []);
+    return context.client.documents.get(requireId2(positionals, "document get"));
+  }
+  if (action === "artifacts") {
+    rejectUnknownFlags(flags, []);
+    return context.client.documents.artifacts(requireId2(positionals, "document artifacts"));
+  }
+  throw usage("usage: morula document <list|get|artifacts>");
+}
+function requireId2(positionals, command) {
+  const id = positionals[0]?.trim();
+  if (!id)
+    throw usage(`usage: morula ${command} <id>`);
+  return id;
+}
+
+// ../morula-cli/src/commands/object-meta.ts
+async function objectMetaCommand(context) {
+  if (!context.runtime.token)
+    throw new CliError("UNAUTHENTICATED", EXIT.UNAUTHENTICATED, "\u8BF7\u5148\u8FD0\u884C morula auth login");
+  const { action, flags } = context.parsed;
+  if (action === "get") {
+    rejectUnknownFlags(flags, ["object"]);
+    return context.client.objectMeta.list(requireFlag(flags, "object"));
+  }
+  if (action === "set") {
+    rejectUnknownFlags(flags, ["object", "key", "value"]);
+    return context.client.objectMeta.set(
+      requireFlag(flags, "object"),
+      requireFlag(flags, "key"),
+      requireFlag(flags, "value")
+    );
+  }
+  throw usage("usage: morula object-meta <get|set>");
+}
+
+// ../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);
+  }
+  if (action === "mr" && positionals[0] === "comment") {
+    return mrComment(context, flags);
+  }
+  if (action === "mr" && positionals[0] === "get") {
+    return mrGet(context, flags);
+  }
+  if (action === "mr" && positionals[0] === "diff") {
+    return mrDiff(context, flags);
+  }
+  if (action === "files") {
+    rejectUnknownFlags(flags, ["space", "repo", "path", "ref"]);
+    const spaceId = flagString(flags, "space");
+    if (!spaceId)
+      throw usage("usage: morula repo files --space <id> [--repo <owner/name>] [--path <p>] [--ref <r>]");
+    return context.client.repos.files(spaceId, {
+      repo: flagString(flags, "repo"),
+      path: flagString(flags, "path"),
+      ref: flagString(flags, "ref")
+    });
+  }
+  if (action === "read") {
+    rejectUnknownFlags(flags, ["space", "repo", "path", "ref"]);
+    const spaceId = flagString(flags, "space");
+    const path = flagString(flags, "path");
+    if (!spaceId || !path)
+      throw usage("usage: morula repo read --space <id> --path <p> [--repo <owner/name>] [--ref <r>]");
+    return context.client.repos.read(spaceId, {
+      path,
+      repo: flagString(flags, "repo"),
+      ref: flagString(flags, "ref")
+    });
+  }
+  throw usage("usage: morula repo <list|checkout|prepare|files|read|mr create|mr list|mr comment|mr get|mr diff>");
+}
+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) {
+        process.stderr.write("[morula-cli] mr create \u5206\u652F\u5DF2\u6709 opened MR\uFF0C\u590D\u7528\u73B0\u6709 MR\n");
+        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", "author", "repo"]);
+  const taskId = context.parsed.positionals[1]?.trim();
+  if (!taskId)
+    throw usage("usage: morula repo mr list <taskId> [--state opened|all|merged|closed] [--limit <n>] [--author <username>] [--repo <owner/name>]");
+  const state = flagString(flags, "state") ?? "opened";
+  const limit = flagNumber(flags, "limit");
+  const author = flagString(flags, "author");
+  const repo = flagString(flags, "repo");
+  const result = await context.client.http.get(
+    `/agent-tasks/${taskId}/vcs/mr-list`,
+    {
+      state,
+      ...limit ? { limit } : {},
+      ...author ? { author } : {},
+      ...repo ? { repoFullName: repo } : {}
+    }
+  );
+  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 mrComment(context, flags) {
+  rejectUnknownFlags(flags, ["mr", "repo", "connection", "content", "content-file"]);
+  const taskId = context.parsed.positionals[1]?.trim();
+  if (!taskId)
+    throw usage("usage: morula repo mr comment <taskId> --mr <iid> [--repo <owner/name>] [--connection <id>] (--content <text> | --content-file <path>)");
+  const mrIid = flagNumber(flags, "mr");
+  if (mrIid == null || !Number.isInteger(mrIid) || mrIid <= 0)
+    throw usage("--mr \u5FC5\u987B\u662F\u6B63\u6574\u6570\uFF08MR/PR \u7F16\u53F7\uFF09");
+  const repo = flagString(flags, "repo");
+  const connection = flagString(flags, "connection");
+  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("\u8BC4\u8BBA\u6B63\u6587\u5FC5\u586B\uFF1A--content <text> \u6216 --content-file <path>");
+  let body = inline ?? "";
+  if (filePath) {
+    try {
+      const { readFile: readFile3 } = await import("node:fs/promises");
+      body = await readFile3(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 (!body?.trim())
+    throw usage("\u8BC4\u8BBA\u6B63\u6587\u4E0D\u80FD\u4E3A\u7A7A");
+  if (body.length > 2e4)
+    throw usage(`\u8BC4\u8BBA\u6B63\u6587\u8D85\u8FC7 20000 \u5B57\u7B26\u4E0A\u9650\uFF1A\u957F\u5185\u5BB9\u8BF7\u7528 morula report create --content-file \u5199\u6210\u62A5\u544A\uFF0C\u8BC4\u8BBA\u91CC\u7ED9\u6458\u8981`);
+  const result = await context.client.http.post(`/agent-tasks/${taskId}/vcs/mr-comment`, {
+    mrIid,
+    body,
+    ...repo ? { repoFullName: repo } : {},
+    ...connection ? { connectionId: connection } : {}
+  });
+  if (result?.ok === false) {
+    throw new CliError(
+      result.code ?? "MR_COMMENT_FAILED",
+      exitFor(result.code),
+      `MR \u8BC4\u8BBA\u5199\u5165\u5931\u8D25: ${result.message ?? result.code ?? "\u672A\u77E5\u539F\u56E0"}`
+    );
+  }
+  return result;
+}
+function exitFor(code) {
+  if (code === "TASK_NOT_FOUND" || code === "NO_CONNECTION")
+    return EXIT.NOT_FOUND;
+  if (code === "MR_NOT_ALLOWED" || code === "CONTENT_TOO_LARGE")
+    return EXIT.USAGE;
+  if (code === "MR_COMMENT_FAILED")
+    return EXIT.UPSTREAM;
+  return EXIT.OTHER;
+}
+async function mrGet(context, flags) {
+  rejectUnknownFlags(flags, ["mr", "repo", "ci", "notes"]);
+  const taskId = context.parsed.positionals[1]?.trim();
+  if (!taskId)
+    throw usage("usage: morula repo mr get <taskId> --mr <iid> [--repo <owner/name>] [--ci] [--notes]");
+  const mrIid = flagNumber(flags, "mr");
+  if (mrIid == null || !Number.isInteger(mrIid) || mrIid <= 0)
+    throw usage("--mr \u5FC5\u987B\u662F\u6B63\u6574\u6570\uFF08MR/PR \u7F16\u53F7\uFF09");
+  const repo = flagString(flags, "repo");
+  const ci = !!flags["ci"];
+  const notes = !!flags["notes"];
+  const result = await context.client.http.get(
+    `/agent-tasks/${taskId}/vcs/mr-detail`,
+    {
+      mrIid,
+      ...repo ? { repoFullName: repo } : {},
+      ...ci ? { ci: 1 } : {},
+      ...notes ? { notes: 1 } : {}
+    }
+  );
+  if (result?.ok === false)
+    throw new CliError(result.code ?? "MR_QUERY_FAILED", EXIT.OTHER, `MR \u8BE6\u60C5\u67E5\u8BE2\u5931\u8D25: ${result.message ?? result.code ?? "\u672A\u77E5\u539F\u56E0"}`);
+  return result;
+}
+async function mrDiff(context, flags) {
+  rejectUnknownFlags(flags, ["mr", "repo", "max-files", "max-chars"]);
+  const taskId = context.parsed.positionals[1]?.trim();
+  if (!taskId)
+    throw usage("usage: morula repo mr diff <taskId> --mr <iid> [--repo <owner/name>] [--max-files <n>] [--max-chars <n>]");
+  const mrIid = flagNumber(flags, "mr");
+  if (mrIid == null || !Number.isInteger(mrIid) || mrIid <= 0)
+    throw usage("--mr \u5FC5\u987B\u662F\u6B63\u6574\u6570\uFF08MR/PR \u7F16\u53F7\uFF09");
+  const repo = flagString(flags, "repo");
+  const maxFiles = flagNumber(flags, "max-files");
+  const maxChars = flagNumber(flags, "max-chars");
+  if (maxFiles != null && maxFiles <= 0)
+    throw usage("--max-files \u5FC5\u987B\u662F\u6B63\u6574\u6570");
+  if (maxChars != null && maxChars <= 0)
+    throw usage("--max-chars \u5FC5\u987B\u662F\u6B63\u6574\u6570");
+  const result = await context.client.http.get(
+    `/agent-tasks/${taskId}/vcs/mr-diff`,
+    {
+      mrIid,
+      ...repo ? { repoFullName: repo } : {},
+      ...maxFiles ? { maxFiles } : {},
+      ...maxChars ? { maxChars } : {}
+    }
+  );
+  if (result?.ok === false)
+    throw new CliError(result.code ?? "MR_QUERY_FAILED", EXIT.OTHER, `MR diff \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";
+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"]);
+    const autopilotId = flagString(flags, "autopilot");
+    if (!autopilotId)
+      throw usage("usage: morula report list --autopilot <id> [--page <n>] [--page-size <n>]");
+    const query = {
+      page: flagNumber(flags, "page"),
+      pageSize: flagNumber(flags, "page-size")
+    };
+    return context.client.reports.listByAutopilot(autopilotId, query);
+  }
+  throw usage(`usage: morula report <create|get|list>
+
+  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`);
+}
+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;
+}
+
+// ../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);
+  }
+  if (action === "create") {
+    rejectUnknownFlags(flags, ["name", "description", "code", "visibility"]);
+    return context.client.spaces.create({
+      name: requireFlag(flags, "name"),
+      description: flagString(flags, "description"),
+      code: flagString(flags, "code"),
+      visibility: flagString(flags, "visibility")
+    });
+  }
+  if (action === "update") {
+    rejectUnknownFlags(flags, ["name", "description", "visibility"]);
+    const id = requireId3(positionals, "space update");
+    const input = {
+      name: flagString(flags, "name"),
+      description: flagString(flags, "description"),
+      visibility: flagString(flags, "visibility")
+    };
+    if (Object.values(input).every((value) => value === void 0))
+      throw usage("space update \u81F3\u5C11\u9700\u8981\u4E00\u4E2A\u5B57\u6BB5\u65D7\u6807\uFF08--name / --description / --visibility\uFF09");
+    return context.client.spaces.update(id, input);
+  }
+  if (action === "delete") {
+    rejectUnknownFlags(flags, []);
+    return context.client.spaces.delete(requireId3(positionals, "space delete"));
+  }
+  throw usage("usage: morula space <list|get|create|update|delete>");
+}
+function requireId3(positionals, command) {
+  const id = positionals[0]?.trim();
+  if (!id)
+    throw usage(`usage: morula ${command} <id>`);
+  return id;
+}
+
+// ../morula-cli/src/commands/spec.ts
+var SPEC = {
+  name: "morula",
+  summary: "Agent-first CLI for Morula task management (plugin surface, injected into task workspaces). Success output is JSON on stdout; errors are JSON on stderr.",
+  resources: [
+    {
+      resource: "auth",
+      summary: "SkyDoor authentication (shared config with morula-runtime)",
+      actions: [
+        {
+          action: "login",
+          summary: "browser SkyDoor SSO using PKCE and loopback callback (writes ~/.morula-cli/config.yaml)",
+          flags: [{ name: "url", type: "string", valueHint: "<baseUrl>", description: "server base URL to log in to" }],
+          examples: ["morula auth login"],
+          writes: "local",
+          interactive: true,
+          emits: ["loggedIn", "context", "baseUrl", "expiresIn"]
+        },
+        {
+          action: "logout",
+          summary: "remove the current context token",
+          flags: [],
+          examples: ["morula auth logout"],
+          writes: "local",
+          idempotent: true,
+          emits: ["loggedIn", "context"]
+        },
+        {
+          action: "status",
+          summary: "show context, endpoint, and authentication state",
+          flags: [],
+          examples: ["morula auth status"],
+          writes: "none",
+          idempotent: true,
+          emits: ["loggedIn", "context", "baseUrl", "user", "expired"]
+        }
+      ]
+    },
+    {
+      resource: "task",
+      summary: "task (business Object) read/write + AgentTask machine protocol (branch/state/analysis-verdict/inbox)",
+      actions: [
+        {
+          action: "list",
+          summary: "list tasks (--mine: \u4EC5\u6211\u8D1F\u8D23\u7684\uFF1B--field key=value \u81EA\u5B9A\u4E49\u5B57\u6BB5\u7B5B\u9009\uFF0C\u9700 --space)",
+          flags: [
+            { name: "space", type: "string", valueHint: "<id>", description: "space id" },
+            { name: "mine", type: "boolean", description: "\u4EC5\u6211\u8D1F\u8D23\u7684\uFF08\u4E0E --assignee \u4E92\u65A5\uFF09" },
+            { name: "assignee", type: "string", valueHint: "<principalId>", description: "\u6309\u8D1F\u8D23\u4EBA\u8FC7\u6EE4" },
+            { name: "principal", type: "string", valueHint: "<id>", description: "\u6309\u521B\u5EFA\u4EBA\u8FC7\u6EE4" },
+            { name: "page", type: "number", valueHint: "<n>", description: "\u9875\u7801" },
+            { name: "page-size", type: "number", valueHint: "<n>", description: "\u6BCF\u9875\u6761\u6570" },
+            { name: "search", type: "string", valueHint: "<text>", description: "\u5173\u952E\u8BCD\u641C\u7D22" },
+            { name: "priority", type: "string", valueHint: "<low|medium|high|urgent>", description: "\u4F18\u5148\u7EA7\u8FC7\u6EE4" },
+            { name: "state", type: "string", valueHint: "<id>", description: "\u72B6\u6001\u8FC7\u6EE4" },
+            { name: "sort", type: "string", valueHint: "<field>", description: "\u6392\u5E8F\u5B57\u6BB5" },
+            { name: "order", type: "string", valueHint: "<asc|desc>", description: "\u6392\u5E8F\u65B9\u5411" },
+            { name: "field", type: "string", valueHint: "key=value[,key=value]", description: "\u81EA\u5B9A\u4E49\u5B57\u6BB5\u7B49\u503C\u7B5B\u9009\uFF08\u591A\u6761\u4EF6 AND\uFF1B\u9700 --space \u89E3\u6790\u5B57\u6BB5\u6A21\u677F\uFF09" }
+          ],
+          examples: ["morula task list --space <id>", "morula task list --mine", "morula task list --space <id> --field priority=p1"],
+          writes: "none",
+          idempotent: true
+        },
+        {
+          action: "create",
+          summary: "create task (\u5FC5\u586B --space/--title\uFF1B\u843D backlog \u7531\u670D\u52A1\u7AEF\u51B3\u5B9A\u521D\u59CB\u72B6\u6001)",
+          flags: [
+            { name: "space", type: "string", valueHint: "<id>", description: "\u7A7A\u95F4 ID\uFF08\u5FC5\u586B\uFF09", required: true },
+            { name: "title", type: "string", valueHint: "<text>", description: "\u6807\u9898\uFF08\u5FC5\u586B\uFF09", required: true },
+            { name: "description", type: "string", valueHint: "<text>", description: "\u63CF\u8FF0\uFF08\u683C\u5F0F\u81EA\u52A8\u68C0\u6D4B\uFF09" },
+            { name: "priority", type: "string", valueHint: "<low|medium|high|urgent>", description: "\u4F18\u5148\u7EA7" },
+            { name: "state", type: "string", valueHint: "<id>", description: "\u521D\u59CB\u72B6\u6001\uFF08\u4E1A\u52A1 Object state id\uFF09" },
+            { name: "owner", type: "string", valueHint: "<principalId>", description: "\u8D1F\u8D23\u4EBA\uFF08\u4EC5\u521B\u5EFA\u65F6\uFF09" },
+            { name: "assignee", type: "string", valueHint: "<principalId>", description: "\u7ECF\u529E\u4EBA" },
+            { name: "visibility", type: "string", valueHint: "<value>", description: "\u53EF\u89C1\u6027" },
+            { name: "estimate-hours", type: "number", valueHint: "<n>", description: "\u9884\u4F30\u5DE5\u65F6" },
+            { name: "schema", type: "string", valueHint: "<id>", description: "\u5B57\u6BB5\u6A21\u677F" },
+            { name: "sort-order", type: "number", valueHint: "<n>", description: "\u6392\u5E8F\u53F7" },
+            { name: "field", type: "string", valueHint: "key=value[,key=value]", description: "\u81EA\u5B9A\u4E49\u5B57\u6BB5 upsert\uFF08\u521B\u5EFA\u540E\u5199\u5165\uFF09" }
+          ],
+          examples: ["morula task create --space <id> --title <text>"],
+          writes: "remote"
+        },
+        {
+          action: "get",
+          summary: "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)",
+          args: [{ name: "objectId", required: false, description: "\u4E1A\u52A1\u4EFB\u52A1\uFF08Object\uFF09ID\uFF1B\u7701\u7565 = \u5F53\u524D AgentTask \u8BE6\u60C5" }],
+          flags: [],
+          examples: ["morula task get", "morula task get <objectId>"],
+          writes: "none",
+          idempotent: true
+        },
+        {
+          action: "update",
+          summary: "update task (--state here is the business Object state id, NOT the AgentTask state code \u2014 see `task state`)",
+          args: [{ name: "id", required: true, description: "\u4EFB\u52A1\uFF08Object\uFF09ID" }],
+          flags: [
+            { name: "title", type: "string", valueHint: "<text>", description: "\u6807\u9898" },
+            { name: "description", type: "string", valueHint: "<text>", description: "\u63CF\u8FF0" },
+            { name: "priority", type: "string", valueHint: "<low|medium|high|urgent>", description: "\u4F18\u5148\u7EA7" },
+            { name: "state", type: "string", valueHint: "<id>", description: "\u72B6\u6001\uFF08\u4E1A\u52A1 Object state id\uFF09" },
+            { name: "assignee", type: "string", valueHint: "<principalId>", description: "\u7ECF\u529E\u4EBA" },
+            { name: "visibility", type: "string", valueHint: "<value>", description: "\u53EF\u89C1\u6027" },
+            { name: "estimate-hours", type: "number", valueHint: "<n>", description: "\u9884\u4F30\u5DE5\u65F6" },
+            { name: "schema", type: "string", valueHint: "<id>", description: "\u5B57\u6BB5\u6A21\u677F" },
+            { name: "sort-order", type: "number", valueHint: "<n>", description: "\u6392\u5E8F\u53F7" },
+            { name: "field", type: "string", valueHint: "key=value[,key=value]", description: "\u81EA\u5B9A\u4E49\u5B57\u6BB5 upsert\uFF08\u7A7A value = \u6E05\u7A7A\uFF09" }
+          ],
+          examples: ["morula task update <id> --title <text>"],
+          writes: "remote"
+        },
+        {
+          action: "delete",
+          summary: "hard delete task",
+          args: [{ name: "id", required: true, description: "\u4EFB\u52A1\uFF08Object\uFF09ID" }],
+          flags: [],
+          examples: ["morula task delete <id>"],
+          writes: "remote"
+        },
+        {
+          action: "branch",
+          summary: "report the final branch name for an agent task (machine protocol; agent naming, runtimeId from env; --repo: secondary repo in a multi-repo task)",
+          args: [{ name: "taskId", required: true, description: "\u672C\u4EFB\u52A1 AgentTask UUID\uFF08morula task get \u65E0\u53C2\u8FD4\u56DE\u7684 id\uFF09" }],
+          flags: [
+            { name: "name", type: "string", valueHint: "<branch>", description: "\u5206\u652F\u540D\uFF08\u5FC5\u586B\uFF09", required: true },
+            { name: "repo", type: "string", valueHint: "<owner/name>", description: "\u6B21\u4ED3\u5E93\uFF08\u591A\u4ED3\u5E93\u4EFB\u52A1\u7684\u5206\u652F\u9010\u4ED3\u4E0A\u62A5\uFF09" }
+          ],
+          examples: ["morula task branch <taskId> --name <type>/<code>-<slug>"],
+          writes: "remote"
+        },
+        {
+          action: "state",
+          summary: "self-transition task state (machine protocol; agent drives todo\u2192in_progress\u2192review, runtimeId from env)",
+          args: [{ name: "taskId", required: true, description: "\u672C\u4EFB\u52A1 AgentTask UUID" }],
+          flags: [{ name: "state", type: "string", valueHint: "<in_progress|review>", description: "\u76EE\u6807\u72B6\u6001 code\uFF08\u5FC5\u586B\uFF09", required: true }],
+          examples: ["morula task state <taskId> --state in_progress"],
+          writes: "remote"
+        },
+        {
+          action: "analysis-verdict",
+          summary: "report the task-analysis verdict (machine protocol; ready \u2192 platform auto-starts development, blocked \u2192 task stays in analysis)",
+          args: [{ name: "taskId", required: true, description: "\u672C\u4EFB\u52A1 AgentTask UUID" }],
+          flags: [
+            { name: "verdict", type: "string", valueHint: "<ready|blocked>", enum: ["ready", "blocked"], description: "\u5206\u6790\u7ED3\u8BBA\uFF08\u5FC5\u586B\uFF1B\u4EC5\u4EFB\u52A1\u5206\u6790\u4EFB\u52A1\u53EF\u4E0A\u62A5\uFF09", required: true },
+            { name: "reason", type: "string", valueHint: "<text>", description: "blocked \u65F6\u7684\u963B\u585E/\u5F85\u6F84\u6E05\u539F\u56E0" }
+          ],
+          examples: ["morula task analysis-verdict <taskId> --verdict ready"],
+          writes: "remote"
+        },
+        {
+          action: "inbox",
+          summary: "checkpoint: pull this thread's unconsumed messages into the current turn (machine protocol; --peek reads without marking them consumed)",
+          flags: [
+            { name: "peek", type: "boolean", description: "\u53EA\u8BFB\uFF0C\u4E0D\u6807\u8BB0\u6D88\u8D39" },
+            { name: "after-seq", type: "number", valueHint: "<n>", description: "\u4ECE\u8BE5 seq \u4E4B\u540E\u62C9\u53D6" }
+          ],
+          examples: ["morula task inbox", "morula task inbox --peek"],
+          writes: "remote"
+        },
+        {
+          action: "agent-tasks",
+          summary: "list the AgentTask executions of a business task (Object). AgentTask UUID \u2260 \u4E1A\u52A1\u4EFB\u52A1 id \u2014 cancel/rerun \u8981\u7684\u662F\u8FD9\u91CC\u7684 id",
+          flags: [
+            { name: "object", type: "string", valueHint: "<objectId>", description: "\u4E1A\u52A1\u4EFB\u52A1\uFF08Object\uFF09ID\uFF08\u5FC5\u586B\uFF09", required: true },
+            { name: "status", type: "string", valueHint: "<queued|dispatched|running|awaiting_approval|completed|failed|cancelled>", description: "\u6309\u5355\u4E2A\u72B6\u6001\u8FC7\u6EE4\uFF08\u7F3A\u7701 = \u5168\u90E8\uFF1B\u670D\u52A1\u7AEF\u4E0D\u505A\u679A\u4E3E\u6821\u9A8C\uFF0C\u975E\u6CD5\u503C\u53EA\u8FD4\u56DE\u7A7A\uFF09" },
+            { name: "page", type: "number", valueHint: "<n>", description: "\u9875\u7801" },
+            { name: "page-size", type: "number", valueHint: "<n>", description: "\u6BCF\u9875\u6761\u6570\uFF08\u670D\u52A1\u7AEF\u7F3A\u7701 20\uFF09" }
+          ],
+          examples: ["morula task agent-tasks --object <objectId>", "morula task agent-tasks --object <objectId> --status failed"],
+          writes: "none",
+          idempotent: true
+        },
+        {
+          action: "cancel",
+          summary: "cancel a running execution (POST /agent-tasks/:id/cancel). queued/dispatched/running/awaiting_approval/failed \u53EF\u53D6\u6D88\uFF1Bcompleted/cancelled \u4E0D\u53EF\uFF08409 CONFLICT\uFF09\uFF1B\u4EFB\u52A1\u4E0D\u5B58\u5728 404 NOT_FOUND\u3002\u6210\u529F\u8FD4\u56DE { ok: true }\u2014\u2014**\u975E\u96F6\u9000\u51FA\u5373\u672A\u53D6\u6D88**\uFF0C\u4E0D\u8981\u5411\u7528\u6237\u6C47\u62A5\u300C\u5DF2\u505C\u6389\u300D",
+          args: [{ name: "taskId", required: true, description: "AgentTask UUID\uFF08\u6765\u81EA morula task agent-tasks\uFF09" }],
+          flags: [],
+          examples: ["morula task cancel <taskId>"],
+          writes: "remote"
+        },
+        {
+          action: "rerun",
+          summary: "rerun a failed/cancelled execution (POST /agent-tasks/:id/rerun; copies the task and re-queues it \u2192 returns a NEW taskId). \u4EC5 failed/cancelled \u53EF\u91CD\u8DD1\uFF0C\u5176\u4ED6\u72B6\u6001 ok:false + code CONFLICT\uFF1B10s \u5185\u5DF2\u6709\u6D3B\u8DC3\u91CD\u8DD1\u4E3A ALREADY_QUEUED",
+          args: [{ name: "taskId", required: true, description: "AgentTask UUID\uFF08\u6765\u81EA morula task agent-tasks\uFF09" }],
+          flags: [],
+          examples: ["morula task rerun <taskId>"],
+          writes: "remote"
+        }
+      ]
+    },
+    {
+      resource: "space",
+      summary: "space (project) read/write",
+      actions: [
+        {
+          action: "list",
+          summary: "list visible spaces",
+          flags: [
+            { name: "page", type: "number", valueHint: "<n>", description: "\u9875\u7801" },
+            { name: "page-size", type: "number", valueHint: "<n>", description: "\u6BCF\u9875\u6761\u6570" },
+            { name: "keyword", type: "string", valueHint: "<text>", description: "\u5173\u952E\u8BCD" }
+          ],
+          examples: ["morula space list"],
+          writes: "none",
+          idempotent: true
+        },
+        {
+          action: "get",
+          summary: "get space details",
+          args: [{ name: "id", required: true, description: "\u7A7A\u95F4 ID" }],
+          flags: [],
+          examples: ["morula space get <id>"],
+          writes: "none",
+          idempotent: true
+        },
+        {
+          action: "create",
+          summary: "create space (project)",
+          flags: [
+            { name: "name", type: "string", valueHint: "<text>", description: "\u7A7A\u95F4\u540D\u79F0\uFF08\u5FC5\u586B\uFF09", required: true },
+            { name: "description", type: "string", valueHint: "<text>", description: "\u63CF\u8FF0" },
+            { name: "code", type: "string", valueHint: "<code>", description: "\u7A7A\u95F4\u7F16\u53F7\uFF08\u7F3A\u7701\u7531\u670D\u52A1\u7AEF\u751F\u6210\uFF09" },
+            { name: "visibility", type: "string", valueHint: "<private|internal|public>", enum: ["private", "internal", "public"], description: "\u53EF\u89C1\u6027" }
+          ],
+          examples: ["morula space create --name <text>"],
+          writes: "remote"
+        },
+        {
+          action: "update",
+          summary: "update space (\u81F3\u5C11\u4E00\u4E2A\u5B57\u6BB5\u65D7\u6807)",
+          args: [{ name: "id", required: true, description: "\u7A7A\u95F4 ID" }],
+          flags: [
+            { name: "name", type: "string", valueHint: "<text>", description: "\u7A7A\u95F4\u540D\u79F0" },
+            { name: "description", type: "string", valueHint: "<text>", description: "\u63CF\u8FF0" },
+            { name: "visibility", type: "string", valueHint: "<private|internal|public>", enum: ["private", "internal", "public"], description: "\u53EF\u89C1\u6027" }
+          ],
+          examples: ["morula space update <id> --name <text>"],
+          writes: "remote"
+        },
+        {
+          action: "delete",
+          summary: "delete space",
+          args: [{ name: "id", required: true, description: "\u7A7A\u95F4 ID" }],
+          flags: [],
+          examples: ["morula space delete <id>"],
+          writes: "remote"
+        }
+      ]
+    },
+    {
+      resource: "space-member",
+      summary: "space member management (admin operations)",
+      actions: [
+        {
+          action: "list",
+          summary: "list space members",
+          flags: [{ name: "space", type: "string", valueHint: "<id>", description: "\u7A7A\u95F4 ID\uFF08\u5FC5\u586B\uFF09", required: true }],
+          examples: ["morula space-member list --space <id>"],
+          writes: "none",
+          idempotent: true
+        },
+        {
+          action: "add",
+          summary: "add member to space",
+          flags: [
+            { name: "space", type: "string", valueHint: "<id>", description: "\u7A7A\u95F4 ID\uFF08\u5FC5\u586B\uFF09", required: true },
+            { name: "principal", type: "string", valueHint: "<id>", description: "\u6210\u5458 principalId\uFF08\u5FC5\u586B\uFF09", required: true },
+            { name: "role", type: "string", valueHint: "<admin|member>", enum: ["admin", "member"], description: "\u89D2\u8272\uFF08\u7F3A\u7701 member\uFF09" }
+          ],
+          examples: ["morula space-member add --space <id> --principal <id>"],
+          writes: "remote"
+        },
+        {
+          action: "update",
+          summary: "update member role",
+          args: [{ name: "memberId", required: true, description: "\u6210\u5458\u884C ID" }],
+          flags: [{ name: "role", type: "string", valueHint: "<admin|member>", enum: ["admin", "member"], description: "\u65B0\u89D2\u8272\uFF08\u5FC5\u586B\uFF09", required: true }],
+          examples: ["morula space-member update <memberId> --role admin"],
+          writes: "remote"
+        },
+        {
+          action: "remove",
+          summary: "remove member from space",
+          args: [{ name: "memberId", required: true, description: "\u6210\u5458\u884C ID" }],
+          flags: [],
+          examples: ["morula space-member remove <memberId>"],
+          writes: "remote"
+        }
+      ]
+    },
+    {
+      resource: "steward",
+      summary: "space steward (project-level agent): read takeover state / dispatch a task with an explicit target state",
+      actions: [
+        {
+          action: "get",
+          summary: "get the steward record of a space (null = \u672A\u63A5\u7BA1)",
+          flags: [{ name: "space", type: "string", valueHint: "<id>", description: "\u7A7A\u95F4\uFF08\u9879\u76EE\uFF09ID\uFF08\u5FC5\u586B\uFF09", required: true }],
+          examples: ["morula steward get --space <id>"],
+          writes: "none",
+          idempotent: true
+        },
+        {
+          action: "dispatch",
+          summary: "dispatch a task: create the task and hand it to the pipeline. --state backlog = \u843D\u5F85\u89C4\u5212\uFF08\u4E0D\u6D3E\u53D1\u6267\u884C\uFF0C\u670D\u52A1\u7AEF\u4E0D\u5EFA AgentTask\uFF09\uFF1B\u7F3A\u7701 todo\uFF08\u5F85\u5206\u6790\uFF09",
+          flags: [
+            { name: "space", type: "string", valueHint: "<id>", description: "\u7A7A\u95F4\uFF08\u9879\u76EE\uFF09ID\uFF08\u5FC5\u586B\uFF09", required: true },
+            { name: "title", type: "string", valueHint: "<text>", description: "\u4EFB\u52A1\u6807\u9898\uFF08\u5FC5\u586B\uFF09", required: true },
+            { name: "description", type: "string", valueHint: "<text>", description: "\u4EFB\u52A1\u63CF\u8FF0" },
+            { name: "state", type: "string", valueHint: "<backlog|todo|in_progress>", enum: ["backlog", "todo", "in_progress"], description: "\u76EE\u6807\u521D\u59CB\u72B6\u6001\uFF08\u7F3A\u7701 todo\uFF09" },
+            { name: "assignee", type: "string", valueHint: "<principalId>", description: "\u6307\u5B9A\u6267\u884C\u8005" },
+            { name: "repo", type: "string", valueHint: "<owner/name>", description: "\u591A\u4ED3\u5E93\u7A7A\u95F4\uFF1A\u6307\u5B9A\u76EE\u6807\u4ED3\u5E93\uFF08\u7F3A\u7701\u7531\u670D\u52A1\u7AEF\u89E3\u6790\uFF09" },
+            { name: "client-message-id", type: "string", valueHint: "<id>", description: "\u5E42\u7B49\u952E\uFF1A\u540C\u4E00\u952E\u91CD\u590D\u6D3E\u5355\u8FD4\u56DE\u539F\u7ED3\u679C" }
+          ],
+          examples: ["morula steward dispatch --space <id> --title <text>", "morula steward dispatch --space <id> --title <text> --state backlog"],
+          writes: "remote"
+        }
+      ]
+    },
+    {
+      resource: "autopilot",
+      summary: "agent autopilots (scheduled/webhook-triggered automated runs; list only shows your own)",
+      actions: [
+        {
+          action: "list",
+          summary: "list autopilots created by the current user",
+          flags: [
+            { name: "space", type: "string", valueHint: "<id>", description: "\u6309\u7A7A\u95F4\u8FC7\u6EE4" },
+            { name: "page", type: "number", valueHint: "<n>", description: "\u9875\u7801" },
+            { name: "page-size", type: "number", valueHint: "<n>", description: "\u6BCF\u9875\u6761\u6570" }
+          ],
+          examples: ["morula autopilot list", "morula autopilot list --space <id>"],
+          writes: "none",
+          idempotent: true
+        },
+        {
+          action: "create",
+          summary: "create an autopilot (--executor is a runtime key; the server currently only accepts `dim`)",
+          flags: [
+            { name: "space", type: "string", valueHint: "<id>", description: "\u5F52\u5C5E\u7A7A\u95F4 ID\uFF08\u5FC5\u586B\uFF09", required: true },
+            { name: "name", type: "string", valueHint: "<text>", description: "\u540D\u79F0\uFF08\u540C\u79DF\u6237\u552F\u4E00\uFF0C\u5FC5\u586B\uFF09", required: true },
+            { name: "runbook", type: "string", valueHint: "<text>", description: "Runbook\uFF1A\u6BCF\u6B21\u89E6\u53D1\u7ED9\u8FD0\u884C\u65F6\u7684\u76EE\u6807/\u80CC\u666F/\u6B65\u9AA4\uFF08\u5FC5\u586B\uFF09", required: true },
+            { name: "executor", type: "string", valueHint: "<key>", description: "\u6267\u884C\u8005\u8FD0\u884C\u65F6 key\uFF08\u5FC5\u586B\uFF1B\u5F53\u524D\u4EC5 dim\uFF09", required: true },
+            { name: "description", type: "string", valueHint: "<text>", description: "\u63CF\u8FF0" },
+            { name: "cron", type: "string", valueHint: "<expr>", description: "cron \u8868\u8FBE\u5F0F\uFF085 \u5B57\u6BB5\uFF09\uFF1B\u7F3A\u7701 = \u4EC5 webhook \u89E6\u53D1" },
+            { name: "vcs-connection", type: "string", valueHint: "<id>", description: "\u9650\u5B9A\u4ED3\u5E93\u8FDE\u63A5\uFF08\u7F3A\u7701\u4E0D\u9650\uFF09" }
+          ],
+          examples: ["morula autopilot create --space <id> --name <text> --runbook <text> --executor dim"],
+          writes: "remote"
+        }
+      ]
+    },
+    {
+      resource: "dashboard",
+      summary: "space dashboard / statistics / member workload (read-only aggregates)",
+      actions: [
+        {
+          action: "get",
+          summary: "get the space dashboard aggregate",
+          flags: [{ name: "space", type: "string", valueHint: "<id>", description: "\u7A7A\u95F4 ID\uFF08\u5FC5\u586B\uFF09", required: true }],
+          examples: ["morula dashboard get --space <id>"],
+          writes: "none",
+          idempotent: true
+        },
+        {
+          action: "statistics",
+          summary: "get space task statistics",
+          flags: [{ name: "space", type: "string", valueHint: "<id>", description: "\u7A7A\u95F4 ID\uFF08\u5FC5\u586B\uFF09", required: true }],
+          examples: ["morula dashboard statistics --space <id>"],
+          writes: "none",
+          idempotent: true
+        },
+        {
+          action: "workload",
+          summary: "get per-member workload in a space",
+          flags: [{ name: "space", type: "string", valueHint: "<id>", description: "\u7A7A\u95F4 ID\uFF08\u5FC5\u586B\uFF09", required: true }],
+          examples: ["morula dashboard workload --space <id>"],
+          writes: "none",
+          idempotent: true
+        }
+      ]
+    },
+    {
+      resource: "object-meta",
+      summary: "task-level agent metadata (D-06 high-signal keys only)",
+      actions: [
+        {
+          action: "get",
+          summary: "read all agent metadata of a task",
+          flags: [{ name: "object", type: "string", valueHint: "<id>", description: "\u4EFB\u52A1\uFF08Object\uFF09ID\uFF08\u5FC5\u586B\uFF09", required: true }],
+          examples: ["morula object-meta get --object <id>"],
+          writes: "none",
+          idempotent: true
+        },
+        {
+          action: "set",
+          summary: "write one agent metadata key. Key must be in the high-signal whitelist: pr_url / pr_number / pipeline_status / deploy_url / waiting_on / blocked_reason / decision",
+          flags: [
+            { name: "object", type: "string", valueHint: "<id>", description: "\u4EFB\u52A1\uFF08Object\uFF09ID\uFF08\u5FC5\u586B\uFF09", required: true },
+            { name: "key", type: "string", valueHint: "<key>", description: "\u5143\u6570\u636E\u952E\uFF08\u5FC5\u586B\uFF0C\u767D\u540D\u5355\uFF09", required: true },
+            { name: "value", type: "string", valueHint: "<text>", description: "\u503C\uFF08\u5FC5\u586B\uFF0C\u975E\u7A7A\uFF09", required: true }
+          ],
+          examples: ["morula object-meta set --object <id> --key pr_url --value <url>"],
+          writes: "remote"
+        }
+      ]
+    },
+    {
+      resource: "document",
+      summary: "document artifacts (ag_artifact; id is a numeric auto-increment id, not a uuid)",
+      actions: [
+        {
+          action: "list",
+          summary: "list document artifacts",
+          flags: [
+            { name: "page", type: "number", valueHint: "<n>", description: "\u9875\u7801" },
+            { name: "page-size", type: "number", valueHint: "<n>", description: "\u6BCF\u9875\u6761\u6570" }
+          ],
+          examples: ["morula document list"],
+          writes: "none",
+          idempotent: true
+        },
+        {
+          action: "get",
+          summary: "get document metadata (\u4E0D\u542B\u5B8C\u6574\u6B63\u6587)",
+          args: [{ name: "id", required: true, description: "\u6587\u6863 ID\uFF08\u6570\u5B57\uFF0C\u6765\u81EA document list\uFF09" }],
+          flags: [],
+          examples: ["morula document get <id>"],
+          writes: "none",
+          idempotent: true
+        },
+        {
+          action: "artifacts",
+          summary: "read the parsed document content (markdown)",
+          args: [{ name: "id", required: true, description: "\u6587\u6863 ID\uFF08\u6570\u5B57\uFF0C\u6765\u81EA document list\uFF09" }],
+          flags: [],
+          examples: ["morula document artifacts <id>"],
+          writes: "none",
+          idempotent: true
+        }
+      ]
+    },
+    {
+      resource: "comment",
+      summary: "object comments (agent summaries live here)",
+      actions: [
+        {
+          action: "list",
+          summary: "list comments for an object",
+          flags: [{ name: "object", type: "string", valueHint: "<id>", description: "\u5BF9\u8C61 ID\uFF08\u5FC5\u586B\uFF09", required: true }],
+          examples: ["morula comment list --object <id>"],
+          writes: "none",
+          idempotent: true
+        },
+        {
+          action: "get",
+          summary: "get comment details",
+          args: [{ name: "id", required: true, description: "\u8BC4\u8BBA ID" }],
+          flags: [],
+          examples: ["morula comment get <id>"],
+          writes: "none",
+          idempotent: true
+        },
+        {
+          action: "add",
+          summary: "add comment (format auto-detected; use markdown for agent final summaries). --mention \u53EF @ \u4EBA\uFF08\u89E6\u53D1\u901A\u77E5/\u50AC\u529E\uFF09",
+          flags: [
+            { name: "object", type: "string", valueHint: "<id>", description: "\u5BF9\u8C61 ID\uFF08\u5FC5\u586B\uFF09", required: true },
+            { name: "content", type: "string", valueHint: "<text>", description: "\u8BC4\u8BBA\u5185\u5BB9\uFF08\u5FC5\u586B\uFF09", required: true },
+            { name: "parent", type: "string", valueHint: "<id>", description: "\u7236\u8BC4\u8BBA\uFF08\u56DE\u590D\uFF09" },
+            { name: "format", type: "string", valueHint: "<markdown|plain|richtext>", enum: ["markdown", "plain", "richtext"], description: "\u5185\u5BB9\u683C\u5F0F\uFF08\u7F3A\u7701\u81EA\u52A8\u68C0\u6D4B\uFF09" },
+            { name: "mention", type: "string", valueHint: "<principalId[,principalId]>", repeatable: true, description: "@ \u4EBA\uFF1A\u88AB\u63D0\u53CA\u8005\u7684 principalId\uFF0C\u53EF\u91CD\u590D\u4F20\uFF08--mention a --mention b\uFF09\u6216\u7528\u9017\u53F7\u5206\u9694\u591A\u4E2A\uFF08\u4E24\u79CD\u6DF7\u7528\u81EA\u52A8\u5408\u5E76\u53BB\u91CD\u4FDD\u5E8F\uFF09\uFF1B\u53EA\u652F\u6301\u4EBA\uFF0C\u4E0D\u652F\u6301 @ \u8FD0\u884C\u65F6/\u667A\u80FD\u4F53" }
+          ],
+          examples: ["morula comment add --object <id> --content <text>", "morula comment add --object <id> --content <text> --mention <principalId>", "morula comment add --object <id> --content <text> --mention <principalIdA> --mention <principalIdB>"],
+          writes: "remote"
+        },
+        {
+          action: "update",
+          summary: "update comment",
+          args: [{ name: "id", required: true, description: "\u8BC4\u8BBA ID" }],
+          flags: [{ name: "content", type: "string", valueHint: "<text>", description: "\u65B0\u5185\u5BB9\uFF08\u5FC5\u586B\uFF09", required: true }],
+          examples: ["morula comment update <id> --content <text>"],
+          writes: "remote"
+        },
+        {
+          action: "delete",
+          summary: "hard delete comment",
+          args: [{ name: "id", required: true, description: "\u8BC4\u8BBA ID" }],
+          flags: [],
+          examples: ["morula comment delete <id>"],
+          writes: "remote"
+        }
+      ]
+    },
+    {
+      resource: "review",
+      summary: "Code Review verdict submission (review task machine protocol)",
+      actions: [
+        {
+          action: "submit",
+          summary: "submit Code Review verdict (machine protocol; review task token)",
+          args: [{ name: "objectId", required: true, description: "\u8BC4\u5BA1\u5BF9\u8C61 ID\uFF08\u7CFB\u7EDF\u63D0\u793A\u300C\u8BC4\u5BA1\u5BF9\u8C61\u300D\uFF09" }],
+          flags: [
+            { name: "verdict", type: "string", valueHint: "<approved|changes_requested|commented>", enum: ["approved", "changes_requested", "commented"], description: "\u8BC4\u5BA1\u7ED3\u8BBA\uFF08\u5FC5\u586B\uFF09", required: true },
+            { name: "details", type: "string", valueHint: "<text>", description: "\u8BC4\u5BA1\u610F\u89C1\uFF08changes_requested \u5FC5\u586B\uFF1A\u6587\u4EF6/\u884C/\u95EE\u9898/\u5EFA\u8BAE\uFF09" },
+            { name: "pr-number", type: "number", valueHint: "<n>", description: "\u8BC4\u5BA1\u5BF9\u8C61\u7684 PR \u7F16\u53F7\uFF08\u6709\u5219\u586B\uFF09" }
+          ],
+          examples: ["morula review submit <objectId> --verdict approved"],
+          writes: "remote"
+        }
+      ]
+    },
+    {
+      resource: "report",
+      summary: "autopilot reports (conclusion-heavy output of automated runs)",
+      actions: [
+        {
+          action: "create",
+          summary: "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)",
+          flags: [
+            { name: "title", type: "string", valueHint: "<text>", description: "\u6807\u9898\uFF08\u5FC5\u586B\uFF09", required: true },
+            { name: "content", type: "string", valueHint: "<markdown>", description: "\u77ED\u6B63\u6587\uFF08\u4E0E --content-file \u4E8C\u9009\u4E00\uFF09" },
+            { name: "content-file", type: "string", valueHint: "<path>", description: "\u957F Markdown \u62A5\u544A\u6587\u4EF6\uFF08\u4E0E --content \u4E8C\u9009\u4E00\uFF09" },
+            { name: "space", type: "string", valueHint: "<id>", description: "\u5F52\u5C5E\u7A7A\u95F4" },
+            { name: "autopilot", type: "string", valueHint: "<id>", description: "\u6240\u5C5E\u81EA\u52A8\u5316\uFF08\u7701\u7565\u65F6\u6309\u5F53\u524D\u4EFB\u52A1\u53CD\u67E5\uFF09" }
+          ],
+          examples: ["morula report create --title <t> --content-file <path>"],
+          writes: "remote"
+        },
+        {
+          action: "get",
+          summary: "get report details (\u542B Markdown \u6B63\u6587)",
+          args: [{ name: "id", required: true, description: "\u62A5\u544A ID" }],
+          flags: [],
+          examples: ["morula report get <id>"],
+          writes: "none",
+          idempotent: true
+        },
+        {
+          action: "list",
+          summary: "list reports of an autopilot",
+          flags: [
+            { name: "autopilot", type: "string", valueHint: "<id>", description: "\u81EA\u52A8\u5316 ID\uFF08\u5FC5\u586B\uFF09", required: true },
+            { name: "page", type: "number", valueHint: "<n>", description: "\u9875\u7801" },
+            { name: "page-size", type: "number", valueHint: "<n>", description: "\u6BCF\u9875\u6761\u6570" }
+          ],
+          examples: ["morula report list --autopilot <id>"],
+          writes: "none",
+          idempotent: true
+        }
+      ]
+    },
+    {
+      resource: "repo",
+      summary: "task-space VCS repos: materialize checkout / MR read & comment (server channel; never approves/merges)",
+      actions: [
+        {
+          action: "list",
+          summary: "list task-space VCS connections (the space repo list \u2014 the task prompt does NOT list repos; query this when a task may span multiple repos)",
+          flags: [{ name: "space", type: "string", valueHint: "<id>", description: "\u7A7A\u95F4 ID\uFF08\u5FC5\u586B\uFF09", required: true }],
+          examples: ["morula repo list --space <id>"],
+          writes: "none",
+          idempotent: true
+        },
+        {
+          action: "checkout",
+          summary: "materialize a repo into the task workdir (local daemon endpoint preferred, works same-turn; falls back to server machine protocol which resolves scope + workContext)",
+          args: [
+            { name: "taskId", required: true, description: "\u672C\u4EFB\u52A1 AgentTask UUID" },
+            { name: "repoFullName", required: true, description: "\u4ED3\u5E93\u5168\u540D\uFF08owner/name\uFF09" }
+          ],
+          flags: [{ name: "ref", type: "string", valueHint: "<branch|sha>", description: "\u68C0\u51FA\u5F15\u7528\uFF08\u7F3A\u7701 = \u7ED1\u5B9A\u5206\u652F\uFF09" }],
+          examples: ["morula repo checkout <taskId> <owner/name>"],
+          writes: "local",
+          idempotent: true
+        },
+        {
+          action: "prepare",
+          summary: "materialize a secondary repo into the task workdir (same level as the primary repo dir)",
+          args: [
+            { name: "taskId", required: true, description: "\u672C\u4EFB\u52A1 AgentTask UUID" },
+            { name: "repoFullName", required: true, description: "\u6B21\u4ED3\u5E93\u5168\u540D\uFF08owner/name\uFF09" }
+          ],
+          flags: [],
+          examples: ["morula repo prepare <taskId> <owner/name>"],
+          writes: "local",
+          idempotent: true
+        },
+        {
+          action: "files",
+          summary: "list files in a space repo via the server (read-only, non-task: no local checkout, no AgentTask context)",
+          flags: [
+            { name: "space", type: "string", valueHint: "<id>", description: "\u7A7A\u95F4 ID\uFF08\u5FC5\u586B\uFF09", required: true },
+            { name: "repo", type: "string", valueHint: "<owner/name>", description: "\u4ED3\u5E93\u5168\u540D\uFF08\u7F3A\u7701 = \u7A7A\u95F4\u4E3B\u4ED3\u5E93\uFF09" },
+            { name: "path", type: "string", valueHint: "<path>", description: "\u76EE\u5F55\u8DEF\u5F84\uFF08\u7F3A\u7701 = \u4ED3\u5E93\u6839\uFF09" },
+            { name: "ref", type: "string", valueHint: "<branch|sha>", description: "\u5206\u652F / tag / commit\uFF08\u7F3A\u7701 = \u9ED8\u8BA4\u5206\u652F\uFF09" }
+          ],
+          examples: ["morula repo files --space <id>", "morula repo files --space <id> --path src"],
+          writes: "none",
+          idempotent: true
+        },
+        {
+          action: "read",
+          summary: "read a single file from a space repo via the server (read-only, non-task)",
+          flags: [
+            { name: "space", type: "string", valueHint: "<id>", description: "\u7A7A\u95F4 ID\uFF08\u5FC5\u586B\uFF09", required: true },
+            { name: "path", type: "string", valueHint: "<path>", description: "\u6587\u4EF6\u8DEF\u5F84\uFF08\u5FC5\u586B\uFF09", required: true },
+            { name: "repo", type: "string", valueHint: "<owner/name>", description: "\u4ED3\u5E93\u5168\u540D\uFF08\u7F3A\u7701 = \u7A7A\u95F4\u4E3B\u4ED3\u5E93\uFF09" },
+            { name: "ref", type: "string", valueHint: "<branch|sha>", description: "\u5206\u652F / tag / commit\uFF08\u7F3A\u7701 = \u9ED8\u8BA4\u5206\u652F\uFF09" }
+          ],
+          examples: ["morula repo read --space <id> --path src/index.ts"],
+          writes: "none",
+          idempotent: true
+        },
+        {
+          action: "mr create",
+          summary: "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)",
+          args: [{ name: "repoFullName", required: true, description: "\u4ED3\u5E93\u5168\u540D\uFF08owner/name\uFF09" }],
+          flags: [
+            { name: "branch", type: "string", valueHint: "<branch>", description: "\u6E90\u5206\u652F\uFF08\u5FC5\u586B\uFF09", required: true },
+            { name: "base", type: "string", valueHint: "<base>", description: "\u76EE\u6807\u5206\u652F\uFF08\u7F3A\u7701 MORULA_BASE_BRANCH / main\uFF09" },
+            { name: "task-code", type: "string", valueHint: "<code>", description: "\u4EFB\u52A1\u7F16\u53F7\uFF08MR \u6807\u9898/\u6B63\u6587\u56DE\u94FE\uFF09" }
+          ],
+          examples: ["morula repo mr create <owner/name> --branch <b> --task-code <code>"],
+          writes: "remote"
+        },
+        {
+          action: "mr list",
+          summary: "list the task-space repos' merge requests (read-only; includes createdAt/updatedAt/author; never approves/merges)",
+          args: [{ name: "taskId", required: true, description: "\u672C\u4EFB\u52A1 AgentTask UUID" }],
+          flags: [
+            { name: "state", type: "string", valueHint: "<opened|closed|merged>", enum: ["opened", "closed", "merged"], description: "MR \u72B6\u6001\u8FC7\u6EE4\uFF08\u7F3A\u7701 opened\uFF09" },
+            { name: "limit", type: "number", valueHint: "<n>", description: "\u6761\u6570\u4E0A\u9650" },
+            { name: "author", type: "string", valueHint: "<username>", description: "\u6309\u4F5C\u8005\u8FC7\u6EE4" },
+            { name: "repo", type: "string", valueHint: "<owner/name>", description: "\u591A\u4ED3\u5E93\u7A7A\u95F4\uFF1A\u76EE\u6807\u4ED3\u5E93\uFF08\u7F3A\u7701\u4E3B\u4ED3\u5E93\uFF09" }
+          ],
+          examples: ["morula repo mr list <taskId> --state opened"],
+          writes: "none",
+          idempotent: true
+        },
+        {
+          action: "mr comment",
+          summary: "write a review comment on an MR/PR (write-only: never approves or merges). \u5199\u4E4B\u524D\u5FC5\u987B\u5148 `morula repo mr get <taskId> --mr <iid> --notes` \u8BFB\u5DF2\u6709\u8BA8\u8BBA\uFF1A\u82E5\u672C\u81EA\u52A8\u5316\u5DF2\u5C31\u540C\u4E00\u95EE\u9898\u7559\u8FC7\u7ED3\u8BBA\u4E14\u7ED3\u8BBA\u672A\u53D8\uFF0C\u4E0D\u8981\u518D\u8BC4\u8BBA\u3002\u5185\u5BB9\u4E3A\u7ED3\u8BBA + \u5173\u952E\u95EE\u9898\uFF08\u6587\u4EF6:\u884C + \u5EFA\u8BAE\uFF09\uFF0C\u672B\u5C3E\u52A0\u7F72\u540D\u884C\uFF1B\u957F\u5185\u5BB9\u5199\u6210\u62A5\u544A\u540E\u7528\u6458\u8981\u5F15\u7528\uFF08morula report create \u2192 \u8BC4\u8BBA\u91CC\u7ED9\u8981\u70B9\uFF09",
+          args: [{ name: "taskId", required: true, description: "\u672C\u4EFB\u52A1 AgentTask UUID" }],
+          flags: [
+            { name: "mr", type: "number", valueHint: "<iid>", description: "MR \u7F16\u53F7\uFF08\u5FC5\u586B\uFF09", required: true },
+            { name: "repo", type: "string", valueHint: "<owner/name>", description: "\u591A\u4ED3\u5E93\u7A7A\u95F4\uFF1A\u76EE\u6807\u4ED3\u5E93\uFF08\u7F3A\u7701\u4E3B\u4ED3\u5E93\uFF09" },
+            { name: "connection", type: "string", valueHint: "<id>", description: "\u8FDE\u63A5 ID\uFF08\u591A\u8FDE\u63A5\u573A\u666F\uFF09" },
+            { name: "content", type: "string", valueHint: "<text>", description: "\u8BC4\u8BBA\u6B63\u6587\uFF08\u4E0E --content-file \u4E8C\u9009\u4E00\uFF09" },
+            { name: "content-file", type: "string", valueHint: "<path>", description: "\u8BC4\u8BBA\u6B63\u6587\u6587\u4EF6\uFF08\u4E0E --content \u4E8C\u9009\u4E00\uFF09" }
+          ],
+          examples: ["morula repo mr comment <taskId> --mr <iid> --content-file <path>"],
+          writes: "remote"
+        },
+        {
+          action: "mr get",
+          summary: "get a single MR detail (read-only; --ci attaches pipeline status where none = no pipeline, not an error; --notes attaches existing comments \u2014 read this before writing a comment to avoid duplicates)",
+          args: [{ name: "taskId", required: true, description: "\u672C\u4EFB\u52A1 AgentTask UUID" }],
+          flags: [
+            { name: "mr", type: "number", valueHint: "<iid>", description: "MR \u7F16\u53F7\uFF08\u5FC5\u586B\uFF09", required: true },
+            { name: "repo", type: "string", valueHint: "<owner/name>", description: "\u591A\u4ED3\u5E93\u7A7A\u95F4\uFF1A\u76EE\u6807\u4ED3\u5E93\uFF08\u7F3A\u7701\u4E3B\u4ED3\u5E93\uFF09" },
+            { name: "ci", type: "boolean", description: "\u9644\u5E26 pipeline \u72B6\u6001" },
+            { name: "notes", type: "boolean", description: "\u9644\u5E26\u5DF2\u6709\u8BC4\u8BBA\uFF08\u5199\u8BC4\u8BBA\u524D\u5148\u8BFB\uFF0C\u9632\u91CD\u590D\uFF09" }
+          ],
+          examples: ["morula repo mr get <taskId> --mr <iid> --notes"],
+          writes: "none",
+          idempotent: true
+        },
+        {
+          action: "mr diff",
+          summary: "read an MR diff via the server (read-only; works without a local checkout; truncated flag is set when output was capped)",
+          args: [{ name: "taskId", required: true, description: "\u672C\u4EFB\u52A1 AgentTask UUID" }],
+          flags: [
+            { name: "mr", type: "number", valueHint: "<iid>", description: "MR \u7F16\u53F7\uFF08\u5FC5\u586B\uFF09", required: true },
+            { name: "repo", type: "string", valueHint: "<owner/name>", description: "\u591A\u4ED3\u5E93\u7A7A\u95F4\uFF1A\u76EE\u6807\u4ED3\u5E93\uFF08\u7F3A\u7701\u4E3B\u4ED3\u5E93\uFF09" },
+            { name: "max-files", type: "number", valueHint: "<n>", description: "\u6587\u4EF6\u6570\u4E0A\u9650" },
+            { name: "max-chars", type: "number", valueHint: "<n>", description: "\u5B57\u7B26\u6570\u4E0A\u9650" }
+          ],
+          examples: ["morula repo mr diff <taskId> --mr <iid>"],
+          writes: "none",
+          idempotent: true
+        }
+      ],
+      notes: [
+        "mr \u662F\u591A\u7EA7\u5B50\u547D\u4EE4\u5F62\u6001\uFF08action=mr\u3001\u5B50\u547D\u4EE4\u4F4D\u5728 positionals[0]\uFF09\uFF1A\u5951\u7EA6\u6309\u5B50\u547D\u4EE4\u62C6\u5206\u58F0\u660E\uFF08mr create / mr list / ...\uFF09\uFF0C\u4E25\u683C\u6821\u9A8C\u53EA\u5BF9\u5355\u7EA7 action \u751F\u6548"
+      ]
+    },
+    {
+      resource: "ci",
+      summary: "CI/CD pipeline facts and pipeline operations: pipeline runs / job logs / deployments / failed test cases (read-only) plus retry of a failed pipeline or job (Phase 3 write, space face only). Read faces share one command surface \u2014 task face `<taskId>` (AgentTask credential, self-check your MR pipeline) vs space face `--space <spaceId>` (steward/session credential, space-wide inspection); the two are mutually exclusive. Retry is space-face ONLY (person + steward); trigger-deploy (play a manual job) stays person-only and is intentionally absent from the CLI",
+      actions: [
+        {
+          action: "status",
+          summary: 'pipeline runs + deployments for a task (or a space); hasCiConfig:false comes with a notice explaining the repo has no CI config (not an error); on the space face repos[] answers per repo (a multi-repo space never answers hasCiConfig for "the space" \u2014 it is null there); on the task face --repo filters runs client-side by repoFullName and echoes repoFilter (the server does NOT support repo filtering)',
+          args: [{ name: "taskId", description: "\u672C\u4EFB\u52A1 AgentTask UUID\uFF08\u4E0E --space \u4E92\u65A5\uFF09" }],
+          flags: [
+            { name: "space", type: "string", valueHint: "<id>", description: "\u7A7A\u95F4 ID\uFF08\u7BA1\u5BB6/\u7A7A\u95F4\u9762\uFF1B\u4E0E <taskId> \u4E92\u65A5\uFF09" },
+            { name: "repo", type: "string", valueHint: "<owner/name>", description: "\u591A\u4ED3\u5E93\u7A7A\u95F4\uFF1A\u53EA\u770B\u8BE5\u4ED3\u5E93\u7684\u8FD0\u884C\uFF08\u4EFB\u52A1\u9762\u4E13\u7528\uFF0C\u5BA2\u6237\u7AEF\u8FC7\u6EE4\uFF09" },
+            { name: "ref", type: "string", valueHint: "<branch>", description: "\u6309\u5206\u652F/tag \u8FC7\u6EE4\uFF08\u7A7A\u95F4\u9762\u4E13\u7528\uFF09" },
+            { name: "failed", type: "boolean", description: "\u53EA\u770B\u5931\u8D25\u7684\u8FD0\u884C\uFF08\u7A7A\u95F4\u9762\u4E13\u7528\uFF09" },
+            { name: "limit", type: "number", valueHint: "<n>", description: "\u8FD0\u884C\u6761\u6570\u4E0A\u9650\uFF08\u670D\u52A1\u7AEF\u9ED8\u8BA4 20\uFF0C\u4E0A\u9650 100\uFF09" }
+          ],
+          examples: ["morula ci status <taskId>", "morula ci status --space <id> --failed"],
+          writes: "none",
+          idempotent: true,
+          emits: ["ok", "taskId", "spaceId", "runs", "deployments", "repos", "hasCiConfig", "notice", "repoFilter"]
+        },
+        {
+          action: "log",
+          summary: "job log by job id (the server resolves the owning run; both faces use this same endpoint \u2014 the task/space flag only declares which face you are calling from). `truncated:true` means the log was tail-cut, not complete",
+          args: [{ name: "taskId", description: "\u672C\u4EFB\u52A1 AgentTask UUID\uFF08\u4E0E --space \u4E92\u65A5\uFF09" }],
+          flags: [
+            { name: "space", type: "string", valueHint: "<id>", description: "\u7A7A\u95F4 ID\uFF08\u7BA1\u5BB6/\u7A7A\u95F4\u9762\uFF1B\u4E0E <taskId> \u4E92\u65A5\uFF09" },
+            { name: "job", type: "string", valueHint: "<jobId>", description: "job ID\uFF08\u5FC5\u586B\uFF1B\u6765\u81EA ci status \u7684 jobs[].id\uFF09", required: true },
+            { name: "tail", type: "number", valueHint: "<n>", description: "\u4FDD\u7559\u7684\u65E5\u5FD7\u5C3E\u90E8\u5B57\u8282\u6570\uFF08\u670D\u52A1\u7AEF\u9ED8\u8BA4 64KB\uFF09" }
+          ],
+          examples: ["morula ci log <taskId> --job <jobId> --tail 20000"],
+          writes: "none",
+          idempotent: true,
+          emits: ["ok", "runId", "jobId", "log", "truncated"]
+        },
+        {
+          action: "deployments",
+          summary: "deployment records for a task (or a space) \u2014 display only: deployments do NOT drive lifecycle state (released is driven solely by a successful production-branch pipeline run)",
+          args: [{ name: "taskId", description: "\u672C\u4EFB\u52A1 AgentTask UUID\uFF08\u4E0E --space \u4E92\u65A5\uFF09" }],
+          flags: [
+            { name: "space", type: "string", valueHint: "<id>", description: "\u7A7A\u95F4 ID\uFF08\u7BA1\u5BB6/\u7A7A\u95F4\u9762\uFF1B\u4E0E <taskId> \u4E92\u65A5\uFF09" }
+          ],
+          examples: ["morula ci deployments <taskId>"],
+          writes: "none",
+          idempotent: true,
+          emits: ["ok", "spaceId", "deployments"]
+        },
+        {
+          action: "test-report",
+          summary: "failed test cases of a run; --run omitted resolves to the newest run in the CI view \u2014 no run at all is CI_RUN_NOT_FOUND (exit 3), never an empty report; provider without this capability (GitHub) returns CAPABILITY_UNSUPPORTED",
+          args: [{ name: "taskId", description: "\u672C\u4EFB\u52A1 AgentTask UUID\uFF08\u4E0E --space \u4E92\u65A5\uFF09" }],
+          flags: [
+            { name: "space", type: "string", valueHint: "<id>", description: "\u7A7A\u95F4 ID\uFF08\u7BA1\u5BB6/\u7A7A\u95F4\u9762\uFF1B\u4E0E <taskId> \u4E92\u65A5\uFF09" },
+            { name: "run", type: "string", valueHint: "<runId>", description: "\u8FD0\u884C ID\uFF08\u7F3A\u7701 = CI \u89C6\u56FE\u91CC\u6700\u65B0\u4E00\u6761\u8FD0\u884C\uFF09" }
+          ],
+          examples: ["morula ci test-report <taskId>"],
+          writes: "none",
+          idempotent: true,
+          emits: ["ok", "runId", "report"]
+        },
+        {
+          action: "retry",
+          summary: "re-run a failed pipeline (Phase 3; space face ONLY \u2014 a positional <taskId> is a usage error, retry is not open to the task face; person + steward, and a steward must go through an elicitation confirm card). Omit both --run and --job to retry the newest FAILED run of the space (no failed run at all \u2192 CI_RUN_NOT_FOUND exit 3). Only failure/cancelled runs or jobs can be retried (CI_RETRY_NOT_ALLOWED exit 6). NOT idempotent: every call starts another platform re-run",
+          flags: [
+            { name: "space", type: "string", valueHint: "<id>", description: "\u7A7A\u95F4 ID\uFF08\u5FC5\u586B\uFF1Bretry \u53EA\u6709\u7A7A\u95F4\u9762\uFF0C\u4EFB\u52A1\u9762\u4E0D\u5F00\u653E\uFF09", required: true },
+            { name: "run", type: "string", valueHint: "<runId>", description: "\u8981\u91CD\u8DD1\u7684\u8FD0\u884C ID\uFF08\u4E0E --job \u4E92\u65A5\uFF1B\u7F3A\u7701 = \u8BE5\u7A7A\u95F4\u6700\u65B0\u4E00\u6761\u5931\u8D25\u8FD0\u884C\uFF09" },
+            { name: "job", type: "string", valueHint: "<jobId>", description: "\u8981\u91CD\u8DD1\u7684\u5355\u4E2A job ID\uFF08\u4E0E --run \u4E92\u65A5\uFF1B\u6765\u81EA ci status \u7684 jobs[].id\uFF09" }
+          ],
+          examples: ["morula ci retry --space <id>", "morula ci retry --space <id> --job <jobId>"],
+          writes: "remote",
+          idempotent: false,
+          emits: ["ok", "action", "runId", "jobId", "externalId", "ref", "acceptedAt"]
+        }
+      ],
+      notes: [
+        "\u4E24\u4E2A\u9762\uFF08\u4EFB\u52A1\u9762 <taskId> / \u7A7A\u95F4\u9762 --space <spaceId>\uFF09\u4E92\u65A5\uFF1A\u540C\u65F6\u7ED9 \u2192 usage error(2)\uFF0C\u90FD\u4E0D\u7ED9\u540C\u6837 usage error\u3002\u51ED\u8BC1\u4E0E\u4F5C\u7528\u57DF\u4E0D\u540C\uFF0C\u731C\u9519\u4F1A\u53D8\u6210\u9759\u9ED8\u8D8A\u6743\u6216\u9759\u9ED8\u5931\u8D25",
+        "\u53EA\u8BFB\u9762\uFF1Astatus / log / deployments / test-report \u53EA\u8BFB\uFF08writes: none\uFF09\uFF1Bretry \u662F Phase 3 \u7684\u552F\u4E00\u5199\u9762\uFF08writes: remote\uFF0C\u975E\u5E42\u7B49\uFF09\uFF0C\u4E14**\u53EA\u6709\u7A7A\u95F4\u9762**\u2014\u2014\u7ED9\u4F4D\u7F6E\u53C2\u6570 <taskId> \u2192 usage error(2)",
+        "\u89E6\u53D1\u624B\u52A8 job\uFF08play\uFF0C\u90E8\u7F72\uFF09\u4E0D\u8FDB CLI\uFF1A\u4EC5\u4EBA\u9762\uFF08D5/D6\uFF09\uFF0C\u5165\u53E3\u53EA\u5728 web \u786E\u8BA4\u5F39\u7A97",
+        "\u670D\u52A1\u7AEF\u4E1A\u52A1\u5931\u8D25\u662F HTTP 200 + `{ ok:false, code, message }`\uFF1ACI_JOB_NOT_FOUND / CI_RUN_NOT_FOUND / TASK_NOT_FOUND / OBJECT_NOT_FOUND \u2192 exit 3\uFF1BCI_RETRY_NOT_ALLOWED / CI_JOB_NOT_MANUAL \u2192 exit 6\uFF1BCAPABILITY_UNSUPPORTED / NO_CONNECTION / \u5176\u4F59 \u2192 exit 1"
+      ]
+    },
+    {
+      resource: "attachment",
+      summary: "file attachments for objects / comments / chat messages (local file upload)",
+      actions: [
+        {
+          action: "upload",
+          summary: "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)",
+          args: [{ name: "file", required: true, description: "\u672C\u5730\u6587\u4EF6\u8DEF\u5F84" }],
+          flags: [
+            { name: "object", type: "string", valueHint: "<id>", description: "\u6302\u5230\u5BF9\u8C61" },
+            { name: "comment", type: "string", valueHint: "<id>", description: "\u6302\u5230\u8BC4\u8BBA" },
+            { name: "ag-message", type: "boolean", description: "\u6302\u5230 Chat \u4F1A\u8BDD\u6700\u65B0\u6D88\u606F" },
+            { name: "task", type: "string", valueHint: "<agentTaskId>", description: "\u7EAF Chat \u4EFB\u52A1\u5F52\u5E76\u5230\u4F1A\u8BDD\u6D88\u606F" },
+            { name: "inline", type: "boolean", description: "\u5185\u8054\u9644\u4EF6" }
+          ],
+          examples: ["morula attachment upload <file> --object <id>"],
+          writes: "remote"
+        },
+        {
+          action: "list",
+          summary: "list attachments for an object",
+          flags: [{ name: "object", type: "string", valueHint: "<id>", description: "\u5BF9\u8C61 ID\uFF08\u5FC5\u586B\uFF09", required: true }],
+          examples: ["morula attachment list --object <id>"],
+          writes: "none",
+          idempotent: true
+        },
+        {
+          action: "get",
+          summary: "get attachment details",
+          args: [{ name: "id", required: true, description: "\u9644\u4EF6 ID" }],
+          flags: [],
+          examples: ["morula attachment get <id>"],
+          writes: "none",
+          idempotent: true
+        },
+        {
+          action: "content",
+          summary: "read the parsed text content (MinerU markdown) of an attachment; unparsed/parsing/failed is reported in the body, not as an HTTP error",
+          args: [{ name: "id", required: true, description: "\u9644\u4EF6 ID" }],
+          flags: [{ name: "max-chars", type: "number", valueHint: "<n>", description: "\u6700\u5927\u8FD4\u56DE\u5B57\u7B26\u6570\uFF08\u670D\u52A1\u7AEF\u7F3A\u7701 8000\uFF09" }],
+          examples: ["morula attachment content <id>", "morula attachment content <id> --max-chars 20000"],
+          writes: "none",
+          idempotent: true
+        },
+        {
+          action: "download-url",
+          summary: "get signed download URL for an attachment",
+          args: [{ name: "id", required: true, description: "\u9644\u4EF6 ID" }],
+          flags: [],
+          examples: ["morula attachment download-url <id>"],
+          writes: "none",
+          idempotent: true
+        },
+        {
+          action: "delete",
+          summary: "delete attachment",
+          args: [{ name: "id", required: true, description: "\u9644\u4EF6 ID" }],
+          flags: [],
+          examples: ["morula attachment delete <id>"],
+          writes: "remote"
+        }
+      ]
+    }
+  ]
+};
+
+// ../morula-cli/src/commands/steward.ts
+async function stewardCommand(context) {
+  if (!context.runtime.token)
+    throw new CliError("UNAUTHENTICATED", EXIT.UNAUTHENTICATED, "\u8BF7\u5148\u8FD0\u884C morula auth login");
+  const { action, flags } = context.parsed;
+  if (action === "get") {
+    rejectUnknownFlags(flags, ["space"]);
+    return context.client.stewards.get(requireFlag(flags, "space"));
+  }
+  if (action === "dispatch") {
+    rejectUnknownFlags(flags, ["space", "title", "description", "state", "assignee", "repo", "client-message-id"]);
+    const projectId = requireFlag(flags, "space");
+    const title = requireFlag(flags, "title");
+    const state = flagString(flags, "state");
+    const description = flagString(flags, "description");
+    const assigneePrincipalId = flagString(flags, "assignee");
+    const repoFullName = flagString(flags, "repo");
+    const clientMessageId = flagString(flags, "client-message-id");
+    return context.client.stewards.dispatch(projectId, {
+      title,
+      ...description !== void 0 ? { description } : {},
+      ...state !== void 0 ? { state } : {},
+      ...assigneePrincipalId !== void 0 ? { assigneePrincipalId } : {},
+      ...repoFullName !== void 0 ? { repoFullName } : {},
+      ...clientMessageId !== void 0 ? { clientMessageId } : {}
+    });
+  }
+  throw usage("usage: morula steward <get|dispatch>");
+}
+
+// ../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 = requireId4(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 = requireId4(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 = requireId4(positionals, "task delete");
+    return context.client.tasks.delete(id);
+  }
+  if (action === "branch") {
+    rejectUnknownFlags(flags, ["name", "repo"]);
+    const id = requireId4(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 = requireId4(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 = requireId4(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 };
+  }
+  if (action === "inbox") {
+    rejectUnknownFlags(flags, ["peek", "after-seq"]);
+    const taskId = await resolveTaskId(context);
+    if (!taskId) {
+      throw usage(`morula task inbox \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 inbox            # \u62C9\u53D6\u672C\u7EBF\u7A0B\u672A\u6D88\u8D39\u6D88\u606F\uFF08\u7EB3\u5165\u672C\u56DE\u5408\uFF0C\u670D\u52A1\u7AEF\u6807\u8BB0\u5DF2\u6D88\u8D39\uFF09
+  morula task inbox --peek     # \u53EA\u8BFB\uFF0C\u4E0D\u6807\u8BB0\u6D88\u8D39
+\u8BF4\u660E: \u4EC5\u5728\u9636\u6BB5\u8FD0\u884C\u8FC7\u7A0B\u4E2D\u3001\u4E14\u5230\u8FBE\u68C0\u67E5\u70B9\u65F6\u8C03\u7528\uFF08\u4E00\u6279\u6539\u52A8\u5B8C\u6210\u540E / git commit \u524D / git push \u524D / \u6536\u5230\u4E2D\u65AD\u4FE1\u53F7\u65F6\uFF09\uFF1B\u6CA1\u6709\u6D88\u606F\u5C31\u7ACB\u5373\u7EE7\u7EED\uFF0C\u4E0D\u8981\u53CD\u590D\u8F6E\u8BE2\u3002`);
+    }
+    const afterSeq = flagNumber(flags, "after-seq");
+    const peek = flagBoolean(flags, "peek");
+    const query = {};
+    if (afterSeq !== void 0)
+      query.afterSeq = afterSeq;
+    if (peek)
+      query.peek = 1;
+    let result;
+    try {
+      result = await context.client.http.get(`/agent-tasks/${encodeURIComponent(taskId)}/thread/inbox`, query);
+    } catch (error) {
+      const code = error?.code ?? error?.response?.data?.code;
+      if (code === "CHECKPOINT_UNSUPPORTED" || code === "CHECKPOINT_NO_ACTIVE_TURN") {
+        throw new CliError(String(code), EXIT.OTHER, `${error?.message ?? "\u5F53\u524D\u4E0D\u53EF\u62C9\u53D6\u68C0\u67E5\u70B9\u6D88\u606F"}\uFF08\u6CA1\u6709\u8FDB\u884C\u4E2D\u7684\u56DE\u5408\u65F6\u65E0\u9700\u68C0\u67E5\u70B9\uFF1B\u7B49\u5F85\u672C\u8F6E\u7ED3\u675F\u540E\u7684\u7EED\u8DD1\u5373\u53EF\uFF09`);
+      }
+      throw error;
+    }
+    const messages = (result?.messages ?? []).map((m) => ({
+      seq: m.seq,
+      author: m.authorName ?? (m.authorType === "user" ? "\u4EBA" : m.authorType === "system" ? "\u5E73\u53F0" : "\u8FD0\u884C\u65F6"),
+      state: m.deliveryState ?? "consumed",
+      content: m.content
+    }));
+    return {
+      taskId,
+      turnNo: result?.turnNo ?? 1,
+      consumed: result?.consumed === true,
+      count: messages.length,
+      messages,
+      ...messages.length === 0 ? { hint: "\u672C\u7EBF\u7A0B\u6CA1\u6709\u65B0\u6D88\u606F\uFF1A\u6309\u539F\u8BA1\u5212\u7EE7\u7EED\uFF0C\u4E0D\u8981\u5C55\u5F00\u8BA8\u8BBA\u3002" } : {}
+    };
+  }
+  if (action === "agent-tasks") {
+    rejectUnknownFlags(flags, ["object", "status", "page", "page-size"]);
+    const objectId = requireFlag(flags, "object");
+    return context.client.agentTasks.list(compact3({
+      objectId,
+      status: flagString(flags, "status"),
+      page: flagNumber(flags, "page"),
+      pageSize: flagNumber(flags, "page-size")
+    }));
+  }
+  if (action === "cancel") {
+    rejectUnknownFlags(flags, []);
+    const id = requireId4(positionals, "task cancel");
+    return context.client.agentTasks.cancel(id);
+  }
+  if (action === "rerun") {
+    rejectUnknownFlags(flags, []);
+    const id = requireId4(positionals, "task rerun");
+    const result = await context.client.agentTasks.rerun(id);
+    if (result?.ok === false)
+      throw new CliError(result.code ?? "RERUN_FAILED", rerunExitCode(result.code), `\u91CD\u8DD1\u5931\u8D25: ${result.message ?? result.code ?? "\u672A\u77E5\u539F\u56E0"}`);
+    return result;
+  }
+  throw usage("usage: morula task <list|create|get|update|delete|branch|state|analysis-verdict|inbox|agent-tasks|cancel|rerun>");
+}
+function rerunExitCode(code) {
+  if (code === "NOT_FOUND")
+    return EXIT.NOT_FOUND;
+  if (code === "CONFLICT" || code === "ALREADY_QUEUED")
+    return EXIT.CONFLICT;
+  return EXIT.OTHER;
+}
+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 requireId4(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,
+  "autopilot": autopilotCommand,
+  "ci": ciCommand,
+  "comment": commentCommand,
+  "dashboard": dashboardCommand,
+  "document": documentCommand,
+  "object-meta": objectMetaCommand,
+  "report": reportCommand,
+  "repo": repoCommand,
+  "review": reviewCommand,
+  "task": taskCommand,
+  "space": spaceCommand,
+  "space-member": spaceMemberCommand,
+  "steward": stewardCommand
+};
+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: renderTopLevelCommands(SPEC),
+  globalFlags: {
+    "--env <context>": "select test or a saved context",
+    "--url <baseUrl>": "override API base URL",
+    "--token <token>": "override token for this invocation (not persisted)",
+    "--json": "no-op; output is always JSON (accepted for familiarity)",
+    "--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, spec: SPEC });