@wowyuarm/dsh-agent-team 0.1.11 → 0.1.13

package/packages/agent-team/lib/progress-nudge.js

@@ -1,328 +0,0 @@
-/**
- * Progress-visibility nudges: advisory Session notices that keep Member agents
- * reporting progress into their Threads. Two regimes over one shared
- * per-Member silent-tool-call counter:
- *
- * - Thread progress (A): a Member holding an active Claim, or following a
- *   taskless Thread, that has run many tool calls since its last committed
- *   public communication is reminded to post a brief update. The reminder
- *   ladder advances 20 → 40 → 60… per Member.
- * - Claim suggestion (B): a Member following a still-`todo` Task it has never
- *   claimed is reminded — once per (Member, Thread) within the current Member
- *   Session — that team_claim exists.
- *
- * The Coordinator owns counting, thresholds, notice formatting, dedupe,
- * in-flight revocation, and the deferred steer. It consumes only facts the
- * Host already holds: live `tool/call`/`user/message` session events in their
- * real `{type, seq, time, data}` envelope, the Session log for one-time
- * recovery, committed ledger operations, and a ledger-owned eligibility
- * projection (`progressNudgeTargets`). It never writes Team facts and never
- * wakes idle agents on its own — a nudge rides the member's next tool call.
- *
- * @module @wowyuarm/dsh-agent-team/progress-nudge
- */
-import { createUserMessage } from '@deepseek-ai/dsh-llm';
-import { AGENT_TEAM_PLUGIN_ID, isCheckpointContinuationMessage } from "./context-source.js";
-/** Notice summary for every nudge this Coordinator injects. */
-export const PROGRESS_NUDGE_NOTICE_SUMMARY = 'Progress visibility reminder';
-export const PROGRESS_NUDGE_TOOL_CALLS_START = 20;
-export const PROGRESS_NUDGE_TOOL_CALLS_STEP = 20;
-export const CLAIM_SUGGESTION_TOOL_CALLS = 5;
-/** Stable line prefix marking Claim-suggestion targets inside a nudge notice; the only text this module ever parses back. */
-const CLAIM_TARGET_LINE_PREFIX = '- Claim target: Task ';
-const CLAIM_TARGET_LINE = /^- Claim target: Task (task:[0-9a-f-]+) — Thread (thread:[0-9a-f-]+)$/;
-/** Ledger operation kinds that count as committed public communication and reset silence. */
-export function isPublicCommunicationOperationKind(kind) {
-    return kind === 'team/message-sent' || kind === 'team/thread-replied'
-        || kind === 'team/claim-created' || kind === 'team/claim-done' || kind === 'team/claim-released';
-}
-/** Whether one message is a nudge notice this module injected. */
-export function isProgressNudgeNotice(message) {
-    const source = message.source;
-    return source.kind === 'plugin' && source.plugin === AGENT_TEAM_PLUGIN_ID
-        && source.form === 'notice' && source.summary === PROGRESS_NUDGE_NOTICE_SUMMARY;
-}
-/**
- * Event-driven per-Member nudge state machine. All state is in-process and
- * scoped to one Member Session; nothing is persisted. The Host feeds it live
- * session events in their real envelope, committed operations, and lifecycle
- * stop points.
- */
-export class ProgressNudgeCoordinator {
-    members = new Map();
-    agentForMember;
-    targetsForMember;
-    sessionLogForMember;
-    log;
-    scheduleSteer;
-    progressThresholdStart;
-    progressThresholdStep;
-    claimSuggestionThreshold;
-    constructor(options) {
-        this.agentForMember = options.agentForMember;
-        this.targetsForMember = options.targetsForMember;
-        this.sessionLogForMember = options.sessionLogForMember;
-        this.log = options.log;
-        this.scheduleSteer = options.scheduleSteer ?? (run => { queueMicrotask(run); });
-        this.progressThresholdStart = options.progressThresholdStart ?? PROGRESS_NUDGE_TOOL_CALLS_START;
-        this.progressThresholdStep = options.progressThresholdStep ?? PROGRESS_NUDGE_TOOL_CALLS_STEP;
-        this.claimSuggestionThreshold = options.claimSuggestionThreshold ?? CLAIM_SUGGESTION_TOOL_CALLS;
-    }
-    /**
-     * One live session event for a Member, in its real `{type, seq, time, data}`
-     * envelope. Only `tool/call` counts toward silence; a `user/message` whose
-     * source is exactly this module's own notice records that the model consumed
-     * the nudge (a Claim suggestion becomes final only then). The live `agent`
-     * is passed in by the caller because it exists at event time even before
-     * the Host finishes publishing the handle.
-     */
-    onSessionEvent(memberId, sessionId, agent, event) {
-        if (event.type === 'user/message') {
-            if (!isProgressNudgeNotice(event.data))
-                return;
-            const state = this.members.get(memberId);
-            if (state === undefined)
-                return;
-            const notice = state.pending;
-            if (notice !== undefined && notice.messageId === event.data.id)
-                state.pending = undefined;
-            for (const threadRef of claimTargetThreadRefs(event.data))
-                state.claimSuggested.add(threadRef);
-            return;
-        }
-        if (event.type !== 'tool/call')
-            return;
-        let state = this.members.get(memberId);
-        if (state === undefined || state.sessionId !== sessionId) {
-            // First event of this Member Session (or a generation the Host did not
-            // stop explicitly): fresh tracking replaces whatever was there, and
-            // consumed one-time suggestions are recovered from the durable log so a
-            // Host restart or suspend/resume within the same Session cannot repeat
-            // them. A Human-initiated new Session has a different id and starts
-            // empty, exactly as specified.
-            this.dropState(memberId, state);
-            state = { sessionId, silentToolCalls: 0, nextProgressThreshold: this.progressThresholdStart,
-                claimSuggested: this.recoverClaimSuggestions(memberId, sessionId), };
-            this.members.set(memberId, state);
-        }
-        state.silentToolCalls += 1;
-        if (state.lastNudgeTurn === event.data.turn)
-            return;
-        this.maybeNudge(memberId, state, agent, event.data.turn);
-    }
-    /**
-     * One ledger operation committed. A Member actor's public communication
-     * resets its silence; every commit also reconciles pending notices whose
-     * targets may have just disappeared (Task accepted, Channel archived, the
-     * Claim taken by someone else).
-     */
-    onCommitted(operation) {
-        if (operation.actor.kind === 'member' && operation.actor.memberId !== undefined
-            && isPublicCommunicationOperationKind(operation.kind)) {
-            const state = this.members.get(operation.actor.memberId);
-            if (state !== undefined) {
-                state.silentToolCalls = 0;
-                state.nextProgressThreshold = this.progressThresholdStart;
-                this.revokePending(operation.actor.memberId, state);
-            }
-        }
-        this.reconcileAll();
-    }
-    /** Revoke one Member's queued-but-unconsumed nudge, e.g. when a higher-priority Team notice is injected. */
-    revokePendingNotice(memberId) {
-        const state = this.members.get(memberId);
-        if (state !== undefined)
-            this.revokePending(memberId, state);
-    }
-    /** Drop all tracking for one Member (suspend/archive/remove/renew/context-clear/steer failure). */
-    stopTracking(memberId) {
-        this.dropState(memberId, this.members.get(memberId));
-        this.members.delete(memberId);
-    }
-    /** Stop tracking every Member. */
-    dispose() {
-        for (const memberId of this.members.keys())
-            this.stopTracking(memberId);
-    }
-    /** Rebuild the consumed one-time suggestion set from this Session's durable log. */
-    recoverClaimSuggestions(memberId, sessionId) {
-        const suggested = new Set();
-        const log = this.sessionLogForMember(memberId, sessionId);
-        if (log === undefined)
-            return suggested;
-        for (const event of log.events) {
-            if (event.type !== 'user/message')
-                continue;
-            if (!isProgressNudgeNotice(event.data))
-                continue;
-            for (const threadRef of claimTargetThreadRefs(event.data))
-                suggested.add(threadRef);
-        }
-        return suggested;
-    }
-    dropState(memberId, state) {
-        if (state === undefined)
-            return;
-        this.revokePending(memberId, state);
-        this.members.delete(memberId);
-    }
-    revokePending(memberId, state) {
-        const notice = state.pending;
-        if (notice !== undefined) {
-            notice.canceled = true;
-            if (notice.steered) {
-                const agent = this.agentForMember(memberId);
-                const pending = agent === undefined ? undefined
-                    : [...agent.inbox.nextStep, ...agent.inbox.nextTurn].find(message => message.id === notice.messageId);
-                // A just-consumed notice is simply gone; remove() returning false is expected.
-                if (pending !== undefined)
-                    agent.inbox.remove(pending.id);
-            }
-        }
-        state.pending = undefined;
-    }
-    /** Re-check every live Member's pending notice against the targets it actually listed. */
-    reconcileAll() {
-        for (const [memberId, state] of this.members) {
-            const notice = state.pending;
-            if (notice === undefined)
-                continue;
-            const agent = this.agentForMember(memberId);
-            if (agent === undefined) {
-                this.dropState(memberId, state);
-                continue;
-            }
-            const targets = this.targetsForMember(memberId);
-            // The notice is stale when ANY target it listed is no longer eligible:
-            // the body names threads whose work may be finished, so a partial
-            // survival must not keep the whole stale notice alive.
-            const progressAlive = notice.progressThreadRefs.length === 0
-                || notice.progressThreadRefs.every(threadRef => targets.progress.some(target => target.threadRef === threadRef));
-            const claimAlive = notice.claimThreadRefs.length === 0
-                || notice.claimThreadRefs.every(threadRef => targets.claim.some(target => target.threadRef === threadRef));
-            if (!progressAlive || !claimAlive)
-                this.revokePending(memberId, state);
-        }
-    }
-    maybeNudge(memberId, state, agent, turn) {
-        const targets = this.targetsForMember(memberId);
-        const progressDue = state.silentToolCalls >= state.nextProgressThreshold && targets.progress.length > 0;
-        const freshClaimTargets = targets.claim
-            .filter(target => !state.claimSuggested.has(target.threadRef) && state.pending?.claimThreadRefs.includes(target.threadRef) !== true);
-        const claimDue = state.silentToolCalls >= this.claimSuggestionThreshold && freshClaimTargets.length > 0;
-        if (!progressDue && !claimDue)
-            return;
-        if (this.hasBlockingNotice(agent))
-            return;
-        const progressTargets = progressDue ? targets.progress : [];
-        const claimTargets = claimDue ? freshClaimTargets : [];
-        const notice = createUserMessage({
-            content: [{ type: 'text', text: nudgeNoticeText(state.silentToolCalls, progressTargets, claimTargets) }],
-            source: { kind: 'plugin', plugin: AGENT_TEAM_PLUGIN_ID, form: 'notice', summary: PROGRESS_NUDGE_NOTICE_SUMMARY },
-        });
-        const pending = {
-            messageId: notice.id,
-            progressThreadRefs: progressTargets.map(target => target.threadRef),
-            claimThreadRefs: claimTargets.map(target => target.threadRef),
-            steered: false,
-            canceled: false,
-        };
-        // Record intent first: the scheduled steer, its cancellation check, and
-        // its failure handling all live on this single PendingNotice object, so a
-        // revoke between queueing and the microtask leaves no orphan injection.
-        // lastNudgeTurn stays as the same-turn intent guard, but the A threshold
-        // only commits after the real steer succeeds — a canceled or failed
-        // schedule leaves the rung due so the next tool call retries it.
-        state.pending = pending;
-        state.lastNudgeTurn = turn;
-        this.scheduleSteer(() => {
-            if (pending.canceled)
-                return;
-            try {
-                agent.steer(notice);
-            }
-            catch (error) {
-                this.log?.(`progress nudge steer failed for member '${memberId}': ${error instanceof Error ? error.message : String(error)}`);
-                pending.canceled = true;
-                if (state.pending === pending)
-                    state.pending = undefined;
-                this.stopTracking(memberId);
-                return;
-            }
-            pending.steered = true;
-            if (pending.progressThreadRefs.length > 0) {
-                // Advance the ladder past the count at real success in one move: a
-                // long silence held back by higher-priority notices must not replay
-                // every skipped rung on successive tool calls after the blocker
-                // clears.
-                while (state.nextProgressThreshold <= state.silentToolCalls)
-                    state.nextProgressThreshold += this.progressThresholdStep;
-            }
-        });
-    }
-    /**
-     * Recovery, Inbox, and pre-compaction notices outrank a progress nudge. If
-     * one is already pending, this nudge stays due and retries on the next tool
-     * call; a DM relay is not a notice and never blocks.
-     */
-    hasBlockingNotice(agent) {
-        for (const message of [...agent.inbox.nextStep, ...agent.inbox.nextTurn]) {
-            const source = message.source;
-            if (source.kind !== 'plugin' || source.plugin !== AGENT_TEAM_PLUGIN_ID)
-                continue;
-            // A queued checkpoint continuation is a pending wake that outranks a
-            // nudge exactly as the notice families above do. It rides the snapshot
-            // form (it must carry its checkpoint ref in a section), so it cannot be
-            // recognized by the notice summary check below.
-            if (isCheckpointContinuationMessage(message))
-                return true;
-            if (source.form !== 'notice')
-                continue;
-            if (source.summary !== PROGRESS_NUDGE_NOTICE_SUMMARY)
-                return true;
-        }
-        return false;
-    }
-}
-/** Extract the threadRefs this module itself wrote as Claim targets in one notice. */
-function claimTargetThreadRefs(message) {
-    const refs = [];
-    for (const block of message.content) {
-        if (block.type !== 'text')
-            continue;
-        for (const line of block.text.split('\n')) {
-            const match = CLAIM_TARGET_LINE.exec(line);
-            if (match !== null)
-                refs.push(match[2]);
-        }
-    }
-    return refs;
-}
-function nudgeNoticeText(silentToolCalls, progress, claim) {
-    const sections = [];
-    if (progress.length > 0) {
-        sections.push([
-            'Progress visibility reminder',
-            '',
-            `You have made ${silentToolCalls} tool calls since your last visible Team update. Please briefly update the relevant Thread(s): what you confirmed, what remains, and any blocker. Read the Thread first if needed, then continue working.`,
-            '',
-            ...progress.map(target => target.reason === 'active-claim'
-                ? `- Task ${target.taskRef} — Thread ${target.threadRef}`
-                : `- Taskless Thread ${target.threadRef} (reply only if your current work relates to it)`),
-        ].join('\n'));
-    }
-    if (claim.length > 0) {
-        sections.push([
-            'Claim visibility reminder',
-            '',
-            'You have been working while following the Task(s) below, but you have never claimed a direction there.',
-            '',
-            ...claim.map(target => `${CLAIM_TARGET_LINE_PREFIX}${target.taskRef} — Thread ${target.threadRef}`),
-            '',
-            'If your current work belongs to one of these Tasks, briefly state your direction in its Thread and consider team_claim. If it does not, no action is required. This is advisory, not a claim requirement.',
-        ].join('\n'));
-    }
-    if (progress.length > 0)
-        sections.push('This is advisory; do not stop useful work merely to produce a long status report.');
-    return sections.join('\n\n');
-}

