@wowyuarm/dsh-agent-team 0.2.0 → 0.2.1

package/packages/tool-agent-team/lib/context-tools.js

@@ -1,34 +1,35 @@
 /**
  * Model-facing context-management tools for Team Members.
  *
- * `context_rollover` and `context_checkpoint` are the published engine's tools,
- * built by `createContinuityTools`: the engine owns their argument contract, the
- * anti-forgery gate on a cited ref, the `concludeTurn()` timing, and the render
- * shapes, while the Team supplies its own vocabulary (`TEAM_CONTINUITY_TEXT`)
- * and the mechanism behind `ContinuityToolAdapter`. Hand-written copies of those
- * two descriptions used to live here and drifted from the engine's defaults, so
- * the Team's guidance now travels only through the engine's text seams.
+ * All four are the published engine's tools, built by `createContinuityTools`:
+ * the engine owns their argument contract, the anti-forgery gate on a cited ref,
+ * the `concludeTurn()` timing, and the render shapes, while the Team supplies
+ * its own vocabulary (`TEAM_CONTINUITY_TEXT`) and the mechanism behind
+ * `ContinuityToolAdapter`. Hand-written copies of those descriptions used to
+ * live here and drifted from the engine's defaults, so the Team's guidance now
+ * travels only through the engine's text seams — including the Team glossary the
+ * engine splices into `context_status` as `timelineGuidance`.
  *
- * `context_timeline` deliberately stays Team-owned. Its render never prints a
- * ref-shaped string for a non-restorable row — a short digest names the row
- * instead, because a printed ref is exactly what a model copies into
- * `checkpointRef` — and the engine's render has no switch for that. The
- * adapter's own `timeline` member is still implemented: the engine's contract
- * requires it, and the shape it returns is the one the engine's render reads.
+ * One Team rule survives only in the adapter: for a row the engine renders as
+ * not restorable it prints that row's `ref` verbatim (`brief` truncates at 120
+ * characters, and a Team ref is 83), and a printed ref is exactly what a model
+ * copies into `checkpointRef`. The adapter therefore answers such a row with a
+ * short digest instead of its ref — the same digest that keeps two rows sharing
+ * a label and a price apart — so no non-selectable row carries a citable string.
  * @module @wowyuarm/dsh-agent-team/context-tools
  */
 import { createHash } from 'node:crypto';
-import { createContinuityTools, } from '@wowyuarm/dsh-context-continuity';
+import { compactibleNow, createContinuityTools, } from '@wowyuarm/dsh-context-continuity';
 import { MAX_TIMELINE_LIMIT } from '@wowyuarm/dsh-agent-team/host';
