@abelxiaoxing/cadence 1.8.2 → 1.8.4

package/agents/design-explorer.md

@@ -2,28 +2,20 @@
 
 You are a package-owned read-only professional Agent for the `abel-design` stage.
 
-You explore the repository ONLY through the scoped `read`, `grep`, `find`, and `ls` tools.
-You have no shell, edit, Git, network, or validation capability, and you never create or modify files.
+Explore the current workspace using only `read`, `grep`, `find`, and `ls`.
+Do not write files, run commands, use Git, invoke workflow controls, or start another agent.
+The parent controls stage authority and validates your evidence.
 
-Submit one accepted final result through `abel_submit_result`; brief accompanying text is harmless.
-If the tool rejects your submission, use its error to correct once in this same disposable session.
-A second rejected structural submission ends the session.
-Never submit again after acceptance.
+Return one concise final answer.
+Put the evidence object in exactly one `json` code fence.
+The parent binds packet identity; do not invent authority or claim verification.
+Required draft fields: include `module_name`, `scope`, `files_read`, `evidence` (with claim, path, line_start, line_end), `constraints_discovered`, `open_questions`, and `risks`.
+The trusted tool binds packet identity.
+Omission is not a verified absence or authorization.
+Optional arrays may describe structures, conventions, dependencies, write-set hints, validation hints, agent impact, and success criteria.
 
-Required draft fields:
-
-- `module_name`: a canonical workspace-relative module path or slug;
-- `scope` and `files_read`: unique workspace-relative paths, with nonempty scope;
-- `evidence`: cited claims with `claim`, `path`, positive `line_start`, and inclusive `line_end >= line_start`;
-- `constraints_discovered`, `open_questions`, and `risks`: explicit arrays (use `[]` only when there are none).
-
-Omit `id`, `packet_id`, `role`, and `kind`: the trusted tool binds them to this packet.
-If supplied, they must match the declared identity.
-Optional advisory arrays are `existing_structures`, `existing_conventions`, `dependencies`, `write_set_hints`, `validation_hints`, `agents_impact_hints`, and `success_criteria_hints`.
-Omission means no advisory information supplied, not a verified absence or authorization.
-Do not invent evidence or drop unresolved questions to satisfy the format.
-Do not add undeclared fields.
-
-You never return raw transcripts, hidden reasoning, or tool-call history.
-A packet is complete only when every claim is cited and every blocking question is explicit.
-If a scope escape, mutation, or undeclared capability is attempted, you fail closed and report the violation.
+Do not return a raw transcript or hidden reasoning.
+Make every claim cite a workspace-relative path and line range.
+If evidence is insufficient, state the blocking question instead of guessing.
+If a correction is needed, correct it once, then stop when the final answer is complete.
+Brief accompanying text is harmless.

package/agents/diagnosis-worker.md

@@ -1,28 +1,17 @@
 # Role: diagnosis-worker
 
-You are a package-owned read-only professional Agent for `abel-diagnose`.
+You are a package-owned evidence worker for `abel-diagnose`.
 
-You collect evidence and falsify candidate root causes ONLY through the scoped `read`, `grep`, `find`, and `ls` tools.
-You never write, execute commands, or run validation.
-The fixed algorithm order is reproduce, falsify, failing-regression, then minimum-repair.
+Collect evidence and falsify candidate root causes using only the read-only tools explicitly enabled by the parent.
+The fixed order is reproduce when permitted, falsify, failing-regression evidence, then minimum-repair guidance.
+You never choose a workflow stage, claim parent-owned command verification, modify files, or invoke workflow controls.
 
-An evidence packet submits one accepted compact structured evidence object through `abel_submit_result` with the reported symptoms, candidate causes, confirming or refuting citations, and a supported root-cause conclusion or an explicit evidence gap.
-Only the parent may claim that command-based reproduction succeeded.
-For evidence, omit `id`, `role`, and `kind`; the tool binds them.
-Keep `conclusions`, `citations`, `constraints`, `risks`, and `blockingQuestions` explicit.
-`dependencies` and `hints` may be omitted when no advisory information is supplied.
-If supplying hints, use `writeSet`, `verification`, and `agentsImpact` (`none`, `update-existing`, `create-index`, or `remove-index`).
-Omission never proves the absence of an impact.
-After a rejected evidence or patch submission, use the error to correct once in this same disposable session.
-A second rejected structural submission ends the session.
-Never submit again after acceptance.
+Return one concise final answer.
+For evidence, put one JSON object in a single `json` code fence with reported symptoms, candidate causes, confirming or refuting citations, constraints, risks, and blockingQuestions.
+Diagnose packets are evidence-only: do not propose a structured diff or claim that a repair was applied.
+The parent owns result acceptance, any later implementation, candidate sealing, verification, and recovery.
 
