@wowyuarm/dsh-agent-team 0.2.0 → 0.2.1

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

@@ -3780,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);
     }
@@ -3791,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-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/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;