@wowyuarm/dsh-agent-team 0.1.15 → 0.2.1

package/packages/agent-team/lib/installed-manifest.js

@@ -0,0 +1,32 @@
+/** The installed bundle's own manifest, read once for both facts taken from it. */
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/**
+ * Parsed manifest of the installed bundle, or `undefined` when it cannot be
+ * read.
+ *
+ * Three levels up: `packages/agent-team/{src,lib}` sits that deep in both a
+ * `link:` checkout and a registry tarball, so a development install and a
+ * published one each state their own truth. An unreadable or malformed manifest
+ * is a broken install, not a failure of whatever asked: every caller degrades to
+ * `'unknown'` or withholds the line it would have stated, so reading this can
+ * never fail the Host boot.
+ */
+export function readInstalledManifest() {
+    try {
+        const manifestPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../../package.json');
+        const parsed = JSON.parse(readFileSync(manifestPath, 'utf8'));
+        return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Version of the manifest this package installed from, or `'unknown'`. */
+export function bundleVersionOf(manifest) {
+    const version = manifest?.version;
+    return typeof version === 'string' && version !== '' ? version : 'unknown';
+}

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

@@ -2,9 +2,39 @@
 const PACKAGE_NAME = '@wowyuarm/dsh-agent-team';
 /** Cordis companion plugin name. */
 export const name = 'agent-team-invariant';
-/** Services required before the companion can validate Team state. */
-export const inject = ['invariants'];
-const install = Object.assign(async (ctx, fail) => {
+/**
+ * Services required before the companion can validate Team state. The check
+ * is self-hosted in this plugin's own fiber — companions used to register
+ * into `@deepseek-ai/dsh-invariants`, which the Harness line after `rc.2`
+ * removes wholesale.
+ */
+export const inject = ['agentTeam'];
+/**
+ * A violated Team ledger invariant, raised on the frame that triggered the
+ * check: boot when the mount replay fails, the committing call while a
+ * divergence is latched. The Host's post-commit boundary recognizes this class
+ * and re-raises it instead of degrading it to a log line.
+ */
+export class AgentTeamInvariantError extends Error {
+    /** Stable failure code, carried over from the removed upstream error class. */
+    code = 'INVARIANT';
+    /** Full npm package name that owns the violated invariant. */
+    packageName = PACKAGE_NAME;
+    /**
+     * Construct a Team invariant failure.
+     * @param message - violated contract, without the standard error prefix.
+     */
+    constructor(message) {
+        super(`invariant violated by "${PACKAGE_NAME}": ${message}`);
+        this.name = 'AgentTeamInvariantError';
+    }
+}
+/**
+ * Validate Team state at mount and keep validating it after every commit.
+ * @param ctx - Cordis context carrying the Agent Team service.
+ * @returns nothing; listeners and the pending check ride the plugin fiber.
+ */
+export const apply = (ctx) => {
     const divergence = (error) => `durable ledger and Team projection diverged: ${String(error)}`;
     // Mounting stays synchronous: a durable ledger that cannot be re-derived
     // must fail startup instead of racing the first commit. The mount adopts
@@ -15,7 +45,7 @@ const install = Object.assign(async (ctx, fail) => {
         ctx.agentTeam.validateLedgerAtMount();
     }
     catch (error) {
-        fail(divergence(error));
+        throw new AgentTeamInvariantError(divergence(error));
     }
     // The commit path cannot pay a full replay before its Remote response
     // returns, and opening a Thread commits. The replay stays the same full one
@@ -47,12 +77,6 @@ const install = Object.assign(async (ctx, fail) => {
         if (pending === undefined)
             pending = setImmediate(check);
         if (latched !== undefined)
-            fail(latched);
+            throw new AgentTeamInvariantError(latched);
     });
-}, { inject: ['agentTeam'] });
-/**
- * Register the Agent Team ledger invariant.
- * @param ctx - Cordis context carrying the invariant registry.
- * @returns the installed registration disposer after setup succeeds.
- */
-export const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+};

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

@@ -1586,6 +1586,7 @@ export class AgentTeamLedger {
             })),
             taskNumbers: Object.freeze(visibleTasks.map(task => Object.freeze({ taskRef: task.taskRef, taskNumber: taskNumbers.get(task.taskRef) ?? 0 }))),
             items: Object.freeze(items),
+            activeTaskThreads: this.activeTaskThreads(visibleTasks, taskNumbers),
             claims: this.claimsForVisibleTasks(visibleTasks),
             activities: Object.freeze(selected.filter((fact) => fact.kind === 'activity').map(fact => fact.activity)),
             cursor: nextCursor,
@@ -3172,6 +3173,40 @@ export class AgentTeamLedger {
         const refs = new Set(tasks.map(task => task.taskRef));
         return Object.freeze([...this.state.claims.values()].filter(claim => refs.has(claim.taskRef)));
     }
+    /**
+     * The team_view「活跃 task thread」radar for a Workspace: every visible Task
+     * still in flight — in_progress or in_review, the two states a live Claim
+     * keeps a Task in — newest activity first. Unlike `recentInboxItems`, this is
+     * not a participation slice: admission is the Task being active in a Channel
+     * the reader can see, whether or not the reader wrote in it, and a Thread
+     * still holding the reader's unread is not excluded. Rows carry the same
+     * `liveClaimOwners`口径 the Inbox and Channel feed already use, so 「谁在这个
+     * Task 上」 never gains a second definition. Archived Channels are already
+     * absent from `visibleTasks`, so their Tasks never reach here.
+     */
+    activeTaskThreads(visibleTasks, taskNumbers) {
+        const rows = [];
+        for (const task of visibleTasks) {
+            if (task.status !== 'in_progress' && task.status !== 'in_review')
+                continue;
+            const thread = this.state.threads.get(task.threadRef);
+            if (thread === undefined)
+                continue;
+            const newest = (this.state.factsByThread.get(thread.threadRef) ?? []).at(-1);
+            if (newest === undefined)
+                continue;
+            const taskNumber = taskNumbers.get(task.taskRef);
+            rows.push({
+                row: Object.freeze({ taskRef: task.taskRef, threadRef: thread.threadRef, channelRef: task.channelRef,
+                    ...(taskNumber === undefined ? {} : { taskNumber }), status: task.status,
+                    subject: boundedInboxPreview(this.threadAnchor(thread.threadRef).body),
+                    members: this.liveClaimOwners(task), lastActivityAt: newest.occurredAt }),
+                sequence: newest.sequence,
+            });
+        }
+        rows.sort((left, right) => right.sequence - left.sequence || left.row.threadRef.localeCompare(right.row.threadRef));
+        return Object.freeze(rows.map(entry => entry.row));
+    }
     tasksForClaims(claims, projected) {
         return Object.freeze([...new Set(claims.map(claim => claim.taskRef))].map(taskRef => {
             const task = this.state.tasks.get(taskRef);
@@ -3745,7 +3780,7 @@ export class AgentTeamLedger {
         if (operation.kind !== 'team/message-sent' || !this.sameActor(operation.actor, request.actor)
             || operation.data.workspaceId !== request.workspaceId || operation.data.message.channelRef !== request.channelRef
             || operation.data.message.body !== request.body.trim() || !this.sameList(operation.data.mentions, recipients)
-            || !this.sameList(operation.data.message.attachments?.map(attachment => attachment.attachmentId) ?? [], request.attachments ?? [])
+            || !this.sameList(operation.data.message.attachments?.map(attachment => attachment.attachmentId) ?? [], request.resolvedAttachments?.map(attachment => attachment.attachmentId) ?? [])
             || (request.asTask !== false) !== (operation.data.task !== undefined))
             this.throwRequestCollision(request.requestId);
     }
@@ -3756,6 +3791,7 @@ export class AgentTeamLedger {
             || (request.taskRef !== undefined && operation.data.task?.taskRef !== request.taskRef)
             || (request.threadRef === undefined && request.taskRef === undefined)
             || operation.data.message.body !== request.body.trim() || operation.data.baseRevision !== request.baseRevision
+            || !this.sameList(operation.data.message.attachments?.map(attachment => attachment.attachmentId) ?? [], request.resolvedAttachments?.map(attachment => attachment.attachmentId) ?? [])
             || !this.sameList(operation.data.mentions, recipients))
             this.throwRequestCollision(request.requestId);
     }

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

@@ -2,7 +2,7 @@ import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { SessionLogOffset } from '@deepseek-ai/dsh-session';
-import { v3RenamedSourceKind } from "./context-source.js";
+import { matchesProducerKind } from "./context-source.js";
 import { memberMemoryDirectoryPath } from "./member-runtime.js";
 export const name = 'wowyuarm-agent-team-member-context';
 const MAX_MEMORY_BYTES = 16 * 1024;
@@ -43,9 +43,7 @@ export function apply(ctx) {
             // 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'
-                // Both identities are this producer's own: the kind written now and
-                // the read-time conversion's rename of this producer's V3 history.
-                && (event.data.source.kind === name || event.data.source.kind === v3RenamedSourceKind(name))
+                && matchesProducerKind(event.data.source.kind, name)
                 && event.data.content[0]?.type === 'text'
                 ? [event.data.content[0].text]
                 : [];

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

@@ -35,7 +35,8 @@ export const AGENT_TEAM_TOOL_NAMES = Object.freeze([
     'team_view',
     'context_rollover',
     'context_checkpoint',
-    'context_timeline',
+    'context_status',
+    'context_compact',
 ]);
 /** Copy a Remote-supplied capability overlay into owned frozen storage. */
 export function deepCopyCapabilities(capabilities) {

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

@@ -27,7 +27,7 @@
  * @module @wowyuarm/dsh-agent-team/member-time-context
  */
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
-import { v3RenamedSourceKind } from "./context-source.js";
+import { matchesProducerKind } from "./context-source.js";
 import { formatTeamDuration, formatTeamTimestamp } from "./time-format.js";
 import { advanceOwnedSessionEventCursor } from "./session-event-cursor.js";
 export const name = 'wowyuarm-agent-team-member-time-context';
@@ -50,9 +50,7 @@ export function applyClockEvent(state, event) {
             return state.openTurn === -1 ? state : { ...state, lastTurnInjectionTime: null, openTurn: -1 };
         case 'user/message': {
             const source = event.data.source;
-            // Both identities are this producer's own: the kind written now and the
-            // read-time conversion's rename of this producer's V3 history.
-            const injected = source.kind === name || source.kind === v3RenamedSourceKind(name);
+            const injected = matchesProducerKind(source.kind, name);
             const withMessage = state.lastMessageTime === event.time ? state : { ...state, lastMessageTime: event.time };
             if (!injected)
                 return withMessage;

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

@@ -1,6 +1,55 @@
 const TRANSIENT_NETWORK_PATTERNS = [/fetch failed/i, /econnreset/i, /etimedout/i, /socket hang up/i];
 const RATE_LIMIT_PATTERNS = [/\b429\b/, /rate limit/i, /\b503\b/, /overloaded/i];
-export function classifyRecoverableError(message) {
+/**
+ * Read the stable code/status off any Harness-shaped failure without trusting
+ * class identity: a cross-package copy of `dsh-llm` preserves own data but
+ * not `instanceof`, so the own fields are the contract.
+ */
+function structuredFailure(error) {
+    if (typeof error !== 'object' || error === null)
+        return {};
+    const root = error;
+    const failure = typeof root.failure === 'object' && root.failure !== null
+        ? root.failure
+        : undefined;
+    const code = typeof failure?.code === 'string' && failure.code.length > 0 ? failure.code
+        : typeof root.code === 'string' && root.code.length > 0 ? root.code : undefined;
+    if (code === undefined)
+        return {};
+    const status = typeof failure?.status === 'number' && Number.isInteger(failure.status) ? failure.status
+        : typeof root.status === 'number' && Number.isInteger(root.status) ? root.status : undefined;
+    return { code, ...status === undefined ? {} : { status } };
+}
+/** The readable message of an arbitrary thrown value. */
+function failureMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === 'object' && error !== null) {
+        const message = error.message;
+        if (typeof message === 'string' && message.length > 0)
+            return message;
+    }
+    return String(error);
+}
+/**
+ * Classify one `agent/error` occurrence. Structured data outranks wording: a
+ * Harness code decides alone (a message can never upgrade a terminal failure
+ * back to recoverable), and the narrow message signatures run only when no
+ * usable code exists at all — `UNKNOWN` means the Harness folded a foreign
+ * error whose own taxonomy Team must not trust.
+ */
+export function classifyRecoverableError(error) {
+    const { code, status } = structuredFailure(error);
+    if (code !== undefined && code !== 'UNKNOWN') {
+        if (code === 'RATE_LIMIT')
+            return 'rate limiting';
+        if (code === 'TRANSPORT' || code === 'TIMEOUT')
+            return 'transient network';
+        if (status === 429 || status === 503)
+            return 'rate limiting';
+        return undefined;
+    }
+    const message = failureMessage(error);
     if (RATE_LIMIT_PATTERNS.some(pattern => pattern.test(message)))
         return 'rate limiting';
     if (TRANSIENT_NETWORK_PATTERNS.some(pattern => pattern.test(message)))
@@ -26,9 +75,9 @@ export class RecoveryCoordinator {
         this.delayMs = options.delayMs ?? RECOVERY_DELAY_MS;
         this.maxConsecutiveErrors = options.maxConsecutiveErrors ?? RECOVERY_MAX_CONSECUTIVE_ERRORS;
     }
-    /** Observe one `agent/error` occurrence for a Member. */
-    onError(memberId, errorMessage) {
-        if (classifyRecoverableError(errorMessage) === undefined) {
+    /** Observe one `agent/error` occurrence for a Member; `error` is the raw event payload. */
+    onError(memberId, error) {
+        if (classifyRecoverableError(error) === undefined) {
             // A non-recoverable failure cancels anything pending: retrying cannot help.
             this.stopTracking(memberId);
             return;