@wowyuarm/dsh-agent-team 0.1.7 → 0.1.9

package/packages/agent-team/lib/index.js

@@ -39,6 +39,58 @@ var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn,
     if (target) Object.defineProperty(target, contextIn.name, descriptor);
     done = true;
 };
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { randomUUID } from 'node:crypto';
 import { isDeepStrictEqual } from 'node:util';
 import { Service } from '@deepseek-ai/cordis';
@@ -46,13 +98,17 @@ import { installModelSelection } from '@deepseek-ai/dsh-agent';
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
 import { scopeOf } from '@deepseek-ai/dsh-scope';
-import { SessionId } from '@deepseek-ai/dsh-session';
+import { SessionId, SessionLogOffset } from '@deepseek-ai/dsh-session';
 import { setSandboxMode } from '@deepseek-ai/dsh-sandbox-policy';
 import { Remote, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import { ATTACHMENT_MAX_BYTES, attachmentPayloadPath, attachmentsRoot, copyPathAttachment, newAttachmentId, readAttachment, sanitizeMediaType, sweepAttachmentCache, validatePathAttachment, writeAttachment } from "./attachments.js";
-import { acceptedTaskCompactionMembers, AutoCompactionCoordinator, PRE_COMPACTION_NOTICE_SUMMARY, preCompactionNoticeText } from "./auto-compaction.js";
+import { PressurePolicyCoordinator } from "./pressure-policy.js";
+import { ContextManagementCoordinator } from "./context-management.js";
+import { createHandoffMessage } from "./context-source.js";
+import { carriedInputOf, checkpointByRef, checkpointRefFor, foldContextProjection, isReminderNoticeSummary, timelineCandidates } from "./context-projection.js";
 import { AGENT_TEAM_HUMAN_MEMBER_ID, AgentTeamLedger, agentTeamHumanActor } from "./ledger.js";
-import { AGENT_TEAM_TOOL_NAMES, deepCopyCapabilities, MemberRuntime } from "./member-runtime.js";
+import { AGENT_TEAM_TOOL_NAMES, deepCopyCapabilities, memberMemoryDirectoryName, MemberRuntime } from "./member-runtime.js";
+import { ProgressNudgeCoordinator } from "./progress-nudge.js";
 import { classifyRecoverableError, RecoveryCoordinator, RECOVERY_MAX_CONSECUTIVE_ERRORS } from "./recovery.js";
 import { agentTeamDomainSpec } from "./spec.js";
 export { agentTeamDomainSpec, agentTeamOperationSchema } from "./spec.js";
@@ -64,6 +120,24 @@ const AGENT_TEAM_PLUGIN_ID = '@wowyuarm/dsh-agent-team';
 const INBOX_NOTICE_SUMMARY = 'Team Inbox has unread work.';
 const RECOVERY_NOTICE_SUMMARY = 'Recovery: continue your interrupted work.';
 const ORPHANED_MEMBER_DIAGNOSTIC = 'Member preset composition was lost after a reload; its tools are unavailable. Resume rebuilds the member in place.';
+/** Longest accepted model-supplied checkpoint display name. */
+const MAX_CHECKPOINT_NAME_CHARS = 120;
+/** Default and maximum number of timeline items one query returns. */
+const DEFAULT_TIMELINE_LIMIT = 12;
+const MAX_TIMELINE_LIMIT = 24;
+/** Deepest ancestor lineage the timeline and seed resolution walk. */
+const MAX_TIMELINE_ANCESTORS = 8;
+/** Product pressure budget constants (see docs/team-collaboration.md). */
+const CONTEXT_HARD_LIMIT_CAP = 256_000;
+const CONTEXT_HANDOFF_AT_CAP = 200_000;
+const CONTEXT_HANDOFF_RESERVE = 8_000;
+const CONTEXT_SAFE_OUTPUT_RESERVE = 16_000;
+/**
+ * Usage at or above which an acknowledged acceptance advises a fresh
+ * rollover instead of keeping the context; capped by the route's effective
+ * handoff budget so narrow routes get a proportionally earlier boundary.
+ */
+const ACCEPT_TASK_BOUNDARY_THRESHOLD = 128_000;
 function sameChangeScope(left, right) {
     if (left.kind === 'workspace' && right.kind === 'workspace')
         return left.workspaceId === right.workspaceId;
@@ -189,6 +263,8 @@ let AgentTeam = (() => {
         domain = __runInitializers(this, _instanceExtraInitializers);
         ledger;
         handles = new Map();
+        /** Live Member per session id; drives the root session/event listener. */
+        memberBySessionId = new Map();
         /** Live selection refs let model edits take effect without disposing the Session. */
         modelSelections = new Map();
         /** Agent ids with a turn in flight; restarts must wait for the boundary. */
@@ -214,7 +290,7 @@ let AgentTeam = (() => {
          * stale keys.
          */
         memberFailures = new Map();
-        autoCompaction;
+        pressurePolicy;
         notifiedInbox = new Map();
         attachmentGcTimer;
         recovery = new RecoveryCoordinator({
@@ -226,34 +302,62 @@ let AgentTeam = (() => {
                 this.ctx.logger.warn(`agent-team: member '${this.memberLabel(memberId)}' reached ${consecutiveFailures}/${RECOVERY_MAX_CONSECUTIVE_ERRORS} consecutive recoverable failures; leaving it in error for the operator`);
             },
         });
+        /**
+         * Advisory progress-visibility nudges. Purely in-process: the ledger owns
+         * eligibility, this coordinator owns counting and notices, and neither ever
+         * writes Team facts. See docs/team-collaboration.md for the regimes.
+         */
+        progressNudge = new ProgressNudgeCoordinator({
+            agentForMember: memberId => this.handles.get(memberId)?.agent,
+            targetsForMember: memberId => this.requireLedger().progressNudgeTargets(memberId),
+            sessionLogForMember: (memberId, sessionId) => {
+                const handle = this.handles.get(memberId);
+                if (handle === undefined || handle.agent.session.id !== sessionId)
+                    return undefined;
+                return { events: handle.agent.session.ownEvents() };
+            },
+            log: message => { this.ctx.logger.warn(message); },
+        });
+        /**
+         * Context self-management: the one deep module that turns a Member's
+         * successful `context_rollover` tool result into its next private context
+         * generation. The ledger owns the binding audit, the Session projection
+         * owns intent, and this coordinator owns only reconstructible process
+         * state. See docs/architecture.md and docs/team-collaboration.md.
+         */
+        contextManagement = new ContextManagementCoordinator({
+            agentForMember: memberId => this.handles.get(memberId)?.agent,
+            memberForAgent: agent => this.memberForAgent(agent),
+            projectionForMember: (memberId, sessionId) => {
+                const handle = this.handles.get(memberId);
+                if (handle === undefined || handle.agent.session.id !== sessionId)
+                    return undefined;
+                return foldContextProjection(handle.agent.session.ownEvents(), handle.agent.session.inheritedEventCount, handle.agent.session.id);
+            },
+            executeTransition: (memberId, plan) => this.executeMemberTransition(memberId, plan),
+            log: message => { this.ctx.logger.warn(`agent-team: ${message}`); },
+        });
         lifecycleTail = Promise.resolve();
         accepting = true;
         changeVersion = 0;
         changeWaiters = new Set();
         constructor(ctx) {
             super(ctx, 'agentTeam');
-            this.autoCompaction = new AutoCompactionCoordinator({
+            this.pressurePolicy = new PressurePolicyCoordinator({
                 agentForMember: memberId => this.handles.get(memberId)?.agent,
+                memberForAgent: agent => {
+                    const member = this.memberForAgent(agent);
+                    return member === undefined ? undefined : { memberId: member.memberId, sessionId: agent.id };
+                },
                 compactionForAgent: agent => this.ctx.agentPresets.serviceFor(agent, 'compaction'),
-                reactivate: memberId => this.reactivateMember(memberId),
+                limitsForAgent: agent => this.routeLimitsForAgent(agent),
+                activeClaimLabels: memberId => this.activeClaimLabels(memberId),
+                runningJobLabels: memberId => this.runningJobLabels(memberId),
                 failed: (memberId, _sessionId, diagnostic) => {
                     this.setMemberFailure(memberId, 'compaction', diagnostic);
                     this.emitAutoCompactionChanged(memberId);
                 },
-                cleared: memberId => {
-                    if (!this.clearMemberFailure(memberId, 'compaction'))
-                        return;
-                    this.emitAutoCompactionChanged(memberId);
-                },
                 log: message => { this.ctx.logger.warn(`agent-team: ${message}`); },
-                // Advisory only: the Agent decides whether anything is worth persisting.
-                steerPreCompaction: agent => {
-                    const hint = createUserMessage({
-                        content: [{ type: 'text', text: preCompactionNoticeText() }],
-                        source: { kind: 'plugin', plugin: AGENT_TEAM_PLUGIN_ID, form: 'notice', summary: PRE_COMPACTION_NOTICE_SUMMARY },
-                    });
-                    agent.steer(hint);
-                },
             });
         }
         /** Open the durable ledger and restore every enabled Member independently. */
@@ -281,7 +385,12 @@ let AgentTeam = (() => {
                     if (recovered)
                         this.notifiedInbox.delete(member.memberId);
                     this.emitChanged([{ kind: 'workspace', workspaceId: member.workspaceId }]);
-                    this.notifyMember(agent);
+                    // A rollover/recovery in flight delivers its own sequenced
+                    // rederived Inbox after the handoff and carried input; a status-driven
+                    // steer here would claim the handoff turn's next step and leapfrog
+                    // the carried messages.
+                    if (!this.contextManagement.isTransitioning(member.memberId))
+                        this.notifyMember(agent);
                 }
                 // A turn that ends without an error closes any automatic recovery episode.
                 // The idle transition is itself presence-affecting (working → available),
@@ -295,11 +404,37 @@ let AgentTeam = (() => {
                     this.emitChanged([{ kind: 'workspace', workspaceId: member.workspaceId }]);
                 }
             });
+            // Progress nudges count every `tool/call` of each Member Session. The
+            // store's dispatch carrier is untagged, so a scope-tagged listener inside
+            // the Agent setup would receive nothing; one root listener that maps the
+            // session id back to its Member is the seam that works (same shape as the
+            // `agent/status` listener above). The first turn of a freshly published
+            // Member cannot race this: `handles.set()` precedes the same activation
+            // continuation that publishes the Agent, so by the time any tool call
+            // streams, the map lookup succeeds.
+            this.ctx.on('session/event', (session, event) => {
+                const memberId = this.memberBySessionId.get(session.id);
+                if (memberId === undefined)
+                    return;
+                const handle = this.handles.get(memberId);
+                if (handle === undefined || handle.agent.session.id !== session.id)
+                    return;
+                this.progressNudge.onSessionEvent(memberId, session.id, handle.agent, event);
+                // A successful assistant response ends any open provider-overflow
+                // recovery sequence for this Member.
+                if (event.type === 'assistant/message')
+                    this.pressurePolicy.onAssistantMessage(handle.agent);
+                // Context management reacts only after a successful durable tool/result;
+                // the projection (not this listener) decides what that means.
+                this.contextManagement.onSessionEvent(memberId, handle.agent, event);
+            });
             const domain = await this.ctx.storageDomain.open(agentTeamDomainSpec);
             this.ctx.effect(() => async () => {
                 this.accepting = false;
                 this.recovery.dispose();
-                await this.autoCompaction.dispose();
+                this.progressNudge.dispose();
+                this.contextManagement.dispose();
+                this.pressurePolicy.dispose();
                 if (this.attachmentGcTimer !== undefined)
                     clearInterval(this.attachmentGcTimer);
                 this.attachmentGcTimer = undefined;
@@ -321,7 +456,7 @@ let AgentTeam = (() => {
             this.startAttachmentGc(ledger);
             // One metadata listing serves every Member restore; per-member list calls
             // would repeat the same I/O linearly during startup.
-            const persistedSessions = new Set((await this.ctx.sessionPersistence.list()).map(header => header.id));
+            const persistedSessions = new Set((await this.persistedSessionHeaders()).map(header => header.id));
             for (const member of ledger.listMembers()) {
                 if (member.state === 'enabled')
                     await this.activateMember(member, undefined, persistedSessions);
@@ -329,6 +464,23 @@ let AgentTeam = (() => {
                     await this.memberRuntime.cleanupRemovedMember(member);
             }
         }
+        /**
+         * Whether one Member Session has durable persisted content, decided through
+         * {@link SessionPersistenceService.inspect} rather than a bare metadata
+         * listing: inspection first awaits any in-flight retirement drain for the
+         * id, so a resume racing a suspend's fire-and-forget final flush cannot
+         * mistake a still-draining persisted Session for an unpersisted one and
+         * fork a fresh generation over it.
+         */
+        async sessionPersisted(sessionId) {
+            try {
+                await this.ctx.sessionPersistence.inspect(sessionId);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
         /** Resolve one exact live Agent to its durable Team Member; forks do not inherit identity. */
         memberForAgent(agent) {
             for (const [memberId, handle] of this.handles) {
@@ -456,7 +608,7 @@ let AgentTeam = (() => {
                     presetId: request.presetId,
                     ...(request.model === undefined ? {} : { model: Object.freeze({ ...request.model }) }),
                     ...(request.capabilities === undefined ? {} : { capabilities: Object.freeze(deepCopyCapabilities(request.capabilities)) }),
-                    privateMemoryPath: dshHomePath('agent-team', 'members', memberId),
+                    privateMemoryPath: dshHomePath('agent-team', 'members', memberMemoryDirectoryName(memberId)),
                     state: 'enabled',
                 });
                 const result = await this.requireLedger().addMember({ ...request, actor: agentTeamHumanActor(), member });
@@ -485,7 +637,13 @@ let AgentTeam = (() => {
                 if (result.committed)
                     this.emitCommitted(result.value.receipt);
                 this.clearMemberNotificationState(result.value.member.memberId);
-                await this.activateMember(result.value.member);
+                // The suspended Session's log is durable once its retirement completes,
+                // and agents.resume() waits for exactly that retirement before loading.
+                // Consulting the persistence tree here instead would race the
+                // fire-and-forget retirement on Windows, where the JSONL backend
+                // publishes directories through transient staging entries that surface
+                // as ENOENT mid-walk — so pass the known session rather than re-listing.
+                await this.activateMember(result.value.member, undefined, new Set([result.value.member.sessionId]));
                 return Object.freeze({ receipt: result.value.receipt, status: this.memberStatus(result.value.member) });
             });
         }
@@ -563,18 +721,7 @@ let AgentTeam = (() => {
                     return Object.freeze({ receipt: result.value.receipt, status: this.memberStatus(result.value.member) });
                 }
                 const renewed = result.value.member;
-                // Drop the old handle's transient state: pending recovery episodes and
-                // error markers belong to the disposed agent, not to the Member.
-                this.recovery.stopTracking(request.memberId);
-                await active.dispose();
-                this.handles.delete(request.memberId);
-                this.modelSelections.delete(request.memberId);
-                this.memberRuntime.forgetMember(request.memberId);
-                this.clearMemberFailure(request.memberId, 'activation');
-                this.clearMemberNotificationState(request.memberId);
-                // The previous log survives on disk; archiving hides it from every
-                // grouping surface so one Member keeps exactly one visible Session.
-                await this.ctx.workspaceRegistry.archiveSession(previousSessionId);
+                await this.retireMemberGeneration(request.memberId, active, previousSessionId);
                 await this.activateMember(renewed, undefined, undefined, previousSessionId);
                 const reactivated = this.handles.get(request.memberId);
                 if (reactivated === undefined) {
@@ -585,6 +732,126 @@ let AgentTeam = (() => {
                 return Object.freeze({ receipt: result.value.receipt, status: this.memberStatus(renewed) });
             });
         }
+        /**
+         * Retire one Member's previous generation after its durable binding moved
+         * onto a new Session id: drop the old handle's transient state, dispose the
+         * Agent, and archive the old Session log (which stays on disk for history).
+         * Shared by the Human clear path and the model-initiated rollover.
+         */
+        async retireMemberGeneration(memberId, active, previousSessionId) {
+            // Drop the old handle's transient state: pending recovery episodes and
+            // error markers belong to the disposed agent, not to the Member.
+            this.recovery.stopTracking(memberId);
+            // The fresh Session may re-earn one Claim suggestion per Thread; the
+            // old Session's one-shot records must not leak into it.
+            this.progressNudge.stopTracking(memberId);
+            // The context admission gate stays armed through disposal: input racing
+            // the retire window must still be captured for the new generation, and
+            // the coordinator drops its own bookkeeping only after the swap settles.
+            this.memberBySessionId.delete(previousSessionId);
+            await active.dispose();
+            this.handles.delete(memberId);
+            this.modelSelections.delete(memberId);
+            this.memberRuntime.forgetMember(memberId);
+            this.clearMemberFailure(memberId, 'activation');
+            this.clearMemberNotificationState(memberId);
+            // The previous log survives on disk; archiving hides it from every
+            // grouping surface so one Member keeps exactly one visible Session.
+            await this.ctx.workspaceRegistry.archiveSession(previousSessionId);
+        }
+        /**
+         * Execute one prepared context rollover at a true idle boundary: commit the
+         * idempotent Member-actor operation, retire the previous generation, and
+         * activate the fresh Session whose first model-facing context is the
+         * Member's own handoff. Later non-Team input captured during the transition
+         * is delivered after the handoff; the Team Inbox is rederived from the
+         * ledger, never copied.
+         */
+        async executeMemberTransition(memberId, plan) {
+            await this.enqueueLifecycle(async () => {
+                this.requireAccepting();
+                const stored = this.requireLedger().getMember(memberId);
+                if (stored === undefined || stored.state !== 'enabled')
+                    throw new Error(`Agent Member '${memberId}' cannot roll over: not enabled`);
+                if (stored.sessionId !== plan.previousSessionId)
+                    throw new Error(`Agent Member '${stored.handle}' is no longer bound to the rolled-over Session`);
+                const active = this.handles.get(memberId);
+                if (active === undefined)
+                    throw new Error(`Agent Member '${stored.handle}' has no active session to roll over`);
+                // A racing turn the admission gate rejects still leaves the Agent
+                // momentarily running; wait for its convergence instead of failing the
+                // swap — the gate guarantees it spends no model request.
+                if (this.runningAgents.has(active.agent.id))
+                    await active.agent.whenIdle();
+                if (this.runningAgents.has(active.agent.id))
+                    throw new Error(`Agent Member '${stored.handle}' is still running; the rollover must wait for idle`);
+                // Checkpoint return: resolve the seed before committing anything. A
+                // violation found here fails the whole swap with the old generation
+                // intact — never a guessed seed over a wrong prefix.
+                const seed = plan.checkpointRef === undefined ? undefined : await this.resolveCheckpointSeed(memberId, active.agent, plan.checkpointRef);
+                // Recheck the job guard at the lifecycle commit seam: a job may have
+                // started or settled after the tool-time validation.
+                const blockingJobs = this.ownedJobsBlockingRollover(active.agent);
+                if (blockingJobs.length > 0) {
+                    throw new Error(`the context rollover is refused: this Member now owns jobs that would not survive the switch (${blockingJobs.join(', ')}); collect or stop them, then retry`);
+                }
+                const rolled = await this.rolloverSessionForAgent(active.agent, {
+                    requestId: plan.requestId,
+                    workspaceId: stored.workspaceId,
+                    memberId,
+                    previousSessionId: plan.previousSessionId,
+                    newSessionId: plan.newSessionId,
+                    handoffEventSeq: plan.handoffEventSeq,
+                    trigger: plan.trigger,
+                    ...(seed === undefined ? {} : { checkpointRef: seed.checkpointRef, sourceSessionId: seed.sourceSessionId, sourceThroughSeq: seed.sourceThroughSeq }),
+                });
+                // The durable old-log projection is the carried-input truth: after the
+                // old Agent retires, fold its final state and take every post-intent
+                // non-Team candidate the old generation never answered. The process
+                // capture only accelerates; it is unioned by message id, never allowed
+                // to override the fold.
+                const preRetireCapture = this.contextManagement.drainCapturedInput(memberId);
+                await this.retireMemberGeneration(memberId, active, plan.previousSessionId);
+                const finalState = foldContextProjection(active.agent.session.ownEvents(), active.agent.session.inheritedEventCount, active.agent.session.id);
+                const foldedCarried = carriedInputOf(finalState);
+                const carriedById = new Map(plan.carriedInput.map(message => [message.id, message]));
+                for (const message of foldedCarried)
+                    carriedById.set(message.id, message);
+                for (const message of preRetireCapture)
+                    if (!carriedById.has(message.id))
+                        carriedById.set(message.id, message);
+                for (const message of this.contextManagement.drainCapturedInput(memberId))
+                    if (!carriedById.has(message.id))
+                        carriedById.set(message.id, message);
+                const carriedInput = [...carriedById.values()];
+                // A fresh rollover seeds nothing and points the lineage parent at the
+                // previous active Session; a checkpoint return seeds the resolved
+                // prefix and parents at the seed source Session instead. Activation
+                // defers the ordinary Inbox wake so the handoff is guaranteed to be the
+                // new generation's first model-facing context.
+                const seedEvents = seed === undefined ? undefined : seed.prefix;
+                await this.activateMember(rolled.member, undefined, undefined, seed === undefined ? plan.previousSessionId : seed.sourceSessionId, {
+                    deferNotify: true,
+                    // The prefix is contiguous from seq 0, so its length is exactly the
+                    // inherited cut the child folds past.
+                    ...(seedEvents === undefined ? {} : { seed: seedEvents, inheritedEventCount: SessionLogOffset(seedEvents.length) }),
+                });
+                const reactivated = this.handles.get(memberId);
+                if (reactivated === undefined) {
+                    throw new Error(`Agent Member '${stored.handle}' failed to activate its next context: ${this.memberFailures.get(memberId)?.activation ?? 'unknown error'}`);
+                }
+                // The handoff is the first model-facing context of the new generation.
+                // It rides the step-priority inbox lane (steer) so a later rederived
+                // Inbox notice queues behind it instead of preempting it; carried input
+                // follows as its own turn, and the Inbox is rederived from ledger facts.
+                reactivated.agent.steer(this.contextManagement.handoffMessageFor(plan));
+                for (const message of carriedInput)
+                    reactivated.agent.followup(message);
+                const notifications = this.requireLedger().notificationFacts(memberId, { workspaceId: rolled.member.workspaceId });
+                if (notifications.length > 0)
+                    this.notifyMember(reactivated.agent, carriedInput.length > 0);
+            });
+        }
         /** Ledger handle for log lines; falls back to the raw id when unknown. */
         memberLabel(memberId) {
             return this.ledger?.getMember(memberId)?.handle ?? memberId;
@@ -628,6 +895,9 @@ let AgentTeam = (() => {
                 if (this.isInboxNotice(pending))
                     handle.agent.inbox.remove(pending.id);
             }
+            // Recovery carries the concrete interrupted work; a queued progress nudge
+            // is stale next to it and must not survive as a second reminder.
+            this.progressNudge.revokePendingNotice(member.memberId);
             handle.agent.steer(hint);
         }
         /** Automatic-recovery wakeup; throwing tells the coordinator the target is gone. */
@@ -895,7 +1165,60 @@ let AgentTeam = (() => {
             const result = await this.requireLedger().readThread({ ...request, actor });
             if (result.committed)
                 this.emitCommitted(result.value.receipt);
-            return result.value;
+            const value = result.value;
+            // Private read-time enrich: an acceptance the reader just acknowledged is
+            // a natural Task boundary, so the Host prices the reader's context once,
+            // after the durable read has committed. Never a ledger fact, never
+            // persisted, and a measurement failure degrades to an explicit
+            // `unavailable` — the committed read is never reversed.
+            const advice = await this.acceptanceContextAdvice(agent, value);
+            return advice === undefined ? value : Object.freeze({ ...value, contextAdvice: advice });
+        }
+        /**
+         * Context advice for one acceptance acknowledged by this read: only when
+         * the read carried an unread accept activity AND the Task is still done.
+         * Repeat reads (nothing unread), history-style reads, and reopened Tasks
+         * carry no advice — the acceptance no longer stands.
+         */
+        async acceptanceContextAdvice(agent, read) {
+            if (read.task === undefined || read.task.resolution !== 'accepted' || read.task.status !== 'done')
+                return undefined;
+            const acknowledgedAccept = read.facts.some(entry => entry.unread && entry.fact.kind === 'activity'
+                && entry.fact.activity.kind === 'accept');
+            if (!acknowledgedAccept)
+                return undefined;
+            return this.contextAdviceFor(agent);
+        }
+        /** Price the reading Member's context against its current route's budgets. */
+        async contextAdviceFor(agent) {
+            try {
+                const limits = await this.routeLimitsForAgent(agent);
+                if (limits === undefined)
+                    return this.unavailableAdvice();
+                const taskBoundaryThreshold = Math.min(ACCEPT_TASK_BOUNDARY_THRESHOLD, limits.handoffAt);
+                if (limits.usageTokens >= limits.handoffAt) {
+                    return Object.freeze({ usageTokens: limits.usageTokens, taskBoundaryThreshold, handoffAt: limits.handoffAt, hardLimit: limits.hardLimit,
+                        action: 'handoff-now',
+                        guidance: 'You are at or above the handoff budget. Finish the current atomic action and unsettled evidence, then call context_rollover with a fresh handoff now.' });
+                }
+                if (limits.usageTokens >= taskBoundaryThreshold) {
+                    return Object.freeze({ usageTokens: limits.usageTokens, taskBoundaryThreshold, handoffAt: limits.handoffAt, hardLimit: limits.hardLimit,
+                        action: 'rollover',
+                        guidance: 'Finish the acceptance closeout, persist only durable reusable conclusions, collect or stop jobs, then call context_rollover with a fresh handoff covering every other active Claim. Do not return to an old checkpoint solely because this Task was accepted.' });
+                }
+                return Object.freeze({ usageTokens: limits.usageTokens, taskBoundaryThreshold, handoffAt: limits.handoffAt, hardLimit: limits.hardLimit,
+                    action: 'keep',
+                    guidance: 'Keep the current context for possible acceptance follow-up. This acceptance is already a timeline boundary; do not create a redundant checkpoint. Record a checkpoint only before the next noisy or risky phase.' });
+            }
+            catch {
+                // Any measurement failure degrades explicitly; the read stays durable.
+                return this.unavailableAdvice();
+            }
+        }
+        unavailableAdvice() {
+            return Object.freeze({ usageTokens: undefined, taskBoundaryThreshold: undefined, handoffAt: undefined, hardLimit: undefined,
+                action: 'unavailable',
+                guidance: 'Context usage could not be measured for this acceptance; manage context by your existing pressure policy.' });
         }
         /**
          * Agent-only direct message: append the audit-only dm-sent operation, then
@@ -958,6 +1281,663 @@ let AgentTeam = (() => {
         validateLedger() {
             this.requireLedger().validate();
         }
+        /**
+         * Effective context-pressure budget for one Member's current route:
+         * `hardLimit = min(256K, routeWindow - outputReserve)` and
+         * `handoffAt = min(200K, hardLimit - handoffReserve)`.
+         */
+        contextLimits(routeWindow) {
+            const hardLimit = Math.min(CONTEXT_HARD_LIMIT_CAP, Math.max(0, routeWindow - CONTEXT_SAFE_OUTPUT_RESERVE));
+            const handoffAt = Math.min(CONTEXT_HANDOFF_AT_CAP, Math.max(0, hardLimit - CONTEXT_HANDOFF_RESERVE));
+            return { hardLimit, handoffAt };
+        }
+        /**
+         * Budget + measurement for one Member's CURRENT routed selection — the
+         * member-pinned model or the default selection, resolved through the LLM
+         * service so a route change is honored at the next pre-step. The last
+         * persisted `request/context` event wins when it matches the current
+         * selection (no directory round-trip for an unchanged route). A selection
+         * whose capacity cannot be resolved returns `undefined` and the pressure
+         * policy fails closed instead of assuming an unbounded route.
+         */
+        async routeLimitsForAgent(agent) {
+            const member = this.memberForAgent(agent);
+            if (member === undefined)
+                return undefined;
+            // The pressure budget must match the route the CURRENT step actually
+            // uses: the live selection ref's `assembled` capture when the step has
+            // entered prompt assembly, its `current` selection otherwise. Re-deriving
+            // from the ledger or the Host default would race a concurrent default
+            // change or live model edit and split the budget from the real route.
+            const ref = this.modelSelections.get(member.memberId);
+            const selection = ref?.assembled ?? ref?.current ?? member.model ?? this.ctx.agentDefaultModel.currentSelection();
+            const meter = agent.ctx.get('tokenMeter');
+            const usageTokens = meter?.measure(agent.session)?.totalTokens;
+            if (usageTokens === undefined)
+                return undefined;
+            const persisted = agent.session.requestContext();
+            let contextWindow;
+            if (persisted?.provider === selection.provider && persisted.model === selection.model) {
+                contextWindow = persisted.contextWindow;
+            }
+            if (contextWindow === undefined) {
+                contextWindow = await this.resolvedContextWindow(selection);
+            }
+            if (contextWindow === undefined)
+                return undefined;
+            const { hardLimit, handoffAt } = this.contextLimits(contextWindow);
+            return { usageTokens, hardLimit, handoffAt };
+        }
+        /** Cache of resolved context windows per provider/model; unknown stays unknown. */
+        routeWindows = new Map();
+        /**
+         * Resolve one selection's provider-owned context capacity, cached per
+         * route. The LLM service is resolved lazily (not a hard inject): the Host
+         * mounts it in every production shape, while ledger-level fixtures provide
+         * only the services the Team service itself owns. A missing or throwing
+         * resolution is an unknown route — the pressure policy fails closed on it.
+         */
+        async resolvedContextWindow(selection) {
+            const key = `${selection.provider}::${selection.model}`;
+            if (this.routeWindows.has(key))
+                return this.routeWindows.get(key);
+            let contextWindow;
+            try {
+                const llm = this.ctx.get('llm');
+                const info = llm === undefined ? undefined : await llm.resolveModelInfo(selection.provider, selection.model);
+                contextWindow = info?.context?.contextWindow;
+            }
+            catch {
+                contextWindow = undefined;
+            }
+            this.routeWindows.set(key, contextWindow);
+            return contextWindow;
+        }
+        /**
+         * Resolve one checkpoint ref to its exact seed prefix before any rollover
+         * commit. The walk covers the current generation (own events) and archived
+         * ancestors through `sessionPersistence`; the same projection definition
+         * folds every source. Guards fail closed: unresolved, foreign-lineage,
+         * open-turn, or nonshrinking targets reject without any lifecycle effect.
+         */
+        async resolveCheckpointSeed(memberId, agent, checkpointRef) {
+            let sessionId = agent.session.id;
+            let live = true;
+            let guard = 0;
+            while (sessionId !== undefined && guard++ < MAX_TIMELINE_ANCESTORS) {
+                let events;
+                let inheritedEventCount;
+                let parentSession;
+                // Capture this iteration's source identity BEFORE the branch advances
+                // the lineage flag: the measurement call below keys on it.
+                const sourceIsCurrent = live;
+                if (live) {
+                    events = agent.session.snapshotEvents();
+                    inheritedEventCount = agent.session.inheritedEventCount;
+                    parentSession = agent.session.header.parentSession;
+                    live = false;
+                }
+                else {
+                    try {
+                        const inspection = await this.ctx.sessionPersistence.inspect(sessionId);
+                        events = inspection.events;
+                        inheritedEventCount = inspection.inheritedEventCount;
+                        parentSession = inspection.meta.parentSession;
+                    }
+                    catch (error) {
+                        throw new Error(`checkpoint '${checkpointRef}' could not be resolved: its source Session is unreadable (${error instanceof Error ? error.message : String(error)})`);
+                    }
+                }
+                // Fold the source with its inherited cut respected: inherited events
+                // are resolved history in that source, never fresh intent; checkpoints
+                // recorded in this source's own span are the selectable targets.
+                const state = foldContextProjection(events, inheritedEventCount, sessionId);
+                // A Team-boundary default checkpoint: the boundary's completed-turn
+                // anchor is the seed cut, and it is selectable exactly when one
+                // Thread's facts entered the context through it — the same proof the
+                // timeline requires, revalidated here because the model may cite a
+                // boundary the timeline never surfaced.
+                const boundary = checkpointRef.startsWith('team-boundary-')
+                    ? state.boundaries.find(entry => entry.key === checkpointRef)
+                    : undefined;
+                const entry = checkpointByRef(state, checkpointRef);
+                const anchorTurnEndSeq = boundary !== undefined ? boundary.turnEndSeq : entry?.turnEndSeq;
+                if (anchorTurnEndSeq !== undefined && anchorTurnEndSeq !== -1) {
+                    if (boundary !== undefined && boundary.source !== 'team-boundary') {
+                        throw new Error(`checkpoint '${checkpointRef}' is not a restorable boundary`);
+                    }
+                    // The seed is the exact contiguous prefix through the anchor's
+                    // completed turn end. Balanced by construction — the turn ended.
+                    const throughSeq = anchorTurnEndSeq + 1;
+                    const prefix = events.slice(0, throughSeq);
+                    if (boundary !== undefined) {
+                        const threads = this.threadsEnteringContext(events, anchorTurnEndSeq);
+                        if (threads.length !== 1) {
+                            throw new Error(threads.length === 0
+                                ? `boundary '${checkpointRef}' has no single attributable Thread; write a fresh handoff instead`
+                                : `boundary '${checkpointRef}' spans multiple Threads; write a fresh handoff instead`);
+                        }
+                    }
+                    // Nonshrinking guard, priced by the SAME source-replayed measurement
+                    // the timeline shows: the seed's retained cost is the SOURCE's own
+                    // token count scaled by the anchor share — a small current generation
+                    // never disguises a large ancestor seed. An unmeasurable source fails
+                    // closed: pricing the unknown as zero would wave an oversized seed
+                    // through.
+                    const limits = await this.routeLimitsForAgent(agent);
+                    const handoffAt = limits?.handoffAt ?? CONTEXT_HANDOFF_AT_CAP;
+                    const sourceUsage = await this.sourceUsageTokens(sessionId, sourceIsCurrent, agent);
+                    if (sourceUsage === undefined) {
+                        throw new Error(`checkpoint '${checkpointRef}' could not be priced: its source Session's context cost cannot be measured; write a fresh handoff instead`);
+                    }
+                    const retained = this.retainedEstimate(sourceUsage, events.length, anchorTurnEndSeq);
+                    if (prefix.length >= events.length) {
+                        throw new Error('checkpoint return does not shrink the working set; use a fresh handoff instead');
+                    }
+                    if (retained >= handoffAt) {
+                        throw new Error('checkpoint return would retain a context at or above the handoff budget; use a fresh handoff instead');
+                    }
+                    // Single-Thread coverage guard: with more than one active Claim the
+                    // Host cannot prove a rewind stays inside one Thread's context.
+                    if (this.requireLedger().activeClaimCountForMember(memberId) > 1) {
+                        throw new Error('multiple active Claims: write a fresh handoff covering all of them instead of returning to a checkpoint');
+                    }
+                    return { checkpointRef, sourceSessionId: sessionId, sourceThroughSeq: SessionLogOffset(throughSeq), prefix };
+                }
+                sessionId = parentSession;
+            }
+            throw new Error(`checkpoint '${checkpointRef}' does not resolve in this Member's lineage`);
+        }
+        /**
+         * Rebuild the handoff for a Member whose rollover committed but whose new
+         * Session activated without the handoff delivery (a crash between the
+         * ledger commit and the swap's delivery step). The previous Session —
+         * recorded in the operation, mirrored by the lineage parent, and available
+         * from the ledger even when the new Session's own header never carried it —
+         * holds the durable intent; fold it cold and deliver the same handoff
+         * envelope first. Idempotent: once any handoff exists in the new Session's
+         * own log this never runs.
+         */
+        async reconstructMissingHandoff(member, agent) {
+            const previousSessionId = agent.session.header.parentSession
+                ?? this.requireLedger().previousSessionForMember(member.memberId);
+            if (previousSessionId === undefined)
+                return;
+            let inspection;
+            try {
+                const result = await this.ctx.sessionPersistence.inspect(previousSessionId);
+                inspection = result;
+            }
+            catch (error) {
+                this.ctx.logger.warn(`agent-team: rollover handoff reconstruction could not read the previous Session '${previousSessionId}': ${error instanceof Error ? error.message : String(error)}`);
+                return;
+            }
+            const state = foldContextProjection(inspection.events, inspection.inheritedEventCount, previousSessionId);
+            if (state.pending === null)
+                return;
+            const pending = state.pending;
+            const message = createHandoffMessage({
+                handoff: pending.handoff,
+                previousSessionId,
+                newSessionId: agent.session.id,
+                trigger: 'model',
+                handoffEventSeq: pending.resultSeq,
+                ...(pending.checkpointRef === undefined ? {} : { checkpointRef: pending.checkpointRef }),
+                ...(pending.relatedFiles.length === 0 ? {} : { relatedFiles: pending.relatedFiles }),
+            });
+            agent.steer(message);
+            this.ctx.logger.info(`agent-team: reconstructed the rollover handoff for member '${this.memberLabel(member.memberId)}' from the previous Session '${previousSessionId}'`);
+        }
+        /**
+         * Resolve the exact recorded seed prefix of one committed checkpoint
+         * return for crash recovery: cold-read the recorded source Session, take
+         * the contiguous prefix of the recorded exclusive length, and verify the
+         * source's own fold still resolves the recorded anchor there — an explicit
+         * checkpoint through `checkpointByRef`, or a default Team boundary whose
+         * recorded ref appears among the source's own boundary keys.
+         * Fail-closed by contract: an unreadable source or an unprovable anchor
+         * REJECTS the activation — a committed checkpoint return may never
+         * downgrade to a blank child.
+         */
+        async recordedCheckpointPrefix(seed) {
+            let inspection;
+            try {
+                inspection = await this.ctx.sessionPersistence.inspect(seed.sourceSessionId);
+            }
+            catch (error) {
+                throw new Error(`the recorded checkpoint-return seed source Session '${seed.sourceSessionId}' is unreadable: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            const through = Number(seed.sourceThroughSeq);
+            if (!Number.isSafeInteger(through) || through < 0 || through > inspection.events.length) {
+                throw new Error(`the recorded checkpoint-return seed cut ${through} is not a valid prefix of Session '${seed.sourceSessionId}'`);
+            }
+            const state = foldContextProjection(inspection.events, inspection.inheritedEventCount, seed.sourceSessionId);
+            const anchorProven = checkpointByRef(state, seed.checkpointRef) !== undefined
+                || state.boundaries.some(boundary => boundary.key === seed.checkpointRef);
+            if (!anchorProven) {
+                throw new Error(`the recorded checkpoint-return anchor '${seed.checkpointRef}' no longer resolves in Session '${seed.sourceSessionId}'`);
+            }
+            return { prefix: inspection.events.slice(0, through) };
+        }
+        /**
+         * Redeliver the old generation's unconsumed post-intent input to a
+         * generation whose durable rollover committed but whose delivery did not
+         * finish. Bound to the ledger's recorded transition target — the CURRENT
+         * Session being that target — never to whether the handoff itself landed,
+         * so a crash after the handoff but before the carried enqueue still
+         * replays. The fold is the same durable truth the live transition uses
+         * (unconsumed, non-Team, order preserved). Idempotency keys on what is
+         * CURRENTLY present: delivered `user/message` ids plus the live inbox's
+         * pending next-step/next-turn ids — a historical insert that was already
+         * claimed (and removed) but never surfaced is NOT known and must replay.
+         * Fail-closed: an unreadable previous Session rejects the activation
+         * rather than silently dropping the Member's input.
+         */
+        async replayCarriedInput(member, agent) {
+            const transition = this.requireLedger().lastTransitionForMember(member.memberId);
+            if (transition === undefined || transition.targetSessionId !== agent.session.id)
+                return 0;
+            let inspection;
+            try {
+                inspection = await this.ctx.sessionPersistence.inspect(transition.previousSessionId);
+            }
+            catch (error) {
+                throw new Error(`the previous Session '${transition.previousSessionId}' holding the Member's carried input is unreadable: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            const state = foldContextProjection(inspection.events, inspection.inheritedEventCount, transition.previousSessionId);
+            const carried = carriedInputOf(state);
+            if (carried.length === 0)
+                return 0;
+            const known = new Set();
+            for (const event of agent.session.ownEvents()) {
+                if (event.type !== 'user/message')
+                    continue;
+                const id = event.data.id;
+                if (id !== undefined)
+                    known.add(id);
+            }
+            for (const pending of [...agent.inbox.nextStep, ...agent.inbox.nextTurn]) {
+                known.add(pending.id);
+            }
+            let redelivered = 0;
+            for (const message of carried) {
+                if (known.has(message.id))
+                    continue;
+                agent.followup(message);
+                redelivered += 1;
+            }
+            if (redelivered > 0)
+                this.ctx.logger.info(`agent-team: redelivered ${redelivered} carried input message(s) for member '${this.memberLabel(member.memberId)}' after the rollover crash recovery`);
+            return redelivered;
+        }
+        /**
+         * Agent-only checkpoint request validation: the tool calls this inside its
+         * own running turn. Like `context_rollover`, the tool performs no side effect —
+         * the durable checkpoint is the successful `tool/call`+`tool/result` pair
+         * the Session projection folds; the ref returned here is deterministic
+         * from this Member Session's identity plus the tool call id, so the model
+         * can cite it before the result exists and a repeated provider call id in
+         * another generation never collides with this one.
+         */
+        recordCheckpointForAgent(agent, request) {
+            const member = this.memberForAgent(agent);
+            if (member === undefined || member.state !== 'enabled')
+                throw new Error('context_checkpoint requires an active Team Member');
+            if (this.runningAgents.has(agent.id) !== true)
+                throw new Error('context_checkpoint must run inside this Member\'s own running turn');
+            const name = request.name.trim();
+            if (name === '')
+                throw new Error('context_checkpoint requires a non-empty name');
+            if (name.length > MAX_CHECKPOINT_NAME_CHARS)
+                throw new Error(`context_checkpoint name exceeds ${MAX_CHECKPOINT_NAME_CHARS} characters`);
+            return { checkpointRef: checkpointRefFor(agent.session.id, request.callId), name };
+        }
+        /**
+         * Agent-only bounded structural timeline: resolved checkpoints plus Team
+         * delivery, handoff, and compaction boundaries across the current
+         * generation and its archived ancestor lineage. Structural only — no
+         * transcript content. The meter prices retained/discarded tokens; entries
+         * the Host cannot prove restorable carry a rejection reason instead of
+         * silently disappearing.
+         */
+        async contextTimelineForAgent(agent, request) {
+            const member = this.memberForAgent(agent);
+            if (member === undefined || member.state !== 'enabled')
+                throw new Error('context_timeline requires an active Team Member');
+            const limit = request.limit === undefined ? DEFAULT_TIMELINE_LIMIT : Math.trunc(request.limit);
+            if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_TIMELINE_LIMIT)
+                throw new Error(`context_timeline limit must be between 1 and ${MAX_TIMELINE_LIMIT}`);
+            const meter = agent.ctx.get('tokenMeter');
+            const measurement = meter?.measure(agent.session);
+            const usageTokens = measurement?.totalTokens ?? 0;
+            const limits = await this.routeLimitsForAgent(agent);
+            const hardLimit = limits?.hardLimit ?? CONTEXT_HARD_LIMIT_CAP;
+            const handoffAt = limits?.handoffAt ?? CONTEXT_HANDOFF_AT_CAP;
+            // Fold the current generation, then walk archived ancestors through their
+            // persisted logs; the same projection definition folds every source.
+            const items = [];
+            const seen = new Set();
+            let sessionId = member.sessionId;
+            let live = true;
+            let guard = 0;
+            while (sessionId !== undefined && guard++ < MAX_TIMELINE_ANCESTORS) {
+                let state;
+                let sourceSessionId = sessionId;
+                let sourceEvents = [];
+                // Capture this iteration's source identity BEFORE the branch advances
+                // the lineage flag: measurement and discard pricing both key on it.
+                const sourceIsCurrent = live;
+                if (live) {
+                    state = foldContextProjection(agent.session.ownEvents(), agent.session.inheritedEventCount, agent.session.id);
+                    sourceEvents = agent.session.snapshotEvents();
+                    sessionId = agent.session.header.parentSession;
+                    live = false;
+                }
+                else {
+                    try {
+                        const inspection = await this.ctx.sessionPersistence.inspect(sessionId);
+                        state = foldContextProjection(inspection.events, inspection.inheritedEventCount, sessionId);
+                        sourceEvents = inspection.events;
+                        sourceSessionId = sessionId;
+                        sessionId = inspection.meta.parentSession;
+                    }
+                    catch {
+                        // An unreadable ancestor ends the lineage walk here.
+                        sessionId = undefined;
+                    }
+                }
+                if (state === undefined)
+                    break;
+                // Price every candidate of this source against the SOURCE's own
+                // replayed measurement — a small current generation never shrinks a
+                // large ancestor's real seed cost. An unmeasurable source (no meter,
+                // unreadable ancestor) prices as UNKNOWN, never as zero: the timeline
+                // marks its candidates unprovable and the return guard rejects them.
+                const sourceUsage = await this.sourceUsageTokens(sourceSessionId, sourceIsCurrent, agent);
+                for (const candidate of timelineCandidates(state, limit)) {
+                    if (seen.has(candidate.ref))
+                        continue;
+                    seen.add(candidate.ref);
+                    items.push(this.timelineItemFor(candidate, sourceUsage, usageTokens, hardLimit, handoffAt, sourceSessionId, sourceIsCurrent, sourceEvents));
+                    if (items.length >= limit)
+                        break;
+                }
+                if (items.length >= limit)
+                    break;
+            }
+            return { usageTokens, hardLimit, handoffAt, items };
+        }
+        /**
+         * Replayed measurement of one lineage source: the live current Session
+         * measures directly; an archived ancestor measures through a borrowed
+         * prepared Session, so a seed's retained cost is priced in the SOURCE's
+         * own tokens — never the current generation's. Returns undefined when no
+         * meter is available or the source cannot be borrowed; callers fail
+         * closed on the unknown.
+         */
+        async sourceUsageTokens(sessionId, live, agent) {
+            const meter = agent.ctx.get('tokenMeter');
+            if (meter === undefined)
+                return undefined;
+            if (live)
+                return meter.measure(agent.session)?.totalTokens;
+            try {
+                const env_1 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const borrowed = __addDisposableResource(env_1, await this.ctx.sessionPersistence.borrowSession(sessionId)
+                    // The borrow resolves the exact Session object for both shapes: the
+                    // live instance for an attached Session, the prepared one for an
+                    // archived ancestor. Measuring through the service context's store
+                    // would need an inject this service does not declare.
+                    , false);
+                    // The borrow resolves the exact Session object for both shapes: the
+                    // live instance for an attached Session, the prepared one for an
+                    // archived ancestor. Measuring through the service context's store
+                    // would need an inject this service does not declare.
+                    const session = borrowed.source === 'live'
+                        ? agent.session.id === sessionId ? agent.session : undefined
+                        : borrowed.preparedSession;
+                    return session === undefined ? undefined : meter.measure(session)?.totalTokens;
+                }
+                catch (e_1) {
+                    env_1.error = e_1;
+                    env_1.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_1);
+                }
+            }
+            catch {
+                return undefined;
+            }
+        }
+        /**
+         * Monotonic anchor-share estimate of a seed's retained cost, priced in the
+         * SOURCE Session's own measurement: the fraction of the source log the
+         * seed prefix covers, scaled to the source's replayed token count. The
+         * anchor position is exact and the share grows monotonically toward the
+         * source's head (100%). A large ancestor's anchor therefore prices at the
+         * ancestor's real size even inside a small current generation — the
+         * timeline display and the return guard share this one estimate.
+         */
+        retainedEstimate(sourceUsageTokens, sourceLength, anchorTurnEndSeq) {
+            if (sourceLength <= 0)
+                return sourceUsageTokens;
+            const share = Math.min(1, Math.max(0, (anchorTurnEndSeq + 1) / sourceLength));
+            return Math.round(sourceUsageTokens * share);
+        }
+        /**
+         * Threads whose facts entered this Session's model context by the given
+         * seq: delivered Team notices (their bodies quote `Thread: <ref>`
+         * structurally) and successful Team-claim mutations (their task overlays
+         * resolve to Threads through the ledger). Never from unread ledger
+         * activity — a Thread the Member never saw did not enter its context.
+         * Order-stable, deduplicated.
+         */
+        threadsEnteringContext(events, throughSeq) {
+            const refs = [];
+            const openAttributions = new Map();
+            const push = (ref) => {
+                if (ref !== undefined && !refs.includes(ref))
+                    refs.push(ref);
+            };
+            for (const event of events) {
+                if (event.seq > throughSeq)
+                    break;
+                if (event.type === 'tool/call' && (event.data.name === 'team_claim' || event.data.name === 'team_message')) {
+                    openAttributions.set(event.data.callId, { name: event.data.name, arguments: event.data.arguments });
+                }
+                else if (event.type === 'tool/result') {
+                    const block = event.data.message.content?.[0];
+                    if (block !== undefined && block.toolCallId !== undefined) {
+                        const recorded = openAttributions.get(block.toolCallId);
+                        if (recorded !== undefined && block.isError !== true) {
+                            openAttributions.delete(block.toolCallId);
+                            try {
+                                const args = JSON.parse(recorded.arguments);
+                                // A claim mutation resolves its Task overlay through the ledger;
+                                // a team_message committed reply names its Thread in its call
+                                // arguments; a committed start's Thread is born in the result
+                                // and is read from the durable presentation meta.
+                                if (recorded.name === 'team_claim' && typeof args.taskRef === 'string' && args.taskRef !== '') {
+                                    push(this.requireLedger().threadForTask(args.taskRef));
+                                }
+                                else if (recorded.name === 'team_message') {
+                                    const meta = event.data.meta;
+                                    if (meta !== undefined && typeof meta === 'object' && meta.kind === 'committed') {
+                                        const metaThreadRef = meta.threadRef;
+                                        if (typeof metaThreadRef === 'string' && metaThreadRef !== '')
+                                            push(metaThreadRef);
+                                    }
+                                    else if (typeof args.threadRef === 'string' && args.threadRef !== '') {
+                                        push(args.threadRef);
+                                    }
+                                }
+                            }
+                            catch {
+                                // Malformed call arguments contribute no attribution.
+                            }
+                        }
+                    }
+                }
+                else if (event.type === 'user/message') {
+                    const source = event.data.source;
+                    if (source?.kind !== 'plugin')
+                        continue;
+                    // Reminder notices never enter attribution — a progress nudge or a
+                    // recovery instruction is not a Team fact.
+                    if (source.form === 'notice' && source.summary !== undefined && isReminderNoticeSummary(source.summary))
+                        continue;
+                    const text = event.data.content.filter(block => block.type === 'text').map(block => block.text ?? '').join('\n');
+                    for (const match of text.matchAll(/Thread: (thread:[0-9a-f-]{6,})/g)) {
+                        push(match[1]);
+                    }
+                }
+            }
+            return refs;
+        }
+        /**
+         * Price and annotate one timeline candidate without mutating anything.
+         * Retained prices in the SOURCE Session's own replayed measurement (the
+         * monotonic anchor-share of the source log); discarded is what a return
+         * replaces — for a current-generation anchor, the measured usage beyond
+         * the anchor; for an ancestor anchor, the current generation's whole
+         * usage (an approximation: the ancestor's own suffix is not part of this
+         * generation). A small current child therefore discards little but may
+         * still retain a large ancestor seed, and both numbers say so honestly.
+         */
+        timelineItemFor(candidate, sourceUsage, currentUsage, _hardLimit, handoffAt, sourceSessionId, sourceIsCurrent, sourceEvents) {
+            const retainedTokens = candidate.source === 'head'
+                ? currentUsage
+                : this.retainedEstimate(sourceUsage ?? 0, sourceEvents.length, candidate.turnEndSeq);
+            const discardedTokens = candidate.source === 'head'
+                ? 0
+                : sourceIsCurrent
+                    ? Math.max(0, currentUsage - retainedTokens)
+                    : currentUsage;
+            const affectedThreads = candidate.turnEndSeq === -1 ? [] : this.threadsEnteringContext(sourceEvents, candidate.turnEndSeq);
+            let restorable = candidate.turnEndSeq !== -1;
+            let reason;
+            if (candidate.source === 'head') {
+                // The head is the current working set: returning to it discards
+                // nothing and is never a meaningful return target.
+                restorable = false;
+                reason = 'the head is the current working set; returning to it discards nothing';
+            }
+            else if (sourceUsage === undefined) {
+                // The source's cost cannot be measured (no meter, or the archived
+                // ancestor cannot be borrowed): the budget cannot be proven, so the
+                // candidate is not selectable. Never price an unknown as zero.
+                restorable = false;
+                reason = 'the source Session\'s context cost cannot be measured, so the return budget cannot be proven';
+            }
+            else if (candidate.source === 'handoff' || candidate.source === 'compaction') {
+                // A handoff starts a generation and a compaction rewrites the visible
+                // surface: rewinding into them is not a proven-safe V1 target.
+                restorable = false;
+                reason = `source '${candidate.source}' is not a restorable checkpoint`;
+            }
+            else if (candidate.source === 'team-boundary') {
+                // A Team delivery is a selectable default checkpoint exactly when the
+                // Host can prove it stays inside one Thread's context: the boundary
+                // resolved at a completed turn AND exactly one Thread's facts entered
+                // the Session context through it. Multi-Thread or unattributable
+                // boundaries document why they are not selectable.
+                if (affectedThreads.length !== 1) {
+                    restorable = false;
+                    reason = affectedThreads.length === 0
+                        ? 'no single Thread is attributable to this boundary'
+                        : 'multiple Threads entered the context through this boundary; write a fresh handoff instead';
+                }
+                else if (retainedTokens >= handoffAt) {
+                    restorable = false;
+                    reason = 'retained context would not materially shrink the working set';
+                }
+            }
+            else if (candidate.source === 'agent' && retainedTokens >= handoffAt) {
+                restorable = false;
+                reason = 'retained context would be at or above the handoff budget';
+            }
+            return {
+                checkpointRef: candidate.ref,
+                name: candidate.label,
+                source: candidate.source,
+                retainedTokens,
+                discardedTokens,
+                affectedThreads,
+                restorable,
+                ...(reason === undefined ? {} : { reason }),
+                ...(candidate.source === 'agent' ? {} : { sourceSessionId }),
+            };
+        }
+        /**
+         * Agent-only rollover request validation: the tool calls this to check its
+         * Member binding, exclusivity, and checkpoint ownership. It performs no
+         * lifecycle effect — the actual transition reacts to the successful tool
+         * result through the context-management coordinator.
+         */
+        async requestNewContext(agent, request) {
+            const member = this.memberForAgent(agent);
+            if (member === undefined || member.state !== 'enabled')
+                throw new Error('context_rollover requires an active Team Member');
+            if (this.contextManagement.isTransitioning(member.memberId))
+                throw new Error('a context rollover is already scheduled for this Member; wait for it to finish before requesting another');
+            if (this.runningAgents.has(agent.id) !== true) {
+                // The tool runs inside the Member's own turn, so a non-running agent at
+                // this point is a harness anomaly; refuse rather than schedule a swap
+                // outside the turn fence.
+                throw new Error('context_rollover must run inside this Member\'s own running turn');
+            }
+            // Job ownership guard: disposing the old Agent cancels its running jobs
+            // and orphaned terminal-but-unreported output would vanish with it. The
+            // rejection names the jobs so the model can collect or stop them first;
+            // the transition rechecks at the lifecycle commit seam because a job may
+            // settle between this validation and the swap.
+            const blocking = this.ownedJobsBlockingRollover(agent);
+            if (blocking.length > 0) {
+                throw new Error(`context_rollover is refused while this Member owns jobs that would not survive the switch (${blocking.join(', ')}); collect or stop them first, then retry`);
+            }
+            if (request.checkpointRef === undefined)
+                return { mode: 'fresh' };
+            if (!/^(context-checkpoint-[0-9a-f]{64}|team-boundary-[0-9a-f]{64})$/.test(request.checkpointRef))
+                throw new Error('checkpointRef must be an opaque ref exactly as returned by context_timeline');
+            // Full current-state prevalidation through the ONE resolver the swap
+            // itself uses: a ref that is fabricated, unattributable, nonshrinking,
+            // unmeasurable, over-budget, or blocked by multiple active Claims
+            // rejects HERE — a model-visible error result instead of a fake
+            // `scheduled` whose async swap always fails. The seed is resolved and
+            // discarded: the transition seam resolves it again, so only the mutable
+            // guard set (jobs, route limits, lineage growth) is revalidated there.
+            await this.resolveCheckpointSeed(member.memberId, agent, request.checkpointRef);
+            return { mode: 'from-checkpoint' };
+        }
+        /**
+         * Jobs this Agent owns that cannot survive a generation swap: any
+         * running/stopping job, and any settled job whose terminal output was
+         * never reported (disposal would silently discard it). In-place hard
+         * compaction is exempt — it never cancels the owner.
+         */
+        ownedJobsBlockingRollover(agent) {
+            const jobs = agent.ctx.get('jobs');
+            if (jobs === undefined)
+                return [];
+            return jobs.list(agent)
+                .filter((job) => job.status === 'running' || job.status === 'stopping' || ((job.status === 'completed' || job.status === 'killed' || job.status === 'failed') && !job.reported))
+                .map((job) => `${job.label} (${job.id})`);
+        }
+        /**
+         * Agent-only session rollover commit: the Member actor must be the target
+         * Member on its currently bound live Session. The Host performs the actual
+         * generation swap around this write; the ledger records only the durable
+         * binding transition and rollover audit envelope.
+         */
+        async rolloverSessionForAgent(agent, request) {
+            const actor = this.memberCall(agent, request.workspaceId);
+            const result = await this.requireLedger().rolloverMemberSession({ ...request, actor });
+            if (result.committed)
+                this.emitCommitted(result.value.receipt);
+            return result.value;
+        }
         emitCommittedOutcome(result) {
             if (result.committed && result.value.kind === 'committed' && result.value.receipt !== undefined)
                 this.emitCommitted(result.value.receipt);
@@ -1036,16 +2016,40 @@ let AgentTeam = (() => {
                     throw error;
             }
         }
-        async activateMember(member, knownWorkspacePath, knownSessions, forkedFrom) {
+        /**
+         * Session headers currently durable in the persistence backend.
+         *
+         * The Host retires a disposed Session's log without awaiting it, so a
+         * concurrent activation can observe the JSONL backend's transient win32
+         * staging directories (.dsh-mkdir-*) as ENOENT while they rename into
+         * place. The read is idempotent; back off briefly instead of failing the
+         * activation on a race the publisher resolves within milliseconds.
+         */
+        async persistedSessionHeaders() {
+            for (let attempt = 0;; attempt += 1) {
+                try {
+                    return await this.ctx.sessionPersistence.list();
+                }
+                catch (error) {
+                    if (attempt >= 3 || error?.code !== 'ENOENT')
+                        throw error;
+                    await new Promise(resolve => setTimeout(resolve, (attempt + 1) * 25));
+                }
+            }
+        }
+        async activateMember(member, knownWorkspacePath, knownSessions, forkedFrom, options) {
             if (this.handles.has(member.memberId))
                 return;
             let created;
             try {
                 const workspace = this.requireWorkspace(member.workspaceId);
                 const workspacePath = knownWorkspacePath ?? workspace.path;
-                await this.memberRuntime.initializePrivateMemory(member.privateMemoryPath);
+                // Existing Members carry the pre-sanitization ledger path; activation
+                // migrates it onto the sanitized directory before provisioning.
+                const sanitizedMemoryPath = dshHomePath('agent-team', 'members', memberMemoryDirectoryName(member.memberId));
+                await this.memberRuntime.initializePrivateMemory(sanitizedMemoryPath, member.privateMemoryPath);
                 const persisted = knownSessions !== undefined ? knownSessions.has(member.sessionId)
-                    : (await this.ctx.sessionPersistence.list()).some(header => header.id === member.sessionId);
+                    : await this.sessionPersisted(member.sessionId);
                 // AgentOptions declares only provider/model. Install the full selection
                 // through the public Agent model-selection seam so reasoning effort is
                 // applied to the next request and not lost during activation.
@@ -1061,6 +2065,46 @@ let AgentTeam = (() => {
                     this.memberRuntime.applyMemberToolPolicy(agentCtx, member);
                     this.validateMemberPreset(agentCtx);
                     installModelSelection(agentCtx, selected);
+                    // Admission gate for pending context rollovers: once a successful
+                    // context_rollover result is durable, queued input must not open another
+                    // old-generation model request. The turn-stop boundary captures the
+                    // inbox (non-Team input is carried to the new generation), and a
+                    // racing pre-step rejects instead of admitting claimed messages.
+                    agentCtx.on('agent/turn-stopping', ({ agent }) => {
+                        if (!this.contextManagement.needsAdmissionGate(agent))
+                            return;
+                        this.contextManagement.captureQueuedInput(agent);
+                    });
+                    agentCtx.on('agent/pre-step', async ({ agent, messages, signal }, next) => {
+                        // Check before AND after the waterfall: a rollover pending at either
+                        // edge must reject this old-generation step, preserving its claimed
+                        // input for the new generation instead of letting it run or drop.
+                        if (this.contextManagement.needsAdmissionGate(agent)) {
+                            this.contextManagement.captureClaimedInput(agent, messages);
+                            return { kind: 'reject' };
+                        }
+                        // Team pressure policy rides the same pre-step seam after the
+                        // admission gate: the handoff-budget notice steers into the running
+                        // turn, and the hard limit forces compaction before the request is
+                        // forwarded — failing closed blocks the step instead of submitting
+                        // over the Team limit. Missing route capacity is an explicit reject.
+                        const pressure = await this.pressurePolicy.onPreStep(agent, signal);
+                        if (pressure.kind === 'reject')
+                            return { kind: 'reject' };
+                        const decision = await next();
+                        if (decision.kind === 'reject' || !this.contextManagement.needsAdmissionGate(agent))
+                            return decision;
+                        this.contextManagement.captureClaimedInput(agent, messages);
+                        return { kind: 'reject' };
+                    });
+                    // Provider context-overflow recovery: one bounded compact-and-retry
+                    // sequence per failure chain through the Team-owned policy.
+                    agentCtx.on('agent/request-error', async ({ agent, failure, signal }, next) => {
+                        const retry = await this.pressurePolicy.onRequestError(agent, failure, signal);
+                        if (retry)
+                            return { kind: 'retry' };
+                        return next();
+                    });
                     return {
                         commit: () => {
                             const agent = agentCtx.agent;
@@ -1077,24 +2121,112 @@ let AgentTeam = (() => {
                         },
                     };
                 };
+                // A renewal's create path parents at the ledger-recorded previous
+                // Session even when the caller does not pass one: a crash between the
+                // durable rollover commit and this activation recreates the Session
+                // from the ledger binding alone, and the lineage parent is what makes
+                // the missing handoff reconstructible on the NEXT failure. A recorded
+                // checkpoint seed re-seeds the child here — the crash lost the process
+                // memory, but the ledger envelope names the exact source prefix.
+                let recordedSeed;
+                let recordedSeedCut;
+                const rolloverSeed = !persisted && options?.seed === undefined
+                    ? this.requireLedger().rolloverSeedForMember(member.memberId, member.sessionId)
+                    : undefined;
+                if (rolloverSeed !== undefined) {
+                    // Fail-closed: an unreadable or unprovable recorded seed rejects
+                    // this activation (the catch below records the diagnostic) instead
+                    // of silently downgrading a committed checkpoint return to a blank
+                    // child.
+                    const resolved = await this.recordedCheckpointPrefix(rolloverSeed);
+                    recordedSeed = resolved.prefix;
+                    recordedSeedCut = SessionLogOffset(resolved.prefix.length);
+                }
+                const lineageParent = forkedFrom ?? (!persisted ? this.requireLedger().previousSessionForMember(member.memberId) : undefined);
+                let recoveryCarried = 0;
+                const seededFromLedger = recordedSeed !== undefined;
+                const effectiveParent = recordedSeed !== undefined ? rolloverSeed.sourceSessionId : lineageParent;
+                const seedOptions = options?.seed !== undefined && options.inheritedEventCount !== undefined
+                    ? { seed: options.seed, inheritedEventCount: options.inheritedEventCount }
+                    : recordedSeed !== undefined && recordedSeedCut !== undefined
+                        ? { seed: recordedSeed, inheritedEventCount: recordedSeedCut }
+                        : {};
                 created = persisted
                     ? await this.ctx.agents.resume({ resumeSessionId: member.sessionId, agentOptions, setup })
                     : await this.ctx.agents.create({
                         sessionId: member.sessionId,
                         // A context renewal records its fork lineage so the archived
-                        // previous Session stays discoverable from the durable header.
-                        meta: { cwd: workspacePath, agentPreset: member.presetId, ...(forkedFrom === undefined ? {} : { parentSession: forkedFrom }) },
+                        // previous Session stays discoverable from the durable header; a
+                        // checkpoint return parents at the seed source and marks the
+                        // fork seeded with its exact inherited prefix length.
+                        meta: {
+                            cwd: workspacePath,
+                            agentPreset: member.presetId,
+                            ...(effectiveParent === undefined ? {} : { parentSession: effectiveParent }),
+                            ...(options?.seed === undefined && !seededFromLedger ? {} : { isSeeded: true }),
+                        },
+                        ...seedOptions,
                         agentOptions,
                         setup,
                     });
                 this.memberRuntime.mountMemberSkillProvider(member, created.agent.ctx, skillSelection);
                 await workspace.attachSession(member.sessionId);
                 this.handles.set(member.memberId, created);
+                this.memberBySessionId.set(member.sessionId, member.memberId);
                 this.modelSelections.set(member.memberId, selected);
                 this.clearMemberFailure(member.memberId, 'activation');
                 this.nameMemberSession(member, created.agent);
-                this.notifyMember(created.agent);
-                this.autoCompaction.activated(member.memberId);
+                // The one-shot pressure notice needs no explicit re-arm here: it latches
+                // on durable Session evidence, and a fresh generation's own event span
+                // starts empty — a new Session is itself the re-arm.
+                // A restart between a durable rollover intent and its swap replays the
+                // old Session; the projection still carries the intent, so finish the
+                // transition (or keep waiting for the containing turn) from here.
+                if (persisted) {
+                    const state = foldContextProjection(created.agent.session.ownEvents(), created.agent.session.inheritedEventCount, created.agent.session.id);
+                    if (state.pending !== null)
+                        this.contextManagement.recoverPendingTransition(member.memberId, created.agent, member.sessionId);
+                    // A restart between one checkpoint's durable result and its quiet
+                    // follow-up delivery repairs exactly once; delivered continuations
+                    // stay delivered through the projection's own delivery record.
+                    this.contextManagement.repairContinuations(created.agent, state);
+                    // A restart after the rollover committed but before the handoff was
+                    // delivered activates the new Session with no handoff in its own
+                    // log — never treat that as an ordinary blank Member Session. The
+                    // operation's recorded previous Session (the lineage parent) still
+                    // holds the intent; rebuild the handoff from it.
+                    if (!state.boundaries.some(boundary => boundary.source === 'handoff')) {
+                        await this.reconstructMissingHandoff(member, created.agent);
+                    }
+                    // Carried input redelivery binds to the committed transition target —
+                    // this Session — never to the handoff's presence: a crash after the
+                    // handoff landed but before the carried enqueue still replays here.
+                    recoveryCarried = await this.replayCarriedInput(member, created.agent);
+                }
+                else if (forkedFrom === undefined && lineageParent !== undefined) {
+                    // A restart recreated a Session that never materialized before the
+                    // crash (the rollover committed, its activation failed, and this
+                    // create path just rebuilt it from the ledger binding alone): the
+                    // same handoff reconstruction applies from the ledger's recorded
+                    // previous Session, and the old generation's unconsumed post-intent
+                    // input — the durable fold, the same truth the live transition uses —
+                    // rides behind the handoff exactly as it would have. The rollover's
+                    // own activation passes its fork parent explicitly and delivers the
+                    // handoff right after — that delivery is the plan, never this
+                    // recovery.
+                    await this.reconstructMissingHandoff(member, created.agent);
+                    recoveryCarried = await this.replayCarriedInput(member, created.agent);
+                }
+                // The ordinary Inbox wake runs LAST, after any recovery delivery above:
+                // the handoff must stay the first model-facing context of a recovered
+                // generation, with carried input behind it and rederived Team facts
+                // behind that. When recovery redelivered carried input, the wake is
+                // sequenced behind it (its own follow-up turn) so the steer lane can
+                // never leapfrog the carried messages. A rollover activation defers the
+                // wake entirely — its caller delivers the handoff (and carried input)
+                // first and rederives the Inbox afterwards.
+                if (options?.deferNotify !== true)
+                    this.notifyMember(created.agent, recoveryCarried > 0);
             }
             catch (error) {
                 await created?.dispose();
@@ -1180,6 +2312,13 @@ let AgentTeam = (() => {
             const handle = this.handles.get(member.memberId);
             if (handle === undefined)
                 return Object.freeze({ member, availability: 'unavailable', presence: 'unavailable' });
+            // A rollover commits its ledger binding before the old generation retires
+            // and the new one activates; during that window the live handle still runs
+            // the previous Session. The Member stays visible but must not report the
+            // new binding as active — a Client following the row would otherwise open
+            // a Session that does not exist yet.
+            if (handle.agent.id !== member.sessionId)
+                return Object.freeze({ member, availability: 'unavailable', presence: 'unavailable', diagnostic: 'context rollover in progress' });
             if (this.ctx.agentPresets.composedPreset(handle.agent.ctx) === undefined) {
                 return Object.freeze({ member, availability: 'active', presence: 'error', diagnostic: ORPHANED_MEMBER_DIAGNOSTIC });
             }
@@ -1233,21 +2372,50 @@ let AgentTeam = (() => {
             }
             const ledger = this.requireLedger();
             this.emitChanged(ledger.changeScopesOf(operation));
+            // Nudge reconciliation precedes notifyMember: a committed reply both
+            // resets the author's silence and cancels any of its queued nudge before
+            // the Inbox notice (higher priority) is considered.
+            this.progressNudge.onCommitted(operation);
             for (const memberId of ledger.affectedMembersOf(operation)) {
                 const handle = this.handles.get(memberId);
                 if (handle !== undefined)
                     this.notifyMember(handle.agent);
             }
-            const compactionMembers = acceptedTaskCompactionMembers(operation);
-            if (compactionMembers !== undefined)
-                this.autoCompaction.schedule(compactionMembers);
+            // Task acceptance no longer schedules standalone auto compaction: it is
+            // a semantic checkpoint/context cue (delivered as ordinary Team
+            // notification), and the Team pressure policy owns compaction entry.
+        }
+        /** Model-visible active-Claim labels for the pressure notice. */
+        activeClaimLabels(memberId) {
+            const ledger = this.ledger;
+            if (ledger === undefined)
+                return [];
+            const labels = [];
+            for (const claim of ledger.activeClaimsForMember(memberId)) {
+                if (claim.state !== 'active')
+                    continue;
+                labels.push(`${claim.claimRef} (${claim.direction})`);
+            }
+            return labels;
+        }
+        /** Model-visible running/stopping job labels for the pressure notice. */
+        runningJobLabels(memberId) {
+            const handle = this.handles.get(memberId);
+            if (handle === undefined)
+                return [];
+            const jobs = handle.agent.ctx.get('jobs');
+            if (jobs === undefined)
+                return [];
+            return jobs.list(handle.agent)
+                .filter((job) => job.status === 'running' || job.status === 'stopping')
+                .map((job) => `${job.name ?? job.id}`);
         }
         emitAutoCompactionChanged(memberId) {
             const workspaceId = this.ledger?.getMember(memberId)?.workspaceId;
             this.emitChanged(workspaceId === undefined ? undefined : [{ kind: 'workspace', workspaceId }]);
         }
         /** Wake from durable unread state with bounded facts for direct and state-changing work. */
-        notifyMember(agent) {
+        notifyMember(agent, sequenced = false) {
             const member = this.memberForAgent(agent);
             if (member === undefined || member.state !== 'enabled')
                 return;
@@ -1256,6 +2424,12 @@ let AgentTeam = (() => {
                 this.notifiedInbox.delete(member.memberId);
                 return;
             }
+            // Any ordinary next-turn input already queued (a rollover's or recovery's
+            // carried messages) forces sequencing regardless of the caller: a steer
+            // would claim the nearest step boundary and leapfrog the carried turn.
+            if (!sequenced) {
+                sequenced = agent.inbox.nextTurn.some(message => message.source.kind === 'user');
+            }
             const signature = JSON.stringify(notifications.map(({ item }) => [
                 item.thread.threadRef, item.thread.revision, item.unreadCount, item.directCount, item.newestSequence,
             ]));
@@ -1271,13 +2445,24 @@ let AgentTeam = (() => {
             const existingInboxHint = pending.find(message => this.isInboxNotice(message));
             if (existingInboxHint !== undefined)
                 agent.inbox.remove(existingInboxHint.id);
+            // A durable Inbox notice outranks a queued progress nudge; revoke it so
+            // the model reads concrete unread work instead of a generic reminder.
+            this.progressNudge.revokePendingNotice(member.memberId);
             const hint = createUserMessage({
                 content: [{ type: 'text', text: this.notificationText(notifications, member.memberId) }],
                 source: { kind: 'plugin', plugin: AGENT_TEAM_PLUGIN_ID, form: 'notice', summary: INBOX_NOTICE_SUMMARY },
             });
             this.notifiedInbox.set(member.memberId, signature);
             try {
-                agent.steer(hint);
+                // Steer normally claims the nearest step boundary — which would
+                // preempt carried input that a rollover or crash recovery queued as
+                // ordinary next-turn messages. The sequenced mode enqueues the
+                // rederived Inbox as its own follow-up turn instead, so the delivery
+                // order stays handoff → carried input → rederived Inbox.
+                if (sequenced)
+                    agent.followup(hint);
+                else
+                    agent.steer(hint);
             }
             catch (error) {
                 this.clearMemberNotificationState(member.memberId);
@@ -1349,11 +2534,28 @@ let AgentTeam = (() => {
         activityNotification(activity, readerId) {
             const actor = activity.actor === AGENT_TEAM_HUMAN_MEMBER_ID
                 ? 'human' : this.requireLedger().getMember(activity.actor)?.handle ?? activity.actor;
-            // Early acceptance completes the reader's own open Claim inside the accept
-            // operation: say so plainly, or the owner keeps working on a done Task.
-            if (activity.kind === 'accept' && activity.actor === AGENT_TEAM_HUMAN_MEMBER_ID && readerId !== undefined
-                && activity.completedClaimRefs?.some(claimRef => this.requireLedger().getClaim(claimRef)?.owner === readerId)) {
-                return `Team Task update\n${actor} accepted Task ${activity.taskRef} and your open Claim was completed with it. No further work is needed.`;
+            // An acceptance concludes the reader's own Claims in two ways: a Claim
+            // already finished before the accept was accepted (its work stands), and
+            // a still-open Claim the accept completed atomically (no further work is
+            // needed). Both must be said plainly, or the owner keeps working on a
+            // done Task or never learns its contribution was accepted.
+            if (activity.kind === 'accept' && activity.actor === AGENT_TEAM_HUMAN_MEMBER_ID && readerId !== undefined) {
+                const acceptedOwn = (activity.acceptedClaimRefs ?? []).filter(claimRef => this.requireLedger().getClaim(claimRef)?.owner === readerId);
+                const completedOwn = (activity.completedClaimRefs ?? []).filter(claimRef => this.requireLedger().getClaim(claimRef)?.owner === readerId);
+                // The early-accept-only reader holds no finished Claim: every own Claim
+                // was completed atomically, so the "finished Claim" clause's ref list
+                // would be empty. Render the completed semantics alone instead of a
+                // sentence with a dangling empty list.
+                const finishedOwn = acceptedOwn.filter(claimRef => !completedOwn.includes(claimRef));
+                if (completedOwn.length > 0 && finishedOwn.length > 0) {
+                    return `Team Task update\n${actor} accepted Task ${activity.taskRef}. Your Claim ${completedOwn.join(', ')} was completed with the acceptance, and your finished Claim ${finishedOwn.join(', ')} was accepted. No further work is needed.`;
+                }
+                if (completedOwn.length > 0) {
+                    return `Team Task update\n${actor} accepted Task ${activity.taskRef} and your open Claim ${completedOwn.join(', ')} was completed with it. No further work is needed.`;
+                }
+                if (acceptedOwn.length > 0) {
+                    return `Team Task update\n${actor} accepted Task ${activity.taskRef}; your finished Claim ${acceptedOwn.join(', ')} was accepted. No further work is needed.`;
+                }
             }
             if (activity.kind === 'claim' || activity.kind === 'done' || activity.kind === 'release') {
                 return `Team Task update\n${actor} ${activity.kind} Claim ${activity.claimRef} on Task ${activity.taskRef}.`;
@@ -1376,12 +2578,14 @@ let AgentTeam = (() => {
                 await handle.dispose();
                 this.handles.delete(memberId);
             }
+            this.memberBySessionId.delete(member.sessionId);
             this.modelSelections.delete(memberId);
             this.memberRuntime.forgetMember(memberId);
             this.clearMemberFailure(memberId, 'activation');
         }
         clearMemberRecoveryState(member) {
             this.recovery.stopTracking(member.memberId);
+            this.progressNudge.stopTracking(member.memberId);
             this.clearMemberFailure(member.memberId, 'runtime');
             this.clearMemberNotificationState(member.memberId);
         }