ai-foreman 1.7.8 → 1.7.9

package/dist/cli/start.js

@@ -37,7 +37,7 @@ import { eligibleTickets, evaluateTicketEligibility } from "../tickets/eligibili
 import { BUILTIN_BRANCH_PREFIX, validateBranchPrefix } from "../branch/prefix.js";
 import { captureCurrentWorkflowSessionIdentity, CurrentWorkflowChangedError, CurrentWorkflowGuardAdapter } from "../branch/currentGuard.js";
 import { ContinuityAdapter, ContinuityRecoveryRequiredError, SessionUnavailableContinuityError } from "../continuity.js";
-import { ContextCapabilityError, RoleSessionController } from "../sessionLifecycle.js";
+import { ContextCapabilityError, RoleSessionController, ThresholdCompactionController } from "../sessionLifecycle.js";
 import { HandoffLoopError, HandoffService, parseBuilderHandoffRequest } from "../handoffs.js";
 import { captureWorkspaceIdentity, createProviderSessionRef, resolveUniqueSessionBinding } from "../sessionIdentity.js";
 import { SessionUnavailableError } from "../adapters/sessionFailure.js";
@@ -625,13 +625,7 @@ export function buildStartCommand() {
                 fast: builderFast,
                 systemPromptAppend: roleBundle.system || undefined,
                 skills: roleBundle.skills.length > 0 ? roleBundle.skills : undefined,
-                contextManagementPolicy: {
-                    role: "builder",
-                    configuredThresholdPercent: thresholdOverride ?? roleDefaults.builder?.auto_compact_threshold_percent ?? 50,
-                    compactMaximum: roleDefaults.builder?.compact_maximum ?? 10,
-                    settingsRevision,
-                    model: model ?? "default",
-                },
+                autoCompactThresholdPercent: thresholdOverride ?? roleDefaults.builder?.auto_compact_threshold_percent ?? 50,
             };
             const adapter = agent === "codex"
                 ? new CodexAdapter(adapterOpts)
@@ -643,12 +637,12 @@ export function buildStartCommand() {
                     throw new SessionUnavailableError({ runtime: "codex", phase: "preflight", dispatchState: "not-sent", executable: agentExecutable ?? "codex", cwd: builderCwd, diagnostics: availability.detail ?? `Codex session ${sessionRef.sessionId} is ${availability.status}`, availability });
                 }
             }
+            await prepareNativeAutoCompaction(adapter);
             return !branchMode ? new CurrentWorkflowGuardAdapter(adapter, builderCwd) : adapter;
         };
         let activeContinuityRunId;
         let liveStatusReporter;
         let activeBuilderForStatus;
