chatroom-cli 1.90.2 → 1.91.0

package/dist/index.js

@@ -28341,66 +28341,10 @@ function resolveCursorCliModel(model) {
   const prefix = `${CURSOR_PROVIDER}/`;
   return model.startsWith(prefix) ? model.slice(prefix.length) : model;
 }
-var CURSOR_COMMAND = "agent", CURSOR_PROVIDER = "cursor", NO_SUBAGENT_DIRECTIVE = "NEVER spawn subagents. Follow the chatroom instructions strictly.", CURSOR_MODELS, CursorAgentService;
+var CURSOR_COMMAND = "agent", CURSOR_PROVIDER = "cursor", NO_SUBAGENT_DIRECTIVE = "NEVER spawn subagents. Follow the chatroom instructions strictly.", CursorAgentService;
 var init_cursor_agent_service = __esm(() => {
   init_cursor_stream_reader();
   init_base_cli_agent_service();
-  CURSOR_MODELS = [
-    "claude-4.6-opus-high",
-    "claude-4.6-opus-high-thinking",
-    "claude-4.6-opus-max",
-    "claude-4.6-opus-max-thinking",
-    "claude-4.5-opus-high",
-    "claude-4.5-opus-high-thinking",
-    "claude-4.6-sonnet-medium",
-    "claude-4.6-sonnet-medium-thinking",
-    "claude-4.5-sonnet",
-    "claude-4.5-sonnet-thinking",
-    "claude-4-sonnet",
-    "claude-4-sonnet-thinking",
-    "claude-4-sonnet-1m",
-    "claude-4-sonnet-1m-thinking",
-    "gpt-5.4-low",
-    "gpt-5.4-medium",
-    "gpt-5.4-medium-fast",
-    "gpt-5.4-high",
-    "gpt-5.4-high-fast",
-    "gpt-5.4-xhigh",
-    "gpt-5.4-xhigh-fast",
-    "gpt-5.3-codex-low",
-    "gpt-5.3-codex-low-fast",
-    "gpt-5.3-codex",
-    "gpt-5.3-codex-fast",
-    "gpt-5.3-codex-high",
-    "gpt-5.3-codex-high-fast",
-    "gpt-5.3-codex-xhigh",
-    "gpt-5.3-codex-xhigh-fast",
-    "gpt-5.3-codex-spark-preview",
-    "gpt-5.2",
-    "gpt-5.2-high",
-    "gpt-5.2-codex-low",
-    "gpt-5.2-codex-low-fast",
-    "gpt-5.2-codex",
-    "gpt-5.2-codex-fast",
-    "gpt-5.2-codex-high",
-    "gpt-5.2-codex-high-fast",
-    "gpt-5.2-codex-xhigh",
-    "gpt-5.2-codex-xhigh-fast",
-    "gpt-5.1-high",
-    "gpt-5.1-codex-max",
-    "gpt-5.1-codex-max-high",
-    "gpt-5.1-codex-mini",
-    "gemini-3.1-pro",
-    "gemini-3-pro",
-    "gemini-3-flash",
-    "grok",
-    "kimi-k2.5",
-    "auto",
-    "composer-2.5",
-    "composer-2",
-    "composer-1.5",
-    "composer-1"
-  ];
   CursorAgentService = class CursorAgentService extends BaseCLIAgentService {
     id = "cursor";
     displayName = "Cursor";
@@ -28415,7 +28359,7 @@ var init_cursor_agent_service = __esm(() => {
       return this.checkVersion(CURSOR_COMMAND);
     }
     async listModels() {
-      return CURSOR_MODELS;
+      return [];
     }
     async spawn(options) {
       const args2 = ["-p", "--force", "--output-format", "stream-json"];
@@ -28617,18 +28561,7 @@ var init_copilot_agent_service = __esm(() => {
       return this.checkVersion(COPILOT_COMMAND);
     }
     async listModels() {
-      return [
-        "claude-3-5-sonnet-20241022",
-        "claude-3-5-haiku-20241022",
-        "claude-haiku-4.5",
-        "claude-sonnet-4-6",
-        "claude-opus-4-6",
-        "gpt-4o",
-        "gpt-4o-mini",
-        "gpt-4-turbo",
-        "gemini-3-pro-preview",
-        "gemini-2-5-flash"
-      ];
+      return [];
     }
     async spawn(options) {
       const { prompt } = options;
@@ -29826,6 +29759,999 @@ var init_claude_sdk = __esm(() => {
   init_claude_sdk_agent_service();
 });
 
+// ../../services/backend/src/domain/entities/harness/codex-sdk.model-variants.ts
+var CODEX_MODEL_VARIANT_COMBINATIONS;
+var init_codex_sdk_model_variants = __esm(() => {
+  CODEX_MODEL_VARIANT_COMBINATIONS = [
+    {},
+    { reasoning: "none" },
+    { reasoning: "low" },
+    { reasoning: "medium" },
+    { reasoning: "high" },
+    { reasoning: "xhigh" }
+  ];
+});
+
+// ../../services/backend/src/domain/entities/harness/model-variant.ts
+function parseParamList(encoded, paramsPart) {
+  const params = {};
+  for (const param of paramsPart.split(",")) {
+    if (!PARAM_RE.test(param)) {
+      throw new ModelVariantParseError(`malformed variant param "${param}" in "${encoded}" (expected key=value)`);
+    }
+    const eq = param.indexOf("=");
+    const key = param.slice(0, eq);
+    if (Object.prototype.hasOwnProperty.call(params, key)) {
+      throw new ModelVariantParseError(`duplicate variant param "${key}" in "${encoded}"`);
+    }
+    params[key] = param.slice(eq + 1);
+  }
+  return params;
+}
+function decodeModelVariant(encoded) {
+  if (encoded.length === 0) {
+    throw new ModelVariantParseError("empty model variant");
+  }
+  const match17 = MODEL_VARIANT_RE.exec(encoded);
+  if (!match17) {
+    throw new ModelVariantParseError(`malformed model variant: "${encoded}"`);
+  }
+  const [, model, paramsPart] = match17;
+  if (paramsPart === undefined) {
+    return { model, params: {} };
+  }
+  return { model, params: parseParamList(encoded, paramsPart) };
+}
+function describeCombination(combo) {
+  const entries2 = Object.entries(combo);
+  return entries2.length === 0 ? "no params" : entries2.map(([k, v3]) => `${k}=${v3}`).join(",");
+}
+function validateModelVariantParams(variant, schema) {
+  const supported = schema.find((combo) => Object.keys(combo).length === Object.keys(variant.params).length && Object.entries(combo).every(([key, value]) => variant.params[key] === value));
+  if (!supported) {
+    throw new ModelVariantValidationError(`unsupported variant params for model "${variant.model}": ` + `${describeCombination(variant.params)}; ` + `allowed: ${schema.map(describeCombination).join(" | ")}`);
+  }
+  return variant;
+}
+var ModelVariantParseError, ModelVariantValidationError, MODEL_VARIANT_RE, PARAM_RE;
+var init_model_variant = __esm(() => {
+  ModelVariantParseError = class ModelVariantParseError extends Error {
+    code = "MODEL_VARIANT_PARSE";
+    constructor(message) {
+      super(message);
+      this.name = "ModelVariantParseError";
+    }
+  };
+  ModelVariantValidationError = class ModelVariantValidationError extends Error {
+    code = "MODEL_VARIANT_VALIDATION";
+    constructor(message) {
+      super(message);
+      this.name = "ModelVariantValidationError";
+    }
+  };
+  MODEL_VARIANT_RE = /^([^\[\]]+?)(?:\[([^\]]*)\])?$/;
+  PARAM_RE = /^[A-Za-z0-9_-]+=[^,\[\]\=]+$/;
+});
+
+// src/daemon/infrastructure/local/harness/services/codex-sdk/codex-sdk-package.ts
+import { existsSync as existsSync2, readFileSync as readFileSync4 } from "node:fs";
+import { createRequire as createRequire4 } from "node:module";
+import { dirname as dirname3, join as join8 } from "node:path";
+import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "node:url";
+function resolveChatroomCliRoot2(moduleRef = import.meta.url) {
+  const filePath = moduleRef.startsWith("file:") ? fileURLToPath3(moduleRef) : moduleRef;
+  let dir = dirname3(filePath);
+  while (dir !== dirname3(dir)) {
+    const packageJsonPath = join8(dir, "package.json");
+    if (existsSync2(packageJsonPath)) {
+      const pkg = JSON.parse(readFileSync4(packageJsonPath, "utf8"));
+      if (pkg.name === "chatroom-cli") {
+        return dir;
+      }
+    }
+    dir = dirname3(dir);
+  }
+  throw new CodexSdkPackageError(`Could not locate chatroom-cli package root while resolving @openai/codex-sdk. ${REINSTALL_HINT2}`);
+}
+function readPinnedSdkVersion2(chatroomCliRoot) {
+  const pkg = JSON.parse(readFileSync4(join8(chatroomCliRoot, "package.json"), "utf8"));
+  const specifier = pkg.dependencies?.["@openai/codex-sdk"];
+  const pinned = specifier?.replace(/^[\^~>=<]+/, "").trim() ?? "";
+  const match17 = pinned.match(/^(\d+\.\d+\.\d+)/);
+  if (!match17) {
+    throw new CodexSdkPackageError(`chatroom-cli must pin an exact @openai/codex-sdk version (found "${specifier ?? "none"}"). ${REINSTALL_HINT2}`);
+  }
+  return match17[1];
+}
+function readInstalledSdkVersion2(packageJsonPath) {
+  const pkg = JSON.parse(readFileSync4(packageJsonPath, "utf8"));
+  return pkg.version;
+}
+function resolveCodexSdkPackageJson(chatroomCliRoot) {
+  const require3 = createRequire4(join8(chatroomCliRoot, "package.json"));
+  try {
+    return require3.resolve("@openai/codex-sdk/package.json", { paths: [chatroomCliRoot] });
+  } catch {
+    const candidate = join8(chatroomCliRoot, "node_modules", "@openai", "codex-sdk", "package.json");
+    if (existsSync2(candidate)) {
+      return candidate;
+    }
+    throw new CodexSdkPackageError(`Could not locate @openai/codex-sdk package.json from ${chatroomCliRoot}. ${REINSTALL_HINT2}`);
+  }
+}
+async function importBundledCodexSdk(moduleRef = import.meta.url) {
+  const chatroomCliRoot = resolveChatroomCliRoot2(moduleRef);
+  const pinnedVersion = readPinnedSdkVersion2(chatroomCliRoot);
+  const packageJsonPath = resolveCodexSdkPackageJson(chatroomCliRoot);
+  const installedVersion = readInstalledSdkVersion2(packageJsonPath);
+  if (installedVersion !== pinnedVersion) {
+    throw new CodexSdkPackageError(`@openai/codex-sdk@${installedVersion} does not match chatroom-cli pin (${pinnedVersion}). ${REINSTALL_HINT2}`);
+  }
+  const entryPath = join8(dirname3(packageJsonPath), "dist", "index.js");
+  if (!existsSync2(entryPath)) {
+    throw new CodexSdkPackageError(`@openai/codex-sdk entry file is missing: ${entryPath}. ${REINSTALL_HINT2}`);
+  }
+  return import(pathToFileURL2(entryPath).href);
+}
+function getBundledCodexSdkVersion(moduleRef = import.meta.url) {
+  const chatroomCliRoot = resolveChatroomCliRoot2(moduleRef);
+  return readInstalledSdkVersion2(resolveCodexSdkPackageJson(chatroomCliRoot));
+}
+function formatCodexSdkError(err) {
+  if (err instanceof Error) {
+    const sdkErr = err;
+    const code2 = sdkErr.code ? `[${sdkErr.code}] ` : "";
+    const name = sdkErr.name && sdkErr.name !== "Error" ? `${sdkErr.name}: ` : "";
+    return `${name}${code2}${err.message}`.trim();
+  }
+  return String(err);
+}
+function formatCodexSdkLoadError(err) {
+  if (err instanceof CodexSdkPackageError) {
+    return err.message;
+  }
+  return formatCodexSdkError(err);
+}
+var REINSTALL_HINT2 = "Reinstall chatroom-cli: npm install -g chatroom-cli@latest", CodexSdkPackageError;
+var init_codex_sdk_package = __esm(() => {
+  CodexSdkPackageError = class CodexSdkPackageError extends Error {
+    code = "CODEX_SDK_PACKAGE_INCOMPLETE";
+    constructor(message) {
+      super(message);
+      this.name = "CodexSdkPackageError";
+    }
+  };
+});
+
+// src/daemon/domain/usecase/detect-terminal-provider-error.ts
+function matchesQuotaPhrase(blob) {
+  const text = blob.toLowerCase();
+  return QUOTA_PHRASES.some((phrase) => text.includes(phrase));
+}
+function matchesStructuredProviderErrorText(blob) {
+  const text = blob.toLowerCase();
+  const hasProviderName = PROVIDER_ERROR_NAMES.some((name) => text.includes(name));
+  return hasProviderName && matchesQuotaPhrase(blob);
+}
+function matchesFatalHarnessErrorText(blob) {
+  const text = blob.toLowerCase();
+  return FATAL_HARNESS_PHRASES.some((phrase) => text.includes(phrase));
+}
+function matchesTerminalProviderErrorText(blob) {
+  return matchesQuotaPhrase(blob) || matchesStructuredProviderErrorText(blob);
+}
+function isNonRetryableHarnessFailureText(blob) {
+  return matchesTerminalProviderErrorText(blob) || matchesFatalHarnessErrorText(blob);
+}
+function isTerminalProviderError(error) {
+  if (typeof error === "string") {
+    return isNonRetryableHarnessFailureText(error);
+  }
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const e = error;
+  if (typeof e.error === "string" && isNonRetryableHarnessFailureText(e.error)) {
+    return true;
+  }
+  const name = extractName(e);
+  const message = extractMessage(e);
+  return matchesQuotaPhrase(message) || matchesQuotaPhrase(`${name} ${message}`) || matchesFatalHarnessErrorText(message) || matchesFatalHarnessErrorText(`${name} ${message}`);
+}
+function isClassifiableHarnessLogLine(line) {
+  if (/\b(?:text|thinking)\]/.test(line))
+    return false;
+  if (/\btool:/.test(line))
+    return false;
+  if (line.includes("agent_end]"))
+    return true;
+  if (line.includes("spawn-error]"))
+    return true;
+  if (line.includes(" error]"))
+    return true;
+  if (line.includes(" run-error]"))
+    return true;
+  return false;
+}
+function extractName(e) {
+  const name = e.name;
+  if (typeof name === "string")
+    return name.toLowerCase();
+  const type = e.type;
+  if (typeof type === "string")
+    return type.toLowerCase();
+  return "";
+}
+function extractMessage(e) {
+  const fromData = messageFromData(e.data);
+  if (fromData)
+    return fromData;
+  if (typeof e.message === "string")
+    return e.message.toLowerCase();
+  if (typeof e.responseBody === "string")
+    return e.responseBody.toLowerCase();
+  if (typeof e.error === "string")
+    return e.error.toLowerCase();
+  if (e.error && typeof e.error === "object") {
+    return extractMessage(e.error);
+  }
+  return "";
+}
+function messageFromData(data) {
+  if (!data || typeof data !== "object")
+    return;
+  const msg = data.message;
+  return typeof msg === "string" ? msg.toLowerCase() : undefined;
+}
+var FATAL_HARNESS_PHRASES, QUOTA_PHRASES, PROVIDER_ERROR_NAMES;
+var init_detect_terminal_provider_error = __esm(() => {
+  FATAL_HARNESS_PHRASES = [
+    "failed to load model",
+    "model loading was stopped",
+    "insufficient system resources",
+    "sandboxing is not supported",
+    "disable local.sandboxoptions.enabled"
+  ];
+  QUOTA_PHRASES = [
+    "usagelimit",
+    "usage limit",
+    "enable usage from your available balance",
+    "rate limit",
+    "ratelimit",
+    "too many requests",
+    "x-ratelimit-exceeded",
+    "weekly rate limit",
+    "exceeded your weekly"
+  ];
+  PROVIDER_ERROR_NAMES = ["ai_apicallerror", "ai_retryerror"];
+});
+
+// src/daemon/domain/usecase/classify-provider-error.ts
+function providerUnavailableAgentEndReason(reason) {
+  if (reason === "model_capacity")
+    return PROVIDER_MODEL_CAPACITY_AGENT_END;
+  if (reason === "rate_limit")
+    return "provider_rate_limit";
+  return "provider_quota";
+}
+function includesPhrase(message, phrases) {
+  const normalized = message.toLowerCase();
+  return phrases.some((phrase) => normalized.includes(phrase));
+}
+function classification(reason, message) {
+  return { reason, message: message.trim(), recoverable: providerUnavailableRecoverable(reason) };
+}
+function classifyProviderErrorMessage(message) {
+  if (includesPhrase(message, MODEL_CAPACITY_PHRASES)) {
+    return classification("model_capacity", message);
+  }
+  if (includesPhrase(message, RATE_LIMIT_PHRASES)) {
+    return classification("rate_limit", message);
+  }
+  if (includesPhrase(message, QUOTA_PHRASES2)) {
+    return classification("quota", message);
+  }
+  return null;
+}
+function classifyProviderErrorLogLine(line) {
+  if (!isClassifiableHarnessLogLine(line))
+    return null;
+  const marker = isProviderUnavailableAgentEndReason(line);
+  if (marker)
+    return classification(marker, line);
+  return classifyProviderErrorMessage(line);
+}
+function classifyProviderErrorFromLogs(logLines) {
+  for (let index = logLines.length - 1;index >= 0; index -= 1) {
+    const result = classifyProviderErrorLogLine(logLines[index]);
+    if (result)
+      return result;
+  }
+  return null;
+}
+function isProviderUnavailableAgentEndReason(reason) {
+  const normalized = reason.toLowerCase();
+  if (normalized.includes(PROVIDER_MODEL_CAPACITY_AGENT_END))
+    return "model_capacity";
+  if (normalized.includes("provider_rate_limit"))
+    return "rate_limit";
+  if (normalized.includes("provider_quota"))
+    return "quota";
+  return null;
+}
+function providerUnavailableRecoverable(reason) {
+  return reason !== "quota";
+}
+var PROVIDER_MODEL_CAPACITY_AGENT_END = "provider_model_capacity", MODEL_CAPACITY_PHRASES, RATE_LIMIT_PHRASES, QUOTA_PHRASES2;
+var init_classify_provider_error = __esm(() => {
+  init_detect_terminal_provider_error();
+  MODEL_CAPACITY_PHRASES = ["selected model is at capacity", "model is at capacity"];
+  RATE_LIMIT_PHRASES = [
+    "rate limit",
+    "ratelimit",
+    "too many requests",
+    "x-ratelimit-exceeded",
+    "weekly rate limit"
+  ];
+  QUOTA_PHRASES2 = [
+    "usagelimit",
+    "usage limit",
+    "enable usage from your available balance",
+    "exceeded your weekly"
+  ];
+});
+
+// src/daemon/infrastructure/local/harness/services/codex-sdk/codex-sdk-stream-adapter.ts
+var CodexSdkStreamAdapter;
+var init_codex_sdk_stream_adapter = __esm(() => {
+  init_classify_provider_error();
+  init_native_stream_adapter_base();
+  CodexSdkStreamAdapter = class CodexSdkStreamAdapter extends NativeStreamAdapterBase {
+    textBuffer = "";
+    handleEvent(event) {
+      this.notifyOutput();
+      switch (event.type) {
+        case "item.started":
+        case "item.updated":
+        case "item.completed":
+          this.handleItem(event.item);
+          break;
+        case "turn.completed":
+          break;
+        case "turn.failed":
+          this.flushText();
+          this.writeProviderUnavailableMarker(event.error.message);
+          this.writeLine(formatAgentLogLine(this.logPrefix, "run-error", event.error.message));
+          break;
+        case "error":
+          this.flushText();
+          this.writeProviderUnavailableMarker(event.message);
+          this.writeLine(formatAgentLogLine(this.logPrefix, "run-error", event.message));
+          break;
+        case "thread.started":
+        case "turn.started":
+        default:
+          break;
+      }
+    }
+    finish() {
+      this.flushText();
+      this.emitAgentEnd();
+    }
+    handleItem(item) {
+      switch (item.type) {
+        case "agent_message":
+          this.appendAssistantText(item.text);
+          break;
+        case "reasoning":
+          this.logReasoning(item);
+          break;
+        case "command_execution":
+          this.logCommandExecution(item);
+          break;
+        case "file_change":
+          this.logFileChange(item);
+          break;
+        case "mcp_tool_call":
+          this.logMcpToolCall(item);
+          break;
+        case "web_search":
+          this.logWebSearch(item);
+          break;
+        case "error":
+          this.flushText();
+          this.writeLine(formatAgentLogLine(this.logPrefix, "error", item.message));
+          break;
+        case "todo_list":
+          break;
+        default:
+          break;
+      }
+    }
+    logReasoning(item) {
+      this.flushText();
+      this.writeLine(formatAgentLogLine(this.logPrefix, "thinking", item.text));
+    }
+    logCommandExecution(item) {
+      this.flushText();
+      this.writeLine(formatAgentLogLine(this.logPrefix, BASH_TOOL_KIND, formatBashRunningPayload(item.command)));
+      if (item.aggregated_output && item.aggregated_output.trim().length > 0) {
+        this.writeLine(formatAgentLogLine(this.logPrefix, "tool-output", item.aggregated_output));
+      }
+      if (item.status === "failed") {
+        this.writeLine(formatAgentLogLine(this.logPrefix, "tool-error", `${item.command} exited with ${item.exit_code ?? "unknown"}`));
+      }
+    }
+    logFileChange(item) {
+      this.flushText();
+      const summary5 = item.changes.map((change) => `${change.kind} ${change.path}`).join(", ");
+      this.writeLine(formatAgentLogLine(this.logPrefix, "file", `${summary5}${item.status === "failed" ? " (patch failed)" : ""}`));
+    }
+    logMcpToolCall(item) {
+      this.flushText();
+      if (item.status === "failed" || item.error) {
+        this.writeLine(formatAgentLogLine(this.logPrefix, "tool-error", `${item.server}/${item.tool}: ${item.error?.message ?? "failed"}`));
+        return;
+      }
+      this.writeLine(formatAgentLogLine(this.logPrefix, "tool", `${item.server}/${item.tool} ${JSON.stringify(item.arguments ?? {})}`));
+    }
+    logWebSearch(item) {
+      this.flushText();
+      this.writeLine(formatAgentLogLine(this.logPrefix, "tool: web_search", item.query));
+    }
+    appendAssistantText(text) {
+      this.textBuffer += text;
+      this.assistantTextCapture.captureAssistantText(text);
+      if (this.textBuffer.includes(`
+`))
+        this.flushText();
+    }
+    flushText() {
+      if (!this.textBuffer)
+        return;
+      for (const line of this.textBuffer.split(`
+`)) {
+        if (line)
+          this.writeLine(formatAgentLogLine(this.logPrefix, "text", line));
+      }
+      this.textBuffer = "";
+    }
+    emitAgentEnd() {
+      if (this.agentEndEmitted)
+        return;
+      this.agentEndEmitted = true;
+      this.flushText();
+      this.writeLine(formatAgentLogLine(this.logPrefix, "agent_end"));
+      for (const cb of this.agentEndCallbacks)
+        cb();
+    }
+    writeProviderUnavailableMarker(message) {
+      const classification2 = classifyProviderErrorMessage(message);
+      if (!classification2)
+        return;
+      this.writeLine(formatAgentLogLine(this.logPrefix, "agent_end", `reason: ${providerUnavailableAgentEndReason(classification2.reason)}`));
+    }
+    writeLine(formatted) {
+      process.stdout.write(`${formatted}
+`);
+      this.emitLogLine?.(formatted);
+    }
+  };
+});
+
+// src/daemon/infrastructure/local/harness/services/codex-sdk/codex-sdk-agent-service.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+async function loadSdk2() {
+  if (_sdkCache2)
+    return _sdkCache2;
+  if (_sdkLoadError2)
+    throw _sdkLoadError2;
+  try {
+    _sdkCache2 = await importBundledCodexSdk();
+    return _sdkCache2;
+  } catch (err) {
+    _sdkLoadError2 = err;
+    throw err;
+  }
+}
+function getSdkPackageVersion2() {
+  if (cachedSdkPackageVersion2)
+    return cachedSdkPackageVersion2;
+  cachedSdkPackageVersion2 = getBundledCodexSdkVersion();
+  return cachedSdkPackageVersion2;
+}
+function buildAgentName(context5) {
+  return `${context5.role}@${context5.chatroomId.slice(-6)}`;
+}
+function decodeCodexVariant(encoded) {
+  if (encoded === undefined)
+    return;
+  return validateModelVariantParams(decodeModelVariant(encoded), CODEX_MODEL_VARIANT_COMBINATIONS);
+}
+function buildThreadOptions(workingDir, variant) {
+  const options = {
+    workingDirectory: workingDir,
+    skipGitRepoCheck: true,
+    sandboxMode: "danger-full-access",
+    networkAccessEnabled: true
+  };
+  if (!variant)
+    return options;
+  options.model = variant.model;
+  const reasoning = variant.params.reasoning;
+  if (reasoning !== undefined && reasoning !== "none") {
+    options.modelReasoningEffort = reasoning;
+  }
+  return options;
+}
+function buildCodexEnv(resolvedConvexUrl) {
+  return Object.fromEntries(Object.entries(buildAgentSpawnEnv(resolvedConvexUrl)).filter((entry) => entry[1] !== undefined));
+}
+function waitForResumeOrAbort2(session2) {
+  if (session2.aborted)
+    return Promise.resolve(null);
+  const queued = session2.pendingResumePrompt;
+  if (queued !== undefined) {
+    session2.pendingResumePrompt = undefined;
+    return Promise.resolve(queued);
+  }
+  return Promise.race([
+    new Promise((resolve2) => {
+      session2.resumeResolve = (prompt) => {
+        session2.resumeResolve = undefined;
+        session2.abortResolve = undefined;
+        resolve2(prompt);
+      };
+    }),
+    new Promise((resolve2) => {
+      session2.abortResolve = () => {
+        session2.resumeResolve = undefined;
+        session2.abortResolve = undefined;
+        resolve2(null);
+      };
+    })
+  ]);
+}
+function writeSpawnError2(logPrefix, err, emitLogLine) {
+  const line = formatAgentLogLine(logPrefix, "spawn-error", formatCodexSdkError(err));
+  process.stderr.write(`${line}
+`);
+  emitLogLine?.(line);
+  console.error(`[${new Date().toISOString()}] ${logPrefix} spawn-error]`, err);
+}
+function notifyResumableThreadId(threadId, session2, correlationId, callbacks) {
+  if (session2.threadId === threadId) {
+    return;
+  }
+  session2.threadId = threadId;
+  const info = {
+    correlationId,
+    resumableId: threadId,
+    source: "provider_allocated"
+  };
+  for (const cb of callbacks) {
+    cb(info);
+  }
+}
+var CODEX_SDK_COMMAND = "codex", TURN_TIMEOUT_MS2 = 3600000, _sdkCache2, _sdkLoadError2, cachedSdkPackageVersion2, CodexSdkAgentService;
+var init_codex_sdk_agent_service = __esm(() => {
+  init_codex_sdk_model_variants();
+  init_model_variant();
+  init_esm();
+  init_codex_sdk_package();
+  init_codex_sdk_stream_adapter();
+  init_spawn_env();
+  init_base_cli_agent_service();
+  init_detection_result();
+  CodexSdkAgentService = class CodexSdkAgentService extends BaseCLIAgentService {
+    id = "codex-sdk";
+    displayName = "Codex (SDK)";
+    command = CODEX_SDK_COMMAND;
+    sessions = new Map;
+    constructor(deps) {
+      super(deps);
+    }
+    async isInstalled() {
+      try {
+        await loadSdk2();
+        return true;
+      } catch (err) {
+        console.warn(`[codex-sdk] unavailable: ${formatCodexSdkLoadError(err)}`);
+        return false;
+      }
+    }
+    detectInstallationEffect() {
+      return exports_Effect.promise(async () => {
+        const installed2 = await this.isInstalled();
+        return installed2 ? DetectionResult.Installed() : DetectionResult.NotInstalled();
+      });
+    }
+    async getVersion() {
+      const match17 = getSdkPackageVersion2().match(/^(\d+)\.(\d+)\.(\d+)/);
+      if (!match17)
+        return null;
+      return {
+        version: `${match17[1]}.${match17[2]}.${match17[3]}`,
+        major: parseInt(match17[1], 10)
+      };
+    }
+    async listModels() {
+      return [];
+    }
+    async resumeTurn(pid, prompt) {
+      const session2 = this.sessions.get(pid);
+      if (!session2) {
+        throw new Error(`No codex-sdk session for pid=${pid}`);
+      }
+      if (session2.resumeResolve) {
+        const resolve2 = session2.resumeResolve;
+        session2.resumeResolve = undefined;
+        session2.abortResolve = undefined;
+        resolve2(prompt);
+        return;
+      }
+      session2.pendingResumePrompt = prompt;
+    }
+    async stop(pid, _options) {
+      const session2 = this.sessions.get(pid);
+      if (session2) {
+        session2.aborted = true;
+        session2.abortResolve?.();
+        try {
+          session2.abortController?.abort();
+        } catch {}
+        try {
+          session2.keeper.kill();
+        } catch {}
+        this.sessions.delete(pid);
+      }
+      await super.stop(pid);
+    }
+    getHarnessReconnectContext(pid) {
+      const session2 = this.sessions.get(pid);
+      if (!session2) {
+        return;
+      }
+      return {
+        agentName: session2.agentName,
+        ...session2.model ? { model: session2.model } : {}
+      };
+    }
+    spawnKeeper(workingDir) {
+      const keeper = this.deps.spawn(process.execPath, ["-e", "setInterval(()=>{},2147483647)"], {
+        cwd: workingDir,
+        stdio: "ignore",
+        shell: false,
+        detached: true
+      });
+      if (!keeper.pid) {
+        keeper.kill();
+        throw new Error("Failed to spawn codex-sdk keeper process");
+      }
+      return keeper;
+    }
+    startRunningSession(args2) {
+      const {
+        pid,
+        keeper,
+        codex,
+        thread,
+        context: context5,
+        model,
+        initialPrompt,
+        deferInitialTurn = false,
+        storedSystemPrompt,
+        resumedThreadId
+      } = args2;
+      const entry = this.registerProcess(pid, context5);
+      const logPrefix = buildAgentLogPrefix("codex-sdk", context5);
+      const agentName = buildAgentName(context5);
+      const harnessSessionId = randomUUID2();
+      const session2 = {
+        keeper,
+        codex,
+        thread,
+        aborted: false,
+        agentName,
+        model,
+        storedSystemPrompt,
+        ...resumedThreadId ? { threadId: resumedThreadId } : {}
+      };
+      this.sessions.set(pid, session2);
+      const callbacks = this.buildSessionCallbacks(pid, context5);
+      this.runTurnLoop({
+        session: session2,
+        correlationId: harnessSessionId,
+        sessionIdUpdatedCallbacks: callbacks.sessionIdUpdatedCallbacks,
+        entry,
+        logPrefix,
+        initialPrompt,
+        deferInitialTurn,
+        finishExit: callbacks.finishExit,
+        outputCallbacks: callbacks.outputCallbacks,
+        agentEndCallbacks: callbacks.agentEndCallbacks,
+        assistantTextCallbacks: callbacks.assistantTextCallbacks,
+        emitLogLine: callbacks.emitLogLine
+      });
+      return this.buildSpawnResult({
+        pid,
+        harnessSessionId,
+        resumedThreadId,
+        exitCallbacks: callbacks.exitCallbacks,
+        outputCallbacks: callbacks.outputCallbacks,
+        agentEndCallbacks: callbacks.agentEndCallbacks,
+        logLineCallbacks: callbacks.logLineCallbacks,
+        assistantTextCallbacks: callbacks.assistantTextCallbacks,
+        sessionIdUpdatedCallbacks: callbacks.sessionIdUpdatedCallbacks
+      });
+    }
+    buildSessionCallbacks(pid, context5) {
+      const exitCallbacks = [];
+      const outputCallbacks = [];
+      const agentEndCallbacks = [];
+      const logLineCallbacks = [];
+      const assistantTextCallbacks = [];
+      const sessionIdUpdatedCallbacks = [];
+      const emitLogLine = (line) => {
+        for (const cb of logLineCallbacks)
+          cb(line);
+      };
+      const finishExit = (code2, signal) => {
+        this.sessions.delete(pid);
+        this.deleteProcess(pid);
+        for (const cb of exitCallbacks) {
+          cb({ code: code2, signal, context: context5 });
+        }
+      };
+      return {
+        exitCallbacks,
+        outputCallbacks,
+        agentEndCallbacks,
+        logLineCallbacks,
+        assistantTextCallbacks,
+        sessionIdUpdatedCallbacks,
+        emitLogLine,
+        finishExit
+      };
+    }
+    buildSpawnResult(args2) {
+      const {
+        pid,
+        harnessSessionId,
+        resumedThreadId,
+        exitCallbacks,
+        outputCallbacks,
+        agentEndCallbacks,
+        logLineCallbacks,
+        assistantTextCallbacks,
+        sessionIdUpdatedCallbacks
+      } = args2;
+      return {
+        pid,
+        harnessSessionId,
+        onExit: (cb) => {
+          exitCallbacks.push(cb);
+        },
+        onOutput: (cb) => {
+          outputCallbacks.push(cb);
+        },
+        onAgentEnd: (cb) => {
+          agentEndCallbacks.push(cb);
+        },
+        onLogLine: (cb) => {
+          logLineCallbacks.push(cb);
+        },
+        onAssistantText: (cb) => {
+          assistantTextCallbacks.push(cb);
+        },
+        onHarnessSessionIdUpdated: (cb) => {
+          sessionIdUpdatedCallbacks.push(cb);
+          if (resumedThreadId) {
+            cb({
+              correlationId: harnessSessionId,
+              resumableId: resumedThreadId,
+              source: "provider_allocated"
+            });
+          }
+        }
+      };
+    }
+    runTurnLoop(args2) {
+      const {
+        session: session2,
+        correlationId,
+        sessionIdUpdatedCallbacks,
+        logPrefix,
+        initialPrompt,
+        deferInitialTurn = false,
+        finishExit,
+        entry,
+        outputCallbacks,
+        agentEndCallbacks,
+        assistantTextCallbacks,
+        emitLogLine
+      } = args2;
+      let exited = false;
+      (async () => {
+        let exitCode = 0;
+        let exitSignal = null;
+        let nextPrompt = deferInitialTurn ? null : initialPrompt;
+        let prependSystemOnNextResume = deferInitialTurn;
+        const storedSystemPrompt = session2.storedSystemPrompt;
+        try {
+          while (!session2.aborted) {
+            if (nextPrompt === null) {
+              const deferredResume = await waitForResumeOrAbort2(session2);
+              if (deferredResume === null || session2.aborted) {
+                if (session2.aborted) {
+                  exitCode = 1;
+                  exitSignal = "SIGTERM";
+                }
+                break;
+              }
+              nextPrompt = prependSystemOnNextResume && storedSystemPrompt ? `${storedSystemPrompt}
+
+${deferredResume}` : deferredResume;
+              prependSystemOnNextResume = false;
+            }
+            try {
+              await this.runOneTurn({
+                session: session2,
+                prompt: nextPrompt,
+                correlationId,
+                sessionIdUpdatedCallbacks,
+                entry,
+                logPrefix,
+                outputCallbacks,
+                agentEndCallbacks,
+                assistantTextCallbacks,
+                emitLogLine
+              });
+              nextPrompt = null;
+            } catch (turnErr) {
+              exitCode = 1;
+              writeSpawnError2(logPrefix, turnErr, emitLogLine);
+              break;
+            }
+            if (session2.aborted) {
+              exitCode = 1;
+              exitSignal = "SIGTERM";
+              break;
+            }
+          }
+        } catch (err) {
+          exitCode = 1;
+          writeSpawnError2(logPrefix, err, emitLogLine);
+        } finally {
+          if (exited)
+            return;
+          exited = true;
+          try {
+            session2.keeper.kill();
+          } catch {}
+          finishExit(exitCode, exitSignal);
+        }
+      })().catch((err) => {
+        writeSpawnError2(logPrefix, err, emitLogLine);
+        if (exited)
+          return;
+        exited = true;
+        try {
+          session2.keeper.kill();
+        } catch {}
+        finishExit(1, null);
+      });
+    }
+    async runOneTurn(args2) {
+      const {
+        session: session2,
+        prompt,
+        correlationId,
+        sessionIdUpdatedCallbacks,
+        entry,
+        logPrefix,
+        outputCallbacks,
+        agentEndCallbacks,
+        assistantTextCallbacks,
+        emitLogLine
+      } = args2;
+      const adapter = new CodexSdkStreamAdapter(logPrefix, emitLogLine);
+      wireNativeStreamAdapter({
+        adapter,
+        assistantTextCallbacks,
+        outputCallbacks,
+        agentEndCallbacks,
+        entry
+      });
+      const abortController = new AbortController;
+      session2.abortController = abortController;
+      try {
+        await withTimeout((async () => {
+          const { events } = await session2.thread.runStreamed(prompt, {
+            signal: abortController.signal
+          });
+          for await (const event of events) {
+            if (session2.aborted)
+              break;
+            adapter.handleEvent(event);
+            if (event.type === "thread.started") {
+              notifyResumableThreadId(event.thread_id, session2, correlationId, sessionIdUpdatedCallbacks);
+            }
+          }
+        })(), TURN_TIMEOUT_MS2, "thread.runStreamed");
+      } finally {
+        session2.abortController = undefined;
+      }
+      adapter.finish();
+    }
+    async spawn(options) {
+      const variant = decodeCodexVariant(options.model);
+      const deferInitialTurn = options.deferInitialTurn ?? false;
+      const keeper = this.spawnKeeper(options.workingDir);
+      const pid = keeper.pid;
+      const context5 = options.context;
+      const fullPrompt = deferInitialTurn ? "" : `${options.systemPrompt}
+
+${options.prompt}`;
+      let codex;
+      let thread;
+      try {
+        const { Codex } = await loadSdk2();
+        codex = new Codex({ env: buildCodexEnv(options.resolvedConvexUrl) });
+        thread = codex.startThread(buildThreadOptions(options.workingDir, variant));
+      } catch (err) {
+        writeSpawnError2(buildAgentLogPrefix("codex-sdk", context5), err);
+        keeper.kill();
+        this.deleteProcess(pid);
+        throw err;
+      }
+      return this.startRunningSession({
+        pid,
+        keeper,
+        codex,
+        thread,
+        context: context5,
+        workingDir: options.workingDir,
+        model: options.model,
+        initialPrompt: fullPrompt,
+        deferInitialTurn,
+        storedSystemPrompt: options.systemPrompt
+      });
+    }
+    async resumeFromDaemonMemory(options, stored) {
+      try {
+        const keeper = this.spawnKeeper(stored.workingDir);
+        const pid = keeper.pid;
+        const variant = decodeCodexVariant(options.model ?? stored.model);
+        const { Codex } = await loadSdk2();
+        const codex = new Codex({ env: buildCodexEnv(options.resolvedConvexUrl) });
+        const thread = codex.resumeThread(stored.harnessSessionId, buildThreadOptions(stored.workingDir, variant));
+        return this.startRunningSession({
+          pid,
+          keeper,
+          codex,
+          thread,
+          context: options.context,
+          workingDir: stored.workingDir,
+          model: options.model ?? stored.model,
+          initialPrompt: options.prompt,
+          storedSystemPrompt: options.systemPrompt,
+          resumedThreadId: stored.harnessSessionId
+        });
+      } catch (err) {
+        writeSpawnError2(buildAgentLogPrefix("codex-sdk", options.context), err, (line) => process.stderr.write(`${line}
+`));
+        return this.spawn(options);
+      }
+    }
+  };
+});
+
+// src/daemon/infrastructure/local/harness/services/codex-sdk/index.ts
+var init_codex_sdk = __esm(() => {
+  init_codex_sdk_agent_service();
+});
+
 // src/daemon/infrastructure/local/harness/services/commandcode/command-code-stream-reader.ts
 import { createInterface as createInterface3 } from "node:readline";
 
@@ -30054,68 +30980,68 @@ __export(exports_cursor_sdk_package, {
   formatCursorSdkLoadError: () => formatCursorSdkLoadError,
   formatCursorSdkError: () => formatCursorSdkError
 });
-import { existsSync as existsSync2, readFileSync as readFileSync4 } from "node:fs";
-import { createRequire as createRequire4 } from "node:module";
-import { dirname as dirname3, join as join8 } from "node:path";
-import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "node:url";
-function resolveChatroomCliRoot2(moduleRef = import.meta.url) {
-  const filePath = moduleRef.startsWith("file:") ? fileURLToPath3(moduleRef) : moduleRef;
-  let dir = dirname3(filePath);
-  while (dir !== dirname3(dir)) {
-    const packageJsonPath = join8(dir, "package.json");
-    if (existsSync2(packageJsonPath)) {
-      const pkg = JSON.parse(readFileSync4(packageJsonPath, "utf8"));
+import { existsSync as existsSync3, readFileSync as readFileSync5 } from "node:fs";
+import { createRequire as createRequire5 } from "node:module";
+import { dirname as dirname4, join as join9 } from "node:path";
+import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL3 } from "node:url";
+function resolveChatroomCliRoot3(moduleRef = import.meta.url) {
+  const filePath = moduleRef.startsWith("file:") ? fileURLToPath4(moduleRef) : moduleRef;
+  let dir = dirname4(filePath);
+  while (dir !== dirname4(dir)) {
+    const packageJsonPath = join9(dir, "package.json");
+    if (existsSync3(packageJsonPath)) {
+      const pkg = JSON.parse(readFileSync5(packageJsonPath, "utf8"));
       if (pkg.name === "chatroom-cli") {
         return dir;
       }
     }
-    dir = dirname3(dir);
+    dir = dirname4(dir);
   }
-  throw new CursorSdkPackageError(`Could not locate chatroom-cli package root while resolving @cursor/sdk. ${REINSTALL_HINT2}`);
+  throw new CursorSdkPackageError(`Could not locate chatroom-cli package root while resolving @cursor/sdk. ${REINSTALL_HINT3}`);
 }
-function readPinnedSdkVersion2(chatroomCliRoot) {
-  const pkg = JSON.parse(readFileSync4(join8(chatroomCliRoot, "package.json"), "utf8"));
+function readPinnedSdkVersion3(chatroomCliRoot) {
+  const pkg = JSON.parse(readFileSync5(join9(chatroomCliRoot, "package.json"), "utf8"));
   const specifier = pkg.dependencies?.["@cursor/sdk"];
   const pinned = specifier?.replace(/^[\^~>=<]+/, "").trim() ?? "";
   const match17 = pinned.match(/^(\d+\.\d+\.\d+)/);
   if (!match17) {
-    throw new CursorSdkPackageError(`chatroom-cli must pin an exact @cursor/sdk version (found "${specifier ?? "none"}"). ${REINSTALL_HINT2}`);
+    throw new CursorSdkPackageError(`chatroom-cli must pin an exact @cursor/sdk version (found "${specifier ?? "none"}"). ${REINSTALL_HINT3}`);
   }
   return match17[1];
 }
-function readInstalledSdkVersion2(entryPath) {
-  const packageJsonPath = join8(dirname3(entryPath), "..", "..", "package.json");
-  const pkg = JSON.parse(readFileSync4(packageJsonPath, "utf8"));
+function readInstalledSdkVersion3(entryPath) {
+  const packageJsonPath = join9(dirname4(entryPath), "..", "..", "package.json");
+  const pkg = JSON.parse(readFileSync5(packageJsonPath, "utf8"));
   return pkg.version;
 }
 function resolveSdkEsmImportPath(cjsEntryPath) {
   const importPath = cjsEntryPath.includes("/dist/cjs/") ? cjsEntryPath.replace("/dist/cjs/", "/dist/esm/") : cjsEntryPath;
-  if (!existsSync2(importPath)) {
-    throw new CursorSdkPackageError(`@cursor/sdk ESM entry file is missing: ${importPath}. ${REINSTALL_HINT2}`);
+  if (!existsSync3(importPath)) {
+    throw new CursorSdkPackageError(`@cursor/sdk ESM entry file is missing: ${importPath}. ${REINSTALL_HINT3}`);
   }
   return importPath;
 }
 async function importBundledCursorSdk(moduleRef = import.meta.url) {
-  const chatroomCliRoot = resolveChatroomCliRoot2(moduleRef);
-  const require3 = createRequire4(join8(chatroomCliRoot, "package.json"));
-  const pinnedVersion = readPinnedSdkVersion2(chatroomCliRoot);
+  const chatroomCliRoot = resolveChatroomCliRoot3(moduleRef);
+  const require3 = createRequire5(join9(chatroomCliRoot, "package.json"));
+  const pinnedVersion = readPinnedSdkVersion3(chatroomCliRoot);
   const entryPath = require3.resolve("@cursor/sdk", { paths: [chatroomCliRoot] });
-  const installedVersion = readInstalledSdkVersion2(entryPath);
+  const installedVersion = readInstalledSdkVersion3(entryPath);
   if (installedVersion !== pinnedVersion) {
-    throw new CursorSdkPackageError(`@cursor/sdk@${installedVersion} does not match chatroom-cli pin (${pinnedVersion}). ${REINSTALL_HINT2}`);
+    throw new CursorSdkPackageError(`@cursor/sdk@${installedVersion} does not match chatroom-cli pin (${pinnedVersion}). ${REINSTALL_HINT3}`);
   }
-  if (!existsSync2(entryPath)) {
-    throw new CursorSdkPackageError(`@cursor/sdk entry file is missing: ${entryPath}. ${REINSTALL_HINT2}`);
+  if (!existsSync3(entryPath)) {
+    throw new CursorSdkPackageError(`@cursor/sdk entry file is missing: ${entryPath}. ${REINSTALL_HINT3}`);
   }
-  const sdk = await import(pathToFileURL2(resolveSdkEsmImportPath(entryPath)).href);
+  const sdk = await import(pathToFileURL3(resolveSdkEsmImportPath(entryPath)).href);
   sdk.configureCursorSdk({ local: { useHttp1ForAgent: true } });
   return sdk;
 }
 function getBundledCursorSdkVersion(moduleRef = import.meta.url) {
-  const chatroomCliRoot = resolveChatroomCliRoot2(moduleRef);
-  const require3 = createRequire4(join8(chatroomCliRoot, "package.json"));
+  const chatroomCliRoot = resolveChatroomCliRoot3(moduleRef);
+  const require3 = createRequire5(join9(chatroomCliRoot, "package.json"));
   const entryPath = require3.resolve("@cursor/sdk", { paths: [chatroomCliRoot] });
-  return readInstalledSdkVersion2(entryPath);
+  return readInstalledSdkVersion3(entryPath);
 }
 function formatCursorSdkError(err) {
   if (err instanceof Error) {
@@ -30133,11 +31059,11 @@ function formatCursorSdkLoadError(err) {
   const message = formatCursorSdkError(err);
   const chunkMatch = message.match(/(\d+)\.index\.js/);
   if (chunkMatch) {
-    return `@cursor/sdk installation is incomplete (missing ${chunkMatch[1]}.index.js). ${REINSTALL_HINT2}`;
+    return `@cursor/sdk installation is incomplete (missing ${chunkMatch[1]}.index.js). ${REINSTALL_HINT3}`;
   }
   return message;
 }
-var REINSTALL_HINT2 = "Reinstall chatroom-cli: npm install -g chatroom-cli@latest", CursorSdkPackageError;
+var REINSTALL_HINT3 = "Reinstall chatroom-cli: npm install -g chatroom-cli@latest", CursorSdkPackageError;
 var init_cursor_sdk_package = __esm(() => {
   CursorSdkPackageError = class CursorSdkPackageError extends Error {
     code = "CURSOR_SDK_PACKAGE_INCOMPLETE";
@@ -30358,30 +31284,30 @@ function tapProcessStreamWrites(onWrite) {
 }
 
 // src/daemon/infrastructure/local/harness/services/cursor-sdk/cursor-sdk-agent-service.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
-async function loadSdk2() {
-  if (_sdkCache2)
-    return _sdkCache2;
-  if (_sdkLoadError2)
-    throw _sdkLoadError2;
+import { randomUUID as randomUUID3 } from "node:crypto";
+async function loadSdk3() {
+  if (_sdkCache3)
+    return _sdkCache3;
+  if (_sdkLoadError3)
+    throw _sdkLoadError3;
   try {
-    _sdkCache2 = await importBundledCursorSdk();
-    return _sdkCache2;
+    _sdkCache3 = await importBundledCursorSdk();
+    return _sdkCache3;
   } catch (err) {
-    _sdkLoadError2 = err;
+    _sdkLoadError3 = err;
     throw err;
   }
 }
-function getSdkPackageVersion2() {
-  if (cachedSdkPackageVersion2)
-    return cachedSdkPackageVersion2;
-  cachedSdkPackageVersion2 = getBundledCursorSdkVersion();
-  return cachedSdkPackageVersion2;
+function getSdkPackageVersion3() {
+  if (cachedSdkPackageVersion3)
+    return cachedSdkPackageVersion3;
+  cachedSdkPackageVersion3 = getBundledCursorSdkVersion();
+  return cachedSdkPackageVersion3;
 }
-function buildAgentName(context5) {
+function buildAgentName2(context5) {
   return `${context5.role}@${context5.chatroomId.slice(-6)}`;
 }
-function waitForResumeOrAbort2(session2) {
+function waitForResumeOrAbort3(session2) {
   if (session2.aborted)
     return Promise.resolve(null);
   const queued = session2.pendingResumePrompt;
@@ -30415,14 +31341,14 @@ function buildLocalAgentOptions(cwd) {
     settingSources: []
   };
 }
-function writeSpawnError2(logPrefix, err, emitLogLine) {
+function writeSpawnError3(logPrefix, err, emitLogLine) {
   const line = formatAgentLogLine(logPrefix, "spawn-error", formatCursorSdkError(err));
   process.stderr.write(`${line}
 `);
   emitLogLine?.(line);
   console.error(`[${new Date().toISOString()}] ${logPrefix} spawn-error]`, err);
 }
-var NO_SUBAGENT_DIRECTIVE2 = "NEVER spawn subagents. Follow the chatroom instructions strictly.", _sdkCache2, _sdkLoadError2, CURSOR_SDK_COMMAND = "cursor-sdk", DEFAULT_MODEL = "composer-2.5", AGENT_CREATE_TIMEOUT_MS = 60000, SEND_TIMEOUT_MS = 60000, RUN_WAIT_TIMEOUT_MS = 3600000, MODELS_LIST_TIMEOUT_MS = 60000, RUN_CANCEL_TIMEOUT_MS = 5000, cachedSdkPackageVersion2, CursorSdkAgentService;
+var NO_SUBAGENT_DIRECTIVE2 = "NEVER spawn subagents. Follow the chatroom instructions strictly.", _sdkCache3, _sdkLoadError3, CURSOR_SDK_COMMAND = "cursor-sdk", DEFAULT_MODEL = "composer-2.5", AGENT_CREATE_TIMEOUT_MS = 60000, SEND_TIMEOUT_MS = 60000, RUN_WAIT_TIMEOUT_MS = 3600000, MODELS_LIST_TIMEOUT_MS = 60000, RUN_CANCEL_TIMEOUT_MS = 5000, cachedSdkPackageVersion3, CursorSdkAgentService;
 var init_cursor_sdk_agent_service = __esm(() => {
   init_esm();
   init_cursor_sdk_package();
@@ -30441,7 +31367,7 @@ var init_cursor_sdk_agent_service = __esm(() => {
       if (!process.env.CURSOR_API_KEY?.trim())
         return false;
       try {
-        await loadSdk2();
+        await loadSdk3();
         return true;
       } catch (err) {
         console.warn(`[cursor-sdk] unavailable: ${formatCursorSdkLoadError(err)}`);
@@ -30455,7 +31381,7 @@ var init_cursor_sdk_agent_service = __esm(() => {
       });
     }
     async getVersion() {
-      const match17 = getSdkPackageVersion2().match(/^(\d+)\.(\d+)\.(\d+)/);
+      const match17 = getSdkPackageVersion3().match(/^(\d+)\.(\d+)\.(\d+)/);
       if (!match17)
         return null;
       return {
@@ -30468,7 +31394,7 @@ var init_cursor_sdk_agent_service = __esm(() => {
       if (!apiKey)
         return [];
       try {
-        const { Cursor } = await loadSdk2();
+        const { Cursor } = await loadSdk3();
         const models = await withTimeout(Cursor.models.list({ apiKey }), MODELS_LIST_TIMEOUT_MS, "Cursor.models.list");
         const listedModelIds = models.map((m) => m.id).filter((id3) => id3.length > 0);
         return normalizeCursorSdkListedModels(listedModelIds);
@@ -30546,14 +31472,14 @@ ${options.systemPrompt}` : NO_SUBAGENT_DIRECTIVE2;
 ${options.prompt}`;
       let agent;
       try {
-        const { Agent } = await loadSdk2();
+        const { Agent } = await loadSdk3();
         agent = await withTimeout(Agent.resume(stored.harnessSessionId, {
           apiKey,
           model: { id: modelId },
           local: buildLocalAgentOptions(stored.workingDir)
         }), AGENT_CREATE_TIMEOUT_MS, "Agent.resume");
       } catch (err) {
-        writeSpawnError2(logPrefix, err);
+        writeSpawnError3(logPrefix, err);
         process.stderr.write(`[${new Date().toISOString()}] role:${context5.role} daemon-resume-fallback] ${formatCursorSdkError(err)} — cold spawning
 `);
         keeper.kill();
@@ -30696,7 +31622,7 @@ ${options.prompt}`;
           while (!session2.aborted) {
             try {
               if (nextPrompt === null) {
-                const deferredResume = await waitForResumeOrAbort2(session2);
+                const deferredResume = await waitForResumeOrAbort3(session2);
                 if (deferredResume === null || session2.aborted) {
                   if (session2.aborted) {
                     exitCode = 1;
@@ -30722,7 +31648,7 @@ ${deferredResume}` : deferredResume;
                 let adapter;
                 const run3 = await withTimeout(agent.send(nextPrompt, {
                   local: { force: isFirstTurn },
-                  idempotencyKey: randomUUID2(),
+                  idempotencyKey: randomUUID3(),
                   onDelta: ({ update: update5 }) => {
                     adapter?.handleInteractionDelta(update5);
                   }
@@ -30745,7 +31671,7 @@ ${deferredResume}` : deferredResume;
                   }
                 } catch (streamErr) {
                   exitCode = 1;
-                  writeSpawnError2(logPrefix, streamErr, emitLogLine);
+                  writeSpawnError3(logPrefix, streamErr, emitLogLine);
                   break;
                 }
                 if (session2.aborted) {
@@ -30758,7 +31684,7 @@ ${deferredResume}` : deferredResume;
                   result = await withTimeout(run3.wait(), RUN_WAIT_TIMEOUT_MS, "run.wait");
                 } catch (waitErr) {
                   exitCode = 1;
-                  writeSpawnError2(logPrefix, waitErr, emitLogLine);
+                  writeSpawnError3(logPrefix, waitErr, emitLogLine);
                   break;
                 }
                 adapter.flushPendingOutput();
@@ -30778,13 +31704,13 @@ ${deferredResume}` : deferredResume;
               }
             } catch (turnErr) {
               exitCode = 1;
-              writeSpawnError2(logPrefix, turnErr, emitLogLine);
+              writeSpawnError3(logPrefix, turnErr, emitLogLine);
               break;
             }
           }
         } catch (err) {
           exitCode = 1;
-          writeSpawnError2(logPrefix, err, emitLogLine);
+          writeSpawnError3(logPrefix, err, emitLogLine);
         } finally {
           if (exited)
             return;
@@ -30796,7 +31722,7 @@ ${deferredResume}` : deferredResume;
           finishExit(exitCode, exitSignal);
         }
       })().catch((err) => {
-        writeSpawnError2(logPrefix, err, emitLogLine);
+        writeSpawnError3(logPrefix, err, emitLogLine);
         if (exited)
           return;
         exited = true;
@@ -30817,7 +31743,7 @@ ${deferredResume}` : deferredResume;
       const pid = keeper.pid;
       const context5 = options.context;
       const logPrefix = buildAgentLogPrefix("cursor-sdk", context5);
-      const agentName = buildAgentName(context5);
+      const agentName = buildAgentName2(context5);
       const modelId = resolveModelId(options.model);
       const systemPrompt = options.systemPrompt ? `${NO_SUBAGENT_DIRECTIVE2}
 
@@ -30827,7 +31753,7 @@ ${options.systemPrompt}` : NO_SUBAGENT_DIRECTIVE2;
 ${options.prompt}`;
       let agent;
       try {
-        const { Agent } = await loadSdk2();
+        const { Agent } = await loadSdk3();
         agent = await withTimeout(Agent.create({
           apiKey,
           name: agentName,
@@ -30835,7 +31761,7 @@ ${options.prompt}`;
           local: buildLocalAgentOptions(options.workingDir)
         }), AGENT_CREATE_TIMEOUT_MS, "Agent.create");
       } catch (err) {
-        writeSpawnError2(logPrefix, err);
+        writeSpawnError3(logPrefix, err);
         keeper.kill();
         this.deleteProcess(pid);
         throw err;
@@ -32883,94 +33809,6 @@ var init_opencode_session_status = __esm(() => {
   OPENCODE_SESSION_STATUSES = ["idle", "busy", "retry"];
 });
 
-// src/daemon/domain/usecase/detect-terminal-provider-error.ts
-function matchesQuotaPhrase(blob) {
-  const text = blob.toLowerCase();
-  return QUOTA_PHRASES.some((phrase) => text.includes(phrase));
-}
-function matchesStructuredProviderErrorText(blob) {
-  const text = blob.toLowerCase();
-  const hasProviderName = PROVIDER_ERROR_NAMES.some((name) => text.includes(name));
-  return hasProviderName && matchesQuotaPhrase(blob);
-}
-function matchesFatalHarnessErrorText(blob) {
-  const text = blob.toLowerCase();
-  return FATAL_HARNESS_PHRASES.some((phrase) => text.includes(phrase));
-}
-function matchesTerminalProviderErrorText(blob) {
-  return matchesQuotaPhrase(blob) || matchesStructuredProviderErrorText(blob);
-}
-function isNonRetryableHarnessFailureText(blob) {
-  return matchesTerminalProviderErrorText(blob) || matchesFatalHarnessErrorText(blob);
-}
-function isTerminalProviderError(error) {
-  if (typeof error === "string") {
-    return isNonRetryableHarnessFailureText(error);
-  }
-  if (!error || typeof error !== "object") {
-    return false;
-  }
-  const e = error;
-  if (typeof e.error === "string" && isNonRetryableHarnessFailureText(e.error)) {
-    return true;
-  }
-  const name = extractName(e);
-  const message = extractMessage(e);
-  return matchesQuotaPhrase(message) || matchesQuotaPhrase(`${name} ${message}`) || matchesFatalHarnessErrorText(message) || matchesFatalHarnessErrorText(`${name} ${message}`);
-}
-function extractName(e) {
-  const name = e.name;
-  if (typeof name === "string")
-    return name.toLowerCase();
-  const type = e.type;
-  if (typeof type === "string")
-    return type.toLowerCase();
-  return "";
-}
-function extractMessage(e) {
-  const fromData = messageFromData(e.data);
-  if (fromData)
-    return fromData;
-  if (typeof e.message === "string")
-    return e.message.toLowerCase();
-  if (typeof e.responseBody === "string")
-    return e.responseBody.toLowerCase();
-  if (typeof e.error === "string")
-    return e.error.toLowerCase();
-  if (e.error && typeof e.error === "object") {
-    return extractMessage(e.error);
-  }
-  return "";
-}
-function messageFromData(data) {
-  if (!data || typeof data !== "object")
-    return;
-  const msg = data.message;
-  return typeof msg === "string" ? msg.toLowerCase() : undefined;
-}
-var FATAL_HARNESS_PHRASES, QUOTA_PHRASES, PROVIDER_ERROR_NAMES;
-var init_detect_terminal_provider_error = __esm(() => {
-  FATAL_HARNESS_PHRASES = [
-    "failed to load model",
-    "model loading was stopped",
-    "insufficient system resources",
-    "sandboxing is not supported",
-    "disable local.sandboxoptions.enabled"
-  ];
-  QUOTA_PHRASES = [
-    "usagelimit",
-    "usage limit",
-    "enable usage from your available balance",
-    "rate limit",
-    "ratelimit",
-    "too many requests",
-    "x-ratelimit-exceeded",
-    "weekly rate limit",
-    "exceeded your weekly"
-  ];
-  PROVIDER_ERROR_NAMES = ["ai_apicallerror", "ai_retryerror"];
-});
-
 // src/daemon/infrastructure/local/harness/services/opencode-sdk/session-event-forwarder.ts
 function formatLogLine(options, kind, payload) {
   return formatTimestampedLogLine(options.role, kind, payload, options.now);
@@ -33308,27 +34146,27 @@ var init_session_event_forwarder = __esm(() => {
 });
 
 // src/daemon/infrastructure/local/harness/services/opencode-sdk/session-metadata-store.ts
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync5, writeFileSync } from "node:fs";
+import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync6, writeFileSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname4, join as join9 } from "node:path";
+import { dirname as dirname5, join as join10 } from "node:path";
 
 class FileSessionMetadataStore {
   filePath;
   constructor(filePath) {
-    this.filePath = filePath ?? join9(homedir2(), ".chatroom", "opencode-sdk-sessions.json");
+    this.filePath = filePath ?? join10(homedir2(), ".chatroom", "opencode-sdk-sessions.json");
   }
   load() {
     try {
-      if (existsSync3(this.filePath)) {
-        return JSON.parse(readFileSync5(this.filePath, "utf-8"));
+      if (existsSync4(this.filePath)) {
+        return JSON.parse(readFileSync6(this.filePath, "utf-8"));
       }
     } catch {}
     return {};
   }
   save(sessions) {
     try {
-      const dir = dirname4(this.filePath);
-      if (!existsSync3(dir)) {
+      const dir = dirname5(this.filePath);
+      if (!existsSync4(dir)) {
         mkdirSync(dir, { recursive: true });
       }
       writeFileSync(this.filePath, JSON.stringify(sessions, null, 2));
@@ -33890,47 +34728,47 @@ __export(exports_pi_sdk_package, {
   getBundledPiSdkVersion: () => getBundledPiSdkVersion,
   formatPiSdkLoadError: () => formatPiSdkLoadError
 });
-import { existsSync as existsSync4, readFileSync as readFileSync6 } from "node:fs";
-import { dirname as dirname5, join as join10 } from "node:path";
-import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL3 } from "node:url";
-function resolveChatroomCliRoot3(moduleRef = import.meta.url) {
-  const filePath = moduleRef.startsWith("file:") ? fileURLToPath4(moduleRef) : moduleRef;
-  let dir = dirname5(filePath);
-  while (dir !== dirname5(dir)) {
-    const packageJsonPath = join10(dir, "package.json");
-    if (existsSync4(packageJsonPath)) {
-      const pkg = JSON.parse(readFileSync6(packageJsonPath, "utf8"));
+import { existsSync as existsSync5, readFileSync as readFileSync7 } from "node:fs";
+import { dirname as dirname6, join as join11 } from "node:path";
+import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL4 } from "node:url";
+function resolveChatroomCliRoot4(moduleRef = import.meta.url) {
+  const filePath = moduleRef.startsWith("file:") ? fileURLToPath5(moduleRef) : moduleRef;
+  let dir = dirname6(filePath);
+  while (dir !== dirname6(dir)) {
+    const packageJsonPath = join11(dir, "package.json");
+    if (existsSync5(packageJsonPath)) {
+      const pkg = JSON.parse(readFileSync7(packageJsonPath, "utf8"));
       if (pkg.name === "chatroom-cli") {
         return dir;
       }
     }
-    dir = dirname5(dir);
+    dir = dirname6(dir);
   }
-  throw new PiSdkPackageError(`Could not locate chatroom-cli package root while resolving ${PI_CODING_AGENT_PKG}. ${REINSTALL_HINT3}`);
+  throw new PiSdkPackageError(`Could not locate chatroom-cli package root while resolving ${PI_CODING_AGENT_PKG}. ${REINSTALL_HINT4}`);
 }
-function readPinnedSdkVersion3(chatroomCliRoot) {
-  const pkg = JSON.parse(readFileSync6(join10(chatroomCliRoot, "package.json"), "utf8"));
+function readPinnedSdkVersion4(chatroomCliRoot) {
+  const pkg = JSON.parse(readFileSync7(join11(chatroomCliRoot, "package.json"), "utf8"));
   const specifier = pkg.dependencies?.[PI_CODING_AGENT_PKG];
   const pinned = specifier?.replace(/^[\^~>=<]+/, "").trim() ?? "";
   const match17 = pinned.match(/^(\d+\.\d+\.\d+)/);
   if (!match17) {
-    throw new PiSdkPackageError(`chatroom-cli must pin an exact ${PI_CODING_AGENT_PKG} version (found "${specifier ?? "none"}"). ${REINSTALL_HINT3}`);
+    throw new PiSdkPackageError(`chatroom-cli must pin an exact ${PI_CODING_AGENT_PKG} version (found "${specifier ?? "none"}"). ${REINSTALL_HINT4}`);
   }
   return match17[1];
 }
-function readInstalledSdkVersion3(entryPath) {
-  const packageJsonPath = join10(dirname5(entryPath), "..", "package.json");
-  const pkg = JSON.parse(readFileSync6(packageJsonPath, "utf8"));
+function readInstalledSdkVersion4(entryPath) {
+  const packageJsonPath = join11(dirname6(entryPath), "..", "package.json");
+  const pkg = JSON.parse(readFileSync7(packageJsonPath, "utf8"));
   return pkg.version;
 }
 function resolvePiSdkEntryPathFromNodeModules(chatroomCliRoot) {
   let dir = chatroomCliRoot;
-  while (dir !== dirname5(dir)) {
-    const entryPath = join10(dir, "node_modules", PI_CODING_AGENT_PKG, "dist", "index.js");
-    if (existsSync4(entryPath)) {
+  while (dir !== dirname6(dir)) {
+    const entryPath = join11(dir, "node_modules", PI_CODING_AGENT_PKG, "dist", "index.js");
+    if (existsSync5(entryPath)) {
       return entryPath;
     }
-    dir = dirname5(dir);
+    dir = dirname6(dir);
   }
   return;
 }
@@ -33938,32 +34776,32 @@ function resolvePiSdkEntryPath(chatroomCliRoot) {
   const resolveMeta = import.meta.resolve;
   if (typeof resolveMeta === "function") {
     try {
-      const parentUrl = pathToFileURL3(join10(chatroomCliRoot, "package.json")).href;
-      return fileURLToPath4(resolveMeta(PI_CODING_AGENT_PKG, parentUrl));
+      const parentUrl = pathToFileURL4(join11(chatroomCliRoot, "package.json")).href;
+      return fileURLToPath5(resolveMeta(PI_CODING_AGENT_PKG, parentUrl));
     } catch {}
   }
   const entryPath = resolvePiSdkEntryPathFromNodeModules(chatroomCliRoot);
   if (entryPath) {
     return entryPath;
   }
-  throw new PiSdkPackageError(`Could not resolve ${PI_CODING_AGENT_PKG} from ${chatroomCliRoot}. ${REINSTALL_HINT3}`);
+  throw new PiSdkPackageError(`Could not resolve ${PI_CODING_AGENT_PKG} from ${chatroomCliRoot}. ${REINSTALL_HINT4}`);
 }
 async function importBundledPiSdk(moduleRef = import.meta.url) {
-  const chatroomCliRoot = resolveChatroomCliRoot3(moduleRef);
-  const pinnedVersion = readPinnedSdkVersion3(chatroomCliRoot);
+  const chatroomCliRoot = resolveChatroomCliRoot4(moduleRef);
+  const pinnedVersion = readPinnedSdkVersion4(chatroomCliRoot);
   const entryPath = resolvePiSdkEntryPath(chatroomCliRoot);
-  const installedVersion = readInstalledSdkVersion3(entryPath);
+  const installedVersion = readInstalledSdkVersion4(entryPath);
   if (installedVersion !== pinnedVersion) {
-    throw new PiSdkPackageError(`${PI_CODING_AGENT_PKG}@${installedVersion} does not match chatroom-cli pin (${pinnedVersion}). ${REINSTALL_HINT3}`);
+    throw new PiSdkPackageError(`${PI_CODING_AGENT_PKG}@${installedVersion} does not match chatroom-cli pin (${pinnedVersion}). ${REINSTALL_HINT4}`);
   }
-  if (!existsSync4(entryPath)) {
-    throw new PiSdkPackageError(`${PI_CODING_AGENT_PKG} entry file is missing: ${entryPath}. ${REINSTALL_HINT3}`);
+  if (!existsSync5(entryPath)) {
+    throw new PiSdkPackageError(`${PI_CODING_AGENT_PKG} entry file is missing: ${entryPath}. ${REINSTALL_HINT4}`);
   }
-  return import(pathToFileURL3(entryPath).href);
+  return import(pathToFileURL4(entryPath).href);
 }
 function getBundledPiSdkVersion(moduleRef = import.meta.url) {
-  const chatroomCliRoot = resolveChatroomCliRoot3(moduleRef);
-  return readInstalledSdkVersion3(resolvePiSdkEntryPath(chatroomCliRoot));
+  const chatroomCliRoot = resolveChatroomCliRoot4(moduleRef);
+  return readInstalledSdkVersion4(resolvePiSdkEntryPath(chatroomCliRoot));
 }
 function formatPiSdkLoadError(err) {
   if (err instanceof PiSdkPackageError) {
@@ -33971,7 +34809,7 @@ function formatPiSdkLoadError(err) {
   }
   return err instanceof Error ? err.message : String(err);
 }
-var PI_CODING_AGENT_PKG = "@earendil-works/pi-coding-agent", REINSTALL_HINT3 = "Reinstall chatroom-cli: npm install -g chatroom-cli@latest", PiSdkPackageError;
+var PI_CODING_AGENT_PKG = "@earendil-works/pi-coding-agent", REINSTALL_HINT4 = "Reinstall chatroom-cli: npm install -g chatroom-cli@latest", PiSdkPackageError;
 var init_pi_sdk_package = __esm(() => {
   PiSdkPackageError = class PiSdkPackageError extends Error {
     code = "PI_SDK_PACKAGE_INCOMPLETE";
@@ -34090,26 +34928,26 @@ var init_pi_sdk_stream_adapter = __esm(() => {
 });
 
 // src/daemon/infrastructure/local/harness/services/pi-sdk/pi-sdk-agent-service.ts
-async function loadSdk3() {
-  if (_sdkCache3)
-    return _sdkCache3;
-  if (_sdkLoadError3)
-    throw _sdkLoadError3;
+async function loadSdk4() {
+  if (_sdkCache4)
+    return _sdkCache4;
+  if (_sdkLoadError4)
+    throw _sdkLoadError4;
   try {
-    _sdkCache3 = await importBundledPiSdk();
-    return _sdkCache3;
+    _sdkCache4 = await importBundledPiSdk();
+    return _sdkCache4;
   } catch (err) {
-    _sdkLoadError3 = err;
+    _sdkLoadError4 = err;
     throw err;
   }
 }
-function getSdkPackageVersion3() {
-  if (cachedSdkPackageVersion3)
-    return cachedSdkPackageVersion3;
-  cachedSdkPackageVersion3 = getBundledPiSdkVersion();
-  return cachedSdkPackageVersion3;
+function getSdkPackageVersion4() {
+  if (cachedSdkPackageVersion4)
+    return cachedSdkPackageVersion4;
+  cachedSdkPackageVersion4 = getBundledPiSdkVersion();
+  return cachedSdkPackageVersion4;
 }
-function waitForResumeOrAbort3(session2) {
+function waitForResumeOrAbort4(session2) {
   if (session2.aborted)
     return Promise.resolve(null);
   const queued = session2.pendingResumePrompt;
@@ -34146,14 +34984,14 @@ function resolveModel(modelRegistry, model) {
   }
   return modelRegistry.getAvailable()[0];
 }
-function writeSpawnError3(logPrefix, err, emitLogLine) {
+function writeSpawnError4(logPrefix, err, emitLogLine) {
   const line = formatAgentLogLine(logPrefix, "spawn-error", formatPiSdkLoadError(err));
   process.stderr.write(`${line}
 `);
   emitLogLine?.(line);
   console.error(`[${new Date().toISOString()}] ${logPrefix} spawn-error]`, err);
 }
-var PI_SDK_COMMAND = "pi-sdk", SESSION_CREATE_TIMEOUT_MS2 = 60000, PROMPT_TIMEOUT_MS = 3600000, _sdkCache3, _sdkLoadError3, cachedSdkPackageVersion3, PiSdkAgentService;
+var PI_SDK_COMMAND = "pi-sdk", SESSION_CREATE_TIMEOUT_MS2 = 60000, PROMPT_TIMEOUT_MS = 3600000, _sdkCache4, _sdkLoadError4, cachedSdkPackageVersion4, PiSdkAgentService;
 var init_pi_sdk_agent_service = __esm(() => {
   init_esm();
   init_pi_sdk_package();
@@ -34171,7 +35009,7 @@ var init_pi_sdk_agent_service = __esm(() => {
     }
     async isInstalled() {
       try {
-        const { ModelRegistry, AuthStorage } = await loadSdk3();
+        const { ModelRegistry, AuthStorage } = await loadSdk4();
         const authStorage = AuthStorage.create();
         const modelRegistry = ModelRegistry.create(authStorage);
         return modelRegistry.getAvailable().length > 0;
@@ -34187,7 +35025,7 @@ var init_pi_sdk_agent_service = __esm(() => {
       });
     }
     async getVersion() {
-      const match17 = getSdkPackageVersion3().match(/^(\d+)\.(\d+)\.(\d+)/);
+      const match17 = getSdkPackageVersion4().match(/^(\d+)\.(\d+)\.(\d+)/);
       if (!match17)
         return null;
       return {
@@ -34197,7 +35035,7 @@ var init_pi_sdk_agent_service = __esm(() => {
     }
     async listModels() {
       try {
-        const { ModelRegistry, AuthStorage } = await loadSdk3();
+        const { ModelRegistry, AuthStorage } = await loadSdk4();
         const authStorage = AuthStorage.create();
         const modelRegistry = ModelRegistry.create(authStorage);
         return modelRegistry.getAvailable().map((entry) => `${entry.provider}/${entry.id}`);
@@ -34262,7 +35100,7 @@ var init_pi_sdk_agent_service = __esm(() => {
         getAgentDir,
         ModelRegistry,
         SessionManager
-      } = await loadSdk3();
+      } = await loadSdk4();
       const authStorage = AuthStorage.create();
       const modelRegistry = ModelRegistry.create(authStorage);
       const resolvedModel = resolveModel(modelRegistry, args2.model);
@@ -34378,7 +35216,7 @@ var init_pi_sdk_agent_service = __esm(() => {
           while (!sdkSession.aborted) {
             try {
               if (nextPrompt === null) {
-                const deferredResume = await waitForResumeOrAbort3(sdkSession);
+                const deferredResume = await waitForResumeOrAbort4(sdkSession);
                 if (deferredResume === null || sdkSession.aborted) {
                   if (sdkSession.aborted) {
                     exitCode = 1;
@@ -34416,13 +35254,13 @@ ${deferredResume}` : deferredResume;
               nextPrompt = null;
             } catch (turnErr) {
               exitCode = 1;
-              writeSpawnError3(logPrefix, turnErr, emitLogLine);
+              writeSpawnError4(logPrefix, turnErr, emitLogLine);
               break;
             }
           }
         } catch (err) {
           exitCode = 1;
-          writeSpawnError3(logPrefix, err, emitLogLine);
+          writeSpawnError4(logPrefix, err, emitLogLine);
         } finally {
           if (exited)
             return;
@@ -34437,7 +35275,7 @@ ${deferredResume}` : deferredResume;
           finishExit(exitCode, exitSignal);
         }
       })().catch((err) => {
-        writeSpawnError3(logPrefix, err, emitLogLine);
+        writeSpawnError4(logPrefix, err, emitLogLine);
         if (exited)
           return;
         exited = true;
@@ -34500,6 +35338,7 @@ function initHarnessRegistry() {
   registerHarness(new CursorSdkAgentService);
   registerHarness(new ClaudeCodeAgentService);
   registerHarness(new ClaudeSdkAgentService);
+  registerHarness(new CodexSdkAgentService);
   registerHarness(new CommandCodeAgentService);
   registerHarness(new CopilotAgentService);
   initialized = true;
@@ -34508,6 +35347,7 @@ var initialized = false;
 var init_registry3 = __esm(() => {
   init_claude();
   init_claude_sdk();
+  init_codex_sdk();
   init_commandcode();
   init_copilot();
   init_cursor();
@@ -34597,10 +35437,10 @@ var init_detection = __esm(() => {
 var MACHINE_CONFIG_VERSION = "1";
 
 // src/infrastructure/machine/storage.ts
-import { randomBytes, randomUUID as randomUUID3 } from "node:crypto";
+import { randomBytes, randomUUID as randomUUID4 } from "node:crypto";
 import * as fs4 from "node:fs/promises";
 import { homedir as homedir3, hostname as hostname2 } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 function enqueueMachineConfigSave(task) {
   const run3 = saveChain.then(task, task);
   saveChain = run3.catch(() => {
@@ -34609,14 +35449,14 @@ function enqueueMachineConfigSave(task) {
   return run3;
 }
 function chatroomConfigDir() {
-  return join11(homedir3(), ".chatroom");
+  return join12(homedir3(), ".chatroom");
 }
 async function ensureConfigDir2() {
   const dir = chatroomConfigDir();
   await fs4.mkdir(dir, { recursive: true, mode: 448 });
 }
 function getMachineConfigPath() {
-  return join11(chatroomConfigDir(), MACHINE_FILE);
+  return join12(chatroomConfigDir(), MACHINE_FILE);
 }
 async function loadConfigFile() {
   const configPath = getMachineConfigPath();
@@ -34670,7 +35510,7 @@ async function createNewEndpointConfig() {
   const now = new Date().toISOString();
   const availableHarnesses = await detectAvailableHarnesses();
   return {
-    machineId: randomUUID3(),
+    machineId: randomUUID4(),
     hostname: hostname2(),
     os: process.platform,
     registeredAt: now,
@@ -34718,7 +35558,7 @@ var init_storage2 = __esm(() => {
 // src/infrastructure/machine/daemon-state.ts
 import * as fs5 from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 function agentKey(chatroomId, role) {
   return `${chatroomId}/${role}`;
 }
@@ -34726,7 +35566,7 @@ async function ensureStateDir() {
   await fs5.mkdir(STATE_DIR, { recursive: true, mode: 448 });
 }
 function stateFilePath(machineId) {
-  return join12(STATE_DIR, `${machineId}.json`);
+  return join13(STATE_DIR, `${machineId}.json`);
 }
 async function loadDaemonState(machineId) {
   const filePath = stateFilePath(machineId);
@@ -34808,8 +35648,8 @@ async function loadEventCursor(machineId) {
 }
 var CHATROOM_DIR2, STATE_DIR, STATE_VERSION = "1";
 var init_daemon_state = __esm(() => {
-  CHATROOM_DIR2 = join12(homedir4(), ".chatroom");
-  STATE_DIR = join12(CHATROOM_DIR2, "machines", "state");
+  CHATROOM_DIR2 = join13(homedir4(), ".chatroom");
+  STATE_DIR = join13(CHATROOM_DIR2, "machines", "state");
 });
 
 // src/infrastructure/machine/index.ts
@@ -35251,9 +36091,9 @@ var init_init = __esm(() => {
 });
 
 // src/tools/output.ts
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 function resolveChatroomDir(workingDir) {
-  return join13(workingDir, CHATROOM_DIR3);
+  return join14(workingDir, CHATROOM_DIR3);
 }
 async function ensureChatroomDir(deps, workingDir) {
   const dir = resolveChatroomDir(workingDir);
@@ -35261,7 +36101,7 @@ async function ensureChatroomDir(deps, workingDir) {
   return dir;
 }
 async function ensureGitignore(deps, workingDir) {
-  const gitignorePath = join13(workingDir, ".gitignore");
+  const gitignorePath = join14(workingDir, ".gitignore");
   const entry = CHATROOM_DIR3;
   let content = "";
   try {
@@ -35291,7 +36131,7 @@ function formatOutputTimestamp(date = new Date) {
 function generateOutputPath(workingDir, toolName, extension, date) {
   const timestamp = formatOutputTimestamp(date);
   const filename = `${toolName}-${timestamp}.${extension}`;
-  return join13(resolveChatroomDir(workingDir), filename);
+  return join14(resolveChatroomDir(workingDir), filename);
 }
 var CHATROOM_DIR3 = ".chatroom";
 var init_output = () => {};
@@ -36100,8 +36940,8 @@ var init_index_esm = __esm(() => {
       var ENVIRONMENT_IS_NODE = typeof process == "object" && process.versions?.node && process.type != "renderer";
       var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
       if (ENVIRONMENT_IS_NODE) {
-        const { createRequire: createRequire5 } = await import("module");
-        var require3 = createRequire5(import.meta.url);
+        const { createRequire: createRequire6 } = await import("module");
+        var require3 = createRequire6(import.meta.url);
       }
       var thisProgram = "./this.program";
       var _scriptName = import.meta.url;
@@ -41307,7 +42147,7 @@ var require_filesystem = __commonJS((exports, module) => {
   var LDD_PATH = "/usr/bin/ldd";
   var SELF_PATH = "/proc/self/exe";
   var MAX_LENGTH = 2048;
-  var readFileSync7 = (path2) => {
+  var readFileSync8 = (path2) => {
     const fd = fs6.openSync(path2, "r");
     const buffer = Buffer.alloc(MAX_LENGTH);
     const bytesRead = fs6.readSync(fd, buffer, 0, MAX_LENGTH, 0);
@@ -41330,7 +42170,7 @@ var require_filesystem = __commonJS((exports, module) => {
   module.exports = {
     LDD_PATH,
     SELF_PATH,
-    readFileSync: readFileSync7,
+    readFileSync: readFileSync8,
     readFile: readFile4
   };
 });
@@ -41373,7 +42213,7 @@ var require_elf = __commonJS((exports, module) => {
 var require_detect_libc = __commonJS((exports, module) => {
   var childProcess = __require("child_process");
   var { isLinux, getReport } = require_process();
-  var { LDD_PATH, SELF_PATH, readFile: readFile4, readFileSync: readFileSync7 } = require_filesystem();
+  var { LDD_PATH, SELF_PATH, readFile: readFile4, readFileSync: readFileSync8 } = require_filesystem();
   var { interpreterPath } = require_elf();
   var cachedFamilyInterpreter;
   var cachedFamilyFilesystem;
@@ -41464,7 +42304,7 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     cachedFamilyFilesystem = null;
     try {
-      const lddContent = readFileSync7(LDD_PATH);
+      const lddContent = readFileSync8(LDD_PATH);
       cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
     } catch (e) {}
     return cachedFamilyFilesystem;
@@ -41487,7 +42327,7 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     cachedFamilyInterpreter = null;
     try {
-      const selfContent = readFileSync7(SELF_PATH);
+      const selfContent = readFileSync8(SELF_PATH);
       const path2 = interpreterPath(selfContent);
       cachedFamilyInterpreter = familyFromInterpreterPath(path2);
     } catch (e) {}
@@ -41549,7 +42389,7 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     cachedVersionFilesystem = null;
     try {
-      const lddContent = readFileSync7(LDD_PATH);
+      const lddContent = readFileSync8(LDD_PATH);
       const versionMatch = lddContent.match(RE_GLIBC_VERSION);
       if (versionMatch) {
         cachedVersionFilesystem = versionMatch[1];
@@ -47744,12 +48584,12 @@ var init_pdfium_renderer = __esm(() => {
 });
 
 // ../../node_modules/.pnpm/@llamaindex+liteparse@1.5.3/node_modules/@llamaindex/liteparse/dist/src/engines/pdf/pdfjsImporter.js
-import { fileURLToPath as fileURLToPath5 } from "node:url";
-import { dirname as dirname6 } from "node:path";
+import { fileURLToPath as fileURLToPath6 } from "node:url";
+import { dirname as dirname7 } from "node:path";
 async function importPdfJs() {
   const pdfUrl = new URL("../../vendor/pdfjs/pdf.mjs", import.meta.url);
   const pdfjs = await import(pdfUrl.href);
-  const dirPath = dirname6(fileURLToPath5(pdfUrl));
+  const dirPath = dirname7(fileURLToPath6(pdfUrl));
   return {
     fn: pdfjs.getDocument,
     dir: dirPath
@@ -69766,7 +70606,7 @@ function applyMarkupTags(markup, text) {
 // ../../node_modules/.pnpm/@llamaindex+liteparse@1.5.3/node_modules/@llamaindex/liteparse/dist/src/processing/gridDebugLogger.js
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
 import { mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname7 } from "path";
+import { dirname as dirname8 } from "path";
 
 class GridDebugLogger {
   config;
@@ -70093,14 +70933,14 @@ class GridDebugLogger {
   flushSync() {
     if (!this.config.outputPath || this.entries.length === 0)
       return;
-    mkdirSync2(dirname7(this.config.outputPath), { recursive: true });
+    mkdirSync2(dirname8(this.config.outputPath), { recursive: true });
     writeFileSync2(this.config.outputPath, this.formatEntries(), "utf-8");
     this.entries = [];
   }
   async flush() {
     if (!this.config.outputPath || this.entries.length === 0)
       return;
-    await mkdir4(dirname7(this.config.outputPath), { recursive: true });
+    await mkdir4(dirname8(this.config.outputPath), { recursive: true });
     await writeFile4(this.config.outputPath, this.formatEntries(), "utf-8");
     this.entries = [];
   }
@@ -76841,6 +77681,14 @@ var init_new = __esm(() => {
   init_view_template();
 });
 
+// ../../services/backend/prompts/cli/context/read.ts
+function contextReadCommand(params = {}) {
+  const prefix = params.cliEnvPrefix ?? "";
+  const chatroomId = params.chatroomId ?? "<chatroom-id>";
+  const role = params.role ?? "<role>";
+  return `${prefix}chatroom context read --chatroom-id="${chatroomId}" --role="${role}"`;
+}
+
 // ../../services/backend/prompts/cli/task-started/main-prompt.ts
 var init_main_prompt = __esm(() => {
   init_new();
@@ -77550,6 +78398,218 @@ var init_get_next_task = __esm(() => {
   init_get_next_task_session_service();
 });
 
+// ../../services/backend/src/domain/entities/team-presets.ts
+function getTeamPreset(teamId) {
+  return TEAM_PRESETS[teamId];
+}
+function listTeamPresetIds() {
+  return Object.keys(TEAM_PRESETS);
+}
+var TEAM_PRESETS, DEFAULT_TEAM_PRESET_ID = "duo";
+var init_team_presets = __esm(() => {
+  TEAM_PRESETS = {
+    duo: {
+      name: "Duo",
+      description: "A planner and builder working as a pair, planner as coordinator",
+      roles: ["planner", "builder"],
+      entryPoint: "planner"
+    },
+    solo: {
+      name: "Solo",
+      description: "A single agent working independently",
+      roles: ["solo"],
+      entryPoint: "solo"
+    }
+  };
+});
+
+// src/commands/team/index.ts
+var exports_team = {};
+__export(exports_team, {
+  setTeam: () => setTeam,
+  listTeamPresets: () => listTeamPresets,
+  getTeam: () => getTeam
+});
+async function createDefaultDeps8() {
+  const client4 = await getConvexClient();
+  return {
+    backend: {
+      mutation: (endpoint, args2) => client4.mutation(endpoint, args2),
+      query: (endpoint, args2) => client4.query(endpoint, args2)
+    },
+    session: { getSessionId }
+  };
+}
+async function requireSession(deps) {
+  const sessionId = await deps.session.getSessionId();
+  if (!sessionId)
+    throw new Error("Not authenticated. Please run: chatroom auth login");
+  return sessionId;
+}
+async function listTeamPresets() {
+  console.log("Team presets:");
+  const teamIds = [
+    DEFAULT_TEAM_PRESET_ID,
+    ...listTeamPresetIds().filter((teamId) => teamId !== DEFAULT_TEAM_PRESET_ID)
+  ];
+  for (const teamId of teamIds) {
+    const preset = TEAM_PRESETS[teamId];
+    if (!preset)
+      continue;
+    console.log(`  ${teamId} — ${preset.name} (${preset.roles.join(", ")}) entry: ${preset.entryPoint}`);
+  }
+}
+async function getTeam(chatroomId, deps) {
+  const d = deps ?? await createDefaultDeps8();
+  const sessionId = await requireSession(d);
+  const team = await d.backend.query(api.chatrooms.get, {
+    sessionId,
+    chatroomId
+  });
+  if (!team)
+    throw new Error(`Chatroom not found or access denied: ${chatroomId}`);
+  console.log(`Current team: ${team.teamId} (${team.teamName})`);
+  console.log(`  Roles: ${team.teamRoles.join(", ")}`);
+  console.log(`  Entry point: ${team.teamEntryPoint}`);
+}
+async function setTeam(chatroomId, teamId, deps) {
+  const preset = getTeamPreset(teamId);
+  if (!preset) {
+    throw new Error(`Unknown team preset "${teamId}". Available presets: ${listTeamPresetIds().join(", ")}`);
+  }
+  const d = deps ?? await createDefaultDeps8();
+  const sessionId = await requireSession(d);
+  await d.backend.mutation(api.chatrooms.updateTeam, {
+    sessionId,
+    chatroomId,
+    teamId,
+    teamName: preset.name,
+    teamRoles: preset.roles,
+    teamEntryPoint: preset.entryPoint
+  });
+  console.log(`✅ Team set to ${teamId} (${preset.name})`);
+  console.log(`  Roles: ${preset.roles.join(", ")}`);
+  console.log(`  Entry point: ${preset.entryPoint}`);
+}
+var init_team = __esm(() => {
+  init_team_presets();
+  init_api3();
+  init_storage();
+  init_client2();
+});
+
+// src/commands/agent/index.ts
+var exports_agent = {};
+__export(exports_agent, {
+  startAgent: () => startAgent,
+  setAgentConfig: () => setAgentConfig,
+  getAgentConfig: () => getAgentConfig
+});
+async function createDefaultDeps9() {
+  const client4 = await getConvexClient();
+  return {
+    backend: {
+      mutation: (endpoint, args2) => client4.mutation(endpoint, args2),
+      query: (endpoint, args2) => client4.query(endpoint, args2)
+    },
+    session: { getSessionId },
+    machine: { getMachineId, loadMachineConfig }
+  };
+}
+async function requireSession2(deps) {
+  const sessionId = await deps.session.getSessionId();
+  if (!sessionId)
+    throw new Error("Not authenticated. Please run: chatroom auth login");
+  return sessionId;
+}
+async function requireMachineId(deps) {
+  const machineId = await deps.machine.getMachineId();
+  if (!machineId)
+    throw new Error("Run machine daemon start first");
+  return machineId;
+}
+function configuredWorkingDir(config3) {
+  return config3?.workingDir;
+}
+async function getConfigs(deps, sessionId, chatroomId) {
+  return await deps.backend.query(api.machines.getTeamAgentConfigs, {
+    sessionId,
+    chatroomId
+  });
+}
+async function getAgentConfig(chatroomId, role, deps) {
+  const d = deps ?? await createDefaultDeps9();
+  const sessionId = await requireSession2(d);
+  const config3 = (await getConfigs(d, sessionId, chatroomId)).find((candidate) => candidate.role.toLowerCase() === role.toLowerCase());
+  if (!config3)
+    throw new Error(`No agent config found for role "${role}"`);
+  console.log(`Agent config: ${role}`);
+  console.log(`  Harness: ${config3.agentHarness ?? "(unset)"}`);
+  console.log(`  Model: ${config3.model ?? "(unset)"}`);
+  console.log(`  Working directory: ${config3.workingDir ?? "(unset)"}`);
+  console.log(`  Machine ID: ${config3.machineId ?? "(unset)"}`);
+  console.log(`  Desired state: ${config3.desiredState ?? "(unset)"}`);
+}
+async function setAgentConfig(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps9();
+  const sessionId = await requireSession2(d);
+  const machineId = await requireMachineId(d);
+  const machineConfig = await d.machine.loadMachineConfig();
+  const workingDir = options.workingDir ?? configuredWorkingDir(machineConfig) ?? process.cwd();
+  await d.backend.mutation(api.machines.saveTeamAgentConfig, {
+    sessionId,
+    chatroomId,
+    role: options.role,
+    type: "remote",
+    machineId,
+    agentHarness: options.harness,
+    model: options.model,
+    workingDir
+  });
+  console.log(`✅ Agent config saved for ${options.role}`);
+  console.log(`  Harness: ${options.harness}`);
+  console.log(`  Model: ${options.model}`);
+  console.log(`  Working directory: ${workingDir}`);
+  console.log(`  Machine ID: ${machineId}`);
+}
+async function startAgent(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps9();
+  const sessionId = await requireSession2(d);
+  const machineId = await requireMachineId(d);
+  const configs = await getConfigs(d, sessionId, chatroomId);
+  const existing = configs.find((candidate) => candidate.role.toLowerCase() === options.role.toLowerCase());
+  const machineConfig = await d.machine.loadMachineConfig();
+  const harness = options.harness ?? existing?.agentHarness;
+  const model = options.model ?? existing?.model;
+  const workingDir = options.workingDir ?? existing?.workingDir ?? configuredWorkingDir(machineConfig) ?? process.cwd();
+  if (!harness || !model) {
+    throw new Error("Harness and model are required; provide flags or configure the agent first");
+  }
+  await d.backend.mutation(api.machines.sendCommand, {
+    sessionId,
+    machineId,
+    type: "start-agent",
+    payload: {
+      chatroomId,
+      role: options.role,
+      agentHarness: harness,
+      model,
+      workingDir
+    }
+  });
+  console.log(`✅ Start command sent for ${options.role}`);
+  console.log(`  Harness: ${harness}`);
+  console.log(`  Model: ${model}`);
+  console.log(`  Working directory: ${workingDir}`);
+  console.log(`  Machine ID: ${machineId}`);
+}
+var init_agent = __esm(() => {
+  init_api3();
+  init_storage();
+  init_client2();
+  init_storage2();
+});
+
 // ../../services/backend/prompts/native/handoff-visibility.ts
 function recipientLabel(toRole) {
   return toRole.toLowerCase() === "user" ? "The user" : `The \`${toRole}\` agent`;
@@ -78001,14 +79061,6 @@ After the enhancer returns **advisory** feedback, you make the **final call**
 }
 var init_planner_to_enhancer = () => {};
 
-// ../../services/backend/prompts/cli/context/read.ts
-function contextReadCommand(params = {}) {
-  const prefix = params.cliEnvPrefix ?? "";
-  const chatroomId = params.chatroomId ?? "<chatroom-id>";
-  const role = params.role ?? "<role>";
-  return `${prefix}chatroom context read --chatroom-id="${chatroomId}" --role="${role}"`;
-}
-
 // ../../services/backend/prompts/utils/context-disclosure.ts
 function getContextReadDisclosureComment(params = {}) {
   const command = contextReadCommand(params);
@@ -78036,14 +79088,27 @@ function messagesAnchorCommand(params = {}) {
   const role = params.role ?? "<role>";
   return `${prefix}chatroom messages anchor --chatroom-id="${chatroomId}" --role="${role}"`;
 }
+function messagesDownloadSinceCommand(params = {}) {
+  const prefix = params.cliEnvPrefix ?? "";
+  const chatroomId = params.chatroomId ?? "<chatroom-id>";
+  const role = params.role ?? "<role>";
+  const sinceMessageId = params.sinceMessageId ?? "<id>";
+  const limit = params.limit ?? 100;
+  return `${prefix}chatroom messages download --chatroom-id="${chatroomId}" --role="${role}" --since-message-id="${sinceMessageId}" --limit=${limit}`;
+}
 function getProofOfVerificationComment(params = {}) {
   const anchorCmd = messagesAnchorCommand(params);
+  const downloadCmd = messagesDownloadSinceCommand({
+    ...params,
+    sinceMessageId: "<from-anchor>",
+    limit: 100
+  });
   return `<!-- Entry-point proof-of-completion workflow — run before filling this section:
 1. \`${anchorCmd}\` — locate the user's last message (and prior user messages for context)
-2. \`messages download --since-message-id=<id>\` — download grep-friendly history since anchor; read handoffs and goals
+2. \`${downloadCmd}\` — download grep-friendly history since anchor; read handoffs and goals
 3. If the user's last message was terse (e.g. "do it", "raise a PR"), review prior user messages from anchor output and widen --limit before validating
 4. Validate commits/PRs against ALL requirements — not just the last slice. Incomplete → rework; do NOT hand off to user.
-Then: ${anchorCmd} → messages download --since-message-id=<id> from anchor output -->`;
+Then: \`${anchorCmd}\` → \`${downloadCmd}\` (use the message ID from anchor output as --since-message-id) -->`;
 }
 function getEntryPointProofOfCompletionVerificationBlock(params = {}) {
   return `${getProofOfVerificationComment(params)}
@@ -78671,6 +79736,22 @@ var init_claude_config = __esm(() => {
   };
 });
 
+// ../../services/backend/src/domain/entities/harness/codex-sdk.config.ts
+var codexSdkCapabilities;
+var init_codex_sdk_config = __esm(() => {
+  codexSdkCapabilities = {
+    runtimeKind: "sdk",
+    supportsDaemonMemoryResume: true,
+    supportsNativeIntegration: true,
+    lifecycle: {
+      turnCompleted: true,
+      outputActivity: true,
+      processExited: true
+    },
+    wireEvents: ["sdk.codex.event"]
+  };
+});
+
 // ../../services/backend/src/domain/entities/harness/commandcode.config.ts
 var commandcodeCapabilities;
 var init_commandcode_config = __esm(() => {
@@ -78820,6 +79901,7 @@ var HARNESS_CAPABILITIES;
 var init_types = __esm(() => {
   init_claude_sdk_config();
   init_claude_config();
+  init_codex_sdk_config();
   init_commandcode_config();
   init_copilot_config();
   init_cursor_sdk_config();
@@ -78831,6 +79913,7 @@ var init_types = __esm(() => {
   HARNESS_CAPABILITIES = {
     claude: claudeCapabilities,
     "claude-sdk": claudeSdkCapabilities,
+    "codex-sdk": codexSdkCapabilities,
     commandcode: commandcodeCapabilities,
     copilot: copilotCapabilities,
     cursor: cursorCapabilities,
@@ -78908,7 +79991,7 @@ __export(exports_handoff, {
   handoffEffect: () => handoffEffect,
   handoff: () => handoff
 });
-async function createDefaultDeps8() {
+async function createDefaultDeps10() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -78985,7 +80068,7 @@ ${err.cause instanceof Error ? err.cause.message : String(err.cause)}`);
   });
 }
 async function handoff(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps8();
+  const d = deps ?? await createDefaultDeps10();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(handoffEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleHandoffError(err)), exports_Effect.provide(layer)));
 }
@@ -79048,7 +80131,7 @@ var exports_complete = {};
 __export(exports_complete, {
   agenticQueryComplete: () => agenticQueryComplete
 });
-async function createDefaultDeps9() {
+async function createDefaultDeps11() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -79080,7 +80163,7 @@ ${err.errorData?.message ?? err.cause.message}`);
   });
 }
 async function agenticQueryComplete(chatroomId, options) {
-  const deps = await createDefaultDeps9();
+  const deps = await createDefaultDeps11();
   await exports_Effect.runPromise(agenticQueryCompleteEffect(chatroomId, options).pipe(exports_Effect.provide(commandServicesLayerFromDeps(deps)), exports_Effect.catchAll(handleCompleteError)));
 }
 var agenticQueryCompleteEffect = (chatroomId, options) => exports_Effect.gen(function* () {
@@ -79125,7 +80208,7 @@ var exports_complete2 = {};
 __export(exports_complete2, {
   enhancerComplete: () => enhancerComplete
 });
-async function createDefaultDeps10() {
+async function createDefaultDeps12() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -79157,7 +80240,7 @@ ${err.errorData?.message ?? err.cause.message}`);
   });
 }
 async function enhancerComplete(chatroomId, options) {
-  const deps = await createDefaultDeps10();
+  const deps = await createDefaultDeps12();
   await exports_Effect.runPromise(enhancerCompleteEffect(chatroomId, options).pipe(exports_Effect.provide(commandServicesLayerFromDeps(deps)), exports_Effect.catchAll(handleCompleteError2)));
 }
 var enhancerCompleteEffect = (chatroomId, options) => exports_Effect.gen(function* () {
@@ -79305,7 +80388,7 @@ function buildBaseLayer(d) {
 function buildFsLayer(fs11) {
   return fs11 ? BacklogFsServiceFrom(fs11) : BacklogFsServiceLive;
 }
-async function createDefaultDeps11() {
+async function createDefaultDeps13() {
   const client4 = await getConvexClient();
   const fs11 = await import("node:fs/promises");
   return {
@@ -79361,51 +80444,51 @@ function computeContentHash(content) {
   return createHash("sha256").update(content).digest("hex");
 }
 async function listBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps11();
+  const d = deps ?? await createDefaultDeps13();
   await exports_Effect.runPromise(listBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function addBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps11();
+  const d = deps ?? await createDefaultDeps13();
   await exports_Effect.runPromise(addBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function completeBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps11();
+  const d = deps ?? await createDefaultDeps13();
   await exports_Effect.runPromise(completeBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function reopenBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps11();
+  const d = deps ?? await createDefaultDeps13();
   await exports_Effect.runPromise(reopenBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function patchBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps11();
+  const d = deps ?? await createDefaultDeps13();
   await exports_Effect.runPromise(patchBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function scoreBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps11();
+  const d = deps ?? await createDefaultDeps13();
   await exports_Effect.runPromise(scoreBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function markForReviewBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps11();
+  const d = deps ?? await createDefaultDeps13();
   await exports_Effect.runPromise(markForReviewBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function historyBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps11();
+  const d = deps ?? await createDefaultDeps13();
   await exports_Effect.runPromise(historyBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function updateBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps11();
+  const d = deps ?? await createDefaultDeps13();
   await exports_Effect.runPromise(updateBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function closeBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps11();
+  const d = deps ?? await createDefaultDeps13();
   await exports_Effect.runPromise(closeBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function deleteBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps11();
+  const d = deps ?? await createDefaultDeps13();
   await exports_Effect.runPromise(deleteBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function exportBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps11();
+  const d = deps ?? await createDefaultDeps13();
   if (!d.fs) {
     console.error("❌ File system operations not available");
     process.exit(1);
@@ -79414,7 +80497,7 @@ async function exportBacklog(chatroomId, options, deps) {
   await exports_Effect.runPromise(exportBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(exports_Layer.merge(buildBaseLayer(d), buildFsLayer(d.fs)))));
 }
 async function importBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps11();
+  const d = deps ?? await createDefaultDeps13();
   if (!d.fs) {
     console.error("❌ File system operations not available");
     process.exit(1);
@@ -80201,7 +81284,7 @@ __export(exports_read, {
   taskReadEffect: () => taskReadEffect,
   taskRead: () => taskRead
 });
-async function createDefaultDeps12() {
+async function createDefaultDeps14() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -80243,7 +81326,7 @@ function handleTaskReadError(err) {
   });
 }
 async function taskRead(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps12();
+  const d = deps ?? await createDefaultDeps14();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(taskReadEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleTaskReadError(err)), exports_Effect.provide(layer)));
 }
@@ -80334,7 +81417,7 @@ __export(exports_skill, {
   activateSkillEffect: () => activateSkillEffect,
   activateSkill: () => activateSkill
 });
-async function createDefaultDeps13() {
+async function createDefaultDeps15() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -80403,12 +81486,12 @@ function handleActivateSkillError(err) {
   });
 }
 async function listSkills(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps13();
+  const d = deps ?? await createDefaultDeps15();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(listSkillsEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleListSkillsError(err)), exports_Effect.provide(layer)));
 }
 async function activateSkill(chatroomId, skillId, options, deps) {
-  const d = deps ?? await createDefaultDeps13();
+  const d = deps ?? await createDefaultDeps15();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(activateSkillEffect(chatroomId, skillId, options).pipe(exports_Effect.catchAll((err) => handleActivateSkillError(err)), exports_Effect.provide(layer)));
 }
@@ -80478,6 +81561,59 @@ var init_skill = __esm(() => {
   init_convex_error();
 });
 
+// src/commands/messages/send.ts
+var exports_send = {};
+__export(exports_send, {
+  sendUserMessage: () => sendUserMessage
+});
+async function createDefaultDeps16() {
+  const client4 = await getConvexClient();
+  return {
+    backend: {
+      mutation: (endpoint, args2) => client4.mutation(endpoint, args2),
+      query: (endpoint, args2) => client4.query(endpoint, args2)
+    },
+    session: { getSessionId }
+  };
+}
+async function requireSession3(deps) {
+  const sessionId = await deps.session.getSessionId();
+  if (!sessionId)
+    throw new Error("Not authenticated. Please run: chatroom auth login");
+  return sessionId;
+}
+async function sendUserMessage(chatroomId, options, deps) {
+  if (!options.content.trim())
+    throw new Error("Message content cannot be empty");
+  const d = deps ?? await createDefaultDeps16();
+  const sessionId = await requireSession3(d);
+  const chatroom = await d.backend.query(api.chatrooms.get, {
+    sessionId,
+    chatroomId
+  });
+  if (!chatroom)
+    throw new Error(`Chatroom not found or access denied: ${chatroomId}`);
+  const targetRole = options.targetRole ?? chatroom.teamEntryPoint;
+  if (!targetRole)
+    throw new Error("Chatroom has no team entry point");
+  const messageId = await d.backend.mutation(api.messages.sendMessage, {
+    sessionId,
+    chatroomId,
+    senderRole: "user",
+    content: options.content,
+    targetRole,
+    type: "message"
+  });
+  console.log(`✅ Message sent to ${targetRole}`);
+  console.log(`  Message ID: ${messageId}`);
+  console.log("  Check task status with: chatroom messages list");
+}
+var init_send = __esm(() => {
+  init_api3();
+  init_storage();
+  init_client2();
+});
+
 // src/commands/messages/messages-fs-service.ts
 import * as nodeFs2 from "node:fs/promises";
 function messageFilename(msg) {
@@ -80845,7 +81981,7 @@ __export(exports_messages, {
   anchorMessagesEffect: () => anchorMessagesEffect,
   anchorMessages: () => anchorMessages
 });
-async function createDefaultDeps14() {
+async function createDefaultDeps17() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -80905,12 +82041,12 @@ function handleMessagesError(err) {
   });
 }
 async function listBySenderRole(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps14();
+  const d = deps ?? await createDefaultDeps17();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(listBySenderRoleEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleMessagesError(err)), exports_Effect.provide(layer)));
 }
 async function listSinceMessage(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps14();
+  const d = deps ?? await createDefaultDeps17();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(listSinceMessageEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleMessagesError(err)), exports_Effect.provide(layer)));
 }
@@ -81036,7 +82172,7 @@ __export(exports_context2, {
   inspectContextEffect: () => inspectContextEffect,
   inspectContext: () => inspectContext
 });
-async function createDefaultDeps15() {
+async function createDefaultDeps18() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -81077,17 +82213,17 @@ function handleContextError(err) {
   });
 }
 async function readContext(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps15();
+  const d = deps ?? await createDefaultDeps18();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(readContextEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleContextError(err)), exports_Effect.provide(layer)));
 }
 async function newContext(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps15();
+  const d = deps ?? await createDefaultDeps18();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(newContextEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleContextError(err)), exports_Effect.provide(layer)));
 }
 async function listContexts(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps15();
+  const d = deps ?? await createDefaultDeps18();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(listContextsEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleContextError(err)), exports_Effect.provide(layer)));
 }
@@ -81095,7 +82231,7 @@ function viewTemplate() {
   return getContextViewTemplate();
 }
 async function inspectContext(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps15();
+  const d = deps ?? await createDefaultDeps18();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(inspectContextEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleContextError(err)), exports_Effect.provide(layer)));
 }
@@ -81335,7 +82471,7 @@ __export(exports_guidelines, {
   listGuidelineTypesEffect: () => listGuidelineTypesEffect,
   listGuidelineTypes: () => listGuidelineTypes
 });
-async function createDefaultDeps16() {
+async function createDefaultDeps19() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -81376,12 +82512,12 @@ function handleListGuidelineTypesError(err) {
   });
 }
 async function viewGuidelines(options, deps) {
-  const d = deps ?? await createDefaultDeps16();
+  const d = deps ?? await createDefaultDeps19();
   const layer = layerFromDeps7(d);
   await exports_Effect.runPromise(viewGuidelinesEffect(options).pipe(exports_Effect.catchAll((err) => handleViewGuidelinesError(err)), exports_Effect.provide(layer)));
 }
 async function listGuidelineTypes(deps) {
-  const d = deps ?? await createDefaultDeps16();
+  const d = deps ?? await createDefaultDeps19();
   const layer = layerFromDeps7(d);
   await exports_Effect.runPromise(listGuidelineTypesEffect().pipe(exports_Effect.catchAll((err) => handleListGuidelineTypesError(err)), exports_Effect.provide(layer)));
 }
@@ -81451,7 +82587,7 @@ __export(exports_artifact, {
   createArtifactEffect: () => createArtifactEffect,
   createArtifact: () => createArtifact
 });
-async function createDefaultDeps17() {
+async function createDefaultDeps20() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -81473,19 +82609,19 @@ function handleArtifactError(err) {
   });
 }
 async function createArtifact(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps17();
+  const d = deps ?? await createDefaultDeps20();
   const layer = commandServicesLayerFromDeps(d);
   return exports_Effect.runPromise(createArtifactEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleArtifactError(err).pipe(exports_Effect.map(() => {
     return;
   }))), exports_Effect.provide(layer)));
 }
 async function viewArtifact(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps17();
+  const d = deps ?? await createDefaultDeps20();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(viewArtifactEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleArtifactError(err)), exports_Effect.provide(layer)));
 }
 async function viewManyArtifacts(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps17();
+  const d = deps ?? await createDefaultDeps20();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(viewManyArtifactsEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleArtifactError(err)), exports_Effect.provide(layer)));
 }
@@ -81835,7 +82971,7 @@ __export(exports_telegram, {
   sendMessageEffect: () => sendMessageEffect,
   sendMessage: () => sendMessage
 });
-async function createDefaultDeps18() {
+async function createDefaultDeps21() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -81917,7 +83053,7 @@ ${err.cause.message}`);
   });
 }
 async function sendMessage(options, deps) {
-  const d = deps ?? await createDefaultDeps18();
+  const d = deps ?? await createDefaultDeps21();
   const layer = layerFromDeps8(d);
   await exports_Effect.runPromise(sendMessageEffect(options).pipe(exports_Effect.catchAll((err) => handleSendMessageError(err)), exports_Effect.provide(layer)));
 }
@@ -82053,6 +83189,11 @@ var init_daemon_layers = __esm(() => {
   init_process();
 });
 
+// src/daemon/entry/daemon-types.ts
+function asConvexSessionId(sessionId) {
+  return sessionId;
+}
+
 // src/daemon/entry/events/event-bus.ts
 class DaemonEventBus {
   listeners = new Map;
@@ -82180,35 +83321,35 @@ var init_daemon_startup_log = __esm(() => {
 import { createHash as createHash2 } from "node:crypto";
 import {
   appendFileSync,
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   mkdirSync as mkdirSync4,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   renameSync,
   unlinkSync,
   writeFileSync as writeFileSync3
 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 function getUrlHash() {
   const url2 = getConvexUrl();
   return createHash2("sha256").update(url2).digest("hex").substring(0, 8);
 }
 function getChildPidsFilePath() {
-  const dir = join16(homedir5(), ".chatroom");
-  return join16(dir, `daemon-children-${getUrlHash()}.pids`);
+  const dir = join17(homedir5(), ".chatroom");
+  return join17(dir, `daemon-children-${getUrlHash()}.pids`);
 }
 function ensureChatroomDir2() {
-  const dir = join16(homedir5(), ".chatroom");
-  if (!existsSync5(dir)) {
+  const dir = join17(homedir5(), ".chatroom");
+  if (!existsSync6(dir)) {
     mkdirSync4(dir, { recursive: true, mode: 448 });
   }
 }
 function readPids() {
   const filePath = getChildPidsFilePath();
-  if (!existsSync5(filePath))
+  if (!existsSync6(filePath))
     return [];
   try {
-    return readFileSync7(filePath, "utf-8").split(`
+    return readFileSync8(filePath, "utf-8").split(`
 `).map((line) => parseInt(line.trim(), 10)).filter((n) => Number.isFinite(n) && n > 0);
   } catch {
     return [];
@@ -82226,9 +83367,9 @@ function trackChildPid(pid) {
 function untrackChildPid(pid) {
   try {
     const filePath = getChildPidsFilePath();
-    if (!existsSync5(filePath))
+    if (!existsSync6(filePath))
       return;
-    const remaining = readFileSync7(filePath, "utf-8").split(`
+    const remaining = readFileSync8(filePath, "utf-8").split(`
 `).filter((line) => {
       const n = parseInt(line.trim(), 10);
       return Number.isFinite(n) && n > 0 && n !== pid;
@@ -82245,7 +83386,7 @@ function untrackChildPid(pid) {
 function clearTrackedPids() {
   try {
     const filePath = getChildPidsFilePath();
-    if (existsSync5(filePath)) {
+    if (existsSync6(filePath)) {
       unlinkSync(filePath);
     }
   } catch {}
@@ -82313,7 +83454,7 @@ var init_orphan_tracker = __esm(() => {
 // src/daemon/entry/handlers/process/output-store.ts
 import { appendFile as appendFile2, mkdir as mkdir8, readFile as readFile6, rm as rm2 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 
 class TempFileOutputStore {
   state;
@@ -82376,7 +83517,7 @@ function createOutputStore(runId) {
   if (!RUN_ID_RE.test(runId)) {
     throw new Error(`Invalid runId: ${runId}`);
   }
-  const filePath = join17(TEMP_DIR, `${runId}.log`);
+  const filePath = join18(TEMP_DIR, `${runId}.log`);
   return new TempFileOutputStore(filePath);
 }
 async function ensureTempDir() {
@@ -82390,7 +83531,7 @@ async function cleanOrphanTempFiles() {
 var TAIL_WINDOW_BYTES, TEMP_DIR, RUN_ID_RE, MAX_TAIL_LINES_V2 = 50;
 var init_output_store = __esm(() => {
   TAIL_WINDOW_BYTES = 32 * 1024;
-  TEMP_DIR = join17(tmpdir(), "chatroom-cli", "runs");
+  TEMP_DIR = join18(tmpdir(), "chatroom-cli", "runs");
   RUN_ID_RE = /^[a-z0-9]+$/i;
 });
 
@@ -98206,9 +99347,9 @@ var init_state_recovery = __esm(() => {
 
 // src/commands/machine/pid.ts
 import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2, mkdirSync as mkdirSync5 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync9, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2, mkdirSync as mkdirSync5 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 function getUrlHash2() {
   const url3 = getConvexUrl();
   return createHash3("sha256").update(url3).digest("hex").substring(0, 8);
@@ -98217,12 +99358,12 @@ function getPidFileName() {
   return `daemon-${getUrlHash2()}.pid`;
 }
 function ensureChatroomDir3() {
-  if (!existsSync6(CHATROOM_DIR4)) {
+  if (!existsSync7(CHATROOM_DIR4)) {
     mkdirSync5(CHATROOM_DIR4, { recursive: true, mode: 448 });
   }
 }
 function getPidFilePath() {
-  return join18(CHATROOM_DIR4, getPidFileName());
+  return join19(CHATROOM_DIR4, getPidFileName());
 }
 function isProcessRunning(pid) {
   try {
@@ -98234,11 +99375,11 @@ function isProcessRunning(pid) {
 }
 function readPid() {
   const pidPath = getPidFilePath();
-  if (!existsSync6(pidPath)) {
+  if (!existsSync7(pidPath)) {
     return null;
   }
   try {
-    const content = readFileSync8(pidPath, "utf-8").trim();
+    const content = readFileSync9(pidPath, "utf-8").trim();
     const pid = parseInt(content, 10);
     if (isNaN(pid) || pid <= 0) {
       return null;
@@ -98256,7 +99397,7 @@ function writePid() {
 function removePid() {
   const pidPath = getPidFilePath();
   try {
-    if (existsSync6(pidPath)) {
+    if (existsSync7(pidPath)) {
       unlinkSync2(pidPath);
     }
   } catch {}
@@ -98319,7 +99460,7 @@ function releaseLock() {
 var CHATROOM_DIR4, LOCK_RETRY_INTERVAL_MS = 500, LOCK_RETRY_MAX_WAIT_MS = 15000;
 var init_pid = __esm(() => {
   init_client2();
-  CHATROOM_DIR4 = join18(homedir6(), ".chatroom");
+  CHATROOM_DIR4 = join19(homedir6(), ".chatroom");
 });
 
 // src/infrastructure/machine/crash-loop-tracker.ts
@@ -99518,6 +100659,7 @@ class AgentProcessManager {
     }
   }
   async runHandleNativeTurnEnd(opts, slot) {
+    this.maybeEmitProviderUnavailable(opts.chatroomId, opts.role, slot);
     if (await tryAbortResumeStorm({
       resumeStormTracker: this.deps.resumeStormTracker,
       backend: createTurnCompletedBackend(this.deps),
@@ -99560,6 +100702,7 @@ class AgentProcessManager {
     }
     const stopReason = resolveStopReason(opts.code, opts.signal);
     const ctx = this.captureExitContext(slot, opts, stopReason);
+    this.maybeEmitProviderUnavailable(opts.chatroomId, opts.role, slot);
     notifyNativeHarnessSessionLostOnExit({
       chatroomId: opts.chatroomId,
       role: opts.role,
@@ -99675,6 +100818,24 @@ class AgentProcessManager {
     console.log(`[AgentProcessManager] cursor-sdk run-error detected: ${formatCursorSdkRunErrorMessage(recentLogLines)}`);
     return true;
   }
+  maybeEmitProviderUnavailable(chatroomId, role, slot) {
+    if (!slot || slot.harness !== "codex-sdk" || slot.providerUnavailableEmitted)
+      return;
+    const classification2 = classifyProviderErrorFromLogs(slot.recentLogLines ?? []);
+    if (!classification2)
+      return;
+    slot.providerUnavailableEmitted = true;
+    this.deps.backend.mutation(api.machines.emitAgentProviderUnavailable, {
+      sessionId: this.deps.sessionId,
+      machineId: this.deps.machineId,
+      chatroomId,
+      role,
+      reason: classification2.reason,
+      model: slot.model ?? "",
+      message: classification2.message,
+      recoverable: providerUnavailableRecoverable(classification2.reason)
+    }).catch(() => {});
+  }
   maybeRestartAgent(opts, ctx) {
     const { harness, model, workingDir, recentLogLines } = ctx;
     const logs = recentLogLines ?? [];
@@ -100347,6 +101508,7 @@ class AgentProcessManager {
     slot.startedAt = this.deps.clock.now();
     slot.pendingOperation = undefined;
     slot.recentLogLines = [];
+    slot.providerUnavailableEmitted = false;
     this.deps.resumeStormTracker.reset(opts.chatroomId, opts.role);
   }
   emitSpawnedAgentUpdate(opts, spawnResult, pid) {
@@ -100619,6 +101781,7 @@ var init_agent_process_manager = __esm(() => {
   init_agent_lifecycle_types();
   init_spawn_policy();
   init_abort_resume_storm();
+  init_classify_provider_error();
   init_classify_resume_storm_reason();
   init_decide_resume_path();
   init_handle_turn_completed();
@@ -100651,7 +101814,7 @@ async function discoverModelsForHarness(harness, service3) {
 async function discoverModels(agentServices) {
   return exports_Effect.runPromise(discoverModelsEffect(agentServices));
 }
-function createDefaultDeps19() {
+function createDefaultDeps22() {
   return {
     backend: {
       mutation: async () => {
@@ -100804,7 +101967,7 @@ Run: ${formatAuthLoginCommand(convexUrl)}`);
   return yield* waitForAuthenticationEffect(convexUrl);
 }), validateSessionEffect = (client4, sessionId, convexUrl) => exports_Effect.gen(function* () {
   const validation = yield* exports_Effect.tryPromise({
-    try: () => client4.query(api.cliAuth.validateSession, { sessionId }),
+    try: () => client4.query(api.cliAuth.validateSession, { sessionId: asConvexSessionId(sessionId) }),
     catch: (e) => e
   });
   if (validation.valid) {
@@ -100818,7 +101981,9 @@ Run: ${formatAuthLoginCommand(convexUrl)}`);
   const newSessionId2 = yield* waitForAuthenticationEffect(convexUrl);
   const typedNewSession = newSessionId2;
   const revalidation = yield* exports_Effect.tryPromise({
-    try: () => client4.query(api.cliAuth.validateSession, { sessionId: typedNewSession }),
+    try: () => client4.query(api.cliAuth.validateSession, {
+      sessionId: asConvexSessionId(typedNewSession)
+    }),
     catch: (e) => e
   });
   if (!revalidation.valid) {
@@ -100845,7 +102010,7 @@ Run: ${formatAuthLoginCommand(convexUrl)}`);
   }
   return config4;
 }), registerMachineEffect = (client4, sessionId, config4) => exports_Effect.catchAll(exports_Effect.tryPromise(() => client4.mutation(api.machines.register, {
-  sessionId,
+  sessionId: asConvexSessionId(sessionId),
   machineId: config4.machineId,
   hostname: config4.hostname,
   os: config4.os,
@@ -100854,7 +102019,10 @@ Run: ${formatAuthLoginCommand(convexUrl)}`);
 })), (error51) => exports_Effect.sync(() => {
   console.warn(`⚠️  Machine registration update failed: ${getErrorMessage(error51)}`);
 })), fetchCachedMachineModelsEffect = (client4, sessionId, machineId) => exports_Effect.tryPromise({
-  try: () => client4.query(api.machines.getMachineModels, { sessionId, machineId }),
+  try: () => client4.query(api.machines.getMachineModels, {
+    sessionId: asConvexSessionId(sessionId),
+    machineId
+  }),
   catch: (e) => e
 }).pipe(exports_Effect.map((result) => result?.availableModels ?? {}), exports_Effect.catchAll(() => exports_Effect.succeed({}))), connectOnceEffect = (client4, sessionId, convexUrl) => exports_Effect.gen(function* () {
   const typedSessionId = yield* validateSessionEffect(client4, sessionId, convexUrl);
@@ -100868,7 +102036,7 @@ Run: ${formatAuthLoginCommand(convexUrl)}`);
   return { typedSessionId, config: config4, machineId, agentServices, cachedModels };
 }), connectDaemonEffect = (client4, sessionId, machineId) => exports_Effect.tryPromise({
   try: () => client4.mutation(api.machines.updateDaemonStatus, {
-    sessionId,
+    sessionId: asConvexSessionId(sessionId),
     machineId,
     connected: true
   }),
@@ -100990,7 +102158,7 @@ var init_init_daemon = __esm(() => {
       convexUrl,
       agentServices,
       cachedModels,
-      deps: createDefaultDeps19()
+      deps: createDefaultDeps22()
     });
     yield* registerEventListenersEffect().pipe(exports_Effect.provide(daemonSessionToLayers(init2)));
     yield* logStartupEffect(cachedModels).pipe(exports_Effect.provide(daemonSessionToLayers(init2)));
@@ -101003,6 +102171,35 @@ var init_init_daemon = __esm(() => {
 function hasEntries(map19) {
   return Object.keys(map19).length > 0;
 }
+function getCatalogEndpoints() {
+  const harnesses = api.harnesses;
+  return {
+    "codex-sdk": harnesses?.codexSdk,
+    copilot: harnesses?.copilot,
+    cursor: harnesses?.cursor
+  };
+}
+async function fetchHarnessCatalog(client4, sessionId) {
+  const endpoints = getCatalogEndpoints();
+  const entries2 = await Promise.all(Object.keys(endpoints).map(async (harness) => {
+    const endpoint = endpoints[harness]?.listModels;
+    if (!endpoint)
+      return;
+    try {
+      return [harness, await client4.query(endpoint, { sessionId })];
+    } catch (error51) {
+      console.warn(`[${formatTimestamp()}] ⚠️  Server model catalog fetch failed for ${harness}: ${getErrorMessage(error51)}`);
+      return;
+    }
+  }));
+  return Object.fromEntries(entries2.filter((entry) => entry !== undefined));
+}
+function applyCatalogOverlay(discovered, catalog) {
+  for (const [harness, models] of Object.entries(catalog)) {
+    discovered[harness] = models;
+  }
+  return discovered;
+}
 function difference4(a, b) {
   const exclude3 = new Set(b);
   return (a ?? []).filter((model) => !exclude3.has(model));
@@ -101050,6 +102247,15 @@ function logPushOutcome(modelDiff, totalCount, options) {
   }
   logRefreshOutcome(modelDiff, totalCount);
 }
+function nextSnapshotAfterHarness(current, harness, result, catalog) {
+  const next4 = { ...current ?? {} };
+  if (result.installed) {
+    next4[harness] = catalog[harness] ?? result.models;
+  } else {
+    delete next4[harness];
+  }
+  return next4;
+}
 var pushModelsSnapshotMutationEffect = (models, modelDiff, nextHarnessFingerprint, ctxConfig, options) => exports_Effect.gen(function* () {
   const session2 = yield* DaemonSessionService;
   yield* exports_Effect.tryPromise({
@@ -101089,16 +102295,10 @@ var pushModelsSnapshotMutationEffect = (models, modelDiff, nextHarnessFingerprin
   const message = getErrorMessage(error51);
   console.warn(`[${formatTimestamp()}] ⚠️  Model refresh failed: ${message}`);
   return { kind: "failed", message };
-}))), refreshModelsEffect, discoverAndPushHarnessModelsEffect = (harness, service3) => exports_Effect.gen(function* () {
+}))), refreshModelsEffect, discoverAndPushHarnessModelsEffect = (harness, service3, catalog) => exports_Effect.gen(function* () {
   const mutable = yield* DaemonMutableStateService;
   const result = yield* exports_Effect.promise(() => discoverModelsForHarness(harness, service3));
-  const current = (yield* exports_Ref.get(mutable.lastPushedModels)) ?? {};
-  const next4 = { ...current };
-  if (result.installed) {
-    next4[harness] = result.models;
-  } else {
-    delete next4[harness];
-  }
+  const next4 = nextSnapshotAfterHarness(yield* exports_Ref.get(mutable.lastPushedModels), harness, result, catalog);
   const pushOutcome = yield* pushModelsSnapshotIfChangedEffect(next4, {
     logPrefix: `${harness} models updated`
   });
@@ -101122,10 +102322,12 @@ var init_models_refresh = __esm(() => {
     }
     const ctxConfig = session2.config;
     const outcome = yield* exports_Effect.gen(function* () {
+      const catalog = yield* exports_Effect.promise(() => fetchHarnessCatalog(session2.client, session2.sessionId));
       const models = yield* exports_Effect.tryPromise({
         try: async () => discoverModels(session2.agentServices),
         catch: (e) => e
       });
+      applyCatalogOverlay(models, catalog);
       const freshConfig = yield* exports_Effect.tryPromise({
         try: async () => ensureMachineRegistered(),
         catch: (e) => e
@@ -101155,7 +102357,8 @@ var init_models_refresh = __esm(() => {
     const session2 = yield* DaemonSessionService;
     if (!session2.config)
       return;
-    yield* exports_Effect.forEach(Array.from(session2.agentServices.entries()), ([harness, service3]) => discoverAndPushHarnessModelsEffect(harness, service3), { concurrency: "unbounded" });
+    const catalog = yield* exports_Effect.promise(() => fetchHarnessCatalog(session2.client, session2.sessionId));
+    yield* exports_Effect.forEach(Array.from(session2.agentServices.entries()), ([harness, service3]) => discoverAndPushHarnessModelsEffect(harness, service3, catalog), { concurrency: "unbounded" });
   });
 });
 
@@ -101198,12 +102401,24 @@ var init_capabilities_bridge = __esm(() => {
 });
 
 // ../../services/backend/config/featureFlags.ts
-var featureFlags;
+function getAllowedSignupMethodsForEnvironment(nodeEnv, convexDeployment) {
+  if (convexDeployment?.startsWith("local:")) {
+    return ["self", "invite"];
+  }
+  if (nodeEnv && DEV_NODE_ENVS.has(nodeEnv)) {
+    return ["self", "invite"];
+  }
+  return ["invite"];
+}
+var DEV_NODE_ENVS, featureFlags;
 var init_featureFlags = __esm(() => {
+  DEV_NODE_ENVS = new Set(["development", "test"]);
   featureFlags = {
     disableLogin: false,
     directHarnessWorkers: true,
-    allowedSignupMethods: ["self"]
+    get allowedSignupMethods() {
+      return getAllowedSignupMethodsForEnvironment("development", process.env.CONVEX_DEPLOYMENT);
+    }
   };
 });
 
@@ -103015,16 +104230,16 @@ var init_jsonc = __esm(() => {
 
 // src/infrastructure/services/workspace/workspace-resolver.ts
 import { readFile as readFile7, readdir, stat as stat3 } from "node:fs/promises";
-import { join as join19, basename, resolve as resolve4 } from "node:path";
+import { join as join20, basename, resolve as resolve4 } from "node:path";
 async function resolveGlobPatternStar(rootDir, cleaned) {
-  const parentDir = join19(rootDir, cleaned.slice(0, -2));
+  const parentDir = join20(rootDir, cleaned.slice(0, -2));
   try {
     const entries2 = await readdir(parentDir, { withFileTypes: true });
     const dirs = [];
     for (const entry of entries2) {
       if (!entry.isDirectory())
         continue;
-      const dirPath = join19(parentDir, entry.name);
+      const dirPath = join20(parentDir, entry.name);
       if (resolve4(dirPath).startsWith(resolve4(rootDir))) {
         dirs.push(dirPath);
       }
@@ -103035,7 +104250,7 @@ async function resolveGlobPatternStar(rootDir, cleaned) {
   }
 }
 async function resolveLiteralPath(rootDir, cleaned) {
-  const dir = join19(rootDir, cleaned);
+  const dir = join20(rootDir, cleaned);
   try {
     if (!resolve4(dir).startsWith(resolve4(rootDir)))
       return [];
@@ -103055,7 +104270,7 @@ async function resolveGlobPattern(rootDir, pattern) {
 }
 async function readPackageJson(dir) {
   try {
-    const content = await readFile7(join19(dir, "package.json"), "utf-8");
+    const content = await readFile7(join20(dir, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     return {
       name: pkg.name || basename(dir),
@@ -103067,7 +104282,7 @@ async function readPackageJson(dir) {
 }
 async function readPnpmWorkspacePatterns(rootDir) {
   try {
-    const content = await readFile7(join19(rootDir, "pnpm-workspace.yaml"), "utf-8");
+    const content = await readFile7(join20(rootDir, "pnpm-workspace.yaml"), "utf-8");
     const patterns = [];
     let inPackages = false;
     for (const line of content.split(`
@@ -103094,7 +104309,7 @@ async function readPnpmWorkspacePatterns(rootDir) {
 }
 async function readPackageJsonWorkspacePatterns(rootDir) {
   try {
-    const content = await readFile7(join19(rootDir, "package.json"), "utf-8");
+    const content = await readFile7(join20(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     if (!pkg.workspaces)
       return [];
@@ -103175,11 +104390,11 @@ var MAX_NAME_LENGTH = 256;
 
 // src/infrastructure/services/workspace/command-discovery.ts
 import { access as access2, readFile as readFile8 } from "node:fs/promises";
-import { join as join20, relative, basename as basename2 } from "node:path";
+import { join as join21, relative, basename as basename2 } from "node:path";
 async function detectPackageManager(workingDir) {
   for (const { file: file2, manager } of LOCKFILE_MAP) {
     try {
-      await access2(join20(workingDir, file2));
+      await access2(join21(workingDir, file2));
       return manager;
     } catch {}
   }
@@ -103248,7 +104463,7 @@ function collectRootScriptCommands(scripts, pm, scriptPrefix, rootSw) {
 }
 async function readRootPackageJson(workingDir, pm, scriptPrefix) {
   let rootPackageName = basename2(workingDir);
-  const pkg = await readJsonFile(join20(workingDir, "package.json"), "root package.json");
+  const pkg = await readJsonFile(join21(workingDir, "package.json"), "root package.json");
   if (!pkg)
     return { commands: [], rootPackageName };
   if (pkg.name)
@@ -103264,7 +104479,7 @@ async function readRootPackageJson(workingDir, pm, scriptPrefix) {
 }
 async function readTurboJson(workingDir, _turboPrefix, _rootSubWorkspace) {
   const turboTaskNames = [];
-  const turbo = await readJsonFile(join20(workingDir, "turbo.json"), "turbo.json");
+  const turbo = await readJsonFile(join21(workingDir, "turbo.json"), "turbo.json");
   if (!turbo?.tasks || typeof turbo.tasks !== "object")
     return turboTaskNames;
   for (const taskName of Object.keys(turbo.tasks)) {
@@ -103277,7 +104492,7 @@ async function readTurboJson(workingDir, _turboPrefix, _rootSubWorkspace) {
 async function readDenoJson(workingDir) {
   const commands = [];
   for (const fileName of ["deno.json", "deno.jsonc"]) {
-    const deno = await readJsonFile(join20(workingDir, fileName), fileName);
+    const deno = await readJsonFile(join21(workingDir, fileName), fileName);
     if (!deno?.tasks || typeof deno.tasks !== "object")
       continue;
     const pkgName = deno.name ?? basename2(workingDir);
@@ -103300,7 +104515,7 @@ async function readMakefile(workingDir) {
   const commands = [];
   for (const fileName of ["Makefile", "makefile"]) {
     try {
-      const content = await readFile8(join20(workingDir, fileName), "utf-8");
+      const content = await readFile8(join21(workingDir, fileName), "utf-8");
       const targets = parseMakefileTargets(content);
       if (targets.length === 0)
         continue;
@@ -103484,7 +104699,7 @@ var init_on_request_restart_agent = __esm(() => {
 });
 
 // src/daemon/domain/usecase/start-agent.ts
-async function startAgent(deps, input) {
+async function startAgent2(deps, input) {
   const now = deps.now?.() ?? Date.now();
   const log4 = deps.log ?? console.log;
   if (now > input.deadline) {
@@ -103521,7 +104736,7 @@ async function startAgent(deps, input) {
 var onRequestStartAgentEffect = (event) => exports_Effect.gen(function* () {
   const agentPm = yield* DaemonAgentProcessManagerService;
   const session2 = yield* DaemonSessionService;
-  yield* exports_Effect.promise(() => startAgent(createStartAgentDeps(agentPm, session2), {
+  yield* exports_Effect.promise(() => startAgent2(createStartAgentDeps(agentPm, session2), {
     commandId: event._id.toString(),
     chatroomId: event.chatroomId,
     role: event.role,
@@ -104227,7 +105442,7 @@ async function dispatchCommandInboundEvent(event) {
 var handler;
 
 // src/daemon/infrastructure/local/harness/adapters/claude-sdk/claude-session.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 
 class ClaudeSdkSession {
   opencodeSessionId;
@@ -104269,7 +105484,7 @@ class ClaudeSdkSession {
       throw new Error("Session is closed");
     const text = input.parts.map((p) => p.text).join(`
 `);
-    const messageId = randomUUID4();
+    const messageId = randomUUID5();
     const model = resolveClaudeModel(this.defaultModel, input.model);
     const useResume = Boolean(this.providerSessionId) && (!this.isFirstQuery || this.resumeOnFirstQuery);
     this.sawTextDelta = false;
@@ -104425,17 +105640,17 @@ var DEFAULT_MAX_TURNS3 = 200, DEFAULT_EFFORT2 = "medium", QUERY_TIMEOUT_MS = 360
 var init_claude_session = () => {};
 
 // src/daemon/infrastructure/local/harness/adapters/claude-sdk/claude-harness.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
-async function loadSdk4() {
-  if (_sdkCache4)
-    return _sdkCache4;
-  if (_sdkLoadError4)
-    throw _sdkLoadError4;
+import { randomUUID as randomUUID6 } from "node:crypto";
+async function loadSdk5() {
+  if (_sdkCache5)
+    return _sdkCache5;
+  if (_sdkLoadError5)
+    throw _sdkLoadError5;
   try {
-    _sdkCache4 = await importBundledClaudeSdk();
-    return _sdkCache4;
+    _sdkCache5 = await importBundledClaudeSdk();
+    return _sdkCache5;
   } catch (err) {
-    _sdkLoadError4 = err;
+    _sdkLoadError5 = err;
     throw err;
   }
 }
@@ -104490,7 +105705,7 @@ class ClaudeSdkHarness {
   async newSession(config4) {
     if (this.closed)
       throw new Error("Harness is closed");
-    const opencodeSessionId = randomUUID5();
+    const opencodeSessionId = randomUUID6();
     const session2 = new ClaudeSdkSession({
       cwd: this.cwd,
       executablePath: this.executablePath,
@@ -104538,9 +105753,9 @@ class ClaudeSdkHarness {
     this.sessions.clear();
   }
 }
-var DEFAULT_MODEL2 = "anthropic/sonnet", _sdkCache4, _sdkLoadError4, _executablePathCache, startClaudeSdkHarness = async (config4) => {
+var DEFAULT_MODEL2 = "anthropic/sonnet", _sdkCache5, _sdkLoadError5, _executablePathCache, startClaudeSdkHarness = async (config4) => {
   try {
-    const sdk = await loadSdk4();
+    const sdk = await loadSdk5();
     const executablePath = await loadExecutablePath();
     return new ClaudeSdkHarness(config4.workingDir, sdk, executablePath);
   } catch (err) {
@@ -104587,7 +105802,7 @@ var init_claude_sdk2 = __esm(() => {
 });
 
 // src/daemon/infrastructure/local/harness/adapters/cursor-sdk/cursor-session.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 function warnWriteLine(line) {
   console.warn(line);
 }
@@ -104617,13 +105832,13 @@ class CursorSdkSession {
       throw new Error("Session is closed");
     const text = input.parts.map((p) => p.text).join(`
 `);
-    const messageId = randomUUID6();
+    const messageId = randomUUID7();
     const isFirstTurn = this.turnCount === 0;
     this.turnCount += 1;
     const modelId = input.model ? resolveModelFromPrompt(input.model.providerID, input.model.modelID) : undefined;
     const run3 = await withTimeout(this.agent.send(text, {
       local: { force: isFirstTurn },
-      idempotencyKey: randomUUID6(),
+      idempotencyKey: randomUUID7(),
       ...modelId ? { model: { id: modelId } } : {},
       onDelta: ({ update: update6 }) => {
         this.handleInteractionDelta(messageId, update6);
@@ -104739,16 +105954,16 @@ var init_cursor_session = __esm(() => {
 });
 
 // src/daemon/infrastructure/local/harness/adapters/cursor-sdk/cursor-harness.ts
-async function loadSdk5() {
-  if (_sdkCache5)
-    return _sdkCache5;
-  if (_sdkLoadError5)
-    throw _sdkLoadError5;
+async function loadSdk6() {
+  if (_sdkCache6)
+    return _sdkCache6;
+  if (_sdkLoadError6)
+    throw _sdkLoadError6;
   try {
-    _sdkCache5 = await importBundledCursorSdk();
-    return _sdkCache5;
+    _sdkCache6 = await importBundledCursorSdk();
+    return _sdkCache6;
   } catch (err) {
-    _sdkLoadError5 = err;
+    _sdkLoadError6 = err;
     throw err;
   }
 }
@@ -104783,7 +105998,7 @@ class CursorSdkHarness {
     const apiKey = process.env.CURSOR_API_KEY?.trim();
     if (!apiKey)
       return [];
-    const { Cursor } = await loadSdk5();
+    const { Cursor } = await loadSdk6();
     const listed = await withTimeout(Cursor.models.list({ apiKey }), MODELS_LIST_TIMEOUT_MS2, "Cursor.models.list");
     const modelIds = normalizeCursorSdkListedModels(listed.map((m) => m.id).filter((id3) => id3.length > 0));
     return [
@@ -104801,7 +106016,7 @@ class CursorSdkHarness {
     if (!apiKey)
       throw new Error("CURSOR_API_KEY is not set");
     const modelId = resolveCursorSdkModel(config4.model ?? DEFAULT_MODEL3);
-    const { Agent } = await loadSdk5();
+    const { Agent } = await loadSdk6();
     const agent = await withTimeout(Agent.create({
       apiKey,
       model: { id: modelId },
@@ -104825,7 +106040,7 @@ class CursorSdkHarness {
     const apiKey = process.env.CURSOR_API_KEY?.trim();
     if (!apiKey)
       throw new Error("CURSOR_API_KEY is not set");
-    const { Agent } = await loadSdk5();
+    const { Agent } = await loadSdk6();
     const agent = await withTimeout(Agent.resume(sessionId, {
       apiKey,
       model: { id: DEFAULT_MODEL3 },
@@ -104855,9 +106070,9 @@ class CursorSdkHarness {
     this.sessions.clear();
   }
 }
-var DEFAULT_MODEL3 = "composer-2.5", MODELS_LIST_TIMEOUT_MS2 = 60000, AGENT_CREATE_TIMEOUT_MS2 = 60000, _sdkCache5, _sdkLoadError5, startCursorSdkHarness = async (config4) => {
+var DEFAULT_MODEL3 = "composer-2.5", MODELS_LIST_TIMEOUT_MS2 = 60000, AGENT_CREATE_TIMEOUT_MS2 = 60000, _sdkCache6, _sdkLoadError6, startCursorSdkHarness = async (config4) => {
   try {
-    await loadSdk5();
+    await loadSdk6();
   } catch (err) {
     throw new Error(`cursor-sdk unavailable: ${formatCursorSdkLoadError(err)}`);
   }
@@ -105415,7 +106630,7 @@ var init_opencode_harness = __esm(() => {
 });
 
 // src/daemon/infrastructure/local/harness/adapters/pi-sdk/pi-session.ts
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 
 class PiSdkSession {
   opencodeSessionId;
@@ -105442,7 +106657,7 @@ class PiSdkSession {
       throw new Error("Session is closed");
     const text = input.parts.map((p) => p.text).join(`
 `);
-    const messageId = randomUUID7();
+    const messageId = randomUUID8();
     const onSessionEvent = (event) => {
       if (this.closed)
         return;
@@ -105502,16 +106717,16 @@ var PROMPT_TIMEOUT_MS2 = 3600000;
 var init_pi_session = () => {};
 
 // src/daemon/infrastructure/local/harness/adapters/pi-sdk/pi-harness.ts
-async function loadSdk6() {
-  if (_sdkCache6)
-    return _sdkCache6;
-  if (_sdkLoadError6)
-    throw _sdkLoadError6;
+async function loadSdk7() {
+  if (_sdkCache7)
+    return _sdkCache7;
+  if (_sdkLoadError7)
+    throw _sdkLoadError7;
   try {
-    _sdkCache6 = await importBundledPiSdk();
-    return _sdkCache6;
+    _sdkCache7 = await importBundledPiSdk();
+    return _sdkCache7;
   } catch (err) {
-    _sdkLoadError6 = err;
+    _sdkLoadError7 = err;
     throw err;
   }
 }
@@ -105583,7 +106798,7 @@ class PiSdkHarness {
     const existing = this.sessions.get(sessionId);
     if (existing)
       return existing;
-    const { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } = await loadSdk6();
+    const { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } = await loadSdk7();
     const sessions = await SessionManager.list(this.cwd, getPiSessionDir(this.cwd));
     const match17 = sessions.find((s) => s.id === sessionId);
     if (!match17) {
@@ -105631,7 +106846,7 @@ class PiSdkHarness {
     this.sessions.clear();
   }
   async createAgentSession(systemPrompt, model) {
-    const { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } = await loadSdk6();
+    const { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } = await loadSdk7();
     const resolvedModel = resolveModel2(this.modelRegistry, model ?? DEFAULT_MODEL4);
     if (!resolvedModel) {
       throw new Error("No Pi model available — configure provider credentials in ~/.pi/agent/auth.json");
@@ -105653,9 +106868,9 @@ class PiSdkHarness {
     return session2;
   }
 }
-var SESSION_CREATE_TIMEOUT_MS3 = 60000, DEFAULT_MODEL4 = "opencode/big-pickle", _sdkCache6, _sdkLoadError6, startPiSdkHarness = async (config4) => {
+var SESSION_CREATE_TIMEOUT_MS3 = 60000, DEFAULT_MODEL4 = "opencode/big-pickle", _sdkCache7, _sdkLoadError7, startPiSdkHarness = async (config4) => {
   try {
-    const { AuthStorage, ModelRegistry } = await loadSdk6();
+    const { AuthStorage, ModelRegistry } = await loadSdk7();
     const authStorage = AuthStorage.create();
     const modelRegistry = ModelRegistry.create(authStorage);
     if (modelRegistry.getAvailable().length === 0) {
@@ -107296,7 +108511,7 @@ var init_assert_registered_working_dir = __esm(() => {
 
 // src/infrastructure/services/workspace/workspace-path-security.ts
 import { realpath } from "node:fs/promises";
-import { dirname as dirname8, isAbsolute, relative as relative2, resolve as resolve5, sep } from "node:path";
+import { dirname as dirname9, isAbsolute, relative as relative2, resolve as resolve5, sep } from "node:path";
 import { gunzipSync } from "node:zlib";
 function validateRelativePathSegments(filePath) {
   if (filePath.includes("\x00"))
@@ -107324,7 +108539,7 @@ function assertContained(workspaceRoot, targetPath) {
   return { ok: true };
 }
 async function resolveNonExistentTarget(workspaceRoot, candidate) {
-  let current = dirname8(candidate);
+  let current = dirname9(candidate);
   for (;; ) {
     try {
       const ancestorReal = await realpath(current);
@@ -107342,7 +108557,7 @@ async function resolveNonExistentTarget(workspaceRoot, candidate) {
       if (code2 !== "ENOENT") {
         return { ok: false, error: "Invalid file path" };
       }
-      const parent = dirname8(current);
+      const parent = dirname9(current);
       if (parent === current) {
         return { ok: false, error: "Path escapes workspace" };
       }
@@ -107568,8 +108783,8 @@ var init_file_content_fulfillment = __esm(() => {
         console.log(`[${formatTimestamp()}] ⏳ File not on disk yet, deferring content sync: ${filePath}`);
         continue;
       }
-      const classification = classifyFileContent(filePath, new Uint8Array(buffer));
-      if (classification.kind === "binary") {
+      const classification2 = classifyFileContent(filePath, new Uint8Array(buffer));
+      if (classification2.kind === "binary") {
         yield* fulfillGzippedContentEffect(session2, workingDir, filePath, "[Binary file]", false, "binary");
         const elapsed4 = Date.now() - startTime;
         console.log(`[${formatTimestamp()}] \uD83D\uDCC4 File content synced to Convex: ${filePath} [binary] (${elapsed4}ms)`);
@@ -108274,7 +109489,7 @@ var init_file_tree_scanner = __esm(() => {
 });
 
 // src/infrastructure/services/workspace/git-workspace-porcelain.ts
-import { existsSync as existsSync7 } from "node:fs";
+import { existsSync as existsSync8 } from "node:fs";
 import path4 from "node:path";
 function isEmptyRepoHeadError(error51) {
   const message = error51.message.toLowerCase();
@@ -108450,7 +109665,7 @@ function porcelainPathsLeftSnapshot(args2) {
   return left3.sort((a, b) => a.localeCompare(b));
 }
 function porcelainUntrackedDeletedEvents(args2) {
-  const exists3 = args2.pathExists ?? ((p) => existsSync7(p));
+  const exists3 = args2.pathExists ?? ((p) => existsSync8(p));
   const left3 = porcelainPathsLeftSnapshot({
     workspaceRoot: args2.workspaceRoot,
     node: args2.node,
@@ -109145,9 +110360,9 @@ class NodeFsHandler {
     if (this.fsw.closed) {
       return;
     }
-    const dirname10 = sp.dirname(file2);
+    const dirname11 = sp.dirname(file2);
     const basename4 = sp.basename(file2);
-    const parent = this.fsw._getWatchedDir(dirname10);
+    const parent = this.fsw._getWatchedDir(dirname11);
     let prevStats = stats;
     if (parent.has(basename4))
       return;
@@ -109174,7 +110389,7 @@ class NodeFsHandler {
             prevStats = newStats2;
           }
         } catch (error51) {
-          this.fsw._remove(dirname10, basename4);
+          this.fsw._remove(dirname11, basename4);
         }
       } else if (parent.has(basename4)) {
         const at = newStats.atimeMs;
@@ -110561,10 +111776,10 @@ function diffPathIndexes(previous, next4) {
 }
 
 // src/infrastructure/services/workspace/workspace-sync-state.ts
-import { createHash as createHash8, randomUUID as randomUUID8 } from "node:crypto";
+import { createHash as createHash8, randomUUID as randomUUID9 } from "node:crypto";
 import * as fs11 from "node:fs/promises";
 import { homedir as homedir7 } from "node:os";
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 function workspaceKeyFor(workingDir) {
   const normalized = normalizeWorkingDirForLookup(workingDir);
   return createHash8("sha256").update(normalized).digest("hex").slice(0, 16);
@@ -110578,10 +111793,10 @@ function buildPathIndex(entries2) {
 }
 function manifestPath(machineId, workingDir) {
   const key = workspaceKeyFor(workingDir);
-  return join23(SYNC_STATE_DIR, machineId, key, "manifest.json");
+  return join24(SYNC_STATE_DIR, machineId, key, "manifest.json");
 }
 async function ensureDir(filePath) {
-  await fs11.mkdir(join23(filePath, ".."), { recursive: true, mode: 448 });
+  await fs11.mkdir(join24(filePath, ".."), { recursive: true, mode: 448 });
 }
 async function loadWorkspaceSyncManifest(machineId, workingDir) {
   try {
@@ -110623,7 +111838,7 @@ function createManifestFromTree(args2) {
     version: SYNC_STATE_VERSION,
     machineId: args2.machineId,
     workingDir: normalizeWorkingDirForLookup(args2.workingDir),
-    syncGeneration: randomUUID8(),
+    syncGeneration: randomUUID9(),
     completedAt: Date.now(),
     scanner: args2.scanner,
     dataHash: args2.dataHash,
@@ -110641,11 +111856,11 @@ function entriesFromPathIndex(paths) {
 }
 var SYNC_STATE_VERSION = "2", SYNC_STATE_DIR;
 var init_workspace_sync_state = __esm(() => {
-  SYNC_STATE_DIR = join23(homedir7(), ".chatroom", "sync-state");
+  SYNC_STATE_DIR = join24(homedir7(), ".chatroom", "sync-state");
 });
 
 // src/infrastructure/services/workspace/workspace-file-tree-coordinator.ts
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 import path7 from "node:path";
 function deltaEntry(paths, pathValue) {
   const type = paths[pathValue];
@@ -110672,7 +111887,7 @@ function buildPendingDeltas(previous, next4) {
   const result = [];
   for (let offset = 0;offset < operations.length; offset += MAX_DELTA_OPERATIONS) {
     const delta = {
-      operationId: randomUUID9(),
+      operationId: randomUUID10(),
       added: [],
       removed: [],
       typeChanged: [],
@@ -110946,7 +112161,7 @@ var init_workspace_file_tree_coordinator = __esm(() => {
 });
 
 // src/daemon/entry/files/file-tree-subscription.ts
-import { randomUUID as randomUUID10 } from "node:crypto";
+import { randomUUID as randomUUID11 } from "node:crypto";
 import { gzipSync as gzipSync3 } from "node:zlib";
 function logSubscriptionWarn(label, err) {
   console.warn(`[${formatTimestamp()}] ⚠️  ${label}: ${getErrorMessage(err)}`);
@@ -111016,7 +112231,7 @@ function toDeltaOperations(delta) {
 }
 async function publishCheckpoint(session2, normalizedWorkingDir, tree, revision) {
   const dataHash = computeFileTreeDataHash(tree);
-  const syncGeneration = randomUUID10();
+  const syncGeneration = randomUUID11();
   const snapshot = await syncScannedFileTree(session2, normalizedWorkingDir, tree, dataHash, syncGeneration);
   let checkpointRevision = revision;
   let result = await session2.backend.mutation(api.workspaceFiles.publishFileTreeCheckpoint, {
@@ -111223,7 +112438,7 @@ var init_file_write_request_priority = __esm(() => {
 
 // src/daemon/entry/files/file-write-fulfillment.ts
 import { access as access4, mkdir as mkdir10, rename as rename4, rm as rm4, writeFile as writeFile9 } from "node:fs/promises";
-import { dirname as dirname11 } from "node:path";
+import { dirname as dirname12 } from "node:path";
 function isTerminalFileWriteError(errorMessage) {
   const terminalMessages = new Set([
     "Invalid file path",
@@ -111322,7 +112537,7 @@ async function validateWriteOperation(operation, absolutePath) {
 }
 async function writePayloadToDisk(absolutePath, operation, content) {
   if (operation === "create") {
-    await mkdir10(dirname11(absolutePath), { recursive: true });
+    await mkdir10(dirname12(absolutePath), { recursive: true });
     await writeFile9(absolutePath, content, { flag: "wx" });
     return;
   }
@@ -111400,7 +112615,7 @@ async function fulfillOneFileWriteRequest(session2, request2) {
         });
         return;
       }
-      await mkdir10(dirname11(targetResolved.absolutePath), { recursive: true });
+      await mkdir10(dirname12(targetResolved.absolutePath), { recursive: true });
       await rename4(resolved.absolutePath, targetResolved.absolutePath);
       await completeWriteRequest(session2, claimed._id, claimed.revision, { status: "done" });
       const elapsed4 = Date.now() - startTime;
@@ -111618,7 +112833,7 @@ function consumePendingFullSync(runId) {
 }
 function startLogObserverSubscription(session2, wsClient2) {
   const queryArgs = {
-    sessionId: session2.sessionId,
+    sessionId: asConvexSessionId(session2.sessionId),
     machineId: session2.machineId
   };
   let stopped = false;
@@ -114037,9 +115252,9 @@ var init_deps = __esm(() => {
 
 // src/daemon/entry/persistence-path.ts
 import { homedir as homedir8 } from "node:os";
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 function resolvePersistenceDbPath(machineId) {
-  return join24(homedir8(), ".chatroom", "daemon", machineId, "events.sqlite");
+  return join25(homedir8(), ".chatroom", "daemon", machineId, "events.sqlite");
 }
 var init_persistence_path = () => {};
 
@@ -115053,10 +116268,10 @@ var init_schema = __esm(() => {
 
 // src/daemon/infrastructure/persistence/open-database.ts
 import { mkdirSync as mkdirSync6 } from "node:fs";
-import { dirname as dirname12 } from "node:path";
+import { dirname as dirname13 } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 function openDatabase(dbPath) {
-  mkdirSync6(dirname12(dbPath), { recursive: true });
+  mkdirSync6(dirname13(dbPath), { recursive: true });
   const db = new DatabaseSync(dbPath);
   for (const sql of MIGRATIONS) {
     db.exec(sql);
@@ -115215,7 +116430,7 @@ async function startDaemon() {
   const localWeb = await startLocalWebServer({ host: "127.0.0.1", port: localWebPort }, { persistence, streamHub: daemonDeps.streamHub });
   const subscribers = startAllSubscribers({
     wsClient: wsClient2,
-    sessionId: init2.sessionId,
+    sessionId: asConvexSessionId(init2.sessionId),
     machineId: init2.machineId,
     router: createDefaultEventRouterDeps()
   });
@@ -115401,7 +116616,7 @@ async function isChatroomInstalledDefault() {
     return false;
   }
 }
-async function createDefaultDeps20() {
+async function createDefaultDeps23() {
   const client4 = await getConvexClient();
   const fs12 = await import("fs/promises");
   return {
@@ -115476,7 +116691,7 @@ After installation, run this command again.`;
   });
 }
 async function installTool(options = {}, deps) {
-  const d = deps ?? await createDefaultDeps20();
+  const d = deps ?? await createDefaultDeps23();
   const layer = layerFromDeps9(d);
   return exports_Effect.runPromise(installToolEffect(options).pipe(exports_Effect.catchAll((err) => handleInstallError(err)), exports_Effect.provide(layer)));
 }
@@ -116003,6 +117218,39 @@ program2.command("get-next-task").description("Join a chatroom and get the next
   });
 });
 var handoffCommandGroup = program2.command("handoff").description("Complete your task and hand off to the next role");
+var teamCommand = program2.command("team").description("Manage chatroom team configuration");
+teamCommand.command("list").description("List available team presets").action(async () => {
+  await maybeRequireAuth();
+  const { listTeamPresets: listTeamPresets2 } = await Promise.resolve().then(() => (init_team(), exports_team));
+  await listTeamPresets2();
+});
+var agentCommand = program2.command("agent").description("Manage agent harness and lifecycle");
+var agentConfigCommand = agentCommand.command("config").description("Agent configuration");
+agentConfigCommand.command("get").description("Show agent configuration for a role").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Agent role").action(async (options) => {
+  await maybeRequireAuth();
+  const { getAgentConfig: getAgentConfig2 } = await Promise.resolve().then(() => (init_agent(), exports_agent));
+  await getAgentConfig2(options.chatroomId, options.role);
+});
+agentConfigCommand.command("set").description("Save agent harness and model configuration").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Agent role").requiredOption("--harness <harness>", "Agent harness").requiredOption("--model <model>", "Model identifier").option("--working-dir <dir>", "Agent working directory").action(async (options) => {
+  await maybeRequireAuth();
+  const { setAgentConfig: setAgentConfig2 } = await Promise.resolve().then(() => (init_agent(), exports_agent));
+  await setAgentConfig2(options.chatroomId, options);
+});
+agentCommand.command("start").description("Start a configured remote agent").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Agent role").option("--harness <harness>", "Agent harness override").option("--model <model>", "Model identifier override").option("--working-dir <dir>", "Agent working directory override").action(async (options) => {
+  await maybeRequireAuth();
+  const { startAgent: startAgent3 } = await Promise.resolve().then(() => (init_agent(), exports_agent));
+  await startAgent3(options.chatroomId, options);
+});
+teamCommand.command("get").description("Show the current team configuration").requiredOption("--chatroom-id <id>", "Chatroom identifier").action(async (options) => {
+  await maybeRequireAuth();
+  const { getTeam: getTeam2 } = await Promise.resolve().then(() => (init_team(), exports_team));
+  await getTeam2(options.chatroomId);
+});
+teamCommand.command("set").description("Set the team preset for a chatroom").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--team <id>", "Team preset (duo|solo)").action(async (options) => {
+  await maybeRequireAuth();
+  const { setTeam: setTeam2 } = await Promise.resolve().then(() => (init_team(), exports_team));
+  await setTeam2(options.chatroomId, options.team);
+});
 handoffCommandGroup.command("view-template").description("Print the handoff message template for a role pair").requiredOption("--role <role>", "Your role").requiredOption("--next-role <nextRole>", "Target role for the handoff").option("--team-id <teamId>", "Team id (solo, duo); defaults to duo").action(async (options) => {
   const { printHandoffViewTemplate: printHandoffViewTemplate2 } = await Promise.resolve().then(() => (init_view_template3(), exports_view_template));
   try {
@@ -116204,6 +117452,12 @@ skillCommand.command("activate <skill-name>").description("Activate a named skil
   await activateSkill2(options.chatroomId, skillName, { role: options.role });
 });
 var messagesCommand = program2.command("messages").description("List and filter chatroom messages");
+var messageCommand = program2.command("message").description("Send chatroom messages");
+messageCommand.command("send").description("Send a user message to a chatroom").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--content <text>", "Message content").option("--target-role <role>", "Target role (defaults to team entry point)").action(async (options) => {
+  await maybeRequireAuth();
+  const { sendUserMessage: sendUserMessage2 } = await Promise.resolve().then(() => (init_send(), exports_send));
+  await sendUserMessage2(options.chatroomId, options);
+});
 messagesCommand.command("list").description("List messages by sender role or since a specific message").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role").option("--sender-role <senderRole>", "Filter by sender role (e.g., user, builder, planner)").option("--since-message-id <messageId>", "Get all messages since this message ID (inclusive)").option("--limit <n>", "Maximum number of messages to show").option("--full", "Show full message content without truncation").action(async (options) => {
   if (!options.senderRole && !options.sinceMessageId) {
     console.error("❌ Must specify either --sender-role or --since-message-id");
@@ -116244,6 +117498,11 @@ messagesCommand.command("anchor").description("Locate the last user message and
     priorLimit: parsedPriorLimit
   });
 });
+messagesCommand.command("send").description("Send a user message to a chatroom").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--content <text>", "Message content").option("--target-role <role>", "Target role (defaults to team entry point)").action(async (options) => {
+  await maybeRequireAuth();
+  const { sendUserMessage: sendUserMessage2 } = await Promise.resolve().then(() => (init_send(), exports_send));
+  await sendUserMessage2(options.chatroomId, options);
+});
 messagesCommand.command("download").description("Download chatroom message history to local files for reading/grep").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role").option("--format <format>", "Download format (default: linear)", "linear").option("--output-dir <path>", "Output directory (default: .chatroom/downloads/messages/linear/<download-id>)").option("--limit <n>", "Max messages to download (default: 10, max: 5000)").option("--since-message-id <messageId>", "Download history since this message ID (inclusive, ascending)").action(async (options) => {
   await maybeRequireAuth();
   if (options.format && options.format !== "linear") {
@@ -116412,4 +117671,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=B2378E8C8597995864756E2164756E21
+//# debugId=D279A4D8F6CF2F1C64756E2164756E21