-import { defineTool } from '@deepseek-ai/dsh-tools';
 import { member, service } from "./host-access.js";
 /**
  * Short stable identifier for one timeline row: a digest of the anchor's own
  * ref. Rows routinely share a label (`Team message` is a constant) and a price
  * (the same completed turn prices both), so without it two distinct anchors
- * read as one duplicated row. Deliberately NOT the ref and deliberately not
- * actionable: a ref only means something on a restorable row, which prints it
- * in full for `context_rollover`.
+ * read as one duplicated row. It is also what a row that is NOT restorable
+ * answers as its `ref`, because the engine's render prints that field for every
+ * row: a ref only means something on a restorable row, which prints it in full
+ * for `context_rollover`.
  */
 function anchorId(checkpointRef) {
     return createHash('sha256').update(checkpointRef).digest('hex').slice(0, 6);
@@ -40,17 +41,62 @@ function agentOf(exec) {
         throw new Error('context tool requires an Agent session');
     return agent;
 }
+/**
+ * The compaction capability in one calling Agent's preset scope, priced by the
+ * same meter the pressure policy reads. The Host owns the address: a preset
+ * revision publishes its services behind its own isolate, so the engine is asked
+ * for through the one method that knows which realm holds it. A Member whose
+ * composition mounts none reports "not available in this scope" — never a
+ * failure, never a silent no-op.
+ *
+ * The meter travels with the scope because two engine decisions read it: how
+ * much of the newest surface a compaction keeps verbatim, and the price a status
+ * reports for a compaction started now. A scope without one still compacts —
+ * keeping the newest instruction and everything after it — and prices nothing.
+ */
+function compactionScopeFor(agent) {
+    const engine = service(agent).compactionForAgent(agent);
+    if (engine === undefined)
+        return undefined;
+    const meter = agent.ctx.get('tokenMeter');
+    return { engine, ...(meter === undefined ? {} : { meter }) };
+}
+/**
+ * One Host timeline item in the engine's own vocabulary. Team's four sources
+ * collapse onto the engine's three kinds, and the two that say something a
+ * reader needs (`handoff`, `compaction`) ride its opaque `kind` field rather
+ * than being flattened silently.
+ *
+ * The `ref` of a row that is not restorable is a short digest rather than the
+ * ref itself: the engine's render prints this field on every row, and a printed
+ * ref is what a model copies into `checkpointRef`. Only a restorable row — the
+ * one kind of row whose ref `context_rollover` accepts — carries a citable
+ * string.
+ */
+export function engineTimelineItems(items) {
+    return items.map(item => ({
+        ref: item.restorable ? item.checkpointRef : anchorId(item.checkpointRef),
+        label: item.name,
+        source: item.source === 'agent' ? 'checkpoint' : item.source === 'head' ? 'head' : 'boundary',
+        ...(item.source === 'handoff' || item.source === 'compaction' ? { kind: item.source } : {}),
+        retainedTokens: item.retainedTokens,
+        discardedTokens: item.discardedTokens,
+        affectedTopics: [...item.affectedThreads],
+        restorable: item.restorable,
+        ...(item.reason === undefined ? {} : { reason: item.reason }),
+    }));
+}
 /**
  * Team's half of the engine's contract: resolve the calling execution to its
  * Member and Host, answer the ref gate from the one policy that owns it, and run
  * the effects. Every method resolves its own caller, because one adapter serves
- * all three tools.
+ * all four tools.
  */
 const adapter = {
     /**
      * One policy, two readers: a ref is restorable exactly when the Team timeline
      * — the same list the model picked from — offers it as such. The walk is asked
-     * for the widest window the timeline tool can show, so any ref a timeline read
+     * for the widest window `context_status` can show, so any ref a status read
      * could have printed is answered here.
      */
     async isRestorableRef(checkpointRef, exec) {
@@ -88,29 +134,23 @@ const adapter = {
             memberId: current.memberId,
             ...(request.limit === undefined ? {} : { limit: request.limit }),
         });
-        // Team's item vocabulary is its own (`agent` / `team-boundary` / `handoff` /
-        // `compaction` / `head`); the engine names the same anchors in its terms —
-        // four Team sources collapse onto the engine's three kinds, and the two that
-        // say something a reader needs (`handoff`, `compaction`) ride its opaque
-        // `kind` field rather than being flattened silently.
+        // "This scope cannot price a compaction" and "a compaction would replace
+        // nothing" are different facts, and only the second is worth showing, so an
+        // unpriced scope omits the field and the status omits its line.
+        const scope = compactionScopeFor(agent);
+        const compactible = scope === undefined ? undefined : compactibleNow(agent.session, scope);
         return {
             usageTokens: result.usageTokens,
             handoffAt: result.handoffAt,
             hardLimit: result.hardLimit,
-            items: result.items.map(item => ({
-                ref: item.checkpointRef,
-                label: item.name,
-                source: item.source === 'agent' ? 'checkpoint' : item.source === 'head' ? 'head' : 'boundary',
-                ...(item.source === 'handoff' || item.source === 'compaction' ? { kind: item.source } : {}),
-                retainedTokens: item.retainedTokens,
-                discardedTokens: item.discardedTokens,
-                affectedTopics: [...item.affectedThreads],
-                restorable: item.restorable,
-                ...(item.reason === undefined ? {} : { reason: item.reason }),
-            })),
+            ...(compactible === undefined ? {} : { compactible }),
+            items: engineTimelineItems(result.items),
             ...(result.incompleteFrom === undefined ? {} : { incompleteFrom: result.incompleteFrom }),
         };
     },
+    compactionFor(agent) {
+        return compactionScopeFor(agent);
+    },
 };
 /**
  * Team vocabulary for the engine's tools. `carriedContext` names the channels a
@@ -118,92 +158,24 @@ const adapter = {
  * your handoff" sentence reads as "everything must be restated", which is what
  * our own corpus showed members doing. The checklist carries the one item the
  * engine's default does not ask for and the corpus showed missing: which facts
- * were verified and which were only trusted.
+ * were verified and which were only trusted. `timelineGuidance` is the glossary
+ * the engine splices into `context_status`: the engine names the structure, and
+ * only the Team can say what its own rows mean.
  */
 const TEAM_CONTINUITY_TEXT = {
     subjectNoun: 'Team Member',
     carriedContext: 'You stay the same Team Member: your @handle and role, your private memory index, your skills catalog, and the Team and Workspace instructions carry across a rollover — they are re-injected at birth — and the Team ledger (Threads, Tasks, Claims, your inbox, your owner jobs) is one query away (team_view, team_inbox). Do not restate any of it.',
     rolloverChecklist: 'the objective and the atomic action in flight; facts and evidence not already recorded elsewhere; which items you verified and which you only trusted; inferences and unresolved conflicts; current external side effects and their verification state (files, git, jobs, browser state, remote calls); one explicit next step',
+    timelineGuidance: ' Team rows carry Team sources: `checkpoint` is one you recorded, `boundary` is a Team boundary this Host contributed — a committed team_message, a successful team_claim mutation, or a follow/unfollow, rendered as `Team message`, `Team task claim change`, `Team attention change` — and `head` is the current generation. A Thread\'s first delivered notice is a boundary too, rendered `First arrival: <refs>`; later re-deliveries and reminders produce none. A Team boundary is a selectable default exactly when the retained prefix through it stays inside one Thread and the return would shrink the working set below the handoff budget; a boundary spanning several Threads, or attributable to none, states its reason instead. The `anchor` shown on a row that is not restorable is a short digest, never a ref: cite only a ref printed on a restorable row.',
     topicNoun: 'Thread',
     topicNounPlural: 'Threads',
 };
 const engineTools = createContinuityTools(adapter, TEAM_CONTINUITY_TEXT);
