@nanmicoder/dsh-agent-teams 0.1.6 → 0.1.8

package/lib/members.js

@@ -64,15 +64,18 @@ function modelSelection(selection) {
 }
 /**
  * Resolve one member's complete model selection. Ordinary members snapshot the
- * captain's current request route and reasoning effort. An explicit member
- * provider/model or plugin-level model replaces only that route; the current
- * captain effort remains the inherited policy and is validated against the
- * target model before a child is created.
+ * captain's current request route and reasoning effort. When provider or model
+ * changes, effort is intentionally omitted so the target model materializes
+ * its own default instead of receiving an adapter-owned id from another route.
+ * An explicit effort overrides either policy; the sentinel "default" also
+ * selects the target model's default. The final effort is validated against
+ * the target model before a child is created.
  */
 export async function resolveMemberLlmSelection(ctx, captain, request, signal) {
     const explicitProvider = request.provider?.trim();
     const explicitModel = request.model?.trim();
     const defaultModel = request.defaultModel?.trim();
+    const explicitEffort = request.reasoningEffort?.trim();
     if (request.provider !== undefined && explicitProvider === '') {
         throw new Error('member LLM provider must not be empty');
     }
@@ -82,21 +85,38 @@ export async function resolveMemberLlmSelection(ctx, captain, request, signal) {
     if (request.defaultModel !== undefined && defaultModel === '') {
         throw new Error('configured memberModel must not be empty');
     }
+    if (request.reasoningEffort !== undefined && explicitEffort === '') {
+        throw new Error('member reasoning effort must not be empty');
+    }
     if (explicitProvider !== undefined && explicitModel === undefined) {
         throw new Error('an explicit member LLM provider requires an explicit member model');
     }
     const current = captain.session.requestHeader()?.config;
-    const provider = explicitProvider ?? current?.provider ?? captain.options.provider;
-    const model = explicitModel ?? defaultModel ?? current?.model ?? captain.options.model;
+    const currentProvider = current?.provider ?? captain.options.provider;
+    const currentModel = current?.model ?? captain.options.model;
+    const provider = explicitProvider ?? currentProvider;
+    const model = explicitModel ?? defaultModel ?? currentModel;
     if (provider === undefined || model === undefined) {
         throw new Error('cannot resolve the member LLM route from the current captain session');
     }
+    // Effort ids belong to one exact provider/model capability. Preserve the
+    // captain's effort only on the same route; a changed route must resolve its
+    // own default. Explicit effort still wins, while "default" forces that
+    // target-default behavior even when the route did not change.
+    const sameRoute = provider === currentProvider && model === currentModel;
+    const reasoningEffort = explicitEffort === undefined
+        ? sameRoute
+            ? current?.reasoningEffort
+            : undefined
+        : explicitEffort === 'default'
+            ? undefined
+            : ReasoningEffortId(explicitEffort);
     const resolved = await ctx.llm.resolveCallConfig({
         provider,
         model,
-        ...current?.reasoningEffort === undefined
+        ...reasoningEffort === undefined
             ? {}
-            : { reasoningEffort: current.reasoningEffort },
+            : { reasoningEffort },
     }, signal);
     return {
         provider: resolved.provider,

package/lib/state.js

@@ -444,17 +444,87 @@ export async function acknowledgeMailbox(stateRoot, teamId, agentKey, messageIds
 function stripLeadingBom(value) {
     return value.charCodeAt(0) === 0xFEFF ? value.slice(1) : value;
 }
-/** Atomically replace one UTF-8 state file from a same-directory temp file. */
+/** Rename attempts before falling back to a direct overwrite. */
+const ATOMIC_RENAME_RETRIES = 3;
+/** Pause between rename attempts, giving a briefly-locking owner time to finish. */
+const ATOMIC_RENAME_RETRY_DELAY_MS = 50;
+/**
+ * Rename error codes worth retrying before the direct-write fallback. On
+ * Windows, replacing an existing file whose target is momentarily held open
+ * without FILE_SHARE_DELETE surfaces as EPERM (or EACCES/EBUSY variants);
+ * EEXIST/ENOTEMPTY cover other "target busy" edge shapes.
+ */
+const RETRYABLE_RENAME_CODES = new Set(['EPERM', 'EACCES', 'EBUSY', 'EEXIST', 'ENOTEMPTY']);
+function isRetryableRenameError(error) {
+    return error instanceof Error
+        && 'code' in error
+        && RETRYABLE_RENAME_CODES.has(error.code ?? '');
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Replace `file` with `content`, preferring an atomic same-directory rename of
+ * an already-written temp file.
+ *
+ * On Windows, `rename(tmp, file)` over an existing target throws EPERM while
+ * any other process keeps the target open without FILE_SHARE_DELETE (editors,
+ * indexers, antivirus scans, preview panes). By that point the payload has
+ * already been fully written to the temp file, so a direct overwrite of the
+ * target is a content-equivalent degraded path: retry the rename a few times
+ * (transient locks clear quickly), then write the target in place. Every path
+ * removes the temp file; when both the atomic rename and the direct write
+ * fail, the combined error surfaces as an {@link AggregateError}.
+ *
+ * @returns nothing once the file has been replaced by one of the two paths.
+ */
+export async function replaceFileAtomicOrDirect(temporary, file, content, primitives, options = {}) {
+    const retries = options.retries ?? ATOMIC_RENAME_RETRIES;
+    const retryDelayMs = options.retryDelayMs ?? ATOMIC_RENAME_RETRY_DELAY_MS;
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            await primitives.rename(temporary, file);
+            return;
+        }
+        catch (error) {
+            if (isRetryableRenameError(error) && attempt < retries) {
+                await sleep(retryDelayMs);
+                continue;
+            }
+            let fallbackError;
+            try {
+                await primitives.writeFile(file, content);
+            }
+            catch (writeError) {
+                fallbackError = writeError;
+            }
+            await primitives.remove(temporary).catch(() => undefined);
+            if (fallbackError !== undefined) {
+                throw new AggregateError([error, fallbackError], `failed to replace "${file}" atomically (${String(error)}) or by direct write (${String(fallbackError)})`);
+            }
+            return;
+        }
+    }
+}
+/**
+ * Atomically replace one UTF-8 state file from a same-directory temp file,
+ * degrading to a direct overwrite when the atomic rename cannot proceed
+ * (see {@link replaceFileAtomicOrDirect} for the Windows EPERM rationale).
+ */
 async function atomicWriteText(file, content) {
     const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
     try {
         await writeFile(temporary, content, { encoding: 'utf8', flag: 'wx' });
-        await rename(temporary, file);
     }
     catch (error) {
         await rm(temporary, { force: true }).catch(() => undefined);
         throw error;
     }
+    await replaceFileAtomicOrDirect(temporary, file, content, {
+        rename: (from, to) => rename(from, to),
+        writeFile: (target, payload) => writeFile(target, payload, 'utf8'),
+        remove: (path) => rm(path, { force: true }),
+    });
 }
 /** Whether a parsed JSON value is a plain record. */
 function isRecord(value) {
@@ -566,6 +636,30 @@ function isTeamMessage(value) {
 export async function removeTeamDir(stateRoot, teamId) {
     await rm(join(stateRoot, teamId), { recursive: true, force: true });
 }
+/**
+ * `rename` with the same transient retry policy as the state-file atomic
+ * write, for paths (like archiving a whole team directory) where there is no
+ * content-equivalent direct-write degradation on Windows. A short-lived
+ * delete-sharing lock on any file below the renamed path is retried a few
+ * times before the error propagates.
+ * @param from - source path.
+ * @param to - destination path.
+ */
+async function renameWithRetry(from, to) {
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            await rename(from, to);
+            return;
+        }
+        catch (error) {
+            if (isRetryableRenameError(error) && attempt < ATOMIC_RENAME_RETRIES) {
+                await sleep(ATOMIC_RENAME_RETRY_DELAY_MS);
+                continue;
+            }
+            throw error;
+        }
+    }
+}
 /**
  * Archive a team instead of deleting it: the whole directory (team.json with
  * tasks and dependency graph, plus the mailboxes) moves under
@@ -583,21 +677,26 @@ export async function archiveTeamDir(stateRoot, teamId) {
     const previous = join(archiveRoot, `.${teamId}.previous-${randomUUID()}`);
     let displaced = false;
     try {
-        await rename(target, previous);
+        // The same Windows EPERM-on-rename applies at the directory boundary: a
+        // delete-sharing violation on any file below `target` blocks the move, so
+        // retry the transient-lock case before giving up.
+        await renameWithRetry(target, previous);
         displaced = true;
     }
     catch (error) {
+        // Only ENOENT means there was nothing to displace; any other failure
+        // (including a persistent EPERM lock) surfaces to the caller.
         if (!(error instanceof Error && 'code' in error && error.code === 'ENOENT')) {
             throw error;
         }
     }
     try {
-        await rename(source, target);
+        await renameWithRetry(source, target);
     }
     catch (error) {
         if (displaced) {
             try {
-                await rename(previous, target);
+                await renameWithRetry(previous, target);
             }
             catch (restoreError) {
                 throw new AggregateError([error, restoreError], `failed to archive team "${teamId}" and restore its previous archive`);

package/lib/tools.js

@@ -221,12 +221,13 @@ export function registerAgentTeamsTools(ctx, config) {
     }));
     ctx.tools.register(defineTool({
         name: 'agent_teams_add_member',
-        description: 'Add a durable continuable member. By default it snapshots the captain\'s current LLM provider, model, and reasoning effort with no user prompt. Supply provider/model only for an explicitly requested role-specific route. The member waits for messages, works on assigned tasks, and can message the team.',
+        description: 'Add a durable continuable member. By default it snapshots the captain\'s current LLM route and effort. Supply provider/model only for an explicitly requested role-specific route; a changed provider or model automatically uses the target model\'s default effort. Set reasoning_effort only to request one of the target model\'s supported ids explicitly (or "default" to force its default). The member waits for messages, works on assigned tasks, and can message the team.',
         parameters: {
             name: { type: 'string', required: true, description: 'Unique member name inside the team.' },
             role: { type: 'string', description: 'Role of the member (e.g. researcher, engineer, reviewer).' },
             provider: { type: 'string', description: 'Optional LLM provider route. Use only when the user explicitly requests a different provider; requires model.' },
             model: { type: 'string', description: 'Optional model override. Omit for the captain\'s current model (or the configured memberModel default).' },
+            reasoning_effort: { type: 'string', description: 'Optional reasoning effort override: one of the target model\'s supported effort ids, or "default" to force its default. When omitted, the captain\'s effort is inherited only for the same provider/model; a changed route uses the target default.' },
         },
         output: {
             schema: {
@@ -270,6 +271,7 @@ export function registerAgentTeamsTools(ctx, config) {
                     provider: args.provider,
                     model: args.model,
                     defaultModel: config.memberModel,
+                    reasoningEffort: args.reasoning_effort,
                 }, exec.signal);
                 const member = {
                     id: '',
@@ -283,7 +285,19 @@ export function registerAgentTeamsTools(ctx, config) {
                 };
                 await spawnMember(ctx, memberRuntime(config), memberSelections, selection, captain, fresh, member, config.stateDir, exec.signal);
                 fresh.members.push(member);
-                await writeTeam(stateRoot, fresh);
+                try {
+                    await writeTeam(stateRoot, fresh);
+                }
+                catch (error) {
+                    // The continuable child is already live, but the durable team record
+                    // never saw it. Retire the orphan so it disappears from subagent
+                    // listings and cannot be resumed, then surface the write failure.
+                    if (member.id !== '') {
+                        await recordRetiredMemberIds(stateRoot, [member.id]).catch(() => undefined);
+                        interruptMember(ctx, captain, member.id);
+                    }
+                    throw error;
+                }
                 appendTeamEvent(ctx, captainSessionOf(ctx, fresh.captainSessionId, captain.session), 'agent-teams/member-added', {
                     teamId: fresh.id,
                     memberId: member.id,

package/lib/types/client/ActivityPanel.d.ts

@@ -16,46 +16,6 @@
  */
 import type { SessionId } from '@deepseek-ai/dsh-session/types';
 import type { ObservableSnapshot, SessionListState } from '@deepseek-ai/dsh-client-runtime/client';
-/** One member row of a host snapshot. */
-export interface ActivityMember {
-    readonly id: string;
-    readonly name: string;
-    readonly role: string;
-    readonly status?: 'idle' | 'working' | 'removed';
-    readonly activity: 'working' | 'idle' | 'unknown';
-    readonly progress: number;
-    readonly done: number;
-    readonly total: number;
-    readonly currentTask: string;
-    readonly unread: number;
-}
-/** One task row of a host snapshot. */
-export interface ActivityTask {
-    readonly id: string;
-    readonly subject: string;
-    readonly status: string;
-    readonly state: 'blocked' | 'open' | 'running' | 'completed';
-    readonly assignee: string;
-    readonly dependencies: readonly string[];
-    readonly depth: number;
-}
-/** One captain-inbox preview row. */
-export interface ActivityMessage {
-    readonly from: string;
-    readonly content: string;
-}
-/** One team snapshot (mirrors the host TeamActivitySnapshot). */
-export interface ActivityTeam {
-    readonly workspace: string;
-    readonly teamId: string;
-    readonly name: string;
-    readonly description?: string;
-    readonly captainSessionId: string;
-    readonly members: readonly ActivityMember[];
-    readonly tasks: readonly ActivityTask[];
-    readonly messageCount: number;
-    readonly captainInbox: readonly ActivityMessage[];
-}
 /** The top-right activity floater. Teams follow the current session: live
  * snapshots and historic card summaries are only shown while their captain
  * session is the one currently open. */

package/lib/types/client/AgentTeamsCard.d.ts

@@ -16,9 +16,8 @@ export declare const OPEN_PANEL_EVENT = "agent-teams:open-panel";
 /** Navigation action injected from the plugin's own SessionsService access. */
 export interface AgentTeamsCardInjected {
     readonly openSession: (id: SessionId) => void;
-    readonly currentSessionId: () => SessionId | undefined;
 }
 /** Complete keyed Chat renderer props. */
 export type AgentTeamsCardProps = PropsRuntime<'conversation.chat.node', 'agent-teams'> & PropsLocale<'agentTeams'> & AgentTeamsCardInjected;
 /** Render one durable team as a compact conversation card. */
-export declare function AgentTeamsCard({ node, openSession, currentSessionId }: AgentTeamsCardProps): import("react").JSX.Element;
+export declare function AgentTeamsCard({ node, openSession, sessionId }: AgentTeamsCardProps): import("react").JSX.Element;

package/lib/types/client/activity-monitor.d.ts

@@ -0,0 +1,106 @@
+/** Shared, demand-driven state for the AgentTeams browser monitor. */
+/** One member row of a host snapshot. */
+export interface ActivityMember {
+    readonly id: string;
+    readonly name: string;
+    readonly role: string;
+    readonly status?: 'idle' | 'working' | 'removed';
+    readonly activity: 'working' | 'idle' | 'unknown';
+    readonly progress: number;
+    readonly done: number;
+    readonly total: number;
+    readonly currentTask: string;
+    readonly unread: number;
+}
+/** One task row of a host snapshot. */
+export interface ActivityTask {
+    readonly id: string;
+    readonly subject: string;
+    readonly status: string;
+    readonly state: 'blocked' | 'open' | 'running' | 'completed';
+    readonly assignee: string;
+    readonly dependencies: readonly string[];
+    readonly depth: number;
+}
+/** One captain-inbox preview row. */
+export interface ActivityMessage {
+    readonly from: string;
+    readonly content: string;
+}
+/** One team snapshot (mirrors the host TeamActivitySnapshot). */
+export interface ActivityTeam {
+    readonly workspace: string;
+    readonly teamId: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly captainSessionId: string;
+    readonly members: readonly ActivityMember[];
+    readonly tasks: readonly ActivityTask[];
+    readonly messageCount: number;
+    readonly captainInbox: readonly ActivityMessage[];
+}
+/** A successfully-created conversation card that currently needs updates. */
+export interface ActivityMonitorTarget {
+    readonly key: string;
+    readonly sessionId: string;
+    readonly teamId: string;
+}
+/** Latest shared response data for both the floater and conversation cards. */
+export interface ActivitySnapshots {
+    readonly teams: readonly ActivityTeam[];
+    readonly archivedTeams: readonly ActivityTeam[];
+}
+/** Subscribe to the active monitor-target list (React external-store shape). */
+export declare function subscribeActivityMonitorTargets(listener: () => void): () => void;
+/** Read the stable active-target snapshot. */
+export declare function getActivityMonitorTargetsSnapshot(): readonly ActivityMonitorTarget[];
+/**
+ * Register one successful AgentTeams card as a monitoring demand.
+ *
+ * The returned cleanup is reference-counted so multiple cards and React
+ * StrictMode remounts cannot stop another card's monitor.
+ */
+export declare function monitorAgentTeam(sessionId: string, teamId: string): () => void;
+/** Stop polling targets whose final archived snapshot has been captured. */
+export declare function settleActivityMonitorTargets(keys: ReadonlySet<string>): void;
+/** Subscribe to the shared live/archive snapshot. */
+export declare function subscribeActivitySnapshots(listener: () => void): () => void;
+/** Read the stable shared live/archive snapshot. */
+export declare function getActivitySnapshotsSnapshot(): ActivitySnapshots;
+/** Publish one or both successful state-route responses. */
+export declare function updateActivitySnapshots(update: Partial<ActivitySnapshots>): void;
+/** Poll cadence for the live host snapshot route. */
+export declare const ACTIVITY_POLL_MS = 1000;
+/** Host route serving live and archived team snapshots. */
+export declare const ACTIVITY_STATE_URL = "/plugins/dsh-agent-teams/state";
+interface ActivityFetchResponse {
+    readonly ok: boolean;
+    json(): Promise<unknown>;
+}
+/** Injectable browser primitives used by the poll controller and its tests. */
+export interface ActivityPollingRuntime {
+    readonly fetchState?: (url: string, init: {
+        readonly cache: 'no-store';
+        readonly signal: AbortSignal;
+    }) => Promise<ActivityFetchResponse>;
+    readonly schedule?: (callback: () => void, intervalMs: number) => unknown;
+    readonly cancel?: (timer: unknown) => void;
+    readonly publishSnapshots?: (update: Partial<ActivitySnapshots>) => void;
+    readonly settleTargets?: (keys: ReadonlySet<string>) => void;
+}
+/** Handle returned by one current-session polling loop. */
+export interface ActivityPollingController {
+    /** The immediate first pass, exposed so offline verification can await it. */
+    readonly firstTick: Promise<void>;
+    /** Idempotently stop the timer and abort the current request. */
+    stop(): void;
+}
+/**
+ * Start the single polling loop for the current session's requested targets.
+ *
+ * With no targets this is deliberately inert: installing the plugin must not
+ * touch the state route. Live state is polled at the normal cadence; archive
+ * state is fetched only as a one-time fallback for targets no longer live.
+ */
+export declare function startActivityPolling(monitorTargets: readonly ActivityMonitorTarget[], runtime?: ActivityPollingRuntime): ActivityPollingController;
+export {};

package/lib/types/command.d.ts

@@ -0,0 +1,71 @@
+/**
+ * The `/agent-teams` slash command and its plain-text gesture boundary.
+ *
+ * Two deterministic activation paths, mirroring the Harness skill pipeline
+ * (`dsh-tool-skill` + the `ui-skill` client source):
+ *
+ * 1. **Host command** — `ctx.commands.register` publishes the closed-namespace
+ *    `/agent-teams` command. The web GUI's slash menu (the Harness
+ *    `ui-commands` client) lists it from the host catalog with the input
+ *    hint; the argued line is claimed client-side and executed through
+ *    `command.execute` WITHOUT ever reaching the model. The handler queues
+ *    one explicit activation message as an ordinary follow-up turn
+ *    (`agent.followup`), so the captain protocol starts deterministically —
+ *    no "use AgentTeams" phrasing required.
+ * 2. **Gesture boundary** — a `agent/pre-step` listener recognizes a leading
+ *    `/agent-teams` token in genuine user messages and injects the same
+ *    activation message. This covers surfaces with no command adjudication
+ *    (headless CLI, API, pasted text in plain composers) and is a no-op for
+ *    the command path, whose line is consumed before it can become a prompt.
+ *    Mid-sentence mentions stay ordinary prose; only `source.kind === 'user'`
+ *    messages are scanned, so injected or external text cannot forge the
+ *    gesture.
+ *
+ * @module dsh-agent-teams/command
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { type UserMessage } from '@deepseek-ai/dsh-llm';
+/** The slash command name (without the leading slash). */
+export declare const AGENT_TEAMS_COMMAND = "agent-teams";
+declare module '@deepseek-ai/dsh-llm' {
+    interface MessageSourceMap {
+        /**
+         * A deterministic `/agent-teams` activation: the goal the user supplied,
+         * delivered as an ordinary follow-up turn instead of the raw slash line.
+         */
+        'agent-teams-command': {
+            readonly kind: 'agent-teams-command';
+            /** The user-supplied goal text (absent when the gesture was bare). */
+            readonly goal?: string;
+        };
+    }
+}
+/**
+ * The deterministic activation text. The system-prompt usage section owns
+ * the full protocol; this message only switches it on for one concrete goal.
+ * @param goal - the user-supplied goal, or `''` for a bare invocation.
+ */
+export declare function buildActivationDirective(goal: string): string;
+/**
+ * The goal of the latest start-anchored `/agent-teams` gesture in genuine
+ * user messages, or `undefined` when no message carries one. `''` means a
+ * bare `/agent-teams` token with no goal.
+ * @param messages - the step's claimed batch (user messages only scanned).
+ */
+export declare function invokedAgentTeamsGoal(messages: readonly UserMessage[]): string | undefined;
+/**
+ * Register the closed-namespace `/agent-teams` host command. The handler
+ * runs against the receiving agent without sending the slash line to the
+ * model: it queues the activation message as an ordinary follow-up turn and
+ * wakes the driver. The registration rides the calling context's fiber, so
+ * a disposed scope (HMR, plugin removal) unregisters the command.
+ * @param ctx - host context providing the `commands` registry.
+ */
+export declare function registerAgentTeamsCommand(ctx: Context): void;
+/**
+ * Install the `agent/pre-step` gesture boundary: a claimed user message
+ * starting with `/agent-teams` gains the deterministic activation message
+ * appended after every other injection, closest to the model's answer.
+ * @param ctx - host context providing the `agent/pre-step` waterfall.
+ */
+export declare function installAgentTeamsGestureBoundary(ctx: Context): void;

package/lib/types/index.d.ts

@@ -37,6 +37,12 @@ export interface Config {
     maxMembers?: number;
     /** Prompt-section order for the usage policy (default `117`, after delegation policy). */
     promptSectionOrder?: number;
+    /**
+     * Register the deterministic `/agent-teams` activation surfaces (the
+     * closed-namespace slash command and the plain-text gesture boundary).
+     * Disable to keep the natural-language trigger as the only entry point.
+     */
+    slashCommand?: boolean;
 }
 export declare const Config: z<Config>;
 export declare function apply(ctx: Context, config: Config): void;

package/lib/types/members.d.ts

@@ -38,6 +38,8 @@ export interface MemberLlmSelectionRequest {
     model?: string;
     /** Plugin-level member model default. */
     defaultModel?: string;
+    /** Explicit reasoning effort; "default" selects the target model's default effort. */
+    reasoningEffort?: string;
 }
 /** Process-local bridge between spawn admission and synchronous child setup. */
 export interface MemberSelectionRuntime {
@@ -46,10 +48,12 @@ export interface MemberSelectionRuntime {
 }
 /**
  * Resolve one member's complete model selection. Ordinary members snapshot the
- * captain's current request route and reasoning effort. An explicit member
- * provider/model or plugin-level model replaces only that route; the current
- * captain effort remains the inherited policy and is validated against the
- * target model before a child is created.
+ * captain's current request route and reasoning effort. When provider or model
+ * changes, effort is intentionally omitted so the target model materializes
+ * its own default instead of receiving an adapter-owned id from another route.
+ * An explicit effort overrides either policy; the sentinel "default" also
+ * selects the target model's default. The final effort is validated against
+ * the target model before a child is created.
  */
 export declare function resolveMemberLlmSelection(ctx: Context, captain: Agent, request: MemberLlmSelectionRequest, signal?: AbortSignal): Promise<MemberLlmSelection>;
 /**

package/lib/types/state.d.ts

@@ -149,6 +149,35 @@ export declare function releaseMailboxDelivery(stateRoot: string, teamId: string
  * malformed lines for diagnostics. Callers serialize this with the team lock.
  */
 export declare function acknowledgeMailbox(stateRoot: string, teamId: string, agentKey: string, messageIds: readonly string[]): Promise<void>;
+/** Filesystem primitives used by {@link replaceFileAtomicOrDirect}; injectable for tests. */
+export interface AtomicReplacePrimitives {
+    rename: (from: string, to: string) => Promise<void>;
+    writeFile: (file: string, content: string) => Promise<void>;
+    remove: (file: string) => Promise<void>;
+}
+/** Tuning knobs for {@link replaceFileAtomicOrDirect} (defaults match production). */
+export interface AtomicReplaceOptions {
+    /** Rename attempts before the direct-write fallback (default 3). */
+    retries?: number;
+    /** Delay between rename attempts in ms (default 50). */
+    retryDelayMs?: number;
+}
+/**
+ * Replace `file` with `content`, preferring an atomic same-directory rename of
+ * an already-written temp file.
+ *
+ * On Windows, `rename(tmp, file)` over an existing target throws EPERM while
+ * any other process keeps the target open without FILE_SHARE_DELETE (editors,
+ * indexers, antivirus scans, preview panes). By that point the payload has
+ * already been fully written to the temp file, so a direct overwrite of the
+ * target is a content-equivalent degraded path: retry the rename a few times
+ * (transient locks clear quickly), then write the target in place. Every path
+ * removes the temp file; when both the atomic rename and the direct write
+ * fail, the combined error surfaces as an {@link AggregateError}.
+ *
+ * @returns nothing once the file has been replaced by one of the two paths.
+ */
+export declare function replaceFileAtomicOrDirect(temporary: string, file: string, content: string, primitives: AtomicReplacePrimitives, options?: AtomicReplaceOptions): Promise<void>;
 /**
  * Remove a team's whole directory (members should be interrupted first).
  * @param stateRoot - resolved absolute state root directory.

package/lib/types/types.d.ts

@@ -51,7 +51,7 @@ export interface TeamMember {
     provider?: string;
     /** Resolved model captured when this member was created. */
     model?: string;
-    /** Resolved reasoning effort captured from the captain's current session. */
+    /** Resolved reasoning effort captured from the captain or target model default. */
     reasoningEffort?: string;
     joinedAt: number;
     status: MemberStatus;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanmicoder/dsh-agent-teams",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "AgentTeams for DeepSeek Harness: multi-agent team collaboration (captain, members, tasks with dependencies, messaging) driven by natural language, with a tree monitor in the web GUI",
   "type": "module",
   "main": "lib/index.js",
@@ -93,6 +93,7 @@
     "@deepseek-ai/dsh-client-ui-conversation": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-client-ui-primitives": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-client-ui-slots": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-commands": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-session": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-subagent": "^0.1.0-rc.6",
@@ -123,6 +124,9 @@
     "@deepseek-ai/dsh-client-ui-slots": {
       "optional": true
     },
+    "@deepseek-ai/dsh-commands": {
+      "optional": true
+    },
     "@deepseek-ai/dsh-llm": {
       "optional": true
     },
@@ -153,6 +157,7 @@
     "@deepseek-ai/dsh-client-ui-conversation": "0.1.0-rc.6",
     "@deepseek-ai/dsh-client-ui-primitives": "0.1.0-rc.6",
     "@deepseek-ai/dsh-client-ui-slots": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-commands": "0.1.0-rc.6",
     "@deepseek-ai/dsh-llm": "0.1.0-rc.6",
     "@deepseek-ai/dsh-session": "0.1.0-rc.6",
     "@deepseek-ai/dsh-subagent": "0.1.0-rc.6",