-        let activeBuilderContextSnapshot;
         const resolvedContinuitySettings = (role) => role === "builder" ? {
             role, source: roleDefaults.builder ? "project" : "provider", make: agent, model: model ?? "default",
             reasoning: builderEffort ?? "default", fast: Boolean(builderFast), session_strategy: roleDefaults.builder?.session_strategy ?? "compact",
@@ -662,67 +656,25 @@ export function buildStartCommand() {
             auto_compact_threshold_percent: roleDefaults.qa?.auto_compact_threshold_percent ?? 50,
             compact_maximum: roleDefaults.qa?.compact_maximum ?? 10,
         };
-        const liveRoleFields = [
-            "make", "model", "reasoning", "fast", "session_strategy", "display_session_cost",
-            "auto_compact_threshold_percent", "compact_maximum",
-        ];
-        const observedRoleDefaults = {
-            builder: { ...(roleDefaults.builder ?? {}) },
-            qa: { ...(roleDefaults.qa ?? {}) },
-        };
-        const observedProjectRevision = { builder: settingsRevision, qa: settingsRevision };
-        const effectiveRoleRevision = { builder: settingsRevision, qa: settingsRevision };
-        const liveRoleOverrides = {
-            builder: new Map(),
-            qa: new Map(),
-        };
         const liveRoleSettings = (role, base) => {
             const live = readAgentDefaults(cwd);
             const revision = live.revision ?? 0;
-            const defaults = role === "builder" ? live.builder : live.qa;
-            if (revision > observedProjectRevision[role]) {
-                const prior = observedRoleDefaults[role];
-                let roleChanged = false;
-                for (const field of liveRoleFields) {
-                    const value = defaults?.[field];
-                    if (!Object.is(value, prior[field])) {
-                        liveRoleOverrides[role].set(field, value);
-                        roleChanged = true;
-                    }
-                }
-                const revisionDb = new WorkflowDb(cwd);
-                let targetedFields;
-                try {
-                    targetedFields = revisionDb.projectSettingsRevisionTargets(revision)[role] ?? [];
-                }
-                finally {
-                    revisionDb.close();
-                }
-                for (const field of targetedFields) {
-                    if (liveRoleFields.includes(field)) {
-                        const typedField = field;
-                        liveRoleOverrides[role].set(typedField, defaults?.[typedField]);
-                    }
-                }
-                observedRoleDefaults[role] = { ...(defaults ?? {}) };
-                observedProjectRevision[role] = revision;
-                if (roleChanged || targetedFields.length)
-                    effectiveRoleRevision[role] = revision;
-            }
-            if (effectiveRoleRevision[role] <= base.settings_revision)
+            if (revision <= base.settings_revision)
                 return base;
-            const merged = {
+            const defaults = role === "builder" ? live.builder : live.qa;
+            return {
                 ...base,
                 source: defaults ? "project" : base.source,
-                settings_revision: effectiveRoleRevision[role],
+                make: defaults?.make ?? base.make,
+                model: defaults?.model ?? base.model,
+                reasoning: defaults?.reasoning ?? base.reasoning,
+                fast: defaults?.fast ?? base.fast,
+                session_strategy: defaults?.session_strategy ?? base.session_strategy,
+                display_session_cost: defaults?.display_session_cost ?? base.display_session_cost,
+                auto_compact_threshold_percent: defaults?.auto_compact_threshold_percent ?? base.auto_compact_threshold_percent,
+                compact_maximum: defaults?.compact_maximum ?? base.compact_maximum,
+                settings_revision: revision,
             };
-            const mutable = merged;
-            for (const [field, value] of liveRoleOverrides[role]) {
-                if (value === undefined)
-                    continue;
-                mutable[field] = value;
-            }
-            return merged;
         };
         const createBuilderForSettings = async (builderCwd, settings) => {
             const ready = await ensureRuntimeReadyForCommand(builderCwd, settings.make, {
@@ -747,12 +699,10 @@ export function buildStartCommand() {
                 fast: settings.fast,
                 systemPromptAppend: roleBundle.system || undefined,
                 skills: roleBundle.skills.length > 0 ? roleBundle.skills : undefined,
-                contextManagementPolicy: {
-                    role: "builder", configuredThresholdPercent: settings.auto_compact_threshold_percent,
-                    compactMaximum: settings.compact_maximum, settingsRevision: settings.settings_revision, model: settings.model,
-                },
+                autoCompactThresholdPercent: settings.auto_compact_threshold_percent,
             };
             const created = settings.make === "codex" ? new CodexAdapter(adapterOptions) : await ClaudeAdapter.create(adapterOptions);
+            await prepareNativeAutoCompaction(created);
             return !branchMode ? new CurrentWorkflowGuardAdapter(created, builderCwd) : created;
         };
         const createQaForSettings = async (qaCwd, settings) => {
@@ -777,12 +727,11 @@ export function buildStartCommand() {
                 fast: settings.fast,
                 systemPromptAppend: `${roleBundle.system}\n\nYou are an independent QA reviewer. Do not edit source, tickets, configuration, or project documentation. You may run tests and create only harmless ignored caches or coverage output.`,
                 skills: roleBundle.skills.length > 0 ? roleBundle.skills : undefined,
-                contextManagementPolicy: {
-                    role: "qa", configuredThresholdPercent: settings.auto_compact_threshold_percent,
-                    compactMaximum: settings.compact_maximum, settingsRevision: settings.settings_revision, model: settings.model,
-                },
+                autoCompactThresholdPercent: settings.auto_compact_threshold_percent,
             };
-            return settings.make === "codex" ? new CodexAdapter(adapterOptions) : await ClaudeAdapter.create(adapterOptions);
+            const created = settings.make === "codex" ? new CodexAdapter(adapterOptions) : await ClaudeAdapter.create(adapterOptions);
+            await prepareNativeAutoCompaction(created);
+            return created;
         };
         const createRecoveringBuilder = async (builderCwd, sessionId, sessionRef) => {
             if (sessionId && !sessionRef) {
@@ -969,6 +918,16 @@ export function buildStartCommand() {
             return continuousBuilder(transfer.successor, builderCwd, runId, input.next);
         };
         const createRawQa = async (qaCwd, sessionRef) => {
+            // Isolated QA conversations are intentionally disposable. Resolve live
+            // QA settings for each one so a threshold-only update applies to the
+            // very next review instead of waiting for a nonexistent session reuse.
+            const qaSettings = liveRoleSettings("qa", resolvedContinuitySettings("qa"));
+            const ready = await ensureRuntimeReadyForCommand(qaCwd, qaSettings.make, {
+                label: "live QA settings",
+                yes: true,
+                allowSwitch: false,
+                model: qaSettings.model === "default" ? undefined : qaSettings.model,
+            });
             const qaPolicy = new PermissionPolicy(config.permissions, qaCwd);
             const roleBundle = loadRoleBundle("qa", { projectDir: qaCwd });
             const adapterOpts = {
@@ -976,28 +935,24 @@ export function buildStartCommand() {
                 configRoot: cwd,
                 sessionRole: "qa",
                 sessionStream: "qa",
-                runtimeExecutable: qaExecutable,
+                runtimeExecutable: ready.executable,
                 runtimePhase: "qa",
-                model: qaModel,
+                model: qaSettings.model === "default" ? undefined : qaSettings.model,
                 ...(sessionRef ? { resumeSessionRef: sessionRef } : {}),
                 sessionGeneration: sessionRef?.generation ?? 0,
                 workspaceIdentity: captureWorkspaceIdentity(qaCwd),
                 permission: createPermissionHandler(qaPolicy, log),
-                effort: qaEffort,
-                fast: qaFast,
+                effort: explicitEffort(qaSettings.reasoning),
+                fast: qaSettings.fast,
                 systemPromptAppend: `${roleBundle.system}\n\nYou are an independent QA reviewer. Do not edit source, tickets, configuration, or project documentation. You may run tests and create only harmless ignored caches or coverage output.`,
                 skills: roleBundle.skills.length > 0 ? roleBundle.skills : undefined,
-                contextManagementPolicy: {
-                    role: "qa",
-                    configuredThresholdPercent: roleDefaults.qa?.auto_compact_threshold_percent ?? 50,
-                    compactMaximum: roleDefaults.qa?.compact_maximum ?? 10,
-                    settingsRevision,
-                    model: qaModel ?? "default",
-                },
+                autoCompactThresholdPercent: qaSettings.auto_compact_threshold_percent,
             };
-            return qaAgent === "codex"
+            const created = qaSettings.make === "codex"
                 ? new CodexAdapter(adapterOpts)
                 : await ClaudeAdapter.create(adapterOpts);
+            await prepareNativeAutoCompaction(created);
+            return created;
         };
         const createRecoveringQa = async (qaCwd, sessionRef) => {
             const initial = await createRawQa(qaCwd, sessionRef);
@@ -1114,7 +1069,6 @@ export function buildStartCommand() {
                         finally {
                             db.close();
                         } },
-                        contextSnapshot: activeBuilderContextSnapshot,
                     });
             });
         };
@@ -1218,9 +1172,8 @@ export function buildStartCommand() {
                 projectDir: cwd,
                 runId: activeContinuityRunId,
                 role: "qa",
-                requireNativeContextManagement: true,
                 initialSettings: qaSettings,
-                historicalCountUncertain: Boolean(recoveryRecord && (recoveryRecord.legacy || !recoveryRecord.runDecisions)),
+                historicalCountUncertain: recoveryCompactionHistoryUncertain(cwd, recoveryRecord, activeContinuityRunId, "qa"),
                 readSettings: () => liveRoleSettings("qa", qaSettings),
                 settingsBoundary: (input) => applyQaSettingsBoundary(activeContinuityRunId, qaCwd, input),
                 settingsAdopted: (settings, active) => liveStatusReporter?.updateState({
@@ -1231,7 +1184,6 @@ export function buildStartCommand() {
                 report: (event) => {
                     currentActivity()?.update(event.kind, event.detail, { provider: qaSettings.make, model: qaSettings.model });
                     log.write("context-lifecycle", { role: "qa", ...event, sample: event.sample });
-                    void liveStatusReporter?.tick();
                 },
                 handoff: async ({ reason, adapter: predecessor, sample, settings, compactionCount }) => {
                     const nativeUsage = await predecessor.sessionUsage?.().catch(() => undefined);
@@ -1252,9 +1204,21 @@ export function buildStartCommand() {
                     return decorateQa(transfer.successor, qaCwd, undefined, settings);
                 },
             });
-            liveStatusReporter?.updateState({ contextSnapshot: () => controller.contextSnapshot() });
             return (await controller.atWorkSessionBoundary(adapter, frozenAction, strategy)).adapter;
         };
+        const observeQaNativeCompactions = async (adapter) => {
+            if (!activeContinuityRunId)
+                return;
+            const qaSettings = resolvedContinuitySettings("qa");
+            const controller = new ThresholdCompactionController({
+                projectDir: cwd,
+                runId: activeContinuityRunId,
+                role: "qa",
+                initialSettings: qaSettings,
+                historicalCountUncertain: recoveryCompactionHistoryUncertain(cwd, recoveryRecord, activeContinuityRunId, "qa"),
+            });
+            await controller.observeNativeCompactions(adapter);
+        };
         const qaNonconvergence = createQaNonconvergenceHandler(cwd, Boolean(opts.yes), roleDefaults.planner);
         if (branchMode) {
             const ticketsConfig = loadTicketsConfig(cwd);
@@ -1356,68 +1320,12 @@ export function buildStartCommand() {
                 });
                 let auditBuilder;
                 let auditViewer;
-                let auditCompleted = false;
                 const auditRunId = `audit-${stamp}`;
                 activeContinuityRunId = auditRunId;
                 try {
-                    const auditSettings = resolvedContinuitySettings("builder");
-                    const auditInstruction = buildBranchAuditInstruction(plan.nodes.map((node) => node.ticket));
-                    const auditDb = new WorkflowDb(cwd);
-                    try {
-                        auditDb.ensureRun(auditRunId);
-                        auditDb.appendContinuityEvent({
-                            runId: auditRunId, role: "host", kind: "branch_audit_initialized",
-                            payload: { frozenActionDigest: createHash("sha256").update(auditInstruction).digest("hex") },
-                            authoritativeStateRevision: auditSettings.settings_revision,
-                        });
-                        auditDb.publishContinuityCheckpoint({
-                            runId: auditRunId, role: "builder", authoritativeStateRevision: auditSettings.settings_revision,
-                            delta: {
-                                version: 1, decisions: [], constraints: [], discoveries: [], completedActions: [], evidence: [], failures: [], blockers: [],
-                                openWork: ["complete the selected-ticket dependency audit"], nextAction: "complete the selected-ticket dependency audit",
-                            },
-                        });
-                    }
-                    finally {
-                        auditDb.close();
-                    }
                     auditBuilder = await createBuilder(cwd);
-                    const auditController = RoleSessionController.managed({
-                        projectDir: cwd, runId: auditRunId, role: "builder", initialSettings: auditSettings,
-                        requireNativeContextManagement: true,
-                        readSettings: () => liveRoleSettings("builder", auditSettings),
-                        settingsBoundary: (input) => applyBuilderSettingsBoundary(auditRunId, cwd, input),
-                        report: (event) => log.write("context-lifecycle", { phase: "branch-audit", ...event, sample: event.sample }),
-                        handoff: async ({ reason, adapter, sample, settings, compactionCount, frozenAction }) => {
-                            const nativeUsage = await adapter.sessionUsage?.().catch(() => undefined);
-                            const transfer = await new HandoffService(cwd).transfer({
-                                runId: auditRunId, role: "builder", reason, predecessorSessionId: adapter.sessionId(), predecessorSessionRef: adapter.sessionRef?.(),
-                                roleState: { phase: "branch-audit", frozenActionDigest: createHash("sha256").update(frozenAction).digest("hex"), contextSample: sample },
-                                ...(nativeUsage ? { sessionUsage: {
-                                        version: 1, runId: auditRunId, role: "builder", provider: adapter.agent,
-                                        providerSessionId: adapter.sessionId(), observedAt: nativeUsage.observedAt, source: nativeUsage.source,
-                                        cumulativeInputTokens: nativeUsage.inputTokens, cumulativeOutputTokens: nativeUsage.outputTokens,
-                                        cumulativeTotalTokens: nativeUsage.totalTokens, authoritativeCostUsd: nativeUsage.authoritativeCostUsd,
-                                    } } : {}),
-                                compactionCount, compactMaximum: settings.compact_maximum,
-                                resources: [{ label: "frozen-branch-audit", content: frozenAction, authoritative: true }],
-                            }, () => createBuilderForSettings(cwd, settings));
-                            log.write("handoff-transfer", {
-                                phase: "branch-audit", reason, generation: transfer.manifest.generation,
-                                predecessorSessionId: transfer.manifest.predecessorSessionId, successorSessionId: transfer.successorSessionId,
-                                acceptanceCheckpointDigest: transfer.acceptanceCheckpointDigest,
-                            });
-                            if (adapter instanceof ContinuityAdapter) {
-                                await adapter.adoptValidatedSuccessor(transfer.successor);
-                                return adapter;
-                            }
-                            await adapter.close().catch(() => { });
-                            return continuousBuilder(transfer.successor, cwd, auditRunId, settings);
-                        },
-                    });
-                    auditBuilder = (await auditController.atSafeBoundary(auditBuilder, auditInstruction)).adapter;
                     auditViewer = printEvents(auditBuilder.events());
-                    const audit = await auditBuilder.sendTurn(auditInstruction);
+                    const audit = await auditBuilder.sendTurn(buildBranchAuditInstruction(plan.nodes.map((node) => node.ticket)));
                     if (audit.isError)
                         throw new Error(audit.text);
                     const auditDependencies = parseAuditDependencies(audit.text);
@@ -1431,7 +1339,6 @@ export function buildStartCommand() {
                         ticketIds: selectedNewTicket ? [selectedNewTicket] : selectedStackTickets ?? deliveryRun?.remaining.slice(0, steps) ?? recoveryRecord?.tickets,
                     });
                     auditDependencyCount = auditDependencies.length;
-                    auditCompleted = true;
                 }
                 finally {
                     await auditBuilder?.close().catch(() => { });
@@ -1439,9 +1346,7 @@ export function buildStartCommand() {
                     const auditDb = new WorkflowDb(cwd);
                     try {
                         if (auditDb.getRun(auditRunId))
-                            auditDb.transition(auditRunId, auditCompleted
-                                ? { status: "completed", checkpoint: "branch-audit-complete", remainingWork: {}, event: "audit_completed" }
-                                : { status: "paused", checkpoint: "branch-audit-interrupted", remainingWork: { action: "complete the selected-ticket dependency audit" }, event: "audit_interrupted" });
+                            auditDb.transition(auditRunId, { status: "completed", checkpoint: "branch-audit-complete", remainingWork: {}, event: "audit_completed" });
                     }
                     finally {
                         auditDb.close();
@@ -1562,8 +1467,7 @@ export function buildStartCommand() {
                     return existing;
                 const controller = RoleSessionController.managed({
                     projectDir: cwd, runId: masterRun.runId, role: "builder", initialSettings: capturedBranchBuilder,
-                    requireNativeContextManagement: true,
-                    historicalCountUncertain: Boolean(recoveryRecord && (recoveryRecord.legacy || !recoveryRecord.runDecisions)),
+                    historicalCountUncertain: recoveryCompactionHistoryUncertain(cwd, recoveryRecord, masterRun.runId, "builder"),
                     readSettings: () => liveRoleSettings("builder", capturedBranchBuilder),
                     settingsBoundary: (input) => applyBuilderSettingsBoundary(masterRun.runId, worktreePath, input),
                     settingsAdopted: (settings, active) => liveStatusReporter?.updateState({
@@ -1571,7 +1475,7 @@ export function buildStartCommand() {
                         adapter: active, settingsRevision: settings.settings_revision, displaySessionCost: settings.display_session_cost,
                         sessionTransition: "adopted live settings",
                     }),
-                    report: (event) => { currentActivity()?.update(event.kind, event.detail, { provider: capturedBranchBuilder.make, model: capturedBranchBuilder.model }); log.write("context-lifecycle", { worktreePath, ...event, sample: event.sample }); void liveStatusReporter?.tick(); },
+                    report: (event) => { currentActivity()?.update(event.kind, event.detail, { provider: capturedBranchBuilder.make, model: capturedBranchBuilder.model }); log.write("context-lifecycle", { worktreePath, ...event, sample: event.sample }); },
                     handoff: async ({ reason, adapter, sample, settings, compactionCount, frozenAction }) => {
                         const nativeUsage = await adapter.sessionUsage?.().catch(() => undefined);
                         const transfer = await new HandoffService(cwd).transfer({
@@ -1623,7 +1527,7 @@ export function buildStartCommand() {
                     archiveDoc: ticketsConfig.paths.archiveDoc,
                 },
                 resumeSessions: resumeSessionByTicket,
-                createBuilder: async (builderCwd, sessionId, sessionRef) => branchContextController(builderCwd).manage(await createBuilder(builderCwd, sessionId, sessionRef)),
+                createBuilder: (builderCwd, sessionId, sessionRef) => createBuilder(builderCwd, sessionId, sessionRef),
                 recordBuilderSession: (session, ticketId) => { masterRun = persistBuildSession(cwd, { ...masterRun, currentTicket: ticketId }, "builder", session); },
                 recordQaSession: (session, ticketId) => { masterRun = persistBuildSession(cwd, { ...masterRun, currentTicket: ticketId }, "qa", session); },
                 onSessionUnavailable: (error) => { branchSessionFailure = error; },
@@ -1633,9 +1537,6 @@ export function buildStartCommand() {
                 observeBuilder: async (builder) => {
                     liveStatusReporter?.stop();
                     activeBuilderForStatus = () => builder;
-                    activeBuilderContextSnapshot = () => [...branchContextControllers.values()]
-                        .map((controller) => controller.contextSnapshot())
-                        .find((snapshot) => snapshot?.contextSample.providerSessionId === builder.sessionId());
                     const reporter = liveStatusReporter = new AgentStatusReporter({
                         runId: masterRun.runId, role: "builder", provider: builder.agent, model: capturedBranchBuilder.model,
                         reasoning: capturedBranchBuilder.reasoning, fast: capturedBranchBuilder.fast, step: Math.min(plan.nodes.length, branchContextControllers.size + 1), total: plan.nodes.length,
@@ -1653,7 +1554,6 @@ export function buildStartCommand() {
                         finally {
                             db.close();
                         } },
-                        contextSnapshot: activeBuilderContextSnapshot,
                     }, (line, snapshot) => {
                         const activity = currentActivity();
                         if (activity && process.stdout.isTTY)
@@ -1664,6 +1564,7 @@ export function buildStartCommand() {
                         const db = new WorkflowDb(cwd);
                         try {
                             db.recordTelemetry(masterRun.runId, snapshot);
+                            db.recordContextSample(snapshot.contextSample);
                             if (snapshot.sessionUsage)
                                 db.recordSessionUsage(snapshot.sessionUsage);
                         }
@@ -1681,8 +1582,10 @@ export function buildStartCommand() {
                 },
                 qaNonconvergence,
                 beforeBuilderTurn: async (adapter, frozenAction, worktreePath) => (await branchContextController(worktreePath).atSafeBoundary(adapter, frozenAction)).adapter,
+                observeBuilderNativeCompactions: async (adapter, worktreePath) => { await branchContextController(worktreePath).observeNativeCompactions(adapter); },
                 builderSessionBoundary: async (adapter, frozenAction, strategy, worktreePath) => (await branchContextController(worktreePath).atWorkSessionBoundary(adapter, frozenAction, strategy)).adapter,
                 qaSessionBoundary,
+                observeQaNativeCompactions,
             });
             if (branchSessionFailure) {
                 const failure = branchSessionFailure;
@@ -1825,9 +1728,8 @@ export function buildStartCommand() {
             projectDir: cwd,
             runId: buildRun.runId,
             role: "builder",
-            requireNativeContextManagement: true,
             initialSettings: capturedBuilder,
-            historicalCountUncertain: Boolean(recoveryRecord && (recoveryRecord.legacy || !recoveryRecord.runDecisions)),
+            historicalCountUncertain: recoveryCompactionHistoryUncertain(cwd, recoveryRecord, buildRun.runId, "builder"),
             readSettings: () => liveRoleSettings("builder", capturedBuilder),
             settingsBoundary: (input) => applyBuilderSettingsBoundary(buildRun.runId, cwd, input),
             settingsAdopted: (settings, active) => liveStatusReporter?.updateState({
@@ -1838,7 +1740,6 @@ export function buildStartCommand() {
             report: (event) => {
                 currentActivity()?.update(event.kind, event.detail, { provider: capturedBuilder.make, model: capturedBuilder.model });
                 log.write("context-lifecycle", { ...event, sample: event.sample });
-                void liveStatusReporter?.tick();
             },
             handoff: async ({ reason, adapter, sample, settings, compactionCount, frozenAction }) => {
                 const nativeUsage = await adapter.sessionUsage?.().catch(() => undefined);
@@ -1868,9 +1769,7 @@ export function buildStartCommand() {
                 return continuousBuilder(transfer.successor, cwd, buildRun.runId, settings);
             },
         });
-        builder = contextController.manage(builder);
-        activeBuilderContextSnapshot = () => contextController.contextSnapshot();
-        const foreman = new Foreman(builder, log, config.notifications.enabled, qaEnabled, 3, cwd, undefined, qaEnabled ? createQa : undefined, capturedQa.session_strategy, createBuilder, capturedBuilder.session_strategy, qaNonconvergence, async (adapter, frozenAction) => (await contextController.atSafeBoundary(adapter, frozenAction)).adapter, async (adapter, frozenAction, strategy) => (await contextController.atWorkSessionBoundary(adapter, frozenAction, strategy)).adapter, qaSessionBoundary);
+        const foreman = new Foreman(builder, log, config.notifications.enabled, qaEnabled, 3, cwd, undefined, qaEnabled ? createQa : undefined, capturedQa.session_strategy, createBuilder, capturedBuilder.session_strategy, qaNonconvergence, async (adapter, frozenAction) => (await contextController.atSafeBoundary(adapter, frozenAction)).adapter, async (adapter, frozenAction, strategy) => (await contextController.atWorkSessionBoundary(adapter, frozenAction, strategy)).adapter, qaSessionBoundary, observeQaNativeCompactions, async (adapter) => { await contextController.observeNativeCompactions(adapter); });
         activeBuilderForStatus = () => foreman.builderAdapter();
         const statusReporter = liveStatusReporter = new AgentStatusReporter({
             runId: buildRun.runId,
@@ -1891,7 +1790,6 @@ export function buildStartCommand() {
             finally {
                 db.close();
             } },
-            contextSnapshot: () => contextController.contextSnapshot(),
         }, (line, snapshot) => {
             const activity = currentActivity();
             if (activity && process.stdout.isTTY)
@@ -1902,6 +1800,7 @@ export function buildStartCommand() {
             const db = new WorkflowDb(cwd);
             try {
                 db.recordTelemetry(buildRun.runId, snapshot);
+                db.recordContextSample(snapshot.contextSample);
                 if (snapshot.sessionUsage)
                     db.recordSessionUsage(snapshot.sessionUsage);
             }
@@ -2054,6 +1953,19 @@ export function buildStartCommand() {
         }
     });
 }
+async function prepareNativeAutoCompaction(adapter) {
+    if (!adapter.prepareAutoCompaction) {
+        await adapter.close().catch(() => { });
+        throw new Error(`${adapter.agent} does not support provider-native automatic compaction`);
+    }
+    try {
+        await adapter.prepareAutoCompaction();
+    }
+    catch (error) {
+        await adapter.close().catch(() => { });
+        throw error;
+    }
+}
 function createQaNonconvergenceHandler(projectDir, noninteractive, planner) {
     return async (context) => {
         if (noninteractive || !process.stdin.isTTY || !process.stdout.isTTY)
@@ -2156,6 +2068,19 @@ function readAgentDefaults(projectDir) {
 function explicitDefaultValue(value) {
     return value && value !== "default" ? value : undefined;
 }
+function recoveryCompactionHistoryUncertain(projectDir, recovery, runId, role) {
+    if (!recovery)
+        return false;
+    if (recovery.legacy || !recovery.runDecisions || !runId)
+        return true;
+    const db = new WorkflowDb(projectDir);
+    try {
+        return db.hasUncheckpointedRoleTurn(runId, role);
+    }
+    finally {
+        db.close();
+    }
+}
 /** Make the executable branch plan exactly match each explicit root-to-tip stack. */
 export function applyExplicitStackTopology(plan, stacks, delivery, branchPrefix) {
     const nodeByTicket = new Map(plan.nodes.map((node) => [node.ticket.id, node]));

package/dist/continuity.d.ts

@@ -1,5 +1,5 @@
 import type { ContinuityDelta, ResolvedAgentSettings } from "rafi-spec";
-import type { BuilderAdapter, CompactResult, ContextManagementPolicy, ContextUsage, InterruptResult, ManagedTurnDispatcher, PreparedContextManagement, ProviderSessionUsage, ProviderSettingSwitch, RuntimeFailure, TurnResult } from "./adapters/types.js";
+import type { BuilderAdapter, CompactResult, ContextUsage, NativeCompaction, ProviderSessionUsage, ProviderSettingSwitch, RuntimeFailure, TurnResult } from "./adapters/types.js";
 export declare const CONTINUITY_MARKER = "RAFI_CONTINUITY_DELTA:";
 export declare class ContinuityValidationError extends Error {
     readonly problems: string[];
@@ -38,7 +38,7 @@ export interface ContinuityAdapterOptions {
     role: "builder" | "qa";
     settings: ResolvedAgentSettings;
     authoritativeStateRevision?: () => number;
-    /** @deprecated Use recoverWithHandoff so successor acceptance is lifecycle-managed and durable. */
+    /** Fresh successor creation after the same-session repair also fails. */
     createSuccessor?: (handoff: string) => Promise<BuilderAdapter>;
     /**
      * Production recovery path for a double-invalid delta. The callback must
@@ -62,7 +62,6 @@ export declare class ContinuityAdapter implements BuilderAdapter {
     private readonly queue;
     private sourcePump?;
     private recoveryLeasePending;
-    private turnDispatcher?;
     constructor(options: ContinuityAdapterOptions);
     get agent(): "claude" | "codex";
     sendTurn(instruction: string): Promise<TurnResult>;
@@ -71,10 +70,10 @@ export declare class ContinuityAdapter implements BuilderAdapter {
     adoptSessionRef(ref: import("rafi-spec").ProviderSessionRefV1): void;
     validateSession(): Promise<import("rafi-spec").SessionAvailabilityV1>;
     compact(): Promise<CompactResult>;
-    prepareContextManagement(policy: ContextManagementPolicy): Promise<PreparedContextManagement>;
-    updateContextManagement(policy: ContextManagementPolicy): Promise<PreparedContextManagement>;
-    interruptTurnAtCompactionBoundary(providerEventId?: string): Promise<InterruptResult>;
-    installManagedTurnDispatcher(dispatcher: ManagedTurnDispatcher): void;
+    prepareAutoCompaction(thresholdPercent?: number): Promise<void>;
+    drainNativeCompactions(): import("./adapters/types.js").NativeCompaction[];
+    restoreNativeCompactions(compactions: NativeCompaction[]): void;
+    contextUsageAfterNativeCompaction(compaction: NativeCompaction): Promise<ContextUsage | undefined>;
     contextUsage(): Promise<ContextUsage | undefined>;
     sessionUsage(): Promise<ProviderSessionUsage | undefined>;
     switchSettings(settings: ProviderSettingSwitch): Promise<CompactResult>;
@@ -82,7 +81,6 @@ export declare class ContinuityAdapter implements BuilderAdapter {
     close(): Promise<void>;
     /** Keep the observable wrapper and event stream stable while moving to an accepted successor. */
     adoptValidatedSuccessor(successor: BuilderAdapter): Promise<void>;
-    private providerTurn;
     private publish;
     private moveRecoveryLeaseAfterCheckpoint;
     private recordSessionUnavailable;