@nanmicoder/dsh-agent-teams 0.1.5 → 0.1.7

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

@@ -10,6 +10,32 @@ export interface RelationshipStage<T extends RelationshipTask> {
     readonly depth: number;
     readonly tasks: readonly T[];
 }
+/** Geometry used by the compact task DAG in the activity panel. */
+export interface CompactDagNode<T extends RelationshipTask> {
+    readonly task: T;
+    readonly x: number;
+    readonly y: number;
+}
+/** One dependency edge routed between two compact DAG nodes. */
+export interface CompactDagEdge {
+    readonly from: string;
+    readonly to: string;
+    readonly path: string;
+}
+/** Complete, scrollable compact DAG projection. */
+export interface CompactDagLayout<T extends RelationshipTask> {
+    readonly width: number;
+    readonly height: number;
+    readonly nodes: readonly CompactDagNode<T>[];
+    readonly edges: readonly CompactDagEdge[];
+}
+/** Reference-panel geometry: narrow nodes with enough room for curved edges. */
+export declare const COMPACT_DAG_NODE_WIDTH = 92;
+export declare const COMPACT_DAG_NODE_HEIGHT = 30;
+export declare const COMPACT_DAG_COLUMN_GAP = 26;
+export declare const COMPACT_DAG_ROW_GAP = 8;
+/** Use a fill-width grid when the task graph has no real dependency edges. */
+export declare function usesParallelTaskGrid<T extends RelationshipTask>(tasks: readonly T[]): boolean;
 /**
  * Whether an expanded activity panel still belongs to the current session.
  *
@@ -29,6 +55,14 @@ export declare function activityPanelExpandedForSession(open: boolean, owner: st
 export declare function dependencyFocusTaskId(pinnedTaskId: string | null, keyboardTaskId: string | null, hoverTaskId: string | null): string | null;
 /** Group tasks by their precomputed dependency depth. */
 export declare function taskStages<T extends RelationshipTask>(tasks: readonly T[]): readonly RelationshipStage<T>[];
