@alook/daemon 0.1.28 → 0.1.30

package/dist/cli/index.js

@@ -98,7 +98,7 @@ var init_nanoid = () => {};
 // src/cli/index.ts
 import { Command, CommanderError } from "commander";
 import { realpathSync as realpathSync2 } from "node:fs";
-import { randomUUID as randomUUID10 } from "node:crypto";
+import { randomUUID as randomUUID11 } from "node:crypto";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 
 // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
@@ -16762,6 +16762,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}`);
@@ -16853,6 +16857,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),
@@ -16920,7 +16925,6 @@ var MAX_FOLDER_NAME_LENGTH = 100;
 var MAX_PROFILE_NAME_LENGTH = 100;
 var MAX_PROFILE_ABOUT_LENGTH = 1000;
 var MAX_MESSAGE_CONTENT_LENGTH = 4000;
-var MAX_EMOJI_BYTES = 32;
 var MAX_ATTACHMENTS_PER_MESSAGE = 10;
 var MAX_ATTACHMENT_SIZE_BYTES = 25 * 1024 * 1024;
 var MAX_ATTACHMENT_THUMBNAIL_EDGE_PX = 1024;
@@ -16934,6 +16938,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();
@@ -17665,7 +17670,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({
@@ -17829,17 +17834,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),
@@ -19135,6 +19141,14 @@ function proxyServerApiFromEnv(prefix = "ALOOK", env = process.env) {
 function createProxyServerApi(config2) {
   const fetchImpl = config2.fetchImpl ?? fetch;
   const base = config2.proxyUrl.replace(/\/+$/, "");
+  const propertyAuditQuery = (property) => {
+    if (!property || typeof property !== "object" || Array.isArray(property))
+      return "";
+    const type = property.type;
+    if (type !== "emoji" && type !== "tag" && type !== "mark")
+      return "";
+    return `?type=${encodeURIComponent(type)}`;
+  };
   async function parseJsonResponse(res, method) {
     let text2;
     try {
@@ -19252,17 +19266,37 @@ function createProxyServerApi(config2) {
     });
     return parseJsonResponse(res, "resolve");
   }
-  async function callReactAdd(req) {
-    const res = await fetchImpl(`${base}/api/community/messages/${REF_PLACEHOLDER_ID}/reactions/${encodeURIComponent(req.emoji)}`, {
+  async function callMessagePropertySet(req) {
+    const res = await fetchImpl(`${base}/api/community/messages/${REF_PLACEHOLDER_ID}/properties${propertyAuditQuery(req.property)}`, {
       method: "PUT",
       headers: {
         "content-type": "application/json",
         authorization: `Bearer ${config2.voucher}`
       },
-      body: JSON.stringify({ channel: req.channel, seq: req.seq })
+      body: JSON.stringify(req)
+    });
+    return parseJsonResponse(res, "messagePropertySet");
+  }
+  async function callMessagePropertyList(req) {
+    const q = new URLSearchParams;
+    q.set("ref", req.channel);
+    q.set("seq", String(req.seq));
+    const res = await fetchImpl(`${base}/api/community/messages/${REF_PLACEHOLDER_ID}/properties?${q.toString()}`, {
+      method: "GET",
+      headers: { authorization: `Bearer ${config2.voucher}` }
+    });
+    return parseJsonResponse(res, "messagePropertyList");
+  }
+  async function callMessagePropertyRemove(req) {
+    const res = await fetchImpl(`${base}/api/community/messages/${REF_PLACEHOLDER_ID}/properties${propertyAuditQuery(req.property)}`, {
+      method: "DELETE",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${config2.voucher}`
+      },
+      body: JSON.stringify(req)
     });
-    const body = await parseJsonResponse(res, "reactAdd");
-    return body?.duplicate ? { ok: true, duplicate: true } : { ok: true };
+    return parseJsonResponse(res, "messagePropertyRemove");
   }
   async function callListMembers(req) {
     const q = new URLSearchParams;
@@ -19314,28 +19348,6 @@ function createProxyServerApi(config2) {
     });
     return parseJsonResponse(res, "inboxPull");
   }
