@wowyuarm/dsh-agent-team 0.1.9 → 0.1.10

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

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { isDeepStrictEqual } from 'node:util';
+import { formatTeamTimestamp } from "./time-format.js";
 /** Stable Human Member identity shared by every replay of one dshHome Team. */
 export const AGENT_TEAM_HUMAN_MEMBER_ID = 'member:human';
 /** Idempotency identity of the one Host bootstrap operation. */
@@ -1009,7 +1010,7 @@ export class AgentTeamLedger {
             // mirror: the reader sent it to the other Member → (you → them).
             const direction = pair ? 'them → you' : 'you → them';
             const truncated = operation.data.body.length > 160 ? `${operation.data.body.slice(0, 160)}…` : operation.data.body;
-            return `(${direction}) ${truncated}`;
+            return `(${direction}, at ${formatTeamTimestamp(operation.occurredAt)}) ${truncated}`;
         }
         return undefined;
     }
@@ -1039,8 +1040,12 @@ export class AgentTeamLedger {
             const task = thread.taskRef === undefined ? undefined : this.state.tasks.get(thread.taskRef);
             const directCount = unread.filter(item => item.direct).length;
             const attention = this.attentionFor(authorized.memberId, thread.threadRef);
+            // Same snapshot, same source as newestSequence: the instant hangs off
+            // the newest unread fact itself, never a second lookup that could
+            // observe a different commit between the two reads.
+            const newest = unread.at(-1).fact;
             items.push(Object.freeze({ channelRef, ...(task === undefined ? {} : { task }), thread, unreadCount: unread.length, directCount,
-                newestSequence: unread.at(-1).fact.sequence, ...(attention === undefined ? {} : { attention }) }));
+                newestSequence: newest.sequence, newestOccurredAt: newest.occurredAt, ...(attention === undefined ? {} : { attention }) }));
         }
         items.sort((left, right) => right.directCount - left.directCount || right.newestSequence - left.newestSequence || left.thread.threadRef.localeCompare(right.thread.threadRef));
         const selected = items.slice(0, limit);
@@ -1235,8 +1240,10 @@ export class AgentTeamLedger {
             const message = fact.message;
             const thread = this.requireThread(message.threadRef);
             const task = thread.taskRef === undefined ? undefined : this.state.tasks.get(thread.taskRef);
+            const facts = this.state.factsByThread.get(thread.threadRef) ?? [];
             return Object.freeze({ message, mentions: fact.mentions, ...(task === undefined ? {} : { task, taskNumber: taskNumbers.get(task.taskRef) ?? 0 }), thread,
-                messageCount: this.state.messageCountByThread.get(thread.threadRef) ?? 0 });
+                messageCount: this.state.messageCountByThread.get(thread.threadRef) ?? 0,
+                lastActivityAt: facts.at(-1)?.occurredAt ?? '' });
         });
         const initialization = this.initialization();
         const nextCursor = selected.length === 0 ? cursor : direction === 'before' ? selected[0].sequence : selected.at(-1).sequence;
