@nanmicoder/dsh-agent-teams 0.1.6 → 0.1.7

package/README.md

@@ -78,7 +78,7 @@ Then ask for a team directly:
 
 Team state is stored under `<workspace>/.agent-teams/`; the Web panel reads that disk truth and combines it with live sub-agent activity.
 
-Member creation is zero-interaction by default: the plugin snapshots the LLM provider, model, and reasoning effort actually used by the captain's current step, and restores that snapshot on later continuations. Only an explicit heterogeneous-team request (for example, “backend on provider A/model X, frontend on provider B/model Y”) supplies a member-specific `provider` + `model`; there is no per-member model or reasoning prompt.
+Member creation is zero-interaction by default: a member on the captain's current LLM route snapshots that provider, model, and reasoning effort, while a member on a requested alternative route snapshots the target model's default effort; later continuations restore the resolved snapshot. Only an explicit heterogeneous-team request (for example, “backend on provider A/model X, frontend on provider B/model Y”) supplies a member-specific `provider` + `model`; there is no per-member model or reasoning prompt.
 
 ## Configuration
 
@@ -94,7 +94,7 @@ Defaults work without extra setup. A trusted profile can override member behavio
     maxMembers: 8
 ```
 
-`memberProvider` is the sub-agent runtime backend (`spawn` / `fork`), not an LLM provider. Cross-LLM-provider routing uses the optional `provider` + `model` fields of `agent_teams_add_member`; `memberModel` is only a model default for all members.
+`memberProvider` is the sub-agent runtime backend (`spawn` / `fork`), not an LLM provider. Cross-LLM-provider routing uses the optional `provider` + `model` fields of `agent_teams_add_member`; `memberModel` is only a model default for all members. A member on the captain's current provider/model inherits the captain's reasoning effort, while a changed provider or model automatically uses the target model's default. To request a particular effort, pass the optional `reasoning_effort` field — one of the target model's supported effort ids, or `"default"` to force the model's own default.
 
 ## Boundaries
 

package/README_ZH.md

@@ -78,7 +78,7 @@ dsh web
 
 团队状态保存在 `<workspace>/.agent-teams/`；Web 面板读取这份磁盘真相，并与实时子 Agent 活动合并展示。
 
-成员创建默认零交互：插件会快照队长**当前这一步**实际使用的 LLM provider、model 与思考强度，成员后续续跑仍使用这份快照。只有当用户明确提出异构分工（例如“后端用 provider A/model X，前端用 provider B/model Y”）时，队长才会把对应的 `provider` + `model` 传给该成员；不会逐个弹出模型或思考强度选择。
+成员创建默认零交互：成员沿用队长当前 LLM 路由时会快照该 provider、model 与思考强度；用户要求改用其他路由时，则快照目标模型的默认强度，成员后续续跑仍使用最终解析出的快照。只有当用户明确提出异构分工（例如“后端用 provider A/model X，前端用 provider B/model Y”）时，队长才会把对应的 `provider` + `model` 传给该成员；不会逐个弹出模型或思考强度选择。
 
 ## 配置
 
@@ -94,7 +94,7 @@ dsh web
     maxMembers: 8
 ```
 
-这里的 `memberProvider` 指子 Agent 的运行后端（`spawn` / `fork`），不是 LLM provider。跨 LLM provider 由 `agent_teams_add_member` 的可选 `provider` + `model` 参数表达；`memberModel` 只是所有成员的模型默认覆盖。
+这里的 `memberProvider` 指子 Agent 的运行后端（`spawn` / `fork`），不是 LLM provider。跨 LLM provider 由 `agent_teams_add_member` 的可选 `provider` + `model` 参数表达；`memberModel` 只是所有成员的模型默认覆盖。成员沿用队长当前 provider/model 时会继承队长的思考强度；provider 或 model 任一改变时会自动使用目标模型的默认档。需要指定特定强度时，可传入可选的 `reasoning_effort` 参数（目标模型支持的档位 id，或 `"default"` 表示强制使用模型自身默认档）。
 
 ## 使用边界
 

package/lib/index.js

@@ -40,7 +40,7 @@ export const Config = z.object({
 function usageSectionText(toolNames) {
     return `When the user asks to run something with AgentTeams (e.g. "use AgentTeams to do X"), you are the captain of a multi-agent team. Follow this protocol:
 1. Call agent_teams_create with a team name and the goal as description. You become the captain and may lead one team at a time.
-2. Call agent_teams_add_member once per role the goal needs (researcher, engineer, reviewer, ...). Members are durable subagents: they wait for your messages, then work a full turn. By default each member snapshots your current provider, model, and reasoning effort. Never ask the user to choose these per member; only pass provider/model when the user explicitly requests a different route for that role.
+2. Call agent_teams_add_member once per role the goal needs (researcher, engineer, reviewer, ...). Members are durable subagents: they wait for your messages, then work a full turn. By default a member on your current provider/model snapshots your current reasoning effort; a member routed to a different provider or model automatically uses that target model's default effort. Never ask the user to choose these per member; only pass provider/model when the user explicitly requests a different route for that role, and reasoning_effort only when the user explicitly requests a particular effort ("default" explicitly selects the target model's default).
 3. Break the goal into tasks with agent_teams_create_task and wire dependencies. Assign role-specific work when useful; unassigned ready work belongs to the shared pool. The scheduler automatically claims one ready task for each truly idle member and wakes it, including across later rounds.
 4. Lead by delegation: monitor with agent_teams_status, send guidance with agent_teams_send_message, and let idle teammates execute ready work. Do not duplicate a teammate's work merely because its turn is slow.
 5. If work is blocked, stale, or needs takeover, always call agent_teams_reassign_task first. Reassign to another idle member, or use assignee=captain before doing it yourself. Reassignment revokes the old attempt and waits for that member to quiesce, preventing late results from overwriting the new attempt.

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/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.7",
   "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",