@songtonyli/dsh-cli 0.1.12 → 0.1.14

package/node_modules/@deepseek-ai/dsh-experimental-agent-team/lib/typert.remote-client.js

@@ -0,0 +1,218 @@
+/* Generated by @deepseek-ai/dsh-typert-generator from the Host FaceModel — do not edit. */
+import { z } from 'zod'
+
+let _deepseek_ai_dsh_experimental_agent_team_agentTeams_createTask_parameter_0$schema$value
+const _deepseek_ai_dsh_experimental_agent_team_agentTeams_createTask_parameter_0$schema = () => (_deepseek_ai_dsh_experimental_agent_team_agentTeams_createTask_parameter_0$schema$value ??= z.intersection(z.string(), z.unknown()))
+let _deepseek_ai_dsh_experimental_agent_team_agentTeams_createTask_parameter_1$schema$value
+const _deepseek_ai_dsh_experimental_agent_team_agentTeams_createTask_parameter_1$schema = () => (_deepseek_ai_dsh_experimental_agent_team_agentTeams_createTask_parameter_1$schema$value ??= z.object({
+  'subject': z.string().readonly(),
+  'description': z.string().readonly(),
+  'blockedBy': z.array(z.intersection(z.string(), z.unknown())).readonly().optional(),
+  'writeScopes': z.array(z.string()).readonly().optional(),
+}))
+let _deepseek_ai_dsh_experimental_agent_team_agentTeams_createTask_result$schema$value
+const _deepseek_ai_dsh_experimental_agent_team_agentTeams_createTask_result$schema = () => (_deepseek_ai_dsh_experimental_agent_team_agentTeams_createTask_result$schema$value ??= z.union([z.object({
+  'ok': z.literal(true).readonly(),
+  'value': z.object({
+  'id': z.intersection(z.string(), z.unknown()).readonly(),
+  'revision': z.number().readonly(),
+  'subject': z.string().readonly(),
+  'description': z.string().readonly(),
+  'status': z.union([z.literal("pending"), z.literal("in_progress"), z.literal("completed"), z.literal("deleted")]).readonly(),
+  'blockedBy': z.array(z.intersection(z.string(), z.unknown())).readonly(),
+  'writeScopes': z.array(z.string()).readonly(),
+  'ownerName': z.string().readonly().optional(),
+  'ready': z.boolean().readonly(),
+  'writeScopeWarnings': z.array(z.string()).readonly(),
+}).readonly(),
+}), z.object({
+  'ok': z.literal(false).readonly(),
+  'error': z.object({
+  'code': z.union([z.literal("team-task-conflict"), z.literal("team-rejected")]).readonly(),
+  'message': z.string().readonly(),
+}).readonly(),
+})]))
+let _deepseek_ai_dsh_experimental_agent_team_agentTeams_updateTask_parameter_0$schema$value
+const _deepseek_ai_dsh_experimental_agent_team_agentTeams_updateTask_parameter_0$schema = () => (_deepseek_ai_dsh_experimental_agent_team_agentTeams_updateTask_parameter_0$schema$value ??= z.intersection(z.string(), z.unknown()))
+let _deepseek_ai_dsh_experimental_agent_team_agentTeams_updateTask_parameter_1$schema$value
+const _deepseek_ai_dsh_experimental_agent_team_agentTeams_updateTask_parameter_1$schema = () => (_deepseek_ai_dsh_experimental_agent_team_agentTeams_updateTask_parameter_1$schema$value ??= z.object({
+  'taskId': z.intersection(z.string(), z.unknown()).readonly(),
+  'expectedRevision': z.number().readonly(),
+  'action': z.union([z.literal("complete"), z.literal("edit"), z.literal("claim"), z.literal("release"), z.literal("set_dependencies"), z.literal("reopen"), z.literal("reassign"), z.literal("delete")]).readonly(),
+  'subject': z.string().readonly().optional(),
+  'description': z.string().readonly().optional(),
+  'blockedBy': z.array(z.intersection(z.string(), z.unknown())).readonly().optional(),
+  'writeScopes': z.array(z.string()).readonly().optional(),
+  'owner': z.string().readonly().optional(),
+}))
+let _deepseek_ai_dsh_experimental_agent_team_agentTeams_updateTask_result$schema$value
+const _deepseek_ai_dsh_experimental_agent_team_agentTeams_updateTask_result$schema = () => (_deepseek_ai_dsh_experimental_agent_team_agentTeams_updateTask_result$schema$value ??= z.union([z.object({
+  'ok': z.literal(true).readonly(),
+  'value': z.object({
+  'id': z.intersection(z.string(), z.unknown()).readonly(),
+  'revision': z.number().readonly(),
+  'subject': z.string().readonly(),
+  'description': z.string().readonly(),
+  'status': z.union([z.literal("pending"), z.literal("in_progress"), z.literal("completed"), z.literal("deleted")]).readonly(),
+  'blockedBy': z.array(z.intersection(z.string(), z.unknown())).readonly(),
+  'writeScopes': z.array(z.string()).readonly(),
+  'ownerName': z.string().readonly().optional(),
+  'ready': z.boolean().readonly(),
+  'writeScopeWarnings': z.array(z.string()).readonly(),
+}).readonly(),
+}), z.object({
+  'ok': z.literal(false).readonly(),
+  'error': z.object({
+  'code': z.union([z.literal("team-task-conflict"), z.literal("team-rejected")]).readonly(),
+  'message': z.string().readonly(),
+}).readonly(),
+})]))
+let _deepseek_ai_dsh_experimental_agent_team_agentTeams_view_parameter_0$schema$value
+const _deepseek_ai_dsh_experimental_agent_team_agentTeams_view_parameter_0$schema = () => (_deepseek_ai_dsh_experimental_agent_team_agentTeams_view_parameter_0$schema$value ??= z.intersection(z.string(), z.unknown()))
+let _deepseek_ai_dsh_experimental_agent_team_agentTeams_view_result$schema$value
+const _deepseek_ai_dsh_experimental_agent_team_agentTeams_view_result$schema = () => (_deepseek_ai_dsh_experimental_agent_team_agentTeams_view_result$schema$value ??= z.object({
+  'members': z.array(z.object({
+  'id': z.intersection(z.string(), z.unknown()).readonly(),
+  'name': z.string().readonly(),
+  'role': z.union([z.literal("lead"), z.literal("teammate")]).readonly(),
+  'status': z.union([z.literal("running"), z.literal("failed"), z.literal("idle"), z.literal("inactive"), z.literal("provisioning")]).readonly(),
+  'description': z.string().readonly().optional(),
+  'provider': z.string().readonly().optional(),
+  'context': z.union([z.literal("fresh"), z.literal("fork")]).readonly().optional(),
+  'model': z.string().readonly().optional(),
+  'diagnostics': z.array(z.string()).readonly(),
+})).readonly(),
+  'tasks': z.array(z.object({
+  'id': z.intersection(z.string(), z.unknown()).readonly(),
+  'revision': z.number().readonly(),
+  'subject': z.string().readonly(),
+  'description': z.string().readonly(),
+  'status': z.union([z.literal("pending"), z.literal("in_progress"), z.literal("completed"), z.literal("deleted")]).readonly(),
+  'blockedBy': z.array(z.intersection(z.string(), z.unknown())).readonly(),
+  'writeScopes': z.array(z.string()).readonly(),
+  'ownerName': z.string().readonly().optional(),
+  'ready': z.boolean().readonly(),
+  'writeScopeWarnings': z.array(z.string()).readonly(),
+})).readonly(),
+}))
+
+export const TYPERT_REMOTE = {
+  package: '@deepseek-ai/dsh-experimental-agent-team',
+  descriptors: [
+    {
+      id: '@deepseek-ai/dsh-experimental-agent-team#agentTeams/createTask',
+      service: 'agentTeams',
+      namespace: 'agentTeams',
+      method: 'createTask',
+      implementation: 'remoteCreateTask',
+      invocation: { kind: 'direct' },
+      scope: {
+        context: 'agent',
+        wire: 'agentId',
+      },
+      parameters: [
+        {
+          name: 'agent',
+          wire: 'agentId',
+          source: 'lookup',
+          lookup: 'agent',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@deepseek-ai/dsh-session/types#SessionId',
+            create: _deepseek_ai_dsh_experimental_agent_team_agentTeams_createTask_parameter_0$schema,
+          },
+        },
+        {
+          name: 'request',
+          wire: 'request',
+          source: 'json',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@deepseek-ai/dsh-experimental-agent-team/client#CreateTeamTaskRequest',
+            create: _deepseek_ai_dsh_experimental_agent_team_agentTeams_createTask_parameter_1$schema,
+          },
+        },
+      ],
+      result: {
+        mode: 'strict',
+        typeSymbol: '@deepseek-ai/dsh-experimental-agent-team/client#TeamTaskMutationResult',
+        create: _deepseek_ai_dsh_experimental_agent_team_agentTeams_createTask_result$schema,
+      },
+      sourceLocation: {"file":"packages/experimental/agent-team/src/index.ts","line":257,"column":3},
+    },
+    {
+      id: '@deepseek-ai/dsh-experimental-agent-team#agentTeams/updateTask',
+      service: 'agentTeams',
+      namespace: 'agentTeams',
+      method: 'updateTask',
+      implementation: 'remoteUpdateTask',
+      invocation: { kind: 'direct' },
+      scope: {
+        context: 'agent',
+        wire: 'agentId',
+      },
+      parameters: [
+        {
+          name: 'agent',
+          wire: 'agentId',
+          source: 'lookup',
+          lookup: 'agent',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@deepseek-ai/dsh-session/types#SessionId',
+            create: _deepseek_ai_dsh_experimental_agent_team_agentTeams_updateTask_parameter_0$schema,
+          },
+        },
+        {
+          name: 'request',
+          wire: 'request',
+          source: 'json',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@deepseek-ai/dsh-experimental-agent-team/client#UpdateTeamTaskRequest',
+            create: _deepseek_ai_dsh_experimental_agent_team_agentTeams_updateTask_parameter_1$schema,
+          },
+        },
+      ],
+      result: {
+        mode: 'strict',
+        typeSymbol: '@deepseek-ai/dsh-experimental-agent-team/client#TeamTaskMutationResult',
+        create: _deepseek_ai_dsh_experimental_agent_team_agentTeams_updateTask_result$schema,
+      },
+      sourceLocation: {"file":"packages/experimental/agent-team/src/index.ts","line":268,"column":3},
+    },
+    {
+      id: '@deepseek-ai/dsh-experimental-agent-team#agentTeams/view',
+      service: 'agentTeams',
+      namespace: 'agentTeams',
+      method: 'view',
+      implementation: 'remoteView',
+      invocation: { kind: 'direct' },
+      scope: {
+        context: 'agent',
+        wire: 'agentId',
+      },
+      parameters: [
+        {
+          name: 'agent',
+          wire: 'agentId',
+          source: 'lookup',
+          lookup: 'agent',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@deepseek-ai/dsh-session/types#SessionId',
+            create: _deepseek_ai_dsh_experimental_agent_team_agentTeams_view_parameter_0$schema,
+          },
+        },
+      ],
+      result: {
+        mode: 'strict',
+        typeSymbol: '@deepseek-ai/dsh-experimental-agent-team/client#TeamView',
+        create: _deepseek_ai_dsh_experimental_agent_team_agentTeams_view_result$schema,
+      },
+      sourceLocation: {"file":"packages/experimental/agent-team/src/index.ts","line":243,"column":3},
+    },
+  ],
+}
+
+export default TYPERT_REMOTE

