@sema-agent/core 5.47.0 → 5.48.0

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);
     }

package/dist/core/types.d.ts

@@ -643,6 +643,27 @@ export interface ToolExecuteContext {
      * Undefined when the tool runs outside a Runner task.
      */
     reminderMark?: string;
+    /**
+     * design/319 (B ticket) — the RUNNING task's reminder-disclosure trigger counters
+     * ({@link import("./reminder-disclosure.js").ReminderDisclosureCounts}), Runner-filled on the same
+     * trusted seat as {@link reminderMark}. Caller-mounted verbatim outlets that run the
+     * detect-and-disclose pipeline (the web tools' exact-mark defuse arm) bump their `<outlet>.<form>`
+     * keys here; the Runner folds the non-zero result into
+     * `TaskResult.stats.mechanisms.reminderDisclosures`. Mutable by design (a counter seat), but only
+     * ever additive — never a decision input. Undefined outside a Runner task.
+     */
+    reminderDisclosureCounts?: import("./reminder-disclosure.js").ReminderDisclosureCounts;
+    /**
+     * Subagent transcript persistence — the RESOLVED delegation entry caps for this run
+     * ({@link RunnerDeps.delegationEntryCaps} after prepare's loud validation; both members always
+     * present). Runner-filled trusted seat, never a model argument — the Agent tool's background lane
+     * reads it at its registration point. Undefined outside a Runner task (the lane then applies the
+     * exported defaults itself, so a directly-driven tool is bounded too).
+     */
+    delegationEntryCaps?: {
+        maxConcurrent: number;
+        maxCumulativePerSession: number;
+    };
     /**
      * Report usage spent in a nested run this tool spawned (e.g. a sub-agent). The Runner accumulates
      * it into the parent task's `TaskResult.stats.nested`, so delegated cost — the multi-agent "~15×"
@@ -3295,6 +3316,15 @@ export interface TaskResult {
                 reps: number;
                 segment: string;
             }>;
+            /** design/319 (B ticket, G9② observation seat) — reminder-disclosure trigger counts for the
+             *  leg, keyed `<outlet>.<form>`: outlets `read` / `notebook` / `pdf` / `mcp` / `webFetch` /
+             *  `webSearch`; forms `bare` (bare-form trailer appended), `marked` (marked-form trailer —
+             *  never throttled), `bare_throttled` (a bare trailer suppressed by the 60s per-key window),
+             *  `defused` (an MCP/web segment's exact-mark bytes were rewritten — the lane's one sanctioned
+             *  byte change, always paired with a `marked` disclosure). Present only when ≥1 key is
+             *  non-zero. This is the D-4/D-6 re-ruling data (defuse/trailer widening to Read/Bash/Grep):
+             *  a reading, never a gate. */
+            reminderDisclosures?: Record<string, number>;
         };
         /**
          * design/91 — **human-review burden** (design/89 §2.4 C2 axis). The wall-clock time a task spent waiting
@@ -4800,6 +4830,14 @@ export interface EngineNotice {
      *    mark would have carried, neutralized/length-bounded (tool and agent-type names are
      *    host/model-controlled inputs).
      *
+     *  - `"delegation.transcript_integrity"` (subagent transcript persistence) — a durable agent row
+     *    with a BOUND transcript sessionId met a session store that attests `not_found` for it: the
+     *    deployment's declared transcript durability is being contradicted by reality. Announced at
+     *    most once per (handle, process) from the continuation read faces (SendMessage preflight /
+     *    AgentTranscript's durable leg); the per-call honest refusals are unchanged, and the declared
+     *    tier is NOT auto-downgraded (declaration-制 — observation reports, it never re-adjudicates);
+     *    `detail: { handle }`.
+     *
      *  Deliberately NOT a notice family: brain retry/reconnect liveness (a rate limit, a 5xx, a
      *  transient network failure being retried). Those are per-attempt liveness frames with their own
      *  frequency semantics and ride the wire `status` channel ({@link BrainStatus}), whose sink the
@@ -5305,6 +5343,28 @@ export interface RunnerDeps {
      *  Same single-instance pairing discipline as `backgroundAgentStore` (RB-37): a deployment that
      *  composes its own tools must thread the SAME instance everywhere. */
     mailboxStore?: import("./mailbox-store.js").MailboxStore;
+    /**
+     * Subagent transcript persistence — the delegation ENTRY caps (CC parity values: 20 concurrent /
+     * 200 cumulative per session tree; defaults exported as `DELEGATION_MAX_CONCURRENT_DEFAULT` /
+     * `DELEGATION_MAX_PER_SESSION_DEFAULT`). Key = `(scope, rootSessionId)`, full depth (grandchildren
+     * share the tree's pool). `maxConcurrent` bounds running/pending a* handles in this process's
+     * registry (parked does not burn a slot — a suspension is not concurrency; a revival claim counts
+     * like a spawn); `maxCumulativePerSession` bounds the RETAINED-WINDOW cumulative count (registry-
+     * retained + store-retained rows — a reaped row returns its quota; deliberately NOT CC's lifetime-
+     * monotonic session counter, which would require a persistent counting surface this economic bound
+     * does not justify — registered divergence). Refusals are coded (`delegation.concurrency_cap` /
+     * `delegation.session_cap`) with the current value and this knob's name in the text.
+     *
+     * BAD VALUES REFUSE LOUDLY at prepare (`config.delegation_entry_caps`, the #123 posture): a
+     * non-positive/non-integer/NaN member, or a resolved pair where `maxConcurrent` exceeds
+     * `maxCumulativePerSession` (you cannot run more at once than you may ever create) — never a
+     * silent fold to the defaults. Per-replica bound (multi-replica deployments are each honestly
+     * bounded; row-level CAS owns correctness, this cap owns economics).
+     */
+    delegationEntryCaps?: {
+        maxConcurrent?: number;
+        maxCumulativePerSession?: number;
+    };
     /** design/176 — deployment tuning for the always-on peer-message admission gate (SendMessage entry
      *  judgment: rate/dedup/hop-chain/queue bounds). Per-field range-validated against the upstream
      *  table with out-of-range values falling back to that field's default; there is NO off switch —