@hicaru/pi-rlm 0.2.0 → 0.2.2

package/src/core/engine.ts

@@ -5,36 +5,23 @@
  * services `llm_query`/`rlm_query` via the bridges, and stops when the model submits an answer
  * or a limit/turn cap is hit. Recursion is wired by giving the sandbox rlm handlers that call
  * back into `runRlm` at depth+1. Used for recursion and for headless/automation runs.
- *
- * When `config.pipeline` is on at depth 0: goal capture, artifact-gated advance_phase,
- * history reset at phase boundaries, and measured validate→blueprint corrective routing.
- * The pipeline is read-only by design: it produces a validated plan; accidental
- * sandbox writes are blocked (steering, not a hard security boundary).
  */
 
 import type { Api, Model, Usage } from "@earendil-works/pi-ai";
 import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
-import { buildInteractiveHandlers } from "../bridge/interactive.ts";
 import { buildLibraryHandler } from "../bridge/library.ts";
 import { mergeLibraryIntoContext } from "../context/library-context.ts";
-import { createLlmBridge } from "../bridge/llm-query.ts";
+import {
+  createSubcallHandlers,
+  type Invocation,
+} from "../bridge/subcall-handlers.ts";
 import { type ChatMsg, modelComplete } from "../bridge/model.ts";
-import { createRlmHandlers } from "../bridge/rlm-query.ts";
-import { displayModelRef, resolveModelId } from "../config/settings.ts";
+import { resolveModelId } from "../config/settings.ts";
 import { buildRlmSystemPrompt } from "../prompts/system.ts";
 import { buildTurnPrompt, FINALIZE_PROMPT } from "../prompts/user.ts";
-import { phaseGuidance } from "../prompts/phases.ts";
 import type { RlmEmitter } from "../tool/rlm-events.ts";
 import { PythonSandbox } from "../sandbox/sandbox.ts";
-import {
-  phaseGatePrompt,
-  type Phase,
-  type PhaseState,
-  type StageGateData,
-} from "./pipeline.ts";
-import { PipelineController } from "./pipeline-handlers.ts";
-import type { ValidationGateData } from "./gates.ts";
-import { captureGoal, type GoalCapture } from "./artifacts.ts";
+import { pinContext, type PinnedContext } from "../sandbox/context-file.ts";
 import { previewStdout, previewText } from "../text/preview.ts";
 import { contextLength, contextSizeStats, contextTypeLabel } from "../text/tokens.ts";
 import { finalAnswerOf, formatReplOutputs, latestAnswerContentOf, turnHadError } from "./answer.ts";
@@ -42,102 +29,41 @@ import { compactHistory, shouldCompact } from "./compaction.ts";
 import { appendUserMessage } from "./history.ts";
 import { runTurn } from "./iteration.ts";
 import { type Limits, LimitError, LimitGuard } from "./limits.ts";
-import type { InteractiveDeps, RlmConfig, RlmInput, RlmResult, RunRlm, Sampling } from "./types.ts";
-import { randomUUID } from "node:crypto";
-import {
-  appendRow,
-  appendTodoRow,
-  generateRunId,
-  pruneRuns,
-  readLibrarySidecars,
-  snapshotPath,
-  writeContextSidecar,
-} from "../state/index.ts";
-import { STATE_SCHEMA_VERSION } from "../state/rows.ts";
-import type { PhaseRow, RunHeader } from "../state/rows.ts";
+import type { RlmConfig, RlmInput, RlmResult, RunRlm, Sampling } from "./types.ts";
 import { serializeForSandbox, type ContextBundle } from "../context/repomix-context.ts";
 import { formatError } from "../util/errors.ts";
