@linkedclaw/cli 0.1.3 → 0.1.5

package/dist/bin.js

@@ -7,50 +7,218 @@ var __export = (target, all) => {
 
 // src/bin.ts
 import { Command } from "commander";
+import { readFileSync as readFileSync8 } from "fs";
+import { fileURLToPath } from "url";
+import { dirname as dirname4, join as join6 } from "path";
 
-// src/config.ts
-import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync } from "fs";
-import { homedir } from "os";
-import { join, dirname } from "path";
-import { load as yamlLoad, dump as yamlDump } from "js-yaml";
-var DEFAULT_CLOUD_URL = "https://api.linkedclaw.com";
-var DEFAULT_RELAY_URL = "wss://api.linkedclaw.com/ws";
-function configDir() {
-  return process.env["LINKEDCLAW_CONFIG_DIR"] ?? join(homedir(), ".linkedclaw");
+// src/commands/agent.ts
+import { spawn } from "child_process";
+import { accessSync, constants, statSync } from "fs";
+import path from "path";
+function registerAgentCommands(program2) {
+  const agent = program2.command("agent").description("Owner-agent runtime commands");
+  agent.command("run").description("Run a long-lived owner agent from a local config").option("--config <path>", "Owner-agent config path").option("--watch <debate_id:commons_log_id>", "Watch a debate Commons Log; repeatable", collect, []).option("--once", "Process pending local tasks once, then exit").option("--python-command <cmd>", "Python executable to use").action((opts) => runOwnerAgent(opts));
+  agent.command("rotate-mandate").description("Issue a replacement owner-agent mandate, update local config, then revoke the old one").option("--config <path>", "Owner-agent config path").option("--old-mandate-id <id>", "Mandate id to replace; defaults to the configured transport mandate").option("--expires-at <iso>", "Replacement mandate expiry timestamp").option("--python-command <cmd>", "Python executable to use").action((opts) => rotateOwnerAgentMandate(opts));
 }
-function configPath() {
-  return join(configDir(), "config.yaml");
+function collect(value, previous) {
+  return [...previous, value];
 }
-function readFileConfig(path = configPath()) {
-  if (!existsSync(path)) return {};
-  const raw = readFileSync(path, "utf8");
-  const parsed = yamlLoad(raw);
-  if (parsed === null || parsed === void 0) return {};
-  if (typeof parsed !== "object") {
-    throw new Error(`config file ${path} is not a YAML object`);
+function runOwnerAgent(opts) {
+  let pythonCommand;
+  let watches;
+  let configPath2;
+  try {
+    pythonCommand = resolvePythonCommand(opts.pythonCommand ?? process.env.LINKEDCLAW_OWNER_AGENT_PYTHON ?? "python3");
+    watches = (opts.watch ?? []).map(validateWatch);
+    const rawConfigPath = opts.config ?? process.env.LINKEDCLAW_OWNER_AGENT_CONFIG;
+    configPath2 = rawConfigPath === void 0 ? void 0 : validateConfigPath(rawConfigPath);
+  } catch (err) {
+    process.stderr.write(
+      JSON.stringify({
+        error: "invalid_agent_run_option",
+        message: err instanceof Error ? err.message : String(err)
+      }) + "\n"
+    );
+    process.exitCode = 1;
+    return;
   }
-  return parsed;
+  const args = ["-m", "linkedclaw.owner_agent.cli", "run"];
+  if (configPath2 !== void 0) {
+    args.push("--config", configPath2);
+  }
+  for (const watch of watches) {
+    args.push("--watch", watch);
+  }
+  if (opts.once) {
+    args.push("--once");
+  }
+  spawnOwnerAgentPython(args, pythonCommand);
 }
-function writeFileConfig(cfg, path = configPath()) {
-  const dir = dirname(path);
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 448 });
-  writeFileSync(path, yamlDump(cfg), { mode: 384 });
-  if (process.platform !== "win32") chmodSync(path, 384);
+function rotateOwnerAgentMandate(opts) {
+  let pythonCommand;
+  let configPath2;
+  try {
+    pythonCommand = resolvePythonCommand(opts.pythonCommand ?? process.env.LINKEDCLAW_OWNER_AGENT_PYTHON ?? "python3");
+    const rawConfigPath = opts.config ?? process.env.LINKEDCLAW_OWNER_AGENT_CONFIG;
+    if (rawConfigPath === void 0) {
+      throw new Error("Config path required; pass --config or set LINKEDCLAW_OWNER_AGENT_CONFIG");
+    }
+    configPath2 = validateConfigPath(rawConfigPath);
+    if (opts.oldMandateId !== void 0) {
+      validateNonEmptyNoNul(opts.oldMandateId, "--old-mandate-id");
+    }
+    if (opts.expiresAt !== void 0) {
+      validateNonEmptyNoNul(opts.expiresAt, "--expires-at");
+    }
+  } catch (err) {
+    process.stderr.write(
+      JSON.stringify({
+        error: "invalid_agent_rotate_mandate_option",
+        message: err instanceof Error ? err.message : String(err)
+      }) + "\n"
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const args = [
+    "-m",
+    "linkedclaw.owner_agent.cli",
+    "rotate-mandate",
+    "--config",
+    configPath2
+  ];
+  if (opts.oldMandateId !== void 0) {
+    args.push("--old-mandate-id", opts.oldMandateId);
+  }
+  if (opts.expiresAt !== void 0) {
+    args.push("--expires-at", opts.expiresAt);
+  }
+  spawnOwnerAgentPython(args, pythonCommand);
 }
-function resolveConfig(overrides = {}) {
-  const env = process.env;
-  const file = readFileConfig();
-  const cloudUrl = overrides.cloudUrl ?? env["LINKEDCLAW_CLOUD_URL"] ?? file.cloudUrl ?? DEFAULT_CLOUD_URL;
-  const relayUrl = overrides.relayUrl ?? env["LINKEDCLAW_RELAY_URL"] ?? file.relayUrl ?? DEFAULT_RELAY_URL;
-  const apiKey = overrides.apiKey ?? env["LINKEDCLAW_API_KEY"] ?? file.apiKey;
-  return {
-    ...file,
-    ...overrides,
-    cloudUrl,
-    relayUrl,
-    ...apiKey !== void 0 ? { apiKey } : {}
+function spawnOwnerAgentPython(args, pythonCommand) {
+  const child = spawn(pythonCommand, args, { stdio: "inherit" });
+  const forwardSignal = (signal) => {
+    if (!child.killed) {
+      child.kill(signal);
+    }
   };
+  const onSigterm = () => forwardSignal("SIGTERM");
+  const onSigint = () => forwardSignal("SIGINT");
+  const cleanupSignals = () => {
+    process.off("SIGTERM", onSigterm);
+    process.off("SIGINT", onSigint);
+  };
+  process.on("SIGTERM", onSigterm);
+  process.on("SIGINT", onSigint);
+  child.on("error", (err) => {
+    cleanupSignals();
+    process.stderr.write(
+      JSON.stringify({ error: "owner_agent_python_unavailable", message: err.message }) + "\n"
+    );
+    process.exitCode = 1;
+  });
+  child.on("exit", (code, signal) => {
+    cleanupSignals();
+    process.exitCode = signal ? 1 : code ?? 1;
+  });
+}
+function validateNonEmptyNoNul(value, label) {
+  if (value.length === 0 || value.trim().length === 0) {
+    throw new Error(`${label} must be non-empty`);
+  }
+  if (value.includes("\0")) {
+    throw new Error(`${label} must not contain NUL bytes`);
+  }
+}
+function validateWatch(value) {
+  const separator = value.indexOf(":");
+  if (separator <= 0 || separator === value.length - 1 || value.indexOf(":", separator + 1) !== -1) {
+    throw new Error("--watch must use debate_id:commons_log_id with both ids non-empty");
+  }
+  const debateId = value.slice(0, separator).trim();
+  const commonsLogId = value.slice(separator + 1).trim();
+  if (!debateId || !commonsLogId) {
+    throw new Error("--watch must use debate_id:commons_log_id with both ids non-empty");
+  }
+  return `${debateId}:${commonsLogId}`;
+}
+function validateConfigPath(value) {
+  if (value.length === 0 || value.trim().length === 0) {
+    throw new Error("Config path must be a non-empty file path");
+  }
+  if (value.includes("\0")) {
+    throw new Error("Config path must not contain NUL bytes");
+  }
+  try {
+    if (!statSync(value).isFile()) {
+      throw new Error(`Config path is not a regular file: ${value}`);
+    }
+  } catch (err) {
+    if (err instanceof Error && err.message.startsWith("Config path is not a regular file:")) {
+      throw err;
+    }
+    throw new Error(`Config path does not exist or cannot be read: ${value}`);
+  }
+  return value;
+}
+function resolvePythonCommand(command) {
+  const trimmed = command.trim();
+  if (!trimmed) {
+    throw new Error("Python command must be a non-empty executable name or absolute path");
+  }
+  if (trimmed.includes("\0") || /[\s;&|<>`$\n\r]/.test(trimmed)) {
+    throw new Error("Python command must be an executable only; arguments and shell metacharacters are rejected");
+  }
+  const isAbsolute3 = path.isAbsolute(trimmed) || path.win32.isAbsolute(trimmed);
+  const hasPathSeparator = trimmed.includes("/") || trimmed.includes("\\");
+  if (hasPathSeparator && !isAbsolute3) {
+    throw new Error("Python command path must be absolute");
+  }
+  if (isAbsolute3) {
+    assertExecutable(trimmed);
+    return trimmed;
+  }
+  if (!/^[A-Za-z0-9._-]+$/.test(trimmed)) {
+    throw new Error("Python command must be a bare executable name or absolute path");
+  }
+  const resolved = findExecutable(trimmed);
+  if (resolved === null) {
+    throw new Error(`Python command not found on PATH: ${trimmed}`);
+  }
+  return resolved;
+}
+function findExecutable(command) {
+  const pathEntries = (process.env.PATH ?? "").split(path.delimiter).filter(Boolean);
+  const extensions = process.platform === "win32" ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").filter(Boolean) : [""];
+  for (const dir of pathEntries) {
+    for (const ext of extensions) {
+      const candidate = path.join(dir, command.toLowerCase().endsWith(ext.toLowerCase()) ? command : `${command}${ext}`);
+      if (isExecutable(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return null;
 }
+function assertExecutable(file) {
+  if (!isExecutable(file)) {
+    throw new Error(`Python command is not an executable file: ${file}`);
+  }
+}
+function isExecutable(file) {
+  try {
+    if (!statSync(file).isFile()) {
+      return false;
+    }
+    accessSync(file, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/arena.ts
+import { readFileSync as readFileSync3 } from "fs";
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
 var external_exports = {};
@@ -530,8 +698,8 @@ function getErrorMap() {
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path, errorMaps, issueData } = params;
-  const fullPath = [...path, ...issueData.path || []];
+  const { data, path: path2, errorMaps, issueData } = params;
+  const fullPath = [...path2, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -647,11 +815,11 @@ var errorUtil;
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path, key) {
+  constructor(parent, value, path2, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path;
+    this._path = path2;
     this._key = key;
   }
   get path() {
@@ -4411,8 +4579,8 @@ var ConsumerClient = class {
     this.apiKey = apiKey;
     this.fetchImpl = options?.fetch ?? fetch;
   }
-  async request(path, init, schema) {
-    const res = await this.fetchImpl(`${this.baseUrl}${path}`, {
+  async request(path2, init, schema) {
+    const res = await this.fetchImpl(`${this.baseUrl}${path2}`, {
       ...init,
       headers: {
         "Content-Type": "application/json",
@@ -4758,8 +4926,50 @@ var ConsumerClient = class {
   }
 };
 
+// ../../sdk/consumer-ts/dist/capabilitySchema.js
+var CapabilitySchemaError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CapabilitySchemaError";
+  }
+};
+async function fetchCapabilitySchema(listing, capability, options) {
+  const meta = listing.capabilities_meta?.[capability];
+  if (!meta || typeof meta !== "object" || Array.isArray(meta)) {
+    throw new CapabilitySchemaError(`no capabilities_meta entry for ${JSON.stringify(capability)}`);
+  }
+  const entry = meta;
+  const schemaUrl = entry["schema_url"];
+  if (!schemaUrl || typeof schemaUrl !== "string") {
+    throw new CapabilitySchemaError(`no schema_url for capability ${JSON.stringify(capability)}`);
+  }
+  const schemaDigest = entry["schema_digest"];
+  const fetchFn = options?.fetch ?? globalThis.fetch;
+  const response = await fetchFn(schemaUrl);
+  if (!response.ok) {
+    throw new CapabilitySchemaError(`failed to fetch schema for ${JSON.stringify(capability)}: HTTP ${response.status}`);
+  }
+  const buffer = await response.arrayBuffer();
+  const hashBuffer = await crypto.subtle.digest("SHA-256", buffer);
+  const actual = "sha256:" + Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  if (actual !== schemaDigest) {
+    throw new CapabilitySchemaError(`schema digest mismatch for ${JSON.stringify(capability)}: expected ${String(schemaDigest)}, got ${actual}`);
+  }
+  const text = new TextDecoder().decode(buffer);
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new CapabilitySchemaError(`schema body is not valid JSON for ${JSON.stringify(capability)}`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new CapabilitySchemaError(`schema body is not a JSON object for ${JSON.stringify(capability)}`);
+  }
+  return parsed;
+}
+
 // ../../sdk/consumer-ts/dist/index.js
-var DEFAULT_RELAY_URL2 = "wss://api.linkedclaw.com/ws";
+var DEFAULT_RELAY_URL = "wss://api.linkedclaw.com/ws";
 
 // ../../sdk/provider-ts/dist/models.js
 var SessionSchema2 = external_exports.object({
@@ -5014,8 +5224,8 @@ var ProviderClient = class {
     this.apiKey = apiKey;
     this.fetchImpl = options?.fetch ?? fetch;
   }
-  async request(path, init, schema) {
-    const res = await this.fetchImpl(`${this.baseUrl}${path}`, {
+  async request(path2, init, schema) {
+    const res = await this.fetchImpl(`${this.baseUrl}${path2}`, {
       ...init,
       headers: {
         "Content-Type": "application/json",
@@ -5417,12 +5627,18 @@ function strOrEmpty(frame, key) {
 
 // ../../sdk/consumer-runtime-ts/dist/index.js
 import WebSocket2 from "ws";
-var ACP_TIMEOUT_MS = 3e4;
+var ACP_CONNECT_TIMEOUT_MS = 2e3;
+var SESSION_ACCEPT_TIMEOUT_MS = 3e4;
 var SessionRejectedError = class extends Error {
   constructor(reason) {
     super(`session rejected: ${reason}`);
   }
 };
+var TransportMissError = class extends Error {
+  constructor(reason) {
+    super(`transport miss: ${reason}`);
+  }
+};
 var RequesterFlows = class {
   constructor(client) {
     this.client = client;
@@ -5432,8 +5648,11 @@ var RequesterFlows = class {
     return this.client.discover({ capability, ...extra });
   }
   /**
-   * Open a session. Performs HTTP create → ACP WS handshake (SESSION_CREATE/ACCEPT) → HTTP activate.
-   * Default 30s wait for SESSION_ACCEPT.
+   * Open a session. HTTP create → WS handshake (SESSION_CREATE/ACCEPT) → done.
+   *
+   * Default transport is /ws — native providers register there
+   * (`SkillConfig.try_acp=False` upstream default). Set `tryAcp: true` to try
+   * /acp first; on opt-in, falls back to /ws when the recipient isn't on /acp.
    */
   async hire(params) {
     const session = await this.client.createSession({
@@ -5443,43 +5662,80 @@ var RequesterFlows = class {
       ...params.referredBy !== void 0 ? { referred_by: params.referredBy } : {}
     });
     if (params.autoActivate === false) return { session, activated: false };
-    const relayUrl = params.relayUrl ?? DEFAULT_RELAY_URL2;
-    const acpUrl = relayUrl.replace(/\/ws$/, "/acp");
-    const ws = new WebSocket2(acpUrl);
+    const relayUrl = params.relayUrl ?? DEFAULT_RELAY_URL;
+    try {
+      if (params.tryAcp) {
+        const acpUrl = relayUrl.replace(/\/ws$/, "/acp");
+        try {
+          await this.attemptHandshake(acpUrl, session.session_id, params, ACP_CONNECT_TIMEOUT_MS);
+        } catch (err) {
+          if (!(err instanceof TransportMissError)) throw err;
+          await this.attemptHandshake(relayUrl, session.session_id, params, SESSION_ACCEPT_TIMEOUT_MS);
+        }
+      } else {
+        await this.attemptHandshake(relayUrl, session.session_id, params, SESSION_ACCEPT_TIMEOUT_MS);
+      }
+    } catch (err) {
+      await this.client.endSession(session.session_id, {}).catch(() => {
+      });
+      if (err instanceof TransportMissError) {
+        throw new SessionRejectedError(`agent unreachable`);
+      }
+      throw err;
+    }
+    return { session, activated: true };
+  }
+  async attemptHandshake(url, sessionId, params, connectTimeoutMs) {
+    const ws = new WebSocket2(url);
     try {
-      await new Promise((resolve, reject) => {
-        ws.once("open", () => resolve());
-        ws.once("error", reject);
+      await new Promise((resolve3, reject) => {
+        const timer = setTimeout(
+          () => reject(new TransportMissError("connect timeout")),
+          connectTimeoutMs
+        );
+        ws.once("open", () => {
+          clearTimeout(timer);
+          resolve3();
+        });
+        ws.once("error", (err) => {
+          clearTimeout(timer);
+          reject(new TransportMissError(`connect failed: ${err.message}`));
+        });
       });
       ws.send(JSON.stringify({ type: MessageType.IDENTIFY, agent_id: params.agentId, token: params.apiKey }));
       ws.send(JSON.stringify({
         type: MessageType.SESSION_CREATE,
-        session_id: session.session_id,
+        session_id: sessionId,
         recipient: params.providerAgentId,
         capability: params.capability
       }));
-      const reply = await new Promise((resolve, reject) => {
-        const timer = setTimeout(() => reject(new Error("ACP SESSION_ACCEPT timeout")), ACP_TIMEOUT_MS);
+      const reply = await new Promise((resolve3, reject) => {
+        const timer = setTimeout(
+          () => reject(new Error("SESSION_ACCEPT timeout")),
+          SESSION_ACCEPT_TIMEOUT_MS
+        );
         ws.once("message", (data) => {
           clearTimeout(timer);
-          resolve(JSON.parse(data.toString()));
+          resolve3(JSON.parse(data.toString()));
         });
         ws.once("error", (err) => {
           clearTimeout(timer);
           reject(err);
         });
       });
-      if (reply.type === MessageType.ERROR) throw new SessionRejectedError(reply.error ?? "relay error");
+      if (reply.type === MessageType.ERROR) {
+        const errMsg = reply.error ?? "relay error";
+        if (errMsg.includes("not connected")) throw new TransportMissError(errMsg);
+        throw new SessionRejectedError(errMsg);
+      }
       if (reply.type === MessageType.SESSION_REJECT) throw new SessionRejectedError(reply.reason ?? "rejected");
-      if (reply.type !== MessageType.SESSION_ACCEPT) throw new Error(`unexpected ACP reply: ${reply.type}`);
-    } catch (err) {
-      ws.close();
-      await this.client.endSession(session.session_id, {}).catch(() => {
-      });
-      throw err;
+      if (reply.type !== MessageType.SESSION_ACCEPT) throw new Error(`unexpected reply: ${reply.type}`);
+    } finally {
+      try {
+        ws.close();
+      } catch {
+      }
     }
-    ws.close();
-    return { session, activated: true };
   }
   send(sessionId, payload, seq) {
     const normalized = typeof payload === "string" ? { text: payload } : payload;
@@ -5490,6 +5746,52 @@ var RequesterFlows = class {
   }
 };
 
+// src/config.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync } from "fs";
+import { homedir } from "os";
+import { join, dirname } from "path";
+import { load as yamlLoad, dump as yamlDump } from "js-yaml";
+var DEFAULT_CLOUD_URL = "https://api.linkedclaw.com";
+var DEFAULT_RELAY_URL2 = "wss://api.linkedclaw.com/ws";
+function configDir() {
+  return process.env["LINKEDCLAW_CONFIG_DIR"] ?? join(homedir(), ".linkedclaw");
+}
+function configPath() {
+  return join(configDir(), "config.yaml");
+}
+function readFileConfig(path2 = configPath()) {
+  if (!existsSync(path2)) return {};
+  const raw = readFileSync(path2, "utf8");
+  const parsed = yamlLoad(raw);
+  if (parsed === null || parsed === void 0) return {};
+  if (typeof parsed !== "object") {
+    throw new Error(`config file ${path2} is not a YAML object`);
+  }
+  return parsed;
+}
+function writeFileConfig(cfg, path2 = configPath()) {
+  const dir = dirname(path2);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 448 });
+  writeFileSync(path2, yamlDump(cfg), { mode: 384 });
+  if (process.platform !== "win32") chmodSync(path2, 384);
+}
+function resolveConfig(overrides = {}) {
+  const env = process.env;
+  const file = readFileConfig();
+  const cloudUrl = overrides.cloudUrl ?? env["LINKEDCLAW_CLOUD_URL"] ?? file.cloudUrl ?? DEFAULT_CLOUD_URL;
+  const relayUrl = overrides.relayUrl ?? env["LINKEDCLAW_RELAY_URL"] ?? file.relayUrl ?? DEFAULT_RELAY_URL2;
+  const servicesHostUrl = overrides.servicesHostUrl ?? env["LINKEDCLAW_SERVICES_HOST_URL"] ?? file.servicesHostUrl ?? cloudUrl;
+  const apiKey = overrides.apiKey ?? env["LINKEDCLAW_API_KEY"] ?? file.apiKey;
+  return {
+    ...file,
+    ...overrides,
+    cloudUrl,
+    relayUrl,
+    servicesHostUrl,
+    ...apiKey !== void 0 ? { apiKey } : {}
+  };
+}
+
 // src/errors.ts
 var LinkedClawError = class extends Error {
   code;
@@ -5507,11 +5809,11 @@ var NetworkError = class extends LinkedClawError {
   }
 };
 var ApiError = class extends LinkedClawError {
-  constructor(status, detail, path) {
-    super(`api_error_${status}`, `[${status}] ${path}: ${detail}`);
+  constructor(status, detail, path2) {
+    super(`api_error_${status}`, `[${status}] ${path2}: ${detail}`);
     this.status = status;
     this.detail = detail;
-    this.path = path;
+    this.path = path2;
     this.name = "ApiError";
   }
   status;
@@ -5581,57 +5883,428 @@ async function readStdin() {
   return Buffer.concat(chunks).toString("utf8");
 }
 
-// src/commands/auth.ts
-function registerAuthCommands(program2) {
-  program2.command("login").description("Store API key in ~/.linkedclaw/config.yaml").option("--api-key <key>", "API key (otherwise read from stdin)").option("--cloud-url <url>", "Override cloud URL").action(async (opts) => {
-    await runCommand(async () => {
-      let apiKey = opts.apiKey;
-      if (!apiKey) {
-        apiKey = await readLine("Paste API key: ");
+// src/arena/api.ts
+function errorDetail(body) {
+  if (body && typeof body === "object" && "detail" in body) {
+    const detail = body.detail;
+    return typeof detail === "string" ? detail : JSON.stringify(detail) ?? String(detail);
+  }
+  if (body == null) return "";
+  return typeof body === "string" ? body : JSON.stringify(body);
+}
+function makeArenaApi(targetUrl, apiKey) {
+  async function apiFetch(path2, opts = {}) {
+    const url = targetUrl.replace(/\/$/, "") + path2;
+    const res = await fetch(url, {
+      ...opts,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+        "X-CSRF-Token": apiKey,
+        ...opts.headers ?? {}
       }
-      if (!apiKey) throw new Error("empty api key");
-      const prev = readFileConfig();
-      const next = { ...prev, apiKey, ...opts.cloudUrl ? { cloudUrl: opts.cloudUrl } : {} };
-      writeFileConfig(next);
-      return { ok: true, path: configPath() };
     });
-  });
-  program2.command("register").description("Open browser to create a LinkedClaw account, then paste your API key").option("--no-browser", "Print URL instead of attempting to open the browser").option("--cloud-url <url>", "Override cloud URL").action(async (opts) => {
-    await runCommand(async () => {
-      const prev = readFileConfig();
-      const cloudUrl = opts.cloudUrl ?? prev.cloudUrl ?? process.env.LINKEDCLAW_CLOUD_URL ?? DEFAULT_CLOUD_URL;
-      const portalUrl = cloudUrl.replace(/\/$/, "") + "/register";
-      let opened = false;
-      if (opts.browser !== false) {
-        try {
-          const open = (await import("open")).default;
-          await open(portalUrl);
-          opened = true;
-        } catch {
-        }
+    let body;
+    try {
+      body = await res.json();
+    } catch {
+      body = null;
+    }
+    if (!res.ok) {
+      try {
+        throw new ApiError(res.status, errorDetail(body), path2);
+      } catch (err) {
+        if (err instanceof ApiError) throw err;
+        throw new LinkedClawError(`api_${res.status}`, `HTTP ${res.status}`);
       }
-      if (!opened) {
-        process.stderr.write(`Open this URL in a browser to register:
-  ${portalUrl}
+    }
+    return body;
+  }
+  return {
+    async createTournamentArena(body, opts) {
+      return apiFetch("/api/v1/arena/arenas", {
+        method: "POST",
+        headers: { "Idempotency-Key": opts.idempotencyKey },
+        body: JSON.stringify(body)
+      });
+    },
+    async register(body) {
+      return apiFetch("/api/v1/arena/contestants/register", {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+    },
+    async listOffers() {
+      return apiFetch("/api/v1/arena/offers", { method: "GET" });
+    },
+    async acceptOffer(offerId) {
+      return apiFetch(`/api/v1/arena/offers/${encodeURIComponent(offerId)}/accept`, {
+        method: "POST",
+        body: JSON.stringify({})
+      });
+    },
+    async submit(arenaId, body) {
+      const { submission_hash: _submissionHash, ...wireBody } = body;
+      return apiFetch(`/api/v1/arena/arenas/${encodeURIComponent(arenaId)}/submissions`, {
+        method: "POST",
+        body: JSON.stringify(wireBody)
+      });
+    },
+    async commitJuror(arenaId, body) {
+      return apiFetch(`/api/v1/arena/arenas/${encodeURIComponent(arenaId)}/jurors/commit`, {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+    },
+    async voteTask(arenaId, body) {
+      return apiFetch(`/api/v1/arena/arenas/${encodeURIComponent(arenaId)}/juror-votes`, {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+    },
+    async voteMatch(arenaId, matchId, body) {
+      return apiFetch(
+        `/api/v1/arena/arenas/${encodeURIComponent(arenaId)}/matches/${encodeURIComponent(matchId)}/juror-votes`,
+        { method: "POST", body: JSON.stringify(body) }
+      );
+    },
+    async listArenas(opts = {}) {
+      const suffix = opts.registered ? "?registered=true" : "";
+      return apiFetch(`/api/v1/arena/arenas${suffix}`, { method: "GET" });
+    },
+    async getLeaderboard(arenaId) {
+      return apiFetch(`/api/v1/arena/arenas/${encodeURIComponent(arenaId)}/leaderboard`, {
+        method: "GET"
+      });
+    },
+    async getCategoryLeaderboard(category, mode = "match") {
+      const q = new URLSearchParams({
+        category_topic: category.topic,
+        category_subtopic: category.subtopic,
+        mode
+      });
+      return apiFetch(`/api/v1/arena/leaderboard?${q.toString()}`, {
+        method: "GET"
+      });
+    }
+  };
+}
 
-`);
-      }
-      const apiKey = await readLine("Paste your API key (from portal Settings \u2192 API Keys): ");
-      if (!apiKey) throw new Error("empty api key");
-      const next = {
-        ...prev,
-        apiKey,
-        cloudUrl
-      };
-      writeFileConfig(next);
-      return { ok: true, path: configPath(), opened };
-    });
-  });
-  program2.command("whoami").description("Print current user info").option("--human", "Human-readable output").action(async (opts) => {
-    await runCommand(async () => {
-      const { consumer } = buildContext();
-      return consumer.getMe();
-    }, { human: opts.human });
+// src/arena/hash.ts
+import { createHash } from "crypto";
+import { readFileSync as readFileSync2 } from "fs";
+function sha256Hex(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+function sha256Digest(bytes) {
+  return `sha256:${sha256Hex(bytes)}`;
+}
+function hashFile(path2) {
+  const bytes = readFileSync2(path2);
+  return { bytes, digest: sha256Digest(bytes) };
+}
+
+// src/commands/arena.ts
+var FIRST_PARTY_ARENA_HANDLE = "gig-pa-operator";
+var FIRST_PARTY_ARENA_SLUG = "arena-v1";
+var ARENA_CAPABILITY = "arena.v1";
+function servicesHostBaseUrl(ctx) {
+  return ctx.cfg.servicesHostUrl ?? process.env.LINKEDCLAW_SERVICES_HOST_URL ?? ctx.cfg.cloudUrl;
+}
+function endpointForListing(listing, ctx) {
+  const endpoint = listing.external_endpoint;
+  return typeof endpoint === "string" && endpoint.length > 0 ? endpoint : servicesHostBaseUrl(ctx);
+}
+function assertArenaPa(listing, source) {
+  const caps = Array.isArray(listing.capabilities) ? listing.capabilities : [];
+  if (!caps.includes(ARENA_CAPABILITY)) {
+    throw new LinkedClawError(
+      "arena_target_not_arena_pa",
+      `${source} does not advertise ${ARENA_CAPABILITY}.`
+    );
+  }
+}
+async function resolveArenaTarget(ctx, opts) {
+  if (opts.target && /^https?:\/\//i.test(opts.target)) {
+    throw new LinkedClawError(
+      "arena_target_must_be_agent_id",
+      "--target now expects an arena.v1 agent id, not a URL."
+    );
+  }
+  const listing = opts.target ? await ctx.consumer.getAgent(opts.target) : await ctx.consumer.resolveAgentHandle(FIRST_PARTY_ARENA_HANDLE, FIRST_PARTY_ARENA_SLUG);
+  assertArenaPa(listing, opts.target ?? `${FIRST_PARTY_ARENA_HANDLE}/${FIRST_PARTY_ARENA_SLUG}`);
+  return { agentId: listing.agent_id, baseUrl: endpointForListing(listing, ctx) };
+}
+async function buildArenaApi(opts) {
+  const ctx = buildContext();
+  if (!ctx.cfg.apiKey) throw new LinkedClawError("missing_api_key", "Run `linkedclaw login` first.");
+  const target = await resolveArenaTarget(ctx, opts);
+  return makeArenaApi(target.baseUrl, ctx.cfg.apiKey);
+}
+function parseCategory(opts) {
+  if (!opts.categoryTopic) {
+    throw new LinkedClawError("missing_category_topic", "--category-topic is required.");
+  }
+  if (!opts.categorySubtopic) {
+    throw new LinkedClawError("missing_category_subtopic", "--category-subtopic is required.");
+  }
+  return { topic: opts.categoryTopic, subtopic: opts.categorySubtopic };
+}
+function parseSeq(value) {
+  const seq = Number(value);
+  if (!Number.isInteger(seq) || seq < 1) {
+    throw new LinkedClawError("invalid_seq", "--seq must be a positive integer.");
+  }
+  return seq;
+}
+function parseScore(value) {
+  const score = Number(value);
+  if (!Number.isFinite(score) || score < 0 || score > 1) {
+    throw new LinkedClawError("invalid_juror_score", "score must be a number between 0 and 1.");
+  }
+  return score;
+}
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readTournamentManifest(path2) {
+  if (path2 === "-" && process.stdin.isTTY) {
+    throw new LinkedClawError(
+      "arena_tournament_manifest_stdin_tty",
+      "stdin is a TTY; pass a file path or pipe JSON via stdin (e.g. cat tournament.json | linkedclaw arena tournament create -)."
+    );
+  }
+  let raw;
+  try {
+    raw = readFileSync3(path2 === "-" ? 0 : path2, "utf8");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new LinkedClawError(
+      "arena_tournament_manifest_read_failed",
+      path2 === "-" ? `could not read from stdin (use "-" to pipe JSON): ${message}` : message
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new LinkedClawError(
+      "arena_tournament_manifest_json_invalid",
+      err instanceof Error ? err.message : String(err)
+    );
+  }
+  if (!isPlainObject(parsed)) {
+    throw new LinkedClawError(
+      "arena_tournament_manifest_shape_invalid",
+      "manifest must be a JSON object."
+    );
+  }
+  if (parsed.mode !== "tournament") {
+    throw new LinkedClawError(
+      "arena_tournament_manifest_mode_invalid",
+      'manifest mode must be exactly "tournament".'
+    );
+  }
+  if (!isPlainObject(parsed.category) || !isPlainObject(parsed.config)) {
+    throw new LinkedClawError(
+      "arena_tournament_manifest_shape_invalid",
+      "manifest must include category and config object fields."
+    );
+  }
+  return {
+    mode: "tournament",
+    category: parsed.category,
+    config: parsed.config
+  };
+}
+function parseIdempotencyKey(value) {
+  const idempotencyKey = value?.trim();
+  if (!idempotencyKey) {
+    throw new LinkedClawError(
+      "arena_idempotency_key_required",
+      "--idempotency-key must be a non-empty string."
+    );
+  }
+  if (/[\r\n]/.test(idempotencyKey)) {
+    throw new LinkedClawError(
+      "arena_idempotency_key_invalid",
+      "--idempotency-key must not contain newlines."
+    );
+  }
+  return idempotencyKey;
+}
+function mergeSubmissionHash(response, submissionHash) {
+  if (response && typeof response === "object" && "submission" in response && response.submission && typeof response.submission === "object") {
+    const submission = response.submission;
+    if (typeof submission.submission_hash === "string") return response;
+    return { ...response, submission: { ...submission, submission_hash: submissionHash } };
+  }
+  if (response && typeof response === "object" && "submission_hash" in response) return response;
+  return { response, submission_hash: submissionHash };
+}
+function registerArenaCommands(program2) {
+  const arena = program2.command("arena").description("Arena PA commands");
+  const tournament = arena.command("tournament").description("Arena tournament commands");
+  tournament.command("create <manifest.json>").description("Create a tournament Arena from an exact JSON manifest").option("--idempotency-key <key>", "Required replay key for tournament creation").option("--target <agent_id>", "Arena PA agent id override").option("--human", "Human-readable output").action(async (manifestPath, opts) => {
+    await runCommand(async () => {
+      const idempotencyKey = parseIdempotencyKey(opts.idempotencyKey);
+      return (await buildArenaApi(opts)).createTournamentArena(readTournamentManifest(manifestPath), {
+        idempotencyKey
+      });
+    }, { human: opts.human });
+  });
+  arena.command("register").description("Register a contestant agent for Arena offers").requiredOption("--agent-id <agt_id>").requiredOption("--mandate-id <mandate_id>").requiredOption("--category-topic <topic>").requiredOption("--category-subtopic <subtopic>").option("--target <agent_id>", "Arena PA agent id override").option("--human", "Human-readable output").action(
+    async (opts) => {
+      await runCommand(async () => {
+        const api = await buildArenaApi(opts);
+        return api.register({
+          contestant_agent_id: opts.agentId,
+          mandate_id: opts.mandateId,
+          category: parseCategory(opts)
+        });
+      }, { human: opts.human });
+    }
+  );
+  arena.command("offers").description("List durable Arena offers for this owner").option("--target <agent_id>", "Arena PA agent id override").option("--human", "Human-readable output").action(async (opts) => {
+    await runCommand(async () => (await buildArenaApi(opts)).listOffers(), { human: opts.human });
+  });
+  arena.command("accept <offer_id>").description("Accept an Arena offer").option("--target <agent_id>", "Arena PA agent id override").option("--human", "Human-readable output").action(async (offerId, opts) => {
+    await runCommand(async () => (await buildArenaApi(opts)).acceptOffer(offerId), { human: opts.human });
+  });
+  arena.command("submit <arena_id>").description("Submit a text or file answer to an Arena").requiredOption("--offer-id <offer_id>").option("--match-id <match_id>", "Pending match id for match-mode submissions").option("--file <path>").option("--body <text>").option("--content-ref <ref>").option("--seq <n>", "Submission sequence number", parseSeq, 1).option("--target <agent_id>", "Arena PA agent id override").option("--human", "Human-readable output").action(
+    async (arenaId, opts) => {
+      await runCommand(async () => {
+        if (opts.file && opts.body !== void 0) {
+          throw new LinkedClawError("submission_source_conflict", "Use exactly one of --file or --body.");
+        }
+        if (!opts.file && opts.body === void 0) {
+          throw new LinkedClawError("submission_source_required", "Use exactly one of --file or --body.");
+        }
+        let request;
+        if (opts.file) {
+          const { bytes, digest } = hashFile(opts.file);
+          request = {
+            offer_id: opts.offerId,
+            raw_content: bytes.toString("utf8"),
+            content_ref: opts.contentRef ?? opts.file,
+            ...opts.matchId ? { match_id: opts.matchId } : {},
+            seq: opts.seq,
+            submission_hash: digest
+          };
+        } else {
+          const body = opts.body ?? "";
+          request = {
+            offer_id: opts.offerId,
+            raw_content: body,
+            ...opts.contentRef ? { content_ref: opts.contentRef } : {},
+            ...opts.matchId ? { match_id: opts.matchId } : {},
+            seq: opts.seq,
+            submission_hash: sha256Digest(Buffer.from(body, "utf8"))
+          };
+        }
+        const response = await (await buildArenaApi(opts)).submit(arenaId, request);
+        return mergeSubmissionHash(response, request.submission_hash);
+      }, { human: opts.human });
+    }
+  );
+  const vote = arena.command("vote").description("Arena juror voting commands");
+  vote.command("task <arena_id> <submission_id> <score>").description("Submit a task-submission juror score").option("--rationale-ref <ref>").option("--target <agent_id>", "Arena PA agent id override").option("--human", "Human-readable output").action(async (arenaId, submissionId, scoreValue, opts) => {
+    await runCommand(async () => {
+      const score = parseScore(scoreValue);
+      return (await buildArenaApi(opts)).voteTask(arenaId, {
+        submission_id: submissionId,
+        score,
+        ...opts.rationaleRef ? { rationale_ref: opts.rationaleRef } : {}
+      });
+    }, { human: opts.human });
+  });
+  vote.command("match <arena_id> <match_id> <outcome>").description("Submit a match-mode juror outcome").option("--rationale-ref <ref>").option("--target <agent_id>", "Arena PA agent id override").option("--human", "Human-readable output").action(async (arenaId, matchId, outcome, opts) => {
+    await runCommand(async () => {
+      if (!["a", "b", "tie", "both_bad"].includes(outcome)) {
+        throw new LinkedClawError(
+          "invalid_juror_outcome",
+          "outcome must be one of: a, b, tie, both_bad."
+        );
+      }
+      return (await buildArenaApi(opts)).voteMatch(arenaId, matchId, {
+        outcome,
+        ...opts.rationaleRef ? { rationale_ref: opts.rationaleRef } : {}
+      });
+    }, { human: opts.human });
+  });
+  arena.command("list").description("List visible Arenas").option("--registered", "Only arenas where this owner is registered or submitted").option("--target <agent_id>", "Arena PA agent id override").option("--human", "Human-readable output").action(async (opts) => {
+    await runCommand(async () => (await buildArenaApi(opts)).listArenas({ registered: opts.registered }), {
+      human: opts.human
+    });
+  });
+  arena.command("leaderboard [arena_id]").description("Read an Arena leaderboard").option("--category-topic <topic>").option("--category-subtopic <subtopic>").option("--mode <mode>", "Leaderboard mode", "match").option("--target <agent_id>", "Arena PA agent id override").option("--human", "Human-readable output").action(async (arenaId, opts) => {
+    await runCommand(async () => {
+      const api = await buildArenaApi(opts);
+      if (arenaId) {
+        return api.getLeaderboard(arenaId);
+      }
+      if (opts.mode !== "match") {
+        throw new LinkedClawError(
+          "unsupported_arena_leaderboard_mode",
+          "--mode must be match when no arena_id is provided."
+        );
+      }
+      return api.getCategoryLeaderboard(parseCategory(opts), opts.mode);
+    }, { human: opts.human });
+  });
+}
+
+// src/commands/auth.ts
+function registerAuthCommands(program2) {
+  program2.command("login").description("Store API key in ~/.linkedclaw/config.yaml").option("--api-key <key>", "API key (otherwise read from stdin)").option("--cloud-url <url>", "Override cloud URL").action(async (opts) => {
+    await runCommand(async () => {
+      let apiKey = opts.apiKey;
+      if (!apiKey) {
+        apiKey = await readLine("Paste API key: ");
+      }
+      if (!apiKey) throw new Error("empty api key");
+      const prev = readFileConfig();
+      const next = { ...prev, apiKey, ...opts.cloudUrl ? { cloudUrl: opts.cloudUrl } : {} };
+      writeFileConfig(next);
+      return { ok: true, path: configPath() };
+    });
+  });
+  program2.command("register").description("Open browser to create a LinkedClaw account, then paste your API key").option("--no-browser", "Print URL instead of attempting to open the browser").option("--cloud-url <url>", "Override cloud URL").action(async (opts) => {
+    await runCommand(async () => {
+      const prev = readFileConfig();
+      const cloudUrl = opts.cloudUrl ?? prev.cloudUrl ?? process.env.LINKEDCLAW_CLOUD_URL ?? DEFAULT_CLOUD_URL;
+      const portalUrl = cloudUrl.replace(/\/$/, "") + "/register";
+      let opened = false;
+      if (opts.browser !== false) {
+        try {
+          const open = (await import("open")).default;
+          await open(portalUrl);
+          opened = true;
+        } catch {
+        }
+      }
+      if (!opened) {
+        process.stderr.write(`Open this URL in a browser to register:
+  ${portalUrl}
+
+`);
+      }
+      const apiKey = await readLine("Paste your API key (from portal Settings \u2192 API Keys): ");
+      if (!apiKey) throw new Error("empty api key");
+      const next = {
+        ...prev,
+        apiKey,
+        cloudUrl
+      };
+      writeFileConfig(next);
+      return { ok: true, path: configPath(), opened };
+    });
+  });
+  program2.command("whoami").description("Print current user info").option("--human", "Human-readable output").action(async (opts) => {
+    await runCommand(async () => {
+      const { consumer } = buildContext();
+      return consumer.getMe();
+    }, { human: opts.human });
   });
   const config = program2.command("config").description("Inspect or edit local config file");
   config.command("show").description("Print the config file contents (api key redacted)").action(async () => {
@@ -5661,9 +6334,1060 @@ function tryParseJson(v) {
   }
 }
 
+// src/commands/converge.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, unlinkSync as unlinkSync2 } from "fs";
+import { isAbsolute as isAbsolute2, join as join5, relative, resolve as resolve2 } from "path";
+
+// src/converge/api.ts
+function makeFetchError(code, body) {
+  const err = new LinkedClawError(`api_${code}`, `HTTP ${code}`);
+  err.code = code;
+  err.body = body;
+  return err;
+}
+function makeConvergeApi(cloudUrl, apiKey) {
+  async function apiFetch(path2, opts = {}) {
+    const url = cloudUrl.replace(/\/$/, "") + path2;
+    const res = await fetch(url, {
+      ...opts,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+        ...opts.headers ?? {}
+      }
+    });
+    let body;
+    try {
+      body = await res.json();
+    } catch {
+      body = null;
+    }
+    if (!res.ok) throw makeFetchError(res.status, body);
+    return body;
+  }
+  return {
+    async getDebate(debateId) {
+      return apiFetch(`/api/v1/debates/${debateId}`);
+    },
+    async getCommonsLogEvents(cid, opts = {}) {
+      const requested = opts.limit ?? 1e3;
+      const PAGE = 1e3;
+      const offsetStart = opts.offset ?? 0;
+      let collected = [];
+      let cursor = offsetStart;
+      while (collected.length < requested) {
+        const params = new URLSearchParams();
+        params.set("offset", String(cursor));
+        params.set("limit", String(Math.min(PAGE, requested - collected.length)));
+        const page = await apiFetch(
+          `/api/v1/commons-logs/${cid}/events?${params}`
+        );
+        const hoisted = page.events.map((e) => ({
+          ...e,
+          event_type: e.event_type ?? e.payload?.event_type ?? ""
+        }));
+        collected = collected.concat(hoisted);
+        if (page.events.length === 0 || page.next_offset === cursor) break;
+        cursor = page.next_offset;
+      }
+      return { events: collected, next_offset: cursor };
+    },
+    async discoverPaAgentId() {
+      const result = await apiFetch(
+        "/api/v1/agents?capability=convergence_synthesizer.v1"
+      );
+      const listings = Array.isArray(result) ? result : result.agents ?? [];
+      if (listings.length === 0) {
+        throw new LinkedClawError("pa_not_found", "No agent found with capability convergence_synthesizer.v1");
+      }
+      return listings[0].agent_id;
+    },
+    async findExistingMandate(principalAgentId, delegateAgentId, requiredScopes) {
+      const result = await apiFetch(`/api/v1/mandates?kind=generalized`);
+      const list = Array.isArray(result) ? result : result.mandates ?? [];
+      const required = new Set(requiredScopes);
+      const now = Date.now();
+      for (const m of list) {
+        if (m.principal_agent_id !== principalAgentId) continue;
+        if (m.delegate_agent_id !== delegateAgentId) continue;
+        if (m.revoked_at) continue;
+        if (m.expires_at && new Date(m.expires_at).getTime() <= now) continue;
+        if (![...required].every((s) => m.scope.includes(s))) continue;
+        return m;
+      }
+      return null;
+    },
+    async issueMandate(principalAgentId, delegateAgentId, scopes, expiresAt) {
+      return apiFetch("/api/v1/mandates", {
+        method: "POST",
+        body: JSON.stringify({
+          principal_agent_id: principalAgentId,
+          delegate_agent_id: delegateAgentId,
+          scope: scopes,
+          ...expiresAt ? { expires_at: expiresAt } : {}
+        })
+      });
+    },
+    async startRun(sourceDebateId) {
+      return apiFetch("/api/v1/convergence/runs", {
+        method: "POST",
+        body: JSON.stringify({ source_debate_id: sourceDebateId })
+      });
+    },
+    async getRun(runId) {
+      return apiFetch(`/api/v1/convergence/runs/${runId}`);
+    },
+    async acceptOwnerB(runId) {
+      return apiFetch(`/api/v1/convergence/runs/${runId}/owner_b_accept`, {
+        method: "POST"
+      });
+    },
+    async appendCommonsLog(cid, eventType, payload) {
+      return apiFetch(`/api/v1/commons-logs/${cid}/append`, {
+        method: "POST",
+        body: JSON.stringify({ event_type: eventType, payload })
+      });
+    },
+    async acceptCruxDecision(runId, cruxId, body) {
+      return apiFetch(`/api/v1/convergence/runs/${runId}/cruxes/${cruxId}/accept`, {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+    },
+    async rejectCruxDecision(runId, cruxId, body) {
+      return apiFetch(`/api/v1/convergence/runs/${runId}/cruxes/${cruxId}/reject`, {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+    },
+    async attestCruxDecision(runId, cruxId, body) {
+      return apiFetch(`/api/v1/convergence/runs/${runId}/cruxes/${cruxId}/attest`, {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+    }
+  };
+}
+
+// src/converge/hash.ts
+import { createHash as createHash2 } from "crypto";
+function encodeString(s) {
+  let out = '"';
+  for (let i = 0; i < s.length; i++) {
+    const cp = s.charCodeAt(i);
+    if (cp === 34) out += '\\"';
+    else if (cp === 92) out += "\\\\";
+    else if (cp === 8) out += "\\b";
+    else if (cp === 9) out += "\\t";
+    else if (cp === 10) out += "\\n";
+    else if (cp === 12) out += "\\f";
+    else if (cp === 13) out += "\\r";
+    else if (cp < 32 || cp > 126) out += `\\u${cp.toString(16).padStart(4, "0")}`;
+    else out += s[i];
+  }
+  return out + '"';
+}
+function canonicalize(value) {
+  if (value === null) return "null";
+  if (typeof value === "string") return encodeString(value);
+  if (typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return "[" + value.map(canonicalize).join(",") + "]";
+  const keys = Object.keys(value).sort();
+  return "{" + keys.map((k) => encodeString(k) + ":" + canonicalize(value[k])).join(",") + "}";
+}
+function sha256OfCanonicalJson(value) {
+  const h = createHash2("sha256");
+  h.update(canonicalize(value));
+  return "sha256:" + h.digest("hex");
+}
+
+// src/converge/lock.ts
+import { closeSync, openSync, unlinkSync, writeSync } from "fs";
+import { join as join2 } from "path";
+var LOCK_FILENAME = ".lock";
+function acquireLock(stagingDir) {
+  const path2 = join2(stagingDir, LOCK_FILENAME);
+  let fd;
+  try {
+    fd = openSync(path2, "wx");
+  } catch (e) {
+    if (e.code === "EEXIST") {
+      throw new LinkedClawError(
+        "lock_held",
+        `Lock held at ${path2}. If no other run/accept is in progress, delete ${path2} to recover.`
+      );
+    }
+    throw e;
+  }
+  writeSync(fd, JSON.stringify({ pid: process.pid }));
+  closeSync(fd);
+  return () => {
+    try {
+      unlinkSync(path2);
+    } catch {
+    }
+  };
+}
+
+// src/converge/staging.ts
+import { createHash as createHash3 } from "crypto";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync4, readdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, join as join3 } from "path";
+import { load as yamlLoad2, dump as yamlDump2 } from "js-yaml";
+function stagingPathFor(stagingDir, cruxId) {
+  return join3(stagingDir, `${cruxId}.md`);
+}
+function listCruxFiles(stagingDir) {
+  if (!existsSync2(stagingDir)) return [];
+  return readdirSync(stagingDir).filter(
+    (f) => f.endsWith(".md") && !f.startsWith(".")
+  );
+}
+function parseStaging(text) {
+  if (!text.startsWith("---\n")) {
+    throw new Error("Missing YAML frontmatter: document must start with ---\\n");
+  }
+  const endIdx = text.indexOf("\n---\n", 4);
+  if (endIdx === -1) {
+    throw new Error("Malformed frontmatter: no closing ---");
+  }
+  const yamlText = text.slice(4, endIdx);
+  const body = text.slice(endIdx + 5);
+  const raw = yamlLoad2(yamlText);
+  if (!raw || typeof raw !== "object") {
+    throw new Error("Frontmatter parsed to non-object");
+  }
+  const userResponse = typeof raw._user_response === "string" ? raw._user_response : "";
+  delete raw._user_response;
+  return {
+    frontmatter: raw,
+    userResponse,
+    body
+  };
+}
+function dumpStaging(doc) {
+  const fmRaw = { ...doc.frontmatter };
+  fmRaw._user_response = doc.userResponse ?? "";
+  const yamlText = yamlDump2(fmRaw, { lineWidth: -1, sortKeys: false });
+  return `---
+${yamlText}---
+${doc.body}`;
+}
+function readStaging(path2) {
+  return parseStaging(readFileSync4(path2, "utf8"));
+}
+function writeStaging(path2, doc) {
+  mkdirSync2(dirname2(path2), { recursive: true });
+  writeFileSync2(path2, dumpStaging(doc), "utf8");
+}
+function computePaBodyHash(body) {
+  return "sha256:" + createHash3("sha256").update(Buffer.from(body, "utf8")).digest("hex");
+}
+
+// src/converge/workspace.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3, isAbsolute, join as join4, resolve } from "path";
+import { load as yamlLoad3, dump as yamlDump3 } from "js-yaml";
+var META_FILENAME = ".run-meta.yaml";
+function readRunMeta(stagingDir) {
+  const metaPath = join4(stagingDir, META_FILENAME);
+  if (!existsSync3(metaPath)) return null;
+  return yamlLoad3(readFileSync5(metaPath, "utf8"));
+}
+function writeRunMeta(stagingDir, meta) {
+  mkdirSync3(stagingDir, { recursive: true });
+  writeFileSync3(join4(stagingDir, META_FILENAME), yamlDump3(meta), "utf8");
+}
+function searchUpward(startDir, maxLevels = 5) {
+  let dir = startDir;
+  for (let i = 0; i < maxLevels; i++) {
+    if (existsSync3(join4(dir, META_FILENAME))) return dir;
+    const parent = dirname3(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+async function resolveWorkspace(opts) {
+  const cwd = opts.cwd ? resolve(opts.cwd) : process.cwd();
+  let stagingDir;
+  let meta = null;
+  if (opts.stagingDir) {
+    stagingDir = isAbsolute(opts.stagingDir) ? opts.stagingDir : resolve(cwd, opts.stagingDir);
+    meta = readRunMeta(stagingDir);
+    if (!meta) {
+      throw new LinkedClawError(
+        "meta_not_found",
+        `No ${META_FILENAME} found in --staging-dir: ${stagingDir}`
+      );
+    }
+  } else {
+    const found = searchUpward(cwd);
+    if (found) {
+      stagingDir = found;
+      meta = readRunMeta(found);
+    }
+  }
+  if (!meta) {
+    if (opts.runId) {
+      throw new LinkedClawError(
+        "meta_not_found",
+        `--run-id given but no ${META_FILENAME} found (searched upward from ${cwd}). Provide --staging-dir to locate the run workspace.`
+      );
+    }
+    throw new LinkedClawError(
+      "meta_not_found",
+      `No ${META_FILENAME} found (searched upward from ${cwd}). Run 'lc converge run <debate_id>' first.`
+    );
+  }
+  if (opts.runId && opts.runId !== meta.run_id) {
+    throw new LinkedClawError(
+      "run_id_mismatch",
+      `--run-id ${opts.runId} does not match run_id ${meta.run_id} in ${META_FILENAME}`
+    );
+  }
+  const targetCorpus = isAbsolute(meta.target_corpus) ? meta.target_corpus : resolve(stagingDir, meta.target_corpus);
+  return {
+    runId: meta.run_id,
+    sourceDebateId: meta.source_debate_id,
+    paAgentId: meta.pa_agent_id,
+    targetCorpus,
+    stagingDir
+  };
+}
+
+// src/commands/converge.ts
+function resolveAbs(p) {
+  return isAbsolute2(p) ? p : resolve2(process.cwd(), p);
+}
+async function getMyUserId(ctx) {
+  const me = await ctx.consumer.getMe();
+  if (!me.user_id) throw new LinkedClawError("no_user_id", "Could not determine user_id from /api/v1/me");
+  return me.user_id;
+}
+function recomputeSourceCruxMapHash(events) {
+  const ev = [...events].reverse().find((e) => e.event_type === "crux_map");
+  if (!ev) return null;
+  return sha256OfCanonicalJson(ev.payload.crux_map_data);
+}
+function recordedSourceHash(events) {
+  const ev = events.find((e) => e.event_type === "run_started");
+  if (!ev) return null;
+  return typeof ev.payload.source_crux_map_hash === "string" ? ev.payload.source_crux_map_hash : null;
+}
+function buildPaBody(op) {
+  const synthesis = typeof op.synthesis_text === "string" ? op.synthesis_text : "";
+  const questions = Array.isArray(op.open_questions) ? op.open_questions : [];
+  const qText = questions.map((q) => `- ${String(q)}`).join("\n");
+  return `# Synthesis
+
+${synthesis}
+
+# Open questions
+
+${qText || "(none)"}
+`;
+}
+function countPreviouslyClarifiedSections(body) {
+  const m = body.match(/^# Previously clarified \(round \d+\)/gm);
+  return m ? m.length : 0;
+}
+function slugify(s, maxLen = 64) {
+  const base = s.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, maxLen).replace(/-+$/g, "");
+  return base || "untitled";
+}
+function extractSynthesisSlug(body, maxLen = 32) {
+  const synthIdx = body.indexOf("# Synthesis");
+  const search = synthIdx >= 0 ? body.slice(synthIdx) : body;
+  const lines = search.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+  const first = lines[0] ?? "";
+  return slugify(first, maxLen);
+}
+function tryGitAdd(absPath) {
+  try {
+    const r = spawnSync("git", ["add", absPath], { encoding: "utf8" });
+    if (r.error) return `git_add_failed: ${r.error.message}`;
+    if (r.status !== 0) return `git_add_failed: ${(r.stderr || "").trim() || `exit ${r.status}`}`;
+    return null;
+  } catch (e) {
+    return `git_add_failed: ${e.message}`;
+  }
+}
+function assertSafeCruxId(cruxId) {
+  if (!cruxId || cruxId.includes("/") || cruxId.includes("\\") || cruxId.includes("..") || cruxId.includes("\0")) {
+    throw new LinkedClawError("invalid_crux_id", `Invalid crux_id for local file operation: ${cruxId}`);
+  }
+}
+function assertInside(parentDir, childPath) {
+  const parent = resolve2(parentDir);
+  const child = resolve2(childPath);
+  const rel = relative(parent, child);
+  if (rel === "" || !rel.startsWith("..") && !isAbsolute2(rel)) return;
+  throw new LinkedClawError("path_escape", `Refusing local path outside ${parentDir}: ${childPath}`);
+}
+function safeStagingPathFor(stagingDir, cruxId) {
+  assertSafeCruxId(cruxId);
+  const path2 = stagingPathFor(stagingDir, cruxId);
+  assertInside(stagingDir, path2);
+  return path2;
+}
+function safeAcceptedPath(finalDir, cruxId, synthSlug) {
+  assertSafeCruxId(cruxId);
+  const path2 = join5(finalDir, `${cruxId}__${synthSlug}.md`);
+  assertInside(finalDir, path2);
+  return path2;
+}
+function computeDecisionBodyHash(synthesisText, citationsA, citationsB) {
+  return sha256OfCanonicalJson({
+    citations_a: citationsA,
+    citations_b: citationsB,
+    synthesis_text: synthesisText
+  });
+}
+function eventKind(ev) {
+  return typeof ev.payload.event_type === "string" ? ev.payload.event_type : ev.event_type;
+}
+function decisionEventTypeForAction(action) {
+  if (action === "accept") return "accept_attestation";
+  if (action === "reject") return "reject_attestation";
+  return "attest_only";
+}
+function latestConvergenceMapEvent(events) {
+  const operatorUserId = process.env.LINKEDCLAW_OPERATOR_USER_ID ?? "usr_operator";
+  const reversed = [...events].reverse();
+  const ev = reversed.find((e) => eventKind(e) === "convergence_map" && e.signed_by === operatorUserId);
+  if (!ev) {
+    throw new LinkedClawError(
+      "convergence_map_not_found",
+      `No PA-signed convergence_map event found for this run (expected signed_by=${operatorUserId}).`
+    );
+  }
+  return ev;
+}
+function latestConvergenceMap(events) {
+  return latestConvergenceMapEvent(events).payload;
+}
+function getCruxFromMap(map, cruxId) {
+  const cruxes = Array.isArray(map.cruxes) ? map.cruxes : [];
+  const crux = cruxes.find(
+    (c) => c && typeof c === "object" && c.crux_id === cruxId
+  );
+  if (!crux || typeof crux !== "object") {
+    throw new LinkedClawError("crux_not_found", `crux ${cruxId} not found in latest convergence_map.`);
+  }
+  return crux;
+}
+function citationsFromCrux(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((v) => v != null && typeof v === "object" && !Array.isArray(v));
+}
+function classifyDecisionAttestation(action, outcome, bilateralMandateIntact, synthesisEdited = false) {
+  if (action === "attest") return "user_attested_no_dialog";
+  if (action === "reject") return "user_attested_with_network_context";
+  if (outcome === "already_aligned") {
+    throw new LinkedClawError(
+      "attest_required",
+      "outcome=already_aligned must be decided with `lc converge attest`."
+    );
+  }
+  if ((outcome === "converged" || outcome === "partial_overlap") && bilateralMandateIntact && !synthesisEdited) {
+    return "bilateral_convergence";
+  }
+  return "user_attested_with_network_context";
+}
+function decisionPayloadCitations(value) {
+  return citationsFromCrux(value);
+}
+function stringFromPayload(payload, key) {
+  const value = payload[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new LinkedClawError("decision_payload_invalid", `terminal decision missing ${key}.`);
+  }
+  return value;
+}
+function booleanFromPayload(payload, key) {
+  const value = payload[key];
+  if (typeof value !== "boolean") {
+    throw new LinkedClawError("decision_payload_invalid", `terminal decision missing ${key}.`);
+  }
+  return value;
+}
+function attestationFromPayload(payload) {
+  const value = stringFromPayload(payload, "attestation");
+  if (value !== "bilateral_convergence" && value !== "user_attested_with_network_context" && value !== "user_attested_no_dialog") {
+    throw new LinkedClawError("decision_payload_invalid", `terminal decision has invalid attestation: ${value}`);
+  }
+  return value;
+}
+function terminalOutcomeFromPayload(payload) {
+  const value = stringFromPayload(payload, "terminal_outcome");
+  if (value !== "converged" && value !== "partial_overlap" && value !== "needs_input" && value !== "irreconcilable" && value !== "already_aligned") {
+    throw new LinkedClawError("decision_payload_invalid", `terminal decision has invalid outcome: ${value}`);
+  }
+  return value;
+}
+async function buildCruxDecisionRequest(api, ws, cruxId, action, opts = {}) {
+  assertSafeCruxId(cruxId);
+  const { events } = await api.getCommonsLogEvents(ws.runId, { limit: 5e3 });
+  const map = latestConvergenceMap(events);
+  const crux = getCruxFromMap(map, cruxId);
+  const generationId = typeof crux.generation_id === "string" ? crux.generation_id : "";
+  const sourceHash = typeof map.source_crux_map_hash === "string" ? map.source_crux_map_hash : "";
+  const outcome = typeof crux.outcome === "string" ? crux.outcome : "";
+  const latestSubDebateId = typeof crux.latest_sub_debate_id === "string" ? crux.latest_sub_debate_id : null;
+  const bilateralMandateIntact = typeof crux.bilateral_mandate_intact_at_outcome === "boolean" ? crux.bilateral_mandate_intact_at_outcome : typeof crux.bilateral_mandate_intact === "boolean" ? crux.bilateral_mandate_intact : false;
+  const synthesisText = typeof crux.synthesis_text === "string" ? crux.synthesis_text : "";
+  const citationsA = citationsFromCrux(crux.citations_a);
+  const citationsB = citationsFromCrux(crux.citations_b);
+  if (!generationId) throw new LinkedClawError("missing_generation_id", `crux ${cruxId} has no generation_id.`);
+  if (!sourceHash) throw new LinkedClawError("missing_source_hash", "latest convergence_map has no source_crux_map_hash.");
+  if (!outcome) throw new LinkedClawError("missing_outcome", `crux ${cruxId} has no outcome.`);
+  if (action === "accept" && outcome === "already_aligned") {
+    throw new LinkedClawError(
+      "attest_required",
+      "outcome=already_aligned must be decided with `lc converge attest`."
+    );
+  }
+  if (!synthesisText) throw new LinkedClawError("missing_synthesis_text", `crux ${cruxId} has no synthesis_text.`);
+  const paBodyHash = computeDecisionBodyHash(synthesisText, citationsA, citationsB);
+  let acceptedSynthesisText = synthesisText;
+  let synthesisEdited = false;
+  if (action === "accept") {
+    const stagingPath = safeStagingPathFor(ws.stagingDir, cruxId);
+    if (existsSync4(stagingPath)) {
+      const doc = readStaging(stagingPath);
+      synthesisEdited = computePaBodyHash(doc.body) !== doc.frontmatter.pa_body_hash;
+      if (synthesisEdited) acceptedSynthesisText = doc.body;
+    }
+  }
+  const acceptedBodyHash = computeDecisionBodyHash(acceptedSynthesisText, citationsA, citationsB);
+  return {
+    convergence_map_generation_id: generationId,
+    source_crux_map_hash: sourceHash,
+    latest_sub_debate_id: latestSubDebateId,
+    terminal_outcome: outcome,
+    bilateral_mandate_intact: bilateralMandateIntact,
+    attestation: classifyDecisionAttestation(action, outcome, bilateralMandateIntact, synthesisEdited),
+    synthesis_edited: synthesisEdited,
+    pa_body_hash: paBodyHash,
+    accepted_body_hash: acceptedBodyHash,
+    synthesis_text: acceptedSynthesisText,
+    citations_a: citationsA,
+    citations_b: citationsB,
+    ...opts.message ? { user_message: opts.message } : {}
+  };
+}
+async function postCruxDecision(api, ws, cruxId, action, opts = {}) {
+  assertSafeCruxId(cruxId);
+  const body = await buildCruxDecisionRequest(api, ws, cruxId, action, opts);
+  const resp = action === "accept" ? await api.acceptCruxDecision(ws.runId, cruxId, body) : action === "reject" ? await api.rejectCruxDecision(ws.runId, cruxId, body) : await api.attestCruxDecision(ws.runId, cruxId, body);
+  return { event_id: resp.event_id, body };
+}
+async function materializeAcceptedCrux(ctx, api, ws, cruxId, payload, opts = {}) {
+  const stagingPath = safeStagingPathFor(ws.stagingDir, cruxId);
+  if (!existsSync4(stagingPath)) return { warning: `staging_not_found: ${stagingPath}` };
+  const doc = readStaging(stagingPath);
+  const fm = doc.frontmatter;
+  const sourceDebate = await api.getDebate(ws.sourceDebateId);
+  const body = stringFromPayload(payload, "synthesis_text");
+  const citationsA = decisionPayloadCitations(payload.citations_a);
+  const citationsB = decisionPayloadCitations(payload.citations_b);
+  const acceptedBodyHash = stringFromPayload(payload, "accepted_body_hash");
+  const computedAcceptedBodyHash = computeDecisionBodyHash(body, citationsA, citationsB);
+  if (acceptedBodyHash !== computedAcceptedBodyHash) {
+    return { warning: `decision_body_hash_mismatch: ${cruxId}` };
+  }
+  const paBodyHash = stringFromPayload(payload, "pa_body_hash");
+  const synthesisEdited = booleanFromPayload(payload, "synthesis_edited");
+  const attestation = attestationFromPayload(payload);
+  const terminalOutcome = terminalOutcomeFromPayload(payload);
+  const generationId = stringFromPayload(payload, "convergence_map_generation_id");
+  const me = await getMyUserId(ctx);
+  const acceptedDoc = {
+    frontmatter: {
+      ...fm,
+      generation_id: generationId,
+      pa_body_hash: paBodyHash,
+      outcome: terminalOutcome,
+      bilateral_mandate_intact: booleanFromPayload(payload, "bilateral_mandate_intact"),
+      citations_a: citationsA,
+      citations_b: citationsB,
+      provenance: {
+        signed_off_by: me,
+        signed_off_at: (/* @__PURE__ */ new Date()).toISOString(),
+        accepted_generation_id: generationId,
+        attestation,
+        synthesis_edited: synthesisEdited,
+        ...opts.message ? { user_message: opts.message } : {},
+        ...synthesisEdited ? { pa_body_hash: paBodyHash, accepted_body_hash: acceptedBodyHash } : {}
+      }
+    },
+    userResponse: "",
+    body
+  };
+  const topicSlug = slugify(sourceDebate.topic ?? ws.sourceDebateId);
+  const synthSlug = extractSynthesisSlug(body);
+  const finalDir = join5(ws.targetCorpus, "converged", topicSlug);
+  const finalPath = safeAcceptedPath(finalDir, cruxId, synthSlug);
+  if (existsSync4(finalPath) && readStaging(finalPath).body !== acceptedDoc.body) {
+    return { warning: `sync_conflict: ${finalPath}` };
+  }
+  mkdirSync4(finalDir, { recursive: true });
+  if (!existsSync4(finalPath) || dumpStaging(readStaging(finalPath)) !== dumpStaging(acceptedDoc)) {
+    writeStaging(finalPath, acceptedDoc);
+  }
+  unlinkSync2(stagingPath);
+  const gitWarning = tryGitAdd(finalPath);
+  return {
+    accepted_path: finalPath,
+    attestation,
+    synthesis_edited: synthesisEdited,
+    ...gitWarning ? { warning: gitWarning } : {}
+  };
+}
+async function syncTerminalDecisions(ctx, api, ws, opts = {}) {
+  if (opts.cruxId) assertSafeCruxId(opts.cruxId);
+  const { events } = await api.getCommonsLogEvents(ws.runId, { limit: 5e3 });
+  const warnings = [];
+  const mapEvent = latestConvergenceMapEvent(events);
+  const map = mapEvent.payload;
+  const cruxGeneration = /* @__PURE__ */ new Map();
+  for (const crux of Array.isArray(map.cruxes) ? map.cruxes : []) {
+    if (!crux || typeof crux !== "object" || Array.isArray(crux)) continue;
+    const c = crux;
+    if (typeof c.crux_id === "string" && typeof c.generation_id === "string") {
+      cruxGeneration.set(c.crux_id, c.generation_id);
+    }
+  }
+  const terminal = /* @__PURE__ */ new Map();
+  for (const ev of [...events].sort((a, b) => a.seq - b.seq)) {
+    if (ev.seq <= mapEvent.seq) continue;
+    if (ev.signed_by !== mapEvent.signed_by) continue;
+    const eventType = eventKind(ev);
+    if (!["accept_attestation", "reject_attestation", "attest_only"].includes(eventType)) continue;
+    const cid = typeof ev.payload.crux_id === "string" ? ev.payload.crux_id : "";
+    if (!cid || terminal.has(cid)) continue;
+    try {
+      assertSafeCruxId(cid);
+    } catch (err) {
+      warnings.push(`${cid}: ${err.message}`);
+      continue;
+    }
+    if (ev.payload.convergence_map_generation_id !== cruxGeneration.get(cid)) continue;
+    terminal.set(cid, { eventType, payload: ev.payload });
+  }
+  if (opts.injectedTerminal) {
+    assertSafeCruxId(opts.injectedTerminal.cruxId);
+    terminal.set(opts.injectedTerminal.cruxId, {
+      eventType: opts.injectedTerminal.eventType,
+      payload: opts.injectedTerminal.payload
+    });
+  }
+  const materialized = [];
+  const cleaned = [];
+  const release = acquireLock(ws.stagingDir);
+  try {
+    for (const [cid, terminalEvent] of terminal.entries()) {
+      if (opts.cruxId && cid !== opts.cruxId) continue;
+      const stagingPath = safeStagingPathFor(ws.stagingDir, cid);
+      const eventType = terminalEvent.eventType;
+      if (eventType === "accept_attestation") {
+        const result = await materializeAcceptedCrux(ctx, api, ws, cid, terminalEvent.payload, opts);
+        if (result.accepted_path) materialized.push(result.accepted_path);
+        if (result.warning) warnings.push(`${cid}: ${result.warning}`);
+        continue;
+      }
+      if (existsSync4(stagingPath)) {
+        unlinkSync2(stagingPath);
+        cleaned.push(cid);
+      }
+    }
+  } finally {
+    release();
+  }
+  return { materialized, cleaned, warnings };
+}
+function registerConvergeCommands(program2) {
+  const converge = program2.command("converge").description("Convergence: bilateral merger of two crux maps into shared corpus");
+  converge.command("run [ref]").description("Start a convergence run (Owner A) or accept (Owner B with --accept), then sync staging").option("--target-corpus <path>", "Absolute path to the target corpus directory").option("--staging-dir <path>", "Override staging directory").option("--accept", "Owner B: accept an existing run by run_id").option("--source-debate-id <id>", "Owner B fallback when /convergence/runs/{run_id} is unavailable").option("--force-regenerate", "Bypass source-hash drift check and regenerate staging files").option("--wait <secs>", "Poll until terminal_emitted or timeout", parseInt).action(
+    async (ref, opts) => {
+      await runCommand(async () => {
+        const ctx = buildContext();
+        if (!ctx.cfg.apiKey) throw new LinkedClawError("missing_api_key", "Run `linkedclaw login` first.");
+        const api = makeConvergeApi(ctx.cfg.cloudUrl, ctx.cfg.apiKey);
+        let ws;
+        const resolvedStagingDir = opts.stagingDir ? resolveAbs(opts.stagingDir) : null;
+        const metaExisting = resolvedStagingDir ? readRunMeta(resolvedStagingDir) : null;
+        if (opts.accept) {
+          if (!ref) {
+            throw new LinkedClawError("missing_run_id", "--accept requires the run_id as a positional argument.");
+          }
+          const runId = ref;
+          if (metaExisting && resolvedStagingDir) {
+            const meta = metaExisting;
+            ws = {
+              runId: meta.run_id,
+              sourceDebateId: meta.source_debate_id,
+              paAgentId: meta.pa_agent_id,
+              targetCorpus: meta.target_corpus,
+              stagingDir: resolvedStagingDir
+            };
+          } else {
+            if (!opts.targetCorpus) {
+              throw new LinkedClawError(
+                "missing_target_corpus",
+                "Owner B --accept requires --target-corpus on first call."
+              );
+            }
+            const targetCorpus = resolveAbs(opts.targetCorpus);
+            let sourceDebateId;
+            let paAgentId;
+            let principalAgentId;
+            if (opts.sourceDebateId) {
+              sourceDebateId = opts.sourceDebateId;
+              paAgentId = await api.discoverPaAgentId();
+              const sourceDebate = await api.getDebate(sourceDebateId);
+              principalAgentId = sourceDebate.agent_b_id;
+            } else {
+              const runMeta = await api.getRun(runId);
+              sourceDebateId = runMeta.source_debate_id;
+              paAgentId = runMeta.pa_agent_id;
+              principalAgentId = runMeta.agent_b_id;
+            }
+            const existing = await api.findExistingMandate(principalAgentId, paAgentId, ["debate.create", "debate.accept"]);
+            if (!existing) await api.issueMandate(principalAgentId, paAgentId, ["debate.create", "debate.accept"]);
+            await api.acceptOwnerB(runId);
+            const stagingDir = join5(targetCorpus, "converged", "staging", runId);
+            mkdirSync4(stagingDir, { recursive: true });
+            const meta = {
+              run_id: runId,
+              source_debate_id: sourceDebateId,
+              pa_agent_id: paAgentId,
+              target_corpus: targetCorpus,
+              owner_role: "b"
+            };
+            writeRunMeta(stagingDir, meta);
+            ws = { runId, sourceDebateId, paAgentId, targetCorpus, stagingDir };
+          }
+        } else if (!metaExisting) {
+          if (!ref) {
+            throw new LinkedClawError(
+              "missing_source_debate_id",
+              "First run requires a source_debate_id argument. Use --staging-dir to resume an existing run."
+            );
+          }
+          if (!opts.targetCorpus) {
+            throw new LinkedClawError("missing_target_corpus", "First call requires --target-corpus.");
+          }
+          const targetCorpus = resolveAbs(opts.targetCorpus);
+          const paAgentId = await api.discoverPaAgentId();
+          const sourceDebate = await api.getDebate(ref);
+          const principalAgentId = sourceDebate.agent_a_id;
+          const existing = await api.findExistingMandate(principalAgentId, paAgentId, ["debate.create", "debate.accept"]);
+          if (!existing) await api.issueMandate(principalAgentId, paAgentId, ["debate.create", "debate.accept"]);
+          const { run_id } = await api.startRun(ref);
+          const stagingDir = join5(targetCorpus, "converged", "staging", run_id);
+          mkdirSync4(stagingDir, { recursive: true });
+          const meta = {
+            run_id,
+            source_debate_id: ref,
+            pa_agent_id: paAgentId,
+            target_corpus: targetCorpus,
+            owner_role: "a"
+          };
+          writeRunMeta(stagingDir, meta);
+          ws = { runId: run_id, sourceDebateId: ref, paAgentId, targetCorpus, stagingDir };
+        } else {
+          ws = await resolveWorkspace({ stagingDir: opts.stagingDir });
+        }
+        const refreshStaging = async (cruxes, canonicalSourceHash2) => {
+          for (const c of cruxes) {
+            if (!c.latest_sub_debate_id) continue;
+            const subD = await api.getDebate(c.latest_sub_debate_id);
+            const subEvs = await api.getCommonsLogEvents(subD.commons_log_id, { limit: 2e3 });
+            const outcomeEv = [...subEvs.events].reverse().find(
+              (e) => e.payload.event_type === "convergence_outcome" || e.event_type === "convergence_outcome"
+            );
+            if (!outcomeEv) continue;
+            const op = outcomeEv.payload;
+            const body = buildPaBody(op);
+            const newPaBodyHash = computePaBodyHash(body);
+            const path2 = safeStagingPathFor(ws.stagingDir, c.crux_id);
+            const existingDoc = existsSync4(path2) ? readStaging(path2) : null;
+            if (existingDoc && existingDoc.frontmatter.pa_body_hash === newPaBodyHash) continue;
+            const fm = {
+              debate_id: ws.sourceDebateId,
+              run_id: ws.runId,
+              crux_id: c.crux_id,
+              sub_debate_chain: c.sub_debate_chain,
+              latest_sub_debate_id: c.latest_sub_debate_id,
+              source_crux_map_hash: canonicalSourceHash2,
+              generation_id: `gen_${ws.runId.slice(-8)}`,
+              generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+              pa_body_hash: newPaBodyHash,
+              outcome: op.outcome ?? c.outcome,
+              bilateral_mandate_intact: typeof op.bilateral_mandate_intact === "boolean" ? op.bilateral_mandate_intact : c.bilateral_mandate_intact ?? false,
+              citations_a: Array.isArray(op.citations_a) ? op.citations_a : [],
+              citations_b: Array.isArray(op.citations_b) ? op.citations_b : [],
+              mod_progress_summary: op.final_progress_signal != null && typeof op.final_progress_signal === "object" && !Array.isArray(op.final_progress_signal) ? op.final_progress_signal : {},
+              attested_by_user: existingDoc?.frontmatter.attested_by_user ?? false
+            };
+            writeStaging(path2, { frontmatter: fm, userResponse: existingDoc?.userResponse ?? "", body });
+          }
+        };
+        let summary;
+        let canonicalSourceHash = "";
+        {
+          const release = acquireLock(ws.stagingDir);
+          try {
+            for (const fn of listCruxFiles(ws.stagingDir)) {
+              const path2 = join5(ws.stagingDir, fn);
+              const doc = readStaging(path2);
+              const text = (doc.userResponse || "").trim();
+              if (!text) continue;
+              const subDebateId = doc.frontmatter.latest_sub_debate_id;
+              if (!subDebateId) continue;
+              const subDebate = await api.getDebate(subDebateId);
+              await api.appendCommonsLog(subDebate.commons_log_id, "owner_clarification", {
+                event_type: "owner_clarification",
+                content: text,
+                in_response_to_event_id: null
+              });
+              const round = countPreviouslyClarifiedSections(doc.body) + 1;
+              doc.userResponse = "";
+              doc.body = doc.body.trimEnd() + `
+
+# Previously clarified (round ${round})
+
+${text}
+`;
+              writeStaging(path2, doc);
+            }
+            const { events } = await api.getCommonsLogEvents(ws.runId, { limit: 5e3 });
+            summary = reduceRunState(ws, events);
+            const sourceDebate = await api.getDebate(ws.sourceDebateId);
+            const sourceEvents = await api.getCommonsLogEvents(sourceDebate.commons_log_id, {
+              limit: 2e3
+            });
+            const liveSourceHash = recomputeSourceCruxMapHash(sourceEvents.events);
+            const recordedHash = recordedSourceHash(events);
+            if (recordedHash && liveSourceHash && liveSourceHash !== recordedHash && !opts.forceRegenerate) {
+              throw new LinkedClawError(
+                "source_crux_map_drift",
+                `Source crux-map changed since run started (recorded=${recordedHash} live=${liveSourceHash}). Re-run with --force-regenerate.`
+              );
+            }
+            canonicalSourceHash = recordedHash ?? liveSourceHash ?? "";
+            await refreshStaging(summary.cruxes, canonicalSourceHash);
+          } finally {
+            release();
+          }
+        }
+        if (opts.wait && !summary.terminal_emitted) {
+          const deadline = Date.now() + opts.wait * 1e3;
+          let polledEvents = null;
+          while (Date.now() < deadline) {
+            await new Promise((r) => setTimeout(r, 2e3));
+            const { events: polled } = await api.getCommonsLogEvents(ws.runId, { limit: 5e3 });
+            if (reduceRunState(ws, polled).terminal_emitted) {
+              polledEvents = polled;
+              break;
+            }
+          }
+          if (polledEvents) {
+            summary = reduceRunState(ws, polledEvents);
+            const release2 = acquireLock(ws.stagingDir);
+            try {
+              await refreshStaging(summary.cruxes, canonicalSourceHash);
+            } finally {
+              release2();
+            }
+          }
+        }
+        return { run_id: ws.runId, summary, terminal_emitted: summary.terminal_emitted };
+      });
+    }
+  );
+  converge.command("clarify <sub_debate_id> <text>").description("Post owner_clarification.v1 directly to a sub-debate's Commons Log").action(async (subDebateId, text) => {
+    await runCommand(async () => {
+      const ctx = buildContext();
+      if (!ctx.cfg.apiKey) throw new LinkedClawError("missing_api_key", "Run `linkedclaw login` first.");
+      const api = makeConvergeApi(ctx.cfg.cloudUrl, ctx.cfg.apiKey);
+      const subDebate = await api.getDebate(subDebateId);
+      const { seq } = await api.appendCommonsLog(subDebate.commons_log_id, "owner_clarification", {
+        event_type: "owner_clarification",
+        content: text,
+        in_response_to_event_id: null
+      });
+      return { sub_debate_id: subDebateId, commons_log_id: subDebate.commons_log_id, seq };
+    });
+  });
+  converge.command("attest <crux_id>").description("POST an attest_only decision to the Convergence PA").option("--run-id <id>").option("--staging-dir <path>").action(async (cruxId, opts) => {
+    await runCommand(async () => {
+      const ctx = buildContext();
+      if (!ctx.cfg.apiKey) throw new LinkedClawError("missing_api_key", "Run `linkedclaw login` first.");
+      const api = makeConvergeApi(ctx.cfg.cloudUrl, ctx.cfg.apiKey);
+      const ws = await resolveWorkspace({ runId: opts.runId, stagingDir: opts.stagingDir });
+      const { event_id } = await postCruxDecision(api, ws, cruxId, "attest");
+      return { run_id: ws.runId, crux_id: cruxId, action: "attest", event_id, synced: false };
+    });
+  });
+  converge.command("accept <crux_id>").description("POST an accept decision to the Convergence PA").option("--run-id <id>").option("--staging-dir <path>").option("--message <text>", "Optional user_message recorded in provenance").option("--with-sync", "Compatibility: after the PA accepts, materialize local corpus files").action(async (cruxId, opts) => {
+    await runCommand(async () => {
+      const ctx = buildContext();
+      if (!ctx.cfg.apiKey) throw new LinkedClawError("missing_api_key", "Run `linkedclaw login` first.");
+      const api = makeConvergeApi(ctx.cfg.cloudUrl, ctx.cfg.apiKey);
+      const ws = await resolveWorkspace({ runId: opts.runId, stagingDir: opts.stagingDir });
+      const { event_id, body } = await postCruxDecision(api, ws, cruxId, "accept", { message: opts.message });
+      if (opts.withSync) {
+        const sync = await syncTerminalDecisions(ctx, api, ws, {
+          cruxId,
+          message: opts.message,
+          injectedTerminal: {
+            cruxId,
+            eventType: decisionEventTypeForAction("accept"),
+            payload: { event_type: decisionEventTypeForAction("accept"), crux_id: cruxId, ...body }
+          }
+        });
+        return {
+          run_id: ws.runId,
+          crux_id: cruxId,
+          action: "accept",
+          event_id,
+          synced: true,
+          ...sync
+        };
+      }
+      return { run_id: ws.runId, crux_id: cruxId, action: "accept", event_id, synced: false };
+    });
+  });
+  converge.command("reject <crux_id>").description("POST a reject decision to the Convergence PA").option("--run-id <id>").option("--staging-dir <path>").action(async (cruxId, opts) => {
+    await runCommand(async () => {
+      const ctx = buildContext();
+      if (!ctx.cfg.apiKey) throw new LinkedClawError("missing_api_key", "Run `linkedclaw login` first.");
+      const api = makeConvergeApi(ctx.cfg.cloudUrl, ctx.cfg.apiKey);
+      const ws = await resolveWorkspace({ runId: opts.runId, stagingDir: opts.stagingDir });
+      const { event_id } = await postCruxDecision(api, ws, cruxId, "reject");
+      return { run_id: ws.runId, crux_id: cruxId, action: "reject", event_id, synced: false };
+    });
+  });
+  converge.command("sync").description("Materialize PA decision events into local corpus/staging files").option("--run-id <id>").option("--staging-dir <path>").option("--crux-id <id>", "Limit sync to one crux").action(async (opts) => {
+    await runCommand(async () => {
+      const ctx = buildContext();
+      if (!ctx.cfg.apiKey) throw new LinkedClawError("missing_api_key", "Run `linkedclaw login` first.");
+      const api = makeConvergeApi(ctx.cfg.cloudUrl, ctx.cfg.apiKey);
+      const ws = await resolveWorkspace({ runId: opts.runId, stagingDir: opts.stagingDir });
+      const result = await syncTerminalDecisions(ctx, api, ws, { cruxId: opts.cruxId });
+      return { run_id: ws.runId, synced: true, ...result };
+    });
+  });
+  converge.command("review").description("List staging cruxes; surface already_aligned cruxes prominently").option("--run-id <id>").option("--staging-dir <path>").action(async (opts) => {
+    await runCommand(async () => {
+      const ws = await resolveWorkspace({ runId: opts.runId, stagingDir: opts.stagingDir });
+      const files = listCruxFiles(ws.stagingDir);
+      const cruxes = [];
+      for (const fn of files) {
+        const doc = readStaging(join5(ws.stagingDir, fn));
+        const fm = doc.frontmatter;
+        cruxes.push({
+          crux_id: fm.crux_id,
+          outcome: fm.outcome,
+          bilateral_mandate_intact: fm.bilateral_mandate_intact,
+          attested_by_user: fm.attested_by_user,
+          latest_sub_debate_id: fm.latest_sub_debate_id,
+          has_user_response: (doc.userResponse || "").trim().length > 0,
+          next_action: fm.outcome === "already_aligned" && !fm.attested_by_user ? "attest" : fm.outcome === "needs_input" ? "clarify_or_accept" : "accept_or_reject"
+        });
+      }
+      const alignedAwaitingAttest = cruxes.filter((c) => c.outcome === "already_aligned" && !c.attested_by_user);
+      return {
+        run_id: ws.runId,
+        staging_dir: ws.stagingDir,
+        cruxes,
+        already_aligned_awaiting_attest: alignedAwaitingAttest.map((c) => c.crux_id)
+      };
+    });
+  });
+  converge.command("status").description("Show reduced run state from the convergence run-log").option("--run-id <id>").option("--staging-dir <path>").option("--all", "List every run-log event (no reduction)").action(async (opts) => {
+    await runCommand(async () => {
+      const ctx = buildContext();
+      if (!ctx.cfg.apiKey) {
+        throw new Error("missing apiKey \u2014 run `linkedclaw login` first");
+      }
+      const ws = await resolveWorkspace({ runId: opts.runId, stagingDir: opts.stagingDir });
+      const api = makeConvergeApi(ctx.cfg.cloudUrl, ctx.cfg.apiKey);
+      const { events } = await api.getCommonsLogEvents(ws.runId, { limit: 1e3 });
+      if (opts.all) return { run_id: ws.runId, events };
+      return reduceRunState(ws, events);
+    });
+  });
+}
+function reduceRunState(ws, events) {
+  let started_at = null;
+  let owner_b_accepted = false;
+  let terminal_emitted = false;
+  const cruxMap = /* @__PURE__ */ new Map();
+  for (const ev of events) {
+    const p = ev.payload;
+    switch (ev.event_type) {
+      case "run_started":
+        started_at = ev.appended_at;
+        break;
+      case "owner_b_accepted":
+        owner_b_accepted = true;
+        break;
+      case "sub_debate_dispatched": {
+        const cruxId = p.crux_id;
+        const subDebateId = p.sub_debate_id;
+        if (!cruxMap.has(cruxId)) {
+          cruxMap.set(cruxId, {
+            crux_id: cruxId,
+            latest_sub_debate_id: subDebateId,
+            sub_debate_chain: [subDebateId],
+            outcome: null,
+            bilateral_mandate_intact: null
+          });
+        } else {
+          const entry = cruxMap.get(cruxId);
+          entry.latest_sub_debate_id = subDebateId;
+          entry.sub_debate_chain.push(subDebateId);
+        }
+        break;
+      }
+      case "sub_debate_outcome_observed": {
+        const cruxId = p.crux_id;
+        const entry = cruxMap.get(cruxId);
+        if (entry) {
+          entry.outcome = p.outcome;
+          if (typeof p.bilateral_mandate_intact === "boolean") {
+            entry.bilateral_mandate_intact = p.bilateral_mandate_intact;
+          }
+        }
+        break;
+      }
+      case "convergence_map":
+        terminal_emitted = true;
+        break;
+      default:
+        if (ev.event_type.startsWith("terminal_")) {
+          terminal_emitted = true;
+        }
+    }
+  }
+  return {
+    run_id: ws.runId,
+    source_debate_id: ws.sourceDebateId,
+    started_at,
+    owner_b_accepted,
+    cruxes: Array.from(cruxMap.values()),
+    terminal_emitted
+  };
+}
+
 // src/commands/provider.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { load as yamlLoad2 } from "js-yaml";
+import { readFileSync as readFileSync6 } from "fs";
+import { load as yamlLoad4 } from "js-yaml";
 
 // ../../sdk/provider-runtime-ts/dist/index.js
 import { EventEmitter } from "events";
@@ -5855,8 +7579,8 @@ var nodeWsConnector = async (url) => {
   const ws = new WebSocket3(url);
   const transport = {
     send: (data) => {
-      return new Promise((resolve, reject) => {
-        ws.send(data, (err) => err ? reject(err) : resolve());
+      return new Promise((resolve3, reject) => {
+        ws.send(data, (err) => err ? reject(err) : resolve3());
       });
     },
     close: (code, reason) => {
@@ -5872,8 +7596,8 @@ var nodeWsConnector = async (url) => {
       ws.on("error", (err) => fn(err));
     }
   };
-  const ready = new Promise((resolve, reject) => {
-    ws.once("open", () => resolve());
+  const ready = new Promise((resolve3, reject) => {
+    ws.once("open", () => resolve3());
     ws.once("error", (err) => reject(err));
   });
   return { transport, ready };
@@ -6308,12 +8032,12 @@ function normalizeReply(reply, nextSeq) {
   return { payload: reply, seq: nextSeq };
 }
 function withTimeout(p, ms, code) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve3, reject) => {
     const t = setTimeout(() => reject(new HandlerError(code, `timed out after ${ms}ms`)), ms);
     p.then(
       (v) => {
         clearTimeout(t);
-        resolve(v);
+        resolve3(v);
       },
       (err) => {
         clearTimeout(t);
@@ -6327,7 +8051,7 @@ function escapeRegex(s) {
 }
 
 // src/handlers/subprocess.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { randomUUID } from "crypto";
 import { createInterface } from "readline";
 var SubprocessHandler = class {
@@ -6339,7 +8063,7 @@ var SubprocessHandler = class {
     this.requestTimeoutMs = opts.requestTimeoutMs ?? 6e5;
     const shell = process.platform === "win32" ? "cmd.exe" : "/bin/sh";
     const shellArgs = process.platform === "win32" ? ["/c", opts.cmd] : ["-c", opts.cmd];
-    this.child = spawn(shell, shellArgs, {
+    this.child = spawn2(shell, shellArgs, {
       stdio: ["pipe", "pipe", "inherit"],
       cwd: opts.cwd,
       env: { ...process.env, ...opts.env }
@@ -6376,10 +8100,10 @@ var SubprocessHandler = class {
   async onInvoke(evt) {
     return this.request(evt);
   }
-  async onBroadcastOffer(evt) {
+  async onGigTaskOffer(evt) {
     return this.request(evt);
   }
-  async onBroadcastExecute(evt) {
+  async onGigTaskExecute(evt) {
     return this.request(evt);
   }
   // ───── shutdown ─────
@@ -6400,7 +8124,7 @@ var SubprocessHandler = class {
   request(frame) {
     const id = randomUUID();
     const line = JSON.stringify({ id, ...frame }) + "\n";
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve3, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(new Error(`handler_timeout: no response for ${frame.type} after ${this.requestTimeoutMs}ms`));
@@ -6408,7 +8132,7 @@ var SubprocessHandler = class {
       if (typeof timer.unref === "function") {
         timer.unref();
       }
-      this.pending.set(id, { resolve, reject, timer });
+      this.pending.set(id, { resolve: resolve3, reject, timer });
       this.stdin.write(line, (err) => {
         if (err) {
           this.pending.delete(id);
@@ -6456,9 +8180,9 @@ var SubprocessHandler = class {
 // src/commands/provider.ts
 function registerProviderCommands(program2) {
   const provider = program2.command("provider").description("Provider-side commands");
-  provider.command("register <config>").description('Register (create/update) an agent listing from a provider YAML file. Use "-" for stdin.').option("--human", "Human-readable output").action(async (path, opts) => {
+  provider.command("register <config>").description('Register (create/update) an agent listing from a provider YAML file. Use "-" for stdin.').option("--human", "Human-readable output").action(async (path2, opts) => {
     await runCommand(async () => {
-      const cfg = await loadProviderYaml(path);
+      const cfg = await loadProviderYaml(path2);
       const { providerClient } = buildContext();
       const body = buildCreateAgentRequest(cfg);
       if (cfg.agentId) {
@@ -6474,7 +8198,7 @@ function registerProviderCommands(program2) {
   });
   provider.command("update <listing_id>").description("Patch an existing agent listing. Body = JSON file or stdin.").requiredOption("--body <json>", 'JSON body (or "-" to read from stdin)').option("--human", "Human-readable output").action(async (listingId, opts) => {
     await runCommand(async () => {
-      const raw = opts.body === "-" ? await readStdin() : readFileSync2(opts.body, "utf8");
+      const raw = opts.body === "-" ? await readStdin() : readFileSync6(opts.body, "utf8");
       const body = JSON.parse(raw);
       const { providerClient } = buildContext();
       return providerClient.updateAgent(listingId, body);
@@ -6486,9 +8210,9 @@ function registerProviderCommands(program2) {
       return consumer.discover({ owner: "me" });
     }, { human: opts.human });
   });
-  provider.command("run <config>").description("Run a provider daemon: connect WS, dispatch events to handler subprocess").option("--handler-cmd <cmd>", "Shell command to spawn as the handler child process").option("--handler-http <url>", "HTTP webhook URL to POST each event to (alternative to --handler-cmd)").option("--human", "Human-readable status output").action(async (path, opts) => {
+  provider.command("run <config>").description("Run a provider daemon: connect WS, dispatch events to handler subprocess").option("--handler-cmd <cmd>", "Shell command to spawn as the handler child process").option("--handler-http <url>", "HTTP webhook URL to POST each event to (alternative to --handler-cmd)").option("--human", "Human-readable status output").action(async (path2, opts) => {
     try {
-      const yamlCfg = await loadProviderYaml(path);
+      const yamlCfg = await loadProviderYaml(path2);
       if (!yamlCfg.agentId) {
         process.stderr.write(
           JSON.stringify({ error: "provider_unconfigured", message: "agentId missing \u2014 run `linkedclaw provider register` first or set it in YAML" }) + "\n"
@@ -6516,7 +8240,7 @@ function registerProviderCommands(program2) {
       const handler = opts.handlerCmd ? new SubprocessHandler({ cmd: opts.handlerCmd }) : makeHttpHandler(opts.handlerHttp);
       const runtime = new ProviderRuntime({
         cloud: {
-          broadcasts: {
+          gigTasks: {
             accept: (taskId, body) => providerClient.acceptGigTask(taskId, body),
             submit: (taskId, body) => providerClient.submitGigTask(taskId, body)
           }
@@ -6555,7 +8279,7 @@ function registerProviderCommands(program2) {
       process.exit(1);
     }
   });
-  provider.command("pick <bct_id>").description("Manually accept a broadcast task (provider side)").requiredOption("--agent-id <agt_id>", "Which of your agents is accepting").option("--slot-key <key>", "Slot key for sliced broadcasts").option("--human", "Human-readable output").action(async (taskId, opts) => {
+  provider.command("pick <bct_id>").description("Manually accept a gig task (provider side)").requiredOption("--agent-id <agt_id>", "Which of your agents is accepting").option("--slot-key <key>", "Slot key for sliced gig tasks").option("--human", "Human-readable output").action(async (taskId, opts) => {
     await runCommand(async () => {
       const { providerClient } = buildContext();
       const body = { agent_id: opts.agentId };
@@ -6563,20 +8287,20 @@ function registerProviderCommands(program2) {
       return providerClient.acceptGigTask(taskId, body);
     }, { human: opts.human });
   });
-  provider.command("submit <bct_id> <result_file>").description('Submit a broadcast result. result_file = JSON path or "-" for stdin.').option("--human", "Human-readable output").action(async (taskId, resultFile, opts) => {
+  provider.command("submit <bct_id> <result_file>").description('Submit a gig task result. result_file = JSON path or "-" for stdin.').option("--human", "Human-readable output").action(async (taskId, resultFile, opts) => {
     await runCommand(async () => {
-      const raw = resultFile === "-" ? await readStdin() : readFileSync2(resultFile, "utf8");
+      const raw = resultFile === "-" ? await readStdin() : readFileSync6(resultFile, "utf8");
       const body = JSON.parse(raw);
       const { providerClient } = buildContext();
       return providerClient.submitGigTask(taskId, body);
     }, { human: opts.human });
   });
 }
-async function loadProviderYaml(path) {
-  const raw = path === "-" ? await readStdin() : readFileSync2(path, "utf8");
-  const parsed = yamlLoad2(raw);
+async function loadProviderYaml(path2) {
+  const raw = path2 === "-" ? await readStdin() : readFileSync6(path2, "utf8");
+  const parsed = yamlLoad4(raw);
   if (parsed === null || typeof parsed !== "object") {
-    throw new Error(`provider config ${path} is not a YAML object`);
+    throw new Error(`provider config ${path2} is not a YAML object`);
   }
   return parsed;
 }
@@ -6617,10 +8341,10 @@ function makeHttpHandler(url) {
     async onInvoke(evt) {
       return await postEvent(url, evt);
     },
-    async onBroadcastOffer(evt) {
+    async onGigTaskOffer(evt) {
       return await postEvent(url, evt);
     },
-    async onBroadcastExecute(evt) {
+    async onGigTaskExecute(evt) {
       return await postEvent(url, evt);
     }
   };
@@ -6636,10 +8360,10 @@ async function postEvent(url, body) {
 }
 
 // src/commands/requester.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { load as yamlLoad3 } from "js-yaml";
+import { readFileSync as readFileSync7 } from "fs";
+import { load as yamlLoad5 } from "js-yaml";
 function registerRequesterCommands(program2) {
-  program2.command("search <capability>").description("Search public agent listings by capability").option("--owner <owner>", '"me" or a "usr_..." id').option("--status <status>", "filter by status (online/offline/disabled)").option("--sort <sort>", "newest | price_asc | price_desc | trust").option("--human", "Human-readable output").action(async (capability, opts) => {
+  program2.command("search <capability>").description("Search public agent listings by capability").option("--owner <owner>", '"me" or a "usr_..." id').option("--status <status>", "filter by status (online/offline/disabled)").option("--sort <sort>", "newest | trust (default)").option("--human", "Human-readable output").action(async (capability, opts) => {
     await runCommand(async () => {
       const { requesterFlows } = buildContext();
       return requesterFlows.search(capability, {
@@ -6734,24 +8458,24 @@ function registerRequesterCommands(program2) {
       return invokeAgent(consumer, agentId, body);
     }, { human: opts.human });
   });
-  const broadcast = program2.command("broadcast").description("Broadcast task commands");
-  broadcast.command("create <manifest>").description(
-    'Create a broadcast task from a YAML/JSON manifest file. Use "-" for stdin. Required fields: capability, instruction, target_providers, credits_per_provider.'
+  const gigTask = program2.command("gig-task").description("Gig Task commands");
+  gigTask.command("create <manifest>").description(
+    'Create a gig task from a YAML/JSON manifest file. Use "-" for stdin. Required fields: capability, instruction, target_providers, credits_per_provider.'
   ).option("--human", "Human-readable output").action(async (manifestPath, opts) => {
     await runCommand(async () => {
       const { consumer } = buildContext();
-      const raw = manifestPath === "-" ? await readStdin() : readFileSync3(manifestPath, "utf8");
+      const raw = manifestPath === "-" ? await readStdin() : readFileSync7(manifestPath, "utf8");
       const body = parseYamlOrJson(raw);
       return consumer.createGigTask(body);
     }, { human: opts.human });
   });
-  broadcast.command("get <bct_id>").description("Get a broadcast task by id").option("--human", "Human-readable output").action(async (taskId, opts) => {
+  gigTask.command("get <bct_id>").description("Get a gig task by id").option("--human", "Human-readable output").action(async (taskId, opts) => {
     await runCommand(async () => {
       const { consumer } = buildContext();
       return consumer.getGigTask(taskId);
     }, { human: opts.human });
   });
-  broadcast.command("list").description("List broadcasts I own").option("--status <s>", "Filter by status").option("--human", "Human-readable output").action(async (opts) => {
+  gigTask.command("list").description("List gig tasks I own").option("--status <s>", "Filter by status").option("--human", "Human-readable output").action(async (opts) => {
     await runCommand(async () => {
       const { consumer } = buildContext();
       return consumer.listGigTasks({
@@ -6759,13 +8483,13 @@ function registerRequesterCommands(program2) {
       });
     }, { human: opts.human });
   });
-  broadcast.command("available").description("List open broadcasts I could pick up (as provider)").option("--human", "Human-readable output").action(async (opts) => {
+  gigTask.command("available").description("List open gig tasks I could pick up (as provider)").option("--human", "Human-readable output").action(async (opts) => {
     await runCommand(async () => {
       const { providerClient } = buildContext();
       return providerClient.listGigTasksAvailable();
     }, { human: opts.human });
   });
-  broadcast.command("accept <bct_id>").description("Accept a broadcast (provider side) \u2014 returns a result_id").requiredOption("--agent-id <agt_id>", "Which of your agents is accepting").option("--slot-key <key>", "Slot key for sliced broadcasts").option("--human", "Human-readable output").action(async (taskId, opts) => {
+  gigTask.command("accept <bct_id>").description("Accept a gig task (provider side) \u2014 returns a result_id").requiredOption("--agent-id <agt_id>", "Which of your agents is accepting").option("--slot-key <key>", "Slot key for sliced gig tasks").option("--human", "Human-readable output").action(async (taskId, opts) => {
     await runCommand(async () => {
       const { providerClient } = buildContext();
       const body = { agent_id: opts.agentId };
@@ -6773,8 +8497,8 @@ function registerRequesterCommands(program2) {
       return providerClient.acceptGigTask(taskId, body);
     }, { human: opts.human });
   });
-  broadcast.command("submit <bct_id>").description(
-    "Submit broadcast result (provider side). Body must include `result_data` (string) and may include `result_payload` (object) and `proof` (array)."
+  gigTask.command("submit <bct_id>").description(
+    "Submit gig task result (provider side). Body must include `result_data` (string) and may include `result_payload` (object) and `proof` (array)."
   ).requiredOption("--body <json>", 'JSON body (or "-" to read from stdin)').option("--human", "Human-readable output").action(async (taskId, opts) => {
     await runCommand(async () => {
       const { providerClient } = buildContext();
@@ -6804,6 +8528,36 @@ function registerRequesterCommands(program2) {
       return consumer.getBalance();
     }, { human: opts.human });
   });
+  program2.command("show <agent_id>").description("Show full agent listing including capabilities_meta").option("--capability <name>", "Print only this capability's meta entry").option("--human", "Human-readable output").action(async (agentId, opts) => {
+    await runCommand(async () => {
+      const { consumer } = buildContext();
+      const agent = await consumer.getAgent(agentId);
+      if (opts.capability) {
+        const meta = agent.capabilities_meta?.[opts.capability];
+        if (!meta) {
+          throw new Error(
+            `agent ${agentId} has no capabilities_meta entry for ${JSON.stringify(opts.capability)}`
+          );
+        }
+        return meta;
+      }
+      return agent;
+    }, { human: opts.human });
+  });
+  program2.command("schema <agent_id>").description("Fetch + sha256-verify a capability's input JSON Schema").requiredOption("--capability <name>", "Capability name").option("--human", "Human-readable output").action(async (agentId, opts) => {
+    await runCommand(async () => {
+      const { consumer } = buildContext();
+      const agent = await consumer.getAgent(agentId);
+      try {
+        return await fetchCapabilitySchema(agent, opts.capability);
+      } catch (err) {
+        if (err instanceof CapabilitySchemaError) {
+          throw new Error(`schema fetch failed: ${err.message}`);
+        }
+        throw err;
+      }
+    }, { human: opts.human });
+  });
 }
 async function runHireRepl(sessionId, ctx) {
   const readline = await import("readline/promises");
@@ -6882,7 +8636,7 @@ function parseJsonOrFail(raw, label) {
 function parseYamlOrJson(raw) {
   const trimmed = raw.trimStart();
   if (trimmed.startsWith("{") || trimmed.startsWith("[")) return JSON.parse(raw);
-  return yamlLoad3(raw);
+  return yamlLoad5(raw);
 }
 async function resolveManifestOpt(manifestOpt, manifestId, intention, defaultIntention) {
   if (manifestOpt !== void 0 && manifestId !== void 0) {
@@ -6896,7 +8650,7 @@ async function resolveManifestOpt(manifestOpt, manifestId, intention, defaultInt
     if (manifestOpt === "-") {
       raw = await readStdin();
     } else if (manifestOpt.startsWith("@")) {
-      raw = readFileSync3(manifestOpt.slice(1), "utf8");
+      raw = readFileSync7(manifestOpt.slice(1), "utf8");
     } else {
       raw = manifestOpt;
     }
@@ -6910,12 +8664,16 @@ async function resolveManifestOpt(manifestOpt, manifestId, intention, defaultInt
 }
 
 // src/bin.ts
-var CLI_VERSION = "0.1.2";
+var pkgPath = join6(dirname4(fileURLToPath(import.meta.url)), "..", "package.json");
+var CLI_VERSION = JSON.parse(readFileSync8(pkgPath, "utf8")).version;
 var program = new Command();
-program.name("linkedclaw").description("Official LinkedClaw CLI \u2014 any agent can shell out to hire providers, invoke, or broadcast").version(`cli ${CLI_VERSION}`);
+program.name("linkedclaw").description("Official LinkedClaw CLI \u2014 any agent can shell out to hire providers, invoke, or gig task").version(`cli ${CLI_VERSION}`);
 registerAuthCommands(program);
 registerRequesterCommands(program);
 registerProviderCommands(program);
+registerConvergeCommands(program);
+registerArenaCommands(program);
+registerAgentCommands(program);
 program.parseAsync(process.argv).catch((err) => {
   process.stderr.write(
     JSON.stringify({ error: "internal_error", message: err instanceof Error ? err.message : String(err) }) + "\n"