package/packages/agent-team/lib/types/progress-nudge.d.ts

@@ -1,136 +0,0 @@
-/**
- * Progress-visibility nudges: advisory Session notices that keep Member agents
- * reporting progress into their Threads. Two regimes over one shared
- * per-Member silent-tool-call counter:
- *
- * - Thread progress (A): a Member holding an active Claim, or following a
- *   taskless Thread, that has run many tool calls since its last committed
- *   public communication is reminded to post a brief update. The reminder
- *   ladder advances 20 → 40 → 60… per Member.
- * - Claim suggestion (B): a Member following a still-`todo` Task it has never
- *   claimed is reminded — once per (Member, Thread) within the current Member
- *   Session — that team_claim exists.
- *
- * The Coordinator owns counting, thresholds, notice formatting, dedupe,
- * in-flight revocation, and the deferred steer. It consumes only facts the
- * Host already holds: live `tool/call`/`user/message` session events in their
- * real `{type, seq, time, data}` envelope, the Session log for one-time
- * recovery, committed ledger operations, and a ledger-owned eligibility
- * projection (`progressNudgeTargets`). It never writes Team facts and never
- * wakes idle agents on its own — a nudge rides the member's next tool call.
- *
- * @module @wowyuarm/dsh-agent-team/progress-nudge
- */
-import { type UserMessage } from '@deepseek-ai/dsh-llm';
-import type { SessionEvent, SessionId } from '@deepseek-ai/dsh-session';
-import type { AgentTeamMemberId, AgentTeamProgressNudgeTargets } from './types.ts';
-/** Notice summary for every nudge this Coordinator injects. */
-export declare const PROGRESS_NUDGE_NOTICE_SUMMARY = "Progress visibility reminder";
-export declare const PROGRESS_NUDGE_TOOL_CALLS_START = 20;
-export declare const PROGRESS_NUDGE_TOOL_CALLS_STEP = 20;
-export declare const CLAIM_SUGGESTION_TOOL_CALLS = 5;
-/** Minimal Agent surface the Coordinator depends on; real Agents satisfy it, tests fake it. */
-export interface ProgressNudgeAgent {
-    readonly inbox: {
-        readonly nextStep: readonly UserMessage[];
-        readonly nextTurn: readonly UserMessage[];
-        remove(messageId: UserMessage['id']): boolean;
-    };
-    steer(message: UserMessage): void;
-}
-/**
- * Read-only view of one Session log used to recover consumed one-time Claim
- * suggestions when a Member Session's tracking is (re)established.
- */
-export interface ProgressNudgeSessionLog {
-    /** Durable events in sequence order; the real `Session.ownEvents()`. */
-    readonly events: readonly SessionEvent[];
-}
-/** Minimal operation fact the Coordinator consumes; the ledger's full record satisfies it structurally. */
-export interface ProgressNudgeOperation {
-    readonly actor: {
-        readonly kind: string;
-        readonly memberId?: AgentTeamMemberId | undefined;
-    };
-    readonly kind: string;
-}
-export interface ProgressNudgeCoordinatorOptions {
-    /** Live Agent lookup for revocation and injection. */
-    readonly agentForMember: (memberId: AgentTeamMemberId) => ProgressNudgeAgent | undefined;
-    /** Current eligibility projection from the ledger. */
-    readonly targetsForMember: (memberId: AgentTeamMemberId) => AgentTeamProgressNudgeTargets;
-    /** Durable Session log lookup for one-time recovery on (re)activation. */
-    readonly sessionLogForMember: (memberId: AgentTeamMemberId, sessionId: SessionId) => ProgressNudgeSessionLog | undefined;
-    /** Log one line when steer fails; the Host wires its logger. */
-    readonly log?: (message: string) => void;
-    /**
-     * Schedule the actual steer past an in-flight session append publication.
-     * The default defers one microtask; tests may substitute a synchronous or
-     * manually triggered scheduler. The callback runs the real steer.
-     */
-    readonly scheduleSteer?: (run: () => void) => void;
-    /** Initial ladder start; tests override to keep runs small. */
-    readonly progressThresholdStart?: number;
-    /** Ladder step; tests override to keep runs small. */
-    readonly progressThresholdStep?: number;
-    /** Claim-suggestion threshold; tests override to keep runs small. */
-    readonly claimSuggestionThreshold?: number;
-}
-/** Ledger operation kinds that count as committed public communication and reset silence. */
-export declare function isPublicCommunicationOperationKind(kind: string): boolean;
-/** Whether one message is a nudge notice this module injected. */
-export declare function isProgressNudgeNotice(message: UserMessage): boolean;
-/**
- * Event-driven per-Member nudge state machine. All state is in-process and
- * scoped to one Member Session; nothing is persisted. The Host feeds it live
- * session events in their real envelope, committed operations, and lifecycle
- * stop points.
- */
-export declare class ProgressNudgeCoordinator {
-    private readonly members;
-    private readonly agentForMember;
-    private readonly targetsForMember;
-    private readonly sessionLogForMember;
-    private readonly log;
-    private readonly scheduleSteer;
-    private readonly progressThresholdStart;
-    private readonly progressThresholdStep;
-    private readonly claimSuggestionThreshold;
-    constructor(options: ProgressNudgeCoordinatorOptions);
-    /**
-     * One live session event for a Member, in its real `{type, seq, time, data}`
-     * envelope. Only `tool/call` counts toward silence; a `user/message` whose
-     * source is exactly this module's own notice records that the model consumed
-     * the nudge (a Claim suggestion becomes final only then). The live `agent`
-     * is passed in by the caller because it exists at event time even before
-     * the Host finishes publishing the handle.
-     */
-    onSessionEvent(memberId: AgentTeamMemberId, sessionId: SessionId, agent: ProgressNudgeAgent, event: SessionEvent): void;
-    /**
-     * One ledger operation committed. A Member actor's public communication
-     * resets its silence; every commit also reconciles pending notices whose
-     * targets may have just disappeared (Task accepted, Channel archived, the
-     * Claim taken by someone else).
-     */
-    onCommitted(operation: ProgressNudgeOperation): void;
-    /** Revoke one Member's queued-but-unconsumed nudge, e.g. when a higher-priority Team notice is injected. */
-    revokePendingNotice(memberId: AgentTeamMemberId): void;
-    /** Drop all tracking for one Member (suspend/archive/remove/renew/context-clear/steer failure). */
-    stopTracking(memberId: AgentTeamMemberId): void;
-    /** Stop tracking every Member. */
-    dispose(): void;
-    /** Rebuild the consumed one-time suggestion set from this Session's durable log. */
-    private recoverClaimSuggestions;
-    private dropState;
-    private revokePending;
-    /** Re-check every live Member's pending notice against the targets it actually listed. */
-    private reconcileAll;
-    private maybeNudge;
-    /**
-     * Recovery, Inbox, and pre-compaction notices outrank a progress nudge. If
-     * one is already pending, this nudge stays due and retries on the next tool
-     * call; a DM relay is not a notice and never blocks.
-     */
-    private hasBlockingNotice;
-}
-//# sourceMappingURL=progress-nudge.d.ts.map

