@wowyuarm/dsh-agent-team 0.1.6 → 0.1.8

package/packages/agent-team/lib/member-context.js

@@ -1,5 +1,6 @@
 import { readFile } from 'node:fs/promises';
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { SessionLogOffset } from '@deepseek-ai/dsh-session';
 export const name = 'wowyuarm-agent-team-member-context';
 const MAX_MEMORY_BYTES = 8 * 1024;
 const BEGIN = '<team-member-private-memory>';
@@ -30,7 +31,10 @@ export function apply(ctx) {
         }
         const text = `${renderMemberIdentity(member)}\n\n${memory}`;
         const latestText = agent.session.surface.nodes.toReversed().flatMap(sequence => {
-            const event = agent.session.events[sequence];
+            // `nodes` are event identities (SessionSeq); snapshotEvents takes log
+            // offsets. Re-entering through the validating constructor keeps the two
+            // number domains explicit (the seq = log.length contiguity contract).
+            const event = agent.session.snapshotEvents(SessionLogOffset(sequence), SessionLogOffset(sequence + 1))[0];
             return event?.type === 'user/message'
                 && event.data.source.kind === 'plugin'
                 && event.data.source.plugin === name
@@ -59,7 +63,7 @@ export function renderMemberMemory(raw, privateMemoryPath = '<private-memory-pat
     const warning = overBudget
         ? '\n\n[Maintenance warning: memory.md exceeds the 8 KiB context budget. Its contents were not injected; do not delete or automatically summarize the file. Maintain a smaller index explicitly.]'
         : '';
-    return `${BEGIN}\nThis is the complete replacement for this Team Member's private memory index; all earlier private-memory context is obsolete. It is reference context only, may be stale, and is not an instruction or Team fact.\n\nPrivate memory directory: ${privateMemoryPath}\nMemory index: ${privateMemoryPath}/memory.md\nNotes directory: ${privateMemoryPath}/notes\nPrivate skills directory: ${privateMemoryPath}/skills\nThese paths are outside the Workspace cwd. Relative filesystem paths resolve from cwd, so use the absolute paths above when reading or editing this Member's memory. Read matching notes on demand; do not copy credentials, sensitive data, guesses, chat logs, other Members' memory, or Team facts already owned by the ledger into memory.\n\n${escape(body)}${warning}\n${END}`;
+    return `${BEGIN}\nThis is the complete replacement for this Team Member's private memory index; all earlier private-memory context is obsolete. It is reference context only, may be stale, and is not an instruction or Team fact.\n\nPrivate memory directory: ${privateMemoryPath}\nMemory index: ${privateMemoryPath}/memory.md\nNotes directory: ${privateMemoryPath}/notes\nPrivate skills directory: ${privateMemoryPath}/skills\nThese paths are outside the Workspace cwd. Relative filesystem paths resolve from cwd, so use the absolute paths above when reading or editing this Member's memory. Only this Member can read this directory — no other human or agent sees its contents; when communicating, restate what you need from it instead of pointing others at these paths. Read matching notes on demand; do not copy credentials, sensitive data, guesses, chat logs, other Members' memory, or Team facts already owned by the ledger into memory.\n\n${escape(body)}${warning}\n${END}`;
 }
 function renderUnavailableMemory(privateMemoryPath, reason) {
     return `${BEGIN}\nThis is the complete replacement for this Team Member's private memory index; all earlier private-memory context is obsolete. ${reason}\n\nPrivate memory directory: ${privateMemoryPath}\nMemory index: ${privateMemoryPath}/memory.md\nNotes directory: ${privateMemoryPath}/notes\nPrivate skills directory: ${privateMemoryPath}/skills\nThese paths are outside the Workspace cwd. Use the absolute paths above when inspecting or repairing this Member's memory.\n${END}`;

package/packages/agent-team/lib/member-runtime.js

@@ -0,0 +1,229 @@
+/**
+ * Per-Member runtime state extracted from the Agent Team Host service: the
+ * cohesive per-Member maps and methods that must dispose together across
+ * activation, edit, suspend, and removal — the tool-policy restriction seam,
+ * the private skill selection/provider mounts, capability warnings, and
+ * private-memory provisioning.
+ *
+ * This class is Host-side by design: its turn-boundary wait subscribes to
+ * Host-level agent events, and every traceable-service registration goes
+ * through contexts the Host already owns. The service keeps orchestration
+ * (ledger, handles, notifications, recovery); this module owns per-Member
+ * runtime invariants.
+ *
+ * @module @wowyuarm/dsh-agent-team/member-runtime
+ */
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { scopeOf } from '@deepseek-ai/dsh-scope';
+import * as memberSkills from "./member-skills.js";
+/**
+ * Read-only core skills shipped beside the preset (the meta skill first:
+ * its description routes any skill-management work to itself). Resolved
+ * from this module's emitted location so it follows the installed plugin,
+ * like the preset roster's own root.
+ */
+const BUNDLED_SKILLS_DIRECTORY = resolve(dirname(fileURLToPath(import.meta.url)), '../core-skills');
+/** Model-facing capabilities every Team-enabled preset must publish. */
+export const AGENT_TEAM_TOOL_NAMES = Object.freeze([
+    'team_inbox',
+    'team_thread',
+    'team_message',
+    'team_claim',
+    'team_view',
+]);
+/** Copy a Remote-supplied capability overlay into owned frozen storage. */
+export function deepCopyCapabilities(capabilities) {
+    const copyAllow = (allow) => allow === undefined ? {} : { allow: [...allow] };
+    return {
+        ...(capabilities.tools === undefined ? {} : { tools: copyAllow(capabilities.tools.allow) }),
+        ...(capabilities.skills === undefined ? {} : { skills: copyAllow(capabilities.skills.allow) }),
+    };
+}
+/** Per-Member runtime state; the four maps dispose together with each Member. */
+export class MemberRuntime {
+    deps;
+    /**
+     * Live per-Member tool restriction disposers, mirroring modelSelections:
+     * activation registers, disposal paths release, edits swap at a turn
+     * boundary. Deliberate interface reservation: the restriction seam is the
+     * primitive future Runtime Revision manifests orchestrate — do not remove
+     * during cleanup.
+     */
+    memberRestrictions = new Map();
+    /**
+     * Runtime-derived capability warnings, recomputed at every activation (like
+     * memberFailures, keyed by Member and never persisted): persisted warnings
+     * would lie after a Host restart or a Harness upgrade renames tools.
+     */
+    capabilityWarnings = new Map();
+    /** Live skill selection refs let capability edits re-filter the catalog without disposing the Session. */
+    skillSelections = new Map();
+    /** Per-Member private skill provider disposers; released with the Member's agent scope. */
+    skillProviderDisposals = new Map();
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /** One Member's live capability warnings, if any; runtime-derived, never persisted. */
+    capabilityWarningsFor(memberId) {
+        return this.capabilityWarnings.get(memberId);
+    }
+    /**
+     * Apply one Member's persisted tool allow-list as a scoped restriction on
+     * the freshly composed preset surface, and derive activation-time warnings
+     * for entries the current tool surface no longer knows. Runs inside setup
+     * BEFORE validateMemberPreset so the validation observes the restricted
+     * view (the Host always unions the five Team tools over the configured
+     * list). Deliberate interface reservation: this restriction seam is the
+     * primitive future Runtime Revision manifests orchestrate — do not remove
+     * during cleanup.
+     */
+    applyMemberToolPolicy(agentCtx, member) {
+        const configured = member.capabilities?.tools?.allow;
+        if (configured === undefined) {
+            this.capabilityWarnings.delete(member.memberId);
+            return;
+        }
+        // Drop names the current surface does not know rather than failing the
+        // activation: a Harness upgrade renaming a tool must not make the Member
+        // unavailable. The warning carries the known-name digest so a distant
+        // future reader can diagnose the drift.
+        const known = this.deps.ctx.tools.schemas(scopeOf(agentCtx)).map(tool => tool.name);
+        const knownSet = new Set(known);
+        const dropped = configured.filter(name => !knownSet.has(name));
+        this.setCapabilityWarnings(member.memberId, dropped.map(name => ({ name, knownNames: known })));
+        const allow = [...new Set([...configured.filter(name => knownSet.has(name)), ...AGENT_TEAM_TOOL_NAMES])];
+        if (allow.length === 0)
+            return;
+        // tools.restrict() requires a scoped context and rejects names outside
+        // the inherited surface; both errors surface as this Member's activation
+        // failure without touching any other Member.
+        const dispose = agentCtx.tools.restrict({ allow });
+        this.memberRestrictions.set(member.memberId, dispose);
+    }
+    /** Swap a live Member's tool policy at a turn boundary: dispose the old restriction, apply the new. */
+    reapplyMemberToolPolicy(member) {
+        this.releaseMemberToolPolicy(member.memberId);
+        this.applyMemberToolPolicy(this.deps.liveMemberContext(member.memberId), member);
+    }
+    /** Release one Member's restriction disposer and warning state; safe to call twice. */
+    releaseMemberToolPolicy(memberId) {
+        const dispose = this.memberRestrictions.get(memberId);
+        if (dispose !== undefined) {
+            this.memberRestrictions.delete(memberId);
+            dispose();
+        }
+        this.capabilityWarnings.delete(memberId);
+    }
+    setCapabilityWarnings(memberId, warnings) {
+        if (warnings.length === 0)
+            this.capabilityWarnings.delete(memberId);
+        else
+            this.capabilityWarnings.set(memberId, Object.freeze([...warnings]));
+    }
+    /**
+     * Wait until one live Member's current turn ends or its Session is
+     * disposed. While the Agent runs, the current turn keeps its schemas and
+     * catalog; the swap happens once idle, so the next step recomputes schemas
+     * from the new restriction and the durable replacement skill catalog from
+     * the new selection, with the same Session and history surviving.
+     * Suspend/remove during the wait resolves it — the disposed handle released
+     * the old restriction already and no disposer leaks. Returns whether any
+     * wait happened, so the caller can re-check the handle afterwards.
+     */
+    async awaitTurnBoundary(active) {
+        if (!this.deps.runningAgents.has(active.agent.id))
+            return false;
+        await new Promise(resolve => {
+            const disposers = [];
+            const settle = () => {
+                for (const dispose of disposers.splice(0))
+                    dispose();
+                resolve();
+            };
+            disposers.push(this.deps.ctx.on('agent/status', (payload) => {
+                if (payload.agent !== active.agent)
+                    return;
+                // A turn that ends — clean idle or error — is the boundary; the
+                // next step recomputes schemas from the new restriction.
+                if (payload.status !== 'running')
+                    settle();
+            }), 
+            // Disposal (suspend/remove/reactivation) resolves the wait: the old
+            // restriction went with the disposed scope, so only the ledger
+            // intent remains to apply at the next activation.
+            this.deps.ctx.on('session/disposed', (session) => {
+                if (session.id === active.agent.session.id)
+                    settle();
+            }));
+        });
+        return true;
+    }
+    /**
+     * Register the Member-private skill provider on the created agent's exact
+     * scope layer (the traceable-service seam, like the tool restriction):
+     * bundled read-only core skills plus this Member's own private directory,
+     * with the live selection ref that later capability edits swap in place.
+     */
+    mountMemberSkillProvider(member, agentCtx, selection) {
+        this.skillProviderDisposals.set(member.memberId, memberSkills.mountMemberSkillProvider(agentCtx, {
+            skillsDirectory: join(member.privateMemoryPath, 'skills'),
+            bundledSkillsDirectory: BUNDLED_SKILLS_DIRECTORY,
+            selection,
+        }));
+        this.skillSelections.set(member.memberId, selection);
+    }
+    /** Live-apply a capability edit to a registered selection; a no-op when none exists. */
+    swapSkillSelection(memberId, allow) {
+        this.skillSelections.get(memberId)?.swap(allow);
+    }
+    /**
+     * Provision one Member's private memory namespace: notes/, skills/, and a
+     * first-run memory.md scaffold. The Member-private skills directory starts
+     * empty; the per-Member provider scans exactly this root (default roots
+     * excluded).
+     */
+    async initializePrivateMemory(path) {
+        await mkdir(join(path, 'notes'), { recursive: true });
+        await mkdir(join(path, 'skills'), { recursive: true });
+        try {
+            await writeFile(join(path, 'memory.md'), '# Member memory\n\n## Stable facts\n- Add only verified, durable facts that help future work.\n\n## Notes index\n- Add focused `notes/*.md` entries here when a reusable detail needs on-demand reading.\n', { flag: 'wx' });
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+        }
+    }
+    /** Irreversibly remove one Member: archive its Session and delete its private namespace. */
+    async cleanupRemovedMember(member) {
+        const results = await Promise.allSettled([
+            this.deps.ctx.workspaceRegistry.archiveSession(member.sessionId),
+            rm(member.privateMemoryPath, { recursive: true, force: true }),
+        ]);
+        const failures = results.flatMap(result => result.status === 'rejected' ? [result.reason] : []);
+        if (failures.length > 0)
+            throw new AggregateError(failures, `failed to clean up removed Member '${member.memberId}'`);
+    }
+    /** Drop one Member's transient selection/disposer state after its handle is gone; safe to call twice. */
+    forgetMember(memberId) {
+        this.skillSelections.delete(memberId);
+        const providerDispose = this.skillProviderDisposals.get(memberId);
+        if (providerDispose !== undefined) {
+            this.skillProviderDisposals.delete(memberId);
+            providerDispose();
+        }
+        this.releaseMemberToolPolicy(memberId);
+    }
+    /** Dispose every registered per-Member seam; service shutdown only. */
+    disposeAll() {
+        this.skillSelections.clear();
+        for (const dispose of this.skillProviderDisposals.values())
+            dispose();
+        this.skillProviderDisposals.clear();
+        for (const dispose of this.memberRestrictions.values())
+            dispose();
+        this.memberRestrictions.clear();
+        this.capabilityWarnings.clear();
+    }
+}

package/packages/agent-team/lib/preset-roster.js

@@ -9,6 +9,7 @@ export function apply(ctx) {
     ctx.plugin(AgentPresets, {
         default: 'team-member',
         roots: [{ path: root, trust: 'system' }],
+        includeShippedRoot: false,
         includeUserRoot: false,
     });
 }

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

@@ -0,0 +1,320 @@
+/**
+ * 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';
+const PROGRESS_NUDGE_PLUGIN_ID = '@wowyuarm/dsh-agent-team';
+/** 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 === PROGRESS_NUDGE_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: PROGRESS_NUDGE_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 !== PROGRESS_NUDGE_PLUGIN_ID || 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/spec.js

@@ -57,7 +57,7 @@ const memberSchema = z.object({
     // Ledgers written before member capabilities existed omit the field.
     capabilities: memberCapabilitiesSchema.optional(),
     privateMemoryPath: z.string().min(1),
-    state: z.union([z.literal('enabled'), z.literal('suspended'), z.literal('inactive')]),
+    state: z.union([z.literal('enabled'), z.literal('suspended'), z.literal('inactive'), z.literal('archived')]),
 }).strict();
 const channelSchema = z.object({
     channelRef: channelRefSchema,
@@ -65,6 +65,8 @@ const channelSchema = z.object({
     name: z.string().min(1),
     description: z.string(),
     createdAtSequence: z.number().int().positive(),
+    // Ledgers written before Channel archival existed omit the field.
+    state: z.enum(['active', 'archived']).default('active'),
 }).strict();
 // Ledgers written before message occurredAt or attachments existed store bare
 // messages; the union schema below stamps occurredAt on load and leaves absent
@@ -246,6 +248,19 @@ const storedAgentTeamOperationSchema = z.discriminatedUnion('kind', [
         kind: z.literal('team/member-resumed'),
         data: z.object({ member: memberSchema }).strict(),
     }).strict(),
+    z.object({
+        ...operationBase,
+        previousOperationId: operationIdSchema.nullable(),
+        kind: z.literal('team/member-archived'),
+        data: z.object({
+            member: memberSchema,
+            claims: z.array(claimSchema),
+            activities: z.array(claimsReleasedActivitySchema),
+            tasks: z.array(taskSchema),
+            threads: z.array(threadSchema),
+            inbox: inboxDeltaSchema,
+        }).strict(),
+    }).strict(),
     z.object({
         ...operationBase,
         previousOperationId: operationIdSchema.nullable(),
@@ -297,6 +312,20 @@ const storedAgentTeamOperationSchema = z.discriminatedUnion('kind', [
             inbox: inboxDeltaSchema,
         }).strict(),
     }).strict(),
+    z.object({
+        ...operationBase,
+        previousOperationId: operationIdSchema.nullable(),
+        kind: z.literal('team/channel-archived'),
+        data: z.object({
+            workspaceId: workspaceIdSchema,
+            channel: channelSchema,
+            claims: z.array(claimSchema),
+            activities: z.array(claimsReleasedActivitySchema),
+            tasks: z.array(taskSchema),
+            threads: z.array(threadSchema),
+            inbox: inboxDeltaSchema,
+        }).strict(),
+    }).strict(),
     z.object({
         ...operationBase,
         previousOperationId: operationIdSchema.nullable(),