@sema-agent/core 5.64.0 → 6.0.0

package/dist/core/runner/runtask.d.ts

@@ -152,16 +152,11 @@ export declare class Runner {
     readonly sessions: SessionStore;
     /** Per-sessionId serialization so two tasks never mutate one session concurrently. */
     private sessionLocks;
-    /** (a) — roots whose rewind-files snapshot hit `too_large`, with the refusal time.
-     *  A 20G workspace otherwise pays a full bounded tree-walk (stat tens of thousands of files) EVERY
-     *  task just to re-discover the same refusal; once too_large, skip further snapshots for that root
-     *  (announced once via onError). E19 semantics unchanged — rewind for that root was already
-     *  impossible. TTL'd (30min), not permanent — a long-lived Runner over a tree the
-     *  user later SHRINKS re-probes instead of being locked out until restart.
-     *  RB-430-b: `skipAnnounced` makes the SKIP itself observable — one announcement per cooldown window,
-     *  so an operator can tell "this turn produced no snapshot" from "snapshots are working", without the
-     *  per-turn log spam the latch exists to prevent. Cleared with the entry when the window elapses. */
-    private snapshotTooLargeRoots;
+    /** #483 rung-1 — per-session read-file-state seats (CC parity: readFileState is session-scoped;
+     *  sema's map stays per-task, so the session scope lives here). A bounded CACHE, never an
+     *  authority: a durable resume's checkpoint seed wins on its leg, and a miss (cross-process,
+     *  evicted) falls back to the transcript-replay rung. See {@link SessionReadFileStates}. */
+    private readonly sessionReadStates;
     /** task notifications born BETWEEN turns (run torn down / harness already idle), parked
      *  per session and drained into the session's next run at its first boundary. Runner-lived (outlives any
      *  single run, like the registry handles that produce into it); bounded + drop-disclosing, see
@@ -179,6 +174,24 @@ export declare class Runner {
      *  observed `already_resolved` and by the FIFO cap — an evicted entry only ever degrades to the explicit
      *  re-supply requirement (fail-loud), never fail-open. */
     private readonly parentConstraintRegistry;
+    /** rescan C2 — same-process suspended-env reap handles by token: the design/51 fence contract is
+     *  "only the expire WINNER destroys the paused env", and the terminal resume-preflight arm
+     *  (resumeStream) can now BE that winner — without this registry the losing stream-side
+     *  reapSuspended returned early and the paused env this process holds leaked forever. Registered
+     *  when a suspend publishes its reap handle; retired when the stream's own reap runs, when a
+     *  resume wins the resolve CAS (the restore path owns the env from there — a later reopen keeps
+     *  the ORIGINAL stream's closure as the reaping owner, deliberately), and when the terminal arm
+     *  wins. Bounded by live suspended streams (the closures hold the same handles). */
+    private readonly suspendedEnvReaps;
+    /** rescan C2 review r3 — SAME-RUNNER claim marks for {@link suspendedEnvReaps}: a token appears
+     *  here from the moment an in-process actor ATTEMPTS its settling CAS (the terminal preflight's
+     *  expire; a resume's resolve) until that actor's duty decision is done. The losing stream-side
+     *  reap preserves a record ONLY while a local claim is in flight — a CROSS-Runner settlement
+     *  leaves no local claim, so the loser retires the record (drops the strong ref; physical cleanup
+     *  belongs to the winning owner, unprovable from here) instead of retaining env handles without
+     *  bound in a long-lived Runner. A stale claim's failure direction is retention (the status quo),
+     *  never a wrong destroy. */
+    private readonly locallyClaimedTokens;
     private static readonly PARENT_CONSTRAINT_REGISTRY_CAP;
     constructor(deps: RunnerDeps);
     /** design/73 §1 v1 — fire `RunnerDeps.onTaskOutcome` through the single swallow-guarded chokepoint
@@ -256,13 +269,6 @@ export declare class Runner {
      * never rejects. Also fills the budget-excluded `stats.suggestions` line.
      */
     private suggestNextPrompts;
-    /**
-     * design/101 §E19 — capture a working-tree snapshot of the just-finished turn, keyed by the leaf
-     * `SessionTreeEntry.id`. Best-effort + never throws (errors route to `onError(phase:"rewind")`). Runs against
-     * ANY ExecutionEnv (local or remote) when a `fileSnapshotStore` is wired (GATE-SPLIT) — the
-     * snapshot is portable (env FileSystem ops). A deployment wanting VM-snapshot instead wires a VM-backed store.
-     */
-    private snapshotTurn;
     /** Run a task to completion and return a machine-readable result. */
     runTask(spec: TaskSpec, internals?: RunInternals): Promise<TaskResult>;
     /**
@@ -411,9 +417,10 @@ export declare class Runner {
      * reaper is the backstop for an env orphaned by a rare pre-teardown throw (same posture as `mcp`).
      *
      * Runs from the run-loop tail AFTER every env-reader (finish()'s compaction `attachWorkingFiles` +
-     * `snapshotTurn`'s rewind-files capture), so the working tree is still readable when they run. This ORDER is the
-     * fix for a teardown-order defect: the old in-`finish` destroy ran BEFORE `snapshotTurn`, so a factory-minted
-     * remote/worktree lane snapshotted an already-destroyed env (plain host/static lanes were false-green).
+     * the file-history boundary settle), so the working tree is still readable when they run. This ORDER is
+     * the fix for a teardown-order defect: the old in-`finish` destroy ran BEFORE the capture seat, so a
+     * factory-minted remote/worktree lane captured an already-destroyed env (plain host/static lanes were
+     * false-green).
      *
      * design/49 v1.5 / design/76 §2.5: a SUSPENDED (`suspendRef.token`) or `needs_review` (`reviewRef.token`) pause
      * `suspendVM`-paused the env and persisted its `workspaceHandle` into the checkpoint — destroying it would