@abelxiaoxing/cadence 1.1.1 → 1.2.1

package/src/design-journal.ts

@@ -11,6 +11,7 @@ const SHA256 = /^[a-f0-9]{64}$/u;
 const IDENTIFIER = /^[a-z0-9](?:[a-z0-9._:-]{0,126}[a-z0-9])?$/iu;
 const ZERO_HASH = "0".repeat(64);
 const MAX_PLAN_BYTES = 16 * 1024 * 1024;
+const MAX_CONTRACT_BYTES = 256 * 1024;
 
 const SCHEMA = `
   CREATE TABLE IF NOT EXISTS design_facts (
@@ -144,6 +145,7 @@ export interface DesignGateProjection {
     | "behavior-decision-changed"
     | "technical-decision-changed"
     | "plan-recompiled"
+    | "gate-a-reapproved"
     | "gate-a-stale"
     | "plan-missing";
 }
@@ -223,6 +225,21 @@ function sha256(value: Uint8Array | string): string {
   return createHash("sha256").update(value).digest("hex");
 }
 
+function contractHash(domain: string, value: string): string {
+  if (
+    typeof value !== "string" ||
+    value.trim().length === 0 ||
+    Buffer.byteLength(value, "utf8") > MAX_CONTRACT_BYTES
+  ) {
+    throw new Error("design-transient-input-invalid");
+  }
+  return createHash("sha256")
+    .update(domain)
+    .update("\0")
+    .update(value.replace(/\r\n?/gu, "\n").trim())
+    .digest("hex");
+}
+
 function requireIdentifier(value: string, label: string): void {
   if (!IDENTIFIER.test(value)) throw new Error(`invalid-${label}`);
 }
@@ -877,11 +894,14 @@ export class DesignJournal {
     operationId: string;
     decisionId: string;
     category: DecisionCategory;
-    contractHash: string;
+    contract: string;
     refs: string[];
   }): Record<string, unknown> {
     requireIdentifier(input.decisionId, "design-decision-id");
-    requireHash(input.contractHash, "design-decision-hash");
+    const decisionContractHash = contractHash(
+      "abel-design-decision-v1",
+      input.contract,
+    );
     if (input.category !== "behavior" && input.category !== "technical") {
       throw new Error("design-decision-category-invalid");
     }
@@ -890,7 +910,7 @@ export class DesignJournal {
       operation: "record-decision",
       decisionId: input.decisionId,
       category: input.category,
-      contractHash: input.contractHash,
+      contractHash: decisionContractHash,
       refs,
     };
     return this.#transaction(() => {
@@ -909,7 +929,7 @@ export class DesignJournal {
       let decision: DesignDecisionProjection;
       if (
         prior &&
-        prior.contractHash === input.contractHash &&
+        prior.contractHash === decisionContractHash &&
         canonicalJson(prior.refs) === canonicalJson(refs)
       ) {
         decision = prior;
@@ -919,7 +939,7 @@ export class DesignJournal {
           decisionId: input.decisionId,
           category: input.category,
           revision,
-          contractHash: input.contractHash,
+          contractHash: decisionContractHash,
           refs,
         };
         const fact = this.#appendFact(
@@ -980,12 +1000,20 @@ export class DesignJournal {
     return undefined;
   }
 
-  approveGate(input: {
-    runId: string;
-    operationId: string;
-    gate: DesignGate;
-    contractHash: string;
-  }): {
+  approveGate(
+    input:
+      | {
+          runId: string;
+          operationId: string;
+          gate: "gate-a";
+          contract: string;
+        }
+      | {
+          runId: string;
+          operationId: string;
+          gate: "gate-b";
+        },
+  ): {
     operation: "approve-gate";
     runId: string;
     gate: DesignGate;
@@ -994,14 +1022,17 @@ export class DesignJournal {
     if (input.gate !== "gate-a" && input.gate !== "gate-b") {
       throw new Error("design-gate-invalid");
     }
-    requireHash(input.contractHash, "design-decision-hash");
-    const request = {
-      operation: "approve-gate",
-      gate: input.gate,
-      contractHash: input.contractHash,
-    };
+    const gateAContractHash =
+      input.gate === "gate-a"
+        ? contractHash("abel-design-gate-a-v1", input.contract)
+        : undefined;
     return this.#transaction(() => {
       this.#run(input.runId, true);
+      const request = {
+        operation: "approve-gate",
+        gate: input.gate,
+        ...(gateAContractHash ? { contractHash: gateAContractHash } : {}),
+      };
       const replay = this.#operationReplay(
         input.runId,
         input.operationId,
@@ -1012,15 +1043,26 @@ export class DesignJournal {
         return structuredClone(replay) as ReturnType<
           DesignJournal["approveGate"]
         >;
+      let approvedContractHash = gateAContractHash;
       if (input.gate === "gate-b") {
         const current = this.#gateStatus(input.runId);
         if (!current.gateA.current) throw new Error("design-gate-a-required");
         const plan = this.#currentPlanProjection(input.runId);
         if (!plan) throw new Error("design-plan-required");
-        if (plan.canonicalHash !== input.contractHash) {
-          throw new Error("design-gate-b-plan-mismatch");
+        const latestDecisionSequence = this.#facts(input.runId)
+          .filter((fact) => fact.kind === "decision")
+          .at(-1)?.sequence;
+        if (
+          plan.sequence <= (current.gateA.approvedSequence ?? 0) ||
+          (latestDecisionSequence !== undefined &&
+            plan.sequence <= latestDecisionSequence)
+        ) {
+          throw new Error("design-plan-stale");
         }
+        approvedContractHash = plan.canonicalHash;
       }
+      if (!approvedContractHash)
+        throw new Error("design-transient-input-invalid");
       const existing = this.#latestApproval(input.runId, input.gate);
       const currentGate = this.#gateStatus(input.runId)[
         input.gate === "gate-a" ? "gateA" : "gateB"
@@ -1029,7 +1071,7 @@ export class DesignJournal {
       if (
         existing &&
         currentGate.current &&
-        existing.proof.contractHash === input.contractHash
+        existing.proof.contractHash === approvedContractHash
       ) {
         proof = existing.proof;
       } else {
@@ -1037,7 +1079,7 @@ export class DesignJournal {
         const payload = {
           gate: input.gate,
           revision,
-          contractHash: input.contractHash,
+          contractHash: approvedContractHash,
         };
         const fact = this.#appendFact(
           input.runId,
@@ -1047,7 +1089,7 @@ export class DesignJournal {
         );
         proof = {
           revision,
-          contractHash: input.contractHash,
+          contractHash: approvedContractHash,
           recordHash: fact.record_hash,
         };
       }
@@ -1506,6 +1548,11 @@ export class DesignJournal {
         latestTechnical > gateBApproval.sequence
       ) {
         staleReason = "technical-decision-changed";
+      } else if (
+        gateAApproval !== undefined &&
+        gateAApproval.sequence > gateBApproval.sequence
+      ) {
+        staleReason = "gate-a-reapproved";
       } else if (plan && plan.sequence > gateBApproval.sequence) {
         staleReason = "plan-recompiled";
       } else if (!plan) {

package/src/index.ts

@@ -37,7 +37,10 @@ import {
   type StructuredVerificationContract,
   verificationSteps,
 } from "./contracts.ts";
-import { validateControlCommand } from "./control-contracts.ts";
+import {
+  canonicalizeControlCommandToolInput,
+  validateControlCommand,
+} from "./control-contracts.ts";
 import {
   assessDeliveryTraceability,
   compileImplementPlan,
@@ -210,6 +213,42 @@ const DESIGN_CONTROL_REQUEST_SCHEMA = {
   description:
     "One closed durable Design control operation. The operation body is strict and idempotent by operationId.",
   oneOf: [
+    ...(["requirement", "change"] as const).map((field) => ({
+      type: "object" as const,
+      properties: {
+        operation: { type: "string" as const, enum: ["start"] },
+        operationId: { type: "string" as const },
+        [field]: {
+          type: "string" as const,
+          description:
+            field === "requirement"
+              ? "Raw Design requirement; code derives and stores only its stable hash."
+              : "Existing canonical change name to resume or revise.",
+        },
+      },
+      required: ["operation", "operationId", field],
+      additionalProperties: false,
+    })),
+    {
+      type: "object",
+      properties: {
+        operation: { type: "string", enum: ["status"] },
+        runId: { type: "string" },
+      },
+      required: ["operation", "runId"],
+      additionalProperties: false,
+    },
+    {
+      type: "object",
+      properties: {
+        operation: { type: "string", enum: ["bind-change"] },
+        runId: { type: "string" },
+        operationId: { type: "string" },
+        change: { type: "string" },
+      },
+      required: ["operation", "runId", "operationId", "change"],
+      additionalProperties: false,
+    },
     {
       type: "object",
       properties: {
@@ -218,7 +257,11 @@ const DESIGN_CONTROL_REQUEST_SCHEMA = {
         operationId: { type: "string" },
         decisionId: { type: "string" },
         category: { type: "string", enum: ["behavior", "technical"] },
-        contractHash: { type: "string" },
+        contract: {
+          type: "string",
+          description:
+            "Normalized decision contract; code hashes it and never persists the text.",
+        },
         refs: { type: "array", items: { type: "string" } },
       },
       required: [
@@ -227,7 +270,7 @@ const DESIGN_CONTROL_REQUEST_SCHEMA = {
         "operationId",
         "decisionId",
         "category",
-        "contractHash",
+        "contract",
         "refs",
       ],
       additionalProperties: false,
@@ -238,10 +281,25 @@ const DESIGN_CONTROL_REQUEST_SCHEMA = {
         operation: { type: "string", enum: ["approve-gate"] },
         runId: { type: "string" },
         operationId: { type: "string" },
-        gate: { type: "string", enum: ["gate-a", "gate-b"] },
-        contractHash: { type: "string" },
+        gate: { type: "string", enum: ["gate-a"] },
+        contract: {
+          type: "string",
+          description:
+            "Complete approved WHAT contract; code hashes it and never persists the text.",
+        },
       },
-      required: ["operation", "runId", "operationId", "gate", "contractHash"],
+      required: ["operation", "runId", "operationId", "gate", "contract"],
+      additionalProperties: false,
+    },
+    {
+      type: "object",
+      properties: {
+        operation: { type: "string", enum: ["approve-gate"] },
+        runId: { type: "string" },
+        operationId: { type: "string" },
+        gate: { type: "string", enum: ["gate-b"] },
+      },
+      required: ["operation", "runId", "operationId", "gate"],
       additionalProperties: false,
     },
     {
@@ -417,7 +475,7 @@ export interface PackageDeliverySourceOptions {
 
 export interface PackageWorkflowDeliverySource extends WorkflowDeliverySource {
   discoverLatest(input: {
-    stage: "abel-design" | "abel-implement";
+    stage: "abel-implement";
     change: string;
   }): Promise<WorkflowAvailableDelivery | undefined>;
 }
@@ -1418,6 +1476,7 @@ export function openPackageWorkflowControlEngine(
   const routeResolution = loadRoutePolicy({
     cwd: consumerRoot,
     home: homedir(),
+    ...(initialContext.model ? { parentModel: initialContext.model } : {}),
   });
   const stateRoot = resolveStateRoot({
     consumerRoot,
@@ -1614,6 +1673,7 @@ export function openPackageWorkflowControlEngine(
       const operationRouteResolution = loadRoutePolicy({
         cwd: consumerRoot,
         home: homedir(),
+        ...(context.model ? { parentModel: context.model } : {}),
       });
       engine.updateRoutePolicy(
         operationRouteResolution.ok
@@ -1636,12 +1696,7 @@ export function openPackageWorkflowControlEngine(
           operationRouteResolution,
           engine.routePolicyStatus(),
         );
-        const designStatus =
-          validation.value.stage === "abel-design" &&
-          typeof outcome.runId === "string"
-            ? { design: design.status(outcome.runId) }
-            : {};
-        return { ...outcome, ...designStatus, routePolicy };
+        return { ...outcome, routePolicy };
       });
     },
     executeDesign(request: unknown) {
@@ -1781,16 +1836,15 @@ export function registerWorkflowControl(
       },
       stage: {
         type: "string",
-        enum: ["abel-design", "abel-implement"],
+        enum: ["abel-implement"],
       },
       change: { type: "string" },
-      provisionalKey: { type: "string" },
       operationId: { type: "string" },
       deliveryRevision: { type: "integer", minimum: 1 },
       receiptHash: { type: "string" },
       routeId: { type: "string" },
     },
-    required: ["command", "stage"],
+    required: ["command", "stage", "change"],
     additionalProperties: false,
   } as const;
   const PACKET_PARAMETERS = {
@@ -1818,9 +1872,15 @@ export function registerWorkflowControl(
       label: "Abel Control",
       description:
         kind === "command"
-          ? "Private stage-bound Abel workflow control. Accepts durable Design and Implement change commands."
+          ? "Private stage-bound Abel workflow control. Accepts durable Implement change commands."
           : "Private stage-bound Abel packet control. Accepts bounded Design and Diagnose packet operations.",
       executionMode: "parallel",
+      ...(kind === "command"
+        ? {
+            prepareArguments: (args: unknown) =>
+              canonicalizeControlCommandToolInput(args) as never,
+          }
+        : {}),
       parameters:
         kind === "command" ? CONTROL_COMMAND_PARAMETERS : PACKET_PARAMETERS,
       async execute(
@@ -1953,7 +2013,9 @@ export function registerWorkflowControl(
             ...(usage === undefined ? {} : { usage }),
           };
         }
-        const validation = validateControlCommand(params);
+        const validation = validateControlCommand(
+          canonicalizeControlCommandToolInput(params),
+        );
         if (!validation.ok) {
           const error = new Error(validation.code);
           error.name = "ControlCommandError";
@@ -2007,10 +2069,6 @@ export function registerWorkflowControl(
           ["completed", "discarded", "rejected"].includes(String(payload.state))
         ) {
           await deactivateStage();
-        } else if (validation.value.stage === "abel-design") {
-          // Design starts/statuses through the command surface, then switches to
-          // its bounded evidence and artifact packet surface for the next turn.
-          registerDispatchTool("packet");
         }
         let display: ReturnType<typeof activity.finalizeWorkflow>;
         if (tuiControl) {
@@ -2068,7 +2126,7 @@ export function registerWorkflowControl(
       if (activePrompt === "abel-design" && prompt !== "abel-design") {
         restoreDesignTools();
       }
-      registerDispatchTool(prompt === "abel-diagnose" ? "packet" : "command");
+      registerDispatchTool(prompt === "abel-implement" ? "command" : "packet");
       activePrompt = prompt;
       const sessionId = ctx.sessionManager?.getSessionId?.();
       if (typeof sessionId === "string") {

package/src/packet-runtime.ts

@@ -20,7 +20,6 @@ import { runtimeForWorkerRoute } from "./parent-provider.ts";
 import {
   loadRoutePolicy,
   type RoutePolicy,
-  unavailableRoutePolicy,
   type WorkerRole,
 } from "./route-policy.ts";
 import { type BrokerActivityUpdate, RunWorkerBroker } from "./worker-broker.ts";
@@ -319,7 +318,7 @@ export class PacketRuntime {
     if (!agent) {
       throw new Error("packet agent definition is unavailable");
     }
-    const broker = this.#brokerFor(context.cwd);
+    const broker = this.#brokerFor(context);
     const routed = await broker.run({
       runId: `${packet.stage}:${packet.id}`,
       operationId: packet.id,
@@ -405,8 +404,8 @@ export class PacketRuntime {
     return routed.value.child;
   }
 
-  #brokerFor(cwd: string): RunWorkerBroker {
-    const root = path.resolve(cwd);
+  #brokerFor(context: PacketContext): RunWorkerBroker {
+    const root = path.resolve(context.cwd);
     const existing = this.#brokers.get(root);
     let policy = this.#routePolicy;
     if (policy && existing) return existing;
@@ -414,12 +413,13 @@ export class PacketRuntime {
       const resolution = loadRoutePolicy({
         cwd: root,
         ...(this.#routePolicyHome ? { home: this.#routePolicyHome } : {}),
+        ...(context.model ? { parentModel: context.model } : {}),
       });
-      if (!resolution.ok && resolution.source.kind !== "none") {
+      if (!resolution.ok) {
         const code = resolution.diagnostics[0]?.code ?? "policy-invalid";
         throw new Error(`route-policy-unavailable:${code}`);
       }
-      policy = resolution.ok ? resolution.policy : unavailableRoutePolicy();
+      policy = resolution.policy;
     }
     const serializedPolicy = JSON.stringify(policy);
     if (existing && this.#brokerPolicies.get(root) === serializedPolicy) {

package/src/route-policy.ts

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { existsSync, lstatSync, readFileSync } from "node:fs";
+import { lstatSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
 import { ROLES } from "./contracts.ts";
@@ -21,6 +21,11 @@ export interface RouteCapabilities {
   maxTokens: number;
 }
 
+export interface ParentModelCapabilities {
+  contextWindow: number;
+  maxTokens: number;
+}
+
 interface RouteBase {
   id: string;
   kind: "inherited" | "custom";
@@ -50,10 +55,9 @@ export interface RoutePolicy {
 
 export type RoutePolicySource =
   | { kind: "project" | "user"; path: string }
-  | { kind: "none" };
+  | { kind: "default" };
 
 export type RoutePolicyDiagnosticCode =
-  | "policy-missing"
   | "policy-unreadable"
   | "policy-invalid-json"
   | "policy-invalid"
@@ -77,7 +81,7 @@ export type ParsedRoutePolicy =
 export type RoutePolicyResolution =
   | {
       ok: true;
-      source: Extract<RoutePolicySource, { kind: "project" | "user" }>;
+      source: RoutePolicySource;
       policy: RoutePolicy;
     }
   | {
@@ -87,8 +91,8 @@ export type RoutePolicyResolution =
     };
 
 /**
- * Internal fail-closed policy used while the selected external policy is
- * missing or invalid. It deliberately contains no inherited-parent route:
+ * Internal fail-closed policy used while a selected explicit policy is
+ * invalid. It deliberately contains no inherited-parent route:
  * the broker therefore reports endpoint-unavailable without making a Worker
  * request, while the local durable control plane remains available.
  *
@@ -351,8 +355,16 @@ export function parseRoutePolicy(value: unknown): ParsedRoutePolicy {
   };
 }
 
-/** Parent-model route used by read-only Design and Diagnose packets. */
-export function parentRoutePolicy(): RoutePolicy {
+/** Default parent-model route used when no explicit policy file exists. */
+export function parentRoutePolicy(
+  parentModel?: ParentModelCapabilities,
+): RoutePolicy {
+  const contextWindow = positiveInteger(parentModel?.contextWindow)
+    ? parentModel.contextWindow
+    : 1;
+  const maxTokens = positiveInteger(parentModel?.maxTokens)
+    ? Math.min(parentModel.maxTokens, contextWindow)
+    : 1;
   const parsed = parseRoutePolicy({
     version: ROUTE_POLICY_VERSION,
     routes: {
@@ -361,8 +373,8 @@ export function parentRoutePolicy(): RoutePolicy {
         capabilities: {
           roles: [...ROLES],
           dialects: [...ROUTE_DIALECTS],
-          contextWindow: 1_000_000,
-          maxTokens: 500_000,
+          contextWindow,
+          maxTokens,
         },
       },
     },
@@ -372,25 +384,41 @@ export function parentRoutePolicy(): RoutePolicy {
   return parsed.policy;
 }
 
-function selectedSource(cwd: string, home: string): RoutePolicySource {
+function selectedSource(
+  cwd: string,
+  home: string,
+): { kind: "project" | "user"; path: string } | { kind: "none" } {
+  const mayExist = (candidate: string): boolean => {
+    try {
+      return lstatSync(candidate, { throwIfNoEntry: false }) !== undefined;
+    } catch {
+      // Permission and path-observation failures are explicit unreadable
+      // policy candidates, not proof that the policy is absent.
+      return true;
+    }
+  };
   const projectPath = path.join(cwd, ".pi", "cadence", "routes.json");
-  if (existsSync(projectPath)) return { kind: "project", path: projectPath };
+  if (mayExist(projectPath)) return { kind: "project", path: projectPath };
   const userPath = path.join(home, ".pi", "agent", "cadence", "routes.json");
-  if (existsSync(userPath)) return { kind: "user", path: userPath };
+  if (mayExist(userPath)) return { kind: "user", path: userPath };
   return { kind: "none" };
 }
 
 export function loadRoutePolicy(
-  options: { cwd?: string; home?: string } = {},
+  options: {
+    cwd?: string;
+    home?: string;
+    parentModel?: ParentModelCapabilities;
+  } = {},
 ): RoutePolicyResolution {
   const cwd = path.resolve(options.cwd ?? process.cwd());
   const home = path.resolve(options.home ?? homedir());
   const source = selectedSource(cwd, home);
   if (source.kind === "none") {
     return {
-      ok: false,
-      source,
-      diagnostics: [{ code: "policy-missing" }],
+      ok: true,
+      source: { kind: "default" },
+      policy: parentRoutePolicy(options.parentModel),
     };
   }
   let bytes: string;

package/src/run-state.ts

@@ -1,5 +1,7 @@
 import { createHash } from "node:crypto";
-import type { ControlStage } from "./control-contracts.ts";
+
+export const RUN_STAGES = ["abel-design", "abel-implement"] as const;
+export type RunStage = (typeof RUN_STAGES)[number];
 
 export const RUN_STATES = [
   "created",
@@ -57,7 +59,7 @@ export interface DeliveryBindingProjection {
 export interface RunProjection {
   runId: string;
   rootHash: string;
-  stage: ControlStage;
+  stage: RunStage;
   change?: string;
   provisionalKey?: string;
   state: RunState;

package/src/run-store.ts

@@ -1,12 +1,12 @@
 import { randomUUID } from "node:crypto";
 import { chmodSync, closeSync, lstatSync, openSync } from "node:fs";
 import { DatabaseSync } from "node:sqlite";
-import type { ControlStage } from "./control-contracts.ts";
 import {
   createRunEvent,
   type DeliveryGate,
   type RunEvent,
   type RunProjection,
+  type RunStage,
   type RunState,
   reduceRunEvents,
   ZERO_EVENT_HASH,
@@ -37,6 +37,7 @@ interface EventRow {
 }
 
 interface OperationRow {
+  kind: string;
   state: string;
   outcome_json: string | null;
   lease_token: string | null;
@@ -49,7 +50,7 @@ export interface RunStoreOptions {
 }
 
 export interface StartRunInput {
-  stage: ControlStage;
+  stage: RunStage;
   change?: string;
   provisionalKey?: string;
   operationId: string;
@@ -338,7 +339,7 @@ export class RunStore {
   #operation(runId: string, operationId: string): OperationRow | undefined {
     return this.#database
       .prepare(
-        `SELECT state, outcome_json, lease_token, lease_expires_at
+        `SELECT kind, state, outcome_json, lease_token, lease_expires_at
          FROM operations WHERE run_id = ? AND operation_id = ?`,
       )
       .get(runId, operationId) as OperationRow | undefined;