@@ -2153,7 +2160,7 @@ export class AgentTeamLedger {
             for (const claim of operation.data.claims)
                 target.claims.set(claim.claimRef, claim);
             for (const activity of operation.data.activities)
-                this.appendActivityFact(target, activity);
+                this.appendActivityFact(target, activity, operation.occurredAt);
             for (const task of operation.data.tasks)
                 target.tasks.set(task.taskRef, task);
             for (const thread of operation.data.threads)
@@ -2169,7 +2176,7 @@ export class AgentTeamLedger {
             for (const claim of operation.data.claims)
                 target.claims.set(claim.claimRef, claim);
             for (const activity of operation.data.activities)
-                this.appendActivityFact(target, activity);
+                this.appendActivityFact(target, activity, operation.occurredAt);
             for (const task of operation.data.tasks)
                 target.tasks.set(task.taskRef, task);
             for (const thread of operation.data.threads)
@@ -2184,7 +2191,7 @@ export class AgentTeamLedger {
             for (const claim of operation.data.claims)
                 target.claims.set(claim.claimRef, claim);
             for (const activity of operation.data.activities)
-                this.appendActivityFact(target, activity);
+                this.appendActivityFact(target, activity, operation.occurredAt);
             for (const task of operation.data.tasks)
                 target.tasks.set(task.taskRef, task);
             for (const thread of operation.data.threads)
@@ -2200,7 +2207,7 @@ export class AgentTeamLedger {
             for (const claim of operation.data.claims)
                 target.claims.set(claim.claimRef, claim);
             for (const activity of operation.data.activities)
-                this.appendActivityFact(target, activity);
+                this.appendActivityFact(target, activity, operation.occurredAt);
             for (const task of operation.data.tasks)
                 target.tasks.set(task.taskRef, task);
             for (const thread of operation.data.threads)
@@ -2209,7 +2216,7 @@ export class AgentTeamLedger {
             return;
         }
         if (operation.kind === 'team/thread-promoted') {
-            this.appendActivityFact(target, operation.data.activity);
+            this.appendActivityFact(target, operation.data.activity, operation.occurredAt);
             target.tasks.set(operation.data.task.taskRef, operation.data.task);
             target.threads.set(operation.data.thread.threadRef, operation.data.thread);
             this.applyInboxDelta(target, operation.data.inbox);
@@ -2219,7 +2226,7 @@ export class AgentTeamLedger {
             const { message, mentions } = operation.data;
             target.messages.push(message);
             target.mentionsByMessage.set(message.messageRef, Object.freeze([...mentions]));
-            this.appendMessageFact(target, message, mentions);
+            this.appendMessageFact(target, message, mentions, message.occurredAt ?? operation.occurredAt);
             if (operation.data.task !== undefined)
                 target.tasks.set(operation.data.task.taskRef, operation.data.task);
             target.threads.set(operation.data.thread.threadRef, operation.data.thread);
@@ -2230,7 +2237,7 @@ export class AgentTeamLedger {
         }
         if (operation.kind === 'team/claim-created' || operation.kind === 'team/claim-done' || operation.kind === 'team/claim-released') {
             target.claims.set(operation.data.claim.claimRef, operation.data.claim);
-            this.appendActivityFact(target, operation.data.activity);
+            this.appendActivityFact(target, operation.data.activity, operation.occurredAt);
             target.tasks.set(operation.data.task.taskRef, operation.data.task);
             target.threads.set(operation.data.thread.threadRef, operation.data.thread);
             this.applyInboxDelta(target, operation.data.inbox);
@@ -2239,7 +2246,7 @@ export class AgentTeamLedger {
         if (operation.kind === 'team/task-changed') {
             for (const claim of operation.data.claims)
                 target.claims.set(claim.claimRef, claim);
-            this.appendActivityFact(target, operation.data.activity);
+            this.appendActivityFact(target, operation.data.activity, operation.occurredAt);
             target.tasks.set(operation.data.task.taskRef, operation.data.task);
             target.threads.set(operation.data.thread.threadRef, operation.data.thread);
             this.applyInboxDelta(target, operation.data.inbox);
@@ -2257,16 +2264,16 @@ export class AgentTeamLedger {
         assertUnhandledKind(operation);
     }
     /** Facts arrive in ledger sequence order, so global and per-thread lists stay sorted by append only. */
-    appendMessageFact(target, message, mentions) {
-        const fact = Object.freeze({ kind: 'message', sequence: message.sequence, message, mentions });
+    appendMessageFact(target, message, mentions, occurredAt) {
+        const fact = Object.freeze({ kind: 'message', sequence: message.sequence, message, mentions, occurredAt });
         target.orderedFacts.push(fact);
         const facts = target.factsByThread.get(message.threadRef) ?? [];
         facts.push(fact);
         target.factsByThread.set(message.threadRef, facts);
         target.messageCountByThread.set(message.threadRef, (target.messageCountByThread.get(message.threadRef) ?? 0) + 1);
     }
-    appendActivityFact(target, activity) {
-        const fact = Object.freeze({ kind: 'activity', sequence: activity.sequence, activity });
+    appendActivityFact(target, activity, occurredAt) {
+        const fact = Object.freeze({ kind: 'activity', sequence: activity.sequence, activity, occurredAt });
         target.orderedFacts.push(fact);
         const facts = target.factsByThread.get(activity.threadRef) ?? [];
         facts.push(fact);
@@ -2318,7 +2325,8 @@ export class AgentTeamLedger {
         const background = firstRead
             ? projection.messages.filter(message => message.threadRef === thread.threadRef && message.sequence < attention.startSequence)
                 .map(message => Object.freeze({ kind: 'message', sequence: message.sequence, message,
-                mentions: projection.mentionsByMessage.get(message.messageRef) ?? [] }))
+                mentions: projection.mentionsByMessage.get(message.messageRef) ?? [],
+                occurredAt: this.occurredAtForFactFrom(projection, message.sequence, message.occurredAt) }))
                 .filter(fact => !unreadFactKeys.has(this.threadFactKey(fact))).slice(-12)
             : [];
         const combined = [...background.map(fact => this.readFactFrom(projection, memberId, fact, false)), ...unreadFacts]
@@ -2393,6 +2401,23 @@ export class AgentTeamLedger {
     threadFactsFrom(projection, threadRef) {
         return projection.factsByThread.get(threadRef) ?? [];
     }
+    /**
+     * The one per-fact instant projection: a fact's wall-clock time is the
+     * occurredAt of the ledger operation that committed it, looked up by
+     * sequence inside the same read snapshot. Every agent-facing surface
+     * (Thread facts, notifications, DM history, mutation results) resolves
+     * through this single path, never a second parallel lookup.
+     */
+    occurredAtForFactFrom(projection, sequence, fallback) {
+        if (fallback !== undefined)
+            return fallback;
+        // Facts arrive in ledger sequence order and `ordered` is append-only, so
+        // the entry at index sequence - 1 is the committing operation. The index
+        // read is guarded for hypothetical projections whose prefix has not yet
+        // caught up; those callers always pass an explicit fallback instead.
+        const operation = projection.ordered[sequence - 1];
+        return operation?.occurredAt ?? '';
+    }
     messageInboxDelta(message, sender, mentions, attention) {
         const markers = mentions.map(memberId => Object.freeze({ memberId, threadRef: message.threadRef,
             messageRef: message.messageRef, sequence: message.sequence }));
@@ -2454,18 +2479,24 @@ export class AgentTeamLedger {
         return this.inboxDelta([], [], [], [], markers);
     }
     removeMemberThreadInbox(memberId, threadRefs) {
-        const removed = [...this.state.attention.values()].filter(attention => attention.memberId === memberId && threadRefs.has(attention.threadRef))
+        return this.removeMemberThreadInboxFrom(this.state, memberId, threadRefs);
+    }
+    removeMemberThreadInboxFrom(projection, memberId, threadRefs) {
+        const removed = [...projection.attention.values()].filter(attention => attention.memberId === memberId && threadRefs.has(attention.threadRef))
             .map(attention => Object.freeze({ memberId, threadRef: attention.threadRef }));
-        const markers = [...this.state.directMarkers.values()].filter(marker => marker.memberId === memberId && threadRefs.has(marker.threadRef));
-        const activityMarkers = [...this.state.activityMarkers.values()].filter(marker => marker.memberId === memberId && threadRefs.has(marker.threadRef));
+        const markers = [...projection.directMarkers.values()].filter(marker => marker.memberId === memberId && threadRefs.has(marker.threadRef));
+        const activityMarkers = [...projection.activityMarkers.values()].filter(marker => marker.memberId === memberId && threadRefs.has(marker.threadRef));
         return this.inboxDelta([], removed, [], markers, [], activityMarkers);
     }
     /** Attention and marker cleanup for EVERY Member on the given Threads. */
     channelArchivalInbox(threadRefs) {
-        const removed = [...this.state.attention.values()].filter(attention => threadRefs.has(attention.threadRef))
+        return this.channelArchivalInboxFrom(this.state, threadRefs);
+    }
+    channelArchivalInboxFrom(projection, threadRefs) {
+        const removed = [...projection.attention.values()].filter(attention => threadRefs.has(attention.threadRef))
             .map(attention => Object.freeze({ memberId: attention.memberId, threadRef: attention.threadRef }));
-        const markers = [...this.state.directMarkers.values()].filter(marker => threadRefs.has(marker.threadRef));
-        const activityMarkers = [...this.state.activityMarkers.values()].filter(marker => threadRefs.has(marker.threadRef));
+        const markers = [...projection.directMarkers.values()].filter(marker => threadRefs.has(marker.threadRef));
+        const activityMarkers = [...projection.activityMarkers.values()].filter(marker => threadRefs.has(marker.threadRef));
         return this.inboxDelta([], removed, [], markers, [], activityMarkers);
     }
     inboxDelta(set = [], removed = [], addedMarkers = [], removedMarkers = [], addedActivityMarkers = [], removedActivityMarkers = []) {
@@ -2864,8 +2895,12 @@ export class AgentTeamLedger {
     isChannelMemberFrom(projection, channelRef, memberId) {
         return projection.memberships.get(channelRef)?.has(memberId) === true;
     }
+    /** Every Thread of the Channel, taskful or taskless — the scope both cleanup validators replay against. */
     channelThreadRefs(channelRef) {
-        return new Set([...this.state.tasks.values()].filter(task => task.channelRef === channelRef).map(task => task.threadRef));
+        return this.channelThreadRefsFrom(this.state, channelRef);
+    }
+    channelThreadRefsFrom(projection, channelRef) {
+        return new Set([...projection.threads.keys()].filter(threadRef => this.channelRefForThreadFrom(projection, threadRef) === channelRef));
     }
     assertJoinableMember(workspaceId, memberId) {
         const member = this.requireMember(memberId);
@@ -3187,7 +3222,7 @@ export class AgentTeamLedger {
             consumedDirectMarkers: operation.data.inbox.directMarkers.removed });
     }
     receipt(operation) {
-        return Object.freeze({ operationId: operation.operationId, requestId: operation.requestId, sequence: operation.sequence });
+        return Object.freeze({ operationId: operation.operationId, requestId: operation.requestId, sequence: operation.sequence, occurredAt: operation.occurredAt });
     }
     removalResult(operation) {
         return Object.freeze({ receipt: this.receipt(operation), member: operation.data.member,
@@ -3214,24 +3249,70 @@ export class AgentTeamLedger {
     sortedRecords() {
         const records = [...this.table.entries()].sort((left, right) => left[1].sequence - right[1].sequence);
         const occurrences = new Map();
+        const instants = new Map();
         for (const [, operation] of records) {
+            instants.set(operation.sequence, operation.occurredAt);
             if (operation.kind === 'team/message-sent' || operation.kind === 'team/thread-replied') {
                 occurrences.set(operation.data.message.messageRef, operation.data.message.occurredAt ?? operation.occurredAt);
             }
         }
-        return records.map(([id, operation]) => [id, this.normalizeOperation(operation, occurrences)]);
+        // Replay against a scratch projection while normalizing, so a legacy
+        // cleanup repair sees the same state its validator will.
+        const projection = emptyProjection();
+        return records.map(([id, operation]) => {
+            const normalized = this.repairLegacyChannelCleanup(this.normalizeOperation(operation, occurrences, instants), projection);
+            this.applyTo(projection, normalized);
+            return [id, normalized];
+        });
+    }
+    /**
+     * Releases up to 0.1.9 scoped Channel archival and Channel member-removal
+     * inbox cleanup to taskful Threads only (the collector read the Task
+     * projection), so archiving or member removal in a Channel holding a
+     * taskless Thread with Attention or markers wrote an incomplete inbox and
+     * every later load rejected the record, leaving the profile unable to boot.
+     * Records carrying exactly that legacy cleanup are repaired in memory the
+     * same way pre-envelope Thread reads are; any other inbox still fails
+     * validation, so a forgery is not silently accepted.
+     */
+    repairLegacyChannelCleanup(operation, projection) {
+        if (operation.kind === 'team/channel-archived') {
+            const channelRef = operation.data.channel.channelRef;
+            const expected = this.channelArchivalInboxFrom(projection, this.channelThreadRefsFrom(projection, channelRef));
+            if (!isDeepStrictEqual(operation.data.inbox, expected)
+                && isDeepStrictEqual(operation.data.inbox, this.channelArchivalInboxFrom(projection, this.legacyChannelThreadRefs(projection, channelRef)))) {
+                return { ...operation, data: { ...operation.data, inbox: expected } };
+            }
+            return operation;
+        }
+        if (operation.kind === 'team/channel-member-removed') {
+            const { channelRef, memberId } = operation.data;
+            const expected = this.removeMemberThreadInboxFrom(projection, memberId, this.channelThreadRefsFrom(projection, channelRef));
+            if (!isDeepStrictEqual(operation.data.inbox, expected)
+                && isDeepStrictEqual(operation.data.inbox, this.removeMemberThreadInboxFrom(projection, memberId, this.legacyChannelThreadRefs(projection, channelRef)))) {
+                return { ...operation, data: { ...operation.data, inbox: expected } };
+            }
+            return operation;
+        }
+        return operation;
+    }
+    /** The pre-fix Channel Thread scope: only Threads carrying a Task. */
+    legacyChannelThreadRefs(projection, channelRef) {
+        return new Set([...projection.tasks.values()].filter(task => task.channelRef === channelRef).map(task => task.threadRef));
     }
     /** Ledgers written before message occurredAt existed store bare messages; Thread reads resolve instants from the originating operations. */
-    normalizeOperation(operation, occurrences) {
+    normalizeOperation(operation, occurrences, instants) {
         if (operation.kind !== 'team/thread-read')
             return operation;
         const stamp = (message) => (message.occurredAt === undefined
             ? { ...message, occurredAt: occurrences.get(message.messageRef) ?? operation.occurredAt }
             : { ...message, occurredAt: message.occurredAt });
-        const facts = operation.data.facts.map((fact) => (fact.fact.kind === 'message'
-            ? { ...fact, fact: { kind: 'message', sequence: fact.fact.sequence, message: stamp(fact.fact.message),
-                    mentions: fact.fact.mentions } }
-            : { ...fact, fact: fact.fact }));
+        const stampEnvelope = (envelope) => envelope.kind === 'message'
+            ? { kind: 'message', sequence: envelope.sequence, message: stamp(envelope.message), mentions: envelope.mentions,
+                occurredAt: envelope.occurredAt ?? envelope.message.occurredAt ?? occurrences.get(envelope.message.messageRef) ?? operation.occurredAt }
+            : { kind: 'activity', sequence: envelope.sequence, activity: envelope.activity,
+                occurredAt: envelope.occurredAt ?? instants.get(envelope.sequence) ?? operation.occurredAt };
+        const facts = operation.data.facts.map((fact) => ({ ...fact, fact: stampEnvelope(fact.fact) }));
         return { ...operation, data: { ...operation.data, anchor: stamp(operation.data.anchor), facts } };
     }
     enqueue(operation) {

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

@@ -0,0 +1,126 @@
+/**
+ * Team Member turn-level clock context.
+ *
+ * The first model step of every eligible Team Member turn appends one
+ * durable, source-attributed clock snapshot: the current instant in the
+ * fixed Team coordination zone (UTC+8), the elapsed time since the
+ * preceding model-visible event, and the ordering authority note. Later
+ * steps of the same turn stay quiet unless the turn runs longer than the
+ * refresh interval, in which case one snapshot lands per elapsed interval —
+ * a tool-dense turn of quick steps produces exactly one line, while a turn
+ * that outlives the interval still shows its real span. The snapshot is an
+ * observation, never ledger authority: sequence and revision, not
+ * wall-clock time, order Team facts.
+ *
+ * This plugin deliberately does not mount the shipped
+ * `@deepseek-ai/dsh-time-context`: its browser-zone policy asks the model to
+ * confirm dates with the user whenever a request carries no unique browser
+ * zone, which is the normal case for background Member wakes (Inbox, DM,
+ * recovery, continuation). The Team coordination zone is fixed instead. If
+ * the harness grows a public non-browser/canonical-zone policy, retire this
+ * row in favor of configuring that plugin.
+ *
+ * State is folded from the Member Session's own events — the same
+ * manual-fold pattern the Host's context projection uses — so restart,
+ * request reconstruction, and compaction all derive identical baselines
+ * without a second durable store.
+ * @module @wowyuarm/dsh-agent-team/member-time-context
+ */
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { formatTeamDuration, formatTeamTimestamp } from "./time-format.js";
+export const name = 'wowyuarm-agent-team-member-time-context';
+/** Default minimum spacing between two snapshots within one turn, in ms. */
+export const CLOCK_REFRESH_INTERVAL_MS = 1_800_000;
+function emptyBaseline() {
+    return { lastMessageTime: null, lastInjectionTime: null, lastTurnInjectionTime: null, openTurn: -1 };
+}
+/**
+ * Fold one session event into the clock baseline. Uninterested events return
+ * the same state reference.
+ * @internal exported for tests.
+ */
+export function applyClockEvent(state, event) {
+    switch (event.type) {
+        case 'turn/start':
+            return event.data.turn === state.openTurn ? state
+                : { ...state, lastTurnInjectionTime: null, openTurn: event.data.turn };
+        case 'turn/end':
+            return state.openTurn === -1 ? state : { ...state, lastTurnInjectionTime: null, openTurn: -1 };
+        case 'user/message': {
+            const source = event.data.source;
+            const injected = source.kind === 'plugin' && source.plugin === name;
+            const withMessage = state.lastMessageTime === event.time ? state : { ...state, lastMessageTime: event.time };
+            if (!injected)
+                return withMessage;
+            return { ...withMessage, lastInjectionTime: event.time, lastTurnInjectionTime: event.time };
+        }
+        case 'assistant/message':
+        case 'tool/result':
+            return state.lastMessageTime === event.time ? state : { ...state, lastMessageTime: event.time };
+        default:
+            return state;
+    }
+}
+/** Fold a whole event log into the clock baseline. @internal exported for tests. */
+export function foldClockBaseline(events) {
+    let state = emptyBaseline();
+    for (const event of events)
+        state = applyClockEvent(state, event);
+    return state;
+}
+/**
+ * Whether this step should append a clock snapshot: the first step of a turn
+ * always does (every wake starts with a fresh instant), and a later step
+ * does only when the turn has run longer than the refresh interval since
+ * the last landed snapshot. Skipped steps produce nothing and never
+ * backfill — their span folds into the next snapshot's elapsed.
+ * @internal exported for tests.
+ */
+export function shouldSampleClock(step, now, baseline, refreshIntervalMs) {
+    if (step === 1)
+        return true;
+    return baseline.lastTurnInjectionTime === null || now - baseline.lastTurnInjectionTime >= refreshIntervalMs;
+}
+/** Render one durable clock snapshot text. @internal exported for tests. */
+export function renderClockSnapshot(input) {
+    // A wall-clock rollback clamps elapsed to 0s without rewriting history.
+    const elapsed = input.previous === undefined ? 'unavailable' : formatTeamDuration(input.now - input.previous);
+    const baseline = input.step === 1 ? 'model-visible event' : 'step context';
+    return `Team clock sampled while preparing turn ${input.turn}, step ${input.step}: ${formatTeamTimestamp(new Date(input.now).toISOString())}\n`
+        + `Elapsed since the preceding ${baseline}: ${elapsed}.\n`
+        + 'Team collaboration timestamps use UTC+8. Sequence and revision, not wall-clock time, determine ordering and concurrency.';
+}
+export function apply(ctx, config = {}) {
+    const refreshIntervalMs = config.refreshIntervalMs ?? CLOCK_REFRESH_INTERVAL_MS;
+    ctx.on('agent/pre-step', async ({ agent, turn, step, signal }, next) => {
+        const decision = await next();
+        if (decision.kind === 'reject' || signal.aborted)
+            return decision;
+        // The Host service is resolved at step time, never through plugin inject
+        // (same reason as member-context: the row mounts while the Host itself
+        // is still restoring Members).
+        const host = ctx.get('agentTeam');
+        if (host === undefined)
+            return decision;
+        if (host.memberForAgent(agent) === undefined)
+            return decision;
+        const now = Date.now();
+        // A rollover starts a fresh Session log, so the fold never guesses
+        // elapsed across generations: a missing prior event renders
+        // `unavailable`, not a fabricated baseline.
+        const baseline = foldClockBaseline(agent.session.ownEvents());
+        // Turn-first-step always samples; later steps sample only at the refresh
+        // interval, so a quick tool-dense turn stays at one line.
+        if (!shouldSampleClock(step, now, baseline, refreshIntervalMs))
+            return decision;
+        const previous = step === 1
+            ? baseline.lastMessageTime ?? undefined
+            : baseline.lastTurnInjectionTime ?? undefined;
+        const text = renderClockSnapshot({ now, turn, step, previous });
+        const message = createUserMessage({
+            content: [{ type: 'text', text }],
+            source: { kind: 'plugin', plugin: name, form: 'snapshot', sections: [{ name, text }] },
+        });
+        return { kind: 'enter', messages: [...decision.messages, message] };
+    }, { prepend: true });
+}

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

@@ -17,8 +17,7 @@
 import { CONTEXT_WINDOW_EXCEEDED_CODE } from '@deepseek-ai/dsh-llm';
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { CONTEXT_PRESSURE_NOTICE_SUMMARY } from "./context-management.js";
-/** Plugin identity of the Agent Team Host, for the notice source. */
-const AGENT_TEAM_PLUGIN_ID = '@wowyuarm/dsh-agent-team';
+import { AGENT_TEAM_PLUGIN_ID } from "./context-source.js";
 /** One pressure-notice text; concise, structured, and inside the reserve. */
 export function contextPressureNoticeText(input) {
     const claims = input.activeClaims.length === 0 ? 'none' : input.activeClaims.join(', ');

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

@@ -22,7 +22,7 @@
  * @module @wowyuarm/dsh-agent-team/progress-nudge
  */
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
-const PROGRESS_NUDGE_PLUGIN_ID = '@wowyuarm/dsh-agent-team';
+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;
@@ -39,7 +39,7 @@ export function isPublicCommunicationOperationKind(kind) {
 /** 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
+    return source.kind === 'plugin' && source.plugin === AGENT_TEAM_PLUGIN_ID
         && source.form === 'notice' && source.summary === PROGRESS_NUDGE_NOTICE_SUMMARY;
 }
 /**
@@ -218,7 +218,7 @@ export class ProgressNudgeCoordinator {
         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 },
+            source: { kind: 'plugin', plugin: AGENT_TEAM_PLUGIN_ID, form: 'notice', summary: PROGRESS_NUDGE_NOTICE_SUMMARY },
         });
         const pending = {
             messageId: notice.id,
@@ -268,7 +268,15 @@ export class ProgressNudgeCoordinator {
     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')
+            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;