@wowyuarm/dsh-agent-team 0.1.9 → 0.1.10

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

@@ -39,58 +39,6 @@ var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn,
     if (target) Object.defineProperty(target, contextIn.name, descriptor);
     done = true;
 };
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
 import { randomUUID } from 'node:crypto';
 import { isDeepStrictEqual } from 'node:util';
 import { Service } from '@deepseek-ai/cordis';
@@ -98,25 +46,27 @@ import { installModelSelection } from '@deepseek-ai/dsh-agent';
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
 import { scopeOf } from '@deepseek-ai/dsh-scope';
-import { SessionId, SessionLogOffset } from '@deepseek-ai/dsh-session';
+import { Session, SessionId, SessionLogOffset } from '@deepseek-ai/dsh-session';
+import { SessionFormatUnsupportedError } from '@deepseek-ai/dsh-session-persistence';
 import { setSandboxMode } from '@deepseek-ai/dsh-sandbox-policy';
 import { Remote, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import { ATTACHMENT_MAX_BYTES, attachmentPayloadPath, attachmentsRoot, copyPathAttachment, newAttachmentId, readAttachment, sanitizeMediaType, sweepAttachmentCache, validatePathAttachment, writeAttachment } from "./attachments.js";
 import { PressurePolicyCoordinator } from "./pressure-policy.js";
 import { ContextManagementCoordinator } from "./context-management.js";
-import { createHandoffMessage } from "./context-source.js";
+import { AGENT_TEAM_PLUGIN_ID, createHandoffMessage } from "./context-source.js";
 import { carriedInputOf, checkpointByRef, checkpointRefFor, foldContextProjection, isReminderNoticeSummary, timelineCandidates } from "./context-projection.js";
 import { AGENT_TEAM_HUMAN_MEMBER_ID, AgentTeamLedger, agentTeamHumanActor } from "./ledger.js";
 import { AGENT_TEAM_TOOL_NAMES, deepCopyCapabilities, memberMemoryDirectoryName, MemberRuntime } from "./member-runtime.js";
 import { ProgressNudgeCoordinator } from "./progress-nudge.js";
 import { classifyRecoverableError, RecoveryCoordinator, RECOVERY_MAX_CONSECUTIVE_ERRORS } from "./recovery.js";
+import { SessionRemediation, handoffAlreadyInLog } from "./session-remediation.js";
 import { agentTeamDomainSpec } from "./spec.js";
+import { formatTeamTimestamp } from "./time-format.js";
 export { agentTeamDomainSpec, agentTeamOperationSchema } from "./spec.js";
 export { AGENT_TEAM_HUMAN_MEMBER_ID, AGENT_TEAM_INITIALIZE_REQUEST_ID } from "./ledger.js";
 export { AGENT_TEAM_TOOL_NAMES } from "./member-runtime.js";
 /** Process-stable marker carried by the final Team message tool definition. */
 export const AGENT_TEAM_PRESET_MARKER = Symbol.for('@wowyuarm/dsh-agent-team.preset');
-const AGENT_TEAM_PLUGIN_ID = '@wowyuarm/dsh-agent-team';
 const INBOX_NOTICE_SUMMARY = 'Team Inbox has unread work.';
 const RECOVERY_NOTICE_SUMMARY = 'Recovery: continue your interrupted work.';
 const ORPHANED_MEMBER_DIAGNOSTIC = 'Member preset composition was lost after a reload; its tools are unavailable. Resume rebuilds the member in place.';
@@ -152,6 +102,35 @@ export function markAgentTeamPreset(definition) {
     Object.defineProperty(definition, AGENT_TEAM_PRESET_MARKER, { value: true });
     return definition;
 }
+/**
+ * Whether the running dsh loads workspace packages from source via tsx.
+ *
+ * The Harness `tsconfig.base.json` maps `@deepseek-ai/*` package names onto
+ * `src/` directories; tsx honors those paths, so a CLI launched with
+ * `node --import tsx/esm apps/cli/src/bin.ts` imports `@deepseek-ai/dsh-scope`
+ * from `src/index.ts` while a profile-installed bundle resolves the compiled
+ * `lib/index.js` — two module instances with independent scope keys.
+ */
+export function isTsxDevMode() {
+    const flags = [...process.execArgv];
+    const nodeOptions = process.env.NODE_OPTIONS;
+    if (nodeOptions !== undefined)
+        flags.push(...nodeOptions.split(/\s+/));
+    return flags.some(flag => flag.includes('tsx'));
+}
+/**
+ * The activation diagnostic for a dsh-scope module-instance mismatch.
+ *
+ * `agentPresets.mount` already rejected an unscoped context, so a scope key
+ * the harness sees but this bundle does not can only mean the two sides
+ * loaded different physical copies of `@deepseek-ai/dsh-scope`.
+ */
+export function teamPresetScopeMismatchMessage(tsxDevMode) {
+    if (tsxDevMode) {
+        return 'selected preset is not team-enabled: the dsh CLI is running from source via tsx (tsconfig paths resolve @deepseek-ai/dsh-scope to src/), so the harness and this bundle load different module instances; start dsh with the compiled CLI instead (pnpm dsh, node apps/cli/lib/bin.js, or npx @deepseek-ai/dsh)';
+    }
+    return 'selected preset is not team-enabled: this bundle and the harness resolved different physical copies of @deepseek-ai/dsh-scope; run pnpm install in the profile directory so node_modules matches the lockfile, then restart';
+}
 /**
  * A DM was durably recorded but its session injection could not run (no live
  * handle, or the wake itself failed). The recorded DM stays durable; the
@@ -454,9 +433,20 @@ let AgentTeam = (() => {
             if (initialization.committed)
                 this.emitCommitted(initialization.value);
             this.startAttachmentGc(ledger);
+            // Legacy-artifact remediation runs before any Member activation: no write
+            // lease exists yet, so publishing sibling generations for refused Session
+            // logs cannot race a live writer. Remediation failure never blocks
+            // startup — the next start retries exactly what the cache does not cover.
+            try {
+                const remediation = new SessionRemediation(this.ctx, this.ctx.sessionPersistence, await SessionRemediation.open(this.ctx));
+                await remediation.remediateEnabledMembers(ledger.listMembers());
+            }
+            catch (error) {
+                this.ctx.logger.warn(`agent-team: legacy Session remediation did not run to completion (it will retry on the next start): ${error instanceof Error ? error.message : String(error)}`);
+            }
             // One metadata listing serves every Member restore; per-member list calls
             // would repeat the same I/O linearly during startup.
-            const persistedSessions = new Set((await this.persistedSessionHeaders()).map(header => header.id));
+            const persistedSessions = new Set((await this.persistedSessionHeaders()).map(snapshot => snapshot.header.id));
             for (const member of ledger.listMembers()) {
                 if (member.state === 'enabled')
                     await this.activateMember(member, undefined, persistedSessions);
@@ -466,20 +456,14 @@ let AgentTeam = (() => {
         }
         /**
          * Whether one Member Session has durable persisted content, decided through
-         * {@link SessionPersistenceService.inspect} rather than a bare metadata
-         * listing: inspection first awaits any in-flight retirement drain for the
-         * id, so a resume racing a suspend's fire-and-forget final flush cannot
-         * mistake a still-draining persisted Session for an unpersisted one and
-         * fork a fresh generation over it.
+         * {@link SessionPersistence.stat} rather than a bare metadata listing: the
+         * backend reports a still-draining session through its pending header, so a
+         * resume racing a suspend's fire-and-forget final flush cannot mistake a
+         * still-draining persisted Session for an unpersisted one and fork a fresh
+         * generation over it.
          */
         async sessionPersisted(sessionId) {
-            try {
-                await this.ctx.sessionPersistence.inspect(sessionId);
-                return true;
-            }
-            catch {
-                return false;
-            }
+            return (await this.ctx.sessionPersistence.stat(sessionId)) !== undefined;
         }
         /** Resolve one exact live Agent to its durable Team Member; forks do not inherit identity. */
         memberForAgent(agent) {
@@ -1240,7 +1224,7 @@ let AgentTeam = (() => {
             }
             try {
                 const message = createUserMessage({
-                    content: [{ type: 'text', text: this.dmRelayText(agent, recipient, request.body.trim(), result.value.receipt.operationId) }],
+                    content: [{ type: 'text', text: this.dmRelayText(agent, recipient, request.body.trim(), result.value.receipt.occurredAt, result.value.receipt.operationId) }],
                     source: { kind: 'plugin', plugin: AGENT_TEAM_PLUGIN_ID, form: 'relay' },
                 });
                 // An idle recipient gets one ordinary turn; a busy one is steered into
@@ -1256,10 +1240,10 @@ let AgentTeam = (() => {
             return result.value;
         }
         /** Relay body: the DM itself plus one bounded line of adjacent context. */
-        dmRelayText(senderAgent, recipient, body, excluding) {
+        dmRelayText(senderAgent, recipient, body, occurredAt, excluding) {
             const sender = this.memberForAgent(senderAgent);
             const prior = this.requireLedger().dmHistoryBetween(senderAgent.id, recipient.memberId, excluding);
-            const header = `Direct message from @${sender?.handle ?? 'a Team Member'}:`;
+            const header = `Direct message from @${sender?.handle ?? 'a Team Member'} at ${formatTeamTimestamp(occurredAt)}:`;
             const context = prior === undefined ? '' : `\n\n[most recent prior DM between you: ${prior}]`;
             return `${header}\n\n${body}${context}`;
         }
@@ -1379,10 +1363,15 @@ let AgentTeam = (() => {
                 }
                 else {
                     try {
-                        const inspection = await this.ctx.sessionPersistence.inspect(sessionId);
-                        events = inspection.events;
-                        inheritedEventCount = inspection.inheritedEventCount;
-                        parentSession = inspection.meta.parentSession;
+                        const handle = await this.ctx.sessionPersistence.open(sessionId, 'read');
+                        try {
+                            events = (await handle.read()).events;
+                            inheritedEventCount = handle.inheritedEventCount;
+                            parentSession = handle.header.parentSession;
+                        }
+                        finally {
+                            await handle.close();
+                        }
                     }
                     catch (error) {
                         throw new Error(`checkpoint '${checkpointRef}' could not be resolved: its source Session is unreadable (${error instanceof Error ? error.message : String(error)})`);
@@ -1465,8 +1454,13 @@ let AgentTeam = (() => {
                 return;
             let inspection;
             try {
-                const result = await this.ctx.sessionPersistence.inspect(previousSessionId);
-                inspection = result;
+                const handle = await this.ctx.sessionPersistence.open(previousSessionId, 'read');
+                try {
+                    inspection = { events: (await handle.read()).events, inheritedEventCount: handle.inheritedEventCount };
+                }
+                finally {
+                    await handle.close();
+                }
             }
             catch (error) {
                 this.ctx.logger.warn(`agent-team: rollover handoff reconstruction could not read the previous Session '${previousSessionId}': ${error instanceof Error ? error.message : String(error)}`);
@@ -1502,7 +1496,13 @@ let AgentTeam = (() => {
         async recordedCheckpointPrefix(seed) {
             let inspection;
             try {
-                inspection = await this.ctx.sessionPersistence.inspect(seed.sourceSessionId);
+                const handle = await this.ctx.sessionPersistence.open(seed.sourceSessionId, 'read');
+                try {
+                    inspection = { events: (await handle.read()).events, inheritedEventCount: handle.inheritedEventCount };
+                }
+                finally {
+                    await handle.close();
+                }
             }
             catch (error) {
                 throw new Error(`the recorded checkpoint-return seed source Session '${seed.sourceSessionId}' is unreadable: ${error instanceof Error ? error.message : String(error)}`);
@@ -1530,21 +1530,63 @@ let AgentTeam = (() => {
          * CURRENTLY present: delivered `user/message` ids plus the live inbox's
          * pending next-step/next-turn ids — a historical insert that was already
          * claimed (and removed) but never surfaced is NOT known and must replay.
-         * Fail-closed: an unreadable previous Session rejects the activation
-         * rather than silently dropping the Member's input.
+         * Fail-closed for genuinely unreadable previous Sessions (missing/IO) so
+         * the Member's input is never dropped silently, with three bounded
+         * exceptions: a generation that already started its own turns needs no
+         * replay (its carried input was delivered or superseded while it ran), a
+         * log-corruption class error skips with a warning (the Host repairs torn
+         * tails; a retired generation's corrupt log must not permanently block the
+         * Member's activation), and a deterministic released-format refusal skips
+         * with a warning (the candidate's own migration audit refuses that
+         * artifact, so no retry can ever read it).
          */
-        async replayCarriedInput(member, agent) {
+        async replayCarriedInput(member, agent, generationStarted) {
             const transition = this.requireLedger().lastTransitionForMember(member.memberId);
             if (transition === undefined || transition.targetSessionId !== agent.session.id)
                 return 0;
-            let inspection;
+            // A generation that already started its own turns needs no previous-Session
+            // replay: its carried input was delivered with the handoff (or superseded)
+            // before any own turn could run. Skipping the inspect also keeps a later
+            // corruption or loss of the retired Session from re-blocking this Member
+            // on every restart of the current generation.
+            if (generationStarted) {
+                this.ctx.logger.info(`agent-team: skipping carried-input replay for member '${this.memberLabel(member.memberId)}': the current Session '${agent.session.id}' already started a generation`);
+                return 0;
+            }
+            let inspectionEvents;
+            let inspectionInherited;
             try {
-                inspection = await this.ctx.sessionPersistence.inspect(transition.previousSessionId);
+                const handle = await this.ctx.sessionPersistence.open(transition.previousSessionId, 'read');
+                try {
+                    inspectionEvents = (await handle.read()).events;
+                    inspectionInherited = handle.inheritedEventCount;
+                }
+                finally {
+                    await handle.close();
+                }
             }
             catch (error) {
-                throw new Error(`the previous Session '${transition.previousSessionId}' holding the Member's carried input is unreadable: ${error instanceof Error ? error.message : String(error)}`);
+                const detail = error instanceof Error ? error.message : String(error);
+                // Log-corruption class: bounded fail-open. The current Session's own
+                // fold is intact and the Host repairs the retired log's torn tail; a
+                // corrupted retired generation must not permanently block activation.
+                if (/corrupt session log/.test(detail)) {
+                    this.ctx.logger.warn(`agent-team: previous Session '${transition.previousSessionId}' holding carried input for member '${this.memberLabel(member.memberId)}' is corrupt: ${detail}; skipping the replay`);
+                    return 0;
+                }
+                // Deterministic released-format refusal: the retired artifact is refused
+                // by the candidate's own migration audit, which no retry can change.
+                // Failing activation here would turn a data problem in a Session the
+                // Member no longer runs in into permanent unavailability — the exact
+                // failure class this hardening removes. Genuine IO and unknown failures
+                // stay fail-closed so carried input is never dropped silently.
+                if (error instanceof SessionFormatUnsupportedError) {
+                    this.ctx.logger.warn(`agent-team: previous Session '${transition.previousSessionId}' holding carried input for member '${this.memberLabel(member.memberId)}' is refused by the session-format migration: ${detail}; skipping the replay`);
+                    return 0;
+                }
+                throw new Error(`the previous Session '${transition.previousSessionId}' holding the Member's carried input is unreadable: ${detail}`);
             }
-            const state = foldContextProjection(inspection.events, inspection.inheritedEventCount, transition.previousSessionId);
+            const state = foldContextProjection(inspectionEvents, inspectionInherited, transition.previousSessionId);
             const carried = carriedInputOf(state);
             if (carried.length === 0)
                 return 0;
@@ -1635,11 +1677,17 @@ let AgentTeam = (() => {
                 }
                 else {
                     try {
-                        const inspection = await this.ctx.sessionPersistence.inspect(sessionId);
-                        state = foldContextProjection(inspection.events, inspection.inheritedEventCount, sessionId);
-                        sourceEvents = inspection.events;
-                        sourceSessionId = sessionId;
-                        sessionId = inspection.meta.parentSession;
+                        const handle = await this.ctx.sessionPersistence.open(sessionId, 'read');
+                        try {
+                            const { events } = await handle.read();
+                            state = foldContextProjection(events, handle.inheritedEventCount, sessionId);
+                            sourceEvents = events;
+                            sourceSessionId = sessionId;
+                            sessionId = handle.header.parentSession;
+                        }
+                        finally {
+                            await handle.close();
+                        }
                     }
                     catch {
                         // An unreadable ancestor ends the lineage walk here.
@@ -1682,29 +1730,17 @@ let AgentTeam = (() => {
             if (live)
                 return meter.measure(agent.session)?.totalTokens;
             try {
-                const env_1 = { stack: [], error: void 0, hasError: false };
+                // 0.1.5 removed borrowSession: rebuild a detached Session from the
+                // stored log so the seed's retained cost is priced by the SOURCE's own
+                // replay, never the current generation's.
+                const handle = await this.ctx.sessionPersistence.open(sessionId, 'read');
                 try {
-                    const borrowed = __addDisposableResource(env_1, await this.ctx.sessionPersistence.borrowSession(sessionId)
-                    // The borrow resolves the exact Session object for both shapes: the
-                    // live instance for an attached Session, the prepared one for an
-                    // archived ancestor. Measuring through the service context's store
-                    // would need an inject this service does not declare.
-                    , false);
-                    // The borrow resolves the exact Session object for both shapes: the
-                    // live instance for an attached Session, the prepared one for an
-                    // archived ancestor. Measuring through the service context's store
-                    // would need an inject this service does not declare.
-                    const session = borrowed.source === 'live'
-                        ? agent.session.id === sessionId ? agent.session : undefined
-                        : borrowed.preparedSession;
-                    return session === undefined ? undefined : meter.measure(session)?.totalTokens;
-                }
-                catch (e_1) {
-                    env_1.error = e_1;
-                    env_1.hasError = true;
+                    const { events } = await handle.read();
+                    const session = Session.create(sessionId, events, handle.header, handle.inheritedEventCount);
+                    return meter.measure(session)?.totalTokens;
                 }
                 finally {
-                    __disposeResources(env_1);
+                    await handle.close();
                 }
             }
             catch {
@@ -2060,7 +2096,7 @@ let AgentTeam = (() => {
                 // allow-list filters the catalog by name through the live ref below.
                 // `swap` is bound by the provider at activation (no-op until then).
                 const skillSelection = { current: member.capabilities?.skills?.allow, swap: () => { } };
-                const setup = async (agentCtx) => {
+                const setup = async (agentCtx, agent) => {
                     await this.ctx.agentPresets.mount(agentCtx, member.presetId);
                     this.memberRuntime.applyMemberToolPolicy(agentCtx, member);
                     this.validateMemberPreset(agentCtx);
@@ -2107,9 +2143,6 @@ let AgentTeam = (() => {
                     });
                     return {
                         commit: () => {
-                            const agent = agentCtx.agent;
-                            if (agent === undefined)
-                                throw new Error('agent-team setup has no unpublished Agent');
                             // The member scope composes no sandbox-policy service (the preset
                             // owns no sandbox row), so read the last logged mode straight from
                             // the session log; `sandbox/mode` is log-only and never joins the
@@ -2179,6 +2212,11 @@ let AgentTeam = (() => {
                 // The one-shot pressure notice needs no explicit re-arm here: it latches
                 // on durable Session evidence, and a fresh generation's own event span
                 // starts empty — a new Session is itself the re-arm.
+                // Snapshot whether this generation had already started its own turns
+                // BEFORE any recovery delivery below: the handoff steer and the Inbox
+                // wake legitimately append `turn/start` to this Session, and those must
+                // never be mistaken for the generation having run on its own.
+                const generationStarted = created.agent.session.ownEvents().some(event => event.type === 'turn/start');
                 // A restart between a durable rollover intent and its swap replays the
                 // old Session; the projection still carries the intent, so finish the
                 // transition (or keep waiting for the containing turn) from here.
@@ -2194,14 +2232,18 @@ let AgentTeam = (() => {
                     // delivered activates the new Session with no handoff in its own
                     // log — never treat that as an ordinary blank Member Session. The
                     // operation's recorded previous Session (the lineage parent) still
-                    // holds the intent; rebuild the handoff from it.
-                    if (!state.boundaries.some(boundary => boundary.source === 'handoff')) {
+                    // holds the intent; rebuild the handoff from it. "No handoff in its
+                    // own log" is judged over both shapes: a generation rescued from the
+                    // retired custom kinds carries its handoff as a source the projection
+                    // does not classify, and rebuilding on top of it would inject the same
+                    // handoff twice.
+                    if (!handoffAlreadyInLog(state.boundaries, created.agent.session.ownEvents())) {
                         await this.reconstructMissingHandoff(member, created.agent);
                     }
                     // Carried input redelivery binds to the committed transition target —
                     // this Session — never to the handoff's presence: a crash after the
                     // handoff landed but before the carried enqueue still replays here.
-                    recoveryCarried = await this.replayCarriedInput(member, created.agent);
+                    recoveryCarried = await this.replayCarriedInput(member, created.agent, generationStarted);
                 }
                 else if (forkedFrom === undefined && lineageParent !== undefined) {
                     // A restart recreated a Session that never materialized before the
@@ -2215,7 +2257,7 @@ let AgentTeam = (() => {
                     // handoff right after — that delivery is the plan, never this
                     // recovery.
                     await this.reconstructMissingHandoff(member, created.agent);
-                    recoveryCarried = await this.replayCarriedInput(member, created.agent);
+                    recoveryCarried = await this.replayCarriedInput(member, created.agent, generationStarted);
                 }
                 // The ordinary Inbox wake runs LAST, after any recovery delivery above:
                 // the handoff must stay the first model-facing context of a recovered
@@ -2232,7 +2274,9 @@ let AgentTeam = (() => {
                 await created?.dispose();
                 this.modelSelections.delete(member.memberId);
                 this.memberRuntime.forgetMember(member.memberId);
-                this.setMemberFailure(member.memberId, 'activation', error instanceof Error ? error.message : String(error));
+                const message = error instanceof Error ? error.message : String(error);
+                this.ctx.logger.warn(`agent-team: activation failed for member '${this.memberLabel(member.memberId)}': ${message}`);
+                this.setMemberFailure(member.memberId, 'activation', message);
             }
             finally {
                 // Activation only changes this Workspace's presence projection.
@@ -2292,6 +2336,12 @@ let AgentTeam = (() => {
             const scope = scopeOf(agentCtx);
             const teamMessage = this.ctx.tools.get('team_message', scope);
             if (teamMessage?.[AGENT_TEAM_PRESET_MARKER] !== true) {
+                // `agentPresets.mount` already rejected an unscoped context, so a scope
+                // key the harness sees but this bundle does not means the two sides
+                // loaded different module instances of @deepseek-ai/dsh-scope (the
+                // common trigger is running the CLI from source via tsx).
+                if (scope === undefined)
+                    throw new Error(teamPresetScopeMismatchMessage(isTsxDevMode()));
                 throw new Error('selected preset is not team-enabled');
             }
             const available = new Set(this.ctx.tools.schemas(scope).map(tool => tool.name));
@@ -2503,7 +2553,7 @@ let AgentTeam = (() => {
                     if (direct && fact.kind === 'message') {
                         const sender = fact.message.sender === AGENT_TEAM_HUMAN_MEMBER_ID
                             ? 'human' : this.requireLedger().getMember(fact.message.sender)?.handle ?? fact.message.sender;
-                        const detail = ['Direct Team mention', `From: ${sender}`, `Channel: ${item.channelRef}`,
+                        const detail = ['Direct Team mention', `Occurred at: ${formatTeamTimestamp(fact.occurredAt)}`, `From: ${sender}`, `Channel: ${item.channelRef}`,
                             ...(item.task === undefined ? [] : [`Task: ${item.task.taskRef}`]),
                             `Thread: ${item.thread.threadRef}`, `Message ref: ${fact.message.messageRef}`,
                             `Message: ${this.boundedNotificationBody(fact.message.body)}`].join('\n');
@@ -2511,15 +2561,15 @@ let AgentTeam = (() => {
                             detailedFactCount += 1;
                     }
                     else if (fact.kind === 'activity') {
-                        const detail = `${this.activityNotification(fact.activity, readerId)}\nThread: ${item.thread.threadRef}`;
+                        const detail = `${this.activityNotification(fact.activity, readerId)}\nOccurred at: ${formatTeamTimestamp(fact.occurredAt)}\nThread: ${item.thread.threadRef}`;
                         if (append(detail))
                             detailedFactCount += 1;
                     }
                 }
-                const ordinaryCount = facts.filter(entry => entry.fact.kind === 'message' && !entry.direct).length;
-                if (ordinaryCount > 0) {
+                const ordinary = facts.filter(entry => entry.fact.kind === 'message' && !entry.direct);
+                if (ordinary.length > 0) {
                     const route = item.task === undefined ? `Thread ${item.thread.threadRef}` : `Task ${item.task.taskRef}`;
-                    append(`${route}: ${ordinaryCount} unread update${ordinaryCount === 1 ? '' : 's'}.`);
+                    append(`${route}: ${ordinary.length} unread update${ordinary.length === 1 ? '' : 's'} · newest at ${formatTeamTimestamp(ordinary.at(-1).fact.occurredAt)}.`);
                 }
             }
             if (omitted)