@nanmicoder/dsh-agent-teams 0.1.13 → 0.1.14

package/lib/types/index.d.ts

@@ -18,6 +18,7 @@
  */
 import type { Context } from '@deepseek-ai/cordis';
 import z from '@deepseek-ai/schemastery';
+import { type TeamProfileConfig } from './profiles.ts';
 export declare const name = "agent-teams";
 export declare const inject: string[];
 /** Plugin configuration. */
@@ -31,10 +32,16 @@ export interface Config {
     memberProvider?: string;
     /** Optional model override applied to every member. */
     memberModel?: string;
+    /** Prompt injected into member personas and automatic task assignments. */
+    executionPrompt?: string;
+    /** Plugin-wide fallback route for unavailable member models. */
+    fallback?: import('./profiles.ts').TeamModelFallbackConfig;
     /** Member delegation depth cap (default `1`; `0` forbids delegation entirely). */
     memberMaxDepth?: number;
     /** Team size cap in members (default `8`). */
     maxMembers?: number;
+    /** Named multi-role team profiles. */
+    profiles?: Record<string, TeamProfileConfig>;
     /** Prompt-section order for the usage policy (default `117`, after delegation policy). */
     promptSectionOrder?: number;
     /**
@@ -45,4 +52,6 @@ export interface Config {
     slashCommand?: boolean;
 }
 export declare const Config: z<Config>;
+/** The model-facing usage policy: when and how to drive AgentTeams. */
+export declare function usageSectionText(toolNames: string, profilesText?: string): string;
 export declare function apply(ctx: Context, config: Config): void;

package/lib/types/members.d.ts

@@ -13,13 +13,22 @@
  */
 import type { Context } from '@deepseek-ai/cordis';
 import { type Agent } from '@deepseek-ai/dsh-agent';
-import type { TeamMember, TeamState } from './types.ts';
+import { type TeamMember, type TeamState } from './types.ts';
+/** Persona snapshot of a profile protocol; the full text lives on team.json. */
+export declare const PERSONA_PROTOCOL_MAX_CHARS = 400;
 /** Runtime knobs for member spawning, resolved from plugin config. */
 export interface MemberRuntimeConfig {
     /** Registered `ctx.subagents` provider name (must support continuable + persona). */
     provider: string;
     /** Child delegation depth cap (0 forbids delegation entirely). */
     maxDepth?: number;
+    /** Plugin-wide execution prompt. */
+    executionPrompt?: string;
+    /** Plugin-wide fallback route. */
+    fallback?: {
+        provider: string;
+        model: string;
+    };
 }
 /** Durable provider/model/reasoning snapshot for one member. */
 export interface MemberLlmSelection {
@@ -29,6 +38,11 @@ export interface MemberLlmSelection {
     model: string;
     /** Adapter-owned reasoning effort, absent when the target has no explicit/default effort. */
     reasoningEffort?: string;
+    /** Configured second-choice route. */
+    fallback?: {
+        provider: string;
+        model: string;
+    };
 }
 /** Optional member-level route requested by the captain. */
 export interface MemberLlmSelectionRequest {
@@ -40,12 +54,40 @@ export interface MemberLlmSelectionRequest {
     defaultModel?: string;
     /** Explicit reasoning effort; "default" selects the target model's default effort. */
     reasoningEffort?: string;
+    /** Configured fallback route. */
+    fallback?: {
+        provider: string;
+        model: string;
+    };
 }
 /** Process-local bridge between spawn admission and synchronous child setup. */
 export interface MemberSelectionRuntime {
     /** Make one selection visible while Harness materializes the fresh child. */
     withPending<T>(parentSessionId: string, label: string, selection: MemberLlmSelection, operation: () => Promise<T>): Promise<T>;
 }
+/**
+ * Validate a resolved roster against every provider catalog before any child
+ * session is created. Catalogs are advisory when empty (some adapters accept
+ * dynamic model ids), but a non-empty catalog is authoritative enough to
+ * catch a typo that would otherwise boot a child and fail on its first turn.
+ */
+export declare function validateMemberLlmSelections(ctx: Context, selections: readonly MemberLlmSelection[], signal?: AbortSignal): Promise<void>;
+export declare function isFallbackFailureCode(code: string): boolean;
+/** Pure state transition used by the request-error handler and TDD tests. */
+export declare function selectFallbackRoute(current: {
+    provider: string;
+    model: string;
+}, fallback: {
+    provider: string;
+    model: string;
+} | undefined, failureCode: string, alreadySwitched: boolean): {
+    retry: boolean;
+    switched: boolean;
+    selection: {
+        provider: string;
+        model: string;
+    };
+};
 /**
  * Resolve one member's complete model selection. Ordinary members snapshot the
  * captain's current request route and reasoning effort. When provider or model
@@ -67,17 +109,20 @@ export declare function installMemberSelectionRuntime(ctx: Context, stateDir: st
 /**
  * The member's system prompt (persona), shadowing the deployment persona for
  * that child. Self-contained: it replaces the whole persona section.
+ * Frozen at spawn: draft must already carry the Team goal and profile protocol.
  * @param team - the team the member joined.
  * @param member - the member record (name/role are read before spawning).
  * @param stateDir - configured state directory, so the member can locate the
  *   team files with its own file tools.
  */
-export declare function memberPersona(team: TeamState, member: TeamMember, stateDir: string): string;
+export declare function memberPersona(team: TeamState, member: TeamMember, stateDir: string, executionPrompt?: string): string;
 /**
  * The initial user message delivered when the member is created.
+ * Counts non-terminal tasks already assigned to this member on the in-memory draft.
  * @param team - the team the member joined.
+ * @param memberName - canonical member name used to count assigned pending work.
  */
-export declare function memberWelcome(team: TeamState): string;
+export declare function memberWelcome(team: TeamState, memberName: string): string;
 /**
  * Spawn one member as a durable continuable subagent of the captain and fill
  * `member.id` with its child session id. On failure nothing is persisted.

package/lib/types/profiles.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Named team-profile templates: config types, normalization, invocation
+ * parsing, and prompt rendering.
+ *
+ * Pure functions only — no I/O, no spawn. Runtime create/spawn stays in
+ * `tools.ts`; this module only turns a config map + a profile name into a
+ * validated, topologically ordered template (or parses `--profile` flags).
+ *
+ * @module dsh-agent-teams/profiles
+ */
+/** Hard cap on named profiles so the usage prompt cannot grow without bound. */
+export declare const MAX_TEAM_PROFILES = 16;
+/** Hard cap on seed tasks per profile. The software-delivery example has 13. */
+export declare const MAX_PROFILE_TASKS = 32;
+/** Protocol excerpt length in the usage / prompt listing. */
+export declare const PROFILE_PROTOCOL_PROMPT_LIMIT = 240;
+/** One member row in a named team-profile template (unresolved). */
+export interface TeamModelFallbackConfig {
+    provider: string;
+    model: string;
+}
+export interface TeamProfileMemberConfig {
+    name: string;
+    role?: string;
+    provider?: string;
+    model?: string;
+    reasoning_effort?: string;
+    executionPrompt?: string;
+    fallback?: TeamModelFallbackConfig;
+}
+/** One seed-task row in a named team-profile template (unresolved). */
+export interface TeamProfileTaskConfig {
+    id: string;
+    subject: string;
+    description?: string;
+    assignee?: string;
+    dependencies?: string[];
+}
+/** One named team-profile template from plugin config. */
+export interface TeamProfileConfig {
+    description?: string;
+    protocol?: string;
+    executionPrompt?: string;
+    fallback?: TeamModelFallbackConfig;
+    members: TeamProfileMemberConfig[];
+    /**
+     * `captain` means the profile supplies people and guardrails only; the
+     * Captain derives the task graph from the user's goal at runtime.
+     * `seed` preserves a fixed template workflow for explicitly scripted teams.
+     */
+    taskPlanning?: 'captain' | 'seed';
+    tasks?: TeamProfileTaskConfig[];
+    reviewPolicy?: import('./types.ts').ReviewPolicy;
+}
+/** A profile member after trim / pairing / reserved-name checks. */
+export interface NormalizedProfileMember {
+    name: string;
+    role?: string;
+    provider?: string;
+    model?: string;
+    reasoningEffort?: string;
+    executionPrompt?: string;
+    fallback?: TeamModelFallbackConfig;
+}
+/** A profile seed task after assignee canonicalization; `sourceIndex` is the YAML order. */
+export interface NormalizedProfileTask {
+    id: string;
+    subject: string;
+    description?: string;
+    assignee?: string;
+    dependencies: string[];
+    sourceIndex: number;
+}
+/** A fully validated, topologically ordered team profile. */
+export interface NormalizedTeamProfile {
+    name: string;
+    description?: string;
+    protocol?: string;
+    executionPrompt?: string;
+    fallback?: TeamModelFallbackConfig;
+    taskPlanning: 'captain' | 'seed';
+    members: NormalizedProfileMember[];
+    tasks: NormalizedProfileTask[];
+    reviewPolicy?: import('./types.ts').ReviewPolicy;
+}
+/** The goal + optional named profile extracted from a slash / gesture line. */
+export interface AgentTeamsInvocation {
+    goal: string;
+    profile?: string;
+}
+/** One configured profile after key trim, for listing / lookup. */
+export interface ListedTeamProfile {
+    name: string;
+    config: TeamProfileConfig;
+}
+/**
+ * Trim every profile key once, reject empty / colliding keys, and reject
+ * more than {@link MAX_TEAM_PROFILES} entries. Does not validate profile
+ * bodies — that belongs to {@link resolveTeamProfile}.
+ */
+export declare function listConfiguredProfiles(profiles: Record<string, TeamProfileConfig> | undefined | null): ListedTeamProfile[];
+/**
+ * Render the usage-prompt listing. One line per profile: name, member count,
+ * task count, protocol excerpt (at most 240 characters). Returns `''` when
+ * nothing is configured so callers can omit the capability entirely.
+ */
+export declare function formatProfilesForPrompt(profiles: Record<string, TeamProfileConfig> | undefined | null): string;
+/**
+ * Walk `rawInput` from the front and eat standalone profile flags. Only
+ * `--profile <name>`, `--profile=<name>`, and `profile=<name>` count; the
+ * first ordinary token stops the scan so a mid-sentence `profile=` stays in
+ * the goal. A leading ordinary token is never treated as a profile name.
+ *
+ * `--profile "name"` strips one matching pair of quotes. Repeat flags and a
+ * `--profile` with no name throw.
+ */
+export declare function parseProfileInvocation(rawInput: string): AgentTeamsInvocation;
+/**
+ * Normalize and pre-validate one named profile. Failures throw before any
+ * caller should create a directory or spawn members.
+ */
+export declare function resolveTeamProfile(profiles: Record<string, TeamProfileConfig>, profileName: string, maxMembers: number): NormalizedTeamProfile;
+/** Public lookup used by activation text and status rendering. */
+export declare function resolveProfileTaskPlanning(config: TeamProfileConfig | undefined): 'captain' | 'seed';

package/lib/types/quality-gates.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Pure quality-gate rules: contracts, path audit, completion, follow-up,
+ * coverage, and resume. Tools and persistence call these; they do not I/O.
+ * @module dsh-agent-teams/quality-gates
+ */
+import { type AcceptanceResult, type CommandResult, type FindingSeverity, type ReviewFinding, type ReviewPolicy, type ReviewVerdict, type TaskKind, type TaskStatus, type TeamState, type TeamTask } from './types.ts';
+declare const QUALITY_KINDS: readonly TaskKind[];
+declare const WRITE_KINDS: readonly TaskKind[];
+declare const DEFAULT_REVIEW_POLICY: Required<Pick<ReviewPolicy, 'requirementsMinRounds' | 'requirementsMaxRounds' | 'codeMaxRounds' | 'maxRepairAttempts'>>;
+export type PathClassification = 'in_scope' | 'out_of_scope' | 'undeclared' | 'illegal';
+export interface CreateTaskInput {
+    subject: string;
+    description?: string;
+    dependencies?: string[];
+    assignee?: string;
+    kind?: TaskKind;
+    round?: number;
+    objective?: string;
+    inScope?: string[];
+    outOfScope?: string[];
+    acceptance?: string[];
+    verify?: string[];
+    deliverables?: string[];
+    nonGoals?: string[];
+    reviewedTaskId?: string;
+    sourceTaskId?: string;
+    sourceFindingIds?: string[];
+    coverageOf?: string[];
+    resume?: boolean;
+    resumeReason?: string;
+}
+export interface ValidateCreateTaskResult {
+    ok: boolean;
+    error?: string;
+    kind?: TaskKind;
+    task?: Partial<TeamTask>;
+    team?: TeamState;
+}
+export interface QualityCompletionUpdate {
+    status?: TaskStatus;
+    output?: string;
+    verdict?: ReviewVerdict;
+    findings?: ReviewFinding[];
+    changedPaths?: string[];
+    acceptanceResults?: AcceptanceResult[];
+    commandsRun?: CommandResult[];
+}
+export interface QualityCompletionResult {
+    ok: boolean;
+    error?: string;
+    requiredStatus?: TaskStatus;
+}
+export interface PlannedFollowUpTask {
+    id?: string;
+    kind: TaskKind;
+    subject?: string;
+    assignee?: string;
+    dependencies?: string[];
+    round?: number;
+    objective?: string;
+    inScope?: string[];
+    outOfScope?: string[];
+    acceptance?: string[];
+    verify?: string[];
+    sourceTaskId?: string;
+    sourceFindingIds?: string[];
+    reviewedTaskId?: string;
+}
+export interface PlanQualityFollowUpResult {
+    created: PlannedFollowUpTask[];
+    tasks: PlannedFollowUpTask[];
+    escalated?: boolean;
+    status?: 'escalated';
+}
+export interface CoverageRow {
+    goal_item: string;
+    task_ids: string[];
+    status: 'missing' | 'in_progress' | 'passed' | 'blocked';
+    evidence?: string;
+}
+export interface DeliveryResult {
+    ok: boolean;
+    blockers: string[];
+}
+export interface ResumeTeamResult {
+    ok?: boolean;
+    status: 'resumed' | 'already_running' | 'rejected';
+    team?: TeamState;
+    error?: string;
+}
+export type QualityLoopState = 'running' | 'halted' | 'escalated' | 'deliverable' | 'blocked';
+export interface QualityLoopSnapshot {
+    state: QualityLoopState;
+    halted: boolean;
+    escalated: boolean;
+    deliverable: boolean;
+    summary: string;
+}
+export interface QualityGraphDraft {
+    subject: string;
+    kind: TaskKind;
+    assignee?: string;
+    dependencies: string[];
+    objective: string;
+    acceptance: string[];
+    inScope?: string[];
+    verify?: string[];
+    coverageOf?: string[];
+}
+export declare const DEFAULT_REVIEW_ACCEPTANCE: readonly ["The latest implementation meets the user goal", "No unresolved blocker or high findings"];
+export declare const DEFAULT_REVIEW_OBJECTIVE = "Review whether the latest implementation satisfies the user goal";
+export declare function taskKindOf(task: Pick<TeamTask, 'kind'> | undefined): TaskKind;
+export declare function isQualityKind(kind: TaskKind | undefined): boolean;
+export declare function resolveReviewPolicy(policy: ReviewPolicy | undefined): Required<typeof DEFAULT_REVIEW_POLICY> & ReviewPolicy;
+export declare function isReviewPolicy(value: unknown): value is ReviewPolicy;
+/** Normalize a workspace-relative POSIX path. `undefined` means illegal. */
+export declare function normalizeWorkspacePath(path: string): string | undefined;
+export declare function pathMatchesScope(path: string, pattern: string): boolean;
+export declare function classifyChangedPath(path: string, inScope?: readonly string[], outOfScope?: readonly string[]): PathClassification;
+export declare function collectChangedPaths(gitStatusText: string): string[];
+export declare function inScopeOverlap(left: readonly string[] | undefined, right: readonly string[] | undefined): string[];
+export declare function validateCreateTask(team: TeamState, input: CreateTaskInput): ValidateCreateTaskResult;
+export declare function evaluateQualityCompletion(task: TeamTask, update: QualityCompletionUpdate): QualityCompletionResult;
+export declare function planQualityFollowUp(team: TeamState, closed: TeamTask): PlanQualityFollowUpResult;
+export declare function buildCoverageMatrix(goalItems: readonly string[], tasks: readonly TeamTask[]): CoverageRow[];
+export declare function canDeclareDelivery(team: TeamState): DeliveryResult;
+export declare function resumeTeamState(team: TeamState, reason: string): ResumeTeamResult;
+export declare function isReviewFinding(value: unknown): value is ReviewFinding;
+export declare function isAcceptanceResult(value: unknown): value is AcceptanceResult;
+export declare function isCommandResult(value: unknown): value is CommandResult;
+export declare function hasValidQualityTaskFields(value: Record<string, unknown>): boolean;
+export declare function isTaskKind(value: unknown): value is TaskKind;
+export declare function isReviewVerdict(value: unknown): value is ReviewVerdict;
+export declare function isFindingSeverity(value: unknown): value is FindingSeverity;
+export declare function looksLikeGateTestContract(value: string | undefined): boolean;
+export declare function sanitizeReviewObjective(value: string | undefined, fallback?: string): string;
+export declare function sanitizeReviewAcceptance(values: readonly string[] | undefined): string[];
+export declare function defaultQualityDeliveryGraph(input: {
+    goal: string;
+    implementer?: string;
+    reviewer?: string;
+    analyst?: string;
+    tester?: string;
+    integrator?: string;
+}): QualityGraphDraft[];
+export declare function qualityPlanningPrompt(): string;
+export declare function describeQualityLoop(team: TeamState): QualityLoopSnapshot;
+export { QUALITY_KINDS, WRITE_KINDS };

package/lib/types/scheduler.d.ts

@@ -13,8 +13,14 @@
  */
 import type { Context } from '@deepseek-ai/cordis';
 import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { TeamTask } from './types.ts';
+/** Per-dependency output cap in the assignment prompt. */
+export declare const DEPENDENCY_OUTPUT_MAX_CHARS = 2000;
+/** Combined dependency-output budget in the assignment prompt. */
+export declare const DEPENDENCY_OUTPUTS_TOTAL_MAX_CHARS = 12000;
 export interface SchedulerConfig {
     readonly stateDir: string;
+    readonly executionPrompt?: string;
 }
 export interface TeamScheduler {
     /** Try to give every genuinely idle/ready member one unit of ready work. */
@@ -22,5 +28,43 @@ export interface TeamScheduler {
     /** Try to flush fallback mail or give one member one ready task. */
     kickMember(workspace: string, teamId: string, memberName: string, captain?: Agent): Promise<void>;
 }
+/** One completed recursive dependency shown to the assignee. */
+export interface DependencyOutput {
+    readonly id: string;
+    readonly subject: string;
+    readonly profileSeedId?: string;
+    readonly output?: string;
+}
+export interface DispatchTicket {
+    readonly taskId: string;
+    readonly memberName: string;
+    readonly memberId: string;
+    readonly attempt: number;
+    readonly attemptId: string;
+    readonly previousAssignee?: string;
+    readonly subject: string;
+    readonly description?: string;
+    readonly teamDescription?: string;
+    readonly profileProtocol?: string;
+    readonly profileSeedId?: string;
+    readonly dependencyOutputs: readonly DependencyOutput[];
+    readonly executionPrompt?: string;
+    readonly kind?: string;
+    readonly round?: number;
+    readonly objective?: string;
+    readonly inScope?: readonly string[];
+    readonly outOfScope?: readonly string[];
+    readonly acceptance?: readonly string[];
+    readonly verify?: readonly string[];
+    readonly reviewedTaskId?: string;
+}
+/**
+ * Recursively collect `status=completed` ancestors of `taskId` in topological
+ * order (dependencies before dependents). Cycles stop that branch only.
+ */
+export declare function collectCompletedDependencyOutputs(tasks: readonly TeamTask[], taskId: string, warn?: (message: string) => void): DependencyOutput[];
+/** Format completed-dependency outputs with per-item and total truncation. */
+export declare function formatDependencyOutputs(items: readonly DependencyOutput[]): string;
+export declare function assignmentPrompt(ticket: DispatchTicket, stateDir: string, teamId: string): string;
 /** Install one scheduler and its member activity observer. */
 export declare function installTeamScheduler(ctx: Context, config: SchedulerConfig): TeamScheduler;

package/lib/types/snapshot.d.ts

@@ -10,12 +10,16 @@
 import type { Context } from '@deepseek-ai/cordis';
 import type { MemberStatus, TeamState } from './types.ts';
 /** Visual task state for the activity panel. */
-export type VisualTaskState = 'blocked' | 'open' | 'running' | 'completed';
+export type VisualTaskState = 'blocked' | 'open' | 'running' | 'completed' | 'failed' | 'cancelled';
 /** One member row of the activity snapshot. */
 export interface TeamActivityMember {
     readonly id: string;
     readonly name: string;
     readonly role: string;
+    readonly provider: string;
+    readonly model: string;
+    readonly reasoningEffort: string;
+    readonly executionPrompt: string;
     readonly status: MemberStatus;
     readonly activity: 'working' | 'idle' | 'unknown';
     readonly progress: number;
@@ -28,11 +32,16 @@ export interface TeamActivityMember {
 export interface TeamActivityTask {
     readonly id: string;
     readonly subject: string;
+    readonly description: string;
     readonly status: string;
     readonly state: VisualTaskState;
     readonly assignee: string;
+    readonly model: string;
     readonly dependencies: readonly string[];
     readonly depth: number;
+    readonly kind?: string;
+    readonly round?: number;
+    readonly verdict?: string;
 }
 /** One captain-inbox preview row. */
 export interface TeamActivityMessage {
@@ -46,6 +55,9 @@ export interface TeamActivitySnapshot {
     readonly name: string;
     readonly description?: string;
     readonly captainSessionId: string;
+    readonly phase: 'staged' | 'running';
+    readonly planReviewState?: 'awaiting_review' | 'awaiting_feedback';
+    readonly halted?: boolean;
     readonly members: readonly TeamActivityMember[];
     readonly tasks: readonly TeamActivityTask[];
     readonly messageCount: number;
@@ -58,6 +70,11 @@ export interface TeamSnapshotOptions {
     /** Archived teams have no meaningful live activity after their sessions stop. */
     readonly historic?: boolean;
 }
+/** Compact `provider/model` route for the activity panel, or just the model. */
+export declare function memberModelRoute(member: {
+    provider?: string;
+    model?: string;
+} | undefined): string;
 /**
  * Assemble one team snapshot from its durable files plus live activity.
  * @param ctx - the plugin context (injects `subagents`, used for activity).

package/lib/types/state.d.ts

@@ -12,7 +12,8 @@
  * `fs` service offers no directory deletion.
  * @module dsh-agent-teams/state
  */
-import type { TaskStatus, TeamMessage, TeamState, TeamTask } from './types.ts';
+import { type TaskStatus, type TeamMessage, type TeamState, type TeamTask } from './types.ts';
+export { buildCoverageMatrix, canDeclareDelivery, classifyChangedPath, collectChangedPaths, defaultQualityDeliveryGraph, describeQualityLoop, evaluateQualityCompletion, hasValidQualityTaskFields, isQualityKind, pathMatchesScope, planQualityFollowUp, qualityPlanningPrompt, resumeTeamState, sanitizeReviewAcceptance, sanitizeReviewObjective, taskKindOf, validateCreateTask, } from './quality-gates.ts';
 /** Mailbox key of the captain. */
 export declare const CAPTAIN_KEY = "captain";
 /**
@@ -69,6 +70,8 @@ export declare function beginTaskAttempt(task: TeamTask, assignee: string): stri
  * Revoke the current worker immediately. Clearing its capability makes old
  * updates stale; a separate handoff generation serializes async quiescence.
  */
+/** Cancel one unfinished task without returning it to the ready pool. */
+export declare function cancelUnfinishedTask(task: TeamTask, output?: string): void;
 export declare function invalidateTaskAttempt(task: TeamTask, nextAssignee?: string, reassigning?: boolean): void;
 /**
  * Create the team directory structure and the initial team record.
@@ -178,6 +181,7 @@ export interface AtomicReplaceOptions {
  * @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>;
+export declare function isTeamTask(value: unknown): value is TeamTask;
 /**
  * Remove a team's whole directory (members should be interrupted first).
  * @param stateRoot - resolved absolute state root directory.
@@ -208,10 +212,11 @@ export declare function readArchivedTeam(stateRoot: string, teamId: string): Pro
  */
 export declare function listArchivedTeamIds(stateRoot: string): Promise<string[]>;
 /** Visual task state for the activity panel. */
-export type VisualTaskState = 'blocked' | 'open' | 'running' | 'completed';
+export type VisualTaskState = 'blocked' | 'open' | 'running' | 'completed' | 'failed' | 'cancelled';
 /**
  * The visual state of one task: `running` while in_progress, `completed`
- * when done, `blocked` while any dependency is unfinished, else `open`.
+ * when done, `failed`/`cancelled` when terminal without success, `blocked`
+ * while any dependency is unfinished, else `open`.
  */
 export declare function taskVisualState(status: string, dependencies: readonly string[], tasks: readonly TeamTask[]): VisualTaskState;
 /**

package/lib/types/tools.d.ts

@@ -10,6 +10,7 @@
  */
 import type { Context } from '@deepseek-ai/cordis';
 import type { Agent } from '@deepseek-ai/dsh-agent';
+import { type TeamState, type TeamTask } from './types.ts';
 /** Resolved plugin config consumed by the tools. */
 export interface ToolsConfig {
     /** State directory name under the captain's workspace. */
@@ -18,23 +19,86 @@ export interface ToolsConfig {
     memberProvider: string;
     /** Optional member model override. */
     memberModel?: string;
+    /** Prompt injected into member personas and assignments. */
+    executionPrompt?: string;
+    /** Plugin fallback route. */
+    fallback?: import('./profiles.ts').TeamModelFallbackConfig;
     /** Member delegation depth cap. */
     memberMaxDepth?: number;
     /** Team size cap (members). */
     maxMembers: number;
+    /** Named team profiles from the active DSH profile. */
+    profiles: Record<string, import('./profiles.ts').TeamProfileConfig>;
 }
-/**
- * Deliver a durable member report at the captain's nearest model boundary.
- *
- * `Agent.steer()` targets the next step while the captain is running, wakes a
- * new turn when it is idle, and lets the Agent runtime reclassify an aborted
- * activity to `next-turn`. This prevents reports from waiting behind the
- * captain's entire orchestration turn.
- */
+/** Browser/UI mutations allowed while a plan is waiting for approval. */
+export type StagedPlanMutation = {
+    action: 'update_member';
+    memberName: string;
+    role?: string | null;
+    provider: string;
+    model: string;
+    reasoningEffort?: string | null;
+    executionPrompt?: string | null;
+} | {
+    action: 'update_task';
+    taskId: string;
+    subject: string;
+    description?: string | null;
+    assignee?: string | null;
+    dependencies: string[];
+} | {
+    action: 'add_task';
+    subject: string;
+    description?: string | null;
+    assignee?: string | null;
+    dependencies: string[];
+} | {
+    action: 'remove_task';
+    taskId: string;
+} | {
+    action: 'remove_member';
+    memberName: string;
+};
+/** Runtime bridge shared by model-facing tools and the Web staging surface. */
+export interface AgentTeamsRuntime {
+    updateStagedPlan(captain: Agent, teamId: string, mutation: StagedPlanMutation, signal?: AbortSignal): Promise<TeamState>;
+    updateStagedPlanBatch(captain: Agent, teamId: string, mutations: readonly StagedPlanMutation[], signal?: AbortSignal): Promise<TeamState>;
+    approveStagedTeam(captain: Agent, teamId: string, signal?: AbortSignal): Promise<{
+        teamId: string;
+        members: number;
+        tasks: number;
+    }>;
+    continueStagedPlanning(captain: Agent, teamId: string): Promise<{
+        teamId: string;
+        alreadyWaiting: boolean;
+    }>;
+    discardStagedTeam(captain: Agent, teamId: string): Promise<{
+        teamId: string;
+    }>;
+}
+export declare function haltTeamWork(input: {
+    ctx: Context;
+    stateRoot: string;
+    teamId: string;
+    captain: Agent;
+    signal?: AbortSignal;
+}): Promise<{
+    teamName: string;
+    cancelledTasks: number;
+    alreadyHalted: boolean;
+}>;
 export declare function steerCaptainReport(captain: Pick<Agent, 'steer'>, from: string, content: string): boolean;
+/** Context queued after the human rejects a staged plan. */
+export declare function stagedPlanDiscardContext(teamName: string): string;
+/** Model-facing continuation that turns the review UI back into a conversation. */
+export declare function stagedPlanFeedbackContext(teamName: string): string;
 /**
  * Register every `agent_teams_*` tool into the shared tools registry.
  * @param ctx - the plugin context (injects `tools`).
  * @param config - resolved tool config.
  */
-export declare function registerAgentTeamsTools(ctx: Context, config: ToolsConfig): void;
+export declare function registerAgentTeamsTools(ctx: Context, config: ToolsConfig): AgentTeamsRuntime;
+export declare function applyQualityFollowUp(team: TeamState, closed: TeamTask): {
+    created: TeamTask[];
+    escalated: boolean;
+};