@alook/daemon 0.1.28 → 0.1.30

package/dist/index.js

@@ -119,6 +119,9 @@ function createDefaultAgentDriverHost(options = {}) {
   };
 }
 
+// agent-driver/dist/adapters/claude/index.js
+import { randomUUID as randomUUID5 } from "node:crypto";
+
 // agent-driver/dist/controller/process-host.js
 import { EventEmitter } from "events";
 
@@ -698,6 +701,7 @@ class ProcessLane {
   admissionSequence = 0;
   activeTerminalReceipt;
   stopPromise;
+  pendingInterrupt;
   pendingPromptAdmission;
   constructor(driver, ctx, opts = {}) {
     this.driver = driver;
@@ -737,12 +741,14 @@ class ProcessLane {
     try {
       spawned = await this.driver.spawn(launchCtx);
     } catch (error) {
+      this.settlePendingInterrupt(false);
       this.settlePendingPrompt({ ok: false, reason: "runtime_error", error: String(error) });
       throw error;
     }
     const { process: proc } = spawned;
     this.process = proc;
     this.attachProcess(proc);
+    this.dispatchPendingInterrupt(proc);
     this.armPendingPromptTimeout();
     if (this.driver.execution.lifetime === "session" && !this.writableStdin(proc)) {
       const rejection = this.stdinUnavailableAdmission();
@@ -841,6 +847,7 @@ class ProcessLane {
     pending.resolve(admission);
   }
   stop(opts = {}) {
+    this.settlePendingInterrupt(false);
     this.settlePendingPrompt({ ok: false, reason: "closed", error: "runtime lane stopped before command admission" });
     if (!this.process)
       return Promise.resolve();
@@ -859,11 +866,39 @@ class ProcessLane {
       proc.kill(opts?.signal ?? "SIGTERM");
     }
   }
-  async interrupt() {
+  async interrupt(input) {
     const proc = this.process;
-    if (!proc || this.closed)
+    if (!proc) {
+      if (!this.started)
+        return false;
+      if (this.pendingInterrupt)
+        return this.pendingInterrupt.promise;
+      let resolve;
+      let reject;
+      const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+      });
+      this.pendingInterrupt = { input, promise, resolve, reject };
+      return promise;
+    }
+    if (this.closed)
       return false;
-    return proc.kill("SIGINT");
+    return this.driver.interrupt(input, proc);
+  }
+  dispatchPendingInterrupt(proc) {
+    const pending = this.pendingInterrupt;
+    if (!pending)
+      return;
+    this.pendingInterrupt = undefined;
+    this.driver.interrupt(pending.input, proc).then(pending.resolve, pending.reject);
+  }
+  settlePendingInterrupt(accepted) {
+    const pending = this.pendingInterrupt;
+    if (!pending)
+      return;
+    this.pendingInterrupt = undefined;
+    pending.resolve(accepted);
   }
   updateSettings(input) {
     return this.driver.updateSettings?.(input) ?? Promise.resolve({ status: "unsupported" });
@@ -1200,11 +1235,40 @@ function tryParseJsonLine(line) {
 
 // agent-driver/dist/adapters/claude/normalizer.js
 var API_ERROR_RE = /API Error:.*(?:Connection error|\b[45]\d{2}\b)/i;
+var CLAUDE_RESULT_ERROR_CODES = new Map([
+  ["error_max_turns", "claude.error_max_turns"],
+  ["error_during_execution", "claude.error_during_execution"],
+  ["error_max_budget_usd", "claude.error_max_budget_usd"],
+  ["error_max_structured_output_retries", "claude.error_max_structured_output_retries"]
+]);
+var CLAUDE_INTERRUPT_TERMINAL_REASONS = new Set(["aborted_streaming", "aborted_tools"]);
+var CLAUDE_USAGE_COMPONENTS = [
+  "inputTokens",
+  "outputTokens",
+  "cacheReadInputTokens",
+  "cacheCreationInputTokens"
+];
+function safeCount(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function safeMoney(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function safeAdd(left, right) {
+  const total = left + right;
+  return Number.isSafeInteger(total) ? total : null;
+}
+function equalCost(left, right) {
+  return Math.abs(left - right) <= Math.max(0.000000000001, Math.abs(right) * 0.000000001);
+}
 
 class ClaudeEventNormalizer {
   turnProtocol;
   currentSession = null;
   usageProjector = new SettledUsageProjector;
+  claudeUsageSession = null;
+  claudeModelUsageHighWater = new Map;
+  claudeUsageMode = "unknown";
   constructor(turnProtocol) {
     this.turnProtocol = turnProtocol;
   }
@@ -1271,9 +1335,9 @@ class ClaudeEventNormalizer {
         out.push({ kind: "assistant_reasoning_completed", text: block.thinking ?? "" });
       } else if (block?.type === "text") {
         const text = block.text ?? "";
-        if (API_ERROR_RE.test(text))
-          out.push({ kind: "error", message: text });
-        else
+        if (API_ERROR_RE.test(text)) {
+          out.push({ kind: "error", code: "claude.api_error", message: text });
+        } else
           completedText.push(text);
       } else if (block?.type === "tool_use") {
         out.push({ kind: "tool_call", name: block.name ?? "unknown_tool", input: block.input });
@@ -1299,14 +1363,19 @@ class ClaudeEventNormalizer {
   }
   handleResult(event, out) {
     const rawOwner = typeof event.user_message_uuid === "string" && event.user_message_uuid.length > 0 ? event.user_message_uuid : null;
-    const turnOwner = rawOwner ? this.turnProtocol?.claimResult(rawOwner) ?? (this.turnProtocol ? null : `claude:${rawOwner}`) : null;
+    const interruptedTerminal = Boolean(this.turnProtocol && !rawOwner && event.subtype === "error_during_execution" && CLAUDE_INTERRUPT_TERMINAL_REASONS.has(event.terminal_reason));
+    const turnOwner = rawOwner ? this.turnProtocol?.claimResult(rawOwner) ?? (this.turnProtocol ? null : `claude:${rawOwner}`) : interruptedTerminal ? this.turnProtocol.claimInterruptedResult() : null;
     if (this.turnProtocol && !turnOwner)
       return;
     const usage = this.buildUsageTelemetry(event, rawOwner);
     if (usage)
       out.push(usage);
-    if (event.is_error || event.subtype === "error_during_execution") {
-      out.push({ kind: "error", message: String(event.result ?? "Claude runtime error") });
+    if (!interruptedTerminal && (event.is_error || event.subtype === "error_during_execution")) {
+      out.push({
+        kind: "error",
+        code: CLAUDE_RESULT_ERROR_CODES.get(event.subtype) ?? "claude.result_error",
+        message: String(event.result ?? "Claude runtime error")
+      });
     }
     out.push({
       kind: "turn_end",
@@ -1318,14 +1387,39 @@ class ClaudeEventNormalizer {
     return this.turnProtocol?.acceptsTurnWork() ?? true;
   }
   buildUsageTelemetry(event, rootRequestId) {
-    const u = event?.usage;
-    if (!u)
-      return null;
     const backendSessionId = event.session_id ?? this.currentSession;
     if (typeof backendSessionId !== "string" || !backendSessionId)
       return null;
     const providerRecordId = rootRequestId ?? (typeof event.request_id === "string" ? event.request_id : "invocation-result");
-    return this.usageProjector.project({
+    const cumulative = this.prepareClaudeModelUsage(event, backendSessionId);
+    if (cumulative === null)
+      return null;
+    if (cumulative) {
+      const hasDelta = cumulative.input > 0 || cumulative.output > 0 || cumulative.cacheRead > 0 || cumulative.cacheWrite > 0;
+      if (!hasDelta) {
+        this.commitClaudeModelUsage(backendSessionId, cumulative);
+        return null;
+      }
+      const projected2 = this.usageProjector.project({
+        runtime: "claude",
+        backendSessionId,
+        providerRecordId,
+        source: "claude_result_model_usage",
+        input: cumulative.input,
+        output: cumulative.output,
+        cacheRead: cumulative.cacheRead,
+        cacheWrite: cumulative.cacheWrite,
+        inputIncludesCache: false,
+        outputIncludesReasoning: true
+      });
+      if (projected2)
+        this.commitClaudeModelUsage(backendSessionId, cumulative);
+      return projected2;
+    }
+    const u = event?.usage;
+    if (!u)
+      return null;
+    const projected = this.usageProjector.project({
       runtime: "claude",
       backendSessionId,
       providerRecordId,
@@ -1337,6 +1431,102 @@ class ClaudeEventNormalizer {
       inputIncludesCache: false,
       outputIncludesReasoning: true
     });
+    if (projected)
+      this.claudeUsageMode = "legacy";
+    return projected;
+  }
+  prepareClaudeModelUsage(event, backendSessionId) {
+    if (this.claudeUsageMode === "invalid")
+      return null;
+    if (!Object.hasOwn(event ?? {}, "modelUsage")) {
+      if (this.claudeUsageMode !== "model_usage")
+        return;
+      return event?.usage ? this.lockClaudeUsageMode() : null;
+    }
+    if (this.claudeUsageMode === "legacy")
+      return this.lockClaudeUsageMode();
+    if (this.claudeUsageMode === "unknown")
+      this.claudeUsageMode = "model_usage";
+    this.claudeUsageSession ??= backendSessionId;
+    if (this.claudeUsageSession !== null && this.claudeUsageSession !== backendSessionId) {
+      return this.lockClaudeUsageMode();
+    }
+    if (!event.modelUsage || typeof event.modelUsage !== "object" || Array.isArray(event.modelUsage)) {
+      return null;
+    }
+    const entries = Object.entries(event.modelUsage);
+    if (entries.length === 0)
+      return null;
+    const highWater = new Map;
+    let input = 0;
+    let output = 0;
+    let cacheRead = 0;
+    let cacheWrite = 0;
+    let snapshotCost = 0;
+    for (const [model, rawValue] of entries) {
+      if (!model.trim() || !rawValue || typeof rawValue !== "object" || Array.isArray(rawValue)) {
+        return null;
+      }
+      const raw = rawValue;
+      const current = {
+        inputTokens: safeCount(raw.inputTokens),
+        outputTokens: safeCount(raw.outputTokens),
+        cacheReadInputTokens: safeCount(raw.cacheReadInputTokens),
+        cacheCreationInputTokens: safeCount(raw.cacheCreationInputTokens),
+        costUSD: safeMoney(raw.costUSD)
+      };
+      if (Object.values(current).some((value) => value === null)) {
+        return null;
+      }
+      const snapshot = current;
+      const prior = this.claudeModelUsageHighWater.get(model) ?? {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadInputTokens: 0,
+        cacheCreationInputTokens: 0,
+        costUSD: 0
+      };
+      for (const component of CLAUDE_USAGE_COMPONENTS) {
+        if (snapshot[component] < prior[component])
+          return null;
+      }
+      if (snapshot.costUSD < prior.costUSD)
+        return null;
+      const nextInput = safeAdd(input, snapshot.inputTokens - prior.inputTokens);
+      const nextOutput = safeAdd(output, snapshot.outputTokens - prior.outputTokens);
+      const nextCacheRead = safeAdd(cacheRead, snapshot.cacheReadInputTokens - prior.cacheReadInputTokens);
+      const nextCacheWrite = safeAdd(cacheWrite, snapshot.cacheCreationInputTokens - prior.cacheCreationInputTokens);
+      if (nextInput === null || nextOutput === null || nextCacheRead === null || nextCacheWrite === null) {
+        return null;
+      }
+      input = nextInput;
+      output = nextOutput;
+      cacheRead = nextCacheRead;
+      cacheWrite = nextCacheWrite;
+      snapshotCost += snapshot.costUSD;
+      if (!Number.isFinite(snapshotCost))
+        return null;
+      highWater.set(model, snapshot);
+    }
+    for (const model of this.claudeModelUsageHighWater.keys()) {
+      if (!highWater.has(model))
+        return null;
+    }
+    if (Object.hasOwn(event, "total_cost_usd")) {
+      const totalCost = safeMoney(event.total_cost_usd);
+      if (totalCost === null || !equalCost(snapshotCost, totalCost))
+        return null;
+    }
+    return { highWater, input, output, cacheRead, cacheWrite };
+  }
+  commitClaudeModelUsage(backendSessionId, projection) {
+    this.claudeUsageSession ??= backendSessionId;
+    this.claudeModelUsageHighWater = projection.highWater;
+    this.claudeUsageMode = "model_usage";
+  }
+  lockClaudeUsageMode() {
+    this.claudeUsageMode = "invalid";
+    return null;
   }
 }
 
@@ -1463,6 +1653,7 @@ class ClaudeTurnProtocol {
   segmentOwnerUuid = null;
   delivered = new Map;
   awaitingFollowOn = false;
+  interruptRequested = false;
   finalized = false;
   beginTurn() {
     const uuid = randomUUID4();
@@ -1471,6 +1662,7 @@ class ClaudeTurnProtocol {
     this.delivered.clear();
     this.delivered.set(uuid, { acknowledged: false, followOn: false });
     this.awaitingFollowOn = false;
+    this.interruptRequested = false;
     this.finalized = false;
     return this.receipt(uuid);
   }
@@ -1497,6 +1689,13 @@ class ClaudeTurnProtocol {
       return false;
     return this.delivered.get(this.rootUuid)?.acknowledged === true;
   }
+  hasActiveTurn() {
+    return this.rootUuid !== null && !this.finalized;
+  }
+  noteInterruptRequested() {
+    if (this.hasActiveTurn())
+      this.interruptRequested = true;
+  }
   claimResult(userMessageUuid) {
     if (this.finalized || !this.rootUuid || userMessageUuid !== this.segmentOwnerUuid)
       return null;
@@ -1513,6 +1712,19 @@ class ClaudeTurnProtocol {
     this.finalized = true;
     return this.receipt(this.rootUuid);
   }
+  claimInterruptedResult() {
+    if (this.finalized || !this.rootUuid || !this.interruptRequested)
+      return null;
+    const unacknowledged = [...this.delivered.values()].filter((input) => !input.acknowledged);
+    if (unacknowledged.length > 0) {
+      this.awaitingFollowOn = true;
+      for (const input of unacknowledged)
+        input.followOn = true;
+      return null;
+    }
+    this.finalized = true;
+    return this.receipt(this.rootUuid);
+  }
   receipt(uuid) {
     return `claude:${uuid}`;
   }
@@ -1538,7 +1750,9 @@ class ClaudeDriver {
   };
   turnProtocol = new ClaudeTurnProtocol;
   eventNormalizer = new ClaudeEventNormalizer(this.turnProtocol);
+  pendingInterrupt;
   beginTurn() {
+    this.pendingInterrupt = undefined;
     const receipt = this.turnProtocol.beginTurn();
     this.eventNormalizer.beginTurn();
     return receipt;
@@ -1577,11 +1791,45 @@ class ClaudeDriver {
     return { process: proc };
   }
   normalizeLine(line) {
-    return this.eventNormalizer.normalizeLine(line);
+    const events = this.eventNormalizer.normalizeLine(line);
+    this.flushPendingInterrupt();
+    return events;
   }
   get currentSessionId() {
     return this.eventNormalizer.currentSessionId;
   }
+  async interrupt(input, process2) {
+    const stdin = process2.stdin;
+    if (!this.turnProtocol.hasActiveTurn() || !stdin || stdin.destroyed || stdin.writableEnded || stdin.writable === false)
+      return false;
+    this.turnProtocol.noteInterruptRequested();
+    if (!this.turnProtocol.acceptsTurnWork()) {
+      this.pendingInterrupt ??= { input, process: process2 };
+      return true;
+    }
+    this.writeInterrupt(input, process2);
+    return true;
+  }
+  writeInterrupt(input, process2) {
+    process2.stdin.write(JSON.stringify({
+      type: "control_request",
+      request_id: input.requestId ?? randomUUID5(),
+      request: { subtype: "interrupt" }
+    }) + `
+`);
+  }
+  flushPendingInterrupt() {
+    const pending = this.pendingInterrupt;
+    if (!pending || !this.turnProtocol.acceptsTurnWork())
+      return;
+    this.pendingInterrupt = undefined;
+    const stdin = pending.process.stdin;
+    if (!stdin || stdin.destroyed || stdin.writableEnded || stdin.writable === false)
+      return;
+    try {
+      this.writeInterrupt(pending.input, pending.process);
+    } catch {}
+  }
   encodeMessage(text, sessionId, opts) {
     const uuid = opts?.mode === "idle" ? this.turnProtocol.rootInputUuid() : this.turnProtocol.steeringInputUuid();
     return JSON.stringify({
@@ -1713,6 +1961,35 @@ import { randomBytes } from "node:crypto";
 var codexQuotaSourceEpoch = randomBytes(16).toString("base64url");
 var codexQuotaSourceGeneration = 0;
 var codexAccountFingerprint = null;
+var CODEX_ERROR_INFO_CODES = new Set([
+  "contextWindowExceeded",
+  "sessionBudgetExceeded",
+  "usageLimitExceeded",
+  "serverOverloaded",
+  "cyberPolicy",
+  "misalignmentPolicyViolation",
+  "internalServerError",
+  "unauthorized",
+  "badRequest",
+  "threadRollbackFailed",
+  "sandboxError",
+  "other",
+  "httpConnectionFailed",
+  "responseStreamConnectionFailed",
+  "responseStreamDisconnected",
+  "responseTooManyFailedAttempts",
+  "activeTurnNotSteerable"
+]);
+function snakeCase(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
+function codexErrorInfoCode(value, fallback) {
+  const label = typeof value === "string" ? value : value && typeof value === "object" && !Array.isArray(value) ? Object.keys(value)[0] : undefined;
+  return label && CODEX_ERROR_INFO_CODES.has(label) ? `codex.${snakeCase(label)}` : fallback;
+}
+function codexRpcErrorCode(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) ? `codex.rpc.${value}` : "codex.rpc_error";
+}
 function rotateCodexQuotaSource() {
   codexQuotaSourceEpoch = randomBytes(16).toString("base64url");
   codexQuotaSourceGeneration += 1;
@@ -1870,7 +2147,11 @@ class CodexEventNormalizer {
       return this.replaceQuotaSnapshots(msg.result ?? {});
     }
     if (msg?.error && msg.id !== undefined) {
-      return [{ kind: "error", message: msg.error?.message ?? "Codex RPC error" }];
+      return [{
+        kind: "error",
+        code: codexRpcErrorCode(msg.error?.code),
+        message: msg.error?.message ?? "Codex RPC error"
+      }];
     }
     if (msg?.result?.thread?.id) {
       return this.adoptAndInit(msg.result.thread.id);
@@ -1939,20 +2220,26 @@ class CodexEventNormalizer {
           return [];
         this.releaseUsageForTurn(params.threadId, params.turn.id);
         if (params.turn.status === "failed") {
+          const error = params.turn.error;
           return [
-            { kind: "error", message: "Codex turn failed" },
+            {
+              kind: "error",
+              code: codexErrorInfoCode(error?.codexErrorInfo, "codex.turn_failed"),
+              message: error?.message ?? "Codex turn failed"
+            },
             { kind: "turn_end", sessionId: this.threadId ?? undefined, turnOwner: this.turnReceipt(params.threadId, params.turn.id) }
           ];
         }
-        if (params.turn.status === "interrupted") {
-          return [{ kind: "error", message: "Codex turn interrupted" }, { kind: "turn_end", sessionId: this.threadId ?? undefined, turnOwner: this.turnReceipt(params.threadId, params.turn.id) }];
-        }
         return [{ kind: "turn_end", sessionId: this.threadId ?? undefined, turnOwner: this.turnReceipt(params.threadId, params.turn.id) }];
       case "error":
         if (params?.willRetry === true) {
           return [{ kind: "runtime_recovery", stage: "retrying", source: "codex_stream" }];
         }
-        return [{ kind: "error", message: params?.error?.message ?? params?.message ?? "Codex error" }];
+        return [{
+          kind: "error",
+          code: codexErrorInfoCode(params?.error?.codexErrorInfo, "codex.error"),
+          message: params?.error?.message ?? params?.message ?? "Codex error"
+        }];
       case "thread/tokenUsage/updated":
         return [];
       case "account/rateLimits/updated":
@@ -2049,42 +2336,46 @@ class CodexEventNormalizer {
   }
   handleItemStarted(params) {
     const t = params?.item?.type ?? params?.type;
+    const callId = this.itemCallId(params);
+    const identity = callId ? { callId } : {};
     switch (t) {
       case "commandExecution":
-        return [{ kind: "tool_call", name: "shell", input: params?.item }];
+        return [{ kind: "tool_call", ...identity, name: "shell", input: params?.item }];
       case "contextCompaction":
         return [{ kind: "compaction_started" }];
       case "enteredReviewMode":
         return [{ kind: "review_started" }];
       case "fileChange":
-        return [{ kind: "tool_call", name: "file_change", input: normalizeFileChangeInput(params?.item) }];
+        return [{ kind: "tool_call", ...identity, name: "file_change", input: normalizeFileChangeInput(params?.item) }];
       case "mcpToolCall":
-        return [{ kind: "tool_call", name: `mcp_${params?.item?.name ?? "tool"}`, input: params?.item }];
+        return [{ kind: "tool_call", ...identity, name: `mcp_${params?.item?.tool ?? params?.item?.name ?? "tool"}`, input: params?.item }];
       case "webSearch":
-        return [{ kind: "tool_call", name: "web_search", input: params?.item }];
+        return [{ kind: "tool_call", ...identity, name: "web_search", input: params?.item }];
       case "collabAgentToolCall":
-        return [{ kind: "tool_call", name: "collab_tool_call", input: params?.item }];
+        return [{ kind: "tool_call", ...identity, name: "collab_tool_call", input: params?.item }];
       default:
         return [];
     }
   }
   handleItemCompleted(params) {
     const t = params?.item?.type ?? params?.type;
+    const callId = this.itemCallId(params);
+    const identity = callId ? { callId } : {};
     switch (t) {
       case "commandExecution":
-        return [{ kind: "tool_output", name: "shell" }];
+        return [{ kind: "tool_output", ...identity, name: "shell" }];
       case "contextCompaction":
         return [{ kind: "compaction_finished" }];
       case "exitedReviewMode":
         return [{ kind: "review_finished" }];
       case "fileChange":
-        return [{ kind: "tool_output", name: "file_change" }];
+        return [{ kind: "tool_output", ...identity, name: "file_change" }];
       case "mcpToolCall":
-        return [{ kind: "tool_output", name: `mcp_${params?.item?.name ?? "tool"}` }];
+        return [{ kind: "tool_output", ...identity, name: `mcp_${params?.item?.tool ?? params?.item?.name ?? "tool"}` }];
       case "webSearch":
-        return [{ kind: "tool_output", name: "web_search" }];
+        return [{ kind: "tool_output", ...identity, name: "web_search" }];
       case "collabAgentToolCall":
-        return [{ kind: "tool_output", name: "collab_tool_call" }];
+        return [{ kind: "tool_output", ...identity, name: "collab_tool_call" }];
       case "agentMessage":
         return [{ kind: "assistant_message_completed", text: params?.item?.text ?? "" }];
       case "reasoning":
@@ -2093,6 +2384,10 @@ class CodexEventNormalizer {
         return [];
     }
   }
+  itemCallId(params) {
+    const value = params?.item?.id ?? params?.itemId;
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+  }
 }
 
 // agent-driver/dist/adapters/codex/home.js
@@ -2563,6 +2858,16 @@ class CodexDriver {
   get currentSessionId() {
     return this.eventNormalizer.currentSessionId;
   }
+  async interrupt(_input, process2) {
+    const threadId = this.eventNormalizer.currentSessionId;
+    const turnId = this.eventNormalizer.currentTurnId;
+    const stdin = process2.stdin;
+    if (!threadId || !turnId || !stdin || stdin.destroyed || stdin.writableEnded || stdin.writable === false)
+      return false;
+    stdin.write(jsonRpcRequest("turn/interrupt", { threadId, turnId }, this.nextRequestId()) + `
+`);
+    return true;
+  }
   buildTurnStart(threadId, text) {
     return jsonRpcRequest("turn/start", { threadId, input: [{ type: "text", text }] }, this.nextRequestId());
   }
@@ -2818,7 +3123,8 @@ class CursorAcpLane {
   started = false;
   ready = false;
   sessionId = null;
-  activePrompt = null;
+  currentPromptRequestId = null;
+  terminalOwner = null;
   requestedStopReason;
   spawnPromise;
   stopPromise;
@@ -2890,16 +3196,19 @@ class CursorAcpLane {
   async send(input) {
     if (!this.ready || !this.process || this.isClosed())
       return { ok: false, reason: "closed" };
-    if (input.mode !== "idle") {
-      return { ok: false, reason: "unsupported", error: "Cursor ACP does not support mid-turn steering" };
+    if (input.mode === "busy") {
+      if (this.currentPromptRequestId === null) {
+        return { ok: false, reason: "runtime_busy", error: "Cursor ACP has no active prompt to steer" };
+      }
+      return this.admitPrompt(input.text, "steer");
     }
-    if (this.activePrompt) {
+    if (this.currentPromptRequestId !== null) {
       return { ok: false, reason: "runtime_busy", error: "Cursor ACP prompt is still active" };
     }
     return this.admitPrompt(input.text);
   }
   async interrupt(_input) {
-    if (!this.ready || !this.sessionId || !this.activePrompt || this.isClosed())
+    if (!this.ready || !this.sessionId || this.currentPromptRequestId === null || this.isClosed())
       return false;
     this.write({ jsonrpc: "2.0", method: "session/cancel", params: { sessionId: this.sessionId } });
     return true;
@@ -2907,7 +3216,8 @@ class CursorAcpLane {
   stop(input = {}) {
     this.requestedStopReason ??= input.reason ?? "requested_stop";
     this.ready = false;
-    this.activePrompt = null;
+    this.currentPromptRequestId = null;
+    this.terminalOwner = null;
     this.openToolCalls.clear();
     this.rejectAllPending(new Error("Cursor ACP lane stopped"));
     this.stopPromise ??= this.stopPhysicalOnce(input);
@@ -3013,19 +3323,22 @@ class CursorAcpLane {
       throw new CursorAcpIncompatibleError("Cursor ACP did not confirm the exact configured model");
     }
   }
-  admitPrompt(text) {
+  admitPrompt(text, delivery = "prompt") {
     if (!this.sessionId)
       return { ok: false, reason: "not_ready", error: "Cursor ACP session is not ready" };
-    if (this.activePrompt)
-      return { ok: false, reason: "runtime_busy", error: "Cursor ACP prompt is still active" };
     const requestId = ++this.requestSequence;
-    const active = {
+    const prompt = {
       requestId,
       receipt: `cursor:acp:${requestId}`
     };
+    const previousPromptRequestId = this.currentPromptRequestId;
+    const previousTerminalOwner = this.terminalOwner;
+    const previousOpenToolCalls = new Set(this.openToolCalls);
+    if (delivery === "prompt")
+      this.terminalOwner = prompt.receipt;
+    this.currentPromptRequestId = requestId;
     this.openToolCalls.clear();
-    this.activePrompt = active;
-    this.pending.set(requestId, { kind: "prompt", method: "session/prompt", active });
+    this.pending.set(requestId, { kind: "prompt", method: "session/prompt", prompt });
     try {
       this.write({
         jsonrpc: "2.0",
@@ -3038,41 +3351,51 @@ class CursorAcpLane {
       });
     } catch (error) {
       this.pending.delete(requestId);
-      if (this.activePrompt?.requestId === requestId)
-        this.activePrompt = null;
+      if (this.currentPromptRequestId === requestId) {
+        this.currentPromptRequestId = previousPromptRequestId;
+        this.terminalOwner = previousTerminalOwner;
+        this.openToolCalls.clear();
+        for (const toolCallId of previousOpenToolCalls)
+          this.openToolCalls.add(toolCallId);
+      }
       throw error;
     }
-    return { ok: true, acceptedAs: "prompt", receipt: active.receipt };
+    return { ok: true, acceptedAs: delivery, receipt: prompt.receipt };
   }
-  completePrompt(active, value) {
-    if (this.activePrompt?.requestId !== active.requestId)
+  completePrompt(prompt, value) {
+    if (this.currentPromptRequestId !== prompt.requestId)
       return;
     const result = record2(value);
     if (!result || typeof result.stopReason !== "string" || !PROMPT_STOP_REASONS.has(result.stopReason)) {
-      this.failPrompt(active, new Error("Cursor ACP prompt response did not contain a supported stopReason"));
+      this.failPrompt(prompt, new Error("Cursor ACP prompt response did not contain a supported stopReason"), "cursor.invalid_stop_reason");
       return;
     }
-    this.activePrompt = null;
+    const terminalOwner = this.terminalOwner ?? prompt.receipt;
+    this.currentPromptRequestId = null;
+    this.terminalOwner = null;
     this.openToolCalls.clear();
     this.events.emit("runtime_event", {
       kind: "turn_end",
       sessionId: this.sessionId ?? undefined,
-      turnOwner: active.receipt
+      turnOwner: terminalOwner
     });
   }
-  failPrompt(active, error) {
-    if (this.activePrompt?.requestId !== active.requestId)
+  failPrompt(prompt, error, code = "cursor.prompt_failed") {
+    if (this.currentPromptRequestId !== prompt.requestId)
       return;
-    this.activePrompt = null;
+    const terminalOwner = this.terminalOwner ?? prompt.receipt;
+    this.currentPromptRequestId = null;
+    this.terminalOwner = null;
     this.openToolCalls.clear();
     this.events.emit("runtime_event", {
       kind: "error",
+      code,
       message: error instanceof Error ? error.message : String(error)
     });
     this.events.emit("runtime_event", {
       kind: "turn_end",
       sessionId: this.sessionId ?? undefined,
-      turnOwner: active.receipt
+      turnOwner: terminalOwner
     });
   }
   call(method, params) {
@@ -3158,7 +3481,8 @@ class CursorAcpLane {
       }
       this.processTerminal = true;
       this.ready = false;
-      this.activePrompt = null;
+      this.currentPromptRequestId = null;
+      this.terminalOwner = null;
       this.openToolCalls.clear();
       this.stopPromise ??= this.stopPhysicalOnce({ reason: "runtime_error", forceAfterMs: 0 });
       this.stopPromise.catch(() => {});
@@ -3176,7 +3500,8 @@ class CursorAcpLane {
         return;
       this.processTerminal = true;
       this.ready = false;
-      this.activePrompt = null;
+      this.currentPromptRequestId = null;
+      this.terminalOwner = null;
       this.openToolCalls.clear();
       this.rejectAllPending(new Error("Cursor ACP process exited"));
       if (this.suppressExit || !this.processActivated)
@@ -3218,11 +3543,12 @@ class CursorAcpLane {
       this.pending.delete(id);
       if (message.error !== undefined) {
         const payload = record2(message.error);
-        this.failPrompt(pending.active, new CursorAcpRpcError(pending.method, typeof payload?.code === "number" ? payload.code : undefined, rpcErrorMessage(message.error)));
+        const rpcCode = typeof payload?.code === "number" && Number.isSafeInteger(payload.code) ? payload.code : undefined;
+        this.failPrompt(pending.prompt, new CursorAcpRpcError(pending.method, rpcCode, rpcErrorMessage(message.error)), rpcCode === undefined ? "cursor.rpc_error" : `cursor.rpc.${rpcCode}`);
       } else if (!("result" in message)) {
-        this.failPrompt(pending.active, new Error("Cursor ACP response omitted result"));
+        this.failPrompt(pending.prompt, new Error("Cursor ACP response omitted result"), "cursor.invalid_response");
       } else {
-        this.completePrompt(pending.active, message.result);
+        this.completePrompt(pending.prompt, message.result);
       }
       return;
     }
@@ -3263,7 +3589,7 @@ class CursorAcpLane {
     const sameSession = payload?.sessionId === this.sessionId;
     const options = Array.isArray(payload?.options) ? payload.options.map(record2).filter(Boolean) : [];
     const allowOnce = options.find((option) => option.kind === "allow_once" && typeof option.optionId === "string" && option.optionId.trim().length > 0);
-    if (!this.ready || !this.activePrompt || !sameSession || !allowOnce) {
+    if (!this.ready || this.currentPromptRequestId === null || !sameSession || !allowOnce) {
       this.write({ jsonrpc: "2.0", id, result: { outcome: { outcome: "cancelled" } } });
       this.diagnostic("error", "Cursor ACP permission request was not allowed for the active prompt");
       return;
@@ -3287,7 +3613,7 @@ class CursorAcpLane {
       this.diagnostic("warning", "Cursor ACP emitted an update for a different session");
       return;
     }
-    if (!this.ready || !this.activePrompt) {
+    if (!this.ready || this.currentPromptRequestId === null) {
       this.diagnostic("warning", "Cursor ACP emitted a session update without an active prompt");
       return;
     }
@@ -3505,7 +3831,11 @@ function parseModelRef(model) {
 function messageFromError(value) {
   const payload = record3(value);
   const message = typeof payload?.message === "string" && payload.message.trim() ? payload.message : undefined;
-  return message ? "OpenCode turn failed" : "OpenCode reported an inconsistent turn outcome";
+  return message ?? "OpenCode reported an inconsistent turn outcome";
+}
+function codeFromError(value) {
+  const payload = record3(value);
+  return payload?.type === "unknown" ? "opencode.unknown" : "opencode.step_failed";
 }
 
 class OpenCodeServiceLane {
@@ -4173,7 +4503,10 @@ class OpenCodeServiceLane {
           root.outcomes.push({
             seq,
             ok: successful,
-            ...!successful ? { message: "OpenCode reported an unsupported final step outcome" } : {}
+            ...!successful ? {
+              code: "opencode.unsupported_finish",
+              message: "OpenCode reported an unsupported final step outcome"
+            } : {}
           });
         }
         const tokens = record3(data.tokens);
@@ -4202,7 +4535,12 @@ class OpenCodeServiceLane {
         break;
       }
       case "session.next.step.failed":
-        root.outcomes.push({ seq, ok: false, message: messageFromError(data.error) });
+        root.outcomes.push({
+          seq,
+          ok: false,
+          code: codeFromError(data.error),
+          message: messageFromError(data.error)
+        });
         break;
       default:
         break;
@@ -4382,11 +4720,11 @@ class OpenCodeServiceLane {
         return;
       const outcome = root.outcomes.filter((item) => item.seq > maxAdmission).sort((left, right) => left.seq - right.seq).at(-1);
       if (!root.interrupted && !outcome) {
-        this.settleRoot(root, false, "OpenCode drain settled without a durable turn outcome");
+        this.settleRoot(root, false, "OpenCode drain settled without a durable turn outcome", "opencode.missing_outcome");
         return;
       }
       if (outcome && !outcome.ok) {
-        this.settleRoot(root, false, outcome.message ?? "OpenCode turn failed");
+        this.settleRoot(root, false, outcome.message ?? "OpenCode turn failed", outcome.code ?? "opencode.turn_failed");
         return;
       }
       this.settleRoot(root, true);
@@ -4412,7 +4750,7 @@ class OpenCodeServiceLane {
   barrierStillCurrent(root, identity, generation) {
     return this.activeRoot === root && root.generation === generation && root.pendingAdmissions === 0 && !root.interruptPending && this.isIdentity(identity) && this.identityMatches();
   }
-  settleRoot(root, success, message) {
+  settleRoot(root, success, message, code = "opencode.turn_failed") {
     if (this.activeRoot !== root)
       return;
     this.activeRoot = null;
@@ -4420,6 +4758,7 @@ class OpenCodeServiceLane {
     if (!success) {
       this.events.emit("runtime_event", {
         kind: "error",
+        code,
         message: message ?? "OpenCode turn failed"
       });
     }
@@ -4935,7 +5274,11 @@ function mapPiSdkEvent(event, sessionId, state) {
         return [{ kind: "assistant_message_completed", text: d.content ?? "" }];
       }
       case "error":
-        return [{ kind: "error", message: d.error?.errorMessage ?? "Pi error" }];
+        return [{
+          kind: "error",
+          code: "pi.message_error",
+          message: d.error?.errorMessage ?? "Pi error"
+        }];
       default:
         return [];
     }
@@ -5215,7 +5558,7 @@ var capabilities = {
     commandOverride: true,
     resume: "by_id",
     sessionLifetime: "persistent",
-    midTurnDelivery: "next_turn_queue",
+    midTurnDelivery: "steer",
     interrupt: true
   },
   opencode: {
@@ -5523,7 +5866,9 @@ class LogicalAgentSession {
   interruptedTurnId;
   processTurnEnded = false;
   stopRequestId;
-  outstandingToolUses = 0;
+  anonymousOutstandingToolUses = 0;
+  outstandingToolCallIds = new Set;
+  toolLifecycleMismatchCount = 0;
   compacting = false;
   reviewing = false;
   steeringDeliveries = new Set;
@@ -5713,6 +6058,9 @@ class LogicalAgentSession {
           queueDwellCount: this.metricValue(this.queueDwellCount),
           queueDwellTotalMs: this.metricValue(this.queueDwellTotalMs),
           sseReconnectCount: this.metricValue(this.sseReconnectCount),
+          outstandingToolUses: this.outstandingToolUseCount(),
+          anonymousOutstandingToolUses: this.metricValue(this.anonymousOutstandingToolUses),
+          toolLifecycleMismatchCount: this.metricValue(this.toolLifecycleMismatchCount),
           resumeOutcome: this.resumeOutcome,
           terminalOwnerKind: this.adapter.execution.terminalOwnership
         }
@@ -6032,15 +6380,36 @@ class LogicalAgentSession {
         }
         return;
       case "tool_call":
-        this.outstandingToolUses += 1;
-        if (turnId)
-          this.emit({ type: "tool_started", turnId, name: event.name, input: jsonValue(event.input) });
+        if (!turnId) {
+          this.toolLifecycleMismatchCount += 1;
+          return;
+        }
+        if (!this.startToolUse(event.callId))
+          return;
+        const startedCallId = this.toolCallId(event.callId);
+        this.emit({
+          type: "tool_started",
+          turnId,
+          ...startedCallId ? { callId: startedCallId } : {},
+          name: event.name,
+          input: jsonValue(event.input)
+        });
         return;
       case "tool_output":
-        this.outstandingToolUses = Math.max(0, this.outstandingToolUses - 1);
-        if (turnId)
-          this.emit({ type: "tool_finished", turnId, name: event.name });
-        if (this.outstandingToolUses === 0 && !this.toolBoundaryFlushDisabled)
+        if (!turnId) {
+          this.toolLifecycleMismatchCount += 1;
+          return;
+        }
+        if (!this.finishToolUse(event.callId))
+          return;
+        const finishedCallId = this.toolCallId(event.callId);
+        this.emit({
+          type: "tool_finished",
+          turnId,
+          ...finishedCallId ? { callId: finishedCallId } : {},
+          name: event.name
+        });
+        if (this.outstandingToolUseCount() === 0 && !this.toolBoundaryFlushDisabled)
           this.flushSafeBoundaryQueue();
         return;
       case "compaction_started":
@@ -6096,7 +6465,7 @@ class LogicalAgentSession {
       }
       case "error":
         this.toolBoundaryFlushDisabled = true;
-        this.turnError = driverError("process", "runtime_error", event.message, true);
+        this.turnError = driverError("process", stableErrorCode(event.code, "runtime_error"), event.message, true);
         this.emit({
           type: "diagnostic",
           turnId,
@@ -6183,7 +6552,7 @@ class LogicalAgentSession {
     this.activeTurn = undefined;
     this.turnError = undefined;
     this.interruptedTurnId = undefined;
-    this.outstandingToolUses = 0;
+    this.clearOutstandingToolUses();
     this.compacting = false;
     this.reviewing = false;
     this.toolBoundaryFlushDisabled = false;
@@ -6207,7 +6576,7 @@ class LogicalAgentSession {
     return this.safeBoundaryFlush;
   }
   canFlushSafeBoundaryQueue() {
-    return this.state === "working" && this.behavior.midTurnDelivery === "safe_boundary_queue" && this.outstandingToolUses === 0 && !this.compacting && !this.reviewing && this.activeTurn !== undefined && this.lane !== null && this.queued.length > 0;
+    return this.state === "working" && this.behavior.midTurnDelivery === "safe_boundary_queue" && this.outstandingToolUseCount() === 0 && !this.compacting && !this.reviewing && this.activeTurn !== undefined && this.lane !== null && this.queued.length > 0;
   }
   async drainSafeBoundaryQueue() {
     while (this.canFlushSafeBoundaryQueue()) {
@@ -6388,7 +6757,7 @@ class LogicalAgentSession {
       return "compacting";
     if (this.reviewing)
       return "reviewing";
-    if (this.outstandingToolUses > 0)
+    if (this.outstandingToolUseCount() > 0)
       return "tool_wait";
     if (this.activeTurn)
       return "working";
@@ -6398,6 +6767,46 @@ class LogicalAgentSession {
     const now = this.host.now();
     return Number.isFinite(now) && now >= 0 ? now : 0;
   }
+  outstandingToolUseCount() {
+    return this.anonymousOutstandingToolUses + this.outstandingToolCallIds.size;
+  }
+  startToolUse(rawCallId) {
+    const callId = this.toolCallId(rawCallId);
+    if (!callId) {
+      this.anonymousOutstandingToolUses += 1;
+      return true;
+    }
+    if (this.outstandingToolCallIds.has(callId)) {
+      this.toolLifecycleMismatchCount += 1;
+      return false;
+    }
+    this.outstandingToolCallIds.add(callId);
+    return true;
+  }
+  finishToolUse(rawCallId) {
+    const callId = this.toolCallId(rawCallId);
+    if (!callId) {
+      if (this.anonymousOutstandingToolUses === 0) {
+        this.toolLifecycleMismatchCount += 1;
+        return false;
+      }
+      this.anonymousOutstandingToolUses -= 1;
+      return true;
+    }
+    if (!this.outstandingToolCallIds.delete(callId)) {
+      this.toolLifecycleMismatchCount += 1;
+      return false;
+    }
+    return true;
+  }
+  clearOutstandingToolUses() {
+    this.anonymousOutstandingToolUses = 0;
+    this.outstandingToolCallIds.clear();
+  }
+  toolCallId(rawCallId) {
+    const callId = rawCallId?.trim();
+    return callId && callId.length <= 1024 ? callId : undefined;
+  }
   metricValue(value) {
     return Number.isFinite(value) && value >= 0 ? value : 0;
   }
@@ -7892,6 +8301,7 @@ function reduceManager(state, event) {
         if ((lease.state === "active" || lease.state === "suspect_active") && lease.outstandingToolUses !== undefined) {
           const unblockedLease = { ...lease };
           delete unblockedLease.outstandingToolUses;
+          delete unblockedLease.outstandingToolCallIds;
           a.execution.lease = unblockedLease;
         }
       });
@@ -8152,26 +8562,40 @@ function onTurnToolLifecycle(state, event, lifecycle) {
   const matchesTerminal = lifecycle === "started" && current.state === "none" && current.lastTerminal !== null && sameIdentity(current.lastTerminal.identity, identity);
   if (!matchesActive && !matchesTerminal)
     return { state, effects: [] };
-  if (lifecycle === "finished" && matchesActive && (current.outstandingToolUses ?? 0) === 0) {
-    return { state, effects: [] };
-  }
   return mutate(state, event.agentId, (agent) => {
     if (!matchesSession(agent, event.sessionInstanceId))
       return;
     const lease = agent.execution.lease;
+    const callId = normalizedToolCallId(event.callId);
     if ((lease.state === "active" || lease.state === "suspect_active") && sameIdentity(lease.identity, identity)) {
-      const outstandingToolUses = (lease.outstandingToolUses ?? 0) + (lifecycle === "started" ? 1 : -1);
+      const identified = new Set(lease.outstandingToolCallIds ?? []);
+      const currentCount = lease.outstandingToolUses ?? 0;
+      const anonymousCount = Math.max(0, currentCount - identified.size);
+      if (lifecycle === "started") {
+        if (callId && identified.has(callId))
+          return;
+        if (callId)
+          identified.add(callId);
+      } else if (callId) {
+        if (!identified.delete(callId))
+          return;
+      } else if (anonymousCount === 0) {
+        return;
+      }
+      const outstandingToolUses = currentCount + (lifecycle === "started" ? 1 : -1);
       if (outstandingToolUses > 0) {
         agent.execution.lease = {
           ...lease,
           lastWorkAt: event.nowMs,
           nativeDeadlineAt: event.nowMs + agent.turnSilence.normalBudgetMs,
           recoveryExtensionsUsed: 0,
-          outstandingToolUses
+          outstandingToolUses,
+          ...identified.size > 0 ? { outstandingToolCallIds: [...identified] } : {}
         };
       } else {
         const unblockedLease = { ...lease };
         delete unblockedLease.outstandingToolUses;
+        delete unblockedLease.outstandingToolCallIds;
         agent.execution.lease = {
           ...unblockedLease,
           lastWorkAt: event.nowMs,
@@ -8190,6 +8614,7 @@ function onTurnToolLifecycle(state, event, lifecycle) {
         nativeDeadlineAt: event.nowMs + agent.turnSilence.normalBudgetMs,
         recoveryExtensionsUsed: 0,
         outstandingToolUses: 1,
+        ...callId ? { outstandingToolCallIds: [callId] } : {},
         reason: "work_after_terminal"
       };
     }
@@ -8353,6 +8778,10 @@ function identityOf(event) {
 function sameIdentity(left, right) {
   return left.sessionInstanceId === right.sessionInstanceId && left.turnId === right.turnId;
 }
+function normalizedToolCallId(rawCallId) {
+  const callId = rawCallId?.trim();
+  return callId && callId.length <= 1024 ? callId : undefined;
+}
 function leaseIsWorking(lease) {
   return lease.state === "active" || lease.state === "suspect_active";
 }
@@ -8432,13 +8861,13 @@ function cliCommandsSection() {
     "",
     "### Messaging",
     "",
-    `1. \`${CLI} inbox pull\` — fetch unread messages; \`--no-ack\` peeks without advancing.`,
+    `1. \`${CLI} inbox pull\` — fetch unread messages and advance their read waterlines.`,
     `2. \`${CLI} message send --target <ref> --remind-after <0|Nm|Nh> --stdin\` — send to a ` + `channel, DM, or thread. ` + `The body is required through \`--stdin\` and limited to 1 KiB of UTF-8. ` + `Attach uploaded files with \`--attachment <id>\` (repeatable, order matters). ` + `\`--remind-after\` accepts \`0\`, or a whole-number duration from \`1m\` to \`24h\`.`,
     `3. \`${CLI} message attachment upload --target <ref> --file <path>\` — upload a file; ` + `returns an id stable across pending→persisted.`,
     `4. \`${CLI} message attachment download --id <id> [--out <path>]\` — download any ` + `attachment you can see (or your own pending uploads).`,
-    `5. \`${CLI} message emoji --target <ref> --emoji <e>\` — react with a single emoji. ` + `Works on channel messages (\`/<server>/<channel>#N\`), DM messages ` + `(\`/.dm/<peer>#N\`), and thread-reply messages (\`/<server>/<channel>/#N#M\`).`,
-    `6. \`${CLI} message mark set --target <full-message-ref>\` — persist a message as outstanding work.`,
-    `7. \`${CLI} message mark remove --target <full-message-ref>\` — clear a completed message mark.`,
+    `5. \`${CLI} message property set --target <full-message-ref> --json <json>\` — add a supported property value to a message.`,
+    `6. \`${CLI} message property list --target <full-message-ref>\` — list the message's current properties and supported capabilities.`,
+    `7. \`${CLI} message property remove --target <full-message-ref> --json <json>\` — remove a supported property value from a message.`,
     `8. \`${CLI} message mark list\` — list every currently visible marked message with its full content.`,
     "",
     "### Servers",
@@ -8446,12 +8875,14 @@ function cliCommandsSection() {
     `1. \`${CLI} server list\` — list your servers.`,
     `2. \`${CLI} server member --server <name#discriminator>\` — list a server's members.`,
     `3. \`${CLI} server join --invite <link>\` — join via invite link or token.`,
+    `4. \`${CLI} server leave --server <name#NNNN>\` — leave a server you belong to. A server owner cannot leave.`,
     "",
     "### Channels",
     "",
     `1. \`${CLI} channel list --server <name#discriminator>\` — list top-level channels, grouped by ` + `category; each is marked \`public\` or \`private\`.`,
     `2. \`${CLI} channel history --channel <ref>\` — read a channel's or thread's past messages ` + `(the context you weren't awake for). Page with \`--before N\` / \`--after N\` (seq N as ` + "anchor), `--around N` to center on a message, `--limit N` for page size.",
     `3. \`${CLI} channel member --channel <ref>\` — roster of a channel or thread. A private ` + `channel/forum returns its concrete member list; a public one returns a hint pointing at ` + `\`${CLI} server member\` (its audience is the whole server).`,
+    `4. \`${CLI} channel leave --channel <ref>\` — leave a thread or private channel/forum. Public channels require leaving their server; DMs cannot be left.`,
     "",
     "### Friends",
     "",
@@ -8504,6 +8935,15 @@ function messagingSection() {
     "Reply where the message came from. Post results in the channel that owns the topic. " + "When uncertain, read history (below) or DM the relevant people.",
     "Write every message body in the stdin/heredoc block; never place it directly on the command line.",
     "",
+    "### Message properties",
+    "",
+    `Message properties are capabilities determined by the target message's channel type. \`${CLI} ` + "message property list --target <full-message-ref>` returns its current values and supported `capabilities`.",
+    "",
+    `- \`emoji\` works on text-channel, DM, and thread messages. Set or remove your own reaction with ` + `\`{"type":"emoji","value":"\uD83D\uDC4D"}\`; \`list\` shows everyone who reacted. Add: ` + `\`${CLI} message property set --target <full-message-ref> --json '{"type":"emoji","value":"\uD83D\uDC4D"}'\`.`,
+    `- \`tag\` works on forum opener messages. Set or remove named tags with ` + `\`{"type":"tag","value":["bug","ready"]}\`. A forum reply is a thread message, so it ` + `supports \`emoji\`, not \`tag\`. Add: \`${CLI} message property set --target ` + `<full-message-ref> --json '{"type":"tag","value":["bug"]}'\`.`,
+    `- \`mark\` works on every message. Mark outstanding work with \`{"type":"mark","value":true}\`: ` + `\`${CLI} message property set --target <full-message-ref> --json ` + `'{"type":"mark","value":true}'\`. Clear it with the same JSON through ` + `\`message property remove\`. Use \`${CLI} message mark list\` for the one-shot global view ` + `of all currently visible marked messages.`,
+    "- `archived` is a reserved tag meaning the forum post is complete. Setting it hides the " + "post from the normal forum feed; removing it reopens the post.",
+    "",
     "### Context refs",
     "",
     "Path-style refs:",
@@ -8616,6 +9056,7 @@ function criticalRulesSection() {
     `- **\`${CLI}\` is the only way to communicate.** Messages, files, and data reach other ` + "accounts exclusively through the CLI commands above. Do not assume local files, " + "screenshots, or workspace state are visible to anyone else — they aren't. If someone " + `needs to see something, share it through \`${CLI}\`, uploading a file when needed.`,
     "- **Never expose tokens, keys, or secrets.** Redact credential-like strings from tool output " + "before sharing.",
     "- **Match the sender's language.** Reply in the language they wrote in.",
+    `- **Leaving a scope is destructive.** Use \`${CLI} channel leave\` or \`${CLI} server leave\` only after your owner explicitly asks you to leave that exact scope.`,
     "- **Channel alignment**: you can't send to a channel with unread messages. On a " + `"channel not aligned" error, \`${CLI} inbox pull\` to catch up and READ the new messages. ` + "Judge if your message is still needed or overlaps with what just landed. Adjust or skip; " + "don't mechanically resend."
   ].join(`
 `);
@@ -8628,7 +9069,7 @@ function executionModelSection() {
     "",
     "On wake, restore durable context from `memory.md` and the context timeline, then pull your inbox. " + "Follow *Outstanding work marks* below before taking new work.",
     "",
-    "`inbox pull` advances your read waterline by default — pulled messages won't come back in a " + "future pull. A task-bearing message stays durable through its server mark even after the " + "read waterline advances."
+    "`inbox pull` advances your read waterline — pulled messages won't come back in a " + "future pull. A task-bearing message stays durable through its server mark even after the " + "read waterline advances."
   ].join(`
 `);
 }
@@ -8700,9 +9141,9 @@ function workspaceMemorySection(config) {
     "",
     "### Outstanding work marks",
     "",
-    "Marks are the durable work queue. If a message requires work beyond an immediate reply, " + `acknowledge it, then run \`${CLI} message mark set --target <full-message-ref>\` before ` + "starting or queuing. Do not mark a message you answer immediately.",
+    "Marks are the durable work queue. If a message requires work beyond an immediate reply, " + `acknowledge it, then run \`${CLI} message property set --target <full-message-ref> ` + `--json '{"type":"mark","value":true}'\` before ` + "starting or queuing. Do not mark a message you answer immediately.",
     "",
-    "Keep it marked while the work is active, queued, or blocked; report blockers where the task " + `came from. Run \`${CLI} message mark remove --target <full-message-ref>\` only after ` + "sending the result, or when the request is cancelled or superseded and nothing remains.",
+    "Keep it marked while the work is active, queued, or blocked; report blockers where the task " + `came from. Run \`${CLI} message property remove --target <full-message-ref> ` + `--json '{"type":"mark","value":true}'\` only after ` + "sending the result, or when the request is cancelled or superseded and nothing remains.",
     "",
     "If `inbox pull` returns a `markedReminder`, run " + `\`${CLI} message mark list\` before taking new work. Do not copy marked tasks into local files.`
   ].join(`
@@ -8819,7 +9260,7 @@ function nowLocalISO() {
 }
 
 // src/manager/managerRuntime.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 var SESSION_STOP_GRACE_MS2 = 2000;
 function normalizeTerminationCause(value) {
   return value === "runtime_error" || value === "killed_stalled" ? value : "other";
@@ -9056,7 +9497,7 @@ class AgentProcessManager {
   liveBackendIds = new Map;
   activeSpawnState = new Map;
   publishedAgentActivity = new Map;
-  traceProcessNonce = randomUUID5();
+  traceProcessNonce = randomUUID6();
   nextSpawnOrdinal = 1;
   nextDaemonTurnOrdinal = 1;
   nextDeliveryOrdinal = 1;
@@ -9332,6 +9773,12 @@ class AgentProcessManager {
     if (this.sessions.get(agentId) === session)
       this.sessions.delete(agentId);
   }
+  async interrupt(agentId) {
+    const session = this.sessions.get(agentId);
+    if (!session)
+      return;
+    await session.interrupt({ requestId: randomUUID6(), reason: "owner_request" });
+  }
   async stopAll() {
     if (this.tickTimer) {
       clearInterval(this.tickTimer);
@@ -9829,7 +10276,7 @@ ${this.opts.wakePromptFooter}` : text;
       case "reset_idle_session": {
         const spawnState = this.activeSpawnState.get(effect.agentId);
         const completion = {
-          eventId: `bae_${randomUUID5()}`,
+          eventId: `bae_${randomUUID6()}`,
           occurredAt: new Date(this.now()).toISOString()
         };
         const persisted = this.forgetSession(effect.agentId, "reset_session", effect.sessionId, completion);
@@ -10224,11 +10671,12 @@ ${this.opts.wakePromptFooter}` : text;
   emitErrorAudit(agentId, scope, code, rawMessage) {
     if (!this.opts.onBotAuditEvent)
       return;
+    const stableCode = /^[A-Za-z0-9_.-]{1,100}$/.test(code) ? code : "runtime_error";
     const message = scrubRuntimeErrorDiagnosticText(rawMessage).slice(0, AUDIT_ERROR_MESSAGE_MAX_LEN);
     try {
       this.opts.onBotAuditEvent(agentId, {
         kind: "error",
-        payload: { scope, code, message, model: this.currentModelFor(agentId) }
+        payload: { scope, code: stableCode, message, model: this.currentModelFor(agentId) }
       }, {
         sessionId: this.liveSessions.get(agentId) ?? null,
         launchId: this.launchIds.get(agentId) ?? null
@@ -10253,18 +10701,18 @@ ${this.opts.wakePromptFooter}` : text;
       return;
     }
     const sessionSuperseded = owner.superseded;
-    const errorMessage2 = event.type === "session_failed" ? event.error.message : event.type === "turn_completed" && event.result.outcome === "failed" ? event.result.error.message : undefined;
-    if (errorMessage2 !== undefined && !sessionSuperseded) {
-      this.emitErrorAudit(agentId, "runtime", "runtime_error", errorMessage2);
+    const runtimeError = event.type === "session_failed" ? event.error : event.type === "turn_completed" && event.result.outcome === "failed" ? event.result.error : undefined;
+    if (runtimeError !== undefined && !sessionSuperseded) {
+      this.emitErrorAudit(agentId, "runtime", runtimeError.code, runtimeError.message);
       if (this.nonCleanEndMarker.get(agentId)?.cause !== "killed_stalled") {
-        this.nonCleanEndMarker.set(agentId, { cause: "runtime_error", detail: errorMessage2 });
+        this.nonCleanEndMarker.set(agentId, { cause: "runtime_error", detail: runtimeError.message });
       }
       const agent = this.state.agents[agentId];
       if (agent?.resetting && agent.resettingSince !== null && this.now() - agent.resettingSince >= this.state.resetStuckThresholdMs) {
         this.log.warn("runtime error during a stuck reset window", {
           agentId,
           resettingForMs: this.now() - agent.resettingSince,
-          message: errorMessage2
+          message: runtimeError.message
         });
       }
     }
@@ -10359,9 +10807,9 @@ ${this.opts.wakePromptFooter}` : text;
         case "assistant_message_completed":
           return { type: "turn_work", turnId: event.turnId };
         case "tool_started":
-          return { type: "turn_tool_started", turnId: event.turnId };
+          return { type: "turn_tool_started", turnId: event.turnId, callId: event.callId };
         case "tool_finished":
-          return { type: "turn_tool_finished", turnId: event.turnId };
+          return { type: "turn_tool_finished", turnId: event.turnId, callId: event.callId };
         case "compaction_started":
         case "compaction_finished":
         case "review_started":
@@ -27136,6 +27584,10 @@ var OwnerDiagnosticReportSchema = exports_external.discriminatedUnion("status",
 // ../shared/src/community-cli-contract.ts
 var DM_SERVER = ".dm";
 var CONTROL_HEARTBEAT_CAPABILITY = "control-heartbeat-v1";
+var AgentInterruptRequestSchema = exports_external.strictObject({
+  type: exports_external.literal("agent:interrupt"),
+  agentId: exports_external.string().min(1).max(128)
+});
 function parseRef(ref) {
   if (!ref.startsWith("/"))
     throw new Error(`ref must start with "/": ${ref}`);
@@ -27227,6 +27679,7 @@ var HostCommandSchema = exports_external.discriminatedUnion("type", [
     type: exports_external.literal("agent:stop"),
     agentId: exports_external.string().min(1)
   }),
+  AgentInterruptRequestSchema,
   exports_external.object({
     type: exports_external.literal("agent:reset"),
     agentId: exports_external.string().min(1),
@@ -27625,6 +28078,10 @@ class AgentRouter {
         }
         break;
       }
+      case "agent:interrupt": {
+        await this.opts.manager.interrupt(cmd.agentId);
+        break;
+      }
       case "agent:stop":
         this.log.info("agent:stop received", { agentId: cmd.agentId });
         try {
@@ -27794,10 +28251,11 @@ var DEFAULT_CAPABILITY_RESOLVER = (method, pathname) => {
   const isMessagesDoor = /\/channels\/[^/]+\/messages(\/|$|\?)/.test(pathname);
   if (isMessagesDoor)
     return method === "GET" ? "read" : "send";
+  if (/\/messages\/[^/]+\/properties(\/|$|\?)/.test(pathname)) {
+    return method === "GET" ? "read" : "send";
+  }
   if (/\/messages\/[^/]+\/reactions\//.test(pathname))
     return "send";
-  if ((method === "PUT" || method === "DELETE") && /\/messages\/[^/]+\/marks(\/|$|\?)/.test(pathname))
-    return "send";
   if (method === "GET" && /\/users\/me\/marks(\/|$|\?)/.test(pathname))
     return "read";
   if (method === "GET" && /\/messages\/[^/]+(\?|$)/.test(pathname))
@@ -27838,6 +28296,12 @@ function isCanonicalChannelScope(channel2) {
     return false;
   }
 }
+function propertyAuditMetadata(method, pathname, requestUrl) {
+  if (method !== "PUT" && method !== "DELETE" || !/^\/api\/community\/messages\/[^/]+\/properties$/.test(pathname))
+    return;
+  const type = new URL2(requestUrl, "http://placeholder").searchParams.get("type");
+  return type === "emoji" || type === "tag" || type === "mark" ? { propertyType: type } : undefined;
+}
 function parseLocalMessageReminderBody(body, agentId) {
   let value;
   try {
@@ -27976,7 +28440,12 @@ async function startCredentialProxy(broker, options = {}) {
     }
     if (onProxyRequest) {
       try {
-        onProxyRequest(reg.agentId, req.method ?? "GET", pathname);
+        const method = req.method ?? "GET";
+        const metadata = propertyAuditMetadata(method, pathname, req.url ?? pathname);
+        if (metadata)
+          onProxyRequest(reg.agentId, method, pathname, metadata);
+        else
+          onProxyRequest(reg.agentId, method, pathname);
       } catch {}
     }
     const outHeaders = { ...req.headers };
@@ -28394,6 +28863,7 @@ var ALLOWED_ICON_MIME_TYPES = [
 ];
 var MAX_ICON_SOURCE_FILE_SIZE_BYTES = 15 * 1024 * 1024;
 // ../shared/src/provider-telemetry.ts
+var DAILY_TOKEN_USAGE_WINDOW_DAYS = 30;
 var safeToken = exports_external.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
 var boundedText = exports_external.string().min(1).refine((value) => new TextEncoder().encode(value).length <= 64, { message: "must be at most 64 UTF-8 bytes" });
 var DailyUsageMetricSchema = safeToken.nullable();
@@ -29125,7 +29595,7 @@ var AgentActivityMessageSchema = exports_external.object({
   state: exports_external.enum(["idle", "starting", "running", "stopping"]),
   usageTimeZone: exports_external.string().min(1).max(128).optional(),
   usageDay: exports_external.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
-  dailyUsage: exports_external.array(DailyUsageSnapshotSchema).max(7).optional(),
+  dailyUsage: exports_external.array(DailyUsageSnapshotSchema).max(DAILY_TOKEN_USAGE_WINDOW_DAYS).optional(),
   quota: ProviderQuotaSnapshotSchema.optional()
 });
 var AgentTypingMessageSchema = exports_external.object({
@@ -29289,17 +29759,18 @@ var CommunityAgentNapRequestSchema = exports_external.object({
     message: "handoff is required"
   })
 });
-var CommunityAgentReactAddRequestSchema = exports_external.object({
+var CommunityAgentMessagePropertyRequestSchema = exports_external.object({
   channel: exports_external.string().min(1),
   seq: CommunityAgentPositiveSeqSchema,
-  emoji: exports_external.string().min(1)
+  property: exports_external.unknown()
 });
 var CommunityAgentFriendRequestSchema = exports_external.object({
   username: exports_external.string().min(1)
 });
 var CommunityAgentListFriendsSchema = exports_external.object({});
 var AuditLogCliInvocationPayloadSchema = exports_external.object({
-  subcommand: exports_external.string().min(1)
+  subcommand: exports_external.string().min(1),
+  propertyType: exports_external.enum(["emoji", "tag", "mark"]).optional()
 });
 var AuditLogToolCallPayloadSchema = exports_external.object({
   name: exports_external.string().min(1),
@@ -32678,7 +33149,7 @@ class MessageReminderScheduler {
 }
 
 // src/manager/agentDriverHost.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 import { homedir as homedir4 } from "node:os";
 import { join as join13 } from "node:path";
 
@@ -32834,7 +33305,7 @@ function createDaemonAgentDriverHost(ctx, onRawLine) {
         onRawLine?.(event.text);
     },
     now: () => Date.now(),
-    createId: () => randomUUID6()
+    createId: () => randomUUID7()
   };
 }
 
@@ -32913,13 +33384,16 @@ class DaemonSelfSleepScheduler {
 // src/telemetry/dailyTokenUsage.ts
 import { chmod, mkdir, open, readFile as readFile2, rename, rm } from "node:fs/promises";
 import { dirname as dirname5, join as join14 } from "node:path";
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
+var TOKEN_USAGE_WINDOW_DAYS = 30;
+var TOKEN_USAGE_RECOVERY_DAYS = 2;
+var TOKEN_USAGE_RETENTION_DAYS = TOKEN_USAGE_WINDOW_DAYS + TOKEN_USAGE_RECOVERY_DAYS;
 function oldestRetainedDay(at, timeZone) {
   const today = dayKeyInTimeZone(at, timeZone);
-  return calendarDayKeyDaysAgo(today, 8);
+  return calendarDayKeyDaysAgo(today, TOKEN_USAGE_RETENTION_DAYS - 1);
 }
 function oldestVisibleDay(today) {
-  return calendarDayKeyDaysAgo(today, 6);
+  return calendarDayKeyDaysAgo(today, TOKEN_USAGE_WINDOW_DAYS - 1);
 }
 function isMetric(value) {
   return value === null || typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
@@ -33081,7 +33555,7 @@ class DailyTokenUsageStore {
   async persist() {
     const directory = dirname5(this.filePath);
     await mkdir(directory, { recursive: true, mode: 448 });
-    const temporary = `${this.filePath}.${randomUUID7()}.tmp`;
+    const temporary = `${this.filePath}.${randomUUID8()}.tmp`;
     try {
       const file2 = await open(temporary, "wx", 384);
       try {
@@ -33163,15 +33637,17 @@ function createRuntimeRawLineTap(args) {
 }
 function deriveAuditLogSubcommand(pathname, method) {
   const canonical = pathname.split("?")[0] ?? pathname;
-  if (/^\/api\/community\/messages\/[^/]+\/reactions\//.test(canonical))
-    return "reactAdd";
-  if (/^\/api\/community\/messages\/[^/]+\/marks$/.test(canonical)) {
+  if (/^\/api\/community\/messages\/[^/]+\/properties$/.test(canonical)) {
+    if (method === "GET")
+      return "messagePropertyList";
     if (method === "PUT")
-      return "markSet";
+      return "messagePropertySet";
     if (method === "DELETE")
-      return "markRemove";
+      return "messagePropertyRemove";
     return null;
   }
+  if (/^\/api\/community\/messages\/[^/]+\/reactions\//.test(canonical))
+    return "reactAdd";
   if (method === "GET" && /^\/api\/community\/users\/me\/marks$/.test(canonical))
     return "markList";
   if (/^\/api\/community\/channels\/[^/]+\/messages\/seq\//.test(canonical))
@@ -33337,14 +33813,14 @@ async function createDaemon(opts) {
       log2.warn("inbox pull timeline observation failed", { agentId, reason, contentEncoding });
     },
     onMessageReminderArm: (input) => reminderSchedulerRef?.arm(input) ?? { armed: false, reason: "reminder_scheduler_unavailable" },
-    onProxyRequest: (agentId, method, pathname) => {
+    onProxyRequest: (agentId, method, pathname, metadata) => {
       const subcommand = deriveAuditLogSubcommand(pathname, method);
       if (!subcommand)
         return;
       const context = managerRef?.auditContext(agentId);
       emitBotAuditEvent(agentId, {
         kind: "cli_invocation",
-        payload: { subcommand }
+        payload: { subcommand, ...metadata ? { propertyType: metadata.propertyType } : {} }
       }, context);
       emitImplicitTypingStopOnSend({
         subcommand,