package/node_modules/@deepseek-ai/dsh-experimental-agent-team/lib/types/activity.js

@@ -0,0 +1,85 @@
+/** One-shot Team change waiters independent of durable state projection. */
+import { errorMessage, TeamError } from "./error.js";
+/** Owns current Team change waiters and releases each at most once. */
+export class TeamActivity {
+    waiters = new Map();
+    closed = false;
+    /**
+     * Wait for one later Team-domain or member-status change.
+     * @param id - Team whose next edge wakes the caller.
+     * @param timeoutMs - bounded wait duration from ten seconds through one hour.
+     * @param signal - caller cancellation for this wait only.
+     * @returns whether the wait ended by timeout.
+     */
+    async wait(id, timeoutMs, signal) {
+        if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 10_000 || timeoutMs > 3_600_000) {
+            throw new TeamError('timeoutMs must be an integer from 10000 through 3600000', 'TEAM_INVALID_TIMEOUT');
+        }
+        signal.throwIfAborted();
+        if (this.closed)
+            return { timedOut: false };
+        const changed = await new Promise((resolve, reject) => {
+            let waiters = this.waiters.get(id);
+            if (waiters === undefined) {
+                waiters = new Set();
+                this.waiters.set(id, waiters);
+            }
+            let settled = false;
+            const finish = (settle) => {
+                /* v8 ignore next -- timeout, abort, and notification may race after one winner removes the others. */
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                signal.removeEventListener('abort', onAbort);
+                waiters.delete(waiter);
+                if (waiters.size === 0)
+                    this.waiters.delete(id);
+                settle();
+            };
+            const onAbort = () => {
+                finish(() => {
+                    const reason = signal.reason;
+                    reject(reason instanceof Error
+                        ? reason
+                        : new TeamError(`wait_agent aborted: ${errorMessage(reason)}`, 'TEAM_WAIT_ABORTED'));
+                });
+            };
+            const waiter = {
+                resolve: () => {
+                    finish(() => { resolve(true); });
+                },
+            };
+            waiters.add(waiter);
+            const timer = setTimeout(() => { finish(() => { resolve(false); }); }, timeoutMs);
+            signal.addEventListener('abort', onAbort, { once: true });
+            // AbortSignal does not replay an abort that wins between the pre-check and listener registration.
+            /* v8 ignore next -- requires an abort in the synchronous gap between the pre-check and listener registration. */
+            if (signal.aborted)
+                onAbort();
+        });
+        return { timedOut: !changed };
+    }
+    /**
+     * Wake and remove every current waiter for one Team.
+     * @param id - Team whose current waiters observe the change.
+     */
+    notify(id) {
+        const waiters = this.waiters.get(id);
+        if (waiters === undefined)
+            return;
+        this.waiters.delete(id);
+        for (const waiter of waiters)
+            waiter.resolve();
+    }
+    /** Close admission and wake every current waiter during runtime disposal. */
+    close() {
+        this.closed = true;
+        for (const waiters of this.waiters.values()) {
+            for (const waiter of waiters)
+                waiter.resolve();
+        }
+        this.waiters.clear();
+    }
+}
+//# sourceMappingURL=activity.js.map

