@abelxiaoxing/cadence 1.2.1 → 1.2.2

package/agents/implementation-worker.md

@@ -20,8 +20,15 @@ Your output is one complete structured patch delivered through `abel_submit_resu
 - 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, task splitting, or an
-  approval-boundary blocker instead of submitting a partial patch.
+- 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.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abelxiaoxing/cadence",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "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/src/index.ts

@@ -1525,19 +1525,46 @@ export function openPackageWorkflowControlEngine(
       if (!phase) {
         return { kind: "paused", code: "task-phase-unavailable" };
       }
+      const taskPhases = Object.values(input.task.phases);
+      const executionBoundary = input.artifactCorrection
+        ? {
+            read: [
+              ...new Set(
+                taskPhases.flatMap((boundary) => [
+                  ...boundary.read,
+                  ...boundary.write,
+                  ...boundary.delete,
+                ]),
+              ),
+            ].sort(),
+            write: [
+              ...new Set(taskPhases.flatMap((boundary) => boundary.write)),
+            ].sort(),
+            delete: [
+              ...new Set(taskPhases.flatMap((boundary) => boundary.delete)),
+            ].sort(),
+          }
+        : {
+            read: [...phase.read],
+            write: [...phase.write],
+            delete: [...phase.delete],
+          };
       const phaseContract = {
         candidateId: input.candidateArtifact.identity.candidateId,
         taskId: input.taskId,
         phase: input.phase,
-        readSet: [...phase.read],
-        writeSet: [...phase.write],
-        deleteSet: [...phase.delete],
+        readSet: executionBoundary.read,
+        writeSet: executionBoundary.write,
+        deleteSet: executionBoundary.delete,
         verification: structuredClone(phase.verification),
         agentsImpact: input.task.agents.impact,
         agentsTarget: input.task.agents.target ?? null,
         agentsManagedOnly: true,
         agentsWriteAllowed: false,
         impactClosure: structuredClone(input.task.impactClosure),
+        ...(input.artifactCorrection
+          ? { artifactCorrection: structuredClone(input.artifactCorrection) }
+          : {}),
         ...(input.repair
           ? {
               repair: {
@@ -1570,7 +1597,11 @@ export function openPackageWorkflowControlEngine(
           path.resolve(input.workspaceRoot, root),
         ),
         allowedPaths: [
-          ...new Set([...phase.read, ...phase.write, ...phase.delete]),
+          ...new Set([
+            ...executionBoundary.read,
+            ...executionBoundary.write,
+            ...executionBoundary.delete,
+          ]),
         ],
         timeoutMs: LIMITS.phaseTimeoutMs,
         signal: input.signal,
@@ -1600,11 +1631,28 @@ export function openPackageWorkflowControlEngine(
       }
       const result = child.result;
       if (result.kind === "context-request") {
-        return classifyCandidateContextRequest(result, [
-          ...phase.read,
-          ...phase.write,
-          ...phase.delete,
-        ]);
+        return classifyCandidateContextRequest(result, {
+          phase: input.phase,
+          readPaths: phase.read,
+          writePaths: phase.write,
+          deletePaths: phase.delete,
+          taskPaths: [
+            ...new Set(
+              Object.values(input.task.phases).flatMap((boundary) => [
+                ...boundary.read,
+                ...boundary.write,
+                ...boundary.delete,
+              ]),
+            ),
+          ],
+          redWritePaths: input.task.phases.red.write,
+          agents: {
+            impact: input.task.agents.impact,
+            ...(input.task.agents.target
+              ? { target: input.task.agents.target }
+              : {}),
+          },
+        });
       }
       if (result.kind !== "sealed-candidate") {
         return { kind: "retryable", code: "candidate-diff-invalid" };

package/src/run-store.ts

@@ -917,7 +917,23 @@ export class RunStore {
     code?: string;
     lease?: OperationLease;
   }): RunProjection {
+    return this.transitionAtomically(input, () => {});
+  }
+
+  transitionAtomically(
+    input: {
+      runId: string;
+      to: RunState;
+      operationId: string;
+      code?: string;
+      lease?: OperationLease;
+    },
+    write: (database: DatabaseSync) => void,
+  ): RunProjection {
     requireIdentifier(input.operationId, "operation-id");
+    if (typeof write !== "function") {
+      throw new Error("state-transition-write-invalid");
+    }
     return this.#transaction(() => {
       if (input.lease) {
         if (input.lease.runId !== input.runId) throw new Error("lease-fenced");
@@ -935,6 +951,7 @@ export class RunStore {
         to: input.to,
         ...(input.code ? { code: input.code } : {}),
       });
+      write(this.#database);
       this.#recordOperation(
         input.runId,
         input.operationId,

package/src/submit-tool.ts

@@ -9,6 +9,7 @@ import {
   type CandidateFailure,
   type DiffResult,
   type EvidenceResult,
+  isAgentsPath,
   isValidRelativePath,
   type SubmitFinalCategory,
   type SubmitSchemaState,
@@ -144,15 +145,57 @@ function candidateArtifactSchema(candidateId: string) {
         code: Type.Union([
           Type.Literal("approved-context-needed"),
           Type.Literal("task-split-needed"),
-          Type.Literal("boundary-review-needed"),
         ]),
-        refs: Type.Array(Type.String(), { maxItems: 32 }),
+        refs: Type.Array(
+          Type.Union([
+            Type.String(),
+            Type.Object(
+              {
+                kind: Type.Literal("requested-path"),
+                path: Type.String(),
+                access: Type.Union([
+                  Type.Literal("read"),
+                  Type.Literal("write"),
+                ]),
+              },
+              { additionalProperties: false },
+            ),
+            Type.Object(
+              {
+                kind: Type.Literal("source-citation"),
+                path: Type.String(),
+                line: Type.Integer({ minimum: 1 }),
+              },
+              { additionalProperties: false },
+            ),
+            Type.Object(
+              {
+                kind: Type.Literal("contract-diagnostic"),
+                ref: Type.String(),
+              },
+              { additionalProperties: false },
+            ),
+          ]),
+          { minItems: 1, maxItems: 32 },
+        ),
       },
       { additionalProperties: false },
     ),
   ]);
 }
 
+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";
@@ -166,11 +209,8 @@ export type CandidateArtifactSubmissionResult =
   | {
       kind: "context-request";
       candidateId: string;
-      code:
-        | "approved-context-needed"
-        | "task-split-needed"
-        | "boundary-review-needed";
-      refs: string[];
+      code: CandidateContextRequestCode;
+      refs: CandidateContextRef[];
     };
 
 export type CandidateContextRequest = Extract<
@@ -178,18 +218,114 @@ export type CandidateContextRequest = Extract<
   { kind: "context-request" }
 >;
 
+export interface CandidateContextBoundary {
+  phase: "red" | "green" | "refactor";
+  readPaths: readonly string[];
+  writePaths: readonly string[];
+  deletePaths?: readonly string[];
+  taskPaths: readonly string[];
+  redWritePaths: readonly string[];
+  agents: {
+    impact: "none" | "update-existing" | "create-index" | "remove-index";
+    target?: string;
+  };
+}
+
 export interface ClassifiedCandidateContextRequest {
-  kind: "paused" | "approval-needed";
+  kind: "paused" | "retryable" | "approval-needed";
   code:
     | "approved-context-needed"
     | "task-split-needed"
-    | "boundary-review-needed";
+    | "boundary-review-needed"
+    | "red-artifact-constraint"
+    | "agents-context-needed"
+    | "agents-write-parent-owned"
+    | "agents-contract-insufficient";
   contextRequest: {
-    code: CandidateContextRequest["code"];
-    refs: string[];
+    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 === "." ||
@@ -198,23 +334,108 @@ function contextRefWithinBoundary(relative: string, approved: string): boolean {
   );
 }
 
+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 classifyCandidateContextRequest(
-  request: CandidateContextRequest,
-  approvedPaths: readonly string[],
+  request: {
+    kind: "context-request";
+    candidateId: string;
+    code: CandidateContextRequestCode;
+    refs: readonly CandidateContextRefInput[];
+  },
+  inputBoundary: readonly string[] | CandidateContextBoundary,
 ): ClassifiedCandidateContextRequest {
-  const refs = [...request.refs];
-  const inBoundary =
-    refs.length > 0 &&
-    refs.every((relative) =>
-      approvedPaths.some((approved) =>
-        contextRefWithinBoundary(relative, approved),
+  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) =>
+      !pathWithinAny(
+        ref.path,
+        ref.access === "write"
+          ? [...boundary.writePaths, ...(boundary.deletePaths ?? [])]
+          : phasePaths,
       ),
+  );
+  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,
     );
-  const approvalNeeded =
-    !inBoundary || request.code === "boundary-review-needed";
+    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: "paused",
+      code:
+        request.code === "task-split-needed"
+          ? "task-split-needed"
+          : "approved-context-needed",
+    };
+  }
   return {
-    kind: approvalNeeded ? "approval-needed" : "paused",
-    code: inBoundary ? request.code : "boundary-review-needed",
+    ...classification,
     contextRequest: {
       code: request.code,
       refs,
@@ -391,18 +612,17 @@ export function createCandidateArtifactTool(
           terminate: true,
         };
       }
-      const refs = value.refs as string[];
-      if (
-        refs.some((relative) => !isValidRelativePath(relative)) ||
-        new Set(refs).size !== refs.length
-      ) {
+      let refs: CandidateContextRef[];
+      try {
+        refs = normalizeCandidateContextRefs(value.refs);
+      } catch (error) {
         schema = "invalid";
         failure = {
           kind: "artifact",
           code: "invalid-structural-result",
           stage: "structural-submit",
         };
-        throw new Error("context request refs are invalid");
+        throw error;
       }
       result = {
         kind: "context-request",
@@ -411,7 +631,7 @@ export function createCandidateArtifactTool(
           CandidateArtifactSubmissionResult,
           { kind: "context-request" }
         >["code"],
-        refs: [...refs],
+        refs,
       };
       return {
         content: [

package/src/workflow-engine.ts

@@ -45,7 +45,13 @@ import { type OperationLease, RunStore } from "./run-store.ts";
 import { observeSafePath } from "./safe-path.ts";
 import type { ResolvedStateRoot } from "./state-root.ts";
 import type { WorkflowActivityUpdate } from "./subagent-activity.ts";
-import type { CandidateArtifactSubmission } from "./submit-tool.ts";
+import {
+  type CandidateArtifactSubmission,
+  type CandidateContextBoundary,
+  type CandidateContextRef,
+  classifyCandidateContextRequest,
+  normalizeCandidateContextRefs,
+} from "./submit-tool.ts";
 import {
   type BeginCandidateInput,
   TASK_LEDGER_LIMITS,
@@ -171,7 +177,14 @@ interface WorkflowContextRequest {
     | "approved-context-needed"
     | "task-split-needed"
     | "boundary-review-needed";
-  refs: string[];
+  refs: CandidateContextRef[];
+}
+
+interface RedArtifactCorrection {
+  code: "red-artifact-constraint";
+  attempt: number;
+  maxAttempts: number;
+  contextRequest?: WorkflowContextRequest;
 }
 
 export const APPROVAL_AUTHORITY_CATEGORIES = [
@@ -296,6 +309,7 @@ export interface WorkflowWorker {
       attribution: "introduced";
       failureIdentities: string[];
     };
+    artifactCorrection?: RedArtifactCorrection;
     signal: AbortSignal;
     onActivity?: (
       event: Pick<
@@ -568,24 +582,72 @@ function normalizeWorkflowContextRequest(
       "approved-context-needed",
       "task-split-needed",
       "boundary-review-needed",
-    ].includes(String(value.code)) ||
-    !Array.isArray(value.refs) ||
-    value.refs.length === 0 ||
-    value.refs.length > 32 ||
-    value.refs.some(
-      (relative) =>
-        typeof relative !== "string" || !isValidRelativePath(relative),
-    ) ||
-    new Set(value.refs).size !== value.refs.length
+    ].includes(String(value.code))
   ) {
     throw new Error("workflow-context-request-invalid");
   }
+  let refs: CandidateContextRef[];
+  try {
+    refs = normalizeCandidateContextRefs(value.refs);
+  } catch {
+    throw new Error("workflow-context-request-invalid");
+  }
   return {
     code: value.code as WorkflowContextRequest["code"],
-    refs: [...(value.refs as string[])],
+    refs,
   };
 }
 
+function contextApprovalRefs(request: WorkflowContextRequest): string[] {
+  return request.refs.flatMap((ref) =>
+    ref.kind === "requested-path" ? [ref.path] : [],
+  );
+}
+
+function contextBoundaryForTask(
+  task: PlanTaskDraft,
+  phase: "red" | "green" | "refactor",
+): CandidateContextBoundary {
+  const boundary = task.phases[phase];
+  if (!boundary) throw new Error("workflow-task-phase-invalid");
+  return {
+    phase,
+    readPaths: boundary.read,
+    writePaths: boundary.write,
+    deletePaths: boundary.delete,
+    taskPaths: [
+      ...new Set(
+        Object.values(task.phases).flatMap((candidate) => [
+          ...candidate.read,
+          ...candidate.write,
+          ...candidate.delete,
+        ]),
+      ),
+    ],
+    redWritePaths: task.phases.red.write,
+    agents: {
+      impact: task.agents.impact,
+      ...(task.agents.target ? { target: task.agents.target } : {}),
+    },
+  };
+}
+
+function classifyPersistedContextRequest(
+  request: WorkflowContextRequest,
+  task: PlanTaskDraft,
+  phase: "red" | "green" | "refactor",
+) {
+  return classifyCandidateContextRequest(
+    {
+      kind: "context-request",
+      candidateId: "candidate-durable-reclassification",
+      code: request.code,
+      refs: request.refs,
+    },
+    contextBoundaryForTask(task, phase),
+  );
+}
+
 function approvalRequirement(
   code: string,
   contextRequest?: WorkflowContextRequest,
@@ -599,7 +661,7 @@ function approvalRequirement(
   return {
     category: requirement.category,
     requiredGates: [...requirement.requiredGates],
-    refs: contextRequest ? [...contextRequest.refs] : [],
+    refs: contextRequest ? contextApprovalRefs(contextRequest) : [],
   };
 }
 
@@ -1282,6 +1344,7 @@ export interface DurableWorkflowEngineOptions {
       attribution: "introduced";
       failureIdentities: string[];
     };
+    artifactCorrection?: RedArtifactCorrection;
     signal: AbortSignal;
     onHeaders(): void;
     onProgress(): void;
@@ -2319,6 +2382,9 @@ class DurableWorkflowComposition
     ledger: TaskLedger,
     input: Parameters<WorkflowWorker["runAttempt"]>[0],
   ): WorkflowAttemptOutcome | undefined {
+    if (input.artifactCorrection?.code === "red-artifact-constraint") {
+      return undefined;
+    }
     const projection = ledger.projection({
       runId: input.runId,
       taskId: input.taskId,
@@ -2925,6 +2991,9 @@ class DurableWorkflowComposition
             },
             route: attempt.route,
             repair,
+            ...(request.artifactCorrection
+              ? { artifactCorrection: request.artifactCorrection }
+              : {}),
             signal: attempt.signal,
             onHeaders: attempt.onHeaders,
             onProgress: attempt.onProgress,
@@ -2972,7 +3041,8 @@ class DurableWorkflowComposition
         proposal.kind !== "sealed-candidate"
       ) {
         return proposal.kind === "operation-cancelled" ||
-          proposal.kind === "paused"
+          proposal.kind === "paused" ||
+          proposal.kind === "approval-needed"
           ? withRoute(proposal)
           : reject(proposal, {
               category: "artifact",
@@ -3213,7 +3283,9 @@ class DurableWorkflowComposition
         changes: revisionChanges(proposalRoot, approvedPaths),
       });
       const requiredOutputs = request.plan.outputs.filter(
-        (output) => output.producer.taskId === request.taskId,
+        (output) =>
+          output.producer.taskId === request.taskId &&
+          (!request.artifactCorrection || output.producer.phase !== "refactor"),
       );
       if (
         requiredOutputs.some(
@@ -3352,7 +3424,7 @@ class DurableWorkflowComposition
   #verifiedPhaseReplay(
     ledger: TaskLedger,
     input: Parameters<WorkflowWorker["runAttempt"]>[0],
-  ): { artifactHash: string; exitCode: number } {
+  ): { artifactHash: string; exitCode: number; isolatedRevisionId: string } {
     const projection = ledger.projection({
       runId: input.runId,
       taskId: input.taskId,
@@ -3366,6 +3438,8 @@ class DurableWorkflowComposition
       !event ||
       typeof event.artifactHash !== "string" ||
       !SHA256.test(event.artifactHash) ||
+      typeof event.isolatedRevisionId !== "string" ||
+      !SHA256.test(event.isolatedRevisionId) ||
       typeof event.exitCode !== "number" ||
       event.actualClassification !== expectedClassification(input.phase)
     ) {
@@ -3374,6 +3448,285 @@ class DurableWorkflowComposition
     return {
       artifactHash: event.artifactHash,
       exitCode: event.exitCode,
+      isolatedRevisionId: event.isolatedRevisionId,
+    };
+  }
+
+  async #runRedArtifactCorrection(input: {
+    resources: DurableRunResources;
+    ledger: TaskLedger;
+    baseline?: DurableVerificationBaseline;
+    attempt: Parameters<WorkflowWorker["runAttempt"]>[0];
+  }): Promise<WorkflowAttemptOutcome> {
+    const { resources, ledger } = input;
+    const request = input.attempt;
+    if (
+      request.phase !== "green" ||
+      request.artifactCorrection?.code !== "red-artifact-constraint"
+    ) {
+      throw new Error("workflow-red-artifact-correction-invalid");
+    }
+    const priorRed = this.#verifiedPhaseReplay(ledger, {
+      ...request,
+      phase: "red",
+    });
+    if (!hasVerificationLifecycle(request.plan)) {
+      return { kind: "paused", code: "red-artifact-constraint" };
+    }
+    const stableRevisionId = resources.currentRevisionId;
+    const correctionPaths = [
+      ...new Set(
+        Object.values(request.task.phases).flatMap((phase) => [
+          ...phase.write,
+          ...phase.delete,
+        ]),
+      ),
+    ];
+    const rejectCorrection = async <T extends WorkflowAttemptOutcome>(
+      outcome: T,
+    ): Promise<T> => {
+      if (resources.currentRevisionId !== stableRevisionId) {
+        await this.#rollbackWorkspacePaths({
+          resources,
+          baseRevisionId: stableRevisionId,
+          rejectedRevisionId: resources.currentRevisionId,
+          paths: correctionPaths,
+        });
+      }
+      return outcome;
+    };
+    const failureIdentities = [
+      hash(
+        "red-artifact-constraint",
+        request.taskId,
+        request.task.phases.red.verification.id,
+      ),
+    ];
+    const correctionAttemptUsed = request.artifactCorrection.attempt;
+    if (
+      correctionAttemptUsed < 1 ||
+      correctionAttemptUsed > request.artifactCorrection.maxAttempts
+    ) {
+      throw new Error("workflow-red-artifact-correction-invalid");
+    }
+    const repaired = await this.#runRepairCandidate({
+      resources,
+      ledger,
+      attempt: request,
+      repairAttempt: correctionAttemptUsed,
+      failureIdentities,
+    });
+    if (repaired.kind !== "repair-committed") {
+      return rejectCorrection(repaired);
+    }
+
+    const correctedRevision = resources.workspaces.getRevision(
+      repaired.commit.isolatedRevisionId,
+    );
+    const acceptedRedRevision = resources.workspaces.getRevision(
+      priorRed.isolatedRevisionId,
+    );
+    if (!acceptedRedRevision.parentRevisionId) {
+      throw new Error("workflow-ledger-revision-base-invalid");
+    }
+    const correctedRedChanges: Record<
+      string,
+      { kind: "absent" } | { kind: "file"; bytes: Uint8Array; mode: number }
+    > = {};
+    for (const relative of [
+      ...new Set([
+        ...request.task.phases.red.write,
+        ...request.task.phases.red.delete,
+      ]),
+    ]) {
+      const entry = correctedRevision.entries[relative];
+      correctedRedChanges[relative] =
+        entry?.kind === "file"
+          ? {
+              kind: "file",
+              bytes: resources.artifacts.read(entry.hash),
+              mode: entry.mode,
+            }
+          : { kind: "absent" };
+    }
+    const correctedRedRevision = resources.workspaces.createRevision({
+      parentRevisionId: acceptedRedRevision.parentRevisionId,
+      changes: correctedRedChanges,
+    });
+    const verifyCorrectedContract = async (input: {
+      phase: "red" | "green";
+      revisionId: string;
+      verification: StructuredVerificationContract;
+    }): Promise<DurablePhaseVerificationResult> => {
+      const root = mkdtempSync(path.join(resources.root, "correction-check-"));
+      try {
+        resources.workspaces.materialize(input.revisionId, root);
+        return await this.#options.verifyPhase({
+          runId: request.runId,
+          deliveryRevision: request.deliveryRevision,
+          taskId: request.taskId,
+          phase: input.phase,
+          root,
+          verification: structuredClone(input.verification),
+          signal: request.signal,
+        });
+      } finally {
+        rmSync(root, { recursive: true, force: true });
+      }
+    };
+    emitWorkflowActivity(request.onActivity, { state: "verifying" });
+    const redVerification = await verifyCorrectedContract({
+      phase: "red",
+      revisionId: correctedRedRevision.revisionId,
+      verification: request.task.phases.red.verification,
+    });
+    if (!redVerification.ok) {
+      return rejectCorrection({
+        ...redVerification,
+        ...(redVerification.kind === "retryable"
+          ? { retryPolicy: "verification" as const }
+          : {}),
+      });
+    }
+    if (
+      redVerification.classification !== "expected-red" ||
+      redVerification.exitCode === 0
+    ) {
+      return rejectCorrection({
+        kind: "retryable",
+        code: "verification-rejected",
+        retryPolicy: "verification",
+      });
+    }
+    const greenVerification = await verifyCorrectedContract({
+      phase: "green",
+      revisionId: repaired.commit.isolatedRevisionId,
+      verification: request.task.phases.green.verification,
+    });
+    if (!greenVerification.ok) {
+      return rejectCorrection({
+        ...greenVerification,
+        ...(greenVerification.kind === "retryable"
+          ? { retryPolicy: "verification" as const }
+          : {}),
+      });
+    }
+    if (
+      greenVerification.classification !== "expected-green" ||
+      greenVerification.exitCode !== 0
+    ) {
+      return rejectCorrection({
+        kind: "retryable",
+        code: "verification-rejected",
+        retryPolicy: "verification",
+      });
+    }
+
+    const repairEvent: VerifiedTaskEvent = {
+      runId: request.runId,
+      taskId: request.taskId,
+      eventId: `red-artifact-correction-${hash(
+        request.operationId,
+        request.taskId,
+        repaired.commit.artifactHash,
+      ).slice(0, 40)}`,
+      kind: "repair-verified",
+      phase: request.phase,
+      attempt: correctionAttemptUsed,
+      commandId: request.task.repairVerification.id,
+      exitCode: 0,
+      diagnostic: repaired.commit.diagnostic,
+      artifactHash: repaired.commit.artifactHash,
+      isolatedRevisionId: repaired.commit.isolatedRevisionId,
+      outputFacts: repaired.commit.outputFacts,
+      attribution: "introduced",
+      failureIdentities: [
+        hash(
+          "red-artifact-constraint",
+          request.taskId,
+          request.task.phases.red.verification.id,
+        ),
+      ],
+      routeId: repaired.commit.routeId,
+      routeFingerprint: repaired.commit.routeFingerprint,
+    };
+    const greenPaths = new Set([
+      ...request.task.phases.green.write,
+      ...request.task.phases.green.delete,
+    ]);
+    const greenEvent: VerifiedTaskEvent = {
+      runId: request.runId,
+      taskId: request.taskId,
+      eventId: `green-corrected-${hash(
+        request.operationId,
+        request.taskId,
+        repaired.commit.artifactHash,
+      ).slice(0, 40)}`,
+      kind: "phase-verified",
+      phase: "green",
+      commandId: request.task.phases.green.verification.id,
+      exitCode: greenVerification.exitCode,
+      expectedClassification: "expected-green",
+      actualClassification: greenVerification.classification,
+      diagnostic: greenVerification.diagnostic,
+      artifactHash: repaired.commit.artifactHash,
+      isolatedRevisionId: repaired.commit.isolatedRevisionId,
+      outputFacts: repaired.commit.outputFacts.filter((fact) =>
+        greenPaths.has(fact.path),
+      ),
+      routeId: repaired.commit.routeId,
+      routeFingerprint: repaired.commit.routeFingerprint,
+    };
+    const events: VerifiedTaskEvent[] = [repairEvent, greenEvent];
+    if (input.baseline) {
+      const affected = await this.#verifyTaskAffected({
+        resources,
+        baseline: input.baseline,
+        task: request.task,
+        revisionId: repaired.commit.isolatedRevisionId,
+        signal: request.signal,
+      });
+      if (affected.kind === "repairable") {
+        return rejectCorrection({
+          kind: "retryable",
+          code: "red-artifact-constraint",
+          retryPolicy: "artifact",
+        });
+      }
+      if (affected.kind !== "verified") return rejectCorrection(affected);
+    }
+    if (request.task.phases.refactor) {
+      ledger.commitVerifiedEvents(events);
+      return {
+        kind: "phase-committed",
+        artifactHash: repaired.commit.artifactHash,
+        isolatedRevisionId: repaired.commit.isolatedRevisionId,
+        exitCode: greenVerification.exitCode,
+        classification: greenVerification.classification,
+        routeId: repaired.commit.routeId,
+        routeFingerprint: repaired.commit.routeFingerprint,
+      };
+    }
+    const completedRevision = this.#completeTracking(resources, request.taskId);
+    ledger.commitTaskCompletion({
+      events,
+      factKey: `task-final-${hash(request.taskId).slice(0, 40)}`,
+      fact: {
+        taskId: request.taskId,
+        phase: request.phase,
+        isolatedRevisionId: completedRevision.revisionId,
+        attribution: "introduced",
+        repairAttempts: correctionAttemptUsed,
+      },
+    });
+    return {
+      kind: "phase-committed",
+      artifactHash: repaired.commit.artifactHash,
+      isolatedRevisionId: completedRevision.revisionId,
+      exitCode: greenVerification.exitCode,
+      classification: greenVerification.classification,
+      routeId: repaired.commit.routeId,
+      routeFingerprint: repaired.commit.routeFingerprint,
     };
   }
 
@@ -3598,6 +3951,16 @@ class DurableWorkflowComposition
       verificationBaseline = captured.baseline;
     }
     this.#openTask(resources, ledger, input);
+    if (input.artifactCorrection?.code === "red-artifact-constraint") {
+      return retained(
+        await this.#runRedArtifactCorrection({
+          resources,
+          ledger,
+          ...(verificationBaseline ? { baseline: verificationBaseline } : {}),
+          attempt: input,
+        }),
+      );
+    }
     if (input.repair) {
       if (!verificationBaseline) {
         throw new Error("workflow-verification-baseline-unavailable");
@@ -3747,7 +4110,8 @@ class DurableWorkflowComposition
         proposal.kind !== "sealed-candidate"
       ) {
         return proposal.kind === "operation-cancelled" ||
-          proposal.kind === "paused"
+          proposal.kind === "paused" ||
+          proposal.kind === "approval-needed"
           ? retained(proposal)
           : reject(proposal, {
               category: "artifact",
@@ -5080,8 +5444,18 @@ export class WorkflowEngine {
       this.#database
         .prepare(
           `UPDATE workflow_engine_tasks