package/packages/agent-team/lib/types/progress-nudge.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"progress-nudge.d.ts","sourceRoot":"","sources":["../../src/progress-nudge.ts"],"names":[],"mappings":"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"}

package/packages/client-agent-team/lib/types/client/TeamSettings.d.ts

@@ -1,3 +0,0 @@
-import type { TeamSettingsProps } from './slots.ts';
-export declare function TeamSettings({ wide, loadMemberGroups, t }: TeamSettingsProps): import("react").JSX.Element;
-//# sourceMappingURL=TeamSettings.d.ts.map

package/packages/client-agent-team/lib/types/client/TeamSettings.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TeamSettings.d.ts","sourceRoot":"","sources":["../../../src/client/TeamSettings.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAGnD,wBAAgB,YAAY,CAAC,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC,EAAE,EAAE,iBAAiB,+BAE5E"}

package/packages/client-agent-team/lib/types/client/TeamSettings.js

@@ -1,5 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { TeamMembersAction } from "./TeamMembersAction.js";
-export function TeamSettings({ wide, loadMemberGroups, t }) {
-    return _jsx(TeamMembersAction, { wide: wide, loadMemberGroups: loadMemberGroups, t: t });
-}

package/packages/client-agent-team/lib/types/client/scope-coverage.d.ts

