@morty-build/cli 0.4.3 → 0.4.5

package/dist/{chunk-DVSX6ALB.js → chunk-IOB4UFOK.js}

@@ -3,7 +3,7 @@ import {
   __export,
   __using,
   package_default
-} from "./chunk-OEX63ZJX.js";
+} from "./chunk-DUNSEOXK.js";
 
 // src/engine/runtime/relay/runtime-revocation.ts
 var runtimeRevocationCloseCode = 1008;
@@ -1285,9 +1285,9 @@ function sizeCaps(defChecks) {
     const d8 = ch._zod.def;
     if (!/_(length|size)$|_equals$/.test(d8.check))
       break;
-    const max = d8.maximum ?? d8.length ?? d8.size;
-    if (max >= 0)
-      caps.push([max, ch]);
+    const max2 = d8.maximum ?? d8.length ?? d8.size;
+    if (max2 >= 0)
+      caps.push([max2, ch]);
   }
   return caps;
 }
@@ -1335,14 +1335,14 @@ function codePointLength(str) {
   const units = str.length;
   if (!highSurrogate.test(str))
     return units;
-  let count = units;
+  let count2 = units;
   for (let i = 0; i < units - 1; i++) {
     if ((str.charCodeAt(i) & 64512) === 55296 && (str.charCodeAt(i + 1) & 64512) === 56320) {
-      count--;
+      count2--;
       i++;
     }
   }
-  return count;
+  return count2;
 }
 function getLengthableOrigin(input2) {
   if (Array.isArray(input2))
@@ -3177,13 +3177,13 @@ var CC_SANITIZE = /[- ]/g;
 function isLuhnAlgo(digits) {
   let length = digits.length;
   let bit = 1;
-  let sum = 0;
+  let sum2 = 0;
   while (length) {
     const value = digits.charCodeAt(--length) - 48;
     bit ^= 1;
-    sum += bit ? [0, 2, 4, 6, 8, 1, 3, 5, 7, 9][value] : value;
+    sum2 += bit ? [0, 2, 4, 6, 8, 1, 3, 5, 7, 9][value] : value;
   }
-  return sum % 10 === 0;
+  return sum2 % 10 === 0;
 }
 function isValidCreditCard(input2) {
   if (!creditCard.test(input2))
@@ -3476,8 +3476,8 @@ function capSize(inst, size) {
   inst._zod.parse = (payload, ctx) => {
     const n = size(payload.value);
     if (n > cap && !ctx?.skipChecks && ctx?.direction !== "backward") {
-      for (const [max, ch] of sizeCaps(inst._zod.def.checks)) {
-        if (n > max && ch._zod.def.when(payload)) {
+      for (const [max2, ch] of sizeCaps(inst._zod.def.checks)) {
+        if (n > max2 && ch._zod.def.when(payload)) {
           const start = payload.issues.length;
           ch._zod.check(payload);
           payload.issues[start].continue = false;
@@ -5183,7 +5183,7 @@ function isRecursive(inst, stack, resolve19) {
     return PROVEN;
   stack.add(inst);
   let result = NONE;
-  const check2 = (child) => {
+  const check3 = (child) => {
     if (result !== PROVEN && child?._zod) {
       const answer = isRecursive(child, stack, resolve19);
       if (answer > result)
@@ -5212,32 +5212,32 @@ function isRecursive(inst, stack, resolve19) {
     case "object": {
       const raw = rawShape(def);
       merge2(raw ? shape(raw, true) : ASSUMED);
-      check2(def.catchall);
+      check3(def.catchall);
       break;
     }
     case "array":
-      check2(def.element);
+      check3(def.element);
       break;
     case "tuple":
       for (const el2 of def.items)
-        check2(el2);
-      check2(def.rest);
+        check3(el2);
+      check3(def.rest);
       break;
     case "record":
     case "map":
-      check2(def.keyType);
-      check2(def.valueType);
+      check3(def.keyType);
+      check3(def.valueType);
       break;
     case "set":
-      check2(def.valueType);
+      check3(def.valueType);
       break;
     case "union":
       for (const el2 of def.options)
-        check2(el2);
+        check3(el2);
       break;
     case "intersection":
-      check2(def.left);
-      check2(def.right);
+      check3(def.left);
+      check3(def.right);
       break;
     case "optional":
     case "nullable":
@@ -5248,15 +5248,15 @@ function isRecursive(inst, stack, resolve19) {
     case "nonoptional":
     case "promise":
     case "success":
-      check2(def.innerType);
+      check3(def.innerType);
       break;
     case "pipe":
-      check2(def.in);
-      check2(def.out);
+      check3(def.in);
+      check3(def.out);
       break;
     case "function":
-      check2(def.input);
-      check2(def.output);
+      check3(def.input);
+      check3(def.output);
       break;
     // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
     case "lazy": {
@@ -5297,10 +5297,10 @@ function isRecursive(inst, stack, resolve19) {
         if (!value || typeof value !== "object")
           continue;
         if (value._zod)
-          check2(value);
+          check3(value);
         else if (Array.isArray(value))
           for (const el2 of value)
-            check2(el2);
+            check3(el2);
       }
     }
   }
@@ -5725,8 +5725,8 @@ function az_default() {
 }
 
 // ../../node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/be.js
-function getBelarusianPlural(count, one2, few, many) {
-  const absCount = Math.abs(count);
+function getBelarusianPlural(count2, one2, few, many) {
+  const absCount = Math.abs(count2);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -8373,8 +8373,8 @@ function hu_default() {
 }
 
 // ../../node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/hy.js
-function getArmenianPlural(count, one2, many) {
-  return Math.abs(count) === 1 ? one2 : many;
+function getArmenianPlural(count2, one2, many) {
+  return Math.abs(count2) === 1 ? one2 : many;
 }
 function withDefiniteArticle(word) {
   if (!word)
@@ -11112,8 +11112,8 @@ function ro_default() {
 }
 
 // ../../node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/ru.js
-function getRussianPlural(count, one2, few, many) {
-  const absCount = Math.abs(count);
+function getRussianPlural(count2, one2, few, many) {
+  const absCount = Math.abs(count2);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -13246,8 +13246,8 @@ function generateChecks(doc, ctx, schema, accessor) {
   if (!schemaChecks || schemaChecks.length === 0)
     return accessor;
   let currentAccessor = accessor;
-  for (const check2 of schemaChecks) {
-    const def = check2._zod.def;
+  for (const check3 of schemaChecks) {
+    const def = check3._zod.def;
     if (def.when && !WHEN_DEFAULTED_CHECKS.has(def.check)) {
       throw new ZodCompileUnsupportedError(`check with a custom "when" condition`);
     }
@@ -13265,15 +13265,15 @@ function generateChecks(doc, ctx, schema, accessor) {
         generateNumberFormatCheck(doc, def, currentAccessor);
         break;
       case "min_length": {
-        const min = numericOperand(def.minimum, "min_length");
-        const len = codePointLengthVar(doc, ctx, currentAccessor, `${currentAccessor}.length >= ${min} && ${currentAccessor}.length < ${def.minimum * 2}`);
-        doc.write(`if (${len} < ${min}) return INVALID;`);
+        const min2 = numericOperand(def.minimum, "min_length");
+        const len = codePointLengthVar(doc, ctx, currentAccessor, `${currentAccessor}.length >= ${min2} && ${currentAccessor}.length < ${def.minimum * 2}`);
+        doc.write(`if (${len} < ${min2}) return INVALID;`);
         break;
       }
       case "max_length": {
-        const max = numericOperand(def.maximum, "max_length");
-        const len = codePointLengthVar(doc, ctx, currentAccessor, `${currentAccessor}.length > ${max}`);
-        doc.write(`if (${len} > ${max}) return INVALID;`);
+        const max2 = numericOperand(def.maximum, "max_length");
+        const len = codePointLengthVar(doc, ctx, currentAccessor, `${currentAccessor}.length > ${max2}`);
+        doc.write(`if (${len} > ${max2}) return INVALID;`);
         break;
       }
       case "length_equals": {
@@ -13295,7 +13295,7 @@ function generateChecks(doc, ctx, schema, accessor) {
         currentAccessor = generateStringFormatCheck(doc, ctx, def, currentAccessor);
         break;
       case "custom":
-        currentAccessor = generateCustomRefineCheck(doc, ctx, check2, currentAccessor);
+        currentAccessor = generateCustomRefineCheck(doc, ctx, check3, currentAccessor);
         break;
       case "bigint_format":
         generateBigIntFormatCheck(doc, def, currentAccessor);
@@ -13311,7 +13311,7 @@ function generateChecks(doc, ctx, schema, accessor) {
         break;
       case "overwrite": {
         const newAccessor = newVar(ctx);
-        generateOverwriteCheck(doc, ctx, check2, currentAccessor, newAccessor);
+        generateOverwriteCheck(doc, ctx, check3, currentAccessor, newAccessor);
         currentAccessor = newAccessor;
         break;
       }
@@ -13434,8 +13434,8 @@ function generatePropertyCheck(doc, ctx, def, accessor) {
   const propAccessor = `${accessor}[${JSON.stringify(def.property)}]`;
   generateCheck(doc, ctx, def.schema, propAccessor);
 }
-function generateOverwriteCheck(doc, ctx, check2, currentAccessor, newAccessor) {
-  const tx2 = check2._zod.def.tx;
+function generateOverwriteCheck(doc, ctx, check3, currentAccessor, newAccessor) {
+  const tx2 = check3._zod.def.tx;
   if (!tx2) {
     throw new ZodCompileUnsupportedError("overwrite check without a transform function");
   }
@@ -13451,8 +13451,8 @@ function throwAsync() {
 function pushIssue(issue2) {
   this.issues.push(issue2);
 }
-function generateCustomRefineCheck(doc, ctx, check2, accessor) {
-  const def = check2._zod.def;
+function generateCustomRefineCheck(doc, ctx, check3, accessor) {
+  const def = check3._zod.def;
   if (def.fn) {
     if (isAsyncFunction(def.fn)) {
       throw new ZodCompileAsyncError("z.compile: async .refine() predicates are not supported");
@@ -13465,11 +13465,11 @@ function generateCustomRefineCheck(doc, ctx, check2, accessor) {
     doc.write(`if (!${resVar}) return INVALID;`);
     return accessor;
   }
-  if (check2._zod.check) {
-    if (isAsyncFunction(check2._zod.check)) {
+  if (check3._zod.check) {
+    if (isAsyncFunction(check3._zod.check)) {
       throw new ZodCompileAsyncError("z.compile: async .superRefine() / check functions are not supported");
     }
-    const checkFn = check2._zod.check;
+    const checkFn = check3._zod.check;
     const helperFn = (value) => {
       const fakePayload = { value, issues: [], addIssue: pushIssue };
       const result = checkFn(fakePayload);
@@ -14091,8 +14091,8 @@ function generateNullableCheck(doc, ctx, schema, accessor, buildsValue = true) {
   return outputVar;
 }
 function generateSizeGate(doc, schema, size) {
-  for (const [max, check2] of sizeCaps(schema._zod.def.checks)) {
-    doc.write(`if (${size} > ${numericOperand(max, check2._zod.def.check)}) return INVALID;`);
+  for (const [max2, check3] of sizeCaps(schema._zod.def.checks)) {
+    doc.write(`if (${size} > ${numericOperand(max2, check3._zod.def.check)}) return INVALID;`);
   }
 }
 function generateArrayCheck(doc, ctx, schema, accessor, buildsValue = true) {
@@ -17392,8 +17392,8 @@ var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
     reg.add(this, meta3);
     return this;
   },
-  refine(check2, params) {
-    return this.check(refine(check2, params));
+  refine(check3, params) {
+    return this.check(refine(check3, params));
   },
   superRefine(refinement, params) {
     return this.check(superRefine(refinement, params));
@@ -21199,8 +21199,8 @@ var sessionPrepareCommandSchema = external_exports.object({
   sessionState: external_exports.literal("provisioned").optional(),
   /** Marks an inspection-only Session preparation. */
   transient: external_exports.boolean().optional()
-}).superRefine((command, context) => {
-  if (command.transient === true && command.sessionState === "provisioned") {
+}).superRefine((command2, context) => {
+  if (command2.transient === true && command2.sessionState === "provisioned") {
     context.addIssue({
       code: "custom",
       message: "A transient Session cannot already be provisioned",
@@ -21310,8 +21310,7 @@ var SESSION_PROMPT_DISPOSITION_KIND = "session.prompt.disposition";
 var SESSION_CANCEL_KIND = "session.cancel";
 var SESSION_CANCEL_BEFORE_START_KIND = "session.cancel-before-start";
 var SessionPromptDisposition = Object.freeze({
-  Queue: "queue",
-  Reject: "reject",
+  Append: "append",
   Steer: "steer"
 });
 var SessionHistoryPolicy = Object.freeze({
@@ -21339,18 +21338,21 @@ var promptAttachmentSchema = external_exports.object({
   uri: external_exports.string().min(1).max(4096)
 }).readonly();
 var decodePromptAttachmentsValue = (value) => decodeZodValue(value, external_exports.array(promptAttachmentSchema).max(16).readonly());
-function readPromptDisposition(value) {
-  const field = value["disposition"];
-  if (field === SessionPromptDisposition.Reject) {
-    return SessionPromptDisposition.Reject;
-  }
-  if (field === SessionPromptDisposition.Queue) {
-    return SessionPromptDisposition.Queue;
-  }
-  if (field === SessionPromptDisposition.Steer) {
-    return SessionPromptDisposition.Steer;
+function readPromptPlacement(value) {
+  switch (value["disposition"]) {
+    case SessionPromptDisposition.Append:
+      if (Object.hasOwn(value, "targetCommandId")) {
+        throw new ProtocolMessageError("An appended prompt names no target command");
+      }
+      return { disposition: SessionPromptDisposition.Append };
+    case SessionPromptDisposition.Steer:
+      return {
+        disposition: SessionPromptDisposition.Steer,
+        targetCommandId: readIdentifier(value, "targetCommandId")
+      };
+    default:
+      throw new ProtocolMessageError("Invalid value field: disposition");
   }
-  throw new ProtocolMessageError("Invalid value field: disposition");
 }
 function decodeSessionPromptCommand(encoded) {
   const value = parseJson(encoded);
@@ -21365,11 +21367,7 @@ function decodeSessionPromptCommand(encoded) {
   if (prompt.trim().length === 0 && attachments.length === 0) {
     throw new ProtocolMessageError("Prompt must contain content");
   }
-  const disposition = readPromptDisposition(value);
-  const targetCommandId = readText(value, "targetCommandId", 128);
-  if (disposition === SessionPromptDisposition.Reject && targetCommandId.length > 0 || disposition !== SessionPromptDisposition.Reject && !isIdentifier(targetCommandId)) {
-    throw new ProtocolMessageError("Prompt disposition has an invalid target command");
-  }
+  const placement = readPromptPlacement(value);
   const sessionConfigurations = hasSessionConfigurations ? decodeSessionConfigurationSelections(value["sessionConfigurations"]) : [];
   if (new Set(sessionConfigurations.map((selection) => selection.configId)).size !== sessionConfigurations.length) {
     throw new ProtocolMessageError("Session configuration identifiers must be unique");
@@ -21380,14 +21378,13 @@ function decodeSessionPromptCommand(encoded) {
     bindingId: readIdentifier(value, "bindingId"),
     commandId: readIdentifier(value, "commandId"),
     directoryId: readDirectoryIdentifier(value, "directoryId"),
-    disposition,
     attachments,
     historyPolicy: readHistoryPolicy(value),
     kind: SESSION_PROMPT_KIND,
     prompt,
     ...hasSessionConfigurations ? { sessionConfigurations } : {},
     sessionId: readIdentifier(value, "sessionId"),
-    targetCommandId
+    ...placement
   };
 }
 function readHistoryPolicy(value) {
@@ -21409,7 +21406,7 @@ function decodeSessionCancelCommand(encoded) {
 function decodeSessionPromptDispositionCommand(encoded) {
   const value = parseJson(encoded);
   assertKind(value, SESSION_PROMPT_DISPOSITION_KIND);
-  if (readPromptDisposition(value) !== SessionPromptDisposition.Steer) {
+  if (value["disposition"] !== SessionPromptDisposition.Steer) {
     throw new ProtocolMessageError("Only queued prompts can be steered");
   }
   return {
@@ -25276,9 +25273,9 @@ var Connection = class {
       return;
     }
     const responseBatch = isResponseBatch(batch);
-    const responseCount = responseBatch ? 0 : batch.reduce((count, message) => count + (isNotificationMessage(message) ? 0 : 1), 0);
+    const responseCount = responseBatch ? 0 : batch.reduce((count2, message) => count2 + (isNotificationMessage(message) ? 0 : 1), 0);
     let remaining = responseCount;
-    let remainingNotifications = batch.reduce((count, message) => count + (isNotificationMessage(message) ? 1 : 0), 0);
+    let remainingNotifications = batch.reduce((count2, message) => count2 + (isNotificationMessage(message) ? 1 : 0), 0);
     let responseSent = false;
     const responses = [];
     const sendResponsesIfReady = async () => {
@@ -67253,8 +67250,8 @@ var ClaudeAcpAgent = class {
     return response;
   }
   async goal(params) {
-    const command = params.action === "set" ? `/goal ${params.objective}` : "/goal clear";
-    const prompt = [{ type: "text", text: command }];
+    const command2 = params.action === "set" ? `/goal ${params.objective}` : "/goal clear";
+    const prompt = [{ type: "text", text: command2 }];
     const steering = await this.steer({
       sessionId: params.sessionId,
       prompt,
@@ -67922,8 +67919,8 @@ var ClaudeAcpAgent = class {
                   type: "content",
                   content: { type: "text", text: m.content }
                 })) : [];
-                const count = message.memories.length;
-                const title2 = isSynthesis ? "Recalled synthesized memory" : `Recalled ${count} ${count === 1 ? "memory" : "memories"}`;
+                const count2 = message.memories.length;
+                const title2 = isSynthesis ? "Recalled synthesized memory" : `Recalled ${count2} ${count2 === 1 ? "memory" : "memories"}`;
                 await sendUpdate({
                   sessionId: message.session_id,
                   update: {
@@ -69947,7 +69944,7 @@ function modelUsageIncrement(current, previous) {
       cachedReadTokens: usage.cachedReadTokens - base.cachedReadTokens,
       cachedWriteTokens: usage.cachedWriteTokens - base.cachedWriteTokens
     } : usage;
-    const rewound = Object.values(subtracted).some((count) => count < 0);
+    const rewound = Object.values(subtracted).some((count2) => count2 < 0);
     const resolved = rewound ? usage : subtracted;
     if (tallyTotal(resolved) > 0) {
       increment[model] = resolved;
@@ -70463,20 +70460,20 @@ function getAvailableSlashCommands(commands, terminalCommands) {
     "release-notes",
     "todos"
   ];
-  return commands.filter((command) => !terminalCommands?.includes(command.name)).map((command) => {
-    const input2 = command.argumentHint ? {
-      hint: Array.isArray(command.argumentHint) ? command.argumentHint.join(" ") : command.argumentHint
+  return commands.filter((command2) => !terminalCommands?.includes(command2.name)).map((command2) => {
+    const input2 = command2.argumentHint ? {
+      hint: Array.isArray(command2.argumentHint) ? command2.argumentHint.join(" ") : command2.argumentHint
     } : null;
-    let name2 = command.name;
-    if (command.name.endsWith(" (MCP)")) {
+    let name2 = command2.name;
+    if (command2.name.endsWith(" (MCP)")) {
       name2 = `mcp:${name2.replace(" (MCP)", "")}`;
     }
     return {
       name: name2,
-      description: command.description || "",
+      description: command2.description || "",
       input: input2
     };
-  }).filter((command) => !UNSUPPORTED_COMMANDS.includes(command.name));
+  }).filter((command2) => !UNSUPPORTED_COMMANDS.includes(command2.name));
 }
 function promptToClaude(prompt) {
   const content = [];
@@ -70487,8 +70484,8 @@ function promptToClaude(prompt) {
         let text2 = chunk.text;
         const mcpMatch = text2.match(/^\/mcp:([^:\s]+):(\S+)(?:\s(.*))?$/);
         if (mcpMatch) {
-          const [, server, command, args] = mcpMatch;
-          text2 = `/${server}:${command} (MCP)${args ? ` ${args}` : ""}`;
+          const [, server, command2, args] = mcpMatch;
+          text2 = `/${server}:${command2} (MCP)${args ? ` ${args}` : ""}`;
         }
         content.push({ type: "text", text: text2 });
         break;
@@ -71339,7 +71336,7 @@ var posixOperations2 = {
     await access2(target, constants3.X_OK);
     return target;
   },
-  executableLaunch: (command, args) => ({ command, arguments: args }),
+  executableLaunch: (command2, args) => ({ command: command2, arguments: args }),
   spawnOptions: { detached: true, windowsHide: true },
   signalCapturedProcesses,
   terminateProcess
@@ -71523,17 +71520,17 @@ async function resolveExecutableTarget(path7) {
   }
   return resolvedPath;
 }
-function executableLaunch(command, args) {
-  if (/\.(?:js|mjs|cjs)$/iu.test(command)) {
-    return { command: process.execPath, arguments: [command, ...args] };
+function executableLaunch(command2, args) {
+  if (/\.(?:js|mjs|cjs)$/iu.test(command2)) {
+    return { command: process.execPath, arguments: [command2, ...args] };
   }
-  if (/\.(?:cmd|bat)$/iu.test(command)) {
+  if (/\.(?:cmd|bat)$/iu.test(command2)) {
     throw new ProcessExecutionError(
       "process_unsupported_script",
       "Use a native executable or a verified Node entrypoint"
     );
   }
-  return { command, arguments: args };
+  return { command: command2, arguments: args };
 }
 function readProcessTable() {
   const systemRoot = environmentValue2(process.env, "SystemRoot");
@@ -71932,8 +71929,8 @@ async function runBoundedProcess(options) {
     }
   }
 }
-function executableLaunch2(command, args) {
-  return hostPlatform.executableLaunch(command, args);
+function executableLaunch2(command2, args) {
+  return hostPlatform.executableLaunch(command2, args);
 }
 var platformSpawnOptions = hostPlatform.spawnOptions;
 
@@ -73403,8 +73400,8 @@ var CodexOwnedAcpAgent = class {
       return;
     }
     const params = decoded.data;
-    const command = "command" in params ? params.command : void 0;
-    const title2 = (command ?? params.reason ?? "Approve a local change").slice(0, APPROVAL_REASON_CHARACTER_LIMIT);
+    const command2 = "command" in params ? params.command : void 0;
+    const title2 = (command2 ?? params.reason ?? "Approve a local change").slice(0, APPROVAL_REASON_CHARACTER_LIMIT);
     const turn = this.#turn;
     const decision = await this.#askPermission(
       title2,
@@ -76428,8 +76425,8 @@ function isBashTool(toolName) {
 }
 function bashCommand(value) {
   const record2 = value;
-  const command = record2?.command ?? record2?.cmd ?? record2?.args?.command ?? record2?.args?.cmd ?? record2?.input?.command ?? record2?.input?.cmd ?? record2?.rawInput?.command ?? record2?.rawInput?.cmd ?? record2?.toolInput?.command ?? record2?.toolInput?.cmd ?? record2?.details?.command ?? record2?.details?.cmd;
-  return typeof command === "string" && command.trim() ? command : void 0;
+  const command2 = record2?.command ?? record2?.cmd ?? record2?.args?.command ?? record2?.args?.cmd ?? record2?.input?.command ?? record2?.input?.cmd ?? record2?.rawInput?.command ?? record2?.rawInput?.cmd ?? record2?.toolInput?.command ?? record2?.toolInput?.cmd ?? record2?.details?.command ?? record2?.details?.cmd;
+  return typeof command2 === "string" && command2.trim() ? command2 : void 0;
 }
 function bashResultText(result) {
   const record2 = result;
@@ -77784,7 +77781,7 @@ var PiAcpAgent = class {
       const cmd = space === -1 ? trimmed.slice(1) : trimmed.slice(1, space);
       const argsString = space === -1 ? "" : trimmed.slice(space + 1);
       const args = parseCommandArgs(argsString);
-      if (builtinAvailableCommands().some((command) => command.name === cmd)) {
+      if (builtinAvailableCommands().some((command2) => command2.name === cmd)) {
         this.conn.startUserMessage();
       }
       if (cmd === "compact") {
@@ -79394,7 +79391,7 @@ var AcpAgentDefinition = class _AcpAgentDefinition {
   label;
   runtimeExecutables;
   #connectionFactory;
-  constructor(id, label, command, createConnection, environment = {}, agentVersion = "", agentIdentity = readExecutableIdentity(command), capabilities = unsupportedSessionCapabilities(), adapterVersion = agentVersion, runtimeExecutables = [agentIdentity]) {
+  constructor(id, label, command2, createConnection, environment = {}, agentVersion = "", agentIdentity = readExecutableIdentity(command2), capabilities = unsupportedSessionCapabilities(), adapterVersion = agentVersion, runtimeExecutables = [agentIdentity]) {
     this.agentIdentity = agentIdentity;
     this.agentVersion = agentVersion;
     this.adapterVersion = adapterVersion;
@@ -80413,11 +80410,11 @@ var AdapterSessionConnection = class {
             event = {
               kind: "commands",
               payload,
-              commands: update.availableCommands.slice(0, 500).map((command) => ({
-                description: truncate(command.description, 500),
-                inputHint: truncate(command.input?.hint ?? "", 255),
-                name: truncate(command.name, 128)
-              })).filter((command) => command.name.length > 0)
+              commands: update.availableCommands.slice(0, 500).map((command2) => ({
+                description: truncate(command2.description, 500),
+                inputHint: truncate(command2.input?.hint ?? "", 255),
+                name: truncate(command2.name, 128)
+              })).filter((command2) => command2.name.length > 0)
             };
             break;
           case "config_option_update":
@@ -82146,14 +82143,14 @@ var acpSessionStoreMigrations = [
   {
     "name": "0011_receipt_admission_order_required.sql",
     "sql": 'PRAGMA foreign_keys=OFF;--> statement-breakpoint\nCREATE TABLE `__new_execution_receipt` (\n	`command_id` text PRIMARY KEY NOT NULL,\n	`session_id` text NOT NULL,\n	`command_hash` text NOT NULL,\n	`attempt_id` text NOT NULL,\n	`admission_order` integer NOT NULL,\n	`started` integer NOT NULL,\n	`outcome` text,\n	`updated_at` text NOT NULL\n);\n--> statement-breakpoint\nINSERT INTO `__new_execution_receipt`("command_id", "session_id", "command_hash", "attempt_id", "admission_order", "started", "outcome", "updated_at") SELECT "command_id", "session_id", "command_hash", "attempt_id", "admission_order", "started", "outcome", "updated_at" FROM `execution_receipt`;--> statement-breakpoint\nDROP TABLE `execution_receipt`;--> statement-breakpoint\nALTER TABLE `__new_execution_receipt` RENAME TO `execution_receipt`;--> statement-breakpoint\nPRAGMA foreign_keys=ON;'
-  }
-];
-
-// src/engine/generated/command-cancellation-migrations.ts
-var commandCancellationMigrations = [
+  },
   {
-    "name": "0000_tired_cardiac.sql",
-    "sql": "CREATE TABLE `cancelled_command` (\n	`command_id` text PRIMARY KEY NOT NULL,\n	`session_id` text NOT NULL\n);\n"
+    "name": "0012_retire_execution_receipts.sql",
+    "sql": "DROP TABLE `execution_identity`;--> statement-breakpoint\nDROP TABLE `execution_receipt`;"
+  },
+  {
+    "name": "0013_command_ledger.sql",
+    "sql": 'CREATE TABLE `command` (\n	`command_id` text PRIMARY KEY NOT NULL,\n	`session_id` text NOT NULL,\n	`command_hash` text NOT NULL,\n	`attempt_id` text NOT NULL,\n	`admission_order` integer NOT NULL,\n	`fate` text NOT NULL,\n	`started_at` text,\n	CONSTRAINT "command_fate" CHECK("command"."fate" IN (\'pending\', \'started\', \'cancelled\', \'settled-before-start\', \'settled-after-start\')),\n	CONSTRAINT "command_started_at" CHECK(("command"."fate" IN (\'started\', \'settled-after-start\')) = ("command"."started_at" IS NOT NULL))\n);\n--> statement-breakpoint\nCREATE UNIQUE INDEX `command_admission_order_idx` ON `command` (`admission_order`);--> statement-breakpoint\nCREATE INDEX `command_session_idx` ON `command` (`session_id`,`admission_order`);--> statement-breakpoint\nCREATE TABLE `command_outcome` (\n	`command_id` text PRIMARY KEY NOT NULL,\n	`outcome` text NOT NULL\n);\n'
   }
 ];
 
@@ -84087,6 +84084,32 @@ function sqliteTableWithCasing(casing) {
 }
 var sqliteTable = sqliteTableWithCasing(void 0);
 
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20261028.1_@types+better-sqlite3@7.6_12a6406e88a0f7753ae87b6d067c841c/node_modules/drizzle-orm/sqlite-core/checks.js
+var CheckBuilder = class {
+  static [entityKind] = "SQLiteCheckBuilder";
+  brand;
+  constructor(name2, value) {
+    this.name = name2;
+    this.value = value;
+  }
+  build(table) {
+    return new Check(table, this);
+  }
+};
+var Check = class {
+  static [entityKind] = "SQLiteCheck";
+  name;
+  value;
+  constructor(table, builder) {
+    this.table = table;
+    this.name = builder.name;
+    this.value = builder.value;
+  }
+};
+function check2(name2, value) {
+  return new CheckBuilder(name2, value);
+}
+
 // ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20261028.1_@types+better-sqlite3@7.6_12a6406e88a0f7753ae87b6d067c841c/node_modules/drizzle-orm/sqlite-core/indexes.js
 var IndexBuilderOn = class {
   static [entityKind] = "SQLiteIndexBuilderOn";
@@ -84137,6 +84160,9 @@ var Index = class {
 function index(name2) {
   return new IndexBuilderOn(name2, false);
 }
+function uniqueIndex(name2) {
+  return new IndexBuilderOn(name2, true);
+}
 
 // ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20261028.1_@types+better-sqlite3@7.6_12a6406e88a0f7753ae87b6d067c841c/node_modules/drizzle-orm/sqlite-core/primary-keys.js
 function primaryKey(...config2) {
@@ -84960,11 +84986,11 @@ function exists(subquery) {
 function notExists(subquery) {
   return sql`not exists ${subquery}`;
 }
-function between(column, min, max) {
-  return sql`${column} between ${bindIfParam(min, column)} and ${bindIfParam(max, column)}`;
+function between(column, min2, max2) {
+  return sql`${column} between ${bindIfParam(min2, column)} and ${bindIfParam(max2, column)}`;
 }
-function notBetween(column, min, max) {
-  return sql`${column} not between ${bindIfParam(min, column)} and ${bindIfParam(max, column)}`;
+function notBetween(column, min2, max2) {
+  return sql`${column} not between ${bindIfParam(min2, column)} and ${bindIfParam(max2, column)}`;
 }
 function like(column, value) {
   return sql`${column} like ${value}`;
@@ -85011,6 +85037,11 @@ function desc(column) {
   return sql`${column} desc`;
 }
 
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20261028.1_@types+better-sqlite3@7.6_12a6406e88a0f7753ae87b6d067c841c/node_modules/drizzle-orm/sql/functions/aggregate.js
+function max(expression) {
+  return sql`max(${expression})`.mapWith(is(expression, Column) ? expression : String);
+}
+
 // ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20261028.1_@types+better-sqlite3@7.6_12a6406e88a0f7753ae87b6d067c841c/node_modules/drizzle-orm/relations.js
 var Relation = class {
   static [entityKind] = "RelationV2";
@@ -87096,7 +87127,6 @@ var LocalSqliteDatabase = class {
 function channelSessionDatabasePaths(stateDirectory, channelId) {
   const channelHash = createHash4("sha256").update(channelId).digest("hex");
   return {
-    cancellations: join23(stateDirectory, "sessions", `${channelHash}.cancellations.sqlite`),
     events: join23(stateDirectory, "sessions", `${channelHash}.events.sqlite`),
     sessions: join23(stateDirectory, "sessions", `${channelHash}.sqlite`)
   };
@@ -87104,7 +87134,6 @@ function channelSessionDatabasePaths(stateDirectory, channelId) {
 var openAcpSessionDatabase = (path7) => {
   return new LocalSqliteDatabase(path7, "ACP Session database", acpSessionStoreMigrations);
 };
-var openCommandCancellationDatabase = (path7) => new LocalSqliteDatabase(path7, "Command cancellation database", commandCancellationMigrations);
 var openSessionEventCacheDatabase = (path7) => new LocalSqliteDatabase(path7, "V2 Session event cache", sessionEventCacheMigrations, [
   "PRAGMA journal_mode = WAL",
   "PRAGMA synchronous = OFF",
@@ -88868,23 +88897,39 @@ var acpSession = sqliteTable("acp_session", {
   updatedAt: text("updated_at").notNull()
 });
 
-// src/engine/schema/acp-session-store/execution-identity.ts
-var executionIdentity = sqliteTable("execution_identity", {
-  commandId: text("command_id").primaryKey(),
-  sessionId: text("session_id").notNull(),
-  commandHash: text("command_hash").notNull()
-});
+// src/engine/schema/acp-session-store/command.ts
+var command = sqliteTable(
+  "command",
+  {
+    commandId: text("command_id").primaryKey(),
+    sessionId: text("session_id").notNull(),
+    commandHash: text("command_hash").notNull(),
+    attemptId: text("attempt_id").notNull(),
+    admissionOrder: integer2("admission_order").notNull(),
+    fate: text("fate", {
+      enum: ["pending", "started", "cancelled", "settled-before-start", "settled-after-start"]
+    }).notNull(),
+    /** When the Agent received the command; only a command that started has one. */
+    startedAt: text("started_at")
+  },
+  (table) => [
+    uniqueIndex("command_admission_order_idx").on(table.admissionOrder),
+    index("command_session_idx").on(table.sessionId, table.admissionOrder),
+    check2(
+      "command_fate",
+      sql`${table.fate} IN ('pending', 'started', 'cancelled', 'settled-before-start', 'settled-after-start')`
+    ),
+    check2(
+      "command_started_at",
+      sql`(${table.fate} IN ('started', 'settled-after-start')) = (${table.startedAt} IS NOT NULL)`
+    )
+  ]
+);
 
-// src/engine/schema/acp-session-store/execution-receipt.ts
-var executionReceipt = sqliteTable("execution_receipt", {
+// src/engine/schema/acp-session-store/command-outcome.ts
+var commandOutcome = sqliteTable("command_outcome", {
   commandId: text("command_id").primaryKey(),
-  sessionId: text("session_id").notNull(),
-  commandHash: text("command_hash").notNull(),
-  attemptId: text("attempt_id").notNull(),
-  admissionOrder: integer2("admission_order").notNull(),
-  started: integer2("started", { mode: "boolean" }).notNull(),
-  outcome: text("outcome"),
-  updatedAt: text("updated_at").notNull()
+  outcome: text("outcome").notNull()
 });
 
 // src/engine/schema/acp-session-store/session-live-event-position-allocation.ts
@@ -88928,90 +88973,111 @@ var AcpSessionTable = class {
   };
 };
 
-// src/engine/schema/command-cancellation/cancelled-command.ts
-var cancelledCommand = sqliteTable("cancelled_command", {
-  commandId: text("command_id").primaryKey(),
-  sessionId: text("session_id").notNull()
-});
-
-// src/engine/storage/session/command-cancellation-table.ts
-var cancellationSchema = external_exports.object({ commandId: external_exports.string(), sessionId: external_exports.string() }).readonly();
-var CommandCancellationTable = class {
-  #database;
-  constructor(database) {
-    this.#database = database;
-  }
-  close = () => this.#database.close();
-  read = (commandId) => {
-    const row = this.#database.orm.select().from(cancelledCommand).where(eq2(cancelledCommand.commandId, commandId)).get();
-    return row === void 0 ? void 0 : cancellationSchema.parse(row);
-  };
-  retain = (cancellations) => {
-    this.#database.transaction(() => {
-      for (const cancellation of cancellations) {
-        this.#database.orm.insert(cancelledCommand).values(cancellation).onConflictDoNothing().run();
-      }
-    });
-  };
-};
-
-// src/engine/storage/session/execution-receipt-table.ts
-var receiptSchema = external_exports.object({
+// src/engine/storage/session/command-ledger-table.ts
+var OUTCOMES_PER_SESSION = 1024;
+var rowSchema = external_exports.object({
   commandId: external_exports.string(),
   sessionId: external_exports.string(),
   commandHash: external_exports.string(),
   attemptId: external_exports.string(),
   admissionOrder: external_exports.number().int().positive().safe(),
-  updatedAt: external_exports.string(),
-  started: external_exports.boolean(),
+  fate: external_exports.enum(["pending", "started", "cancelled", "settled-before-start", "settled-after-start"]),
+  startedAt: external_exports.string().nullable(),
   outcome: external_exports.string().nullable()
 }).readonly();
-var identitySchema = external_exports.object({ sessionId: external_exports.string(), commandHash: external_exports.string() }).readonly();
-var ExecutionReceiptTable = class {
+function ledgerCommand({ fate, startedAt, outcome, ...identity2 }) {
+  const invalid = () => {
+    throw new Error("The command ledger holds an invalid row", { cause: { commandId: identity2.commandId, fate } });
+  };
+  switch (fate) {
+    case "pending":
+      return outcome === null ? { ...identity2, fate: { kind: fate } } : invalid();
+    case "started":
+      return startedAt !== null && outcome === null ? { ...identity2, fate: { kind: fate, startedAt } } : invalid();
+    case "cancelled":
+      return { ...identity2, fate: { kind: fate, outcome } };
+    case "settled-before-start":
+      return outcome === null ? invalid() : { ...identity2, fate: { kind: fate, outcome } };
+    case "settled-after-start":
+      return startedAt === null ? invalid() : { ...identity2, fate: { kind: fate, startedAt, outcome } };
+    default:
+      return fate;
+  }
+}
+var CommandLedgerTable = class {
   #database;
   constructor(database) {
     this.#database = database;
   }
-  identity = (commandId) => {
-    const row = this.#database.orm.select({ sessionId: executionIdentity.sessionId, commandHash: executionIdentity.commandHash }).from(executionIdentity).where(eq2(executionIdentity.commandId, commandId)).get();
-    return row === void 0 ? void 0 : identitySchema.parse(row);
+  #select = () => this.#database.orm.select({
+    commandId: command.commandId,
+    sessionId: command.sessionId,
+    commandHash: command.commandHash,
+    attemptId: command.attemptId,
+    admissionOrder: command.admissionOrder,
+    fate: command.fate,
+    startedAt: command.startedAt,
+    outcome: commandOutcome.outcome
+  }).from(command).leftJoin(commandOutcome, eq2(commandOutcome.commandId, command.commandId));
+  read = (commandId) => {
+    const row = this.#select().where(eq2(command.commandId, commandId)).get();
+    return row === void 0 ? void 0 : ledgerCommand(rowSchema.parse(row));
+  };
+  /** The Session's commands in admission order. */
+  session = (sessionId) => this.#select().where(eq2(command.sessionId, sessionId)).orderBy(asc(command.admissionOrder)).all().map((row) => ledgerCommand(rowSchema.parse(row)));
+  /** Every command in admission order. */
+  all = () => this.#select().orderBy(asc(command.admissionOrder)).all().map((row) => ledgerCommand(rowSchema.parse(row)));
+  /** The commands that have not settled. */
+  unsettled = () => this.#database.orm.select({ commandId: command.commandId }).from(command).where(inArray(command.fate, ["pending", "started"])).all().map((row) => row.commandId);
+  /**
+   * Admits a command after every other. An earlier admission of the identifier that settled before it started is
+   * replaced; any other earlier admission makes this one fail.
+   */
+  admit = (identity2) => {
+    this.#database.transaction(() => {
+      const replaced = this.#database.orm.delete(command).where(and(eq2(command.commandId, identity2.commandId), eq2(command.fate, "settled-before-start"))).returning({ commandId: command.commandId }).get();
+      if (replaced !== void 0) {
+        this.#database.orm.delete(commandOutcome).where(eq2(commandOutcome.commandId, replaced.commandId)).run();
+      }
+      this.#database.orm.insert(command).values({ ...identity2, admissionOrder: this.#nextAdmissionOrder(), fate: "pending" }).run();
+    });
+  };
+  /** Records that a pending command was handed to its Agent. */
+  start = (commandId, startedAt) => {
+    this.#database.orm.update(command).set({ fate: "started", startedAt }).where(and(eq2(command.commandId, commandId), eq2(command.fate, "pending"))).run();
   };
-  list = () => this.#database.orm.select().from(executionReceipt).orderBy(asc(executionReceipt.admissionOrder), asc(executionReceipt.commandId)).all().map((row) => receiptSchema.parse(row));
-  save = (receipt, terminalLimit) => this.#database.transaction(() => {
-    this.#database.orm.insert(executionReceipt).values(receipt).onConflictDoUpdate({ target: executionReceipt.commandId, set: receipt }).run();
-    if (receipt.outcome === null) {
+  /**
+   * Settles an unsettled command with its outcome and drops the outcomes the Session no longer keeps. Returns the
+   * commands whose outcome was dropped.
+   */
+  settle = (commandId, fate, outcome) => this.#database.transaction(() => {
+    const settled = this.#database.orm.update(command).set(fate === "settled-after-start" ? { fate } : { fate, startedAt: null }).where(and(eq2(command.commandId, commandId), inArray(command.fate, ["pending", "started"]))).returning({ sessionId: command.sessionId }).get();
+    if (settled === void 0) {
       return [];
     }
-    const retained = this.#database.orm.select({ commandId: executionReceipt.commandId }).from(executionReceipt).where(and(eq2(executionReceipt.sessionId, receipt.sessionId), isNotNull(executionReceipt.outcome))).orderBy(desc(executionReceipt.updatedAt), desc(executionReceipt.commandId)).limit(terminalLimit).all();
-    if (retained.length === terminalLimit) {
-      return this.#remove(
-        and(
-          eq2(executionReceipt.sessionId, receipt.sessionId),
-          isNotNull(executionReceipt.outcome),
-          notInArray(
-            executionReceipt.commandId,
-            retained.map((row) => row.commandId)
-          )
-        )
-      );
-    }
-    return [];
+    this.#database.orm.insert(commandOutcome).values({ commandId, outcome }).run();
+    return this.#dropOutcomes(settled.sessionId);
   });
-  remove = (commandId) => {
-    this.#database.transaction(() => this.#remove(eq2(executionReceipt.commandId, commandId)));
-  };
-  #remove = (condition) => {
-    if (condition === void 0) {
-      throw new Error("Execution receipt removal requires a scope");
+  /** Admits an unseen command as already cancelled, so the identifier can never run. */
+  admitCancelled = (identity2, outcome) => this.#database.transaction(() => {
+    this.#database.orm.insert(command).values({ ...identity2, admissionOrder: this.#nextAdmissionOrder(), fate: "cancelled" }).run();
+    this.#database.orm.insert(commandOutcome).values({ commandId: identity2.commandId, outcome }).run();
+    return this.#dropOutcomes(identity2.sessionId);
+  });
+  #nextAdmissionOrder = () => (this.#database.orm.select({ latest: max(command.admissionOrder) }).from(command).get()?.latest ?? 0) + 1;
+  /** Keeps the outcomes of the Session's latest settled commands; a command that never started goes with its outcome. */
+  #dropOutcomes = (sessionId) => {
+    const boundary = this.#database.orm.select({ admissionOrder: command.admissionOrder }).from(command).innerJoin(commandOutcome, eq2(commandOutcome.commandId, command.commandId)).where(eq2(command.sessionId, sessionId)).orderBy(desc(command.admissionOrder)).limit(1).offset(OUTCOMES_PER_SESSION - 1).get();
+    if (boundary === void 0) {
+      return [];
+    }
+    const dropped = this.#database.orm.select({ commandId: command.commandId, fate: command.fate }).from(command).innerJoin(commandOutcome, eq2(commandOutcome.commandId, command.commandId)).where(and(eq2(command.sessionId, sessionId), lt2(command.admissionOrder, boundary.admissionOrder))).all();
+    const commandIds = dropped.map((row) => row.commandId);
+    if (commandIds.length > 0) {
+      this.#database.orm.delete(commandOutcome).where(inArray(commandOutcome.commandId, commandIds)).run();
+      this.#database.orm.delete(command).where(and(inArray(command.commandId, commandIds), eq2(command.fate, "settled-before-start"))).run();
     }
-    this.#database.orm.insert(executionIdentity).select(
-      this.#database.orm.select({
-        commandId: executionReceipt.commandId,
-        sessionId: executionReceipt.sessionId,
-        commandHash: executionReceipt.commandHash
-      }).from(executionReceipt).where(and(condition, eq2(executionReceipt.started, true)))
-    ).onConflictDoNothing().run();
-    return this.#database.orm.delete(executionReceipt).where(condition).returning({ commandId: executionReceipt.commandId }).all().map((row) => row.commandId);
+    return commandIds;
   };
 };
 
@@ -91991,8 +92057,8 @@ var NativeSessionService = class {
     this.#sessions = sessions;
     this.#activeTurn = activeTurn;
   }
-  execute = async (command, signal) => {
-    return await this.#operations.run({ signal }, (scoped) => this.#execute(command, scoped.signal));
+  execute = async (command2, signal) => {
+    return await this.#operations.run({ signal }, (scoped) => this.#execute(command2, scoped.signal));
   };
   close = () => this.#operations.close(async () => void 0);
   readSessionHistory = async (options, nativeSessionId, eventLimit, cursor) => this.#operations.run(
@@ -92010,31 +92076,31 @@ var NativeSessionService = class {
       })
     )
   );
-  #execute = async (command, signal) => {
+  #execute = async (command2, signal) => {
     signal.throwIfAborted();
-    const cwd = await this.#directories.resolve(this.#bindingId, command.directoryId, signal);
+    const cwd = await this.#directories.resolve(this.#bindingId, command2.directoryId, signal);
     const additionalDirectories = await this.#directories.resolveMany(
       this.#bindingId,
-      command.additionalDirectoryIds,
+      command2.additionalDirectoryIds,
       signal
     );
     signal.throwIfAborted();
     const options = {
       additionalDirectories,
-      ...await this.#resolveAgent(command.agentId, signal),
+      ...await this.#resolveAgent(command2.agentId, signal),
       cwd,
-      sessionId: command.sessionId,
+      sessionId: command2.sessionId,
       signal
     };
-    if (command.action === "active-turn") {
-      nativeSessionIdSchema.parse(command.targetSessionId);
+    if (command2.action === "active-turn") {
+      nativeSessionIdSchema.parse(command2.targetSessionId);
       return {
         action: "active-turn",
         kind: "native.session.result",
-        requestId: command.requestId,
-        sessionId: command.sessionId,
-        targetSessionId: command.targetSessionId,
-        ...await this.#activeTurn(command, options),
+        requestId: command2.requestId,
+        sessionId: command2.sessionId,
+        targetSessionId: command2.targetSessionId,
+        ...await this.#activeTurn(command2, options),
         queuedCancellation: "before-start"
       };
     }
@@ -92046,10 +92112,10 @@ var NativeSessionService = class {
         "native_session_unsupported"
       );
     }
-    const entryScope = JSON.stringify([command.agentId, command.bindingId, command.sessionId]);
+    const entryScope = JSON.stringify([command2.agentId, command2.bindingId, command2.sessionId]);
     const cursorScope = JSON.stringify([entryScope, cwd]);
     const register = async (info) => {
-      const authorized = await this.authorizeEntry(command, options, info);
+      const authorized = await this.authorizeEntry(command2, options, info);
       if (authorized === null) {
         return null;
       }
@@ -92065,7 +92131,7 @@ var NativeSessionService = class {
       });
       return {
         entryId,
-        mortySessionIds: this.#sessions.findLinkedSessions(command.agentId, info.sessionId).filter((session) => session.prompted && session.cwd === authorized.cwd).map((session) => decodeIdentifier(session.sessionId)),
+        mortySessionIds: this.#sessions.findLinkedSessions(command2.agentId, info.sessionId).filter((session) => session.prompted && session.cwd === authorized.cwd).map((session) => decodeIdentifier(session.sessionId)),
         nativeSessionId: decodeIdentifier(info.sessionId),
         title: info.title ?? "Untitled session",
         directoryId: authorized.directoryId,
@@ -92076,13 +92142,13 @@ var NativeSessionService = class {
     };
     const envelope2 = {
       kind: "native.session.result",
-      requestId: command.requestId,
-      sessionId: command.sessionId
+      requestId: command2.requestId,
+      sessionId: command2.sessionId
     };
-    if (command.action === "list") {
+    if (command2.action === "list") {
       let cursor = null;
-      if (command.cursor !== null) {
-        const known = this.#cursors.get(command.cursor);
+      if (command2.cursor !== null) {
+        const known = this.#cursors.get(command2.cursor);
         if (known?.scope !== cursorScope) {
           throw new AcpExecutionError(
             "Refresh the native session list before continuing",
@@ -92126,10 +92192,10 @@ var NativeSessionService = class {
         nextCursor
       };
     }
-    if (command.action === "find") {
+    if (command2.action === "find") {
       const found = await options.adapter.findSession({
         query: nativeSessionQuery(options),
-        nativeSessionId: command.nativeSessionId,
+        nativeSessionId: command2.nativeSessionId,
         budget: {
           maximumPages: 500,
           maximumEntries: 500
@@ -92141,7 +92207,7 @@ var NativeSessionService = class {
       }
       throw new AcpExecutionError("The native session was not found", {}, "native_session_not_found");
     }
-    const selected = this.#entries.get(command.entryId);
+    const selected = this.#entries.get(command2.entryId);
     if (selected?.scope !== entryScope) {
       throw new AcpExecutionError(
         "Select a session from a fresh native session list",
@@ -92156,8 +92222,8 @@ var NativeSessionService = class {
         "native_session_target_changed"
       );
     }
-    const target = await this.resolveTarget(command, options, selected);
-    const action = command.action;
+    const target = await this.resolveTarget(command2, options, selected);
+    const action = command2.action;
     if (action === "import" && !capabilities.loadSession && !capabilities.resumeSession) {
       throw new AcpExecutionError("This Agent cannot import native sessions", {}, "native_session_unsupported");
     }
@@ -92181,7 +92247,7 @@ var NativeSessionService = class {
       {
         ...options,
         cwd: target.cwd,
-        sessionId: command.targetSessionId,
+        sessionId: command2.targetSessionId,
         additionalDirectories: target.additionalDirectories
       },
       action === "fork" ? { kind: "fork", nativeSessionId: target.info.sessionId, title: title2 } : { kind: "import", nativeSessionId: target.info.sessionId, title: title2 },
@@ -92190,7 +92256,7 @@ var NativeSessionService = class {
     signal.throwIfAborted();
     const ready = {
       additionalDirectories: target.additionalEntries,
-      agentId: command.agentId,
+      agentId: command2.agentId,
       agentName: opened.prepared.agentName,
       agentVersion: opened.prepared.agentVersion,
       capabilities: opened.prepared.capabilities,
@@ -92200,7 +92266,7 @@ var NativeSessionService = class {
       directoryId: target.directoryId,
       directoryLabel: target.directoryLabel,
       kind: "session.ready",
-      requestId: command.requestId,
+      requestId: command2.requestId,
       restored: true,
       sessionId: opened.sessionId
     };
@@ -92208,7 +92274,7 @@ var NativeSessionService = class {
       ...envelope2,
       action,
       ready,
-      targetSessionId: command.targetSessionId,
+      targetSessionId: command2.targetSessionId,
       title: title2
     };
   };
@@ -92242,14 +92308,14 @@ var NativeSessionService = class {
     }
     return entries;
   };
-  authorizeEntry = async (command, options, info) => {
+  authorizeEntry = async (command2, options, info) => {
     try {
-      const primary = await this.#directories.identify(command.bindingId, info.cwd, options.signal);
+      const primary = await this.#directories.identify(command2.bindingId, info.cwd, options.signal);
       const additionalDirectories = [];
       const additionalEntries = [];
       const paths = /* @__PURE__ */ new Set([primary.path]);
       for (const path7 of info.additionalDirectories) {
-        const directory = await this.#directories.identify(command.bindingId, path7, options.signal);
+        const directory = await this.#directories.identify(command2.bindingId, path7, options.signal);
         if (paths.has(directory.path)) {
           throw new LocalAuthorizationError("Native session roots must be distinct");
         }
@@ -92276,7 +92342,7 @@ var NativeSessionService = class {
       throw error62;
     }
   };
-  resolveTarget = async (command, options, selected) => {
+  resolveTarget = async (command2, options, selected) => {
     const info = await options.adapter.findSession({
       query: nativeSessionQuery(options),
       nativeSessionId: selected.nativeSessionId,
@@ -92295,7 +92361,7 @@ var NativeSessionService = class {
       }
       throw cause;
     });
-    const target = await this.authorizeEntry(command, options, info);
+    const target = await this.authorizeEntry(command2, options, info);
     if (target === null) {
       throw new LocalAuthorizationError("The selected native session is not authorized");
     }
@@ -92376,12 +92442,12 @@ async function resolvePromptArtifacts(read, attachments, signal) {
 }
 
 // src/engine/session/prompt/prompt-lifecycle.ts
-function promptContent(command) {
+function promptContent(command2) {
   const content = [];
-  if (command.prompt.length > 0) {
-    content.push({ text: command.prompt, type: "text" });
+  if (command2.prompt.length > 0) {
+    content.push({ text: command2.prompt, type: "text" });
   }
-  for (const attachment of command.attachments) {
+  for (const attachment of command2.attachments) {
     content.push(
       attachment.kind === "image" ? {
         byteLength: attachment.byteLength,
@@ -92418,31 +92484,30 @@ var PromptLifecycle = class {
     this.#executions = executions;
     this.#sink = sink;
   }
-  requested = (command) => {
-    this.#queued.set(command.commandId, {
-      commandId: command.commandId,
-      content: promptContent(command),
-      ...command.disposition === void 0 ? {} : { disposition: command.disposition },
+  requested = (command2) => {
+    this.#queued.set(command2.commandId, {
+      commandId: command2.commandId,
+      content: promptContent(command2),
+      disposition: command2.disposition,
       context: {
-        agentId: command.agentId,
-        directoryId: command.directoryId,
-        additionalDirectoryIds: command.additionalDirectoryIds
+        agentId: command2.agentId,
+        directoryId: command2.directoryId,
+        additionalDirectoryIds: command2.additionalDirectoryIds
       },
-      sessionId: command.sessionId,
-      ...command.targetCommandId.length === 0 ? {} : { targetCommandId: command.targetCommandId }
+      sessionId: command2.sessionId,
+      ...command2.disposition === SessionPromptDisposition.Steer ? { targetCommandId: command2.targetCommandId } : {}
     });
   };
   /** The lifecycle metadata the Agent session records when it starts this claimed command. */
-  lifecycle = (sessionId, commandId, attemptId, epoch, disposition) => {
+  lifecycle = (sessionId, commandId, attemptId, epoch, dispatch) => {
     const request = this.#queued.get(commandId);
     if (request?.sessionId === sessionId) {
       return {
         attemptId,
         content: request.content,
-        disposition,
         epoch,
         context: request.context,
-        ...request.targetCommandId === void 0 ? {} : { targetCommandId: request.targetCommandId }
+        ...dispatch.kind === "steer" ? { disposition: SessionPromptDisposition.Steer, targetCommandId: dispatch.targetCommandId } : { disposition: SessionPromptDisposition.Append }
       };
     }
     throw new Error("The executing prompt was not registered in the V2 queue");
@@ -92611,69 +92676,44 @@ async function settleAbandonedTurn(projection, operations, cancellation) {
 
 // src/engine/session/turn/execution-receipts.ts
 import { createHash as createHash8, randomUUID as randomUUID15 } from "node:crypto";
-var MAX_TERMINAL_RECEIPTS = 1024;
-function executionStarted(state) {
-  switch (state.kind) {
-    case "pending":
-    case "settled-before-start":
-      return false;
-    case "started":
-    case "settled-after-start":
-      return true;
-    default: {
-      const unreachable2 = state;
-      throw new Error("Unexpected execution state", { cause: unreachable2 });
-    }
-  }
+var isStarted = (fate) => fate.kind === "started" || fate.kind === "settled-after-start";
+var isUnsettled = (fate) => fate.kind === "pending" || fate.kind === "started";
+var lifecyclePayload = (outcome) => {
+  const event = decodeKnownSessionEventPayload(JSON.parse(outcome));
+  return event?.type === "lifecycle-metadata" ? event.payload : void 0;
+};
+function restartedBeforeStart(outcome) {
+  const payload = lifecyclePayload(outcome);
+  return payload?.kind === "prompt.failed-before-start" && payload.code === "runtime_restarted";
 }
-function cancelledBeforeStart(state) {
-  if (state.kind !== "settled-before-start") {
-    return false;
+function settledFate(fate, outcome) {
+  if (fate.kind === "started") {
+    return { kind: "settled-after-start", startedAt: fate.startedAt, outcome };
   }
-  const outcome = decodeKnownSessionEventPayload(JSON.parse(state.outcome));
-  return outcome?.type === "lifecycle-metadata" && outcome.payload.kind === "prompt.completed" && promptCompletion(outcome.payload).kind === "cancelled";
+  const payload = lifecyclePayload(outcome);
+  return payload?.kind === "prompt.completed" && promptCompletion(payload).kind === "cancelled" ? { kind: "cancelled", outcome } : { kind: "settled-before-start", outcome };
 }
-function restartedBeforeStart(state) {
-  if (state.kind !== "settled-before-start") {
-    return false;
+function commandStanding(command2, sessionId) {
+  if (command2 === void 0) {
+    return { kind: "unseen" };
   }
-  const outcome = decodeKnownSessionEventPayload(JSON.parse(state.outcome));
-  return outcome?.type === "lifecycle-metadata" && outcome.payload.kind === "prompt.failed-before-start" && outcome.payload.code === "runtime_restarted";
-}
-function executionOutcome(state) {
-  switch (state.kind) {
+  if (command2.sessionId !== sessionId) {
+    return { kind: "foreign" };
+  }
+  const fate = command2.fate;
+  switch (fate.kind) {
     case "pending":
     case "started":
-      return null;
+      return { kind: "retained", command: command2 };
+    case "cancelled":
+      return fate.outcome === null ? { kind: "cancelled" } : { kind: "retained", command: command2 };
     case "settled-before-start":
+      return restartedBeforeStart(fate.outcome) ? { kind: "retryable" } : { kind: "retained", command: command2 };
     case "settled-after-start":
-      return state.outcome;
-    default: {
-      const unreachable2 = state;
-      throw new Error("Unexpected execution state", { cause: unreachable2 });
-    }
-  }
-}
-function settledExecution(state, outcome) {
-  return { kind: executionStarted(state) ? "settled-after-start" : "settled-before-start", outcome };
-}
-function commandStanding({ receipt, identity: identity2, cancellation }, sessionId) {
-  if (receipt !== void 0) {
-    if (receipt.sessionId !== sessionId) {
-      return { kind: "foreign" };
-    }
-    if (!executionStarted(receipt.state) && !cancelledBeforeStart(receipt.state) && cancellation?.sessionId === sessionId) {
-      return { kind: "cancelled", receipt };
-    }
-    return restartedBeforeStart(receipt.state) ? { kind: "retryable", receipt } : { kind: "retained", receipt };
-  }
-  if (identity2 !== void 0) {
-    return identity2.sessionId === sessionId ? { kind: "expired", commandHash: identity2.commandHash } : { kind: "foreign" };
-  }
-  if (cancellation !== void 0) {
-    return cancellation.sessionId === sessionId ? { kind: "cancelled", receipt: void 0 } : { kind: "foreign" };
+      return fate.outcome === null ? { kind: "expired", commandHash: command2.commandHash } : { kind: "retained", command: command2 };
+    default:
+      return fate;
   }
-  return { kind: "unseen" };
 }
 var cancelledBeforeStartOutcome = (commandId) => ({
   type: "lifecycle-metadata",
@@ -92684,95 +92724,69 @@ var storedOutcome = (stored) => {
   const event = decodeKnownSessionEventPayload(parsed);
   return event === null ? void 0 : { event, recordedAt: external_exports.object({ recordedAt: external_exports.string() }).parse(parsed).recordedAt };
 };
-var unexpectedStanding = (standing) => {
-  throw new Error("Unexpected command standing", { cause: standing });
-};
 var ExecutionReceipts = class {
-  #executions = /* @__PURE__ */ new Map();
-  #table;
-  #cancellations;
-  #closing = false;
+  #ledger;
   #onCount;
-  constructor(table, cancellations, onCount = () => void 0) {
+  /**
+   * The terminal events this process recorded with the Agent's own failure text. That text can quote user input, so
+   * it never enters the ledger, which keeps the content-free form; clients of this process still read the original.
+   */
+  #agentOutcomes = /* @__PURE__ */ new Map();
+  /**
+   * Settlements reached while this process shuts down. They are artifacts of stopping, not of the commands, so the
+   * ledger keeps the commands unsettled and the next process reports that the restart interrupted them.
+   */
+  #shutdownSettlements = /* @__PURE__ */ new Map();
+  #closing = false;
+  constructor(ledger, onCount = () => void 0) {
+    this.#ledger = ledger;
     this.#onCount = onCount;
-    this.#table = table;
-    this.#cancellations = cancellations;
-    const retained = [];
-    for (const { commandId, started, outcome, updatedAt: _updatedAt, ...identity2 } of table.list()) {
-      const pending = { kind: started ? "started" : "pending" };
-      const state = outcome === null ? pending : settledExecution(pending, outcome);
-      this.#executions.set(commandId, {
-        ...identity2,
-        state
-      });
-      if (cancelledBeforeStart(state)) {
-        retained.push({ commandId, sessionId: identity2.sessionId });
-      }
-    }
-    cancellations.retain(retained);
   }
-  /** Reads every ledger that can still change the answer and classifies the identifier for the Session. */
-  #standing = (commandId, sessionId) => {
-    const receipt = this.#executions.get(commandId);
-    const final = receipt !== void 0 && (executionStarted(receipt.state) || cancelledBeforeStart(receipt.state));
-    return commandStanding(
-      {
-        receipt,
-        identity: receipt === void 0 ? this.#table.identity(commandId) : void 0,
-        cancellation: final ? void 0 : this.#cancellations.read(commandId)
-      },
-      sessionId
-    );
+  #withShutdownSettlement = (command2) => {
+    const fate = this.#shutdownSettlements.get(command2.commandId);
+    return fate === void 0 ? command2 : { ...command2, fate };
   };
-  #remember = (commandId, receipt, evicted) => {
-    this.#executions.set(commandId, receipt);
-    for (const evictedCommandId of evicted) {
-      this.#executions.delete(evictedCommandId);
-    }
-    let activeCount = 0;
-    for (const entry of this.#executions.values()) {
-      if (executionOutcome(entry.state) === null) {
-        activeCount += 1;
-      }
-    }
-    this.#onCount(activeCount);
+  #read = (commandId) => {
+    const command2 = this.#ledger.read(commandId);
+    return command2 === void 0 ? void 0 : this.#withShutdownSettlement(command2);
   };
-  #save = (commandId, receipt, durableOutcome = executionOutcome(receipt.state)) => {
-    const { state, ...identity2 } = receipt;
-    if (!this.#closing && cancelledBeforeStart(state)) {
-      this.#cancellations.retain([{ commandId, sessionId: receipt.sessionId }]);
-      this.#remember(commandId, receipt, []);
+  #standing = (commandId, sessionId) => commandStanding(this.#read(commandId), sessionId);
+  /** The outcome clients read for a settled command: what this process recorded, else the ledger's form. */
+  #outcome = ({ commandId, fate }) => {
+    if (isUnsettled(fate) || fate.outcome === null) {
+      return void 0;
     }
-    const evicted = this.#closing ? [] : this.#table.save(
-      {
-        ...identity2,
-        commandId,
-        started: executionStarted(state),
-        outcome: durableOutcome,
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      },
-      MAX_TERMINAL_RECEIPTS
-    );
-    this.#remember(commandId, receipt, evicted);
+    return this.#agentOutcomes.get(commandId) ?? fate.outcome;
   };
-  #nextAdmissionOrder = () => {
-    let latest = 0;
-    for (const receipt of this.#executions.values()) {
-      latest = Math.max(latest, receipt.admissionOrder);
+  #publishCount = () => {
+    this.#onCount(this.#ledger.unsettled().filter((commandId) => !this.#shutdownSettlements.has(commandId)).length);
+  };
+  /** Settles an unsettled command. `agentOutcome` is the outcome with the Agent's text, when it differs. */
+  #settle = (commandId, fate, outcome, agentOutcome) => {
+    const settled = settledFate(fate, outcome);
+    if (agentOutcome !== void 0) {
+      this.#agentOutcomes.set(commandId, agentOutcome);
+    }
+    if (this.#closing) {
+      this.#shutdownSettlements.set(commandId, settled);
+    } else {
+      for (const dropped of this.#ledger.settle(commandId, settled.kind, outcome)) {
+        this.#agentOutcomes.delete(dropped);
+      }
     }
-    return latest + 1;
+    this.#publishCount();
   };
   beginShutdown = () => {
     this.#closing = true;
   };
   outcome = (commandId) => this.restatedOutcome(commandId)?.event;
-  /** The outcome the command's receipt holds, with the time it was recorded. */
+  /** The outcome the ledger keeps for the command, with the time it was recorded. */
   restatedOutcome = (commandId) => {
-    const receipt = this.#executions.get(commandId);
-    const outcome = receipt === void 0 ? null : executionOutcome(receipt.state);
-    return outcome === null ? void 0 : storedOutcome(outcome);
+    const command2 = this.#read(commandId);
+    const outcome = command2 === void 0 ? void 0 : this.#outcome(command2);
+    return outcome === void 0 ? void 0 : storedOutcome(outcome);
   };
-  /** The command's delivery as these receipts know it; another Session's command reads as unknown. */
+  /** The command's delivery as the ledger knows it; another Session's command reads as unknown. */
   delivery = (commandId, sessionId) => {
     const standing = this.#standing(commandId, sessionId);
     switch (standing.kind) {
@@ -92787,9 +92801,10 @@ var ExecutionReceipts = class {
       case "retained":
         break;
       default:
-        return unexpectedStanding(standing);
+        return standing;
     }
-    if (executionOutcome(standing.receipt.state) === null) {
+    const command2 = this.#read(commandId);
+    if (command2 === void 0 || isUnsettled(command2.fate)) {
       return { state: "accepted" };
     }
     const outcome = this.outcome(commandId);
@@ -92805,62 +92820,54 @@ var ExecutionReceipts = class {
     }
   };
   /**
-   * How the Session's most recently admitted turn ended. Admission order survives updates and
-   * restarts. Commands that never started (queued, or reserved for cancellation) are not turns,
-   * unless they failed before starting. A steering command that completed as `steered` joined the
-   * turn it steered, which reports for both; a steer not known to have joined (it failed, or a
-   * restart interrupted it) keeps its own outcome. Undefined while the latest turn runs or none is
-   * retained.
+   * How the Session's most recently admitted turn ended. Commands that never started (queued, or reserved for
+   * cancellation) are not turns, unless they failed before starting. A steering command that completed as `steered`
+   * joined the turn it steered, which reports for both; a steer not known to have joined (it failed, or a restart
+   * interrupted it) keeps its own outcome. Undefined while the latest turn runs or its outcome is no longer kept.
    */
   lastTurn = (sessionId) => {
     let last;
-    let latestOrder = 0;
-    for (const [commandId, receipt] of this.#executions) {
-      if (receipt.sessionId !== sessionId) {
-        continue;
-      }
-      const outcome2 = this.outcome(commandId);
+    for (const stored of this.#ledger.session(sessionId)) {
+      const command2 = this.#withShutdownSettlement(stored);
+      const outcome2 = this.outcome(command2.commandId);
       const payload = outcome2?.type === "lifecycle-metadata" ? outcome2.payload : void 0;
       const failedBeforeStart = payload?.kind === "prompt.failed-before-start";
       const steered = payload?.kind === "prompt.completed" && promptCompletion(payload).kind === "steered";
-      if ((executionStarted(receipt.state) || failedBeforeStart) && !steered && receipt.admissionOrder > latestOrder) {
-        last = commandId;
-        latestOrder = receipt.admissionOrder;
+      const kept = command2.fate.kind === "started" || outcome2 !== void 0;
+      if (kept && (isStarted(command2.fate) || failedBeforeStart) && !steered) {
+        last = { commandId: command2.commandId, outcome: outcome2 };
       }
     }
-    const outcome = last === void 0 ? void 0 : this.outcome(last);
+    const outcome = last?.outcome;
     if (last === void 0 || outcome?.type !== "lifecycle-metadata" || !isPromptTerminal(outcome.payload)) {
       return void 0;
     }
     switch (outcome.payload.kind) {
       case "prompt.completed":
-        return { commandId: last, state: "completed", stopReason: outcome.payload.stopReason };
+        return { commandId: last.commandId, state: "completed", stopReason: outcome.payload.stopReason };
       case "prompt.failed":
       case "prompt.failed-before-start":
         return {
           code: outcome.payload.code,
-          commandId: last,
+          commandId: last.commandId,
           message: outcome.payload.message,
           state: "failed"
         };
     }
   };
-  /** When the Session's running command started, while its receipt holds the time. */
+  /** When the Session's running command started. */
   startedAt = (commandId, sessionId) => {
-    const receipt = this.#executions.get(commandId);
-    return receipt?.sessionId === sessionId && receipt.state.kind === "started" ? receipt.state.startedAt : void 0;
+    const command2 = this.#read(commandId);
+    return command2?.sessionId === sessionId && command2.fate.kind === "started" ? command2.fate.startedAt : void 0;
   };
   /**
    * The recorded terminal events of the Session's settled prompts whose Agent reported the user message they
-   * recorded, while their receipts are retained.
+   * recorded, while the ledger keeps their outcomes.
    */
   promptOutcomes = (sessionId) => {
     const outcomes = [];
-    for (const [commandId, receipt] of this.#executions) {
-      if (receipt.sessionId !== sessionId) {
-        continue;
-      }
-      const outcome = this.restatedOutcome(commandId);
+    for (const command2 of this.#ledger.session(sessionId)) {
+      const outcome = this.restatedOutcome(command2.commandId);
       const event = outcome?.event;
       if (outcome?.recordedAt !== void 0 && event?.type === "lifecycle-metadata" && (event.payload.kind === "prompt.completed" || event.payload.kind === "prompt.failed") && event.payload.messageId !== void 0) {
         outcomes.push({ payload: event.payload, recordedAt: outcome.recordedAt });
@@ -92868,7 +92875,7 @@ var ExecutionReceipts = class {
     }
     return outcomes;
   };
-  /** Started identities remain authoritative after their detailed receipt is evicted. */
+  /** A command that started stays started after its outcome is no longer kept. */
   hasStarted = (commandId, sessionId) => {
     const standing = this.#standing(commandId, sessionId);
     switch (standing.kind) {
@@ -92880,9 +92887,9 @@ var ExecutionReceipts = class {
       case "expired":
         return true;
       case "retained":
-        return executionStarted(standing.receipt.state);
+        return isStarted(standing.command.fate);
       default:
-        return unexpectedStanding(standing);
+        return standing;
     }
   };
   /**
@@ -92909,7 +92916,7 @@ var ExecutionReceipts = class {
       case "unseen":
         break;
       default:
-        return unexpectedStanding(standing);
+        return standing;
     }
     const outcome = cancelledBeforeStartOutcome(commandId);
     const commandHash = createHash8("sha256").update(
@@ -92919,22 +92926,18 @@ var ExecutionReceipts = class {
         sessionId
       })
     ).digest("hex");
-    this.#save(commandId, {
-      admissionOrder: this.#nextAdmissionOrder(),
-      attemptId: randomUUID15(),
-      commandHash,
-      sessionId,
-      state: {
-        kind: "settled-before-start",
-        outcome: JSON.stringify({ ...outcome, recordedAt: (/* @__PURE__ */ new Date()).toISOString() })
-      }
-    });
+    for (const dropped of this.#ledger.admitCancelled(
+      { attemptId: randomUUID15(), commandHash, commandId, sessionId },
+      JSON.stringify({ ...outcome, recordedAt: (/* @__PURE__ */ new Date()).toISOString() })
+    )) {
+      this.#agentOutcomes.delete(dropped);
+    }
     return { kind: "recorded", outcome };
   };
   /**
-   * Receipts follow their command's recorded lifecycle. `prompt.started` is recorded where the command is handed
+   * The ledger follows each command's recorded lifecycle. `prompt.started` is recorded where the command is handed
    * to the Agent, so the started mark and the event clients see are one transition; a terminal event settles the
-   * receipt. Nothing else marks a command started.
+   * command. Nothing else marks a command started.
    */
   record = (event) => {
     if (event.type !== "lifecycle-metadata") {
@@ -92942,70 +92945,66 @@ var ExecutionReceipts = class {
     }
     const payload = event.payload;
     if (payload.kind === "prompt.started") {
-      const receipt2 = this.#executions.get(payload.commandId);
-      if (receipt2?.state.kind === "pending") {
-        this.#save(payload.commandId, {
-          ...receipt2,
-          state: { kind: "started", startedAt: event.recordedAt }
-        });
-      }
+      this.#ledger.start(payload.commandId, event.recordedAt);
       return;
     }
     if (!isPromptTerminal(payload)) {
       return;
     }
-    const receipt = this.#executions.get(payload.commandId);
-    if (receipt === void 0) {
+    const fate = this.#read(payload.commandId)?.fate;
+    if (fate === void 0 || !isUnsettled(fate)) {
       return;
     }
-    const sanitized = payload.kind === "prompt.completed" ? payload : { ...payload, message: "The local Agent could not complete the request" };
     const outcome = { type: "lifecycle-metadata", payload, recordedAt: event.recordedAt };
-    this.#save(
+    if (payload.kind === "prompt.completed") {
+      this.#settle(payload.commandId, fate, JSON.stringify(outcome));
+      return;
+    }
+    const contentFree = { ...payload, message: "The local Agent could not complete the request" };
+    this.#settle(
       payload.commandId,
-      { ...receipt, state: settledExecution(receipt.state, JSON.stringify(outcome)) },
-      JSON.stringify({ ...outcome, payload: sanitized })
+      fate,
+      JSON.stringify({ ...outcome, payload: contentFree }),
+      JSON.stringify(outcome)
     );
   };
   recover = () => {
     const recovered = [];
-    for (const [commandId, receipt] of [...this.#executions]) {
-      const outcome = executionOutcome(receipt.state);
-      const restoreCancellation = this.#standing(commandId, receipt.sessionId).kind === "cancelled";
-      const event = restoreCancellation ? cancelledBeforeStartOutcome(commandId) : outcome === null ? {
+    for (const command2 of this.#ledger.all()) {
+      const fate = command2.fate;
+      if (!isUnsettled(fate)) {
+        const restated = fate.outcome === null ? void 0 : storedOutcome(fate.outcome);
+        if (restated !== void 0) {
+          recovered.push({ kind: "restated", sessionId: command2.sessionId, outcome: restated });
+        }
+        continue;
+      }
+      const event = {
         type: "lifecycle-metadata",
-        payload: executionStarted(receipt.state) ? {
+        payload: fate.kind === "started" ? {
           kind: "prompt.failed",
-          commandId,
-          attemptId: receipt.attemptId,
+          commandId: command2.commandId,
+          attemptId: command2.attemptId,
           code: "runtime_restarted",
           message: "The local runtime restarted while this request was running"
         } : {
           kind: "prompt.failed-before-start",
-          commandId,
+          commandId: command2.commandId,
           code: "runtime_restarted",
           message: "The local runtime restarted before this request started"
         }
-      } : decodeKnownSessionEventPayload(JSON.parse(outcome));
-      if (event === null) {
-        continue;
-      }
-      if (!restoreCancellation && outcome !== null) {
-        const restated = storedOutcome(outcome);
-        if (restated !== void 0) {
-          recovered.push({ kind: "restated", sessionId: receipt.sessionId, outcome: restated });
-        }
-        continue;
-      }
+      };
       const recordedAt = (/* @__PURE__ */ new Date()).toISOString();
-      recovered.push({ kind: "recorded", sessionId: receipt.sessionId, event, recordedAt });
-      this.#save(commandId, {
-        ...receipt,
-        state: settledExecution(receipt.state, JSON.stringify({ ...event, recordedAt }))
-      });
+      recovered.push({ kind: "recorded", sessionId: command2.sessionId, event, recordedAt });
+      this.#settle(command2.commandId, fate, JSON.stringify({ ...event, recordedAt }));
     }
     return recovered;
   };
-  claimExecution = (commandId, sessionId, commandJson) => {
+  /**
+   * Claims a command's identifier for the Session. A known identifier is answered from the ledger; a new command is
+   * recorded only when `admits` accepts it in the same step, so a command the Session refuses leaves no record.
+   */
+  claimExecution = (commandId, sessionId, commandJson, admits) => {
     const commandHash = createHash8("sha256").update(commandJson).digest("hex");
     const standing = this.#standing(commandId, sessionId);
     switch (standing.kind) {
@@ -93013,48 +93012,44 @@ var ExecutionReceipts = class {
       case "cancelled":
         return { kind: "conflict" };
       case "retained":
-        if (standing.receipt.commandHash !== commandHash) {
+        if (standing.command.commandHash !== commandHash) {
           return { kind: "conflict" };
         }
         return {
-          attemptId: standing.receipt.attemptId,
+          attemptId: standing.command.attemptId,
           commandId,
           kind: "duplicate",
-          state: executionOutcome(standing.receipt.state) === null ? "unsettled" : "settled"
+          state: isUnsettled(standing.command.fate) ? "unsettled" : "settled"
         };
       case "expired":
         return standing.commandHash === commandHash ? { kind: "expired" } : { kind: "conflict" };
       case "retryable":
-        this.#table.remove(commandId);
-        this.#executions.delete(commandId);
-        return this.claimExecution(commandId, sessionId, commandJson);
+      // A restart failed it before it started: the admission replaces that failure.
       case "unseen":
         break;
       default:
-        return unexpectedStanding(standing);
+        return standing;
+    }
+    if (!admits()) {
+      return { kind: "refused" };
     }
     const attemptId = randomUUID15();
-    this.#save(commandId, {
-      admissionOrder: this.#nextAdmissionOrder(),
-      attemptId,
-      commandHash,
-      sessionId,
-      state: { kind: "pending" }
-    });
+    this.#ledger.admit({ attemptId, commandHash, commandId, sessionId });
+    this.#publishCount();
     return { attemptId, commandId, kind: "accepted" };
   };
   /** Only commands without a terminal result can still be cancelled. */
   findUnsettledAttemptId = (commandId, sessionId) => {
-    const receipt = this.#executions.get(commandId);
-    return receipt?.sessionId === sessionId && executionOutcome(receipt.state) === null ? receipt.attemptId : null;
+    const command2 = this.#read(commandId);
+    return command2?.sessionId === sessionId && isUnsettled(command2.fate) ? command2.attemptId : null;
   };
   isTerminalExecution = (commandId, sessionId) => {
-    const receipt = this.#executions.get(commandId);
-    return receipt?.sessionId === sessionId && executionOutcome(receipt.state) !== null;
+    const command2 = this.#read(commandId);
+    return command2?.sessionId === sessionId && !isUnsettled(command2.fate);
   };
   close = () => {
-    this.#executions.clear();
-    this.#cancellations.close();
+    this.#agentOutcomes.clear();
+    this.#shutdownSettlements.clear();
   };
 };
 
@@ -93163,9 +93158,9 @@ var ActiveRuntimeTurn = class {
    * `started` and `startedAt` read the command's execution receipt, the single owner of whether and when the command
    * started.
    */
-  constructor(command, attemptId, started, startedAt) {
+  constructor(command2, attemptId, started, startedAt) {
     this.attemptId = attemptId;
-    this.command = command;
+    this.command = command2;
     this.#controller = new AbortController();
     this.#started = started;
     this.#startedAt = startedAt;
@@ -93177,16 +93172,16 @@ var ActiveRuntimeTurn = class {
     this.#admission = { kind: "queued", promotion: Promise.withResolvers() };
   };
   /** Whether the prompt was admitted to its Session's queue, whatever happened to it afterwards. */
-  enteredQueue = () => this.command.disposition === SessionPromptDisposition.Queue && this.#admission.kind !== "waiting";
-  isQueued = () => (this.#admission.kind === "queued" || this.#admission.kind === "admitted" && this.#admission.disposition === SessionPromptDisposition.Queue) && !this.#started() && !this.#controller.signal.aborted;
+  enteredQueue = () => this.#admission.kind === "queued" || this.#admission.kind === "promoted" || this.#admission.kind === "admitted" && this.#admission.fromQueue;
+  isQueued = () => (this.#admission.kind === "queued" || this.#admission.kind === "admitted" && this.#admission.fromQueue && this.#admission.dispatch.kind === "own") && !this.#started() && !this.#controller.signal.aborted;
   abortRuntime = () => {
     this.#controller.abort();
   };
   finish = () => {
     this.#finished.resolve();
   };
-  promoteQueuedPrompt = (command) => {
-    if (command.commandId !== this.command.commandId || command.sessionId !== this.command.sessionId || this.#controller.signal.aborted) {
+  promoteQueuedPrompt = (command2) => {
+    if (command2.commandId !== this.command.commandId || command2.sessionId !== this.command.sessionId || this.#controller.signal.aborted) {
       return "unavailable";
     }
     switch (this.#admission.kind) {
@@ -93199,15 +93194,19 @@ var ActiveRuntimeTurn = class {
       case "promoted":
         return "accepted";
       case "admitted":
-        return this.#admission.disposition === SessionPromptDisposition.Steer ? "accepted" : "already-started";
+        return this.#admission.dispatch.kind === "steer" ? "accepted" : "already-started";
       case "waiting":
         return "unavailable";
     }
   };
-  admit = () => {
-    const disposition = this.effectiveDisposition();
-    this.#admission = { kind: "admitted", disposition };
-    return disposition;
+  /**
+   * Fixes how the prompt executes before asynchronous Agent preparation, so a late promotion cannot change a dispatch
+   * that execution has already selected.
+   */
+  admit = (dispatch) => {
+    const fromQueue = this.enteredQueue();
+    this.#admission = { kind: "admitted", dispatch, fromQueue };
+    return dispatch;
   };
   queuePromotion = () => {
     if (this.#admission.kind === "queued") {
@@ -93215,19 +93214,21 @@ var ActiveRuntimeTurn = class {
     }
     return this.#admission.kind === "promoted" ? Promise.resolve() : null;
   };
-  effectiveDisposition = () => {
+  /** Whether the prompt joins another turn's execution instead of owning one, so it holds no place in the queue. */
+  isSteering = () => {
     switch (this.#admission.kind) {
       case "waiting":
+        return this.command.disposition === SessionPromptDisposition.Steer;
       case "queued":
-        return this.command.disposition;
+        return false;
       case "promoted":
-        return SessionPromptDisposition.Steer;
+        return true;
       case "admitted":
-        return this.#admission.disposition;
+        return this.#admission.dispatch.kind === "steer";
     }
   };
   /** A steering prompt joins the execution of the turn it steers; every other prompt owns its execution. */
-  execution = () => this.effectiveDisposition() === SessionPromptDisposition.Steer ? this.command.targetCommandId : this.command.commandId;
+  execution = () => this.#admission.kind === "admitted" && this.#admission.dispatch.kind === "steer" ? this.#admission.dispatch.targetCommandId : this.command.commandId;
   recordEvent = (event) => {
     if (event.sessionId !== this.command.sessionId || "commandId" in event && event.commandId !== this.command.commandId) {
       return event;
@@ -93312,14 +93313,14 @@ var SessionExecutionState = class {
     this.#operations = operations;
   }
   isEmpty = () => this.#turnsByCommandId.size === 0;
-  start = (command, attemptId) => {
+  start = (command2, attemptId) => {
     const turn = new ActiveRuntimeTurn(
-      command,
+      command2,
       attemptId,
-      () => this.#operations.hasStarted(command.commandId, this.#sessionId),
-      () => this.#operations.startedAt(command.commandId, this.#sessionId)
+      () => this.#operations.hasStarted(command2.commandId, this.#sessionId),
+      () => this.#operations.startedAt(command2.commandId, this.#sessionId)
     );
-    this.#turnsByCommandId.set(command.commandId, turn);
+    this.#turnsByCommandId.set(command2.commandId, turn);
     return turn;
   };
   get = (commandId) => this.#turnsByCommandId.get(commandId);
@@ -93351,31 +93352,27 @@ var SessionExecutionState = class {
     }
     await Promise.all(turns.map((turn) => turn.completion));
   };
+  /**
+   * Admits the turn in arrival order. A steering prompt joins the running turn it names. An appended prompt runs
+   * when no earlier turn owns an execution, and otherwise waits in the queue until every earlier one ended or the
+   * user promotes it to steer the turn it waits behind. Admission never refuses an appended prompt.
+   */
   admitAndWait = async (turn, waitSignal, onQueued) => {
-    const command = turn.command;
+    const command2 = turn.command;
     waitSignal.throwIfAborted();
-    const head = () => [...this.#turnsByCommandId.values()].find(
-      (turn2) => turn2.effectiveDisposition() !== SessionPromptDisposition.Steer
-    );
-    if (command.disposition === SessionPromptDisposition.Queue) {
-      const target = head();
-      if ((target === turn || target?.command.commandId !== command.targetCommandId) && !this.#operations.isTerminalExecution(command.targetCommandId, this.#sessionId)) {
-        return { kind: "queue-target-unavailable" };
-      }
+    if (command2.disposition === SessionPromptDisposition.Steer) {
+      return turn.admit({ kind: "steer", targetCommandId: command2.targetCommandId });
+    }
+    const head = () => [...this.#turnsByCommandId.values()].find((candidate) => !candidate.isSteering());
+    if (head() !== turn) {
       turn.enqueue();
       onQueued();
     }
-    if (turn.effectiveDisposition() === SessionPromptDisposition.Steer) {
-      return { disposition: turn.admit(), kind: "available" };
-    }
     for (; ; ) {
       waitSignal.throwIfAborted();
       const first = head();
       if (first === void 0 || first === turn) {
-        return { disposition: turn.admit(), kind: "available" };
-      }
-      if (command.disposition !== SessionPromptDisposition.Queue) {
-        return { kind: "busy" };
+        return turn.admit({ kind: "own" });
       }
       const promotion = turn.queuePromotion();
       if (promotion === null) {
@@ -93386,7 +93383,7 @@ var SessionExecutionState = class {
         promotion.then(() => "promoted")
       ]);
       if (decision === "promoted") {
-        return { disposition: turn.admit(), kind: "available" };
+        return turn.admit({ kind: "steer", targetCommandId: first.command.commandId });
       }
     }
   };
@@ -93411,8 +93408,8 @@ var SessionTurns = class {
     return session;
   };
   get = (commandId, sessionId) => this.#bySessionId.get(sessionId)?.get(commandId);
-  start = (command, attemptId) => {
-    const turn = this.session(command.sessionId).start(command, attemptId);
+  start = (command2, attemptId) => {
+    const turn = this.session(command2.sessionId).start(command2, attemptId);
     this.#activity.start(turn);
     return turn;
   };
@@ -93673,20 +93670,13 @@ function buildSessionLayer(options) {
   const sessionDatabase = openAcpSessionDatabase(databases.sessions);
   let events;
   let operations;
-  let cancellations;
   try {
-    cancellations = new CommandCancellationTable(openCommandCancellationDatabase(databases.cancellations));
-    operations = new ExecutionReceipts(
-      new ExecutionReceiptTable(sessionDatabase),
-      cancellations,
-      options.onExecutionCountChange
-    );
+    operations = new ExecutionReceipts(new CommandLedgerTable(sessionDatabase), options.onExecutionCountChange);
     events = new CachedSessionEventStore(
       new SessionEventCacheTable(openSessionEventCacheDatabase(databases.events)),
       new SqliteSessionLiveEventPosition(new LiveEventPositionTable(sessionDatabase))
     );
   } catch (error62) {
-    cancellations?.close();
     sessionDatabase.close();
     throw error62;
   }
@@ -93734,14 +93724,14 @@ function buildSessionLayer(options) {
     directories,
     manager,
     async (request, requestOptions) => {
-      const snapshot = await activeSessions.executionSnapshot(async (command) => {
-        if (command.sessionId !== request.targetSessionId || command.agentId !== request.agentId) {
+      const snapshot = await activeSessions.executionSnapshot(async (command2) => {
+        if (command2.sessionId !== request.targetSessionId || command2.agentId !== request.agentId) {
           return false;
         }
-        const cwd = await directories.resolve(command.bindingId, command.directoryId, requestOptions.signal);
+        const cwd = await directories.resolve(command2.bindingId, command2.directoryId, requestOptions.signal);
         const additionalDirectories = await directories.resolveMany(
-          command.bindingId,
-          command.additionalDirectoryIds,
+          command2.bindingId,
+          command2.additionalDirectoryIds,
           requestOptions.signal
         );
         return cwd === requestOptions.cwd && additionalDirectories.length === requestOptions.additionalDirectories.length && additionalDirectories.every(
@@ -94519,7 +94509,7 @@ async function refreshAgentCatalog(config2, discover, signal) {
 
 // src/engine/runtime/catalog/handle-agent-catalog-discovery.ts
 var CATALOG_DISCOVERY_TIMEOUT_MILLISECONDS = 9e4;
-function discoveredEvent(command, agents) {
+function discoveredEvent(command2, agents) {
   return {
     agents: agents.map((agent2) => ({
       agentVersion: agent2.agentVersion,
@@ -94527,7 +94517,7 @@ function discoveredEvent(command, agents) {
       label: agent2.label
     })),
     kind: "agent.catalog.discovered",
-    requestId: command.requestId
+    requestId: command2.requestId
   };
 }
 function createAgentCatalogDiscoveryHandler(dependencies) {
@@ -94535,20 +94525,20 @@ function createAgentCatalogDiscoveryHandler(dependencies) {
   const requestIds = /* @__PURE__ */ new Set();
   let controller = null;
   let completion = null;
-  const handle = (command) => {
-    if (requestIds.has(command.requestId) || controller !== null) {
+  const handle = (command2) => {
+    if (requestIds.has(command2.requestId) || controller !== null) {
       if (socket.readyState === WebSocket3.OPEN) {
         send(socket, {
           code: "agent_catalog_discovery_busy",
           kind: AGENT_CATALOG_DISCOVERY_FAILED_KIND,
           message: "An Agent catalog discovery is already running",
-          requestId: command.requestId
+          requestId: command2.requestId
         });
       }
       return;
     }
     controller = new AbortController();
-    requestIds.add(command.requestId);
+    requestIds.add(command2.requestId);
     const operationSignal = AbortSignal.any([signal, controller.signal]);
     const timeout = timer.schedule(
       () => controller?.abort(new Error("Agent catalog discovery timed out")),
@@ -94562,7 +94552,7 @@ function createAgentCatalogDiscoveryHandler(dependencies) {
           send(
             socket,
             discoveredEvent(
-              command,
+              command2,
               published.agents.map((agent2) => ({
                 agentVersion: agent2.agentVersion,
                 id: agent2.id,
@@ -94574,7 +94564,7 @@ function createAgentCatalogDiscoveryHandler(dependencies) {
       } catch (error62) {
         diagnostics.daemonDiagnostic(
           "agent_catalog_discovery_failed",
-          command.requestId,
+          command2.requestId,
           { code: operationErrorCode(error62) },
           error62
         );
@@ -94583,12 +94573,12 @@ function createAgentCatalogDiscoveryHandler(dependencies) {
             code: operationErrorCode(error62),
             kind: AGENT_CATALOG_DISCOVERY_FAILED_KIND,
             message: operationErrorMessage(error62),
-            requestId: command.requestId
+            requestId: command2.requestId
           });
         }
       } finally {
         timeout.cancel();
-        requestIds.delete(command.requestId);
+        requestIds.delete(command2.requestId);
         controller = null;
         completion = null;
       }
@@ -94700,9 +94690,9 @@ function isUnavailableModel(cause, modelSettingId, requestedModel) {
 function unsupportedModelIds(unsupportedModels) {
   return [...new Set(unsupportedModels.map((item) => item.requestedValue))];
 }
-async function discoverAgentSettings(command, resolveAgent, bindingId, directories, sessions, signal) {
-  const { agent: agent2, adapter: harnessAdapter } = await resolveAgent(command.agentId, signal);
-  const directoryId = command.directoryId ?? "default";
+async function discoverAgentSettings(command2, resolveAgent, bindingId, directories, sessions, signal) {
+  const { agent: agent2, adapter: harnessAdapter } = await resolveAgent(command2.agentId, signal);
+  const directoryId = command2.directoryId ?? "default";
   const cwd = await directories.resolve(bindingId, directoryId, signal);
   const inspectedBaseSnapshot = await sessions.inspectAgentSettings({
     adapter: harnessAdapter,
@@ -94720,12 +94710,12 @@ async function discoverAgentSettings(command, resolveAgent, bindingId, directori
   const baseModel = modelOption(baseSnapshot.configOptions);
   const unsupportedModels = [];
   let selectedSnapshot = baseSnapshot;
-  if (command.model !== void 0) {
-    if (baseModel === void 0 || baseModel.type !== "select" || !baseModel.values.some((value) => value.value === command.model)) {
+  if (command2.model !== void 0) {
+    if (baseModel === void 0 || baseModel.type !== "select" || !baseModel.values.some((value) => value.value === command2.model)) {
       unsupportedModels.push(
         new AcpConfigurationValueUnavailableError(
           baseModel?.id ?? "model",
-          command.model,
+          command2.model,
           baseModel?.values.map((value) => value.value) ?? []
         )
       );
@@ -94736,12 +94726,12 @@ async function discoverAgentSettings(command, resolveAgent, bindingId, directori
           additionalDirectories: [],
           agent: agent2,
           cwd,
-          model: command.model,
+          model: command2.model,
           signal
         });
       } catch (cause) {
         signal.throwIfAborted();
-        if (!isUnavailableModel(cause, baseModel.id, command.model)) {
+        if (!isUnavailableModel(cause, baseModel.id, command2.model)) {
           throw cause;
         }
         unsupportedModels.push(cause);
@@ -94750,7 +94740,7 @@ async function discoverAgentSettings(command, resolveAgent, bindingId, directori
   }
   const adapter = agentSettingsAdapterForAgent(agent2.id);
   const modelEffort = await discoverModelEffort(
-    command,
+    command2,
     agent2,
     harnessAdapter,
     adapter.modelEffortResolution,
@@ -94774,13 +94764,13 @@ async function discoverAgentSettings(command, resolveAgent, bindingId, directori
   );
   return {
     event: {
-      agentId: command.agentId,
+      agentId: command2.agentId,
       agentName: selectedSnapshot.agentName,
       agentVersion: selectedSnapshot.agentVersion,
       directoryId,
       kind: AGENT_SETTINGS_DISCOVERED_KIND,
       modelEffort,
-      requestId: command.requestId,
+      requestId: command2.requestId,
       settings,
       settingsRevision: settingsRevision(agent2, baseSnapshot.agentVersion, baseSettings, modelEffort)
     },
@@ -94851,7 +94841,7 @@ function unavailableModelEffort() {
     valuesByModel: {}
   };
 }
-async function discoverModelEffort(command, agent2, harnessAdapter, resolution, initialOptions, selectedOptions, initiallyUnsupportedModels, discoveredModelEffort, cwd, sessions, signal) {
+async function discoverModelEffort(command2, agent2, harnessAdapter, resolution, initialOptions, selectedOptions, initiallyUnsupportedModels, discoveredModelEffort, cwd, sessions, signal) {
   const model = modelOption(initialOptions);
   const unsupportedModels = initiallyUnsupportedModels;
   if (resolution !== AGENT_MODEL_EFFORT_RESOLUTION_COMPLETE && resolution !== AGENT_MODEL_EFFORT_RESOLUTION_ON_MODEL_SELECTION) {
@@ -94903,11 +94893,11 @@ async function discoverModelEffort(command, agent2, harnessAdapter, resolution,
       valuesByModel
     };
   }
-  if (command.model !== void 0) {
-    const modelUnsupported = unsupportedModels.some((diagnostic) => diagnostic.requestedValue === command.model);
+  if (command2.model !== void 0) {
+    const modelUnsupported = unsupportedModels.some((diagnostic) => diagnostic.requestedValue === command2.model);
     const selectedEffort2 = effortOption(selectedOptions);
     if (!modelUnsupported) {
-      valuesByModel[command.model] = selectedEffort2?.type === "select" ? selectedEffort2.values : [];
+      valuesByModel[command2.model] = selectedEffort2?.type === "select" ? selectedEffort2.values : [];
     }
     return {
       effortSettingId: selectedEffort2?.id ?? "",
@@ -94966,24 +94956,24 @@ function settingsRevision(agent2, reportedAgentVersion, settings, modelEffort) {
 function createAgentSettingsDiscoveryHandler(dependencies) {
   const { config: config2, directories, sessions, diagnostics, socket, signal, timer } = dependencies;
   const agentSettingsDiscoveries = /* @__PURE__ */ new Map();
-  const handle = (command) => {
-    const directoryId = command.directoryId ?? "default";
+  const handle = (command2) => {
+    const directoryId = command2.directoryId ?? "default";
     const existing = [...agentSettingsDiscoveries.values()].find(
-      (request) => request.agentId === command.agentId && request.directoryId === directoryId && !request.controller.signal.aborted
+      (request) => request.agentId === command2.agentId && request.directoryId === directoryId && !request.controller.signal.aborted
     );
-    if ([...agentSettingsDiscoveries.values()].some((request) => request.requestIds.has(command.requestId))) {
+    if ([...agentSettingsDiscoveries.values()].some((request) => request.requestIds.has(command2.requestId))) {
       if (socket.readyState === WebSocket4.OPEN) {
         send(socket, {
           code: "agent_settings_discovery_busy",
           kind: AGENT_SETTINGS_DISCOVERY_FAILED_KIND,
           message: "This settings discovery request is already running",
-          requestId: command.requestId
+          requestId: command2.requestId
         });
       }
       return;
     }
-    if (existing !== void 0 && existing.model === command.model && existing.requestIds.size < 16) {
-      existing.requestIds.add(command.requestId);
+    if (existing !== void 0 && existing.model === command2.model && existing.requestIds.size < 16) {
+      existing.requestIds.add(command2.requestId);
       return;
     }
     if (existing !== void 0) {
@@ -94992,7 +94982,7 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
           code: "agent_settings_discovery_busy",
           kind: AGENT_SETTINGS_DISCOVERY_FAILED_KIND,
           message: "Another settings discovery is already running for this Agent",
-          requestId: command.requestId
+          requestId: command2.requestId
         });
       }
       return;
@@ -95003,13 +94993,13 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
           code: "agent_settings_discovery_busy",
           kind: AGENT_SETTINGS_DISCOVERY_FAILED_KIND,
           message: "Too many Agent settings discoveries are running",
-          requestId: command.requestId
+          requestId: command2.requestId
         });
       }
       return;
     }
     const controller = new AbortController();
-    const requestIds = /* @__PURE__ */ new Set([command.requestId]);
+    const requestIds = /* @__PURE__ */ new Set([command2.requestId]);
     const operationSignal = AbortSignal.any([signal, controller.signal]);
     const timeout = timer.schedule(
       () => controller.abort(
@@ -95020,7 +95010,7 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
     const completion = (async () => {
       try {
         const result = await discoverAgentSettings(
-          command,
+          command2,
           dependencies.resolveAgent,
           config2.bindingId,
           directories,
@@ -95028,10 +95018,10 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
           operationSignal
         );
         for (const diagnostic of result.unsupportedModels) {
-          const details = agentSettingsFailureDetails(command.agentId, diagnostic);
-          diagnostics.daemonDiagnostic("agent_settings_model_unsupported", command.requestId, details);
+          const details = agentSettingsFailureDetails(command2.agentId, diagnostic);
+          diagnostics.daemonDiagnostic("agent_settings_model_unsupported", command2.requestId, details);
           process.stderr.write(
-            `Morty daemon diagnostic ${JSON.stringify({ event: "agent_settings_model_unsupported", requestId: command.requestId, ...details })}
+            `Morty daemon diagnostic ${JSON.stringify({ event: "agent_settings_model_unsupported", requestId: command2.requestId, ...details })}
 `
           );
         }
@@ -95042,11 +95032,11 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
         }
       } catch (error62) {
         const failure2 = operationSignal.aborted ? controller.signal.reason ?? new SessionError("agent_settings_discovery_cancelled", "Agent settings discovery cancelled") : error62;
-        const details = agentSettingsFailureDetails(command.agentId, failure2);
-        diagnostics.daemonDiagnostic("agent_settings_discovery_failed", command.requestId, details, failure2);
+        const details = agentSettingsFailureDetails(command2.agentId, failure2);
+        diagnostics.daemonDiagnostic("agent_settings_discovery_failed", command2.requestId, details, failure2);
         if (failure2 instanceof OperationError && failure2.code === "invalid_session_configuration") {
           process.stderr.write(
-            `Morty daemon diagnostic ${JSON.stringify({ event: "agent_settings_discovery_failed", requestId: command.requestId, ...details })}
+            `Morty daemon diagnostic ${JSON.stringify({ event: "agent_settings_discovery_failed", requestId: command2.requestId, ...details })}
 `
           );
         }
@@ -95062,13 +95052,13 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
         }
       } finally {
         timeout.cancel();
-        agentSettingsDiscoveries.delete(command.requestId);
+        agentSettingsDiscoveries.delete(command2.requestId);
       }
     })();
-    agentSettingsDiscoveries.set(command.requestId, {
-      agentId: command.agentId,
+    agentSettingsDiscoveries.set(command2.requestId, {
+      agentId: command2.agentId,
       directoryId,
-      model: command.model,
+      model: command2.model,
       requestIds,
       completion,
       controller
@@ -95112,14 +95102,14 @@ import { createHash as createHash11 } from "node:crypto";
 function createContentWriteCommands(context) {
   const pending = /* @__PURE__ */ new Map();
   const operations = /* @__PURE__ */ new Set();
-  const fail = (command, error62) => {
-    pending.delete(command.requestId);
+  const fail = (command2, error62) => {
+    pending.delete(command2.requestId);
     send(context.socket, {
       code: "content_write_failed",
       kind: FILE_FAILED_KIND,
       message: error62 instanceof Error ? error62.message : "The content could not be stored",
-      requestId: command.requestId,
-      sessionId: command.sessionId
+      requestId: command2.requestId,
+      sessionId: command2.sessionId
     });
   };
   const write = {
@@ -95273,15 +95263,15 @@ async function resolveFile(value, workingDirectory, signal) {
   }
   return null;
 }
-async function streamLocalFile(command, send2, sendChunk, signal, workingDirectory, externalContent) {
-  const external = await externalContent.resolve(command.sessionId, command.path, signal);
-  const target = external?.path ?? await resolveFile(command.path, workingDirectory, signal);
+async function streamLocalFile(command2, send2, sendChunk, signal, workingDirectory, externalContent) {
+  const external = await externalContent.resolve(command2.sessionId, command2.path, signal);
+  const target = external?.path ?? await resolveFile(command2.path, workingDirectory, signal);
   if (target === null) {
     throw new Error("The local file is unavailable");
   }
   const before = await readPathMetadata(target);
   signal.throwIfAborted();
-  if (before.kind !== "file" || before.size < 1 || before.size > command.maxBytes) {
+  if (before.kind !== "file" || before.size < 1 || before.size > command2.maxBytes) {
     throw new Error("The local file is too large to read");
   }
   const raster = external === null ? await readLocalRaster(target, signal) : null;
@@ -95291,12 +95281,12 @@ async function streamLocalFile(command, send2, sendChunk, signal, workingDirecto
     mediaType: external?.mediaType ?? raster?.mimeType ?? (extname3(target).toLowerCase() === ".svg" ? "image/svg+xml" : "application/octet-stream"),
     modifiedAt: before.modifiedAt.toISOString(),
     name: external?.name ?? (basename8(target) || "file"),
-    requestId: command.requestId,
-    sessionId: command.sessionId
+    requestId: command2.requestId,
+    sessionId: command2.sessionId
   });
   let sequence = 0;
   for await (const bytes of readFileChunks(target, CONTENT_CHUNK_MAX_BYTES, signal)) {
-    sendChunk(command.requestId, sequence, bytes);
+    sendChunk(command2.requestId, sequence, bytes);
     sequence += 1;
   }
   const after = await readPathMetadata(target);
@@ -95306,8 +95296,8 @@ async function streamLocalFile(command, send2, sendChunk, signal, workingDirecto
   }
   send2({
     kind: FILE_END_KIND,
-    requestId: command.requestId,
-    sessionId: command.sessionId
+    requestId: command2.requestId,
+    sessionId: command2.sessionId
   });
 }
 
@@ -95436,10 +95426,10 @@ async function loadHistoryPage(sessionId, eventLimit, initialCursor, queuedPromp
     queuedPromptRequests
   };
 }
-async function executeSessionHistoryPageLoad(socket, command, config2, resolveAgent, directories, diagnostics, sessions, nativeSessions, eventProjection, signal) {
+async function executeSessionHistoryPageLoad(socket, command2, config2, resolveAgent, directories, diagnostics, sessions, nativeSessions, eventProjection, signal) {
   let agentId;
   try {
-    const [entry] = await nativeSessions.querySessions([command.sessionId], signal);
+    const [entry] = await nativeSessions.querySessions([command2.sessionId], signal);
     if (entry === void 0) {
       throw new SessionError("session_not_found", "The Session was not found");
     }
@@ -95453,17 +95443,17 @@ async function executeSessionHistoryPageLoad(socket, command, config2, resolveAg
     );
     const loadOptions = {
       additionalDirectories: resolved.additionalDirectories,
-      ...await resolveAgent(entry.agentId, signal, command.sessionId),
+      ...await resolveAgent(entry.agentId, signal, command2.sessionId),
       cwd: resolved.cwd,
-      sessionId: command.sessionId,
+      sessionId: command2.sessionId,
       signal
     };
-    const recovery = eventProjection.promptRequestRecovery(command.sessionId);
-    const settled = eventProjection.promptOutcomes(command.sessionId);
+    const recovery = eventProjection.promptRequestRecovery(command2.sessionId);
+    const settled = eventProjection.promptOutcomes(command2.sessionId);
     const events = await loadHistoryPage(
-      command.sessionId,
-      command.eventLimit,
-      command.cursor,
+      command2.sessionId,
+      command2.eventLimit,
+      command2.cursor,
       recovery.queuedPromptRequests,
       async (eventLimit, cursor) => await sessions.loadSessionEvents(loadOptions, eventLimit, cursor)
     );
@@ -95477,68 +95467,68 @@ async function executeSessionHistoryPageLoad(socket, command, config2, resolveAg
         }
       },
       kind: SESSION_HISTORY_PAGE_LOADED_KIND,
-      requestId: command.requestId,
-      sessionId: command.sessionId
+      requestId: command2.requestId,
+      sessionId: command2.sessionId
     });
   } catch (error62) {
     if (!signal.aborted) {
       diagnostics.daemonDiagnostic(
         "session_history_v2_load_failed",
-        command.requestId,
+        command2.requestId,
         {
           ...agentId === void 0 ? {} : { agentId },
           code: operationErrorCode(error62),
-          sessionId: command.sessionId
+          sessionId: command2.sessionId
         },
         error62
       );
-      reportOperationFailure(socket, command.requestId, command.sessionId, error62);
+      reportOperationFailure(socket, command2.requestId, command2.sessionId, error62);
     }
   }
 }
-async function executeSessionPreviewHistoryPageLoad(socket, command, config2, resolveAgent, directories, diagnostics, nativeSessions, signal) {
+async function executeSessionPreviewHistoryPageLoad(socket, command2, config2, resolveAgent, directories, diagnostics, nativeSessions, signal) {
   try {
     const resolved = await resolveSessionDirectories(
       directories,
       config2.bindingId,
-      command.directoryId,
-      command.additionalDirectoryIds,
+      command2.directoryId,
+      command2.additionalDirectoryIds,
       signal
     );
     const loadOptions = {
       additionalDirectories: resolved.additionalDirectories,
-      ...await resolveAgent(command.agentId, signal, command.sessionId),
+      ...await resolveAgent(command2.agentId, signal, command2.sessionId),
       cwd: resolved.cwd,
-      sessionId: command.sessionId,
+      sessionId: command2.sessionId,
       signal
     };
     const events = await loadHistoryPage(
-      command.sessionId,
-      command.eventLimit,
-      command.cursor,
+      command2.sessionId,
+      command2.eventLimit,
+      command2.cursor,
       [],
-      async (eventLimit, cursor) => await nativeSessions.readSessionHistory(loadOptions, command.sessionId, eventLimit, cursor)
+      async (eventLimit, cursor) => await nativeSessions.readSessionHistory(loadOptions, command2.sessionId, eventLimit, cursor)
     );
     signal.throwIfAborted();
     send(socket, {
       events,
       kind: SESSION_PREVIEW_HISTORY_PAGE_LOADED_KIND,
-      requestId: command.requestId,
-      sessionId: command.sessionId
+      requestId: command2.requestId,
+      sessionId: command2.sessionId
     });
   } catch (error62) {
     if (!signal.aborted) {
       diagnostics.daemonDiagnostic(
         "session_history_v2_load_failed",
-        command.requestId,
+        command2.requestId,
         {
-          agentId: command.agentId,
+          agentId: command2.agentId,
           code: operationErrorCode(error62),
-          sessionId: command.sessionId
+          sessionId: command2.sessionId
         },
         error62
       );
-      reportOperationFailure(socket, command.requestId, command.sessionId, error62);
+      reportOperationFailure(socket, command2.requestId, command2.sessionId, error62);
     }
   }
 }
@@ -95706,21 +95696,21 @@ import { WebSocket as WebSocket6 } from "undici";
 function createNativeSessionRequestHandler(dependencies) {
   const { diagnostics, nativeSessions, signal, socket, timer } = dependencies;
   const pending = /* @__PURE__ */ new Map();
-  const cancel = (command) => {
-    const request = pending.get(command.requestId);
-    if (request?.sessionId === command.sessionId) {
+  const cancel = (command2) => {
+    const request = pending.get(command2.requestId);
+    if (request?.sessionId === command2.sessionId) {
       request.controller.abort(
         new SessionError("native_session_cancelled", "Native session operation cancelled")
       );
     }
   };
-  const handle = (command) => {
-    const previous = [...pending.values()].filter((request) => request.agentId === command.agentId);
-    if (pending.has(command.requestId) || pending.size >= 4) {
+  const handle = (command2) => {
+    const previous = [...pending.values()].filter((request) => request.agentId === command2.agentId);
+    if (pending.has(command2.requestId) || pending.size >= 4) {
       reportOperationFailure(
         socket,
-        command.requestId,
-        command.sessionId,
+        command2.requestId,
+        command2.sessionId,
         new SessionError("native_session_busy", "Another native session operation is running")
       );
       return;
@@ -95734,7 +95724,7 @@ function createNativeSessionRequestHandler(dependencies) {
     const completion = (async () => {
       try {
         operationSignal.throwIfAborted();
-        const skipPrevious = command.action === "active-turn";
+        const skipPrevious = command2.action === "active-turn";
         if (previous.length > 0 && !skipPrevious) {
           await new Promise((resolve19, reject2) => {
             const onAbort = () => reject2(operationSignal.reason);
@@ -95752,7 +95742,7 @@ function createNativeSessionRequestHandler(dependencies) {
           });
         }
         operationSignal.throwIfAborted();
-        const result = await nativeSessions.execute(command, operationSignal);
+        const result = await nativeSessions.execute(command2, operationSignal);
         if (socket.readyState === WebSocket6.OPEN) {
           send(socket, result);
         }
@@ -95761,24 +95751,24 @@ function createNativeSessionRequestHandler(dependencies) {
         const event = "native_session_operation_failed";
         diagnostics.daemonDiagnostic(
           event,
-          command.requestId,
+          command2.requestId,
           {
-            action: command.action,
-            agentId: command.agentId,
+            action: command2.action,
+            agentId: command2.agentId,
             code: operationErrorCode(failure2),
-            sessionId: command.sessionId
+            sessionId: command2.sessionId
           },
           failure2
         );
-        reportOperationFailure(socket, command.requestId, command.sessionId, failure2);
+        reportOperationFailure(socket, command2.requestId, command2.sessionId, failure2);
       } finally {
         timeout.cancel();
-        pending.delete(command.requestId);
+        pending.delete(command2.requestId);
       }
     })();
-    pending.set(command.requestId, {
-      agentId: command.agentId,
-      sessionId: command.sessionId,
+    pending.set(command2.requestId, {
+      agentId: command2.agentId,
+      sessionId: command2.sessionId,
       controller,
       completion
     });
@@ -96013,7 +96003,7 @@ function warnIgnoredSetting(event, commandId, sessionId, agentId, selection, cat
 // src/engine/session/prompt/execute-prompt.ts
 async function executePrompt({
   eventProjection,
-  command,
+  command: command2,
   resolveAgent,
   readArtifact,
   reportFailure,
@@ -96021,53 +96011,43 @@ async function executePrompt({
   sessions,
   attemptId,
   epoch,
-  waitForSessionAvailability,
+  waitForSessionAdmission,
   signal,
   cancellationRequested
 }) {
   try {
     const resolved = await resolveSessionDirectories(
       directories,
-      command.bindingId,
-      command.directoryId,
-      command.additionalDirectoryIds,
+      command2.bindingId,
+      command2.directoryId,
+      command2.additionalDirectoryIds,
       signal
     );
     const { agent: agent2, adapter, externalizeSessionUpdate } = await resolveAgent(
-      command.agentId,
+      command2.agentId,
       signal,
-      command.sessionId
+      command2.sessionId
     );
-    const availability = await waitForSessionAvailability(signal);
-    if (availability.kind === "busy") {
-      throw new AcpExecutionError("Another prompt is already running in this conversation", {}, "session_busy");
-    }
-    if (availability.kind === "queue-target-unavailable") {
-      throw new AcpExecutionError(
-        "The queued prompt target is unavailable",
-        {},
-        "prompt_queue_target_unavailable"
-      );
-    }
-    if (availability.disposition === SessionPromptDisposition.Steer && !sessions.acceptsSteering(command.sessionId, command.targetCommandId)) {
-      throw new AcpExecutionError("The steering target is unavailable", {}, "prompt_queue_target_unavailable");
+    const dispatch = await waitForSessionAdmission(signal);
+    if (dispatch.kind === "steer" && !sessions.acceptsSteering(command2.sessionId, dispatch.targetCommandId)) {
+      throw new AcpExecutionError("The steering target is unavailable", {}, "steering_target_unavailable");
     }
-    const appliedSettings = command.sessionConfigurations === void 0 ? void 0 : agentForSessionConfiguration(agent2, command.sessionConfigurations);
+    const appliedSettings = command2.sessionConfigurations === void 0 ? void 0 : agentForSessionConfiguration(agent2, command2.sessionConfigurations);
     const executionAgent = appliedSettings?.agent ?? agent2;
     const sessionConfigurations = appliedSettings?.sessionConfigurations;
-    const recovery = command.historyPolicy === SessionHistoryPolicy.ExecutionOnly ? { kind: "execution-only" } : { kind: "interactive-only" };
+    const recovery = command2.historyPolicy === SessionHistoryPolicy.ExecutionOnly ? { kind: "execution-only" } : { kind: "interactive-only" };
     const preparation = {
       adapter,
       ...externalizeSessionUpdate === void 0 ? {} : { externalizeSessionUpdate },
       additionalDirectories: resolved.additionalDirectories,
       agent: executionAgent,
       cwd: resolved.cwd,
-      sessionId: command.sessionId,
+      sessionId: command2.sessionId,
       signal,
       recovery
     };
     let prepared = await sessions.prepareExecutionSession(preparation);
-    if (command.sessionConfigurations !== void 0 && availability.disposition !== SessionPromptDisposition.Steer) {
+    if (command2.sessionConfigurations !== void 0 && dispatch.kind !== "steer") {
       await applyCompleteSessionConfiguration(
         sessions,
         prepared.configOptions,
@@ -96076,44 +96056,38 @@ async function executePrompt({
         adapter,
         resolved.cwd,
         resolved.additionalDirectories,
-        command.commandId,
-        command.sessionId,
+        command2.commandId,
+        command2.sessionId,
         signal
       );
       prepared = await sessions.prepareExecutionSession(preparation);
     }
     signal.throwIfAborted();
-    const lifecycle = eventProjection.lifecycle(
-      command.sessionId,
-      command.commandId,
-      attemptId,
-      epoch,
-      availability.disposition
-    );
-    const attachments = await resolvePromptArtifacts(readArtifact, command.attachments, signal);
-    const skipped = command.attachments.length - attachments.images.length - attachments.resources.length;
+    const lifecycle = eventProjection.lifecycle(command2.sessionId, command2.commandId, attemptId, epoch, dispatch);
+    const attachments = await resolvePromptArtifacts(readArtifact, command2.attachments, signal);
+    const skipped = command2.attachments.length - attachments.images.length - attachments.resources.length;
     if (skipped > 0) {
-      reportFailure("prompt_attachments_skipped", command.commandId, { count: skipped.toString() });
+      reportFailure("prompt_attachments_skipped", command2.commandId, { count: skipped.toString() });
     }
-    if (command.prompt.trim().length === 0 && attachments.images.length === 0 && attachments.resources.length === 0) {
+    if (command2.prompt.trim().length === 0 && attachments.images.length === 0 && attachments.resources.length === 0) {
       throw new PromptArtifactError("prompt_attachments_unsupported", "No supported prompt content remains");
     }
     let stopReason;
-    if (availability.disposition === SessionPromptDisposition.Steer) {
+    if (dispatch.kind === "steer") {
       await sessions.steerPrompt({
         adapter,
         ...externalizeSessionUpdate === void 0 ? {} : { externalizeSessionUpdate },
         additionalDirectories: resolved.additionalDirectories,
         agent: executionAgent,
-        commandId: command.commandId,
+        commandId: command2.commandId,
         cwd: resolved.cwd,
         images: attachments.images,
         lifecycle,
-        prompt: command.prompt,
+        prompt: command2.prompt,
         resources: attachments.resources,
-        sessionId: command.sessionId,
+        sessionId: command2.sessionId,
         signal,
-        targetCommandId: command.targetCommandId
+        targetCommandId: dispatch.targetCommandId
       });
       stopReason = "steered";
     } else {
@@ -96123,35 +96097,33 @@ async function executePrompt({
         ...externalizeSessionUpdate === void 0 ? {} : { externalizeSessionUpdate },
         additionalDirectories: resolved.additionalDirectories,
         agent: executionAgent,
-        commandId: command.commandId,
+        commandId: command2.commandId,
         cwd: resolved.cwd,
-        disposition: availability.disposition,
         images: attachments.images,
         lifecycle,
-        prompt: command.prompt,
+        prompt: command2.prompt,
         resources: attachments.resources,
-        sessionId: command.sessionId,
+        sessionId: command2.sessionId,
         signal,
-        targetCommandId: command.targetCommandId,
         recovery
       });
       stopReason = result.stopReason;
     }
-    await eventProjection.completed(command.sessionId, command.commandId, stopReason);
+    await eventProjection.completed(command2.sessionId, command2.commandId, stopReason);
   } catch (error62) {
     if (signal.aborted && cancellationRequested()) {
-      await eventProjection.completed(command.sessionId, command.commandId, "cancelled");
+      await eventProjection.completed(command2.sessionId, command2.commandId, "cancelled");
       return;
     }
     const code = operationErrorCode(error62);
     const failureCode = code === "session_operation_failed" ? "agent_execution_failed" : code;
     const failureMessage = code === "session_operation_failed" ? "The local agent could not complete the request" : operationErrorMessage(error62);
-    await eventProjection.failed(command.sessionId, command.commandId, attemptId, failureCode, failureMessage);
-    reportFailure("session_prompt_failed", command.commandId, {
-      agentId: command.agentId,
+    await eventProjection.failed(command2.sessionId, command2.commandId, attemptId, failureCode, failureMessage);
+    reportFailure("session_prompt_failed", command2.commandId, {
+      agentId: command2.agentId,
       code: failureCode,
-      commandId: command.commandId,
-      sessionId: command.sessionId
+      commandId: command2.commandId,
+      sessionId: command2.sessionId
     });
     console.error("Morty daemon command failed", error62);
   }
@@ -96177,8 +96149,19 @@ var sessionPromptCommand = {
     const receipt = context.operations.claimExecution(
       message.commandId,
       message.sessionId,
-      encodeSessionPromptCommand(message)
+      encodeSessionPromptCommand(message),
+      () => message.disposition === SessionPromptDisposition.Append || context.sessions.acceptsSteering(message.sessionId, message.targetCommandId)
     );
+    if (receipt.kind === "refused") {
+      send(context.socket, {
+        code: "steering_target_unavailable",
+        requestId: message.commandId,
+        kind: "session.operation.failed",
+        message: "The turn to steer is not running.",
+        sessionId: message.sessionId
+      });
+      return;
+    }
     if (receipt.kind === "conflict") {
       send(context.socket, {
         code: "command_identity_conflict",
@@ -96239,7 +96222,7 @@ var sessionPromptCommand = {
       sessions: context.sessions,
       attemptId: receipt.attemptId,
       epoch: turn.epoch,
-      waitForSessionAvailability: (signal) => context.sessionTurns.admitAndWait(turn, signal, () => {
+      waitForSessionAdmission: (signal) => context.sessionTurns.admitAndWait(turn, signal, () => {
         queueChanged();
       }),
       signal: turn.signal,
@@ -96361,83 +96344,83 @@ var runtimePingCommand = {
 };
 
 // src/engine/runtime/command/registry/session.ts
-async function prepareSession(command, recovery, closed, config2, resolveAgent, directories, sessions, metrics, signal) {
+async function prepareSession(command2, recovery, closed, config2, resolveAgent, directories, sessions, metrics, signal) {
   return await metrics.measure("prepare-total", async () => {
     const resolved = await metrics.measure(
       "workspace-resolve",
       async () => await resolveSessionDirectories(
         directories,
         config2.bindingId,
-        command.directoryId,
-        command.additionalDirectoryIds,
+        command2.directoryId,
+        command2.additionalDirectoryIds,
         signal
       )
     );
-    const resolvedAgent = await resolveAgent(command.agentId, signal, command.sessionId);
+    const resolvedAgent = await resolveAgent(command2.agentId, signal, command2.sessionId);
     const preparation = {
       additionalDirectories: resolved.additionalDirectories,
       ...resolvedAgent,
       cwd: resolved.cwd,
-      sessionId: command.sessionId,
+      sessionId: command2.sessionId,
       signal
     };
-    const prepared = command.transient === true ? await sessions.inspectSession(preparation, metrics) : recovery.kind === "history-required" ? await sessions.restoreSession(preparation, metrics, closed) : await sessions.prepareSession(preparation, metrics, closed);
-    const configuration = command.configuration;
+    const prepared = command2.transient === true ? await sessions.inspectSession(preparation, metrics) : recovery.kind === "history-required" ? await sessions.restoreSession(preparation, metrics, closed) : await sessions.prepareSession(preparation, metrics, closed);
+    const configuration = command2.configuration;
     const snapshot = configuration === void 0 ? prepared : await metrics.measure(
       "configuration",
       async () => await sessions.applySessionConfiguration({
         ...preparation,
         booleanValue: configuration.booleanValue,
         configId: configuration.configId,
-        requestId: command.requestId,
+        requestId: command2.requestId,
         value: configuration.value,
         valueType: configuration.valueType
       })
     );
     return {
       additionalDirectories: resolved.additionalDirectoryEntries,
-      agentId: command.agentId,
+      agentId: command2.agentId,
       agentName: prepared.agentName,
       agentVersion: prepared.agentVersion,
       capabilities: prepared.capabilities,
       commands: prepared.commands,
       configOptions: snapshot.configOptions,
       configurationRevision: snapshot.configurationRevision,
-      directoryId: command.directoryId,
+      directoryId: command2.directoryId,
       directoryLabel: resolved.directoryLabel,
       kind: "session.ready",
-      requestId: command.requestId,
+      requestId: command2.requestId,
       restored: prepared.restored,
-      sessionId: command.sessionId
+      sessionId: command2.sessionId
     };
   });
 }
-async function executeWorkspaceList(socket, command, directories, signal) {
+async function executeWorkspaceList(socket, command2, directories, signal) {
   try {
-    const listing = command.view === "metadata" ? await directories.describe(command.bindingId, command.directoryId, signal).then((directory) => ({
-      directoryId: command.directoryId,
+    const listing = command2.view === "metadata" ? await directories.describe(command2.bindingId, command2.directoryId, signal).then((directory) => ({
+      directoryId: command2.directoryId,
       directoryLabel: directory.label,
       entries: [],
       parentDirectoryId: directory.parentDirectoryId
-    })) : await directories.list(command.bindingId, command.directoryId, signal);
+    })) : await directories.list(command2.bindingId, command2.directoryId, signal);
     send(socket, {
-      bindingId: command.bindingId,
+      bindingId: command2.bindingId,
       directoryId: listing.directoryId,
       directoryLabel: listing.directoryLabel,
       entries: listing.entries,
       kind: "workspace.entries",
       parentDirectoryId: listing.parentDirectoryId,
-      requestId: command.requestId
+      requestId: command2.requestId
     });
   } catch (error62) {
-    reportOperationFailure(socket, command.requestId, "", error62);
+    reportOperationFailure(socket, command2.requestId, "", error62);
   }
 }
-async function executeSessionPrepare(socket, command, config2, resolveAgent, directories, sessions, diagnostics, signal) {
+async function executeSessionPrepare(socket, command2, config2, resolveAgent, directories, sessions, diagnostics, signal) {
   const metrics = new AccumulatingOperationMetrics();
   try {
     const readyEvent = await prepareSession(
-      command,
+      command2,
       { kind: "interactive-only" },
       "reopen",
       config2,
@@ -96454,22 +96437,22 @@ async function executeSessionPrepare(socket, command, config2, resolveAgent, dir
   } catch (error62) {
     diagnostics.daemonDiagnostic(
       "session_prepare_failed",
-      command.requestId,
+      command2.requestId,
       {
-        agentId: command.agentId,
+        agentId: command2.agentId,
         code: operationErrorCode(error62),
-        sessionId: command.sessionId
+        sessionId: command2.sessionId
       },
       error62
     );
-    reportOperationFailure(socket, command.requestId, command.sessionId, error62, metrics.snapshot());
+    reportOperationFailure(socket, command2.requestId, command2.sessionId, error62, metrics.snapshot());
   }
 }
-async function executeSessionRestore(socket, command, config2, resolveAgent, directories, sessions, nativeSessions, diagnostics, signal) {
+async function executeSessionRestore(socket, command2, config2, resolveAgent, directories, sessions, nativeSessions, diagnostics, signal) {
   const metrics = new AccumulatingOperationMetrics();
   try {
     const entry = await metrics.measure("session-lookup", async () => {
-      const [found] = await nativeSessions.querySessions([command.sessionId], signal);
+      const [found] = await nativeSessions.querySessions([command2.sessionId], signal);
       if (found === void 0) {
         throw new SessionError("session_not_found", "The Session was not found");
       }
@@ -96482,8 +96465,8 @@ async function executeSessionRestore(socket, command, config2, resolveAgent, dir
         bindingId: config2.bindingId,
         directoryId: entry.directoryId,
         kind: "session.prepare",
-        requestId: command.requestId,
-        sessionId: command.sessionId,
+        requestId: command2.requestId,
+        sessionId: command2.sessionId,
         sessionState: "provisioned"
       },
       { kind: "history-required" },
@@ -96499,24 +96482,24 @@ async function executeSessionRestore(socket, command, config2, resolveAgent, dir
       entry,
       kind: "session.restored",
       ready: { ...ready, runtimeTimings: metrics.snapshot() },
-      requestId: command.requestId
+      requestId: command2.requestId
     });
   } catch (error62) {
     diagnostics.daemonDiagnostic(
       "session_restore_failed",
-      command.requestId,
+      command2.requestId,
       {
         code: operationErrorCode(error62),
-        sessionId: command.sessionId
+        sessionId: command2.sessionId
       },
       error62
     );
-    reportOperationFailure(socket, command.requestId, command.sessionId, error62, metrics.snapshot());
+    reportOperationFailure(socket, command2.requestId, command2.sessionId, error62, metrics.snapshot());
   }
 }
-async function executeSessionRename(socket, command, config2, resolveAgent, directories, sessions, nativeSessions, signal) {
+async function executeSessionRename(socket, command2, config2, resolveAgent, directories, sessions, nativeSessions, signal) {
   try {
-    const [entry] = await nativeSessions.querySessions([command.sessionId], signal);
+    const [entry] = await nativeSessions.querySessions([command2.sessionId], signal);
     if (entry === void 0) {
       throw new SessionError("session_not_found", "The Session was not found");
     }
@@ -96530,17 +96513,17 @@ async function executeSessionRename(socket, command, config2, resolveAgent, dire
     const renamed = await sessions.renameSession(
       {
         additionalDirectories: resolved.additionalDirectories,
-        ...await resolveAgent(entry.agentId, signal, command.sessionId),
+        ...await resolveAgent(entry.agentId, signal, command2.sessionId),
         cwd: resolved.cwd,
-        sessionId: command.sessionId,
+        sessionId: command2.sessionId,
         signal
       },
-      command.title
+      command2.title
     );
     send(socket, {
       kind: "session.renamed",
-      requestId: command.requestId,
-      sessionId: command.sessionId,
+      requestId: command2.requestId,
+      sessionId: command2.sessionId,
       title: renamed.title,
       updatedAt: renamed.updatedAt
     });
@@ -96548,42 +96531,42 @@ async function executeSessionRename(socket, command, config2, resolveAgent, dire
     if (signal.aborted) {
       signal.throwIfAborted();
     }
-    reportOperationFailure(socket, command.requestId, command.sessionId, error62);
+    reportOperationFailure(socket, command2.requestId, command2.sessionId, error62);
   }
 }
-async function executeSessionConfigure(socket, command, config2, resolveAgent, directories, sessions, signal) {
+async function executeSessionConfigure(socket, command2, config2, resolveAgent, directories, sessions, signal) {
   try {
     const resolved = await resolveSessionDirectories(
       directories,
       config2.bindingId,
-      command.directoryId,
-      command.additionalDirectoryIds,
+      command2.directoryId,
+      command2.additionalDirectoryIds,
       signal
     );
     const snapshot = await sessions.configureSession({
       additionalDirectories: resolved.additionalDirectories,
-      ...await resolveAgent(command.agentId, signal, command.sessionId),
-      booleanValue: command.booleanValue,
-      configId: command.configId,
-      expectedConfigurationRevision: command.expectedConfigurationRevision,
+      ...await resolveAgent(command2.agentId, signal, command2.sessionId),
+      booleanValue: command2.booleanValue,
+      configId: command2.configId,
+      expectedConfigurationRevision: command2.expectedConfigurationRevision,
       cwd: resolved.cwd,
-      requestId: command.requestId,
-      sessionId: command.sessionId,
+      requestId: command2.requestId,
+      sessionId: command2.sessionId,
       signal,
-      value: command.value,
-      valueType: command.valueType
+      value: command2.value,
+      valueType: command2.valueType
     });
     send(socket, {
       ...snapshot,
       kind: "session.config.updated",
-      requestId: command.requestId,
-      sessionId: command.sessionId
+      requestId: command2.requestId,
+      sessionId: command2.sessionId
     });
   } catch (error62) {
     if (signal.aborted) {
       signal.throwIfAborted();
     }
-    reportOperationFailure(socket, command.requestId, command.sessionId, error62);
+    reportOperationFailure(socket, command2.requestId, command2.sessionId, error62);
   }
 }
 var workspaceListCommand = {
@@ -96667,11 +96650,11 @@ var sessionRenameCommand = {
     );
   }
 };
-async function executeSessionConfigRead(socket, command, config2, resolveAgent, directories, sessions, nativeSessions, diagnostics, signal) {
+async function executeSessionConfigRead(socket, command2, config2, resolveAgent, directories, sessions, nativeSessions, diagnostics, signal) {
   const metrics = new AccumulatingOperationMetrics();
   try {
     const entry = await metrics.measure("session-lookup", async () => {
-      const [found] = await nativeSessions.querySessions([command.sessionId], signal);
+      const [found] = await nativeSessions.querySessions([command2.sessionId], signal);
       if (found === void 0) {
         throw new SessionError("session_not_found", "The Session was not found");
       }
@@ -96684,8 +96667,8 @@ async function executeSessionConfigRead(socket, command, config2, resolveAgent,
         bindingId: config2.bindingId,
         directoryId: entry.directoryId,
         kind: "session.prepare",
-        requestId: command.requestId,
-        sessionId: command.sessionId,
+        requestId: command2.requestId,
+        sessionId: command2.sessionId,
         sessionState: "provisioned"
       },
       // A settings read must not force history loading: Agents without
@@ -96705,20 +96688,20 @@ async function executeSessionConfigRead(socket, command, config2, resolveAgent,
       configOptions: ready.configOptions,
       configurationRevision: ready.configurationRevision,
       kind: SESSION_CONFIG_READ_RESULT_KIND,
-      requestId: command.requestId,
-      sessionId: command.sessionId
+      requestId: command2.requestId,
+      sessionId: command2.sessionId
     });
   } catch (error62) {
     diagnostics.daemonDiagnostic(
       "session_config_read_failed",
-      command.requestId,
+      command2.requestId,
       {
         code: operationErrorCode(error62),
-        sessionId: command.sessionId
+        sessionId: command2.sessionId
       },
       error62
     );
-    reportOperationFailure(socket, command.requestId, command.sessionId, error62, metrics.snapshot());
+    reportOperationFailure(socket, command2.requestId, command2.sessionId, error62, metrics.snapshot());
   }
 }
 var sessionConfigReadCommand = {
@@ -96770,11 +96753,11 @@ function createCommandRegistry(context) {
   ];
   return {
     dispatch: (message) => {
-      const command = commands.find((candidate) => candidate.kind === message.kind);
-      if (command === void 0) {
+      const command2 = commands.find((candidate) => candidate.kind === message.kind);
+      if (command2 === void 0) {
         throw new Error("Unsupported protocol message");
       }
-      command.handle(context, message);
+      command2.handle(context, message);
     },
     dispatchChunk: (message) => {
       const frame = (() => {
@@ -96794,7 +96777,7 @@ function createCommandRegistry(context) {
     settle: async () => {
       await Promise.all([
         contentWrites.settle(),
-        ...commands.flatMap((command) => command.settle === void 0 ? [] : [command.settle()])
+        ...commands.flatMap((command2) => command2.settle === void 0 ? [] : [command2.settle()])
       ]);
     }
   };
@@ -97777,8 +97760,8 @@ var RuntimeLoop = class {
       await runRuntime(config2, signal, void 0, {
         ...this.#options.turnActivity === void 0 ? {} : { turnActivity: this.#options.turnActivity },
         ...this.#options.agentProcesses === void 0 ? {} : { agentProcesses: this.#options.agentProcesses },
-        onExecutionCountChange: (count) => {
-          this.#options.onExecutionCountChange?.(count);
+        onExecutionCountChange: (count2) => {
+          this.#options.onExecutionCountChange?.(count2);
         },
         ...this.#options.onConnectionStatus === void 0 ? {} : { onConnectionStatus: this.#options.onConnectionStatus },
         ...this.#options.reportUpgradeAvailability === void 0 ? {} : { reportUpgradeAvailability: this.#options.reportUpgradeAvailability },
@@ -97924,4 +97907,4 @@ export {
   * MIT Licensed
   *)
 */
-//# sourceMappingURL=chunk-DVSX6ALB.js.map
+//# sourceMappingURL=chunk-IOB4UFOK.js.map