-const contextTimeline = defineTool({
-    name: 'context_timeline',
-    description: 'Inspect the bounded structural timeline of this Member\'s context lineage: named checkpoints you recorded, Team boundaries (effect anchors: a committed team_message, a successful team_claim mutation, a follow/unfollow — rendered as `Team message`, `Team task claim change`, `Team attention change`; plus a Thread\'s first delivered notice, rendered as `First arrival: <refs>`), handoff and compaction boundaries, and the current head — across the current generation and its archived ancestors. Only the first delivery of a Thread\'s facts anchors; later re-deliveries and reminders produce no boundary. Returns approximate retained/discarded token estimates, current usage against the pressure budget, the Threads whose facts entered your context by each anchor, and which anchors are restorable. A Team boundary is a selectable default checkpoint exactly when the retained prefix through it stays inside one Thread and the return would shrink the working set below the handoff budget; a boundary spanning several Threads, or attributable to none, states its reason instead. Every row carries a short `anchor` id: it distinguishes rows that share a label and a price, and it is NOT a ref — only the `checkpointRef` printed on a restorable row may be cited to context_rollover. Structural only: no transcript content. A fresh context_rollover (no checkpointRef) never requires consulting this timeline first — call it directly. Use this tool only when you specifically intend a checkpointRef return: to pick the smallest sufficient ref, or to confirm that a fresh handoff is the better path when every anchor is marked non-restorable.',
-    parameters: {
-        limit: { type: 'number', description: 'Maximum number of items to return (default 12, at most 24).' },
-    },
-    output: {
-        schema: { type: 'object', additionalProperties: false, properties: {
-                usageTokens: { type: 'number', required: true },
-                hardLimit: { type: 'number', required: true },
-                handoffAt: { type: 'number', required: true },
-                items: { type: 'array', required: true, items: { type: 'object', additionalProperties: false, properties: {
-                            checkpointRef: { type: 'string', required: true },
-                            name: { type: 'string', required: true },
-                            source: { type: 'string', required: true },
-                            retainedTokens: { type: 'number', required: true },
-                            discardedTokens: { type: 'number', required: true },
-                            affectedThreads: { type: 'array', required: true, items: { type: 'string' } },
-                            restorable: { type: 'boolean', required: true },
-                            reason: { type: 'string' },
-                            sourceSessionId: { type: 'string' },
-                        } } },
-                incompleteFrom: { type: 'object', additionalProperties: false, properties: {
-                        sessionId: { type: 'string', required: true },
-                        reason: { type: 'string', required: true },
-                    } },
-            } },
-        // The item list is the whole decision surface: without each anchor's
-        // ref, label, source, size estimates, affected Threads, and
-        // restorable/reason verdict, the model cannot pick a `checkpointRef` for
-        // `context_rollover` — the summary line alone left the tool unusable for
-        // seeded returns. The short anchor id distinguishes rows that share a
-        // label and a price without ever printing a ref that is not usable. The
-        // Host bounds items (default 12, at most 24), so the list cannot grow
-        // unbounded. `incompleteFrom` states where and why the lineage walk
-        // stopped early, so history read up to that ancestor is known to be a
-        // truncation, not everything that exists.
-        render: (_args, value) => {
-            const lines = [`Context timeline: ${value.usageTokens} tokens used (handoff at ${value.handoffAt}, hard limit ${value.hardLimit}). ${value.items.length} item(s):`];
-            for (const item of value.items) {
-                const threads = item.affectedThreads.length === 0 ? 'no Threads' : `Threads ${item.affectedThreads.join(', ')}`;
-                const size = `retained ~${item.retainedTokens}, discarded ~${item.discardedTokens}`;
-                const restorable = item.restorable
-                    ? `restorable — ref: ${item.checkpointRef}`
-                    : `not restorable — ${item.reason ?? 'no reason given'}`;
-                lines.push(`- ${item.name} [source: ${item.source}; anchor ${anchorId(item.checkpointRef)}] (${size}; ${threads}) — ${restorable}`);
-            }
-            if (value.incompleteFrom !== undefined) {
-                lines.push(`History incomplete: the lineage walk stopped at Session ${value.incompleteFrom.sessionId} (${value.incompleteFrom.reason}); ancestors before it could not be read and are not reflected above.`);
-            }
-            return [{ type: 'text', text: lines.join('\n') }];
-        },
-    },
-    async execute(args, exec) {
-        const agent = exec.agent;
-        if (agent === undefined)
-            throw new Error('context_timeline requires an Agent session');
-        const current = member(agent);
-        const host = service(agent);
-        const limit = typeof args.limit === 'number' ? args.limit : undefined;
-        const result = await host.contextTimelineForAgent(agent, { memberId: current.memberId, ...(limit === undefined ? {} : { limit }) });
-        // The Host result is deeply immutable; the tool output contract carries
-        // plain arrays, so re-shape without any semantic change.
-        return {
-            usageTokens: result.usageTokens,
-            hardLimit: result.hardLimit,
-            handoffAt: result.handoffAt,
-            items: result.items.map(item => ({ ...item, affectedThreads: [...item.affectedThreads] })),
-            ...(result.incompleteFrom === undefined ? {} : { incompleteFrom: result.incompleteFrom }),
-        };
-    },
-});
 export function registerContextTools(ctx) {
-    // The engine's two, then the Team's own timeline: one registration each, and
-    // the roster the Host validates against stays the same three names.
+    // The engine's four, and nothing else: the roster the Host validates against
+    // carries the same names, so no description names a tool this surface lacks.
     ctx.tools.register(engineTools.rollover);
     ctx.tools.register(engineTools.checkpoint);
-    ctx.tools.register(contextTimeline);
+    ctx.tools.register(engineTools.status);
+    ctx.tools.register(engineTools.compact);
 }