@@ -1,41 +0,0 @@
-/** The change scopes whose wakes one surface answers with a shared refresh round. */
-export type SupplementalScope = 'workspace' | 'presence';
-/** One change wake, carrying a version from the scope that issued it. */
-export interface ScopeWake {
-    readonly scope: SupplementalScope;
-    readonly version: number;
-}
-/**
- * Per-scope coverage of the change versions one surface has already answered.
- *
- * A version is only comparable inside the scope that issued it: the Host
- * answers a workspace scope from the durable ledger position and a presence
- * scope from its process-local wake epoch, which starts low and climbs on every
- * Agent transition. One high-water mark shared by both would therefore let a
- * presence epoch swallow a later, smaller ledger sequence and park the surface
- * on stale data, so coverage and pending versions are kept per scope.
- *
- * One round answers one version per scope. The Host delivers one event to every
- * matching scope, so the first version a round sees in a scope it has not
- * answered yet is that event reaching a second scope, and joins the round
- * already fetching instead of earning a second identical read. A newer version
- * in a scope the round has answered arrived after the round issued its fetch,
- * so it owes one trailing round.
- */
-export declare class ScopeCoverage {
-    private readonly covered;
-    private readonly pending;
-    /** The scopes the open round has an answer for. */
-    private readonly answered;
-    private fetching;
-    /** Folds one wake in and answers whether it opens a round. */
-    wake(scope: SupplementalScope, version: number): boolean;
-    /** Opens a round's fetch window; versions observed from here on are pending. */
-    beginRound(): void;
-    /** Closes a round's fetch window and answers whether a trailing round is owed. */
-    finishRound(): boolean;
-    /** Drops every observation: a new owner starts with nothing covered. */
-    reset(): void;
-    private coveredOf;
-}
-//# sourceMappingURL=scope-coverage.d.ts.map