-A candidate packet submits one complete structured patch: either the failing regression or, after the parent has verified that regression, the minimum repair.
-Use ordered `replace`, `rewrite`, `create`, and `delete` operations inside the approved write set.
-Never write unified-diff headers or hunk ranges because the trusted control plane generates them.
-If approved context is insufficient, submit a small typed context request instead of a partial patch.
-The trusted submit tool validates the accepted payload; brief accompanying text is harmless.
-Never claim that you ran the parent-owned verification.
-
-You never invent a fix for an unverified root cause, change behavior contracts, select another workflow stage, or prescribe parent recovery.
-Scope-expanding repairs are reported as evidence for a user decision.
+Use the terms failing-regression and minimum-repair when describing the diagnosis algorithm.
+Never claim a result, and never invent a fix for an unverified root cause.
+Keep output bounded.
+If a correction is needed, describe the minimum repair and its verification condition, then stop when the final answer is complete.

package/agents/implementation-worker.md

@@ -1,39 +1,21 @@
 # Role: implementation-worker
 
-You are a package-owned read-only professional Agent for `abel-implement` task phases (Red, Green, and optional Refactor).
+You are a package-owned implementation worker for `abel-implement` task phases (Red, Green, and optional Refactor).
 
-You explore the workspace ONLY through the scoped `read`, `grep`, `find`, and `ls` tools.
-You never write the workspace, run validation, or execute commands.
+Use only the tools explicitly enabled by the parent.
+The current working directory is a disposable proposal workspace, not an OS sandbox: never access unrelated absolute paths, never commit Git, and never claim that parent-owned verification succeeded.
+Edit only paths in the phase contract.
+The parent captures and checks the workspace diff, including out-of-bound changes; never silently drop such changes.
 
-Your output is one complete structured patch delivered through `abel_submit_result`:
+Make the smallest complete change required by the objective.
+Preserve the expected parent-owned verification contract.
+If context is insufficient, explain the missing context rather than making a speculative partial repair.
+Describe changed paths and intent in the final summary, but never write unified-diff headers or hunk ranges and do not calculate hashes or byte counts.
+Finish without claiming a result; the parent owns result acceptance.
 
-- copy the attempt-bound `candidateId` from the phase contract;
-- submit one accepted `candidate-patch` call containing that `candidateId` and
-  an ordered `operations` array;
-- use `replace` with exact uniquely occurring `oldText` and the intended
-  `newText` for compact edits, `rewrite` for a complete existing-file body,
-  `create` with complete content plus `regular | executable` mode, and
-  `delete` only for an approved deletion path;
-- never write unified-diff headers or hunks and never calculate sequences,
-  Base64 encodings, byte counts, or hashes; the trusted submit tool validates
-  the operations, generates the diff, chunks it, and seals it atomically;
-- every operation path is within the declared phase boundary; paths that do
-  not need a change may remain untouched;
-- preserve the expected parent-owned verification contract without claiming a result;
-- use a typed `context-request` for bounded context or task splitting instead
-  of submitting a partial patch; classify every ref as a requested path with
-  `read | write` access, a source citation with path and line, or a
-  contract-diagnostic ref;
-- report only the missing context and structural facts: never select
-  `approval-needed`, `boundary-review-needed`, a Gate, or a workflow stage;
-- an `AGENTS.md` path is never a Worker write path;
-- report an AGENTS read need separately, and leave every sealed AGENTS contract
-  and managed-block update to the parent control plane.
-
-If the submit tool rejects malformed operations, use its concrete error to correct the submission once in this same disposable session; a second rejected structural submission ends the session.
-
-Never submit again after acceptance; brief accompanying text is harmless.
-
-If the configured candidate limit is exceeded, the submit tool returns terminal typed `result-limit` with `limitBytes`; never continue with a partial or truncated patch.
-The parent alone reviews, applies, and validates the generated diff.
-You report candidate facts only and never claim execution success, select parent recovery, choose a workflow stage, or control the task DAG.
+Finish with a concise plain-text summary.
+If the parent requests structured evidence, put one JSON object in a single `json` code fence.
+Never claim a result, select a workflow stage, choose recovery, or report verification success.
+Respect output limits (including a terminal `result-limit`) and stop when the requested work is complete.
+If a correction is needed, correct it once, then stop when the final answer is complete.
+Brief accompanying text is harmless.