@@ -347,8 +348,10 @@ export class RunStore {
   #operationOutcome(
     runId: string,
     operationId: string,
+    kind: string,
   ): RunProjection | undefined {
     const row = this.#operation(runId, operationId);
+    if (row && row.kind !== kind) throw new Error("operation-id-conflict");
     if (row?.state !== "committed" || row.outcome_json === null)
       return undefined;
     return parseProjection(row.outcome_json);
@@ -465,6 +468,7 @@ export class RunStore {
         const replay = this.#operationOutcome(
           existing.run_id,
           input.operationId,
+          "start",
         );
         if (replay) return replay;
         const projection = parseProjection(existing.projection_json);
@@ -539,7 +543,11 @@ export class RunStore {
     requireIdentifier(input.operationId, "operation-id");
     if (!CHANGE_NAME.test(input.change)) throw new Error("invalid-change");
     return this.#transaction(() => {
-      const replay = this.#operationOutcome(input.runId, input.operationId);
+      const replay = this.#operationOutcome(
+        input.runId,
+        input.operationId,
+        "change-bound",
+      );
       if (replay) return replay;
       const current = this.status(input.runId);
       if (current.stage !== "abel-design" || !current.provisionalKey) {
@@ -597,7 +605,11 @@ export class RunStore {
       if (input.lease.runId !== input.runId) throw new Error("lease-fenced");
       this.#assertLease(input.lease);
     }
-    const replay = this.#operationOutcome(input.runId, input.operationId);
+    const replay = this.#operationOutcome(
+      input.runId,
+      input.operationId,
+      "delivery-bound",
+    );
     if (replay) return replay;
     const existing = this.#database
       .prepare(
@@ -911,7 +923,11 @@ export class RunStore {
         if (input.lease.runId !== input.runId) throw new Error("lease-fenced");
         this.#assertLease(input.lease);
       }
-      const replay = this.#operationOutcome(input.runId, input.operationId);
+      const replay = this.#operationOutcome(
+        input.runId,
+        input.operationId,
+        "state-transitioned",
+      );
       if (replay) return replay;
       const current = this.status(input.runId);
       const projection = this.#appendEvent(input.runId, "state-transitioned", {