ai-foreman 1.7.20 → 1.7.21

package/dist/continuity.js

@@ -1,3 +1,4 @@
+import { dispatchWithGraphAccess, withGraphSessionAccess } from "./graph/session.js";
 import { localBuildAuthority } from "./buildAdmission.js";
 import { randomUUID, createHash } from "node:crypto";
 import { BuilderEventQueue } from "./activity.js";
@@ -109,6 +110,11 @@ export function continuityInstruction(role) {
 export class ContinuityAdapter {
     options;
     adapter;
+    contractCapabilities() { return this.adapter.contractCapabilities?.() ?? { sameSessionAcceptance: false, nativeCompactionBarrier: false }; }
+    contractEnforcing = false;
+    enableContractEnforcement() { this.contractEnforcing = true; this.adapter.enableContractEnforcement?.(); }
+    contractCompactionSequence() { return this.adapter.contractCompactionSequence?.() ?? 0; }
+    acceptContractDelivery(sequence) { this.adapter.acceptContractDelivery?.(sequence); }
     queue = new BuilderEventQueue();
     sourcePump;
     recoveryLeasePending;
@@ -168,6 +174,9 @@ export class ContinuityAdapter {
     }
     get agent() { return this.adapter.agent; }
     async sendTurn(instruction, policy) {
+        return withGraphSessionAccess(this.options.projectDir, this.adapter, () => this.sendTurnOwned(instruction, policy));
+    }
+    async sendTurnOwned(instruction, policy) {
         const db = new WorkflowDb(this.options.projectDir);
         try {
             db.appendContinuityEvent({ runId: this.options.runId, role: "host", kind: "turn_started", payload: { role: this.options.role, instructionDigest: sha(instruction), instructionBytes: Buffer.byteLength(instruction) }, authoritativeStateRevision: this.revision() });
@@ -202,7 +211,7 @@ export class ContinuityAdapter {
                 journal.updateOperation(dispatchId, "in_progress");
             });
             try {
-                original = await this.adapter.sendTurn(providerInstruction, policy);
+                original = await dispatchWithGraphAccess(this.options.projectDir, this.adapter, providerInstruction, policy, (text, p) => this.adapter.sendTurn(text, p));
             }
             catch (error) {
                 journal.updateOperation(dispatchId, "uncertain", { error: String(error) });
@@ -253,7 +262,7 @@ export class ContinuityAdapter {
                 return this.sendTurn([
                     "Continue the frozen action after the accepted Rafi handoff. Do not repeat completed side effects.",
                     instruction,
-                ].join("\n\n"));
+                ].join("\n\n"), policy);
             }
             return { ...original, text: parsed.cleanText, hostInstruction: instruction, providerInstruction: original.providerInstruction ?? providerInstruction,
                 rawResponse: original.rawResponse ?? original.text, cleanedResponse: parsed.cleanText };
@@ -280,12 +289,12 @@ export class ContinuityAdapter {
         finally {
             budget.close();
         }
-        const repair = await this.adapter.sendTurn([
+        const repair = await dispatchWithGraphAccess(this.options.projectDir, this.adapter, [
             "Continuity protocol repair only. Do not run tools, repeat work, or change files.",
             `Your prior turn's continuity record was invalid: ${parsed.error?.problems.join("; ")}.`,
             continuityInstruction(),
             "Return only the continuity record.",
-        ].join("\n"), { ...policy, responseOnly: true });
+        ].join("\n"), { ...policy, purpose: "response-repair", responseOnly: true }, (text, p) => this.adapter.sendTurn(text, p));
         const repaired = parseContinuityDelta(repair.text);
         if (repaired.delta && !repair.isError && !repair.failure) {
             this.publish(repaired.delta, "turn_completed_after_repair", original);
@@ -293,7 +302,7 @@ export class ContinuityAdapter {
             const successor = await this.options.handleHandoffRequest?.(original.text, this.adapter, instruction);
             if (successor && successor !== this.adapter) {
                 await this.adoptValidatedSuccessor(successor);
-                return this.sendTurn(["Continue the frozen action after the accepted Rafi handoff. Do not repeat completed side effects.", instruction].join("\n\n"));
+                return this.sendTurn(["Continue the frozen action after the accepted Rafi handoff. Do not repeat completed side effects.", instruction].join("\n\n"), policy);
             }
             return { ...original, text: parsed.cleanText, hostInstruction: instruction, providerInstruction: original.providerInstruction ?? providerInstruction,
                 rawResponse: original.rawResponse ?? original.text, cleanedResponse: parsed.cleanText };
@@ -330,7 +339,7 @@ export class ContinuityAdapter {
         if (!this.options.createSuccessor)
             throw new ContinuityRecoveryRequiredError(this.options.runId, this.options.role, "continuity repair failed in the original session and no validated successor is configured");
         const successor = await this.options.createSuccessor(handoff);
-        const accepted = await successor.sendTurn(`${handoff}\n\nReply with HANDOFF_ACCEPTED on the first line, then ${continuityInstruction()}`);
+        const accepted = await dispatchWithGraphAccess(this.options.projectDir, successor, `${handoff}\n\nReply with HANDOFF_ACCEPTED on the first line, then ${continuityInstruction()}`, { purpose: "contract-acceptance", responseOnly: true }, (text, p) => successor.sendTurn(text, p));
         const successorDelta = parseContinuityDelta(accepted.text);
         const firstAcceptanceLine = accepted.text.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
         if (firstAcceptanceLine !== "HANDOFF_ACCEPTED" || !successorDelta.delta || !successor.sessionId()) {
@@ -378,12 +387,19 @@ export class ContinuityAdapter {
     restoreNativeCompactions(compactions) { this.adapter.restoreNativeCompactions?.(compactions); }
     contextUsageAfterNativeCompaction(compaction) { return this.adapter.contextUsageAfterNativeCompaction?.(compaction) ?? Promise.resolve(undefined); }
     contextUsage() { return this.adapter.contextUsage?.() ?? Promise.resolve(undefined); }
+    graphRuntimeSettings() { return this.adapter.graphRuntimeSettings?.(); }
     sessionUsage() { return this.adapter.sessionUsage?.() ?? Promise.resolve(undefined); }
     switchSettings(settings) { return this.adapter.switchSettings ? this.adapter.switchSettings(settings) : Promise.resolve({ ok: false, error: "provider adapter does not support settings changes" }); }
     events() { return this.queue; }
     async close() { await this.adapter.close(); await this.sourcePump?.catch(() => { }); this.queue.close(); }
     /** Keep the observable wrapper and event stream stable while moving to an accepted successor. */
     async adoptValidatedSuccessor(successor) {
+        if (this.contractEnforcing) {
+            successor.enableContractEnforcement?.();
+            if (successor !== this.adapter)
+                await successor.close().catch(() => { });
+            throw new ContinuityRecoveryRequiredError(this.options.runId, this.options.role, "Replacement Builder requires host contract delivery before any continuation; completed turn must be reconciled without automatic replay");
+        }
         if (successor === this.adapter)
             return;
         const prior = this.adapter;

package/dist/foreman.d.ts

@@ -1,3 +1,4 @@
+import type { GraphPurpose } from "rafi-spec";
 import type { BuilderAdapter, PermissionHandler, PermissionRequest, TurnResult } from "./adapters/types.js";
 import type { PermissionPolicy } from "./permissions/policy.js";
 import { type AnsweredProviderQuestion } from "./providerQuestions.js";
@@ -85,19 +86,25 @@ export declare class Foreman {
     /** Exact durable build-run scope. Observability is never an identity authority. */
     private readonly qaRunId;
     private readonly continueIndependentTickets;
+    private readonly builderWorktree?;
+    private readonly decisionPrompt?;
+    private graphPurpose;
+    setGraphPurpose(purpose: GraphPurpose): void;
     private readonly ticketsEnabled;
     private readonly notificationsEnabled;
     private readonly terminalBellEnabled;
     private readonly qaStream;
     private builderWorkSessions;
     private currentTicketId?;
+    private preflightPlan;
+    approvedPlanText(): string;
     constructor(builder: BuilderAdapter, log: Log, notifications?: boolean | ForemanNotificationOptions, qaEnabled?: boolean, qaMaxCycles?: number, projectDir?: string | undefined, 
     /** @deprecated QA must be created by qaFactory in a disposable snapshot. */
     _deprecatedSameSessionReviewer?: BuilderAdapter, qaFactory?: ((cwd: string, sessionId?: string) => Promise<QaSessionHandle>) | undefined, qaSessionStrategy?: SessionStrategy, builderFactory?: ((cwd: string, sessionId?: string) => Promise<BuilderAdapter>) | undefined, builderSessionStrategy?: SessionStrategy, qaNonconvergence?: ((context: QaNonconvergenceContext) => Promise<QaNonconvergenceDecision>) | undefined, beforeBuilderTurn?: ((adapter: BuilderAdapter, frozenAction: string) => Promise<BuilderAdapter>) | undefined, builderSessionBoundary?: ((adapter: BuilderAdapter, frozenAction: string, strategy: SessionStrategy) => Promise<BuilderAdapter>) | undefined, qaSessionBoundary?: ((handle: QaSessionHandle, frozenAction: string, strategy: SessionStrategy, cwd: string, recovery?: QaSessionBoundaryRecovery) => Promise<QaSessionBoundaryResult>) | undefined, observeQaNativeCompactions?: ((adapter: BuilderAdapter) => Promise<void>) | undefined, 
     /** Persist a Builder's provider-native event immediately after every turn. */
     observeBuilderNativeCompactions?: ((adapter: BuilderAdapter) => Promise<void>) | undefined, observer?: RunObserver | undefined, qaRuntimeContext?: unknown | undefined, qaContinuityManaged?: boolean, qaReportRecovery?: QaReportRecoveryHandler | undefined, qaResumedRecovery?: QaRecoveryPacket | undefined, 
     /** Exact durable build-run scope. Observability is never an identity authority. */
-    qaRunId?: string, continueIndependentTickets?: boolean, initialTicketId?: string);
+    qaRunId?: string, continueIndependentTickets?: boolean, initialTicketId?: string, builderWorktree?: string | undefined, decisionPrompt?: ((decision: import("rafi-spec").PendingHumanDecision) => Promise<string | undefined>) | undefined);
     private waitForUserInput;
     /**
      * Send one instruction and resolve any needs_input exchanges before returning.
@@ -106,6 +113,7 @@ export declare class Foreman {
     private doTurn;
     private prepareBuilderBoundary;
     private doTurnWith;
+    private doTurnWithOwned;
     /** Send a planning turn and return the builder's response text. Does not count toward steps. */
     runPreflight(n: number, ticketsContent?: string, preferredTicketId?: string, executionTickets?: readonly string[]): Promise<string>;
     /** Send user feedback on the plan; builder responds with a revised list. Does not count toward steps. */
@@ -140,7 +148,7 @@ export declare class Foreman {
         passCertificateId?: string;
         sourceStateDigest?: string;
     }>;
-    /** Complete only the pending QA boundary and its tracker transition. No Builder work turn is sent. */
+    /** Resume the pending boundary, including authorized waiting guidance, then complete its tracker transition. */
     completePendingQaRecovery(ticketId: string): Promise<{
         outcome: "passed" | "blocked" | "needs-human" | "waived";
         detail?: string;