package/config/.env.example

@@ -1,8 +1,5 @@
-# Worker routing is configured as one whole JSON policy at
-# <project>/.pi/cadence/routes.json or ~/.pi/agent/cadence/routes.json.
-# Copy routes.example.json and reference custom credentials by environment
-# variable name; never place credential values in routes.json.
-CADENCE_CUSTOM_WORKER_API_KEY=
+# Cadence child workers use the active Pi model and authentication configuration.
+# Cadence no longer reads routes.json or custom worker endpoint settings.
 
 # Context7 works anonymously with its default URL. Uncomment the API key for
 # authenticated access, or the URL only when overriding the default endpoint.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abelxiaoxing/cadence",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "description": "Four explicit Abel workflow prompts with stage-isolated design and diagnosis, durable resumable implementation, and three package-owned professional Agents.",
   "license": "MIT",
   "type": "module",

package/prompts/abel-diagnose.md

@@ -37,8 +37,8 @@ Use bounded `abel_dispatch` packets with `action: "run"`, `stage: "abel-diagnose
 Each packet covers one defect or one falsification question.
 Do not send an Implement control command from Diagnose.
 
-The parent runs reproduction and verification commands and applies accepted diffs.
-A diagnosis Worker is read-only: it proposes cited evidence or one complete candidate diff and never claims that it executed a command or observed a passing result.
+The parent runs reproduction and verification commands and owns any later implementation.
+A diagnosis Worker is read-only and evidence-only: it returns cited evidence and minimum-repair guidance, never proposes or applies a diff, and never claims that it executed a command or observed a passing result.
 
 ## Evidence-first algorithm
 
@@ -51,8 +51,8 @@ For each defect, keep this order:
    Accept a root cause only when evidence rules out material alternatives.
 4. Add the smallest executable regression verification and run it.
    It must fail for the reproduced defect, not for syntax, setup, environment, or another reason.
-5. Apply the minimum repair within the existing behavior and architecture contract.
-   Run the regression after every edit and the affected suite after refactoring.
+5. Describe the minimum repair within the existing behavior and architecture contract, including its regression verification condition.
+   Do not edit files or claim that a repair was applied from Diagnose.
 6. Compare the full suite with baseline and require no introduced failure.
    Classify any AGENTS impact and apply only a verified managed-region update at a stable parent checkpoint.
    Preserve every byte outside `<!-- ABEL:AGENTS-INDEX:START -->` and `<!-- ABEL:AGENTS-INDEX:END -->`; never give a Worker an AGENTS write path or put runtime/session ids, credentials, or approval state in the index.
@@ -65,7 +65,7 @@ Do not silently widen Diagnose and do not transform an ordinary repair failure i
 
 When an approved browser E2E check cannot run, pause only that check and provide executable remediation; continue independent non-browser evidence when safe.
 
-Finish only when reproduction, falsification, failing regression, minimum repair, affected verification, and baseline comparison are all evidenced.
+Finish only when reproduction, falsification, failing-regression evidence, minimum-repair guidance, affected verification, and baseline comparison are all evidenced.
 After presenting the final structural diagnosis/repair result, send `{"action":"finish"}` so private dispatch is deactivated.
 A resumable evidence or capability pause remains active for direct follow-up and must not send finish.
 Never archive, publish, or commit implicitly.

package/src/candidate-context.ts

@@ -0,0 +1,289 @@
+import { isAgentsPath, isValidRelativePath } from "./contracts.ts";
+import type { BeginCandidateInput, TaskLedger } from "./task-ledger.ts";
+export type CandidateContextRequestCode =
+  | "approved-context-needed"
+  | "task-split-needed"
+  | "boundary-review-needed";
+
+export type CandidateContextRef =
+  | { kind: "requested-path"; path: string; access: "read" | "write" }
+  | { kind: "source-citation"; path: string; line: number }
+  | { kind: "contract-diagnostic"; ref: string };
+
+export type CandidateContextRefInput = string | CandidateContextRef;
+
+export type CandidateArtifactSubmissionResult =
+  | {
+      kind: "sealed-candidate";
+      candidateId: string;
+      state: "sealed";
+      artifactHash: string;
+      bytes: number;
+      paths: string[];
+      replayed?: true;
+    }
+  | {
+      kind: "context-request";
+      candidateId: string;
+      code: CandidateContextRequestCode;
+      refs: CandidateContextRef[];
+    };
+
+export type CandidateContextRequest = Extract<
+  CandidateArtifactSubmissionResult,
+  { kind: "context-request" }
+>;
+
+export interface CandidateContextBoundary {
+  phase: "red" | "green" | "refactor";
+  readPaths: readonly string[];
+  writePaths: readonly string[];
+  deletePaths?: readonly string[];
+  taskPaths: readonly string[];
+  contextReadRoots?: readonly string[];
+  redWritePaths: readonly string[];
+  agents: {
+    impact: "none" | "update-existing" | "create-index" | "remove-index";
+    target?: string;
+  };
+}
+
+export interface ClassifiedCandidateContextRequest {
+  kind: "paused" | "retryable" | "approval-needed";
+  code:
+    | "approved-context-needed"
+    | "task-split-needed"
+    | "boundary-review-needed"
+    | "red-artifact-constraint"
+    | "agents-context-needed"
+    | "agents-write-parent-owned"
+    | "agents-contract-insufficient";
+  contextRequest: {
+    code: CandidateContextRequestCode;
+    refs: CandidateContextRef[];
+  };
+}
+
+const LEGACY_CITATION = /^(.*):(\d+)$/u;
+const LEGACY_DIAGNOSTIC =
+  /^(?:phase-contract|task-contract|sealed-contract|workflow-contract)\.[a-z0-9._-]+$/iu;
+
+function validDiagnosticRef(value: unknown): value is string {
+  return (
+    typeof value === "string" &&
+    value.length > 0 &&
+    value.length <= 512 &&
+    value.trim() === value &&
+    !/[\r\n\0]/u.test(value)
+  );
+}
+
+function normalizeCandidateContextRef(
+  input: CandidateContextRefInput,
+): CandidateContextRef {
+  if (typeof input === "string") {
+    const citation = LEGACY_CITATION.exec(input);
+    if (citation && isValidRelativePath(citation[1])) {
+      const line = Number(citation[2]);
+      if (Number.isSafeInteger(line) && line >= 1) {
+        return { kind: "source-citation", path: citation[1], line };
+      }
+    }
+    if (LEGACY_DIAGNOSTIC.test(input)) {
+      return { kind: "contract-diagnostic", ref: input };
+    }
+    if (!isValidRelativePath(input)) {
+      throw new Error("context request refs are invalid");
+    }
+    return { kind: "requested-path", path: input, access: "read" };
+  }
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error("context request refs are invalid");
+  }
+  if (
+    input.kind === "requested-path" &&
+    Object.keys(input).length === 3 &&
+    isValidRelativePath(input.path) &&
+    (input.access === "read" || input.access === "write")
+  ) {
+    return { ...input };
+  }
+  if (
+    input.kind === "source-citation" &&
+    Object.keys(input).length === 3 &&
+    isValidRelativePath(input.path) &&
+    Number.isSafeInteger(input.line) &&
+    input.line >= 1
+  ) {
+    return { ...input };
+  }
+  if (
+    input.kind === "contract-diagnostic" &&
+    Object.keys(input).length === 2 &&
+    validDiagnosticRef(input.ref)
+  ) {
+    return { ...input };
+  }
+  throw new Error("context request refs are invalid");
+}
+
+export function normalizeCandidateContextRefs(
+  value: unknown,
+): CandidateContextRef[] {
+  if (!Array.isArray(value) || value.length === 0 || value.length > 32) {
+    throw new Error("context request refs are invalid");
+  }
+  const refs = value.map((entry) =>
+    normalizeCandidateContextRef(entry as CandidateContextRefInput),
+  );
+  const identities = refs.map((ref) => JSON.stringify(ref));
+  if (new Set(identities).size !== refs.length) {
+    throw new Error("context request refs are invalid");
+  }
+  return refs;
+}
+
+function contextRefWithinBoundary(relative: string, approved: string): boolean {
+  return (
+    approved === "." ||
+    relative === approved ||
+    relative.startsWith(`${approved}/`)
+  );
+}
+
+function normalizedBoundary(
+  boundary: readonly string[] | CandidateContextBoundary,
+): CandidateContextBoundary {
+  if (!Array.isArray(boundary)) return boundary as CandidateContextBoundary;
+  return {
+    phase: "green",
+    readPaths: boundary,
+    writePaths: [],
+    deletePaths: [],
+    taskPaths: boundary,
+    redWritePaths: [],
+    agents: { impact: "none" },
+  };
+}
+
+function pathWithinAny(relative: string, approved: readonly string[]): boolean {
+  return approved.some((path) => contextRefWithinBoundary(relative, path));
+}
+
+export function permitsContextRead(
+  relative: string,
+  roots: readonly string[],
+): boolean {
+  // Dynamic discovery never grants hidden credentials or a directory tree.
+  return (
+    isValidRelativePath(relative) &&
+    relative.split("/").every((part) => !part.startsWith(".")) &&
+    !/\.(?:pem|key|p12|pfx)$/iu.test(relative) &&
+    pathWithinAny(relative, roots)
+  );
+}
+
+export function classifyCandidateContextRequest(
+  request: {
+    kind: "context-request";
+    candidateId: string;
+    code: CandidateContextRequestCode;
+    refs: readonly CandidateContextRefInput[];
+  },
+  inputBoundary: readonly string[] | CandidateContextBoundary,
+): ClassifiedCandidateContextRequest {
+  const refs = normalizeCandidateContextRefs(request.refs);
+  const boundary = normalizedBoundary(inputBoundary);
+  const phasePaths = [
+    ...boundary.readPaths,
+    ...boundary.writePaths,
+    ...(boundary.deletePaths ?? []),
+  ];
+  const requested = refs.filter(
+    (ref): ref is Extract<CandidateContextRef, { kind: "requested-path" }> =>
+      ref.kind === "requested-path",
+  );
+  const ordinaryRequested = requested.filter((ref) => !isAgentsPath(ref.path));
+  const outsideOrdinary = ordinaryRequested.filter(
+    (ref) =>
+      !(
+        ref.access === "read" &&
+        permitsContextRead(ref.path, boundary.contextReadRoots ?? [])
+      ) &&
+      !pathWithinAny(
+        ref.path,
+        ref.access === "write"
+          ? [...boundary.writePaths, ...(boundary.deletePaths ?? [])]
+          : [...phasePaths, ...boundary.taskPaths],
+      ),
+  );
+  const agentsRequested = requested.filter((ref) => isAgentsPath(ref.path));
+  const agentsWrites = agentsRequested.filter((ref) => ref.access === "write");
+  const citedRedArtifacts = refs.filter(
+    (ref): ref is Extract<CandidateContextRef, { kind: "source-citation" }> =>
+      ref.kind === "source-citation" &&
+      pathWithinAny(ref.path, boundary.redWritePaths) &&
+      !pathWithinAny(ref.path, [
+        ...boundary.writePaths,
+        ...(boundary.deletePaths ?? []),
+      ]),
+  );
+  const requestedRedArtifacts = outsideOrdinary.filter(
+    (ref) =>
+      pathWithinAny(ref.path, boundary.redWritePaths) &&
+      pathWithinAny(ref.path, boundary.taskPaths),
+  );
+  const redArtifactConstraint =
+    boundary.phase === "green" &&
+    (citedRedArtifacts.length > 0 || requestedRedArtifacts.length > 0) &&
+    outsideOrdinary.every((ref) => requestedRedArtifacts.includes(ref)) &&
+    agentsRequested.every((ref) => ref.access === "read");
+
+  let classification: Pick<ClassifiedCandidateContextRequest, "kind" | "code">;
+  if (outsideOrdinary.length > 0 && !redArtifactConstraint) {
+    classification = {
+      kind: "approval-needed",
+      code: "boundary-review-needed",
+    };
+  } else if (agentsWrites.length > 0) {
+    const targetMismatch = agentsWrites.some(
+      (ref) =>
+        boundary.agents.impact === "none" ||
+        boundary.agents.target === undefined ||
+        ref.path !== boundary.agents.target,
+    );
+    classification = targetMismatch
+      ? { kind: "approval-needed", code: "agents-contract-insufficient" }
+      : { kind: "paused", code: "agents-write-parent-owned" };
+  } else if (redArtifactConstraint) {
+    classification = { kind: "retryable", code: "red-artifact-constraint" };
+  } else if (agentsRequested.length > 0) {
+    classification = { kind: "paused", code: "agents-context-needed" };
+  } else {
+    classification = {
+      kind: "retryable",
+      code:
+        request.code === "task-split-needed"
+          ? "task-split-needed"
+          : "approved-context-needed",
+    };
+  }
+  return {
+    ...classification,
+    contextRequest: {
+      code: request.code,
+      refs,
+    },
+  };
+}
+
+export interface CandidateArtifactSubmission {
+  ledger: Pick<
+    TaskLedger,
+    "beginCandidate" | "appendCandidateSegment" | "sealCandidate"
+  >;
+  identity: BeginCandidateInput;
+  workspaceRoot: string;
+  writePaths: readonly string[];
+  deletePaths: readonly string[];
+}

package/src/contracts.ts

@@ -159,38 +159,18 @@ export const VERIFICATION_ADAPTER_CODES = [
   "verification-config-unsafe",
 ] as const;
 export const CHILD_TRANSPORT_CODES = [
-  "child-provider-rate-limited",
-  "first-progress-timeout",
-  "stream-idle-timeout",
-  "attempt-timeout",
-  "child-no-final-assistant",
-  "child-provider-stream-aborted",
-  "child-provider-stream-error",
   "child-timeout",
-  "timeout",
   "transport-failure",
 ] as const;
 export const FAILURE_STAGES = [
-  "child-session-create",
-  "child-provider-stream",
   "child-timeout",
-  "child-finalization",
-  "structural-submit",
-  "candidate-retention",
+  "child-provider-stream",
   "candidate-diff",
-  "parent-review",
   "candidate-apply",
-  "agents-checkpoint",
   "phase-runtime",
 ] as const;
 
-export const SUBMIT_FINAL_CATEGORIES = [
-  "no-final-assistant",
-  "text-only",
-  "mixed",
-  "multiple-submit",
-  "single-submit-only",
-] as const;
+export const SUBMIT_FINAL_CATEGORIES = ["text-only"] as const;
 export const SUBMIT_SCHEMA_STATES = [
   "not-submitted",
   "valid",
@@ -1892,6 +1872,16 @@ export function validatePacketEnvelope(
   ) {
     return { ok: false, reason: "invalid Design packet contract" };
   }
+  if (
+    packet.stage === "abel-diagnose" &&
+    (packet.output !== "evidence" ||
+      (packet.declared.write as unknown[]).length !== 0)
+  ) {
+    return {
+      ok: false,
+      reason: "invalid Diagnose evidence-only packet contract",
+    };
+  }
 
   return {
     ok: true,

package/src/durable-contracts.ts

@@ -1,13 +1,11 @@
 import type { ArtifactStore } from "./artifact-store.ts";
+import type { CandidateArtifactSubmission } from "./candidate-context.ts";
 import type {
   StructuredVerificationContract,
   VerificationInputObservation,
 } from "./contracts.ts";
 import type { ImplementPlan, PlanTaskDraft } from "./delivery-compiler.ts";
-import type { RoutePolicy, WorkerRoutePolicy } from "./route-policy.ts";
-
 import type { ResolvedStateRoot } from "./state-root.ts";
-import type { CandidateArtifactSubmission } from "./submit-tool.ts";
 import type { TaskLedger } from "./task-ledger.ts";
 
 import type {
@@ -123,7 +121,6 @@ export interface DurableWorkflowEngineOptions {
   consumerRoot: string;
   stateRoot: ResolvedStateRoot;
   deliverySource: WorkflowDeliverySource;
-  routePolicy: RoutePolicy;
   proposeCandidate(input: {
     runId: string;
     operationId: string;
@@ -134,7 +131,6 @@ export interface DurableWorkflowEngineOptions {
     workspaceRoot: string;
     ledgerProjection: unknown;
     candidateArtifact: CandidateArtifactSubmission;
-    route: WorkerRoutePolicy;
     repair?: {
       attempt: number;
       attribution: "introduced";