package/packages/tool-agent-team/lib/types/context-tools.d.ts

@@ -1,22 +1,38 @@
 /**
  * Model-facing context-management tools for Team Members.
  *
- * `context_rollover` and `context_checkpoint` are the published engine's tools,
- * built by `createContinuityTools`: the engine owns their argument contract, the
- * anti-forgery gate on a cited ref, the `concludeTurn()` timing, and the render
- * shapes, while the Team supplies its own vocabulary (`TEAM_CONTINUITY_TEXT`)
- * and the mechanism behind `ContinuityToolAdapter`. Hand-written copies of those
- * two descriptions used to live here and drifted from the engine's defaults, so
- * the Team's guidance now travels only through the engine's text seams.
+ * All four are the published engine's tools, built by `createContinuityTools`:
+ * the engine owns their argument contract, the anti-forgery gate on a cited ref,
+ * the `concludeTurn()` timing, and the render shapes, while the Team supplies
+ * its own vocabulary (`TEAM_CONTINUITY_TEXT`) and the mechanism behind
+ * `ContinuityToolAdapter`. Hand-written copies of those descriptions used to
+ * live here and drifted from the engine's defaults, so the Team's guidance now
+ * travels only through the engine's text seams — including the Team glossary the
+ * engine splices into `context_status` as `timelineGuidance`.
  *
- * `context_timeline` deliberately stays Team-owned. Its render never prints a
- * ref-shaped string for a non-restorable row — a short digest names the row
- * instead, because a printed ref is exactly what a model copies into
- * `checkpointRef` — and the engine's render has no switch for that. The
- * adapter's own `timeline` member is still implemented: the engine's contract
- * requires it, and the shape it returns is the one the engine's render reads.
+ * One Team rule survives only in the adapter: for a row the engine renders as
+ * not restorable it prints that row's `ref` verbatim (`brief` truncates at 120
+ * characters, and a Team ref is 83), and a printed ref is exactly what a model
+ * copies into `checkpointRef`. The adapter therefore answers such a row with a
+ * short digest instead of its ref — the same digest that keeps two rows sharing
+ * a label and a price apart — so no non-selectable row carries a citable string.
  * @module @wowyuarm/dsh-agent-team/context-tools
  */