package/node_modules/@deepseek-ai/dsh-experimental-agent-team/lib/types/client.js

@@ -0,0 +1,3 @@
+/** Client-safe Agent Teams request, result, and view vocabulary. */
+export {};
+//# sourceMappingURL=client.js.map

package/node_modules/@deepseek-ai/dsh-experimental-agent-team/lib/types/error.js

@@ -0,0 +1,23 @@
+/** Typed Agent Teams failures. */
+import { inspect } from 'node:util';
+import { HarnessError } from '@deepseek-ai/dsh-llm';
+/** Stable failure raised by the Team domain. */
+export class TeamError extends HarnessError {
+    constructor(message, code, options) {
+        super(message, code, options);
+        this.name = 'TeamError';
+    }
+}
+/**
+ * Render an arbitrary thrown value without replacing the original rejection.
+ * @param error - caught value used in a diagnostic or durable failure record.
+ * @returns one bounded single-line description.
+ */
+export function errorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === 'string')
+        return error;
+    return inspect(error, { breakLength: Infinity, compact: true, depth: 4 });
+}
+//# sourceMappingURL=error.js.map

package/node_modules/@deepseek-ai/dsh-experimental-agent-team/lib/types/index.js

@@ -0,0 +1,313 @@
+/** Agent Teams service façade over roster, mailbox, task, and runtime lifecycle owners. */
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import z from '@deepseek-ai/schemastery';
+import { Remote, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import { TeamActivity } from "./activity.js";
+import { errorMessage, TeamError } from "./error.js";
+import { TeamJournal } from "./journal.js";
+import { TeamRuntimeLifecycle } from "./lifecycle.js";
+import { TeamMailbox } from "./mailbox.js";
+import { teamProjectionDefinition } from "./projection.js";
+import { TeamRoster } from "./roster.js";
+import { TeamTaskBoard } from "./task-board.js";
+import { TeamId } from "./types.js";
+export { TeamId, TeamMessageId, TeamTaskId } from "./types.js";
+export { TeamError } from "./error.js";
+const DEFAULT_MAX_MEMBERS = 16;
+const DEFAULT_MAX_TASKS = 256;
+const DEFAULT_MAX_PENDING_MESSAGES = 64;
+const DEFAULT_MAX_MESSAGE_BYTES = 65_536;
+const DEFAULT_DISPOSAL_TIMEOUT_MS = 5_000;
+/** Validate one positive safe-integer deployment limit. */
+function positiveLimit(name, value) {
+    if (!Number.isSafeInteger(value) || value < 1) {
+        throw new TeamError(`${name} must be a positive safe integer`, 'TEAM_INVALID_CONFIG');
+    }
+    return value;
+}
+/** Agent Teams service backed by the exact live Lead Session log. */
+let TeamService = (() => {
+    let _classSuper = TypertRemoteService;
+    let _instanceExtraInitializers = [];
+    let _remoteView_decorators;
+    let _remoteCreateTask_decorators;
+    let _remoteUpdateTask_decorators;
+    return class TeamService extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _remoteView_decorators = [Remote('view')];
+            _remoteCreateTask_decorators = [Remote('createTask')];
+            _remoteUpdateTask_decorators = [Remote('updateTask')];
+            __esDecorate(this, null, _remoteView_decorators, { kind: "method", name: "remoteView", static: false, private: false, access: { has: obj => "remoteView" in obj, get: obj => obj.remoteView }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _remoteCreateTask_decorators, { kind: "method", name: "remoteCreateTask", static: false, private: false, access: { has: obj => "remoteCreateTask" in obj, get: obj => obj.remoteCreateTask }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _remoteUpdateTask_decorators, { kind: "method", name: "remoteUpdateTask", static: false, private: false, access: { has: obj => "remoteUpdateTask" in obj, get: obj => obj.remoteUpdateTask }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static inject = ['agents', 'sessions', 'sessionPersistence', 'sessionProjections', 'subagents'];
+        static Config = z.object({
+            maxMembers: z.number().step(1).min(1).default(DEFAULT_MAX_MEMBERS),
+            maxTasks: z.number().step(1).min(1).default(DEFAULT_MAX_TASKS),
+            maxPendingMessagesPerMember: z.number().step(1).min(1).default(DEFAULT_MAX_PENDING_MESSAGES),
+            maxMessageBytes: z.number().step(1).min(1).default(DEFAULT_MAX_MESSAGE_BYTES),
+            disposalTimeoutMs: z.number().step(1).min(1).default(DEFAULT_DISPOSAL_TIMEOUT_MS),
+        });
+        /** Validated deployment limits used by every Team operation. */
+        config = __runInitializers(this, _instanceExtraInitializers);
+        activity;
+        lifecycle;
+        journal;
+        roster;
+        mailbox;
+        tasks;
+        constructor(ctx, config = {}) {
+            super(ctx, 'agentTeams');
+            this.config = {
+                maxMembers: positiveLimit('maxMembers', config.maxMembers ?? DEFAULT_MAX_MEMBERS),
+                maxTasks: positiveLimit('maxTasks', config.maxTasks ?? DEFAULT_MAX_TASKS),
+                maxPendingMessagesPerMember: positiveLimit('maxPendingMessagesPerMember', config.maxPendingMessagesPerMember ?? DEFAULT_MAX_PENDING_MESSAGES),
+                maxMessageBytes: positiveLimit('maxMessageBytes', config.maxMessageBytes ?? DEFAULT_MAX_MESSAGE_BYTES),
+                disposalTimeoutMs: positiveLimit('disposalTimeoutMs', config.disposalTimeoutMs ?? DEFAULT_DISPOSAL_TIMEOUT_MS),
+            };
+            this.activity = new TeamActivity();
+            this.lifecycle = new TeamRuntimeLifecycle(this.config.disposalTimeoutMs);
+            this.journal = new TeamJournal(ctx, (root) => { this.activity.notify(TeamId(root.id)); });
+            this.roster = new TeamRoster(ctx, this.journal, this.lifecycle, this.config.maxMembers);
+            this.mailbox = new TeamMailbox(ctx, this.journal, this.roster, this.lifecycle, this.config.maxPendingMessagesPerMember, this.config.maxMessageBytes);
+            this.tasks = new TeamTaskBoard(this.journal, this.config.maxTasks);
+            ctx.on('session/event', (session, event) => { this.mailbox.observeSessionEvent(session, event); });
+            ctx.on('agent/created', ({ agent }) => { this.scheduleRecovery(agent); });
+            ctx.on('agent/status', ({ agent }) => {
+                const membership = this.roster.tryMembership(agent);
+                if (membership !== undefined)
+                    this.activity.notify(membership.id);
+            });
+            ctx.effect(() => {
+                const disposeProjection = ctx.root.sessionProjections.register(teamProjectionDefinition);
+                return async () => {
+                    try {
+                        await this.disposeRuntime();
+                    }
+                    finally {
+                        disposeProjection();
+                    }
+                };
+            }, 'agentTeams.runtimeLifecycle()');
+            for (const agent of ctx.agents.list())
+                this.scheduleRecovery(agent);
+        }
+        /**
+         * Resolve one exact live Agent's Team role.
+         * @param agent - exact live Agent used as the authority credential.
+         * @returns its root, Team identity, role, and model-facing name.
+         */
+        membership(agent) {
+            return this.roster.membership(agent);
+        }
+        /**
+         * List the runtime-enriched roster visible to one Team member.
+         * @param agent - exact live Team member.
+         * @returns Lead and teammate rows in creation order.
+         */
+        listMembers(agent) {
+            return this.roster.list(this.roster.membership(agent));
+        }
+        /**
+         * Create one named, continuable direct child of the Team Lead.
+         * @param caller - exact live Lead Agent.
+         * @param request - immutable name, description, prompt, context mode, provider, and cancellation.
+         * @returns the active roster row.
+         */
+        async spawnTeammate(caller, request) {
+            return await this.roster.spawn(caller, request);
+        }
+        /**
+         * Queue one durable peer message, then attempt immediate delivery.
+         * @param caller - exact live sending Team member.
+         * @param request - target name, content, and pre-queue cancellation.
+         * @returns durable message identity and immediate-delivery observation.
+         */
+        async sendMessage(caller, request) {
+            return await this.mailbox.send(caller, request);
+        }
+        /**
+         * Create one unowned pending task in the Team Lead log.
+         * @param caller - exact live Team member creating the task.
+         * @param request - task text, blockers, and advisory write scopes.
+         * @returns the revision-one task view.
+         */
+        async createTask(caller, request) {
+            return await this.tasks.create(this.roster.membership(caller), request);
+        }
+        /**
+         * Return one task, including a deleted tombstone.
+         * @param caller - exact live Team member reading the task.
+         * @param id - Team-local task identity.
+         * @returns the latest task value and derived readiness diagnostics.
+         */
+        getTask(caller, id) {
+            return this.tasks.get(this.roster.membership(caller), id);
+        }
+        /**
+         * List current non-deleted tasks in numeric creation order.
+         * @param caller - exact live Team member reading the board.
+         * @returns detached current task views.
+         */
+        listTasks(caller) {
+            return this.tasks.list(this.roster.membership(caller));
+        }
+        /**
+         * Compare-and-set one authorized task transition.
+         * @param caller - exact live Team member authorizing the mutation.
+         * @param request - task identity, expected revision, action, and action fields.
+         * @returns the committed next task revision.
+         */
+        async updateTask(caller, request) {
+            return await this.tasks.update(caller, this.roster.membership(caller), request);
+        }
+        /**
+         * Wait for the next Team-domain or member-status change.
+         * @param caller - exact live Team member waiting for activity.
+         * @param timeoutMs - bounded wait duration from ten seconds through one hour.
+         * @param signal - caller cancellation for the wait only.
+         * @returns one observed change or a timeout result.
+         */
+        async waitForChange(caller, timeoutMs, signal) {
+            const membership = this.roster.membership(caller);
+            return await this.activity.wait(membership.id, timeoutMs, signal);
+        }
+        /**
+         * Interrupt one live teammate turn without clearing its pending inbox.
+         * @param caller - exact live Lead Agent.
+         * @param targetName - durable teammate name.
+         * @returns the target status sampled before cancellation.
+         */
+        interrupt(caller, targetName) {
+            return this.roster.interrupt(caller, targetName);
+        }
+        /**
+         * Resolve a caller without throwing, used by scoped-tool installation and observers.
+         * @param agent - candidate exact live Agent.
+         * @returns Team membership, or undefined for non-Team subagents and stale identities.
+         */
+        tryMembership(agent) {
+            return this.roster.tryMembership(agent);
+        }
+        /**
+         * Read the current roster and non-deleted task board through the generated Remote API.
+         * @param agent - exact live Team member used as the authority credential.
+         * @returns detached current roster and task views.
+         */
+        remoteView(agent) {
+            return {
+                members: this.listMembers(agent),
+                tasks: this.listTasks(agent),
+            };
+        }
+        /**
+         * Create one shared task through the generated Remote API.
+         * @param agent - exact live Team member creating the task.
+         * @param request - task text, blockers, and advisory write scopes.
+         * @returns the revision-one task or a typed Team rejection.
+         */
+        remoteCreateTask(agent, request) {
+            return this.taskMutationResult(this.createTask(agent, request));
+        }
+        /**
+         * Apply one task mutation and preserve Team rejections as business results.
+         * @param agent - exact live Team member authorizing the mutation.
+         * @param request - task identity, expected revision, action, and action fields.
+         * @returns the committed task or a typed Team rejection.
+         */
+        remoteUpdateTask(agent, request) {
+            return this.taskMutationResult(this.updateTask(agent, request));
+        }
+        /** Preserve Team task rejections while allowing unexpected failures to reject the Remote call. */
+        async taskMutationResult(operation) {
+            try {
+                return { ok: true, value: await operation };
+            }
+            catch (error) {
+                if (!(error instanceof TeamError))
+                    throw error;
+                return {
+                    ok: false,
+                    error: {
+                        code: error.code === 'TEAM_TASK_STALE_REVISION' ? 'team-task-conflict' : 'team-rejected',
+                        message: error.message,
+                    },
+                };
+            }
+        }
+        /** Queue one contained recovery pass after publication has unwound. */
+        scheduleRecovery(agent) {
+            queueMicrotask(() => {
+                if (this.lifecycle.disposed)
+                    return;
+                void this.recoverFor(agent).catch((error) => {
+                    if (this.lifecycle.disposed)
+                        return;
+                    this.ctx.logger.warn(`Agent Teams recovery for "${agent.id}" failed: ${errorMessage(error)}`);
+                });
+            });
+        }
+        /** Reconcile roster provisioning before retrying that member's pending mailbox. */
+        async recoverFor(agent) {
+            await this.roster.recoverFor(agent, this.lifecycle.signal);
+            await this.mailbox.recoverFor(agent, this.lifecycle.signal);
+        }
+        /** Stop Team-owned live branches and release every waiter before service disposal completes. */
+        async disposeRuntime() {
+            this.lifecycle.close();
+            this.activity.close();
+            const failures = [];
+            await this.lifecycle.settle(this.roster.pendingCreations(), failures);
+            await this.lifecycle.settle(this.mailbox.pendingDispatches(), failures);
+            for (const [root, childIds] of this.roster.liveChildrenByRoot()) {
+                try {
+                    await this.roster.stopTeammates(root, childIds);
+                }
+                catch (error) {
+                    failures.push(error);
+                }
+            }
+            if (failures.length > 0)
+                throw new AggregateError(failures, 'Agent Teams runtime disposal failed');
+        }
+    };
+})();
+export { TeamService };
+export default TeamService;
+//# sourceMappingURL=index.js.map

package/node_modules/@deepseek-ai/dsh-experimental-agent-team/lib/types/invariant.js

@@ -0,0 +1,26 @@
+/** Agent Teams runtime invariant companion. */
+import { isTeamEvent, teamProjectionDefinition, } from "./projection.js";
+const PACKAGE_NAME = '@deepseek-ai/dsh-experimental-agent-team';
+/** Cordis companion plugin name. */
+export const name = 'team-invariant';
+/** Invariant registry required by the companion. */
+export const inject = ['invariants'];
+/** Validate candidate Team events against the projected committed prefix. */
+const install = Object.assign((ctx, fail) => {
+    ctx.on('internal/dispatch', (_mode, eventName, args) => {
+        if (eventName !== 'session/event')
+            return;
+        const [session, event] = args;
+        /* v8 ignore next -- non-Team Session events have no Agent Teams invariant. */
+        if (!isTeamEvent(event))
+            return;
+        const state = ctx.sessionProjections.stateOf(session, 'agentTeam');
+        const candidate = teamProjectionDefinition.apply(structuredClone(state), event);
+        if (candidate.failure !== undefined) {
+            fail(`session event ${event.seq} violates the Agent Teams stream: ${candidate.failure}`);
+        }
+    }, { global: true });
+}, { inject: ['sessionProjections'] });
+/** Register the package invariant companion. */
+export const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//# sourceMappingURL=invariant.js.map