+/**
+ * Lay tasks out as the reference panel's compact left-to-right DAG.
+ *
+ * Columns are dependency-depth stages. Rows are stable task-id order within
+ * each stage. Edges use cubic curves so fan-in remains readable without
+ * turning every task into a large card.
+ */
+export declare function compactDagLayout<T extends RelationshipTask>(tasks: readonly T[]): CompactDagLayout<T>;
 /**
  * Return the complete upstream/downstream chain around one task.
  *

package/lib/types/event-types.d.ts

@@ -44,6 +44,8 @@ export interface AgentTeamsTaskUpdatedData {
     readonly status: string;
     readonly assignee?: string;
     readonly output?: string;
+    readonly attempt?: number;
+    readonly attemptId?: string;
 }
 /** Closes one team record: the team was deleted. */
 export interface AgentTeamsTeamDeletedData {

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>;
 /**
@@ -115,11 +119,24 @@ export declare function deliverToMember(ctx: Context, captain: Agent, childId: s
  */
 export declare function interruptMember(ctx: Context, captain: Agent, childId: string): void;
 /**
- * Snapshot each direct continuable child's activity under the captain's
- * session, keyed by child session id. A member that is currently running its
- * turn reports `running`; an idle member reports `inactive`.
+ * Install the missing per-child retirement boundary above Harness rc.6.
+ *
+ * Upstream `interrupt()` deliberately preserves continuable sessions and the
+ * upstream seam exposes no targeted forget/retire method. The durable
+ * AgentTeams index therefore guards all three public continuation boundaries:
+ * retired rows disappear from `list_agents` (children and descendants), and a
+ * direct `followup()` is rejected before it can cold-resume the member. Exact
+ * ids keep unrelated subagents untouched; transcripts remain in persistence
+ * for archived-team review.
+ */
+export declare function installRetiredMemberGuard(ctx: Context, stateDir: string): void;
+/**
+ * Snapshot each direct continuable child's real driver activity under the
+ * captain's session. `listChildren().activity` is only session residency, so
+ * live children are refined through the Agent registry exactly like Harness's
+ * shipped `list_agents` tool.
  * @param ctx - the plugin context (injects `subagents`).
  * @param captainSessionId - the captain's session id.
  * @returns child id → activity, missing entries are unknown children.
  */
-export declare function memberActivity(ctx: Context, captainSessionId: string): Promise<Map<string, 'running' | 'inactive'>>;
+export declare function memberActivity(ctx: Context, captainSessionId: string): Promise<Map<string, 'running' | 'idle' | 'ready'>>;

package/lib/types/scheduler.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Event-driven shared task scheduler.
+ *
+ * Claude Code teammates keep polling the shared task list after a turn. DSH
+ * continuable agents instead expose explicit idle/running edges, so this
+ * scheduler closes the same loop without keeping a polling turn alive: every
+ * idle edge and every task-graph mutation attempts one atomic claim and wakes
+ * the selected durable member.
+ * @module dsh-agent-teams/scheduler
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+export interface SchedulerConfig {
+    readonly stateDir: string;
+}
+export interface TeamScheduler {
+    /** Try to give every genuinely idle/ready member one unit of ready work. */
+    kickTeam(workspace: string, teamId: string, captain?: Agent): Promise<void>;
+    /** Try to flush fallback mail or give one member one ready task. */
+    kickMember(workspace: string, teamId: string, memberName: string, captain?: Agent): Promise<void>;
+}
+/** Install one scheduler and its member activity observer. */
+export declare function installTeamScheduler(ctx: Context, config: SchedulerConfig): TeamScheduler;

package/lib/types/snapshot.d.ts

@@ -8,7 +8,7 @@
  * @module dsh-agent-teams/snapshot
  */
 import type { Context } from '@deepseek-ai/cordis';
-import type { TeamState } from './types.ts';
+import type { MemberStatus, TeamState } from './types.ts';
 /** Visual task state for the activity panel. */
 export type VisualTaskState = 'blocked' | 'open' | 'running' | 'completed';
 /** One member row of the activity snapshot. */
@@ -16,6 +16,7 @@ export interface TeamActivityMember {
     readonly id: string;
     readonly name: string;
     readonly role: string;
+    readonly status: MemberStatus;
     readonly activity: 'working' | 'idle' | 'unknown';
     readonly progress: number;
     readonly done: number;
@@ -50,6 +51,13 @@ export interface TeamActivitySnapshot {
     readonly messageCount: number;
     readonly captainInbox: readonly TeamActivityMessage[];
 }
+/** Snapshot projection switches for live and archived teams. */
+export interface TeamSnapshotOptions {
+    /** Historic review must retain members that were marked removed at shutdown. */
+    readonly includeRemoved?: boolean;
+    /** Archived teams have no meaningful live activity after their sessions stop. */
+    readonly historic?: boolean;
+}
 /**
  * Assemble one team snapshot from its durable files plus live activity.
  * @param ctx - the plugin context (injects `subagents`, used for activity).
@@ -58,7 +66,7 @@ export interface TeamActivitySnapshot {
  * @param state - the durable team record.
  * @returns the panel snapshot.
  */
-export declare function assembleTeamSnapshot(ctx: Context, stateRoot: string, workspace: string, state: TeamState): Promise<TeamActivitySnapshot>;
+export declare function assembleTeamSnapshot(ctx: Context, stateRoot: string, workspace: string, state: TeamState, options?: TeamSnapshotOptions): Promise<TeamActivitySnapshot>;
 /**
  * Collect every team under the given workspace state roots.
  * @param ctx - the plugin context.

package/lib/types/state.d.ts

@@ -61,6 +61,15 @@ export declare const TASK_TRANSITIONS: Readonly<Record<TaskStatus, readonly Task
  * @returns the transition error, or undefined when allowed.
  */
 export declare function transitionError(current: TaskStatus, next: TaskStatus): string | undefined;
+/** Activate the task's current generation for one owner and return its capability id. */
+export declare function activateTaskAttempt(task: TeamTask, assignee: string): string;
+/** Start a fresh task generation for one owner. */
+export declare function beginTaskAttempt(task: TeamTask, assignee: string): string;
+/**
+ * Revoke the current worker immediately. Clearing its capability makes old
+ * updates stale; a separate handoff generation serializes async quiescence.
+ */
+export declare function invalidateTaskAttempt(task: TeamTask, nextAssignee?: string, reassigning?: boolean): void;
 /**
  * Create the team directory structure and the initial team record.
  * @param stateRoot - resolved absolute state root directory.
@@ -89,6 +98,10 @@ export declare function readTeamSync(stateRoot: string, teamId: string): TeamSta
  * @param state - the record to persist.
  */
 export declare function writeTeam(stateRoot: string, state: TeamState): Promise<void>;
+/** Read the durable set of member session ids retired by remove/delete. */
+export declare function readRetiredMemberIds(stateRoot: string): Promise<Set<string>>;
+/** Atomically add session ids to the durable retired-member deny-list. */
+export declare function recordRetiredMemberIds(stateRoot: string, memberIds: readonly string[]): Promise<void>;
 /**
  * Find the team owned by one captain session (at most one per captain).
  * @param stateRoot - resolved absolute state root directory.
@@ -125,6 +138,46 @@ export declare function appendMailbox(stateRoot: string, teamId: string, agentKe
  * @returns the messages, empty when the mailbox does not exist yet.
  */
 export declare function readMailbox(stateRoot: string, teamId: string, agentKey: string, onMalformedLine?: (lineNumber: number, error: unknown) => void): Promise<TeamMessage[]>;
+/** Read only messages that have not been acknowledged by their recipient. */
+export declare function readUnreadMailbox(stateRoot: string, teamId: string, agentKey: string, onMalformedLine?: (lineNumber: number, error: unknown) => void): Promise<TeamMessage[]>;
+/** Lease selected fallback messages to one delivery path. */
+export declare function claimMailboxDelivery(stateRoot: string, teamId: string, agentKey: string, messageIds: readonly string[]): Promise<void>;
+/** Release a failed delivery lease so the scheduler can retry it later. */
+export declare function releaseMailboxDelivery(stateRoot: string, teamId: string, agentKey: string, messageIds: readonly string[]): Promise<void>;
+/**
+ * Mark selected durable mailbox records delivered/read while preserving
+ * 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

@@ -20,12 +20,20 @@ export interface TeamTask {
     /** What needs to be done. */
     description?: string;
     status: TaskStatus;
-    /** Member name the task is assigned to; unassigned tasks await a claim. */
+    /** Member name (or `captain`) the task is assigned to; unassigned tasks await a claim. */
     assignee?: string;
     /** Task ids that must reach `completed` before this task can be claimed. */
     dependencies: string[];
     /** The worker's written result, set when the task completes or fails. */
     output?: string;
+    /** Monotonic execution generation. Reassignment/retry invalidates every older attempt. */
+    attempt?: number;
+    /** Capability for the current claimed/in-progress attempt. Members must present it when updating. */
+    attemptId?: string;
+    /** Opaque generation for a revocation/handoff that has not started its next attempt yet. */
+    handoffId?: string;
+    /** A handoff is quiescing the old owner; the scheduler must not dispatch it yet. */
+    reassigning?: boolean;
     createdAt: number;
     updatedAt: number;
 }
@@ -43,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;
@@ -57,6 +65,12 @@ export interface TeamMessage {
     to: string;
     content: string;
     ts: number;
+    /** Process-local delivery lease; prevents fallback and direct delivery racing. */
+    deliveryClaimedAt?: number;
+    /** Set after the durable message was accepted by the recipient's live Harness inbox. */
+    deliveredAt?: number;
+    /** Set once the recipient has consumed or been shown the durable fallback. */
+    readAt?: number;
 }
 /** The full durable team record. */
 export interface TeamState {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanmicoder/dsh-agent-teams",
-  "version": "0.1.5",
+  "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",
@@ -82,7 +82,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.client.json --noEmit",
     "sync:skill": "node scripts/sync-skill.mjs",
     "verify:skill": "node scripts/sync-skill.mjs --check",
-    "verify": "node scripts/verify.mjs && pnpm verify:skill",
+    "verify": "node scripts/verify.mjs && node scripts/lifecycle-verify.mjs && node scripts/stress-verify.mjs && pnpm verify:skill",
     "prepublishOnly": "pnpm build && pnpm verify"
   },
   "peerDependencies": {