+import { type ContextTimelineItem } from '@wowyuarm/dsh-context-continuity';
+import { type AgentTeamTimelineItem } from '@wowyuarm/dsh-agent-team/host';
+/**
+ * One Host timeline item in the engine's own vocabulary. Team's four sources
+ * collapse onto the engine's three kinds, and the two that say something a
+ * reader needs (`handoff`, `compaction`) ride its opaque `kind` field rather
+ * than being flattened silently.
+ *
+ * The `ref` of a row that is not restorable is a short digest rather than the
+ * ref itself: the engine's render prints this field on every row, and a printed
+ * ref is what a model copies into `checkpointRef`. Only a restorable row — the
+ * one kind of row whose ref `context_rollover` accepts — carries a citable
+ * string.
+ */
+export declare function engineTimelineItems(items: readonly AgentTeamTimelineItem[]): ContextTimelineItem[];
 export declare function registerContextTools(ctx: {
     readonly tools: {
         register(tool: unknown): void;

package/packages/tool-agent-team/lib/types/context-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context-tools.d.ts","sourceRoot":"","sources":["../../src/context-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAqMH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE;IAAE,QAAQ,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAA;KAAE,CAAA;CAAE,GAAG,IAAI,CAMrG"}
+{"version":3,"file":"context-tools.d.ts","sourceRoot":"","sources":["../../src/context-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAKL,KAAK,mBAAmB,EAIzB,MAAM,kCAAkC,CAAA;AAEzC,OAAO,EAAsB,KAAK,qBAAqB,EAAE,MAAM,+BAA+B,CAAA;AA6C9F;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,SAAS,qBAAqB,EAAE,GAAG,mBAAmB,EAAE,CAYlG;AA0FD,wBAAgB,oBAAoB,CAAC,GAAG,EAAE;IAAE,QAAQ,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAA;KAAE,CAAA;CAAE,GAAG,IAAI,CAOrG"}

package/packages/agent-team/lib/pressure-policy.js

@@ -1,235 +0,0 @@
-/**
- * Team-owned context pressure policy.
- *
- * The Team preset mounts `compaction-basic` with `auto: false`; this
- * coordinator owns both policy entry points instead — the proactive handoff
- * notice near the effective handoff budget and the forced CompactionEngine
- * reduction before any request at or above the effective hard limit — while
- * reusing the public CompactionEngine implementation. The hard-limit
- * translation lives in exactly one method; no caller re-derives it.
- *
- * Fail-closed rule: at the hard limit, a compaction that no-ops, throws, is
- * cancelled, or does not advance the durable surface must block the model
- * request (reject the step) rather than knowingly submit over the Team limit.
- * A blocked Member keeps its log and reports a recoverable error.
- * @module @wowyuarm/dsh-agent-team/pressure-policy
- */
-import { CONTEXT_WINDOW_EXCEEDED_CODE } from '@deepseek-ai/dsh-llm';
-import { createUserMessage } from '@deepseek-ai/dsh-llm';
-import { contextPressureNoticeText as engineContextPressureNoticeText } from '@wowyuarm/dsh-context-continuity';
-import { AGENT_TEAM_PLUGIN_ID, isAgentTeamSourceKind } from "./context-source.js";
-import { advanceOwnedSessionEventCursor } from "./session-event-cursor.js";
-/**
- * Stable summary of the one-shot rollover pressure notice. It is a durable
- * marker: the notice's own presence in a Session's log is what latches the
- * policy, so the wording is read back and must not drift.
- */
-export const CONTEXT_PRESSURE_NOTICE_SUMMARY = 'Context pressure: prepare a handoff';
-/**
- * Whether this Session's own span already carries the pressure notice: either
- * surfaced as a `user/message` or still queued in a durable
- * `agent/inbox/spliced` insert. Expressed as a fold rather than a scan because
- * the answer is monotone — once delivered it stays delivered for the
- * generation — so the cursor only ever has to read events it has not seen.
- */
-export const PRESSURE_NOTICE_FOLD = {
-    start: false,
-    step: (delivered, event) => {
-        if (delivered)
-            return true;
-        if (event.type === 'user/message' && isPressureNotice(event.data))
-            return true;
-        if (event.type === 'agent/inbox/spliced' && event.data.inserted.some(isPressureNotice))
-            return true;
-        return false;
-    },
-};
-/**
- * One pressure-notice text. The wording is the engine's — the same sentence a
- * fresh-context handoff is asked for through — so the notice and the rollover
- * tool cannot drift apart; Team supplies only its own labels and input shape.
- */
-export function contextPressureNoticeText(input) {
-    return engineContextPressureNoticeText({
-        usageTokens: input.usageTokens,
-        handoffAt: input.handoffAt,
-        hardLimit: input.hardLimit,
-        inHand: input.activeClaims,
-        jobs: input.runningJobs,
-    }, { inHandLabel: 'Active Claims', jobsLabel: 'Owner jobs' });
-}
-/** Whether one user message is this policy's one-shot pressure notice. */
-function isPressureNotice(message) {
-    // The source arrives untyped from the inbox; identity is matched by exact
-    // kind — the shape written now and the read-time conversion's V3 rename.
-    const source = message.source;
-    return isAgentTeamSourceKind(source?.kind)
-        && source?.summary === CONTEXT_PRESSURE_NOTICE_SUMMARY;
-}
-export class PressurePolicyCoordinator {
-    options;
-    /**
-     * Retry budget per agent for the current provider-overflow sequence.
-     * Process-only by design: a restart re-earns one sequence per chain.
-     */
-    overflowRetries = new Map();
-    /**
-     * Whether the one-shot notice was already delivered, folded incrementally per
-     * Member. The scan below is a monotone "has this ever happened" fold over the
-     * Session's own events, so a cursor can replace re-scanning the whole log on
-     * every step; identity guarding falls back to a cold fold when the Member's
-     * Session changed under the entry.
-     */
-    noticeSeen = new Map();
-    disposed = false;
-    constructor(options) {
-        this.options = options;
-    }
-    /**
-     * The one-shot pressure notice is durable Session evidence, not process
-     * state: a `CONTEXT_PRESSURE_NOTICE_SUMMARY` notice already surfaced as a
-     * `user/message`, or still queued in a durable `agent/inbox/spliced`
-     * insert (a steered notice surfaces only at the next step boundary, and a
-     * Host restart replays the splice before surfacing), marks the current
-     * generation as already notified. A resume or restart stays quiet; a
-     * rollover starts a fresh Session whose own event span has no notice yet,
-     * which is exactly the documented re-arm.
-     */
-    noticeDelivered(agent, memberId) {
-        const owned = advanceOwnedSessionEventCursor(this.noticeSeen.get(memberId), agent.session.id, PRESSURE_NOTICE_FOLD, agent.session.ownEvents(), agent.session.inheritedEventCount);
-        this.noticeSeen.set(memberId, owned);
-        return owned.cursor.value;
-    }
-    dispose() {
-        this.disposed = true;
-        this.overflowRetries.clear();
-    }
-    /** A successful assistant response ends any open overflow-recovery sequence. */
-    onAssistantMessage(agent) {
-        this.overflowRetries.delete(agent);
-    }
-    /**
-     * Pre-step policy for one Member agent: below the handoff budget nothing
-     * happens; at the handoff budget one structured notice per generation is
-     * steered into the running turn; at the hard limit the request is forced
-     * through compaction first and fails closed when that cannot be proven.
-     * Returns the decision for the step: `continue` forwards, `reject` blocks.
-     */
-    async onPreStep(agent, signal) {
-        if (this.disposed || signal.aborted)
-            return { kind: 'continue' };
-        const member = this.options.memberForAgent(agent);
-        if (member === undefined)
-            return { kind: 'continue' };
-        const limits = await this.options.limitsForAgent(agent);
-        if (limits === undefined) {
-            // A missing route capacity must be explicit, never an accidental
-            // unlimited policy: reject the step with a recoverable diagnostic.
-            const diagnostic = 'context pressure policy: the routed model capacity is unknown; refusing to forward a request without a bounded context budget';
-            this.options.failed(member.memberId, member.sessionId, diagnostic);
-            return { kind: 'reject' };
-        }
-        const { usageTokens, hardLimit, handoffAt } = limits;
-        if (usageTokens >= hardLimit) {
-            const outcome = await this.enforceHardLimit(agent, member.memberId, member.sessionId, signal);
-            return outcome ? { kind: 'continue' } : { kind: 'reject' };
-        }
-        if (usageTokens >= handoffAt && !this.noticeDelivered(agent, member.memberId)) {
-            const notice = createUserMessage({
-                content: [{ type: 'text', text: contextPressureNoticeText({
-                            usageTokens, handoffAt, hardLimit,
-                            activeClaims: this.options.activeClaimLabels(member.memberId),
-                            runningJobs: this.options.runningJobLabels(member.memberId),
-                        }) }],
-                source: { kind: AGENT_TEAM_PLUGIN_ID, form: 'notice', summary: CONTEXT_PRESSURE_NOTICE_SUMMARY },
-            });
-            try {
-                agent.steer(notice);
-            }
-            catch (error) {
-                this.options.log(`context pressure notice failed: ${error instanceof Error ? error.message : String(error)} (member ${member.memberId})`);
-            }
-            return { kind: 'notice' };
-        }
-        return { kind: 'continue' };
-    }
-    /**
-     * Provider-overflow recovery: one bounded compact-and-retry sequence per
-     * open failure chain. Returns whether the request may retry once.
-     */
-    async onRequestError(agent, failure, signal) {
-        if (this.disposed || signal.aborted)
-            return false;
-        if (failure.code !== CONTEXT_WINDOW_EXCEEDED_CODE)
-            return false;
-        const member = this.options.memberForAgent(agent);
-        if (member === undefined)
-            return false;
-        const retries = this.overflowRetries.get(agent) ?? 0;
-        if (retries >= 1)
-            return false;
-        const engine = this.options.compactionForAgent(agent);
-        if (engine === undefined)
-            return false;
-        const generation = agent.session.surface.replaceGeneration;
-        try {
-            await engine.compactIfNeeded(agent, 'context-overflow', signal);
-        }
-        catch (error) {
-            // Durable prune progress before a later summary failure justifies the
-            // single retry; cancellation never does.
-            if (!signal.aborted && agent.session.surface.replaceGeneration > generation) {
-                this.overflowRetries.set(agent, retries + 1);
-                return true;
-            }
-            this.options.log(`context-overflow recovery failed: ${error instanceof Error ? error.message : String(error)} (member ${member.memberId})`);
-            return false;
-        }
-        if (signal.aborted || agent.session.surface.replaceGeneration <= generation)
-            return false;
-        this.overflowRetries.set(agent, retries + 1);
-        return true;
-    }
-    /**
-     * The one Team hard-limit translation: force a CompactionEngine reduction
-     * in the current Agent/Session and prove it advanced the durable surface
-     * (or measurably reduced pressure) before continuing. Background jobs are
-     * untouched — compaction never cancels or discards them.
-     * @returns whether the request may proceed.
-     */
-    async enforceHardLimit(agent, memberId, sessionId, signal) {
-        const engine = this.options.compactionForAgent(agent);
-        if (engine === undefined) {
-            const diagnostic = 'context hard limit reached and compaction is unavailable in the Member scope; the request was blocked';
-            this.options.failed(memberId, sessionId, diagnostic);
-            return false;
-        }
-        const meter = agent.ctx.get('tokenMeter');
-        const before = meter?.measure(agent.session)?.totalTokens ?? Number.POSITIVE_INFINITY;
-        const generation = agent.session.surface.replaceGeneration;
-        let result;
-        try {
-            result = await engine.compactIfNeeded(agent, 'context-overflow', signal);
-        }
-        catch (error) {
-            const diagnostic = `context hard limit compaction failed: ${error instanceof Error ? error.message : String(error)}; the request was blocked`;
-            this.options.failed(memberId, sessionId, diagnostic);
-            return false;
-        }
-        if (signal.aborted)
-            return false;
-        const after = meter?.measure(agent.session)?.totalTokens ?? Number.POSITIVE_INFINITY;
-        const surfaceAdvanced = agent.session.surface.replaceGeneration > generation;
-        const pressureReduced = meter === undefined ? false : after < before;
-        if (!surfaceAdvanced && !pressureReduced) {
-            // No-op or unchanged replacement generation: fail closed rather than
-            // knowingly submit over the Team limit.
-            const diagnostic = result === null
-                ? 'context hard limit reached and no compactable range exists; the request was blocked'
-                : 'context hard limit compaction produced no measurable reduction; the request was blocked';
-            this.options.failed(memberId, sessionId, diagnostic);
-            return false;
-        }
-        return true;
-    }
-}