+import { createSubcallGates, type SubcallGates } from "../util/concurrency.ts";
+
+/**
+ * Grace period for detached sub-calls to settle before the run disposes its sandbox.
+ * Past it the abort signal (or process exit) is what stops them; waiting longer would
+ * hold a finished run open on work whose result nobody can receive.
+ */
+const DETACHED_SETTLE_MS = 5_000;
 
 
-export interface EngineDeps extends InteractiveDeps {
+export interface EngineDeps {
   readonly model: Model<Api>;
-  readonly workerModel: Model<Api>;
+  readonly llmModel: Model<Api>;
   readonly registry: ModelRegistry;
   readonly config: RlmConfig;
   readonly limits?: Limits;
+  /** Session-wide sub-call admission, shared with the repl() tool. Private one if omitted. */
+  readonly gates?: SubcallGates;
   readonly signal?: AbortSignal;
   /** Live RlmDetails reporting via onUpdate. Required — replaces SubcallObserver. */
   readonly emitter: RlmEmitter;
   /** Called with each completion's usage (root + sub-LLM) for cost/token rollups. */
   readonly onUsage?: (usage: Usage, role: "root" | "sub") => void;
-  /** Run-state persistence handle. undefined ⇒ persistence off. */
-  readonly runState?: { readonly cwd: string; readonly dir: string; readonly snapshot: boolean };
   /** Test-only: override model completion (scripted multi-turn responses). */
   readonly complete?: import("./iteration.ts").CompleteFn;
 }
 
-/** Optional payload for a fresh-session history reset at a phase boundary. */
-export interface PhaseHistoryOptions {
-  readonly goal?: GoalCapture;
-  readonly validation?: ValidationGateData;
-  /** Engine notice folded into the first user message (no console I/O). */
-  readonly notice?: string;
-}
-
-/**
- * Fresh-session policy: at each phase boundary the conversation is replaced;
- * artifacts (paths) are the only channel. REPL variables persist — the transition
- * message tells the model context survives in the sandbox, not in chat.
- */
-export function resetHistoryForPhase(
-  system: string,
-  state: PhaseState,
-  options: PhaseHistoryOptions = {},
-): ChatMsg[] {
-  const { goal, validation, notice } = options;
-  const parts: string[] = [
-    `You are entering the '${state.current}' phase.`,
-  ];
-  if (notice) parts.push(notice);
-  if (goal) {
-    parts.push(`The user's verbatim brief: read ${goal.goalPath} from the REPL (open()).`);
-    parts.push(`Pre-run dirty baseline (exclude from delta judgment): ${goal.baselinePath}`);
-  }
-  for (const [p, ref] of Object.entries(state.artifacts)) {
-    if (ref === undefined) continue;
-    parts.push(
-      ref.status === "superseded"
-        ? `Superseded artifact from '${p}' (rejected by validation): ${ref.path} — read it and the validation before re-planning; do not repeat its blockers.`
-        : `Artifact from '${p}': ${ref.path}`,
-    );
-  }
-  if (validation) {
-    parts.push(
-      `Previous validation found ${validation.blockersCount} blocker(s) — read the validation artifact and address every blocker in the revised plan.`,
-    );
-  }
-  parts.push(phaseGuidance(state.current));
-  parts.push("Your REPL variables persist; the chat history was reset to keep your window small.");
-  return [
-    { role: "system", content: system },
-    { role: "user", content: parts.join("\n") },
-  ];
-}
-
 /** Build a `runRlm` bound to the given deps. The returned function is reused for recursion. */
 export function createEngine(deps: EngineDeps): RunRlm {
   const { emitter } = deps;
   const run: RunRlm = async (input: RlmInput): Promise<RlmResult> => {
-    const nowIso = (): string => new Date().toISOString(); // local helper — 4 call sites below
-    const persist = input.depth === 0 && deps.runState !== undefined;
-    const runCwd = deps.runState?.cwd ?? process.cwd();
-    // Compute runId early for run-state correlation on resume.
-    const runId = persist
-      ? (input.resume ? input.resume.header.runId : generateRunId())
-      : undefined;
-    // I4: session-scoped pickle trust — nonce prevents cross-session snapshot replay.
-    // On resume, sessionNonce is undefined → no snapshots, history-only replay.
-    const sessionNonce = persist && !input.resume ? randomUUID() : undefined;
+    const runCwd = process.cwd();
     // For depth > 0, input.parentNodeId is the subcall ID created by the parent's rlm-query bridge.
     // For depth 0, input.parentNodeId is undefined — engine uses root-level bridge methods.
     const selfReportId = input.depth === 0 ? undefined : input.parentNodeId;
@@ -162,107 +88,96 @@ export function createEngine(deps: EngineDeps): RunRlm {
     const model = overrideModel ?? deps.model;
 
     // Create LimitGuard BEFORE the bridge so sub-LLM usage feeds into it.
-    // Children inherit the parent's remaining budget/timeout (reference: limits propagate
-    // as remaining amounts, not the full original cap).
-    // CA: seed the clock on resume so resumed runs don't get a fresh timeout budget.
+    // Children inherit the parent's remaining timeout (propagated as remaining amount, not
+    // the full original cap).
     const limits = new LimitGuard({
-      maxBudgetUsd: input.remainingBudgetUsd ?? deps.limits?.maxBudgetUsd,
       maxTimeoutMs: input.remainingTimeoutMs ?? deps.limits?.maxTimeoutMs,
       maxErrors: deps.limits?.maxErrors,
       maxTokens: deps.limits?.maxTokens,
-    }, input.resume?.usageSeed.durationMs ?? 0);
-    const remainingBudget = (): { readonly budgetUsd?: number; readonly timeoutMs?: number } => ({
-      budgetUsd: limits.remainingBudgetUsd(),
-      timeoutMs: limits.remainingTimeoutMs(),
     });
 
-    const llm = createLlmBridge({
-      workerModel: () => deps.workerModel,
+    // One Invocation for the whole run: this engine owns exactly one sandbox at one depth,
+    // and its emitter and LimitGuard outlive every sub-call it services — including
+    // detached ones, which is why the headless path needs no session registry.
+    const invocation: Invocation = {
+      emitter,
+      parentId: selfReportId,
+      depth: input.depth,
+      limits: {
+        remainingTimeoutMs: () => limits.remainingTimeoutMs(),
+        addUsage: (u) => {
+          limits.addUsage(u);
+          deps.onUsage?.(u, "sub");
+        },
+        addRaw: (costUsd, inputTokens, outputTokens) => {
+          limits.addRaw(costUsd, inputTokens, outputTokens);
+        },
+      },
+    };
+    // Detached work must not outlive the sandbox we dispose in `finally`: track it so the
+    // run can settle or abort it first (a child engine left running would keep spending).
+    let detachedInFlight = 0;
+    let detachedIdle: (() => void) | undefined;
+    const subcalls = createSubcallHandlers({
+      resolve: () => invocation,
+      gates: deps.gates
+        ?? createSubcallGates(deps.config.maxConcurrentSubcalls, deps.config.maxConcurrentChildren),
       registry: deps.registry,
-      config: () => deps.config,
+      getLlmModel: () => deps.llmModel,
+      getModel: () => model,
+      getConfig: () => deps.config,
       signal: deps.signal,
-      onUsage: (u) => {
-        limits.addUsage(u);
-        deps.onUsage?.(u, "sub");
-      },
-      emitter: () => emitter,
-      parentId: () => selfReportId,
-      depth: () => input.depth,
-      remainingBudget,
-    });
-    const rlm = createRlmHandlers({
-      run,
-      llm,
-      config: () => deps.config,
-      modelLabel: (override) => displayModelRef(deps.registry, override, model),
-      emitter: () => emitter,
-      parentNodeId: () => selfReportId,
-      remainingBudget,
-      onChildUsage: (costUsd, inputTokens, outputTokens) => {
-        limits.addRaw(costUsd, inputTokens, outputTokens);
+      runChild: run,
+      // Read lazily: a library loaded on turn 3 must reach a child spawned on turn 4. Safe
+      // despite being wired before liveContext is assigned — children can only spawn from an
+      // interrupt during runTurn, which is strictly after loadContext below.
+      getChildContext: () => liveContext,
+      trackDetached: async (task) => {
+        detachedInFlight += 1;
+        try {
+          return await task();
+        } finally {
+          detachedInFlight -= 1;
+          if (detachedInFlight === 0) detachedIdle?.();
+        }
       },
     });
+    /** Wait (bounded) for detached work before the sandbox goes away. */
+    const settleDetached = async (): Promise<void> => {
+      if (detachedInFlight === 0) return;
+      await new Promise<void>((resolve) => {
+        detachedIdle = resolve;
+        setTimeout(resolve, DETACHED_SETTLE_MS).unref?.();
+      });
+      detachedIdle = undefined;
+    };
     let sandbox: PythonSandbox | undefined;
+    /**
+     * This run's live context: the repo pack plus every library loaded so far. Children inherit
+     * it, so it must grow when load_library appends (see the library handler's onLoaded below).
+     *
+     * Run-scoped on purpose — recursion means N of these are live at once, and a module-level
+     * "current context" would hand a depth-3 child its cousin's world.
+     */
+    let liveContext: unknown = null;
+    /**
+     * This run's hold on the serialized context file. Kept for the whole run so every child that
+     * inherits the same payload reuses one file instead of re-serializing the repository.
+     */
+    let contextPin: PinnedContext | undefined;
+    /** Re-pin after the payload changes identity (mergeLibraryIntoContext returns a new array). */
+    const repinLiveContext = async (): Promise<void> => {
+      const previous = contextPin;
+      contextPin = await pinContext(liveContext);
+      await previous?.release();
+    };
     let best = "";
     let lastAnswer = "";
     let compactions = 0;
     let completedTurns = 0;
-    /** Owns all pipeline state (phase, per-phase latest save, ask rounds, pending reset). */
-    let pipeline: PipelineController | undefined;
     let nodeStatus: "done" | "error" = "done";
-    let persistOn = persist;
-    if (persist && deps.runState && !input.resume && runId) {
-      const json = typeof input.context !== "string";
-      const sidecarOk = await writeContextSidecar(deps.runState.cwd, deps.runState.dir, runId, input.context, json);
-      if (!sidecarOk) {
-        persistOn = false; // QC: skip header if sidecar failed — prevents orphan trail referencing non-existent context
-      } else {
-        const header: RunHeader = {
-          kind: "header", v: STATE_SCHEMA_VERSION, runId, ts: nowIso(),
-          rootPrompt: input.rootPrompt,
-          context: { type: contextTypeLabel(input.context), chars: contextLength(input.context), json },
-          models: { model: model.id, worker: deps.workerModel.id },
-          meta: { maxIterations: deps.config.maxIterations, maxDepth: deps.config.maxDepth, orchestrator: deps.config.orchestrator, pipeline: deps.config.pipeline },
-        };
-        persistOn = await appendRow(deps.runState.cwd, deps.runState.dir, runId, header);
-      }
-      await pruneRuns(deps.runState.cwd, deps.runState.dir, deps.config.runLog?.maxRuns ?? 50); // Ops: retention (always — cleanup even if sidecar failed)
-    }
-
-    const recordTerminal = async (status: "completed" | "finalized" | "aborted" | "stopped", r: RlmResult): Promise<boolean> => {
-      if (!persistOn || !runId || !deps.runState) return false;
-      return await appendRow(deps.runState.cwd, deps.runState.dir, runId, {
-        kind: "terminal", ts: nowIso(), status, answer: r.answer, iterations: r.iterations,
-        usage: { costUsd: r.costUsd, inputTokens: r.inputTokens, outputTokens: r.outputTokens },
-      });
-    };
-
-    const persistPhaseRow = async (
-      state: PhaseState,
-      artifactPath: string | undefined,
-      artifactPhase: Phase | undefined,
-      gateData: StageGateData | undefined,
-      supersededPath?: string,
-    ): Promise<void> => {
-      if (!persistOn || !runId || !deps.runState) return;
-      const row: PhaseRow = {
-        kind: "phase",
-        turn: completedTurns + 1,
-        ts: nowIso(),
-        phase: state.current,
-        summary: state.summary,
-        artifactPath,
-        artifactPhase,
-        blockersCount: gateData?.kind === "validation" ? gateData.validation.blockersCount : undefined,
-        backwardJumps: state.backwardJumps,
-        supersededPath,
-      };
-      const ok = await appendRow(deps.runState.cwd, deps.runState.dir, runId, row);
-      if (!ok) persistOn = false;
-    };
 
     try {
-      const pipelineOn = input.depth === 0 && deps.config.pipeline;
       const meta = {
         contextType: contextTypeLabel(input.context),
         contextChars: contextLength(input.context),
@@ -272,74 +187,23 @@ export function createEngine(deps: EngineDeps): RunRlm {
       const system = buildRlmSystemPrompt(meta, {
         orchestrator: deps.config.orchestrator,
         recursion: input.depth + 1 < deps.config.maxDepth,
-        askUserQuestion: deps.config.askUserQuestion && input.depth === 0,
-        todo: deps.config.todo,
-        pipeline: deps.config.pipeline && input.depth === 0,
         maxPromptChars: deps.config.maxPromptChars,
         libraryLoader: deps.config.libraryLoader,
+        child: input.depth > 0,
       });
 
-      pipeline = new PipelineController({
-        runCwd,
-        maxBackwardJumps: deps.config.maxBackwardJumps,
-        emitter,
-        completedTurns: () => completedTurns,
-        resetHistoryForPhase: (state, options) => resetHistoryForPhase(system, state, options),
-        persistPhaseRow,
-      });
-      const phaseHandlers = pipelineOn ? pipeline.handlers() : {};
-      const baseAsk = deps.config.askUserQuestion ? deps.onAskUserQuestion : undefined;
-      const interactiveHandlers = buildInteractiveHandlers({
-        onAskUserQuestion: baseAsk
-          ? async (questions) => {
-              const answers = await baseAsk(questions);
-              // Count only successfully serviced root-depth rounds (handler already rejects depth>0).
-              pipeline?.noteAskRound();
-              return answers;
-            }
-          : undefined,
-        onTodo: deps.config.todo ? deps.onTodo : undefined,
-        onTodoRow: async (action, params, todoResult) => {
-          if (!persistOn || !runId || !deps.runState) return;
-          const ok = await appendTodoRow(deps.runState.cwd, deps.runState.dir, runId, {
-            turn: completedTurns + 1, ts: nowIso(), action, params, result: todoResult,
-          });
-          if (!ok) persistOn = false;
-        },
-        emitter,
-        depth: input.depth,
-        parentId: selfReportId,
-      });
-
-      const restoredSlots = input.resume && deps.runState && runId
-        ? await readLibrarySidecars(deps.runState.cwd, deps.runState.dir, runId)
-        : [];
-      // Seed host-side idempotency from restored sidecars so re-load is a no-op.
-      const restoredPrefixes: string[] = [];
-      for (const slot of restoredSlots) {
-        if (!Array.isArray(slot.payload) || slot.payload.length === 0) continue;
-        const first = slot.payload[0];
-        if (first === null || typeof first !== "object") continue;
-        const path = typeof (first as { path?: unknown }).path === "string"
-          ? (first as { path: string }).path
-          : "";
-        const m = path.match(/^(lib\/[^/]+\/)/);
-        if (m?.[1] !== undefined) restoredPrefixes.push(m[1]);
-      }
       const libraryHandlers = deps.config.libraryLoader
         ? buildLibraryHandler({
             cwd: runCwd,
             emitter,
             parentId: selfReportId,
             signal: deps.signal,
-            startIndex: 1 + restoredSlots.reduce((m, s) => Math.max(m, s.index), 0),
-            loadedPrefixes: restoredPrefixes,
-            onLoaded: async (index, payload) => {
-              if (!persistOn || !runId || !deps.runState) return;
-              await writeContextSidecar(
-                deps.runState.cwd, deps.runState.dir, runId,
-                payload, typeof payload !== "string", index,
-              );
+            getContext: () => liveContext,
+            onLoaded: async (payload) => {
+              // The accumulator is what children inherit, which is what makes inheritance
+              // transitive — grandchildren see the library too.
+              liveContext = mergeLibraryIntoContext(liveContext, payload);
+              await repinLiveContext();
             },
           }).handlers
         : {};
@@ -352,85 +216,37 @@ export function createEngine(deps: EngineDeps): RunRlm {
         signal: deps.signal,
         initTimeoutMs: deps.config.sandboxInitTimeoutMs,
         maxPromptChars: deps.config.maxPromptChars,
-        // Pipeline at depth 0 is read-only: guard open() write modes in the worker.
-        readOnly: pipelineOn,
-        handlers: { ...llm, ...rlm, ...phaseHandlers, ...interactiveHandlers, ...libraryHandlers },
+        awaitTimeoutS: Math.round(deps.config.requestTimeoutMs / 1000),
+        handlers: { ...subcalls, ...libraryHandlers },
       });
 
-      let history: ChatMsg[] = input.resume ? input.resume.history : [{ role: "system", content: system }];
-      let pendingReplOutputs: string | undefined = input.resume?.pendingReplOutputs;
-      const startTurn = input.resume?.completedTurns ?? 0;
-      if (input.resume) {
-        limits.addRaw(input.resume.usageSeed.costUsd, input.resume.usageSeed.inputTokens, input.resume.usageSeed.outputTokens);
-        best = input.resume.best;
-        compactions = input.resume.compactions;
-        completedTurns = input.resume.completedTurns;
-        if (input.resume.phase) pipeline.seedFromResume(input.resume.phase);
-      } else if (pipelineOn) {
-        // Goal capture (script, no LLM) + seed phase state + fresh history.
-        const captured = captureGoal(runCwd, input.rootPrompt);
-        // Fail-soft: fold the failure into the first reset message (never console — corrupts TUI).
-        const goalNotice = captured.ok
-          ? undefined
-          : `Note: goal artifact could not be written (${captured.error}); the brief remains only in the system prompt.`;
-        // Clarify only when interviews are enabled AND the host wired a callback.
-        // Config alone is not enough: without onAskUserQuestion every ask throws and
-        // the run would burn maxIterations stuck at clarify (askRounds stays 0).
-        const startPhase =
-          deps.config.askUserQuestion && deps.onAskUserQuestion !== undefined
-            ? "clarify"
-            : "research";
-        history = pipeline.seedFresh(startPhase, captured.ok ? captured.value : undefined, goalNotice);
-      }
+      let history: ChatMsg[] = [{ role: "system", content: system }];
+      let pendingReplOutputs: string | undefined;
 
       // Context: serialize ContextBundle to sandbox-ready JSON array, pass raw strings through.
-      // Resume: merge library sidecars into the single `context` list (no context_N slots).
-      let contextValue: unknown =
+      liveContext =
         typeof input.context === "object" && input.context !== null && "files" in input.context
           ? serializeForSandbox(input.context as ContextBundle)
           : input.context;
-      for (const slot of restoredSlots) {
-        contextValue = mergeLibraryIntoContext(contextValue, slot.payload);
-      }
-      await sandbox.loadContext(contextValue);
-      if (input.resume?.snapshotTurn !== undefined && deps.runState && runId && sessionNonce) // R-C1: restore only for same-session (sessionNonce present)
-        await sandbox.restore(snapshotPath(deps.runState.cwd, deps.runState.dir, runId, input.resume.snapshotTurn), sessionNonce);
-      for (let i = startTurn; i < deps.config.maxIterations; i++) {
+      contextPin = await pinContext(liveContext);
+      await sandbox.loadContextPinned(contextPin);
+      for (let i = 0; i < deps.config.maxIterations; i++) {
         limits.checkTimeout();
         if (selfReportId) emitter.emitSubcallUpdated({ id: selfReportId, detail: `turn ${i + 1}/${deps.config.maxIterations}` });
         else emitter.emitTurn(i + 1, deps.config.maxIterations);
 
-        // Apply deferred history reset from a prior advance_phase (fresh session policy).
-        const scheduledReset = pipeline.takePendingReset();
-        if (scheduledReset !== undefined) {
-          history = scheduledReset;
-          pendingReplOutputs = undefined;
-        }
-
         if (deps.config.compaction) {
           const compactionDeps = {
             // Summarisation is done by the cheap worker model; the threshold stays on the
             // root model's context window (that is the window the history fills each turn).
-            model: deps.workerModel,
+            model: deps.llmModel,
             registry: deps.registry,
             contextWindow: model.contextWindow,
             thresholdPct: deps.config.compactionThresholdPct,
             signal: deps.signal,
           };
           if (shouldCompact(history, compactionDeps)) {
-            const prevHistoryRef = history;
-            let compactionUsage = { costUsd: 0, inputTokens: 0, outputTokens: 0 };
-            history = await compactHistory(history, compactionDeps, ++compactions, (u) => {
-              limits.addUsage(u);
-              compactionUsage = { costUsd: compactionUsage.costUsd + u.cost.total, inputTokens: compactionUsage.inputTokens + u.input, outputTokens: compactionUsage.outputTokens + u.output }; // CC: accumulate
-            });
-            if (persistOn && runId && deps.runState && history !== prevHistoryRef) {
-              const ok = await appendRow(deps.runState.cwd, deps.runState.dir, runId, {
-                kind: "compaction", turn: i + 1, ts: nowIso(), history,
-                usage: compactionUsage,
-              });
-              if (!ok) persistOn = false; // QC: disable persistence on first failure (match turn-row pattern)
-            }
+            history = await compactHistory(history, compactionDeps, ++compactions, (u) => limits.addUsage(u));
           }
         }
 
@@ -439,14 +255,7 @@ export function createEngine(deps: EngineDeps): RunRlm {
           pendingReplOutputs = undefined;
         }
 
-        const gateMsg = deps.config.pipeline ? phaseGatePrompt(pipeline.phase, completedTurns) : undefined;
-        const gateUserMsg = gateMsg ? `[${new Date().toISOString()}] ${gateMsg}` : undefined;
-        // Phase guidance lives only in resetHistoryForPhase (fresh session) — do not re-inject
-        // into every turn prompt (avoids duplication on turn 1 and dead post-transition flags).
-        appendUserMessage(
-          history,
-          buildTurnPrompt(i, deps.config.maxIterations, gateUserMsg),
-        );
+        appendUserMessage(history, buildTurnPrompt(i, deps.config.maxIterations));
 
         // rootSampling fields win; smartReasoning is the default reasoning when not overridden.
         const rootSampling: Sampling = {
@@ -476,86 +285,29 @@ export function createEngine(deps: EngineDeps): RunRlm {
         completedTurns = i + 1;
         const final = finalAnswerOf(turn.results);
         if (final != null) {
-          // Validate-phase finalize is gated: the controller measures THIS turn's validation
-          // save only, never phase.artifacts (stale after a prior corrective loop).
-          if (pipelineOn && pipeline.phase?.current === "validate") {
-            const outcome = await pipeline.finalizeInValidate(final);
-            if (outcome.kind === "reject") {
-              history.push({ role: "assistant", content: turn.response });
-              pendingReplOutputs = outcome.error;
-              continue;
-            }
-            if (outcome.kind === "loop-back") {
-              history = outcome.history;
-              pendingReplOutputs = undefined;
-              continue;
-            }
-            if (outcome.kind === "halt") {
-              const halted = result(outcome.report, i + 1, limits);
-              await recordTerminal("completed", halted);
-              lastAnswer = halted.answer;
-              return halted;
-            }
-            // outcome.kind === "accept" — take the model's final answer
-          }
           const done = result(final, i + 1, limits);
-          await recordTerminal("completed", done);
           lastAnswer = done.answer;
           return done;
         }
 
         limits.observe(turnHadError(turn.results));
-        // Always capture this turn's REPL outputs for the JSONL trail (fidelity).
-        const turnReplOutputs = formatReplOutputs(turn.results, turn.skippedBlocks);
-        // If advance_phase scheduled a history reset, apply it now (do not pollute fresh history).
-        const nextReset = pipeline.takePendingReset();
-        if (nextReset !== undefined) {
-          history = nextReset;
-          // Fanout/advance result is already embedded in the reset user message — do not
-          // also append raw REPL stdout as a next-turn user message.
-          pendingReplOutputs = undefined;
-        } else {
-          history.push({ role: "assistant", content: turn.response });
-          pendingReplOutputs = turnReplOutputs;
-        }
-
-        if (persistOn && runId && deps.runState) {
-          const pklPath = snapshotPath(deps.runState.cwd, deps.runState.dir, runId, i + 1);
-          const snapOk = deps.runState.snapshot && sandbox && sessionNonce
-            ? await sandbox.snapshot(pklPath, sessionNonce)
-            : false;
-          const ok = await appendRow(deps.runState.cwd, deps.runState.dir, runId, {
-            kind: "turn", turn: i + 1, ts: nowIso(),
-            response: turn.response,
-            // Trail keeps the real REPL output even when history was reset (issue #9).
-            replOutputs: turnReplOutputs || undefined,
-            answerContent: answerContent || undefined,
-            error: turnHadError(turn.results),
-            usage: { costUsd: turn.usage.cost.total, inputTokens: turn.usage.input, outputTokens: turn.usage.output }, // B2: Usage has .input/.output, not .inputTokens/.outputTokens
-            cumulativeDurationMs: limits.usage().durationMs, // B3: required by TurnRow, seeds LimitGuard clock on resume (CA)
-            snapshotOk: snapOk,
-          });
-          if (!ok) persistOn = false;
-          // No finalizeSnapshot — snapshot is atomic (os.rename inside worker.py)
-        }
+        history.push({ role: "assistant", content: turn.response });
+        pendingReplOutputs = formatReplOutputs(turn.results, turn.skippedBlocks);
       }
       if (pendingReplOutputs) appendUserMessage(history, pendingReplOutputs);
       const finalized = result(await finalize(history, model, deps, limits), deps.config.maxIterations, limits);
-      await recordTerminal("finalized", finalized);
       lastAnswer = finalized.answer;
       return finalized;
     } catch (err) {
       // Abort is a user action — resolve with the best partial, not an error.
       if (deps.signal?.aborted) {
         const aborted = result(best.trim() || "(aborted)", completedTurns, limits);
-        await recordTerminal("aborted", aborted);
         lastAnswer = aborted.answer;
         return aborted;
       }
       if (err instanceof LimitError) {
         nodeStatus = "error";
         const stopped = result(best.trim() || `(stopped: ${err.message})`, completedTurns, limits);
-        await recordTerminal("stopped", stopped);
         lastAnswer = stopped.answer;
         return stopped;
       }
@@ -573,6 +325,9 @@ export function createEngine(deps: EngineDeps): RunRlm {
         if (nodeStatus !== "error" && lastAnswer) emitter.emitAnswer(previewText(lastAnswer));
         emitter.emitStatus(nodeStatus === "error" ? "error" : "done");
       }
+      // Settle detached work FIRST: a child still running may be about to pin this same payload.
+      await settleDetached();
+      await contextPin?.release();
       await sandbox?.dispose();
     }
   };

package/src/core/history.ts

@@ -1,4 +1,4 @@
-/** Shared history mutation helpers used by both the engine loop and the resume fold. */
+/** Shared history mutation helpers for the engine loop. */
 
 import type { ChatMsg } from "../bridge/model.ts";