-           SET state = 'paused', pause_code = 'operation-interrupted',
-               context_request_json = NULL, queue_position = NULL
+           SET state = 'paused',
+               pause_code = CASE
+                 WHEN pause_code = 'red-artifact-constraint'
+                   THEN pause_code
+                 ELSE 'operation-interrupted'
+               END,
+               context_request_json = CASE
+                 WHEN pause_code = 'red-artifact-constraint'
+                   THEN context_request_json
+                 ELSE NULL
+               END,
+               queue_position = NULL
            WHERE run_id = ? AND state IN ('phase-running', 'validating')`,
         )
         .run(row.run_id);
@@ -5745,6 +6119,23 @@ export class WorkflowEngine {
     const orderedPhases = phases(task);
     let phaseIndex = orderedPhases.indexOf(row.phase);
     let artifactAttempts = 0;
+    const persistedContextRequest = row.context_request_json
+      ? normalizeWorkflowContextRequest(
+          JSON.parse(row.context_request_json) as unknown,
+        )
+      : undefined;
+    const persistedRedArtifactCorrection =
+      row.phase === "green" &&
+      persistedContextRequest !== undefined &&
+      classifyPersistedContextRequest(persistedContextRequest, task, "green")
+        .code === "red-artifact-constraint";
+    let redArtifactCorrection =
+      row.phase === "green" &&
+      (row.pause_code === "red-artifact-constraint" ||
+        persistedRedArtifactCorrection);
+    let correctionContextRequest = redArtifactCorrection
+      ? persistedContextRequest
+      : undefined;
     if (phaseIndex < 0) throw new Error("workflow-task-phase-invalid");
     while (phaseIndex < orderedPhases.length) {
       const phase = orderedPhases[phaseIndex];
@@ -5771,6 +6162,7 @@ export class WorkflowEngine {
             JSON.parse(current.verification_json) as unknown,
           )
         : undefined;
+      const plan = this.#planForRevision(runId, row.delivery_revision);
       const repair =
         verificationStatus?.scope === "change-task-affected" &&
         verificationStatus.attribution === "introduced" &&
@@ -5782,19 +6174,31 @@ export class WorkflowEngine {
               failureIdentities: [...verificationStatus.failureIdentities],
             }
           : undefined;
+      const artifactCorrection =
+        redArtifactCorrection && phase === "green"
+          ? {
+              code: "red-artifact-constraint" as const,
+              attempt: artifactAttempts + 1,
+              maxAttempts: plan.verification.artifactCorrection.maxAttempts,
+              ...(correctionContextRequest
+                ? {
+                    contextRequest: structuredClone(correctionContextRequest),
+                  }
+                : {}),
+            }
+          : undefined;
       this.#setTask(
         runId,
         row.task_id,
         {
           state: "phase-running",
           phase,
-          pauseCode: null,
-          contextRequest: null,
+          pauseCode: artifactCorrection?.code ?? null,
+          contextRequest: correctionContextRequest ?? null,
           queuePosition: null,
         },
         lease,
       );
-      const plan = this.#planForRevision(runId, row.delivery_revision);
       let outcome: WorkflowAttemptOutcome;
       try {
         outcome = await this.#worker.runAttempt({
@@ -5825,6 +6229,7 @@ export class WorkflowEngine {
               }
             : {}),
           ...(repair ? { repair } : {}),
+          ...(artifactCorrection ? { artifactCorrection } : {}),
           signal,
           onActivity: (event) => {
             const projection = this.#runStore.status(runId);
@@ -5864,9 +6269,29 @@ export class WorkflowEngine {
         this.#setVerificationStatus(runId, outcome.verification, lease);
       }
       if (outcome.kind === "retryable" && outcome.retryPolicy === "artifact") {
+        if (outcome.code === "red-artifact-constraint") {
+          redArtifactCorrection = true;
+          correctionContextRequest = outcome.contextRequest
+            ? normalizeWorkflowContextRequest(outcome.contextRequest)
+            : correctionContextRequest;
+        }
         artifactAttempts += 1;
         const maxAttempts = plan.verification.artifactCorrection.maxAttempts;
         if (artifactAttempts < maxAttempts) {
+          this.#setTask(
+            runId,
+            row.task_id,
+            {
+              state: "retryable",
+              phase,
+              pauseCode: redArtifactCorrection
+                ? "red-artifact-constraint"
+                : outcome.code,
+              contextRequest: correctionContextRequest ?? null,
+              queuePosition: null,
+            },
+            lease,
+          );
           emitWorkflowActivity(onActivity, {
             state: "retrying",
             stage: this.#runStore.status(runId).stage,
@@ -5910,6 +6335,8 @@ export class WorkflowEngine {
           return;
         }
         artifactAttempts = 0;
+        redArtifactCorrection = false;
+        correctionContextRequest = undefined;
         phaseIndex += 1;
         if (phaseIndex >= orderedPhases.length) {
           this.#setTask(
@@ -5978,7 +6405,7 @@ export class WorkflowEngine {
             contextRequest:
               !approvalCodeInvalid && outcome.contextRequest
                 ? normalizeWorkflowContextRequest(outcome.contextRequest)
-                : null,
+                : (correctionContextRequest ?? null),
             queuePosition: null,
           },
           lease,
@@ -5990,11 +6417,119 @@ export class WorkflowEngine {
   }
 
   #firstPaused(rows: EngineTaskRow[]): EngineTaskRow | undefined {
-    return rows.find((row) =>
-      ["paused", "retryable", "approval-needed"].includes(row.state),
+    return (
+      rows.find((row) => row.state === "approval-needed") ??
+      rows.find((row) => ["paused", "retryable"].includes(row.state))
     );
   }
 
+  #recoverLegacyContextApproval(runId: string): boolean {
+    const projection = this.#runStore.status(runId);
+    if (!["approval-needed", "paused"].includes(projection.state)) return false;
+    const rows = this.#tasks(runId);
+    const approvalRows = rows.filter((row) => row.state === "approval-needed");
+    if (approvalRows.length === 0) return false;
+    const reclassified = rows.flatMap((row) => {
+      if (
+        row.state !== "approval-needed" ||
+        row.pause_code !== "boundary-review-needed" ||
+        row.context_request_json === null
+      ) {
+        return [];
+      }
+      try {
+        const request = normalizeWorkflowContextRequest(
+          JSON.parse(row.context_request_json) as unknown,
+        );
+        const classified = classifyPersistedContextRequest(
+          request,
+          this.#taskPlan(row),
+          row.phase,
+        );
+        if (classified.kind === "approval-needed") return [];
+        return [
+          {
+            row,
+            state: classified.kind === "retryable" ? "retryable" : "paused",
+            code: classified.code,
+            contextRequest: JSON.stringify(
+              normalizeWorkflowContextRequest(classified.contextRequest),
+            ),
+          },
+        ];
+      } catch {
+        return [];
+      }
+    });
+    const reclassifiedTaskIds = new Set(
+      reclassified.map((entry) => entry.row.task_id),
+    );
+    const retainedApprovals = approvalRows.filter(
+      (row) => !reclassifiedTaskIds.has(row.task_id),
+    );
+    const updateTasks = (database: DatabaseSync) => {
+      for (const entry of reclassified) {
+        const updated = database
+          .prepare(
+            `UPDATE workflow_engine_tasks
+             SET state = ?, phase = ?, pause_code = ?, context_request_json = ?,
+                 queue_position = NULL
+             WHERE run_id = ? AND task_id = ?
+               AND state = 'approval-needed'
+               AND pause_code = 'boundary-review-needed'`,
+          )
+          .run(
+            entry.state,
+            entry.row.phase,
+            entry.code,
+            entry.contextRequest,
+            runId,
+            entry.row.task_id,
+          );
+        if (Number(updated.changes) !== 1) {
+          throw new Error("workflow-legacy-context-race");
+        }
+      }
+    };
+    const transitionWithUpdates = (
+      to: "paused" | "approval-needed",
+      code: string,
+    ) =>
+      this.#runStore.transitionAtomically(
+        {
+          runId,
+          to,
+          operationId: `legacy-context-${hash(
+            runId,
+            String(projection.sequence),
+            to,
+            code,
+            JSON.stringify(
+              reclassified.map((entry) => [entry.row.task_id, entry.code]),
+            ),
+          ).slice(0, 40)}`,
+          code,
+        },
+        updateTasks,
+      );
+    if (retainedApprovals.length > 0) {
+      if (projection.state === "approval-needed") {
+        if (reclassified.length === 0) return false;
+        this.#transaction(() => updateTasks(this.#database));
+      } else {
+        transitionWithUpdates(
+          "approval-needed",
+          retainedApprovals[0].pause_code ?? "approval-code-invalid",
+        );
+      }
+      return true;
+    }
+    const first = reclassified[0];
+    if (!first) return false;
+    transitionWithUpdates("paused", first.code);
+    return true;
+  }
+
   async #finishChange(
     runId: string,
     operationId: string,
@@ -6592,7 +7127,10 @@ export class WorkflowEngine {
         )
       : undefined;
     const pauseCode =
-      projection.pauseCode ?? firstPaused?.pause_code ?? "task-paused";
+      projection.state === "approval-needed" &&
+      firstPaused?.state === "approval-needed"
+        ? (firstPaused.pause_code ?? projection.pauseCode ?? "task-paused")
+        : (projection.pauseCode ?? firstPaused?.pause_code ?? "task-paused");
     const approval =
       projection.state === "approval-needed"
         ? approvalRequirement(pauseCode, contextRequest)
@@ -6941,6 +7479,7 @@ export class WorkflowEngine {
   ) {
     const runId = this.#lookupRun(command.stage, command.change);
     if (!runId) throw new Error("run-not-found");
+    this.#recoverLegacyContextApproval(runId);
     const replay = this.#beginOperation(
       runId,
       command.operationId,
@@ -7337,6 +7876,7 @@ export class WorkflowEngine {
       case "status": {
         const runId = this.#lookupRun(command.stage, command.change);
         if (!runId) throw new Error("run-not-found");
+        this.#recoverLegacyContextApproval(runId);
         return this.#withAvailableDelivery(this.#statusByRun(runId));
       }
       case "resume":