package/packages/client-agent-team/lib/types/client/scope-coverage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scope-coverage.d.ts","sourceRoot":"","sources":["../../../src/client/scope-coverage.ts"],"names":[],"mappings":"AAAA,qFAAqF;AACrF,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG,UAAU,CAAA;AAExD,yEAAyE;AACzE,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAA;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuC;IAC/D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuC;IAC/D,mDAAmD;IACnD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA+B;IACxD,OAAO,CAAC,QAAQ,CAAQ;IAExB,8DAA8D;IAC9D,IAAI,CAAC,KAAK,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO;IAWxD,gFAAgF;IAChF,UAAU,IAAI,IAAI;IAKlB,kFAAkF;IAClF,WAAW,IAAI,OAAO;IAYtB,wEAAwE;IACxE,KAAK,IAAI,IAAI;IAOb,OAAO,CAAC,SAAS;CAGlB"}

package/packages/client-agent-team/lib/types/client/scope-coverage.js

@@ -1,64 +0,0 @@
-/**
- * Per-scope coverage of the change versions one surface has already answered.
- *
- * A version is only comparable inside the scope that issued it: the Host
- * answers a workspace scope from the durable ledger position and a presence
- * scope from its process-local wake epoch, which starts low and climbs on every
- * Agent transition. One high-water mark shared by both would therefore let a
- * presence epoch swallow a later, smaller ledger sequence and park the surface
- * on stale data, so coverage and pending versions are kept per scope.
- *
- * One round answers one version per scope. The Host delivers one event to every
- * matching scope, so the first version a round sees in a scope it has not
- * answered yet is that event reaching a second scope, and joins the round
- * already fetching instead of earning a second identical read. A newer version
- * in a scope the round has answered arrived after the round issued its fetch,
- * so it owes one trailing round.
- */
-export class ScopeCoverage {
-    covered = new Map();
-    pending = new Map();
-    /** The scopes the open round has an answer for. */
-    answered = new Set();
-    fetching = false;
-    /** Folds one wake in and answers whether it opens a round. */
-    wake(scope, version) {
-        if (version <= this.coveredOf(scope))
-            return false;
-        if (this.fetching && this.answered.has(scope)) {
-            this.pending.set(scope, Math.max(this.pending.get(scope) ?? 0, version));
-            return false;
-        }
-        this.answered.add(scope);
-        this.covered.set(scope, version);
-        return !this.fetching;
-    }
-    /** Opens a round's fetch window; versions observed from here on are pending. */
-    beginRound() {
-        this.pending.clear();
-        this.fetching = true;
-    }
-    /** Closes a round's fetch window and answers whether a trailing round is owed. */
-    finishRound() {
-        this.fetching = false;
-        this.answered.clear();
-        let owed = false;
-        for (const [scope, version] of this.pending) {
-            if (version <= this.coveredOf(scope))
-                continue;
-            this.covered.set(scope, version);
-            owed = true;
-        }
-        return owed;
-    }
-    /** Drops every observation: a new owner starts with nothing covered. */
-    reset() {
-        this.covered.clear();
-        this.pending.clear();
-        this.answered.clear();
-        this.fetching = false;
-    }
-    coveredOf(scope) {
-        return this.covered.get(scope) ?? 0;
-    }
-}