ai-foreman 1.7.29 → 2.0.0

package/dist/buildApproval.js

@@ -125,6 +125,31 @@ export function buildScopeRevision(projectDir, consequences) {
     });
     return createHash("sha256").update(JSON.stringify([contents, consequences])).digest("hex");
 }
+/** Unticketed recovery binds existing authorizations, never a fabricated plan. */
+export function frozenWorkApprovalBinding(projectDir, runId, workIds) {
+    if (!workIds.length || new Set(workIds).size !== workIds.length)
+        throw new Error("Frozen work approval requires a unique nonempty work scope");
+    const db = new WorkflowDb(projectDir);
+    try {
+        const admissions = [...workIds].sort().map(id => db.assertAdmittedWork(runId, id));
+        if (admissions.some(admission => admission.kind !== "synthetic"))
+            throw new Error("Frozen work approval cannot replace ticket plan approval");
+        return { kind: "synthetic", runId, workIds: [...workIds].sort(), admissionDigest: createHash("sha256").update(canonical(admissions)).digest("hex"), scopeRevision: buildScopeRevision(projectDir) };
+    }
+    finally {
+        db.close();
+    }
+}
+export function validateFrozenWorkApprovalBinding(projectDir, runId, workIds, binding) {
+    try {
+        if (canonical(frozenWorkApprovalBinding(projectDir, runId, workIds)) !== canonical(binding))
+            return { valid: false, reason: "Frozen work authorization, scope or configuration changed" };
+        return { valid: true };
+    }
+    catch (error) {
+        return { valid: false, reason: String(error) };
+    }
+}
 /** Compute the exact host-owned inputs covered by a recovery plan approval. */
 export function planApprovalBinding(projectDir, ticketIds, consequences) {
     const paths = resolveTicketPaths(loadTicketsConfig(projectDir), projectDir);

package/dist/buildAssignment.d.ts

@@ -17,6 +17,7 @@ export interface BuildAssignmentCapture {
 type BuildSourceState = Pick<FrozenQaSourceState, "digest" | "head" | "contentDigest" | "capturedAt" | "pathInventory" | "stagedDiff" | "unstagedDiff" | "untracked"> & {
     captureMode: "git" | "filesystem";
     omissions?: string[];
+    fileByteLengths?: Record<string, number>;
 };
 export declare class BuildAssignmentRejected extends Error {
 }

package/dist/buildAssignment.js

@@ -1,3 +1,5 @@
+import { operationPayload, operationResponse, operationStatus } from "./structuredOperation.js";
+import { workReportOutput } from "rafi-spec";
 import { assertBuilderContractCoverage } from "./qaBuilderCoverage.js";
 import { resolveEffectiveQaConfiguration } from "./qaEffectiveConfig.js";
 import { contractDigest } from "./qaVerificationContract.js";
@@ -118,7 +120,7 @@ export function prepareInterruptedBuilderSourceContinuation(projectDir, runId) {
                 db.updateOperation(dispatch.idempotencyKey, "failed", { result: { ...receipt, priorResult: dispatch.result }, error: "Interrupted provider outcome remains unknown; verified stopped local execution is replaced by source inspection and fresh QA, without replay" });
             db.updateOperation(assignment.idempotencyKey, "failed", { result: { ...receipt, priorResult: assignment.result }, error: "Interrupted assignment preserved for source-bound continuation; completion is not established" });
             const event = db.appendContinuityEvent({ runId, role: "host", kind: "interrupted_source_reconciled", payload: { ...receipt, dispatchIds: dispatches.map(op => op.idempotencyKey), assignmentId: assignment.idempotencyKey }, authoritativeStateRevision: db.continuityHead(runId, "run")?.authoritativeStateRevision ?? 0 });
-            db.publishContinuityCheckpoint({ runId, role: "builder", state: "current", authoritativeStateRevision: event.authoritativeStateRevision, delta: {
+            db.publishContinuityCheckpoint({ runId, role: "builder", state: "current", hostEventKind: "source-reconciliation", inputCheckpointDigests: [], authoritativeStateRevision: event.authoritativeStateRevision, delta: {
                     version: 1, decisions: [`Continue already-approved ticket ${intent.ticketId} in the SAME build from preserved source; this host reconciliation is not a successful provider turn.`],
                     constraints: ["Never replay the interrupted provider instruction or assume its side effects did not happen. Inspect current files first, implement only missing approved work, and require independent QA. Preserve all completed tickets and accepted QA.", "The predecessor session's compaction history remains unknown; use a validated fresh handoff before any new implementation."],
                     discoveries: [], completedActions: [], evidence: [`Host-observed source digest ${source.digest}; interrupted assignment ${assignment.idempotencyKey}; reconciliation ${reconciliationId}`],
@@ -384,7 +386,23 @@ export function beginBuildAssignment(projectDir, runId, ticketId, worktree, inst
     }
 }
 export function finishBuildAssignment(projectDir, assignment, result, status) {
-    let rejection = result.failure?.dispatchState === "not-sent" ? undefined : validateBuildAssignment(assignment.ticketId, status, result.text);
+    let rejection;
+    if (result.failure?.dispatchState !== "not-sent") {
+        try {
+            const response = operationResponse(result, workReportOutput);
+            if (!["completed", "blocked", "needs-input"].includes(response.result.kind))
+                throw new Error("Unconsumed intermediate assignment result");
+            if (result.structured?.state !== "candidate" || result.structured.dispatchId !== result.turnId)
+                throw new Error("Assignment receipt dispatch mismatch");
+            const nativeStatus = operationStatus(result, workReportOutput, assignment.ticketId);
+            if (nativeStatus.kind !== status.kind || status.ticket && status.ticket !== assignment.ticketId)
+                throw new Error("Assignment status disagrees with the native result");
+            status = nativeStatus;
+        }
+        catch (error) {
+            rejection = `Builder assignment has no valid native result: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
     // Source capture can fail after an external turn. Keep the response even then.
     let after;
     let sourceError;
@@ -408,12 +426,13 @@ export function finishBuildAssignment(projectDir, assignment, result, status) {
                 }
             }
             const responseDigest = db.putEvidence("qa", Buffer.from(result.rawResponse ?? result.text));
+            const structuredResponseDigest = result.structured ? db.putEvidence("qa", Buffer.from(JSON.stringify(result.structured))) : undefined;
             const cleanedResponseDigest = db.putEvidence("qa", Buffer.from(result.cleanedResponse ?? result.text));
             const providerInstructionDigest = result.providerInstruction ? db.putEvidence("qa", Buffer.from(result.providerInstruction)) : undefined;
-            db.updateOperation(assignment.operationId, result.failure?.dispatchState === "unknown" || result.isError && !result.failure?.dispatchState && status.kind === "unknown" ? "uncertain" : "confirmed", { result: { turnId: result.turnId, responseDigest, cleanedResponseDigest, providerInstructionDigest, providerMetadata: result.providerMetadata, dispatchState: result.failure?.dispatchState, status, rejection, sourceError, after: after ? retainSource(db, after) : undefined } });
+            db.updateOperation(assignment.operationId, result.failure?.dispatchState === "unknown" || result.isError && !result.failure?.dispatchState && status.kind === "unknown" ? "uncertain" : "confirmed", { result: { turnId: result.turnId, responseDigest, structuredResponseDigest, cleanedResponseDigest, providerInstructionDigest, providerMetadata: result.providerMetadata, dispatchState: result.failure?.dispatchState, status, rejection, sourceError, after: after ? retainSource(db, after) : undefined } });
             const admission = db.assertAdmittedWork(assignment.runId, assignment.ticketId);
             db.qaPreparationStore().metric(assignment.runId, assignment.ticketId, admission.requirementsDigest, `metric:builder-result:${assignment.operationId}`, "phase-observation", { phase: "builder", durationMs: Math.max(0, Date.now() - Date.parse(assignment.before.capturedAt)), costUsd: result.costAuthoritative ? result.costUsd : null, inputTokens: result.inputTokens ?? null, outputTokens: result.outputTokens ?? null });
-            db.finishGuidance(assignment.guidanceIds, "builder", { submitted: result.failure?.dispatchState === "not-sent" ? false : result.turnId ? true : undefined, receipt: result.turnId ? { turnId: result.turnId, responseDigest, providerInstructionDigest, postSourceDigest: after?.digest } : undefined, applied: !rejection && status.kind === "done" && assignment.guidanceIds.every(id => result.text.includes(id)) });
+            db.finishGuidance(assignment.guidanceIds, "builder", { submitted: result.failure?.dispatchState === "not-sent" ? false : result.turnId ? true : undefined, receipt: result.turnId ? { turnId: result.turnId, responseDigest, providerInstructionDigest, postSourceDigest: after?.digest } : undefined, applied: !rejection && status.kind === "done" });
             if (rejection || sourceError) {
                 const run = db.getRun(assignment.runId);
                 db.transition(assignment.runId, { checkpoint: "build-assignment-rejected", state: { ...run.state, assignmentConflict: { operationId: assignment.operationId, ticketId: assignment.ticketId, worktree: assignment.worktree, responseDigest, rejection, sourceError } }, event: "build_assignment_rejected", payload: { operationId: assignment.operationId, ticketId: assignment.ticketId, returnedTicketId: status.ticket, responseDigest, rejection, sourceError } });
@@ -425,7 +444,7 @@ export function finishBuildAssignment(projectDir, assignment, result, status) {
     }
     if (!rejection && !sourceError && !result.isError && status.kind === "done" && after) {
         try {
-            queueGraphMaintenance(projectDir, assignment.worktree, assignment.operationId, result.text, after.contentDigest !== assignment.before.contentDigest);
+            queueGraphMaintenance(projectDir, assignment.worktree, assignment.operationId, operationPayload(result, workReportOutput).graphMaintenance === "meaningful-indexed-change", after.contentDigest !== assignment.before.contentDigest);
         }
         catch (error) {
             console.error(`Graph maintenance deferred: ${String(error)}`);
@@ -436,7 +455,7 @@ export function finishBuildAssignment(projectDir, assignment, result, status) {
 function retainSource(db, source) {
     const staged = retainDiff(db, source.stagedDiff);
     const unstaged = retainDiff(db, source.unstagedDiff);
-    return { digest: source.digest, head: source.head, captureMode: source.captureMode, omissions: source.omissions, contentDigest: source.contentDigest, capturedAt: source.capturedAt, pathInventory: source.pathInventory,
+    return { digest: source.digest, head: source.head, captureMode: source.captureMode, omissions: source.omissions, contentDigest: source.contentDigest, capturedAt: source.capturedAt, pathInventory: source.pathInventory, fileByteLengths: source.fileByteLengths,
         stagedDiffDigest: staged.digest, stagedDiffChunks: staged.chunks, stagedDiffBytes: source.stagedDiff.length,
         unstagedDiffDigest: unstaged.digest, unstagedDiffChunks: unstaged.chunks, unstagedDiffBytes: source.unstagedDiff.length,
         untracked: source.untracked.map(file => { const evidence = retainDiff(db, file.bytes); return { path: file.path, mode: file.mode, kind: file.kind, digest: file.digest, evidenceDigest: evidence.digest, evidenceChunks: evidence.chunks, byteLength: file.bytes.length }; }) };
@@ -452,31 +471,71 @@ function retainDiff(db, bytes) {
 }
 export function captureBuildSource(worktree) {
     const head = spawnSync("git", ["-C", worktree, "rev-parse", "--verify", "HEAD"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
-    if (head.status === 0)
-        return { ...captureFrozenQaSource(worktree), captureMode: "git" };
+    if (head.status === 0) {
+        const source = captureFrozenQaSource(worktree);
+        // Length is only a hint for comparing a final prefix with the already
+        // digest-bound baseline hash. A stale length can never manufacture a match.
+        const fileByteLengths = {};
+        for (const item of source.pathInventory) {
+            if (!item.worktreeObject?.startsWith("file:"))
+                continue;
+            try {
+                const stat = lstatSync(join(worktree, item.path));
+                if (stat.isFile())
+                    fileByteLengths[item.path] = stat.size;
+            }
+            catch { /* unavailable comparison stays explicit */ }
+        }
+        return { ...source, captureMode: "git", fileByteLengths };
+    }
     if (head.error?.code !== "ENOENT" && !/not a git repository|Needed a single revision|unknown revision/.test(head.stderr ?? ""))
         throw head.error ?? new Error(`Git source identity is unavailable: ${head.stderr}`);
     const capture = () => {
         const root = resolve(worktree);
         const untracked = [];
-        const ignored = new Set([".git", ".rafi", ".foreman", "node_modules"]);
-        const visit = (directory) => {
-            for (const entry of readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-                if (ignored.has(entry.name))
+        const gitPaths = spawnSync("git", ["-C", root, "ls-files", "--others", "--exclude-standard", "-z"], { encoding: "buffer", stdio: ["ignore", "pipe", "pipe"] });
+        if (gitPaths.status === 0) {
+            for (const path of gitPaths.stdout.toString().split("\0").filter(Boolean).sort()) {
+                if (path === ".foreman" || path.startsWith(".foreman/") || path === ".rafi" || path.startsWith(".rafi/"))
                     continue;
-                const path = join(directory, entry.name);
-                if (entry.isDirectory())
-                    visit(path);
-                else if (entry.isFile() || entry.isSymbolicLink()) {
-                    const kind = entry.isSymbolicLink() ? "symlink" : "file";
-                    const bytes = kind === "symlink" ? Buffer.from(readlinkSync(path)) : readFileSync(path);
-                    untracked.push({ path: relative(root, path).replace(/\\/g, "/"), kind, bytes, mode: lstatSync(path).mode, digest: createHash("sha256").update(bytes).digest("hex") });
+                const absolute = join(root, path);
+                let stat;
+                try {
+                    stat = lstatSync(absolute);
                 }
-                else
-                    throw new Error(`Unsupported source path type: ${path}`);
+                catch {
+                    continue;
+                }
+                // Git reports an untracked nested repository as its directory. It is
+                // a separate source boundary, not a reason to recursively hash its
+                // entire checkout (MoneyTree's vendor/reference trees can be GBs).
+                if (!stat.isFile() && !stat.isSymbolicLink())
+                    continue;
+                const kind = stat.isSymbolicLink() ? "symlink" : "file";
+                const bytes = kind === "symlink" ? Buffer.from(readlinkSync(absolute)) : readFileSync(absolute);
+                untracked.push({ path, kind, bytes, mode: stat.mode, digest: createHash("sha256").update(bytes).digest("hex") });
             }
-        };
-        visit(root);
+        }
+        else {
+            const ignored = new Set([".git", ".rafi", ".foreman", "node_modules"]);
+            const visit = (directory) => {
+                for (const entry of readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+                    if (ignored.has(entry.name))
+                        continue;
+                    const path = join(directory, entry.name);
+                    if (entry.isDirectory())
+                        visit(path);
+                    else if (entry.isFile() || entry.isSymbolicLink()) {
+                        const kind = entry.isSymbolicLink() ? "symlink" : "file";
+                        const bytes = kind === "symlink" ? Buffer.from(readlinkSync(path)) : readFileSync(path);
+                        untracked.push({ path: relative(root, path).replace(/\\/g, "/"), kind, bytes, mode: lstatSync(path).mode, digest: createHash("sha256").update(bytes).digest("hex") });
+                    }
+                    else
+                        throw new Error(`Unsupported source path type: ${path}`);
+                }
+            };
+            visit(root);
+        }
         const contentDigest = createHash("sha256").update(JSON.stringify(untracked.map(({ bytes: _, ...identity }) => identity))).digest("hex");
         return { digest: contentDigest, head: "unavailable", captureMode: "filesystem", omissions: ["Git baseline/diff unavailable: project is not a repository or has no first commit"], contentDigest, capturedAt: new Date().toISOString(),
             pathInventory: untracked.map(file => ({ path: file.path, staged: [], unstaged: [], untracked: { kind: file.kind, mode: file.mode, digest: file.digest } })), untracked, stagedDiff: Buffer.alloc(0), unstagedDiff: Buffer.alloc(0) };

package/dist/buildInterventions.d.ts

@@ -72,7 +72,7 @@ export declare function verifyBuilderGuidance(db: Database.Database, ids: string
     certificateId: string;
     sourceStateDigest: string;
     reviewBasisDigest: string;
-}, response: string, turnReceiptDigest: string): void;
+}, response: string | readonly string[], turnReceiptDigest: string): void;
 /** Called only inside the owning process's existing dispatch transaction. */
 export declare function reserveGuidance(db: Database.Database, runId: string, workId: string, recipient: InstructionRecipient, operationId: string, sourceDigest: string, instructionText: string, reserve?: boolean): {
     text: string;
@@ -87,4 +87,4 @@ export declare function verifyGuidance(db: Database.Database, ids: string[], cer
     certificateId: string;
     sourceStateDigest: string;
     reviewBasisDigest: string;
-}, response: string): void;
+}, response: string | readonly string[]): void;

package/dist/buildInterventions.js

@@ -4,6 +4,8 @@ import { join } from "node:path";
 import { realpathSync as realpath } from "node:fs";
 import { validateManagerActionRequestV1 } from "rafi-spec";
 import { registerHandbackWriter } from "./qaHandbackMigration.js";
+import { registerQaGraphJournalWriter } from "./qaDeliveryJournal.js";
+import { assertStructuredCutoverComplete, STRUCTURED_CUTOVER_REASON } from "./structuredCutover.js";
 import { assertAdmittedWork } from "./buildWorkAdmission.js";
 export class BuildControlBoundary extends Error {
 }
@@ -81,6 +83,11 @@ export class BuildInterventionControl {
         this.db = new Database(join(projectDir, ".rafi/recovery.sqlite3"), { fileMustExist: true });
         try {
             registerHandbackWriter(this.db);
+            registerQaGraphJournalWriter(this.db);
+            assertStructuredCutoverComplete(this.db);
+            const run = this.db.prepare("SELECT legacy,checkpoint,state_json FROM workflow_runs WHERE run_id=?").get(runId);
+            if (!run || run.legacy || run.checkpoint === STRUCTURED_CUTOVER_REASON || JSON.parse(run.state_json).structuredCommunicationCutover)
+                throw new Error("Cutover workflow cannot receive Manager controls");
             if (this.db.pragma("user_version", { simple: true }) !== 4)
                 throw new Error("Manager controls require the work-admission upgrade");
             const project = this.db.prepare("SELECT canonical_root FROM build_project_identity").get();
@@ -259,10 +266,10 @@ export function assertFinalizationControls(db, runId, workId) {
 export function builderVerificationContext(db, runId, workId, sourceDigest) {
     const records = db.prepare("SELECT instruction_id FROM build_instructions WHERE run_id=? AND work_id=? ORDER BY sequence").all(runId, workId).map(row => instruction(db, row.instruction_id));
     const eligible = records.filter(record => (record.request.action === "guide_builder" || record.request.action === "supersede" && !record.deliveries.some(delivery => delivery.recipient === "qa")) && record.deliveries.some(delivery => delivery.recipient === "builder" && ["acknowledged", "applied"].includes(delivery.state) && delivery.receipt?.postSourceDigest === sourceDigest));
-    return { ids: eligible.map(record => record.instructionId), text: eligible.length ? "\n\nBuilder guidance awaiting independent verification on this exact source:\n" + eligible.map(record => `Instruction ${record.instructionId}: ${record.request.text}`).join("\n") + "\nOnly for a relevant result independently established with supporting evidence, emit MANAGER_INSTRUCTION_VERIFIED: <instruction ID>. A general pass alone is insufficient." : "" };
+    return { ids: eligible.map(record => record.instructionId), text: eligible.length ? "\n\nBuilder guidance awaiting independent verification on this exact source:\n" + eligible.map(record => `Instruction ${record.instructionId}: ${record.request.text}`).join("\n") + "\nOnly for a relevant result independently established with supporting evidence, include the exact instruction ID in the native qa-verdict payload.verifiedInstructionIds array. A general pass alone is insufficient." : "" };
 }
 export function verifyBuilderGuidance(db, ids, certificate, response, turnReceiptDigest) {
-    const verified = new Set([...response.matchAll(/^MANAGER_INSTRUCTION_VERIFIED:\s*([A-Za-z0-9_.:-]+)\s*$/gm)].map(match => match[1]));
+    const verified = new Set(typeof response === "string" ? [...response.matchAll(/^MANAGER_INSTRUCTION_VERIFIED:\s*([A-Za-z0-9_.:-]+)\s*$/gm)].map(match => match[1]) : response);
     for (const id of ids) {
         if (!verified.has(id))
             continue;
@@ -298,7 +305,7 @@ export function reserveGuidance(db, runId, workId, recipient, operationId, sourc
                 throw new BuildControlBoundary("Both-agent guidance is waiting for Builder's scoped response before a fresh QA review");
             selected.push(record);
         }
-        const text = instructionText + (selected.length ? "\n\nAuthorized one-use Manager guidance (mandatory requirements and findings still apply):\n" + selected.map(record => `Instruction ${record.instructionId} (${record.textDigest}):\n${record.request.text}`).join("\n\n") + (recipient === "qa" ? "\nFor each instruction whose relevant result you independently established on this source, include MANAGER_INSTRUCTION_VERIFIED: <instruction ID> with the supporting verification evidence. A general passing review alone does not verify an unrelated instruction." : "\nReport each instruction ID whose requested action you applied, with evidence; delivery alone is not independent verification.") : "");
+        const text = instructionText + (selected.length ? "\n\nAuthorized one-use Manager guidance (mandatory requirements and findings still apply):\n" + selected.map(record => `Instruction ${record.instructionId} (${record.textDigest}):\n${record.request.text}`).join("\n\n") + (recipient === "qa" ? "\nFor each instruction whose relevant result you independently established on this source, include the exact instruction ID in payload.verifiedInstructionIds with the supporting verification evidence. A general passing review alone does not verify an unrelated instruction." : "\nReport each instruction ID whose requested action you applied, with evidence; delivery alone is not independent verification.") : "");
         if (reserve)
             for (const record of selected)
                 setDelivery(db, record.instructionId, { recipient, state: "reserved", operationId: `${operationId}:${record.instructionId}:${recipient}`, sourceDigest, instructionDigest: hash(text) });
@@ -315,7 +322,7 @@ export function finishGuidance(db, ids, recipient, result) {
     } }).immediate();
 }
 export function verifyGuidance(db, ids, certificate, response) {
-    const verified = new Set([...response.matchAll(/^MANAGER_INSTRUCTION_VERIFIED:\s*([A-Za-z0-9_.:-]+)\s*$/gm)].map(match => match[1]));
+    const verified = new Set(typeof response === "string" ? [...response.matchAll(/^MANAGER_INSTRUCTION_VERIFIED:\s*([A-Za-z0-9_.:-]+)\s*$/gm)].map(match => match[1]) : response);
     for (const id of ids) {
         if (!verified.has(id))
             continue;

package/dist/buildLaunchGate.js

@@ -1,3 +1,4 @@
+import { parseHostIpc } from "rafi-spec";
 /** Minimal pre-CLI child. No providers or mutable workflow code before acknowledgement. */
 import { WorkflowDb } from "./workflowDb.js";
 import { pathToFileURL } from "node:url";
@@ -14,7 +15,7 @@ finally {
 await new Promise((resolve, reject) => {
     const timeout = setTimeout(() => finish(new Error("Resume startup acknowledgement timed out")), 10_000);
     const disconnected = () => finish(new Error("Resume launcher exited before acknowledgement"));
-    const message = (value) => { if (value === "rafi-launch-ack")
+    const message = (value) => { const ack = parseHostIpc(value); if (ack?.kind === "rafi-launch-ack" && ack.token === token && ack.pid === process.pid)
         finish(); };
     function finish(error) {
         clearTimeout(timeout);
@@ -27,7 +28,7 @@ await new Promise((resolve, reject) => {
     }
     process.once("disconnect", disconnected);
     process.on("message", message);
-    process.send({ kind: "rafi-launch-registered", token });
+    process.send({ version: 1, kind: "rafi-launch-registered", token, pid: process.pid });
 });
 // The durable claim still validates the token atomically after acknowledgement.
 if (!process.env.RAFI_BUILD_WORKER_RUN)

package/dist/builderGuidanceFollowup.js

@@ -1,9 +1,11 @@
 import { collectBuilderContractCoverage } from "./qaBuilderCoverage.js";
+import { observeHostBuilderTests } from "./qaBuilderEvidence.js";
 import { maintainGraphTask } from "./graph/boundary.js";
 import { ensureBuilderContract } from "./qaBuildGate.js";
 import { graphContext, sendGraphTurn } from "./graph/turn.js";
-import { beginBuildAssignment, finishBuildAssignment } from "./buildAssignment.js";
-import { parseStepStatus } from "./foreman.js";
+import { beginBuildAssignment, captureBuildSource, finishBuildAssignment } from "./buildAssignment.js";
+import { workReportOutput } from "rafi-spec";
+import { nativePolicy, operationInstruction, operationStatus } from "./structuredOperation.js";
 /** One journaled mutation shared by current-branch and isolated-worktree resume. */
 export async function deliverBuilderGuidanceFollowup(scope, instruction, followup, host) {
     try {
@@ -14,17 +16,26 @@ export async function deliverBuilderGuidanceFollowup(scope, instruction, followu
         instruction += "\n" + await ensureBuilderContract(scope.projectDir, scope.runId, scope.ticketId, scope.worktree, adapter);
         const assignment = beginBuildAssignment(scope.projectDir, scope.runId, scope.ticketId, scope.worktree, instruction, followup, adapter);
         // The handback policy prevents provider wrappers from retrying this mutation.
-        const result = await sendGraphTurn(adapter, assignment.instruction, graphContext(scope.projectDir, scope.worktree, "manager-guidance", assignment.instruction, { logicalTaskId: assignment.operationId, operationId: assignment.operationId, runId: scope.runId, workId: scope.ticketId }), { handback: true, logicalActionId: assignment.operationId });
-        const status = parseStepStatus(result.text);
+        const hostToolObservations = [];
+        const initialSourceDigest = captureBuildSource(scope.worktree).digest;
+        const stopHostObservation = observeHostBuilderTests(adapter, scope.worktree, hostToolObservations);
+        let result;
+        try {
+            result = await sendGraphTurn(adapter, `${assignment.instruction}\n${operationInstruction(workReportOutput)}`, graphContext(scope.projectDir, scope.worktree, "manager-guidance", assignment.instruction, { logicalTaskId: assignment.operationId, operationId: assignment.operationId, runId: scope.runId, workId: scope.ticketId }), nativePolicy(workReportOutput, { handback: true, logicalActionId: assignment.operationId, journalRunId: scope.runId }));
+        }
+        finally {
+            stopHostObservation();
+        }
+        const status = operationStatus(result, workReportOutput, scope.ticketId);
         if (!result.isError && !result.failure && status.kind === "done")
-            await collectBuilderContractCoverage(scope.projectDir, scope.runId, scope.ticketId, scope.worktree, adapter, assignment.operationId, assignment.instruction, result);
+            await collectBuilderContractCoverage(scope.projectDir, scope.runId, scope.ticketId, scope.worktree, adapter, assignment.operationId, assignment.instruction, result, hostToolObservations, initialSourceDigest);
         const rejection = finishBuildAssignment(scope.projectDir, assignment, result, status);
         if (!rejection && !result.isError && status.kind === "done")
             await maintainGraphTask(scope.projectDir, scope.worktree, assignment.operationId, adapter).catch(() => undefined);
         await host.completed?.(assignment.operationId, adapter);
         if (rejection || result.isError || result.failure || status.kind !== "done" || !result.turnId)
             return { ok: false, detail: rejection ?? result.failure?.diagnostics ?? `Builder follow-up stopped with ${status.kind}; reconcile its result before continuing`, response: result.text };
-        return { ok: true, response: result.text, summary: status.summary ?? "Builder applied waiting guidance", providerTurnId: result.turnId };
+        return { ok: true, outcome: "remediation-reported", response: result.text, summary: status.summary ?? "Builder applied waiting guidance", providerTurnId: result.turnId };
     }
     catch (error) {
         // A thrown submission leaves the assignment in progress. The existing

package/dist/cli/manager.js

@@ -1,5 +1,7 @@
+import { managerOutput } from "rafi-spec";
+import { nativePolicy, operationInstruction, operationResponse } from "../structuredOperation.js";
 import { dispatchWithGraphAccess } from "../graph/session.js";
-import { createManagerGraphEvidence, parseManagerGraphRequest } from "../graph/manager.js";
+import { createManagerGraphEvidence } from "../graph/manager.js";
 import { prepareOwnershipRepair, repairOwnership } from "../buildOwnershipRepair.js";
 import { BuildInterventionControl, parseManagerAction } from "../buildInterventions.js";
 import { randomUUID } from "node:crypto";
@@ -9,14 +11,14 @@ import { resolve } from "node:path";
 import { join } from "node:path";
 import { mkdtempSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { ManagerEvidenceService, parseManagerEvidenceRequestV2 } from "../managerEvidence.js";
+import { ManagerEvidenceService } from "../managerEvidence.js";
 import { buildManagerEvidencePacketV2 } from "../managerPacket.js";
 import { Command } from "commander";
 import { createRoleBuilder, readOnlyPermissionConfig } from "../agentRun.js";
 import { Log } from "../log.js";
 import { buildManagerEvidencePacket, buildManagerProjectPacket } from "../managerPacket.js";
 import { ManagerSessionRecorder } from "../observability.js";
-import { collectManagerProjectDiagnostics, executeManagerEvidenceRequest, MANAGER_LOOKUP_MAX_ROUNDS, parseManagerEvidenceRequest, resolveManagerQuestionRuns } from "../projectDiagnostics.js";
+import { collectManagerProjectDiagnostics, executeManagerEvidenceRequest, MANAGER_LOOKUP_MAX_ROUNDS, resolveManagerQuestionRuns } from "../projectDiagnostics.js";
 import { accent, sanitizeTerminalText } from "../terminalStyle.js";
 export function buildManagerCommand(options = {}) {
     return new Command("manager")
@@ -87,11 +89,16 @@ export async function runManager(projectDir, options) {
             const packet = buildManagerProjectPacket(report, question, packetState, referencedRunIds);
             packetState = packet.state;
             const graphEvidence = createManagerGraphEvidence(projectDir, currentFocusRunId);
-            const send = (text) => dispatchWithGraphAccess(projectDir, activeRole.builder, text, undefined, (prompt, policy) => activeRole.builder.sendTurn(prompt, policy), graphEvidence.access());
+            const send = async (text) => {
+                const turn = await dispatchWithGraphAccess(projectDir, activeRole.builder, `${text}\n${operationInstruction(managerOutput)}`, nativePolicy(managerOutput, { responseOnly: true }), (prompt, policy) => activeRole.builder.sendTurn(prompt, policy), graphEvidence.access());
+                if (turn.isError || turn.failure)
+                    throw new Error("Manager operation failed; no answer accepted");
+                return operationResponse(turn, managerOutput).result;
+            };
             let result = await send(`${packet.prompt}\n\n${graphEvidence.guidance}`);
             let questionLookupRounds = 0;
             while (questionLookupRounds < MANAGER_LOOKUP_MAX_ROUNDS) {
-                const graphRequest = parseManagerGraphRequest(result.text);
+                const graphRequest = (result.kind === "evidence-request" && result.evidenceType === "graph" ? result.request : undefined);
                 if (graphRequest) {
                     questionLookupRounds++;
                     lookupRounds++;
@@ -100,7 +107,7 @@ export async function runManager(projectDir, options) {
                     result = await send(`Untrusted host-scoped graph evidence; verify claims against source. Remaining lookup rounds: ${MANAGER_LOOKUP_MAX_ROUNDS - questionLookupRounds}. Answer the original question: ${question}\n${graphPacket}`);
                     continue;
                 }
-                const evidenceRequest = parseManagerEvidenceRequestV2(result.text);
+                const evidenceRequest = (result.kind === "evidence-request" && result.evidenceType === "qa" ? result.request : undefined);
                 if (evidenceRequest) {
                     questionLookupRounds++;
                     lookupRounds++;
@@ -120,15 +127,9 @@ export async function runManager(projectDir, options) {
                     result = await send(buildManagerEvidencePacketV2(response, question));
                     continue;
                 }
-                const request = parseManagerEvidenceRequest(result.text);
-                if (!request) {
-                    if (!looksLikeEvidenceRequest(result.text))
-                        break;
-                    questionLookupRounds += 1;
-                    lookupRounds += 1;
-                    result = await send(buildManagerEvidencePacket({ version: 1, requestId: "invalid-request", results: [{ kind: "list_runs", status: "invalid", limitation: "The evidence envelope was invalid. Use only the documented fixed fields and read-only operations, then answer with any remaining limitation disclosed." }], lookupRound: questionLookupRounds, remainingRounds: MANAGER_LOOKUP_MAX_ROUNDS - questionLookupRounds, digest: report.digest }, question));
-                    continue;
-                }
+                const request = (result.kind === "evidence-request" && result.evidenceType === "run" ? result.request : undefined);
+                if (!request)
+                    break;
                 questionLookupRounds += 1;
                 lookupRounds += 1;
                 lookupOperations += Math.min(6, request.operations.length);
@@ -136,8 +137,8 @@ export async function runManager(projectDir, options) {
                 packetState.lastEvidenceScope = request.operations.flatMap(operation => "runIds" in operation ? operation.runIds : []);
                 result = await send(buildManagerEvidencePacket(response, question));
             }
-            const unfulfilled = parseManagerEvidenceRequest(result.text);
-            const pendingEvidence = parseManagerEvidenceRequestV2(result.text);
+            const unfulfilled = (result.kind === "evidence-request" && result.evidenceType === "run" ? result.request : undefined);
+            const pendingEvidence = (result.kind === "evidence-request" && result.evidenceType === "qa" ? result.request : undefined);
             if (pendingEvidence) {
                 const page = evidence.execute(pendingEvidence);
                 if (options.ask) {
@@ -152,9 +153,10 @@ export async function runManager(projectDir, options) {
                 result = await send(buildManagerEvidencePacket(limitation, question));
             }
             if (!pendingEvidence) {
-                const answer = parseManagerEvidenceRequest(result.text) || parseManagerGraphRequest(result.text) || looksLikeEvidenceRequest(result.text)
-                    ? "Manager could not complete an answer within the bounded evidence lookup budget. Continue with /qa-attempts <run> <ticket> or /qa-report <run> <ticket> <attempt>."
-                    : result.text.trim();
+                const answer = result.kind === "completed" ? result.payload.answer
+                    : result.kind === "blocked" ? `${result.reason} Next: ${result.nextAction}`
+                        : result.kind === "needs-input" ? result.question
+                            : "Manager could not complete an answer within the bounded evidence lookup budget. Continue with /qa-attempts <run> <ticket> or /qa-report <run> <ticket> <attempt>.";
                 // One-shot evidence requests can mix JSON with prose, so add the label
                 // only when this answer stream has not emitted machine-readable data.
                 // Model-provided text is sanitized only for display, never for storage.

package/dist/cli/start.js

@@ -1,3 +1,4 @@
+import { nativePolicy, operationInstruction, operationPayload, structuredTurnErrorMessage } from "../structuredOperation.js";
 import { finalQaRoleInstructions, resolveEffectiveQaConfiguration } from "../qaEffectiveConfig.js";
 import { activateQaRecoveryBuilder } from "../qaBuilderActivation.js";
 import { graphContext, sendGraphTurn } from "../graph/turn.js";
@@ -11,7 +12,7 @@ import { captureFrozenQaSource } from "../qaSnapshot.js";
 import { finishStartAdmission, superviseStart, supervisedRunId } from "../supervisedStart.js";
 import { assertBuildAssignmentReconciled, isInterruptedBuilderRecovery, assertInterruptedSourceSnapshot } from "../buildAssignment.js";
 import { durableHumanDecision, HumanDecisionRequired, HumanDecisionCancelled, servicePendingHumanDecisions } from "../humanDecision.js";
-import { requiresBuildApproval, buildScopeRevision, createBuildApprovalGate, validatePlanApprovalBinding } from "../buildApproval.js";
+import { requiresBuildApproval, buildScopeRevision, createBuildApprovalGate, validatePlanApprovalBinding, validateFrozenWorkApprovalBinding } from "../buildApproval.js";
 import { Command, Option } from "commander";
 import { accent, error, sanitizeTerminalText, success, warning } from "../terminalStyle.js";
 import { resolve, join, relative } from "node:path";
@@ -34,7 +35,7 @@ import { isTicketsInitialized, loadTicketsConfig, resolveTicketPaths } from "../
 import { hasRollbackOrMitigationPlan, loadTickets } from "../tickets/ticketLoader.js";
 import { StateDb } from "../tickets/stateDb.js";
 import { ticketDefinitionDigest } from "../tickets/riskWaivers.js";
-import { applySharedDeliveryBranch, applySizeBranchPolicy, buildBranchAuditInstruction, buildBranchPlan, parseAuditDependencies } from "../branch/planner.js";
+import { applySharedDeliveryBranch, applySizeBranchPolicy, buildBranchAuditInstruction, buildBranchPlan } from "../branch/planner.js";
 import { currentGitRef, ensureCleanBaseWorktree, generatedTrackerDirtyPaths } from "../branch/git.js";
 import { captureDirtyBaseline } from "../branch/dirtyBaseline.js";
 import { formatGitHubFailure, preflightGh } from "../branch/github.js";
@@ -42,7 +43,7 @@ import { preflightGlab } from "../branch/gitlab.js";
 import { readDeliveryUnitSession, runBranchPlan } from "../branch/runner.js";
 import { branchPlanLogMetadata, presentBranchPlan } from "../branch/presentation.js";
 import { branchTicketScopeProgress, buildRunSessionBinding, checkpointBuildRun, completeBuildRun, createBuildRun, currentBranchRecoveryTicket, currentBranchTicketProgress, recoveryExecutionTickets, finishBranchTicketScope, finishRecoveredTicketScope, heartbeatBuildRun, persistBuildSession, persistCurrentBuildSession, projectBuildRecovery, readBuildRuns, releaseBuildLease, resumeBuildRun } from "../buildRuns.js";
-import { parseProviderContract, qaRemediationProposalV1Schema } from "rafi-spec";
+import { branchAuditOutput, plannerRemediationOutput } from "rafi-spec";
 import { parse as parseYaml } from "yaml";
 import { findResumableBranchSessions, formatBranchContinueCommand, formatBranchSummaryFollowupCommands, } from "../branch/resume.js";
 import { detectGitProvider, loadTicketSetupConfig } from "../tickets/setupConfig.js";
@@ -699,9 +700,11 @@ export function buildStartCommand(options = {}) {
             // recovery remains fail-closed on an exact current-plan approval.
             if (recoveryRecord && autoApprovePlanUpdates && recoveryTickets.length > 0) {
                 const decision = recoveryRecord.recoveryDecision;
-                if (!decision?.planApproval)
+                if (!decision?.planApproval && !decision?.frozenWorkApproval)
                     fail("saved --yes approval has no exact plan binding; rerun rafi build:resume --yes to approve the current plan");
-                const approvalCheck = validatePlanApprovalBinding(cwd, recoveryTickets, decision.planApproval);
+                const approvalCheck = decision.frozenWorkApproval
+                    ? validateFrozenWorkApprovalBinding(cwd, recoveryRecord.runId, recoveryTickets, decision.frozenWorkApproval)
+                    : validatePlanApprovalBinding(cwd, recoveryTickets, decision.planApproval);
                 if (!approvalCheck.valid)
                     fail(`saved --yes approval is stale (${approvalCheck.reason}); rerun rafi build:resume --yes before provider work`);
             }
@@ -1305,7 +1308,6 @@ export function buildStartCommand(options = {}) {
                     try {
                         const revision = countDb.continuityHead(runId, "builder")?.authoritativeStateRevision ?? settings.settings_revision;
                         countDb.appendContinuityEvent({ runId, role: "builder", kind: "builder_requested_handoff_delta", payload: request.delta, authoritativeStateRevision: revision });
-                        countDb.publishContinuityCheckpoint({ runId, role: "builder", delta: request.delta, authoritativeStateRevision: revision });
                         compactionCount = countDb.successfulCompactionCount(runId, "builder", predecessor.sessionRef?.() ?? sessionId);
                     }
                     finally {
@@ -1318,6 +1320,7 @@ export function buildStartCommand(options = {}) {
                         predecessorSessionId: sessionId,
                         predecessorSessionRef: predecessor.sessionRef?.(),
                         requestedByBuilder: true,
+                        predecessorDispatchId: request.predecessorDispatchId,
                         roleState: {
                             ...request.roleState,
                             frozenActionDigest: createHash("sha256").update(frozenAction).digest("hex"),
@@ -1334,7 +1337,8 @@ export function buildStartCommand(options = {}) {
                         resources: [{ label: "frozen-action", content: frozenAction, authoritative: true }],
                     }, (_handoff, runtime) => createBuilderForSettings(builderCwd, settingsForRequestedRuntime(effectiveSettings, runtime)), handoffRecoveryOptions("builder"));
                     log.write("handoff-transfer", {
-                        requestedByBuilder: true, reason: request.reason, generation: transfer.manifest.generation,
+                        requestedByBuilder: true,
+                        predecessorDispatchId: request.predecessorDispatchId, reason: request.reason, generation: transfer.manifest.generation,
                         predecessorSessionId: transfer.manifest.predecessorSessionId, successorSessionId: transfer.successorSessionId,
                         acceptanceCheckpointDigest: transfer.acceptanceCheckpointDigest,
                     });
@@ -2027,10 +2031,13 @@ export function buildStartCommand(options = {}) {
                     try {
                         auditBuilder = await createBuilder(cwd);
                         auditViewer = printEvents(auditBuilder.events());
-                        const audit = await sendGraphTurn(auditBuilder, buildBranchAuditInstruction(plan.nodes.map((node) => node.ticket)), graphContext(cwd, auditBuilder.sessionRef?.()?.cwd ?? cwd, "branch-dependency-audit", plan.nodes.map(node => node.ticket.id).join(" ")), { purpose: "planning" });
+                        const audit = await sendGraphTurn(auditBuilder, `${buildBranchAuditInstruction(plan.nodes.map((node) => node.ticket))}\n${operationInstruction(branchAuditOutput)}`, graphContext(cwd, auditBuilder.sessionRef?.()?.cwd ?? cwd, "branch-dependency-audit", plan.nodes.map(node => node.ticket.id).join(" ")), nativePolicy(branchAuditOutput, { purpose: "planning", journalRunId: auditRunId }));
                         if (audit.isError)
-                            throw new Error(audit.text);
-                        const auditDependencies = parseAuditDependencies(audit.text);
+                            throw new Error(structuredTurnErrorMessage(audit, "Branch dependency audit"));
+                        const auditDependencies = operationPayload(audit, branchAuditOutput).dependencies;
+                        const selectedIds = new Set(plan.nodes.map(node => node.ticket.id));
+                        if (auditDependencies.some(dep => dep.ticket === dep.dependsOn || !selectedIds.has(dep.ticket) || !selectedIds.has(dep.dependsOn)))
+                            throw new Error("Branch audit returned a foreign or self dependency");
                         plan = buildBranchPlan(tickets, states, {
                             steps,
                             baseRef: opts.base ?? loadTicketSetupConfig(cwd)?.build.base_branch ?? currentGitRef(cwd),
@@ -3146,8 +3153,7 @@ export function createQaNonconvergenceHandler(projectDir, noninteractive, planne
                 `User discussion: ${String(discussion)}`,
                 `Complete QA history:\n${JSON.stringify(context.history, null, 2)}`,
                 `${diffTruncated ? "Builder diff (TRUNCATED at 128 KiB; inspect the actual worktree before relying on it)" : "Full Builder diff"}:\n${diff || "(no tracked diff)"}`,
-                "Return RAFI_QA_REMEDIATION_START, then one JSON object {\"summary\":\"...\",\"fix_instructions\":[\"...\"]}, then RAFI_QA_REMEDIATION_END.",
-                "End with STEP_STATUS: plan_complete | summary=\"QA remediation proposed\"",
+                "Submit the native planner-remediation payload with summary and fix_instructions.",
             ].join("\n\n");
             let resumeSessionId;
             let revision = 0;
@@ -3155,24 +3161,14 @@ export function createQaNonconvergenceHandler(projectDir, noninteractive, planne
                 revision++;
                 const proposalDigest = createHash("sha256").update(JSON.stringify([scope, round, revision, instruction, planner, captureFrozenQaSource(context.builderWorktree).digest])).digest("hex");
                 const run = await durableReadOnlyProposal({ projectDir, runId, ticketId: context.ticket.id, digest: proposalDigest, operation: () => runRoleInstruction({
-                        projectDir, role: "planner", instruction, label: "QA Planner remediation", agent: planner?.make,
+                        projectDir, role: "planner", instruction, output: plannerRemediationOutput, label: "QA Planner remediation", agent: planner?.make,
                         model: explicitDefaultValue(planner?.model), effort: explicitEffort(planner?.reasoning), fast: planner?.fast,
                         resumeSessionId, permissionConfig: readOnlyPermissionConfig(), sandboxMode: "read-only",
                         logPath: makeRoleLogPath(projectDir, "qa-remediation"), logEvent: "rafi-plan",
                     }) });
-                if (run.turn.result.isError || run.turn.status.kind !== "plan_complete")
+                if (run.turn.result.isError || run.turn.status.kind !== "done")
                     throw new Error(`Planner remediation failed: ${run.turn.status.error ?? run.turn.result.text.slice(0, 500)}`);
-                const match = /RAFI_QA_REMEDIATION_START\s*([\s\S]*?)\s*RAFI_QA_REMEDIATION_END/.exec(run.turn.result.text);
-                if (!match)
-                    throw new Error("Planner remediation did not return the required structured proposal");
-                let parsed;
-                try {
-                    parsed = JSON.parse(match[1].replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, ""));
-                }
-                catch (error) {
-                    throw new Error(`Planner remediation proposal is invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
-                }
-                const proposal = parseProviderContract(qaRemediationProposalV1Schema, parsed, "RAFI_QA_REMEDIATION");
+                const proposal = operationPayload(run.turn.result, plannerRemediationOutput);
                 console.log(`\nPlanner remediation: ${proposal.summary}\n${proposal.fix_instructions.map((item) => `- ${item}`).join("\n")}`);
                 const decision = await ask(`QA remediation approval ${revision}: ${JSON.stringify(proposal)}`, [{ id: "approve", label: "Approve" }, { id: "revise", label: "Revise" }, { id: "cancel", label: "Return to choices" }], () => select({ message: "Use this remediation for a new Builder fix session?", options: [
                         { value: "approve", label: "Approve (Recommended)" }, { value: "revise", label: "Discuss/revise" }, { value: "cancel", label: "Cancel and return to choices" },
@@ -3185,7 +3181,7 @@ export function createQaNonconvergenceHandler(projectDir, noninteractive, planne
                 if (isCancel(feedback))
                     break;
                 resumeSessionId = run.sessionId;
-                instruction = `Revise the complete QA remediation proposal using this feedback: ${String(feedback)}. Keep the exact structured envelope and final plan_complete marker.`;
+                instruction = `Revise the complete QA remediation proposal using this feedback: ${String(feedback)}. Use the native planner-remediation contract.`;
             }
         }
     };

package/dist/cli/tickets.d.ts

@@ -1,17 +1,10 @@
 import { Command } from "commander";
 import type { StructuredPlanV1 } from "rafi-spec";
 import { Log } from "../log.js";
-import { type StepStatus } from "../foreman.js";
 import type { EffortLevel } from "../adapters/types.js";
 import { type RoleBuilderOptions } from "../agentRun.js";
 import type { TicketsConfig } from "../tickets/config.js";
 import { type TicketPopulateRuntimeMode, type TicketSourceConfig, type TicketsSetupConfig } from "../tickets/setupConfig.js";
-/**
- * Ticket Maker may append an explanatory note after its machine envelope.
- * Preserve a schema-valid proposal before Foreman's strict generic marker
- * repair path replaces the response with a status-only correction.
- */
-export declare function acceptTicketPopulationCompletion(text: string): StepStatus | undefined;
 /** Commander preserves comma-delimited values as one argument; accept both documented forms. */
 export declare function normalizeRiskWaiverTicketIds(values: readonly string[] | undefined): string[];
 /** Record an explicit, definition-bound exception for existing risk tickets. */