-  async function callMarkSet(req) {
-    const res = await fetchImpl(`${base}/api/community/messages/resolve/marks`, {
-      method: "PUT",
-      headers: {
-        "content-type": "application/json",
-        authorization: `Bearer ${config2.voucher}`
-      },
-      body: JSON.stringify(req)
-    });
-    await parseJsonResponse(res, "markSet");
-  }
-  async function callMarkRemove(req) {
-    const res = await fetchImpl(`${base}/api/community/messages/resolve/marks`, {
-      method: "DELETE",
-      headers: {
-        "content-type": "application/json",
-        authorization: `Bearer ${config2.voucher}`
-      },
-      body: JSON.stringify(req)
-    });
-    await parseJsonResponse(res, "markRemove");
-  }
   async function callListMarks() {
     const res = await fetchImpl(`${base}/api/community/users/me/marks`, {
       method: "GET",
@@ -19492,11 +19504,32 @@ function createProxyServerApi(config2) {
     }
     return { server: projectServer(body.server) };
   }
+  async function callLeaveChannel(req) {
+    const parsed = parseRef(req.channel);
+    const scope = parsed.threadRootSeq === undefined ? "channel" : "thread";
+    const collection = scope === "thread" ? "participants" : "members";
+    const res = await fetchImpl(`${base}/api/community/channels/${REF_PLACEHOLDER_ID}/${collection}/self?ref=${encodeURIComponent(req.channel)}`, {
+      method: "DELETE",
+      headers: { authorization: `Bearer ${config2.voucher}` }
+    });
+    await parseJsonResponse(res, "leaveChannel");
+    return { left: req.channel, scope };
+  }
+  async function callLeaveServer(req) {
+    const res = await fetchImpl(`${base}/api/community/servers/${REF_PLACEHOLDER_ID}/leave?server=${encodeURIComponent(req.server)}`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${config2.voucher}` }
+    });
+    await parseJsonResponse(res, "leaveServer");
+    return { left: req.server, scope: "server" };
+  }
   return {
     listServers: (_r) => callListServers(),
     joinServer: callJoinServer,
+    leaveServer: callLeaveServer,
     listChannels: callListChannels,
     channelMember: callChannelMember,
+    leaveChannel: callLeaveChannel,
     inboxPull: callInboxPull,
     inboxSnapshot: (_r) => callInboxSnapshot(),
     ack: callAck,
@@ -19507,9 +19540,9 @@ function createProxyServerApi(config2) {
     attachmentUpload: callUpload,
     attachmentDownload: callDownload,
     updateProfile: callUpdateProfile,
-    reactAdd: callReactAdd,
-    markSet: callMarkSet,
-    markRemove: callMarkRemove,
+    messagePropertySet: callMessagePropertySet,
+    messagePropertyList: callMessagePropertyList,
+    messagePropertyRemove: callMessagePropertyRemove,
     listMarks: (_r) => callListMarks(),
     friendRequest: callFriendRequest,
     listFriends: (_r) => callListFriends(),
@@ -19556,6 +19589,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";
 
@@ -20135,6 +20171,7 @@ class ProcessLane {
   admissionSequence = 0;
   activeTerminalReceipt;
   stopPromise;
+  pendingInterrupt;
   pendingPromptAdmission;
   constructor(driver, ctx, opts = {}) {
     this.driver = driver;
@@ -20174,12 +20211,14 @@ class ProcessLane {
     try {
       spawned = await this.driver.spawn(launchCtx);
     } catch (error51) {
+      this.settlePendingInterrupt(false);
       this.settlePendingPrompt({ ok: false, reason: "runtime_error", error: String(error51) });
       throw error51;
     }
     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();
@@ -20278,6 +20317,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();
@@ -20296,11 +20336,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 promise2 = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+      });
+      this.pendingInterrupt = { input, promise: promise2, resolve, reject };
+      return promise2;
+    }
+    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" });
@@ -20637,11 +20705,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;
   }
@@ -20708,9 +20805,9 @@ class ClaudeEventNormalizer {
         out.push({ kind: "assistant_reasoning_completed", text: block.thinking ?? "" });
       } else if (block?.type === "text") {
         const text2 = block.text ?? "";
-        if (API_ERROR_RE.test(text2))
-          out.push({ kind: "error", message: text2 });
-        else
+        if (API_ERROR_RE.test(text2)) {
+          out.push({ kind: "error", code: "claude.api_error", message: text2 });
+        } else
           completedText.push(text2);
       } else if (block?.type === "tool_use") {
         out.push({ kind: "tool_call", name: block.name ?? "unknown_tool", input: block.input });
@@ -20736,14 +20833,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",
@@ -20755,14 +20857,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,
@@ -20774,6 +20901,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;
   }
 }
 
@@ -20900,6 +21123,7 @@ class ClaudeTurnProtocol {
   segmentOwnerUuid = null;
   delivered = new Map;
   awaitingFollowOn = false;
+  interruptRequested = false;
   finalized = false;
   beginTurn() {
     const uuid3 = randomUUID4();
@@ -20908,6 +21132,7 @@ class ClaudeTurnProtocol {
     this.delivered.clear();
     this.delivered.set(uuid3, { acknowledged: false, followOn: false });
     this.awaitingFollowOn = false;
+    this.interruptRequested = false;
     this.finalized = false;
     return this.receipt(uuid3);
   }
@@ -20934,6 +21159,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;
@@ -20950,6 +21182,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(uuid3) {
     return `claude:${uuid3}`;
   }
@@ -20975,7 +21220,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;
@@ -21014,11 +21261,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, process3) {
+    const stdin = process3.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: process3 };
+      return true;
+    }
+    this.writeInterrupt(input, process3);
+    return true;
+  }
+  writeInterrupt(input, process3) {
+    process3.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(text2, sessionId, opts) {
     const uuid3 = opts?.mode === "idle" ? this.turnProtocol.rootInputUuid() : this.turnProtocol.steeringInputUuid();
     return JSON.stringify({
@@ -21150,6 +21431,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;
@@ -21307,7 +21617,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);
@@ -21376,20 +21690,26 @@ class CodexEventNormalizer {
           return [];
         this.releaseUsageForTurn(params.threadId, params.turn.id);
         if (params.turn.status === "failed") {
+          const error51 = params.turn.error;
           return [
-            { kind: "error", message: "Codex turn failed" },
+            {
+              kind: "error",
+              code: codexErrorInfoCode(error51?.codexErrorInfo, "codex.turn_failed"),
+              message: error51?.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":
@@ -21486,42 +21806,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":
@@ -21530,6 +21854,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
@@ -22000,6 +22328,16 @@ class CodexDriver {
   get currentSessionId() {
     return this.eventNormalizer.currentSessionId;
   }
+  async interrupt(_input, process3) {
+    const threadId = this.eventNormalizer.currentSessionId;
+    const turnId = this.eventNormalizer.currentTurnId;
+    const stdin = process3.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, text2) {
     return jsonRpcRequest("turn/start", { threadId, input: [{ type: "text", text: text2 }] }, this.nextRequestId());
   }
@@ -22255,7 +22593,8 @@ class CursorAcpLane {
   started = false;
   ready = false;
   sessionId = null;
-  activePrompt = null;
+  currentPromptRequestId = null;
+  terminalOwner = null;
   requestedStopReason;
   spawnPromise;
   stopPromise;
@@ -22327,16 +22666,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;
@@ -22344,7 +22686,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);
@@ -22450,19 +22793,22 @@ class CursorAcpLane {
       throw new CursorAcpIncompatibleError("Cursor ACP did not confirm the exact configured model");
     }
   }
-  admitPrompt(text2) {
+  admitPrompt(text2, 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",
@@ -22475,41 +22821,51 @@ class CursorAcpLane {
       });
     } catch (error51) {
       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 error51;
     }
-    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 = record3(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, error51) {
-    if (this.activePrompt?.requestId !== active.requestId)
+  failPrompt(prompt, error51, 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: error51 instanceof Error ? error51.message : String(error51)
     });
     this.events.emit("runtime_event", {
       kind: "turn_end",
       sessionId: this.sessionId ?? undefined,
-      turnOwner: active.receipt
+      turnOwner: terminalOwner
     });
   }
   call(method, params) {
@@ -22595,7 +22951,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(() => {});
@@ -22613,7 +22970,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)
@@ -22655,11 +23013,12 @@ class CursorAcpLane {
       this.pending.delete(id);
       if (message2.error !== undefined) {
         const payload = record3(message2.error);
-        this.failPrompt(pending.active, new CursorAcpRpcError(pending.method, typeof payload?.code === "number" ? payload.code : undefined, rpcErrorMessage(message2.error)));
+        const rpcCode = typeof payload?.code === "number" && Number.isSafeInteger(payload.code) ? payload.code : undefined;
+        this.failPrompt(pending.prompt, new CursorAcpRpcError(pending.method, rpcCode, rpcErrorMessage(message2.error)), rpcCode === undefined ? "cursor.rpc_error" : `cursor.rpc.${rpcCode}`);
       } else if (!("result" in message2)) {
-        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, message2.result);
+        this.completePrompt(pending.prompt, message2.result);
       }
       return;
     }
@@ -22700,7 +23059,7 @@ class CursorAcpLane {
     const sameSession = payload?.sessionId === this.sessionId;
     const options = Array.isArray(payload?.options) ? payload.options.map(record3).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;
@@ -22724,7 +23083,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;
     }
@@ -22942,7 +23301,11 @@ function parseModelRef(model) {
 function messageFromError(value) {
   const payload = record4(value);
   const message2 = typeof payload?.message === "string" && payload.message.trim() ? payload.message : undefined;
-  return message2 ? "OpenCode turn failed" : "OpenCode reported an inconsistent turn outcome";
+  return message2 ?? "OpenCode reported an inconsistent turn outcome";
+}
+function codeFromError(value) {
+  const payload = record4(value);
+  return payload?.type === "unknown" ? "opencode.unknown" : "opencode.step_failed";
 }
 
 class OpenCodeServiceLane {
@@ -23610,7 +23973,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 = record4(data.tokens);
@@ -23639,7 +24005,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;
@@ -23819,11 +24190,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);
@@ -23849,7 +24220,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, success2, message2) {
+  settleRoot(root, success2, message2, code = "opencode.turn_failed") {
     if (this.activeRoot !== root)
       return;
     this.activeRoot = null;
@@ -23857,6 +24228,7 @@ class OpenCodeServiceLane {
     if (!success2) {
       this.events.emit("runtime_event", {
         kind: "error",
+        code,
         message: message2 ?? "OpenCode turn failed"
       });
     }
@@ -24372,7 +24744,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 [];
     }
@@ -24652,7 +25028,7 @@ var capabilities = {
     commandOverride: true,
     resume: "by_id",
     sessionLifetime: "persistent",
-    midTurnDelivery: "next_turn_queue",
+    midTurnDelivery: "steer",
     interrupt: true
   },
   opencode: {
@@ -24960,7 +25336,9 @@ class LogicalAgentSession {
   interruptedTurnId;
   processTurnEnded = false;
   stopRequestId;
-  outstandingToolUses = 0;
+  anonymousOutstandingToolUses = 0;
+  outstandingToolCallIds = new Set;
+  toolLifecycleMismatchCount = 0;
   compacting = false;
   reviewing = false;
   steeringDeliveries = new Set;
@@ -25150,6 +25528,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
         }
@@ -25469,15 +25850,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":
@@ -25533,7 +25935,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,
@@ -25620,7 +26022,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;
@@ -25644,7 +26046,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()) {
@@ -25825,7 +26227,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";
@@ -25835,6 +26237,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;
   }
@@ -27473,10 +27915,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))
@@ -27517,6 +27960,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 {
@@ -27655,7 +28104,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 };
@@ -27938,6 +28392,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;
         }
       });
@@ -28198,26 +28653,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, (agent2) => {
     if (!matchesSession(agent2, event.sessionInstanceId))
       return;
     const lease = agent2.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) {
         agent2.execution.lease = {
           ...lease,
           lastWorkAt: event.nowMs,
           nativeDeadlineAt: event.nowMs + agent2.turnSilence.normalBudgetMs,
           recoveryExtensionsUsed: 0,
-          outstandingToolUses
+          outstandingToolUses,
+          ...identified.size > 0 ? { outstandingToolCallIds: [...identified] } : {}
         };
       } else {
         const unblockedLease = { ...lease };
         delete unblockedLease.outstandingToolUses;
+        delete unblockedLease.outstandingToolCallIds;
         agent2.execution.lease = {
           ...unblockedLease,
           lastWorkAt: event.nowMs,
@@ -28236,6 +28705,7 @@ function onTurnToolLifecycle(state, event, lifecycle) {
         nativeDeadlineAt: event.nowMs + agent2.turnSilence.normalBudgetMs,
         recoveryExtensionsUsed: 0,
         outstandingToolUses: 1,
+        ...callId ? { outstandingToolCallIds: [callId] } : {},
         reason: "work_after_terminal"
       };
     }
@@ -28399,6 +28869,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";
 }
@@ -28620,13 +29094,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",
@@ -28634,12 +29108,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",
     "",
@@ -28692,6 +29168,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:",
@@ -28804,6 +29289,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(`
 `);
@@ -28816,7 +29302,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(`
 `);
 }
@@ -28888,9 +29374,9 @@ function workspaceMemorySection(config2) {
     "",
     "### 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(`
@@ -28943,7 +29429,7 @@ function toLocalISO(iso) {
 }
 
 // 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";
@@ -29180,7 +29666,7 @@ class AgentProcessManager {
   liveBackendIds = new Map;
   activeSpawnState = new Map;
   publishedAgentActivity = new Map;
-  traceProcessNonce = randomUUID5();
+  traceProcessNonce = randomUUID6();
   nextSpawnOrdinal = 1;
   nextDaemonTurnOrdinal = 1;
   nextDeliveryOrdinal = 1;
@@ -29456,6 +29942,12 @@ class AgentProcessManager {
     if (this.sessions.get(agentId) === session2)
       this.sessions.delete(agentId);
   }
+  async interrupt(agentId) {
+    const session2 = this.sessions.get(agentId);
+    if (!session2)
+      return;
+    await session2.interrupt({ requestId: randomUUID6(), reason: "owner_request" });
+  }
   async stopAll() {
     if (this.tickTimer) {
       clearInterval(this.tickTimer);
@@ -29953,7 +30445,7 @@ ${this.opts.wakePromptFooter}` : text2;
       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);
@@ -30348,11 +30840,12 @@ ${this.opts.wakePromptFooter}` : text2;
   emitErrorAudit(agentId, scope, code, rawMessage) {
     if (!this.opts.onBotAuditEvent)
       return;
+    const stableCode = /^[A-Za-z0-9_.-]{1,100}$/.test(code) ? code : "runtime_error";
     const message2 = scrubRuntimeErrorDiagnosticText(rawMessage).slice(0, AUDIT_ERROR_MESSAGE_MAX_LEN);
     try {
       this.opts.onBotAuditEvent(agentId, {
         kind: "error",
-        payload: { scope, code, message: message2, model: this.currentModelFor(agentId) }
+        payload: { scope, code: stableCode, message: message2, model: this.currentModelFor(agentId) }
       }, {
         sessionId: this.liveSessions.get(agentId) ?? null,
         launchId: this.launchIds.get(agentId) ?? null
@@ -30377,18 +30870,18 @@ ${this.opts.wakePromptFooter}` : text2;
       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 agent2 = this.state.agents[agentId];
       if (agent2?.resetting && agent2.resettingSince !== null && this.now() - agent2.resettingSince >= this.state.resetStuckThresholdMs) {
         this.log.warn("runtime error during a stuck reset window", {
           agentId,
           resettingForMs: this.now() - agent2.resettingSince,
-          message: errorMessage2
+          message: runtimeError.message
         });
       }
     }
@@ -30483,9 +30976,9 @@ ${this.opts.wakePromptFooter}` : text2;
         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":
@@ -30938,6 +31431,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 {
@@ -32380,7 +32877,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";
 
@@ -32536,7 +33033,7 @@ function createDaemonAgentDriverHost(ctx, onRawLine) {
         onRawLine?.(event.text);
     },
     now: () => Date.now(),
-    createId: () => randomUUID6()
+    createId: () => randomUUID7()
   };
 }
 
@@ -32615,13 +33112,16 @@ class DaemonSelfSleepScheduler {
 // src/telemetry/dailyTokenUsage.ts
 import { chmod, mkdir, open, readFile as readFile2, rename, rm } from "node:fs/promises";
 import { dirname as dirname6, 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;
@@ -32783,7 +33283,7 @@ class DailyTokenUsageStore {
   async persist() {
     const directory = dirname6(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 {
@@ -32865,15 +33365,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))
@@ -33039,14 +33541,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,
@@ -33968,10 +34470,17 @@ function projectFsm(row, targetAgentId) {
     "queueDwellTotalMs",
     "sseReconnectCount"
   ];
-  const hasMetrics = metricKeys.some((key) => (key in row) || row[key] !== undefined) || "resumeOutcome" in row || "terminalOwnerKind" in row;
+  const toolMetricKeys = [
+    "outstandingToolUses",
+    "anonymousOutstandingToolUses",
+    "toolLifecycleMismatchCount"
+  ];
+  const hasMetrics = metricKeys.some((key) => (key in row) || row[key] !== undefined) || toolMetricKeys.some((key) => (key in row) || row[key] !== undefined) || "resumeOutcome" in row || "terminalOwnerKind" in row;
   if (hasMetrics) {
     if (!metricKeys.every((key) => copyFiniteNumber(row, output, key)))
       return null;
+    if (!toolMetricKeys.every((key) => copyInteger(row, output, key, { optional: true })))
+      return null;
     const resumeOutcome = enumValue(row.resumeOutcome, RESUME_OUTCOMES);
     const terminalOwnerKind = enumValue(row.terminalOwnerKind, TERMINAL_OWNER_KINDS);
     if (!resumeOutcome || !terminalOwnerKind)
@@ -36683,7 +37192,7 @@ ${MESSAGE_SEND_STDIN_POLICY}`);
     }
     replyToSeq = n;
   }
-  const nonce = randomUUID10();
+  const nonce = randomUUID11();
   const res = await sendWithRetry(api2, {
     agentId: agent2,
     channel: channel2,
@@ -36712,22 +37221,43 @@ ${MESSAGE_SEND_STDIN_POLICY}`);
     return { sent, reminder: { armed: false, reason: "local reminder request failed" } };
   }
 }
-async function cmdMessageEmoji(opts) {
+function parseMessagePropertyJson(command, raw) {
+  if (typeof raw !== "string")
+    throw new CliError(`${command}: --json <json> is required`);
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new CliError(`${command}: --json must be valid JSON`);
+  }
+}
+async function cmdMessagePropertySet(opts) {
   const api2 = getApi();
   const target2 = opts.target;
-  const emoji3 = opts.emoji;
   if (!target2)
-    throw new CliError("message emoji: --target <ref> is required (e.g. /demo#1234/general#42)");
-  if (!emoji3)
-    throw new CliError("message emoji: --emoji <string> is required");
-  const { channel: channel2, seq } = parseMessageTarget("message emoji", target2);
-  if (Buffer.byteLength(emoji3, "utf8") > MAX_EMOJI_BYTES) {
-    const err = new CliError("emoji is too long");
-    err.hint = "use a single emoji, not a phrase";
-    throw err;
-  }
-  const res = await api2.reactAdd({ channel: channel2, seq, emoji: emoji3 });
-  return { target: target2, emoji: emoji3, duplicate: res.duplicate === true };
+    throw new CliError("message property set: --target <ref> is required");
+  const request = parseMessageTarget("message property set", target2);
+  const property = parseMessagePropertyJson("message property set", opts.json);
+  const result = await withTransientMutationRetry(() => api2.messagePropertySet({ ...request, property }));
+  return { target: target2, ...result };
+}
+async function cmdMessagePropertyList(opts) {
+  const api2 = getApi();
+  const target2 = opts.target;
+  if (!target2)
+    throw new CliError("message property list: --target <ref> is required");
+  const request = parseMessageTarget("message property list", target2);
+  const result = await api2.messagePropertyList(request);
+  return { target: target2, ...result };
+}
+async function cmdMessagePropertyRemove(opts) {
+  const api2 = getApi();
+  const target2 = opts.target;
+  if (!target2)
+    throw new CliError("message property remove: --target <ref> is required");
+  const request = parseMessageTarget("message property remove", target2);
+  const property = parseMessagePropertyJson("message property remove", opts.json);
+  const result = await withTransientMutationRetry(() => api2.messagePropertyRemove({ ...request, property }));
+  return { target: target2, ...result };
 }
 function parseMessageTarget(command, target2) {
   let parsed;
@@ -36744,24 +37274,6 @@ function parseMessageTarget(command, target2) {
   const channel2 = parsed.threadRootSeq !== undefined ? `/${parsed.server}/${parsed.channel}/#${parsed.threadRootSeq}` : `/${parsed.server}/${parsed.channel}`;
   return { channel: channel2, seq: parsed.seq };
 }
-async function cmdMessageMarkSet(opts) {
-  const api2 = getApi();
-  const target2 = opts.target;
-  if (!target2)
-    throw new CliError("message mark set: --target <ref> is required");
-  const request = parseMessageTarget("message mark set", target2);
-  await withTransientMutationRetry(() => api2.markSet(request));
-  return { target: target2, marked: true };
-}
-async function cmdMessageMarkRemove(opts) {
-  const api2 = getApi();
-  const target2 = opts.target;
-  if (!target2)
-    throw new CliError("message mark remove: --target <ref> is required");
-  const request = parseMessageTarget("message mark remove", target2);
-  await withTransientMutationRetry(() => api2.markRemove(request));
-  return { target: target2, marked: false };
-}
 async function cmdMessageMarkList(opts) {
   const api2 = getApi();
   const { marked } = await api2.listMarks({ agentId: agentId(opts) });
@@ -36891,7 +37403,7 @@ async function cmdInboxPull(opts) {
   let acked = 0;
   let ackError;
   let failed;
-  if (opts.ack !== false && messages.length > 0) {
+  if (messages.length > 0) {
     const latest = new Map;
     for (const m of messages) {
       const seqN = Number(m.seq.replace("#", ""));
@@ -36959,6 +37471,14 @@ async function cmdServerJoin(opts) {
   const { server } = await api2.joinServer({ agentId: agent2, invite: token });
   return { server };
 }
+async function cmdServerLeave(opts) {
+  const api2 = getApi();
+  const agent2 = agentId(opts);
+  const server = opts.server;
+  if (!server)
+    throw new CliError("server leave: --server <name#NNNN> is required");
+  return await api2.leaveServer({ agentId: agent2, server });
+}
 async function cmdChannelList(opts) {
   const api2 = getApi();
   const agent2 = agentId(opts);
@@ -36975,6 +37495,26 @@ async function cmdChannelMember(opts) {
     throw new CliError("channel member: --channel <ref> is required");
   return await api2.channelMember({ agentId: agent2, channel: channel2 });
 }
+async function cmdChannelLeave(opts) {
+  const api2 = getApi();
+  const agent2 = agentId(opts);
+  const channel2 = opts.channel;
+  if (!channel2)
+    throw new CliError("channel leave: --channel <ref> is required");
+  let parsed;
+  try {
+    parsed = parseRef(channel2);
+  } catch {
+    throw new CliError("channel leave: malformed channel ref");
+  }
+  if (parsed.server === DM_SERVER) {
+    throw new CliError("channel leave: DMs cannot be left");
+  }
+  if (parsed.seq !== undefined) {
+    throw new CliError("channel leave: message refs cannot be left; use a channel or thread-root ref");
+  }
+  return await api2.leaveChannel({ agentId: agent2, channel: channel2 });
+}
 async function cmdChannelHistory(opts) {
   const api2 = getApi();
   const agent2 = agentId(opts);
@@ -37032,22 +37572,22 @@ function buildProgram(stdin) {
     const result = await cmdMessageSend({ ...globalOpts, ...localOpts }, stdin);
     printEnvelope({ success: result });
   });
-  message2.command("emoji").description("react to a message with a single emoji").requiredOption("--target <ref>", "message ref (path-style, e.g. /demo#1234/general#42 or /.dm/peer#0007#42)").requiredOption("--emoji <string>", "single emoji character").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
-    const localOpts = this.opts();
-    const globalOpts = program.opts();
-    const result = await cmdMessageEmoji({ ...globalOpts, ...localOpts });
+  const property = message2.command("property").description("message property operations").exitOverride();
+  property.configureOutput({ writeOut: () => {}, writeErr: () => {} });
+  property.command("set").description("add a supported property value to a message").requiredOption("--target <ref>", "full message ref").requiredOption("--json <json>", "property JSON").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+    const result = await cmdMessagePropertySet({ ...program.opts(), ...this.opts() });
     printEnvelope({ success: result });
   });
-  const mark = message2.command("mark").description("durable message mark operations").exitOverride();
-  mark.configureOutput({ writeOut: () => {}, writeErr: () => {} });
-  mark.command("set").description("mark a message as outstanding work").requiredOption("--target <ref>", "full message ref").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
-    const result = await cmdMessageMarkSet({ ...program.opts(), ...this.opts() });
+  property.command("list").description("list current properties and supported capabilities").requiredOption("--target <ref>", "full message ref").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+    const result = await cmdMessagePropertyList({ ...program.opts(), ...this.opts() });
     printEnvelope({ success: result });
   });
-  mark.command("remove").description("remove an outstanding-work mark").requiredOption("--target <ref>", "full message ref").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
-    const result = await cmdMessageMarkRemove({ ...program.opts(), ...this.opts() });
+  property.command("remove").description("remove a supported property value from a message").requiredOption("--target <ref>", "full message ref").requiredOption("--json <json>", "property JSON").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+    const result = await cmdMessagePropertyRemove({ ...program.opts(), ...this.opts() });
     printEnvelope({ success: result });
   });
+  const mark = message2.command("mark").description("global durable-mark queries").exitOverride();
+  mark.configureOutput({ writeOut: () => {}, writeErr: () => {} });
   mark.command("list").description("list all currently visible marked messages").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
     const result = await cmdMessageMarkList({ ...program.opts(), ...this.opts() });
     printEnvelope({ success: result });
@@ -37068,7 +37608,7 @@ function buildProgram(stdin) {
   });
   const inbox = program.command("inbox").description("inbox operations").exitOverride();
   inbox.configureOutput({ writeOut: () => {}, writeErr: () => {} });
-  inbox.command("pull").description("fetch unread messages from all channels").option("--max <n>", "max messages to return").option("--no-ack", "do not advance read waterlines (peek only)").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+  inbox.command("pull").description("fetch unread messages from all channels").option("--max <n>", "max messages to return").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
     const localOpts = this.opts();
     const globalOpts = program.opts();
     const result = await cmdInboxPull({ ...globalOpts, ...localOpts });
@@ -37094,6 +37634,12 @@ function buildProgram(stdin) {
     const result = await cmdServerJoin({ ...globalOpts, ...localOpts });
     printEnvelope({ success: result });
   });
+  server.command("leave").description("leave a server you belong to").option("--server <handle>", "server name#NNNN handle (from `server list`)").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+    const localOpts = this.opts();
+    const globalOpts = program.opts();
+    const result = await cmdServerLeave({ ...globalOpts, ...localOpts });
+    printEnvelope({ success: result });
+  });
   const channel2 = program.command("channel").description("channel operations").exitOverride();
   channel2.configureOutput({ writeOut: () => {}, writeErr: () => {} });
   channel2.command("list").description("list top-level channels visible to this agent in one server").option("--server <handle>", "server name#discriminator handle (from `server list`)").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
@@ -37114,6 +37660,12 @@ function buildProgram(stdin) {
     const result = await cmdChannelMember({ ...globalOpts, ...localOpts });
     printEnvelope({ success: result });
   });
+  channel2.command("leave").description("leave a thread or private channel/forum").option("--channel <ref>", "channel/thread ref (path-style)").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+    const localOpts = this.opts();
+    const globalOpts = program.opts();
+    const result = await cmdChannelLeave({ ...globalOpts, ...localOpts });
+    printEnvelope({ success: result });
+  });
   const friend = program.command("friend").description("friend operations").exitOverride();
   friend.configureOutput({ writeOut: () => {}, writeErr: () => {} });
   friend.command("request").description("send a friend request to a user by handle (owner-approval required)").option("--username <name#0042>", "the target's global handle, e.g. Alice#0042").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {