@sema-agent/core 5.46.0 → 5.48.0

package/dist/core/runner/runtask.js

@@ -3446,7 +3446,8 @@ export class Runner {
                     gates: [...prepared.humanReviewRef.gates],
                 };
             }
-            if (rs.counters.finalVerifyInjections > 0 || rs.attach.attachmentsInjected > 0 || rs.counters.repetitionCuts > 0 || rs.counters.repetitionSpared > 0 || rs.counters.approachNoticesSent > 0) {
+            const reminderDisclosuresActive = Object.keys(prepared.reminderDisclosureCounts).length > 0;
+            if (rs.counters.finalVerifyInjections > 0 || rs.attach.attachmentsInjected > 0 || rs.counters.repetitionCuts > 0 || rs.counters.repetitionSpared > 0 || rs.counters.approachNoticesSent > 0 || reminderDisclosuresActive) {
                 stats.mechanisms = {
                     ...(rs.counters.finalVerifyInjections > 0 ? { finalVerifyInjected: true } : {}),
                     ...(rs.counters.finalVerifyInjections > 0 ? { finalVerifyInjections: rs.counters.finalVerifyInjections } : {}),
@@ -3455,6 +3456,7 @@ export class Runner {
                     ...(rs.counters.repetitionCuts > 0 ? { repetitionCuts: rs.counters.repetitionCuts } : {}),
                     ...(rs.counters.repetitionSpared > 0 ? { repetitionSpared: rs.counters.repetitionSpared } : {}),
                     ...(rs.counters.repetitionEvents.length > 0 ? { repetitionEvents: rs.counters.repetitionEvents } : {}),
+                    ...(reminderDisclosuresActive ? { reminderDisclosures: { ...prepared.reminderDisclosureCounts } } : {}),
                 };
             }
             const result = assembleResult(spec, prepared.sessionId, final, stats, {

package/dist/core/session-reconcile.js

@@ -9,7 +9,8 @@ const INTERRUPTED_IDEMPOTENT = "[INTERRUPTED] The previous run ended before this
     "may not have taken effect. It is safe to REPLAY: re-issuing the same call converges the state to " +
     "what you intended. If you decide not to re-issue it, verify the current state first.";
 const INTERRUPTED_NEVER_STARTED = "[INTERRUPTED] The run was aborted before this tool call started. It was never executed and had " +
-    "no side effects — it is safe to re-issue this call if you still need it.";
+    "no side effects. If the run was stopped by a pending approval or an unresolved gate, wait for it " +
+    "to be resolved before re-issuing; re-issuing is otherwise safe if you still need this call.";
 const INTERRUPTED_REPEAT_UNKNOWN = "[INTERRUPTED] Same as an earlier interrupted call in this batch: no result was recorded and the outcome is " +
     "UNKNOWN — verify before relying on it.";
 const INTERRUPTED_REPEAT_SAFE = "[INTERRUPTED] Same as an earlier interrupted call in this batch: this tool is read-only/idempotent, so just " +
@@ -17,7 +18,7 @@ const INTERRUPTED_REPEAT_SAFE = "[INTERRUPTED] Same as an earlier interrupted ca
 const INTERRUPTED_REPEAT_IDEMPOTENT = "[INTERRUPTED] Same as an earlier interrupted call in this batch: it is safe to REPLAY — re-issue it, or verify " +
     "the current state if you decide not to.";
 const INTERRUPTED_REPEAT_NEVER_STARTED = "[INTERRUPTED] Same as an earlier interrupted call in this batch: it never started and had no side effects — " +
-    "safe to re-issue.";
+    "re-issuing is safe once whatever stopped the run is resolved.";
 const REPEAT_TEXT = {
     never_started: INTERRUPTED_REPEAT_NEVER_STARTED,
     read: INTERRUPTED_REPEAT_SAFE,

package/dist/core/session-store.d.ts

@@ -1,5 +1,5 @@
 import { type SessionRepo } from "../internal/harness.js";
-import { type AcquiredSession, type SessionStore, type SessionStoreSummary } from "./session.js";
+import { type AcquiredSession, type PlacedSessionRow, type SessionPlacement, type SessionStore, type SessionStoreSummary } from "./session.js";
 import type { StoreDurability } from "./checkpoint-store.js";
 import { SESSION_DEFAULT_TTL_DAYS } from "../config/defaults.js";
 export { SESSION_DEFAULT_TTL_DAYS };
@@ -36,6 +36,21 @@ export interface TtlSessionStoreOptions {
      * fail-closed as process-local (under-promise, never over-promise).
      */
     durability?: StoreDurability;
+    /**
+     * Subagent transcript persistence — the store's per-placement durability declaration (see
+     * {@link SessionStore.placements}). Same declaration rule as {@link durability}: this cache layer
+     * cannot inspect whether the injected repo persists placed sessions, so the DEPLOYMENT that wired
+     * the repo states the fact (`FileStorageBackend` passes `{subagent:{durability:"durable"}}`).
+     * Declaring it also arms the cache-layer placement obligations (list exclusion, claim refusal,
+     * release-is-deletion, sweep-never-deletes) — they key on the repo-persisted tuple, which a repo
+     * that ignores `placement` never mints, so declaring over such a repo is the deployment lying to
+     * itself (declaration-制, wiring-manifest posture).
+     */
+    placements?: {
+        subagent?: {
+            durability: StoreDurability;
+        };
+    };
 }
 /**
  * TTL-cached {@link SessionStore} over a pluggable {@link SessionRepo}.
@@ -59,6 +74,18 @@ export declare class TtlSessionStore implements SessionStore {
     readonly retention: "none";
     /** design/173 §2.3 — see {@link TtlSessionStoreOptions.durability} for the declaration rules. */
     readonly durability?: StoreDurability;
+    /** Subagent transcript persistence — see {@link TtlSessionStoreOptions.placements}. */
+    readonly placements?: {
+        subagent?: {
+            durability: StoreDurability;
+        };
+    };
+    /** Placed-partition enumeration, present only when the backing repo can enumerate placements
+     *  (see {@link SessionStore.listPlaced} — absence means the partition-GC leg is unavailable). */
+    readonly listPlaced?: (kind: "subagent", opts?: {
+        olderThanMs?: number;
+        scope?: string;
+    }) => Promise<PlacedSessionRow[]>;
     private repo;
     private entries;
     /** Session-ownership rows (the multi-tenant admission capability face — see SessionStore.ownerOf).
@@ -68,6 +95,20 @@ export declare class TtlSessionStore implements SessionStore {
     private owners;
     /** In-flight acquisitions keyed by id, so concurrent acquire(sameId) share one session. */
     private pending;
+    /** Subagent transcript persistence (codex 323-r2) — placed ids whose durable deletion FAILED: the
+     *  placed fact for the retry lives HERE, not on a retained cache entry, because the repo may have
+     *  torn down the shared session authority before its removal failed (the File repo closes the
+     *  append fd pre-rmSync) — a retained entry would serve a session whose log is closed while the
+     *  file still exists (append → log_closed, transcript revival broken until restart). The entry is
+     *  dropped instead, so a re-acquire replays a FRESH authority from disk; success clears the row. */
+    private pendingPlacedDeletes;
+    /** Subagent transcript persistence (codex 323-r3) — placed deletions IN FLIGHT: acquire awaits the
+     *  settlement before resolving the id, because the repo's delete tears down the shared session
+     *  authority mid-flight — an acquire racing the await window could capture (or rebuild and then
+     *  lose) an authority the delete is about to close, and the caller would hold a session whose
+     *  first append answers log_closed while the file still exists. The gate is per-id and bounded by
+     *  the delete's own settlement (both outcomes release it). */
+    private deletingPlaced;
     /** Sessions pinned by a design/45 checkpoint — skipped by idle sweep until unpinned (B6/§5). */
     private pinned;
     private defaultTtlMs;
@@ -77,7 +118,24 @@ export declare class TtlSessionStore implements SessionStore {
     /** Get an existing session by id (resuming from the repo if needed), or create one. */
     acquire(sessionId?: string, opts?: {
         requireExisting?: boolean;
+        placement?: SessionPlacement;
     }): Promise<AcquiredSession>;
+    /**
+     * Placement obligation 6 (claim closure): an EXISTING placed session refuses the claim-form
+     * acquire — no `requireExisting` (the read/revive form, obligation 5) and no creation placement
+     * (the trusted-internals form; the creating call and its dedup/retry re-acquires stay legal, and
+     * placement immutability means the argument can never REWRITE anything — the persisted tuple wins).
+     *
+     * …and the MIRROR direction (codex 323-r1 F1 — the pre-claim SQUAT race): the child session id is
+     * published on the spawn frame BEFORE the child's prepare creates the session, so a concurrent
+     * claim-form acquire could win first creation and hand the trusted placement caller an ORDINARY
+     * session — host-listable, never really-deleted, the declared full tier falsified in silence. On
+     * a store that DECLARES the partition (an ignoring store legally drops placements), an acquire
+     * carrying a placement must therefore come back with a PERSISTED tuple whose join identity
+     * matches the declaration — a missing or foreign tuple refuses loudly, on every resolution path
+     * (cache hit, pending-promise inherit, open, idempotent re-create).
+     */
+    private assertPlacementAdmission;
     /** Resume an existing session from the repo, or create it if the backend has no such id (unless
      *  `requireExisting`, in which case a genuinely-missing id fails loud instead — design/114 Phase3). */
     private openOrCreate;

package/dist/core/session-store.js

@@ -1,4 +1,4 @@
-import { InMemorySessionRepo, uuidv7, } from "../internal/harness.js";
+import { InMemorySessionRepo, SessionError, uuidv7, } from "../internal/harness.js";
 import { isSessionConflict } from "./session.js";
 const DAY_MS = 24 * 60 * 60 * 1000;
 import { SESSION_DEFAULT_TTL_DAYS } from "../config/defaults.js";
@@ -6,10 +6,14 @@ export { SESSION_DEFAULT_TTL_DAYS };
 export class TtlSessionStore {
     retention = "none";
     durability;
+    placements;
+    listPlaced;
     repo;
     entries = new Map();
     owners = new Map();
     pending = new Map();
+    pendingPlacedDeletes = new Set();
+    deletingPlaced = new Map();
     pinned = new Set();
     defaultTtlMs;
     evictPolicy;
@@ -21,6 +25,12 @@ export class TtlSessionStore {
             this.durability = durability;
         this.defaultTtlMs = (opts.defaultTtlDays ?? SESSION_DEFAULT_TTL_DAYS) * DAY_MS;
         this.evictPolicy = opts.evict ?? (opts.repo ? "forget" : "delete");
+        if (opts.placements !== undefined)
+            this.placements = opts.placements;
+        const repoListPlaced = this.repo.listPlaced;
+        if (typeof repoListPlaced === "function") {
+            this.listPlaced = (kind, o) => repoListPlaced.call(this.repo, kind, o);
+        }
         if (opts.sweepIntervalMs !== undefined && opts.sweepIntervalMs > 0) {
             this.sweepTimer = setInterval(() => this.sweep(), opts.sweepIntervalMs);
             this.sweepTimer.unref?.();
@@ -29,8 +39,12 @@ export class TtlSessionStore {
     async acquire(sessionId, opts) {
         this.sweep();
         if (sessionId) {
+            const inflightPlacedDelete = this.deletingPlaced.get(sessionId);
+            if (inflightPlacedDelete !== undefined)
+                await inflightPlacedDelete;
             const existing = this.entries.get(sessionId);
             if (existing) {
+                this.assertPlacementAdmission(sessionId, existing.placement, opts);
                 existing.lastActiveAt = Date.now();
                 return { session: existing.session, sessionId };
             }
@@ -39,26 +53,46 @@ export class TtlSessionStore {
             }
             const inflight = this.pending.get(sessionId);
             if (inflight) {
-                return { session: await inflight, sessionId };
+                const session = await inflight;
+                this.assertPlacementAdmission(sessionId, this.entries.get(sessionId)?.placement, opts);
+                return { session, sessionId };
             }
-            const p = this.openOrCreate(sessionId, false);
+            const p = this.openOrCreate(sessionId, false, opts?.placement);
             this.pending.set(sessionId, p);
             try {
-                return { session: await p, sessionId };
+                const session = await p;
+                this.assertPlacementAdmission(sessionId, this.entries.get(sessionId)?.placement, opts);
+                return { session, sessionId };
             }
             finally {
                 this.pending.delete(sessionId);
             }
         }
-        const session = await this.createAndStore(undefined);
+        const session = await this.createAndStore(undefined, opts?.placement);
         const meta = await session.getMetadata();
         return { session, sessionId: meta.id };
     }
-    async openOrCreate(id, requireExisting = false) {
+    assertPlacementAdmission(sessionId, placement, opts) {
+        if (placement !== undefined && opts?.requireExisting !== true && opts?.placement === undefined) {
+            throw new SessionError("placement_refused", `session ${sessionId} belongs to the ${placement.kind} placement partition — a claim-form acquire cannot attach to it (read it with requireExisting, or address the agent through its a* handle)`);
+        }
+        if (opts?.placement !== undefined && opts.requireExisting !== true && this.placements?.subagent !== undefined) {
+            const want = opts.placement;
+            if (placement === undefined) {
+                throw new SessionError("placement_refused", `session ${sessionId} exists OUTSIDE the ${want.kind} placement partition it was declared into — refusing to run a subagent transcript on it (a concurrent claim-form create won this id, or the repo dropped the tuple)`);
+            }
+            if (placement.kind !== want.kind || placement.scope !== want.scope || placement.handle !== want.handle) {
+                throw new SessionError("placement_refused", `session ${sessionId}'s persisted placement does not match the declared one (persisted ${placement.kind}/${placement.scope ?? "-"}/${placement.handle ?? "-"} vs declared ${want.kind}/${want.scope ?? "-"}/${want.handle ?? "-"}) — refusing a cross-tuple attach`);
+            }
+        }
+    }
+    async openOrCreate(id, requireExisting = false, placement) {
         try {
             const session = await this.repo.open({ id, createdAt: "" });
             const meta = await session.getMetadata();
-            this.entries.set(id, { session, lastActiveAt: Date.now(), createdAt: meta.createdAt, ...(meta.forkedFrom !== undefined ? { forkedFrom: meta.forkedFrom } : {}) });
+            if (meta.placement === undefined)
+                this.pendingPlacedDeletes.delete(id);
+            this.entries.set(id, { session, lastActiveAt: Date.now(), createdAt: meta.createdAt, ...(meta.forkedFrom !== undefined ? { forkedFrom: meta.forkedFrom } : {}), ...(meta.placement !== undefined ? { placement: meta.placement } : {}) });
             return session;
         }
         catch (err) {
@@ -68,13 +102,15 @@ export class TtlSessionStore {
             if (requireExisting && isNotFound(err)) {
                 throw err;
             }
-            return this.createAndStore(id);
+            return this.createAndStore(id, placement);
         }
     }
-    async createAndStore(id) {
-        const session = await this.repo.create(id ? { id } : {});
+    async createAndStore(id, placement) {
+        const session = await this.repo.create({ ...(id !== undefined ? { id } : {}), ...(placement !== undefined ? { placement } : {}) });
         const meta = await session.getMetadata();
-        this.entries.set(meta.id, { session, lastActiveAt: Date.now(), createdAt: meta.createdAt, ...(meta.forkedFrom !== undefined ? { forkedFrom: meta.forkedFrom } : {}) });
+        if (meta.placement === undefined)
+            this.pendingPlacedDeletes.delete(meta.id);
+        this.entries.set(meta.id, { session, lastActiveAt: Date.now(), createdAt: meta.createdAt, ...(meta.forkedFrom !== undefined ? { forkedFrom: meta.forkedFrom } : {}), ...(meta.placement !== undefined ? { placement: meta.placement } : {}) });
         return session;
     }
     touch(sessionId) {
@@ -92,6 +128,7 @@ export class TtlSessionStore {
     }
     async list() {
         return [...this.entries.entries()]
+            .filter(([, e]) => e.placement === undefined)
             .map(([sessionId, e]) => ({
             sessionId,
             lastActiveAt: e.lastActiveAt,
@@ -137,12 +174,43 @@ export class TtlSessionStore {
             return;
         }
         const e = this.entries.get(sessionId);
-        if (!e) {
+        if (e !== undefined && e.placement === undefined)
+            this.pendingPlacedDeletes.delete(sessionId);
+        let placed = e !== undefined ? e.placement !== undefined : this.pendingPlacedDeletes.has(sessionId);
+        if (!placed && e === undefined && this.placements !== undefined) {
+            const probe = this.repo.placementOf;
+            if (typeof probe === "function") {
+                try {
+                    placed = (await probe.call(this.repo, sessionId)) !== undefined;
+                }
+                catch {
+                    placed = false;
+                }
+            }
+        }
+        if (!e && !placed) {
+            return;
+        }
+        if (placed) {
+            this.pendingPlacedDeletes.add(sessionId);
+            this.entries.delete(sessionId);
+            let settleGate;
+            this.deletingPlaced.set(sessionId, new Promise((r) => (settleGate = r)));
+            try {
+                const meta = e !== undefined ? await e.session.getMetadata() : { id: sessionId, createdAt: "" };
+                await this.repo.delete(meta);
+            }
+            finally {
+                this.deletingPlaced.delete(sessionId);
+                settleGate();
+            }
+            this.pendingPlacedDeletes.delete(sessionId);
+            this.owners.delete(sessionId);
             return;
         }
         this.entries.delete(sessionId);
         if (this.evictPolicy === "delete") {
-            await this.repo.delete(await e.session.getMetadata());
+            await this.repo.delete(e !== undefined ? await e.session.getMetadata() : { id: sessionId, createdAt: "" });
             this.owners.delete(sessionId);
         }
     }
@@ -174,7 +242,7 @@ export class TtlSessionStore {
             }
             if (now - e.lastActiveAt > this.defaultTtlMs) {
                 this.entries.delete(id);
-                if (this.evictPolicy === "delete") {
+                if (this.evictPolicy === "delete" && e.placement === undefined) {
                     void this.repo.delete({ id, createdAt: "" }).then(() => {
                         this.owners.delete(id);
                     }, () => { });

package/dist/core/session.d.ts

@@ -7,8 +7,43 @@ export { SessionError } from "../internal/harness.js";
 export type { SessionWriteOptions } from "../internal/harness.js";
 import type { Session } from "../internal/harness.js";
 import type { SessionTreeEntry } from "../internal/harness.js";
+export type { SessionPlacementRecord } from "../internal/harness.js";
 /** True when `err` is a session optimistic-lock conflict (a concurrent writer won the branch leaf). */
 export declare function isSessionConflict(err: unknown): boolean;
+/**
+ * Subagent transcript persistence — the ACQUIRE-form placement declaration a trusted spawner passes
+ * when it creates a subagent's transcript session: the session is created INTO the store's subagent
+ * partition instead of the host lane. The minter reports the fact; the store never guesses residency
+ * from call shape. `placedAt` is stamped by the store at creation (see
+ * {@link SessionPlacementRecord}). Reaches stores ONLY through the engine's trusted internals chain
+ * (never a public TaskSpec key — a public key would let any caller push arbitrary sessions into the
+ * partition and poison store-side retention/enumeration).
+ */
+export interface SessionPlacement {
+    kind: "subagent";
+    /** Tenant key, same source as the durable agent row's `scope`. */
+    scope?: string;
+    /** The spawning host session (retrieval/partition metadata; authorization stays on the row predicate). */
+    parentSessionId?: string;
+    /** The delegation tree's root host session (fixed point). */
+    rootSessionId?: string;
+    /** The durable agent row key (`a…`) — the store-side join key for orphan GC. */
+    handle?: string;
+}
+/**
+ * One row of {@link SessionStore.listPlaced}. The row-store join key is the FULL `(scope, handle)`
+ * tuple — a listing that cannot supply both returns the discriminated `tupleIncomplete` variant
+ * instead (consumers fail closed on it: never age-reaped, reported honestly).
+ */
+export type PlacedSessionRow = {
+    sessionId: string;
+    placedAt: number;
+} & ({
+    scope: string;
+    handle: string;
+} | {
+    tupleIncomplete: true;
+});
 /** A session handed back by a {@link SessionStore}: the harness `Session` plus its resolved id. */
 export interface AcquiredSession {
     session: Session;
@@ -66,13 +101,47 @@ export interface SessionStore {
      * fact.
      */
     readonly durability?: import("./checkpoint-store.js").StoreDurability;
+    /**
+     * Subagent transcript persistence — the store's PER-PLACEMENT durability declaration: "this store
+     * understands and honors placement semantics (partitioning + the obligations below), and sessions
+     * placed into the `subagent` partition have THIS durability". Declaration, never duck-typing (the
+     * wiring manifest relays it verbatim). The store-level {@link durability} continues to describe
+     * only UN-placed sessions — a routing/composite store whose transient host lane and durable
+     * subagent partition differ can therefore be honest on both axes. ABSENT = the store does not
+     * understand placement: an `acquire` carrying one is legally IGNORED (the session is then an
+     * ordinary one, and the deployment's delegation-durability tier reads as rows-only).
+     *
+     * Declaring this commits the store to the placement obligations:
+     *  1. a placed session enjoys the declared durability (`acquire(id, {requireExisting:true})`
+     *     reaches it after a restart when `"durable"`);
+     *  2. placed sessions do NOT appear on host enumeration faces (`list()` and every deployment
+     *     listing path — restart-stable);
+     *  3. acquire semantics for sessions WITHOUT a placement are byte-unchanged;
+     *  4. `release(placedId)` is a REAL deletion (durable history included) — the joint reap's
+     *     "row and session both gone" depends on it;
+     *  5. placement is FIRST-WRITE IMMUTABLE — a re-open (`requireExisting`, with or without a
+     *     placement argument) returns the same session and never rewrites the tuple;
+     *  6. a placed id cannot be CLAIMED: a later claim-form acquire (no `requireExisting`, no
+     *     creation placement) of an existing placed id refuses loudly
+     *     (`SessionError("placement_refused")`) instead of attaching.
+     */
+    readonly placements?: {
+        subagent?: {
+            durability: "durable" | "process-local";
+        };
+    };
     /** Get an existing session by id, or create one (optionally with a caller-supplied id). design/114 Phase3:
      *  `opts.requireExisting` ⇒ a store MUST fail loud (throw a `not_found` {@link SessionError}) on a genuinely
      *  missing id rather than create-on-miss — so a reuse-style warm-resume of a gone session errors instead of
      *  silently starting a fresh empty run. A store that cannot honor it MUST still not silently create (either
-     *  implement the check or reject the option). */
+     *  implement the check or reject the option).
+     *  `opts.placement` (subagent transcript persistence): CREATE the session into the named placement
+     *  partition (see {@link SessionPlacement} — trusted-internals channel only). Ignored by stores
+     *  that do not declare {@link placements}; on a store that does, the creating call is exempt from
+     *  obligation 6 above and idempotent re-acquire by the same trusted chain stays legal. */
     acquire(sessionId?: string, opts?: {
         requireExisting?: boolean;
+        placement?: SessionPlacement;
     }): Promise<AcquiredSession>;
     /** Mark a session recently active (resets idle TTL where applicable). May be async for durable stores. */
     touch(sessionId: string): void | Promise<void>;
@@ -115,6 +184,19 @@ export interface SessionStore {
      * that cannot enumerate omits this (the shell then has no session-list affordance — honest degrade).
      */
     list?(): Promise<SessionStoreSummary[]>;
+    /**
+     * Subagent transcript persistence — enumerate the PLACED partition (the input to the joint reap's
+     * partition leg: sessions whose owning agent row is gone are the orphan shape it collects).
+     * **Optional**: absent = the partition-GC leg is simply unavailable on this store (documented,
+     * fail-closed — placed sessions then age out only through the row-joined reap path). `olderThanMs`
+     * filters by session AGE (last activity where knowable, else `placedAt`); `scope` narrows to one
+     * tenant. Rows return the FULL `(scope, handle)` join tuple or the honest `tupleIncomplete`
+     * variant (see {@link PlacedSessionRow}) — consumers must skip incomplete tuples, never guess.
+     */
+    listPlaced?(kind: "subagent", opts?: {
+        olderThanMs?: number;
+        scope?: string;
+    }): Promise<PlacedSessionRow[]>;
     /**
      * design/110 — FORK a session: copy `sourceId`'s durable history (root→leaf) into a NEW session and return its
      * id (or `null` if the source doesn't exist). The forked session is independent (writes to it don't touch the

package/dist/core/task-registry-agent.d.ts

@@ -1,6 +1,17 @@
 import { type BackgroundAgentRecord, type BackgroundAgentStore } from "./background-agent-store.js";
 import { type StopSource, type TaskAccess, type TaskRetrievalStatus, type UnifiedTaskOutput, type UnifiedTaskResult, type BackgroundAgentTaskHandle, type DurableAgentCore, type ParkedClaimTicket, type RegisterBackgroundAgentInput } from "./task-registry-shared.js";
 import { type ToolResultStore } from "./tool-result-store.js";
+/**
+ * Subagent transcript persistence (delegation entry caps) — the ACTIVE handles of one delegation
+ * tree in THIS process's registry: `background_agent` handles whose status is running/pending
+ * (parked does not burn a concurrency slot — a suspension is not concurrency; terminal handles are
+ * not active) under the `(scope, rootSessionId)` key (full depth: a grandchild's row carries the
+ * tree's fixed-point root, so the whole tree shares one pool; a depth-1 row whose rootSessionId
+ * predates the floor falls back to its parentSessionId — same fallback the access predicate's root
+ * arm rides). SYNCHRONOUS by contract: the caps enforcement runs check→register in one synchronous
+ * segment, which is what makes the reservation race-free in-process.
+ */
+export declare function activeDelegationHandlesLane(core: DurableAgentCore, scope: string, rootSessionId: string): string[];
 export declare function ensureDurableHeartbeatLane(core: DurableAgentCore): void;
 /** design/151 S1a — enqueue one durable-row write (see {@link DurableAgentLane} for the lane
  *  contract). `patch` is captured at CALL time (the settle-site values), applied in chain order.
@@ -66,9 +77,25 @@ export declare function endDurableClaimLane(core: DurableAgentCore, id: string):
  *  transcript lives on unanchored — the exact strand this orchestration exists to prevent. */
 export declare function reapDurableAgentsLane(core: DurableAgentCore, scope: string, deps: {
     store: BackgroundAgentStore;
+    /** `listPlaced` (subagent transcript persistence, optional): arms the PARTITION leg below —
+     *  placed transcript sessions whose owning row is GONE (row never landed / deleted-but-release-
+     *  failed) are the orphan shape only a session-side enumeration can find. Absent = that leg is
+     *  unavailable (documented; the row-joined path still runs). */
     sessions?: {
         unpin?(sessionId: string): unknown;
         release(sessionId: string): Promise<void> | void;
+        listPlaced?(kind: "subagent", opts?: {
+            olderThanMs?: number;
+            scope?: string;
+        }): Promise<Array<{
+            sessionId: string;
+            placedAt: number;
+        } & ({
+            scope: string;
+            handle: string;
+        } | {
+            tupleIncomplete: true;
+        })>>;
     };
     /** design/151 §7.7 (F-13) — the row's mailbox dies with the row: a WINNING delete also drops
      *  the (scope, handle) mailbox (advisory — a mailbox fault never blocks the reap; an orphaned
@@ -86,6 +113,7 @@ export declare function reapDurableAgentsLane(core: DurableAgentCore, scope: str
     rowsReaped: number;
     sessionsReleased: number;
     skippedNoSessions: number;
+    orphanPlacedReleased: number;
 }>;
 /** codex 终审 C-4 half — after a probe-false RELEASE the row must stop claiming a transcript:
  *  the heartbeat's F-1 arm keeps re-driving a flush-failed lane, so a later successful flush

package/dist/core/task-registry-agent.js

@@ -7,6 +7,23 @@ import { delimitUntrusted } from "./untrusted-text.js";
 import { boundedRedactedSummary } from "./untrusted-egress.js";
 import { mintCompletionId, commitCompletionIdIfEmpty, clipTaskOutput, assertOwnership, sleepPollStep, alreadyTerminalStopNote, canAccess, normalizeAgentName, closestName, DURABLE_AGENT_HEARTBEAT_MS, DURABLE_AGENT_HANDLE_RE, BG_AGENT_REAP_STOP_ERROR, } from "./task-registry-shared.js";
 import { buildToolResultRef, OFFLOAD_TOOL_NAME, toolResultProvenanceOf } from "./tool-result-store.js";
+export function activeDelegationHandlesLane(core, scope, rootSessionId) {
+    const out = [];
+    for (const h of core.handles.values()) {
+        if (h.type !== "background_agent")
+            continue;
+        if (h.status !== "running" && h.status !== "pending")
+            continue;
+        if (h.scope !== scope)
+            continue;
+        const bh = h;
+        const root = bh.rootSessionId ?? bh.parentSessionId ?? (bh.sessionScoped ? bh.owner : undefined);
+        if (root !== rootSessionId)
+            continue;
+        out.push(h.id);
+    }
+    return out;
+}
 export function ensureDurableHeartbeatLane(core) {
     if (core.durableHeartbeatTimer !== undefined)
         return;
@@ -170,7 +187,7 @@ export async function reapDurableAgentsLane(core, scope, deps, policy) {
         await deps.store.reap(scope, now, { staleRunningMaxAgeMs: policy.staleRunningMaxAgeMs });
     }
     if (policy.maxAgeMs === undefined && policy.keep === undefined)
-        return { rowsReaped: 0, sessionsReleased: 0, skippedNoSessions: 0 };
+        return { rowsReaped: 0, sessionsReleased: 0, skippedNoSessions: 0, orphanPlacedReleased: 0 };
     const terminal = (await deps.store.listByScope(scope)).filter((r) => r.status !== "running" && r.status !== "parked");
     terminal.sort((a, b) => b.spawnedAt - a.spawnedAt);
     const doomed = new Map();
@@ -239,7 +256,51 @@ export async function reapDurableAgentsLane(core, scope, deps, policy) {
             core.reapedHandles.delete(r.handle);
         }
     }
-    return { rowsReaped, sessionsReleased, skippedNoSessions };
+    let orphanPlacedReleased = 0;
+    if (policy.maxAgeMs !== undefined && deps.sessions !== undefined && typeof deps.sessions.listPlaced === "function") {
+        let placed = [];
+        try {
+            placed = await deps.sessions.listPlaced("subagent", { olderThanMs: policy.maxAgeMs, scope });
+        }
+        catch {
+            placed = [];
+        }
+        for (const p of placed) {
+            if ("tupleIncomplete" in p)
+                continue;
+            if (p.scope !== scope)
+                continue;
+            if (core.claimingHandles.has(p.handle) || core.reapingHandles.has(p.handle))
+                continue;
+            let row;
+            try {
+                row = await deps.store.get(p.handle, scope);
+            }
+            catch {
+                continue;
+            }
+            if (row !== null)
+                continue;
+            const inProc = core.handles.get(p.handle);
+            if (inProc !== undefined && (inProc.status === "running" || inProc.status === "pending" || inProc.status === "parked"))
+                continue;
+            try {
+                await deps.sessions.unpin?.(p.sessionId);
+                await deps.sessions.release(p.sessionId);
+                orphanPlacedReleased++;
+            }
+            catch {
+            }
+            if (deps.mailbox !== undefined) {
+                try {
+                    await deps.mailbox.drop(scope, p.handle);
+                }
+                catch {
+                }
+            }
+        }
+    }
+    return { rowsReaped, sessionsReleased, skippedNoSessions, orphanPlacedReleased };
 }
 export function releaseDurableTranscriptAnchorLane(core, id) {
     const handle = core.handles.get(id);

package/dist/core/task-registry.d.ts

@@ -166,9 +166,24 @@ export declare class TaskRegistry {
     endDurableClaim(id: string): void;
     reapDurableAgents(scope: string, deps: {
         store: BackgroundAgentStore;
+        /** `listPlaced` (subagent transcript persistence, optional) arms the partition-orphan leg —
+         *  see {@link reapDurableAgentsLane}. Pass the deployment's SessionStore directly (the
+         *  TtlSessionStore over a placement-capable repo exposes it). */
         sessions?: {
             unpin?(sessionId: string): unknown;
             release(sessionId: string): Promise<void> | void;
+            listPlaced?(kind: "subagent", opts?: {
+                olderThanMs?: number;
+                scope?: string;
+            }): Promise<Array<{
+                sessionId: string;
+                placedAt: number;
+            } & ({
+                scope: string;
+                handle: string;
+            } | {
+                tupleIncomplete: true;
+            })>>;
         };
         /** design/151 §7.7 (F-13) — the row's mailbox dies with the row: a WINNING delete also drops
          *  the (scope, handle) mailbox (advisory — a mailbox fault never blocks the reap; an orphaned
@@ -186,6 +201,7 @@ export declare class TaskRegistry {
         rowsReaped: number;
         sessionsReleased: number;
         skippedNoSessions: number;
+        orphanPlacedReleased: number;
     }>;
     releaseDurableTranscriptAnchor(id: string): void;
     bindBackgroundAgentSession(id: string, sessionId: string): void;
@@ -270,6 +286,11 @@ export declare class TaskRegistry {
     /** #258 — the row's current stop-cycle counter, read by the spawn lanes right after registering to
      *  thread into the child's `RunInternals.cycleSeq`; see {@link backgroundAgentCycleSeqLane}. */
     backgroundAgentCycleSeq(id: string): number | undefined;
+    /** Subagent transcript persistence (delegation entry caps) — one delegation tree's ACTIVE
+     *  (running/pending) a* handles in THIS process, keyed `(scope, rootSessionId)`; SYNCHRONOUS by
+     *  contract (the caps check and the registration form one atomic segment). See
+     *  {@link activeDelegationHandlesLane}. */
+    activeDelegationHandles(scope: string, rootSessionId: string): string[];
     /** ASYNC (revive arbitration) — the durable half is a guarded ownership claim on the row (awaited before the
      *  in-memory flip), so this leg and a cross-process claim arbitrate in one domain instead of both
      *  believing they own the cycle. See {@link reviveBackgroundAgentLane}. */

package/dist/core/task-registry.js

@@ -10,7 +10,7 @@ import { registerWorkflowLane, pollWorkflowLane, stopWorkflowLane } from "./task
 import { mintCompletionId, canAccessWorkflowRun, formatWorkflowRun, clipTaskOutput, assertOwnership, sleepPollStep, statusFromBackground, rollSpoolText, accountDroppedBytes, renderSpoolBody, spoolDropNote, droppedGapNote, alreadyTerminalStopNote, terminalTaskSummary, TASK_OUTPUT_MAX_CHARS, MONITOR_BATCH_WINDOW_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_MAX_TIMEOUT_MS, MONITOR_MAX_BATCHES_PER_MINUTE, canAccess, DURABLE_AGENT_HANDLE_RE, } from "./task-registry-shared.js";
 export { normalizeAgentName, DURABLE_AGENT_HEARTBEAT_MS, DURABLE_AGENT_HANDLE_RE, BG_AGENT_REAP_STOP_ERROR } from "./task-registry-shared.js";
 import { TASK_OUTPUT_TOOL_NAME, TASK_STOP_TOOL_NAME, TASK_OUTPUT_CONTRACT, TASK_STOP_CONTRACT, TASK_OUTPUT_MISSING_ID_MESSAGE, TASK_STOP_MISSING_ID_MESSAGE, TASK_STOP_PARAMS, resolveTaskIdArg, REGISTRY_TASK_TOOL_CAPS, composeTaskOutputDescription, composeTaskOutputParams, composeTaskStopDescription, } from "./task-tool-shape.js";
-import { durableAgentArmedLane, durableAgentRowProbeLane, beginDurableClaimLane, endDurableClaimLane, reapDurableAgentsLane, noteBackgroundAgentActivityLane, reapStaleSessionBackgroundAgentsLane, releaseDurableTranscriptAnchorLane, bindBackgroundAgentSessionLane, registerBackgroundAgentLane, recordBackgroundAgentOrgAdmissionLane, parkBackgroundAgentLane, reconcileParkedAgentsLane, claimParkedAgentLane, rollbackParkedClaimLane, consumeParkedFlipLane, finalizeParkedResumeLane, settleBackgroundAgentLane, abortBackgroundAgentsForOwnerLane, serveDurableAgentRowLane, resolveBackgroundAgentByNameLane, backgroundAgentCycleSeqLane, markRetainedContinuationLane, reviveBackgroundAgentLane, settleRevivedAgentLane, unmarkRetainedContinuationLane, attachAgentNotifyLane, deliverToRunningAgentLane, runningBackgroundAgentLabelsLane, runningAgentFooterLane, notFoundRunningAgentsTail, pollBackgroundAgentLane, stopBackgroundAgentLane, } from "./task-registry-agent.js";
+import { durableAgentArmedLane, durableAgentRowProbeLane, beginDurableClaimLane, endDurableClaimLane, reapDurableAgentsLane, noteBackgroundAgentActivityLane, reapStaleSessionBackgroundAgentsLane, releaseDurableTranscriptAnchorLane, bindBackgroundAgentSessionLane, registerBackgroundAgentLane, recordBackgroundAgentOrgAdmissionLane, parkBackgroundAgentLane, reconcileParkedAgentsLane, claimParkedAgentLane, rollbackParkedClaimLane, consumeParkedFlipLane, finalizeParkedResumeLane, settleBackgroundAgentLane, abortBackgroundAgentsForOwnerLane, serveDurableAgentRowLane, resolveBackgroundAgentByNameLane, backgroundAgentCycleSeqLane, activeDelegationHandlesLane, markRetainedContinuationLane, reviveBackgroundAgentLane, settleRevivedAgentLane, unmarkRetainedContinuationLane, attachAgentNotifyLane, deliverToRunningAgentLane, runningBackgroundAgentLabelsLane, runningAgentFooterLane, notFoundRunningAgentsTail, pollBackgroundAgentLane, stopBackgroundAgentLane, } from "./task-registry-agent.js";
 export { canAccessWorkflowRun, clipTaskOutput, MONITOR_BATCH_WINDOW_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_MAX_TIMEOUT_MS, MONITOR_MAX_BATCHES_PER_MINUTE };
 const BLOCK_DEFAULT_TIMEOUT_MS = 30_000;
 const BLOCK_MAX_TIMEOUT_MS = 600_000;
@@ -194,6 +194,9 @@ export class TaskRegistry {
     backgroundAgentCycleSeq(id) {
         return backgroundAgentCycleSeqLane(this.core, id);
     }
+    activeDelegationHandles(scope, rootSessionId) {
+        return activeDelegationHandlesLane(this.core, scope, rootSessionId);
+    }
     reviveBackgroundAgent(id, access, abort) {
         return reviveBackgroundAgentLane(this.core, id, access, abort);
     }