@tencent-ai/agent-harness 0.2.0-beta.6 → 0.2.0-beta.8

package/cli/dist-server/types/node/tools/task-list-tool.d.ts

@@ -0,0 +1,20 @@
+import { Session } from '../../vendor/cbc-core/node/index.js';
+import { RunContext, ToolNames } from '../../vendor/cbc-shared/node/index.js';
+import { Logger } from '../../workspace/telemetry/lib/common/index.js';
+import { z } from 'zod';
+import { BaseTool } from './base-tool';
+import { TaskStorageService } from './task-storage-service';
+import { Tool, ToolCallArgumentRenderer, ToolResult } from './tool-protocol';
+declare const TaskListParameters: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare class TaskListTool extends BaseTool implements Tool {
+    protected readonly taskStorageService: TaskStorageService;
+    protected readonly logger: Logger;
+    name: ToolNames;
+    readonly promptCacheStability: "volatile";
+    parameters: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    argumentRenderer: ToolCallArgumentRenderer;
+    needsApproval: boolean;
+    execute(_input: z.infer<typeof TaskListParameters>, context?: RunContext<Session>): Promise<ToolResult>;
+    private generateSummary;
+}
+export {};

package/cli/dist-server/types/node/tools/task-output-tool.d.ts

@@ -0,0 +1,142 @@
+import { type Session } from '../../vendor/cbc-core/node/index.js';
+import { ToolNames } from '../../vendor/cbc-shared/node/index.js';
+import { Logger } from '../../workspace/telemetry/lib/common/index.js';
+import type { RunContext } from '@openai/agents';
+import { z } from 'zod';
+import { AgentTaskManager, AgentTaskOutputFileManager } from '../agent-task/agent-task-protocol';
+import { BaseTool } from './base-tool';
+import { Tool, ToolCallArgumentRenderer, ToolResult } from './tool-protocol';
+declare const TaskOutputParameters: z.ZodEffects<z.ZodObject<{
+    task_id: z.ZodString;
+    block: z.ZodOptional<z.ZodBoolean>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    filter: z.ZodOptional<z.ZodString>;
+    full: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    timeout: number;
+    task_id: string;
+    filter?: string | undefined;
+    block?: boolean | undefined;
+    full?: boolean | undefined;
+}, {
+    task_id: string;
+    timeout?: number | undefined;
+    filter?: string | undefined;
+    block?: boolean | undefined;
+    full?: boolean | undefined;
+}>, {
+    timeout: number;
+    task_id: string;
+    filter?: string | undefined;
+    block?: boolean | undefined;
+    full?: boolean | undefined;
+}, {
+    task_id: string;
+    timeout?: number | undefined;
+    filter?: string | undefined;
+    block?: boolean | undefined;
+    full?: boolean | undefined;
+}>;
+export declare class TaskOutputTool extends BaseTool implements Tool {
+    protected readonly agentTaskManager: AgentTaskManager;
+    protected readonly taskOutputFileManager: AgentTaskOutputFileManager;
+    protected readonly logger: Logger;
+    name: ToolNames;
+    description: string;
+    aliases: string[];
+    needsApproval: boolean;
+    parameters: z.ZodEffects<z.ZodObject<{
+        task_id: z.ZodString;
+        block: z.ZodOptional<z.ZodBoolean>;
+        timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        filter: z.ZodOptional<z.ZodString>;
+        full: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        timeout: number;
+        task_id: string;
+        filter?: string | undefined;
+        block?: boolean | undefined;
+        full?: boolean | undefined;
+    }, {
+        task_id: string;
+        timeout?: number | undefined;
+        filter?: string | undefined;
+        block?: boolean | undefined;
+        full?: boolean | undefined;
+    }>, {
+        timeout: number;
+        task_id: string;
+        filter?: string | undefined;
+        block?: boolean | undefined;
+        full?: boolean | undefined;
+    }, {
+        task_id: string;
+        timeout?: number | undefined;
+        filter?: string | undefined;
+        block?: boolean | undefined;
+        full?: boolean | undefined;
+    }>;
+    argumentRenderer: ToolCallArgumentRenderer;
+    execute(input: z.infer<typeof TaskOutputParameters>, context?: RunContext<Session>): Promise<ToolResult>;
+    private executeDurableTeamRuntimeTask;
+    /**
+     * Workflow 后台任务的 output 渲染。
+     *
+     * Workflow 跑完后由 WorkflowTool 在 finalizeBackgroundTask 里把 record.output
+     * 落盘到 task.outputFilePath。这里直接读文件,
+     * 失败时给出明确提示。仍在运行的 workflow 给 hint 让模型不要轮询。
+     */
+    /** Agent 子任务进度游标：每任务上次投喂到的绝对偏移（终态清账）。 */
+    private readonly progressOffsets;
+    /**
+     * BackgroundTask 的模型读取游标。WeakMap 让游标随 ToolManager 中的任务对象一起回收，
+     * stdout / stderr 独立推进；不清空共享 buffer，UI 与 full snapshot 仍可读取累计内容。
+     */
+    private readonly shellReadCursors;
+    /**
+     * 运行中进度增量。语义对齐 claude 2.1.235 的 TaskOutput（SIn +
+     * getTaskOutputDelta，二进制实测）：running 态回退读任务输出、字节截尾 +
+     * `[NKB of earlier output omitted]` 前缀、缺席回空；增量游标使重复轮询
+     * 只回新增（上下文）+ 写透尾环命中零文件读（remote fs）。
+     */
+    private readProgressDelta;
+    /**
+     * 游标写入带容量上限：终态渲染才清账（见 execute 尾部 delete），从未被
+     * 轮询到终态的任务（abort/杀死后不再查询）会永久滞留——长驻 server
+     * 累积子代理任务时是无界泄漏。超限逐出最早插入项（Map 迭代序），
+     * 被逐出任务若再被轮询按 firstPoll 语义从头投喂，语义无损。
+     */
+    private static readonly PROGRESS_OFFSET_CAP;
+    private rememberProgressOffset;
+    private executeWorkflowTask;
+    /**
+     * Handle agent sub-task output (original TaskOutputTool behavior)
+     */
+    private executeAgentTask;
+    private buildAgentTaskOutputLines;
+    private renderAgentTaskSnapshot;
+    /**
+     * Handle background shell task output (merged from BashOutputTool)
+     *
+     * 当 `block=true`（默认）且任务仍在运行时，先 await 到任务终态（或 timeout）再渲染
+     * 输出——对齐 agent-task 的 `waitFor` 语义。历史实现无视 block/timeout 直接返回当前
+     * buffer + "still running" hint，导致模型收到 block 请求后立刻拿到"仍在运行"，
+     * 于是反复重试 TaskOutput 形成紧密轮询死循环（#issue：CBC 一直 loop 发送
+     * "I'll wait for the completion notification"）。真正 block 住后模型每轮最多一次调用，
+     * 死循环消失。
+     */
+    private executeBackgroundShellTask;
+    /**
+     * 等待后台 shell 任务到达终态（completed/failed/cancelled/killed），或 timeout / abort。
+     *
+     * 优先订阅 `session.backgroundTaskSubject`（bash-tool 在 status 变更时 `.next(task)`），
+     * 事件驱动、无空转。拿不到 session（如某些非交互路径）时降级为轮询 task.status。
+     * 无论哪条路径退出，都不改写 task —— 仅"等待"，渲染逻辑照旧读 task 当前快照。
+     *
+     * timeout 语义与 agent-task waitFor 对齐：到点即返回（此时 status 可能仍是 running，
+     * 由调用方渲染 running 快照 + hint）。abort（用户 Ctrl+C）同样立即返回。
+     */
+    private waitForShellTerminal;
+    private formatDuration;
+}
+export {};

package/cli/dist-server/types/node/tools/task-stop-tool.d.ts

@@ -0,0 +1,61 @@
+import type { RunContext } from '@openai/agents';
+import { z } from 'zod';
+import { AgentTaskManager } from '../agent-task/agent-task-protocol';
+import { InterruptionService, Session } from '../../vendor/cbc-core/node/index.js';
+import { BaseTool } from './base-tool';
+import { Tool, ToolResult } from './tool-protocol';
+import { ToolNames } from '../../vendor/cbc-shared/node/index.js';
+declare const TaskStopParameters: z.ZodEffects<z.ZodObject<{
+    task_id: z.ZodOptional<z.ZodString>;
+    shell_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    task_id?: string | undefined;
+    shell_id?: string | undefined;
+}, {
+    task_id?: string | undefined;
+    shell_id?: string | undefined;
+}>, {
+    task_id?: string | undefined;
+    shell_id?: string | undefined;
+}, {
+    task_id?: string | undefined;
+    shell_id?: string | undefined;
+}>;
+export declare class TaskStopTool extends BaseTool implements Tool {
+    protected readonly agentTaskManager: AgentTaskManager;
+    protected readonly interruptionService: InterruptionService;
+    name: ToolNames;
+    description: string;
+    aliases: string[];
+    parameters: z.ZodEffects<z.ZodObject<{
+        task_id: z.ZodOptional<z.ZodString>;
+        shell_id: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        task_id?: string | undefined;
+        shell_id?: string | undefined;
+    }, {
+        task_id?: string | undefined;
+        shell_id?: string | undefined;
+    }>, {
+        task_id?: string | undefined;
+        shell_id?: string | undefined;
+    }, {
+        task_id?: string | undefined;
+        shell_id?: string | undefined;
+    }>;
+    needsApproval: boolean;
+    /** Auto mode classifier projection: the target task/shell id (Claude alignment, decision D1). */
+    toAutoClassifierInput(input: unknown): string;
+    execute(input: z.infer<typeof TaskStopParameters>, context: RunContext<Session>): Promise<ToolResult>;
+    /**
+     * Stop an agent sub-task via AgentTaskManager
+     */
+    private stopAgentTask;
+    /**
+     * Stop a background shell task via ToolManager
+     */
+    private stopBackgroundShellTask;
+    private currentMainSessionId;
+    private formatDuration;
+}
+export {};

package/cli/dist-server/types/node/tools/task-storage-service.d.ts

@@ -0,0 +1,161 @@
+import { Logger } from '../../workspace/telemetry/lib/common/index.js';
+import { FileLockService } from '../lock';
+/**
+ * Task item structure - aligned with Claude Code TaskCreate/TaskUpdate tools
+ */
+export interface TaskItem {
+    /** Unique task identifier */
+    id: string;
+    /** Brief title for the task (imperative form) */
+    subject: string;
+    /** Detailed description of what needs to be done */
+    description: string;
+    /** Present continuous form shown in spinner when in_progress */
+    activeForm?: string;
+    /** Task status */
+    status: 'pending' | 'in_progress' | 'completed';
+    /** Task owner (agent name) */
+    owner?: string;
+    /** Arbitrary metadata */
+    metadata?: Record<string, unknown>;
+    /** Task IDs that this task blocks (cannot start until this completes) */
+    blocks?: string[];
+    /** Task IDs that block this task (must complete before this can start) */
+    blockedBy?: string[];
+    /** Creation timestamp */
+    createdAt: number;
+    /** Last update timestamp */
+    updatedAt: number;
+}
+/**
+ * A stable TaskStorage snapshot used by the ACP v2 plan projector.
+ *
+ * `revision` is private transport state, not part of the ACP plan wire shape.
+ * It lets a client channel reject an older concurrent tool result that arrives
+ * after a newer replacing snapshot.
+ */
+export interface TaskStorageSnapshot {
+    sourceId: string;
+    revision: string;
+    tasks: TaskItem[];
+}
+export declare const TaskStorageService: unique symbol;
+/**
+ * Interface for Task list persistence - aligned with Claude Code TaskCreate/TaskGet/TaskUpdate/TaskList
+ */
+export interface TaskStorageService {
+    /**
+     * Create a new task
+     * @param sessionId The session ID
+     * @param task The task to create (id will be auto-generated)
+     * @returns The created task with assigned ID
+     */
+    create(sessionId: string, task: Omit<TaskItem, 'id' | 'createdAt' | 'updatedAt'>): Promise<TaskItem>;
+    /**
+     * Get a task by ID
+     * @param sessionId The session ID
+     * @param taskId The task ID
+     * @returns The task or undefined if not found
+     */
+    get(sessionId: string, taskId: string): Promise<TaskItem | undefined>;
+    /**
+     * Update a task
+     * @param sessionId The session ID
+     * @param taskId The task ID
+     * @param updates The fields to update
+     * @returns The updated task or undefined if not found
+     */
+    update(sessionId: string, taskId: string, updates: Partial<Omit<TaskItem, 'id' | 'createdAt'>>): Promise<TaskItem | undefined>;
+    /**
+     * Delete a task
+     * @param sessionId The session ID
+     * @param taskId The task ID
+     * @returns true if deleted, false if not found
+     */
+    delete(sessionId: string, taskId: string): Promise<boolean>;
+    /**
+     * List all tasks
+     * @param sessionId The session ID
+     * @returns Array of all tasks
+     */
+    list(sessionId: string): Promise<TaskItem[]>;
+    /**
+     * Best-effort, strictly read a full snapshot under the storage lock and
+     * assign it a private monotonic revision. Capture failure returns
+     * undefined instead of changing the Task tool result.
+     */
+    listSnapshot(sessionId: string): Promise<TaskStorageSnapshot | undefined>;
+    /**
+     * Get the directory path for a session's tasks
+     * @param sessionId The session ID
+     */
+    getTaskDir(sessionId: string): string;
+}
+export declare class TaskStorageServiceImpl implements TaskStorageService {
+    protected readonly logger: Logger;
+    protected readonly fileLockService: FileLockService;
+    /**
+     * Get the base directory for task storage
+     */
+    protected getTasksBaseDir(): string;
+    /**
+     * Get the directory path for a session's tasks
+     */
+    getTaskDir(sessionId: string): string;
+    /**
+     * Get the file path for a specific task
+     */
+    protected getTaskFilePath(sessionId: string, taskId: string): string;
+    private getSnapshotRevisionFilePath;
+    /**
+     * Get the lock name for a session's tasks
+     */
+    protected getSessionLockName(sessionId: string): string;
+    /**
+     * Ensure the session's task directory exists
+     */
+    protected ensureTaskDir(sessionId: string): Promise<void>;
+    /**
+     * Get next available task ID by scanning existing files
+     * Note: This must be called within a lock to prevent race conditions
+     */
+    protected getNextId(sessionId: string): Promise<number>;
+    /**
+     * Load a single task from file
+     */
+    protected loadTaskFile(sessionId: string, taskId: string): Promise<TaskItem | undefined>;
+    /**
+     * Save a single task to file using atomic write (write to temp, then rename)
+     */
+    protected saveTaskFile(sessionId: string, task: TaskItem): Promise<void>;
+    /**
+     * Delete a task file
+     */
+    protected deleteTaskFile(sessionId: string, taskId: string): Promise<boolean>;
+    /**
+     * Create a new task
+     */
+    create(sessionId: string, task: Omit<TaskItem, 'id' | 'createdAt' | 'updatedAt'>): Promise<TaskItem>;
+    /**
+     * Get a task by ID
+     */
+    get(sessionId: string, taskId: string): Promise<TaskItem | undefined>;
+    /**
+     * Update a task
+     */
+    update(sessionId: string, taskId: string, updates: Partial<Omit<TaskItem, 'id' | 'createdAt'>>): Promise<TaskItem | undefined>;
+    /**
+     * Delete a task
+     */
+    delete(sessionId: string, taskId: string): Promise<boolean>;
+    /**
+     * List all tasks
+     */
+    list(sessionId: string): Promise<TaskItem[]>;
+    listSnapshot(sessionId: string): Promise<TaskStorageSnapshot | undefined>;
+    private readSnapshotRevision;
+    private advanceSnapshotRevision;
+    private listSnapshotUnlocked;
+    private isTaskItem;
+    private listUnlocked;
+}

package/cli/dist-server/types/node/tools/task-update-tool.d.ts

@@ -0,0 +1,79 @@
+import { Session } from '../../vendor/cbc-core/node/index.js';
+import { RunContext, ToolNames } from '../../vendor/cbc-shared/node/index.js';
+import { Logger } from '../../workspace/telemetry/lib/common/index.js';
+import { z } from 'zod';
+import { BaseTool } from './base-tool';
+import { TaskStorageService } from './task-storage-service';
+import { Tool, ToolCallArgumentRenderer, ToolResult } from './tool-protocol';
+declare const TaskUpdateParameters: z.ZodObject<{
+    taskId: z.ZodString;
+    subject: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    activeForm: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<["pending", "in_progress", "completed", "deleted"]>>;
+    addBlocks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    addBlockedBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    owner: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    taskId: string;
+    description?: string | undefined;
+    status?: "pending" | "in_progress" | "completed" | "deleted" | undefined;
+    owner?: string | undefined;
+    subject?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    activeForm?: string | undefined;
+    addBlocks?: string[] | undefined;
+    addBlockedBy?: string[] | undefined;
+}, {
+    taskId: string;
+    description?: string | undefined;
+    status?: "pending" | "in_progress" | "completed" | "deleted" | undefined;
+    owner?: string | undefined;
+    subject?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    activeForm?: string | undefined;
+    addBlocks?: string[] | undefined;
+    addBlockedBy?: string[] | undefined;
+}>;
+export declare class TaskUpdateTool extends BaseTool implements Tool {
+    protected readonly taskStorageService: TaskStorageService;
+    protected readonly logger: Logger;
+    name: ToolNames;
+    parameters: z.ZodObject<{
+        taskId: z.ZodString;
+        subject: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        activeForm: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodEnum<["pending", "in_progress", "completed", "deleted"]>>;
+        addBlocks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        addBlockedBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        owner: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        taskId: string;
+        description?: string | undefined;
+        status?: "pending" | "in_progress" | "completed" | "deleted" | undefined;
+        owner?: string | undefined;
+        subject?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        activeForm?: string | undefined;
+        addBlocks?: string[] | undefined;
+        addBlockedBy?: string[] | undefined;
+    }, {
+        taskId: string;
+        description?: string | undefined;
+        status?: "pending" | "in_progress" | "completed" | "deleted" | undefined;
+        owner?: string | undefined;
+        subject?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        activeForm?: string | undefined;
+        addBlocks?: string[] | undefined;
+        addBlockedBy?: string[] | undefined;
+    }>;
+    argumentRenderer: ToolCallArgumentRenderer;
+    needsApproval: boolean;
+    execute(input: z.infer<typeof TaskUpdateParameters>, context?: RunContext<Session>): Promise<ToolResult>;
+    private buildCompletionGuidance;
+}
+export {};

package/cli/dist-server/types/node/tools/team-create-tool.d.ts

@@ -0,0 +1,84 @@
+import { Session } from '../../vendor/cbc-core/node/index.js';
+import { RunContext, ToolNames } from '../../vendor/cbc-shared/node/index.js';
+import { Logger } from '../../workspace/telemetry/lib/common/index.js';
+import { z } from 'zod';
+import { TeamMemberRegistry } from '../agent-team/team-member';
+import { BaseTool } from './base-tool';
+import { Tool, ToolCallArgumentRenderer, ToolResult } from './tool-protocol';
+export declare function getTeamMemberRegistry(): TeamMemberRegistry;
+export declare function stopTeamLeadPoller(): void;
+export declare function setLeadInboxPaused(session: Session, paused: boolean): void;
+export declare function isLeadInboxPaused(session: Session): boolean;
+/**
+ * Pause all team-internal follow-up dispatch into the lead session after cancel.
+ *
+ * Two independent wake-up sources must be gated together:
+ * 1. lead inbox polling (future teammate/framework messages)
+ * 2. rich queue auto-dispatch (items already queued before cancel)
+ *
+ * Messages are preserved; they are only deferred until the next explicit user
+ * prompt resumes the flow.
+ */
+export declare function pauseTeamLeadFollowUpDispatch(session: Session): void;
+/**
+ * Resume team-internal follow-up dispatch when the user explicitly starts a new
+ * turn after cancel.
+ */
+export declare function resumeTeamLeadFollowUpDispatch(session: Session): void;
+/**
+ * Start polling team-lead's inbox for messages from teammates.
+ *
+ * Idempotent: if polling is already active, this is a no-op.
+ *
+ * - Always pushes to session.inputSubject for UI rendering.
+ * - If the main agent is running → enqueue message so it gets picked up
+ *   in the current turn.
+ * - If the main agent is idle → trigger a new agent turn via AgentService.run
+ *   so the agent processes the teammate's message immediately.
+ *
+ * Also registers this session with the TeamInboxDispatchService so that, when
+ * the lead finishes the current turn (`agent_end`), any items queued during
+ * that turn get auto-activated into a new independent run. Without this,
+ * Mode B messages would sit in the rich queue with nobody to dispatch them.
+ */
+export declare function startTeamLeadInboxPolling(teamName: string, session: Session): void;
+/**
+ * TeamCreate tool - creates a new team for multi-agent collaboration.
+ *
+ * Creates:
+ *   ~/.codebuddy/teams/{team-name}/config.json
+ *   ~/.codebuddy/teams/{team-name}/inboxes/
+ *   ~/.codebuddy/tasks/{team-name}/
+ */
+export declare class TeamCreateTool extends BaseTool implements Tool {
+    protected readonly logger: Logger;
+    name: ToolNames;
+    description: string;
+    parameters: z.ZodObject<{
+        team_name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        agent_type: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        team_name: string;
+        description?: string | undefined;
+        agent_type?: string | undefined;
+    }, {
+        team_name: string;
+        description?: string | undefined;
+        agent_type?: string | undefined;
+    }>;
+    argumentRenderer: ToolCallArgumentRenderer;
+    needsApproval: boolean;
+    /**
+     * Keep deferred-tool discovery aligned with the runtime feature gate.
+     * Otherwise TeamCreate remains visible in ToolSearch after Agent Teams is disabled.
+     */
+    shouldShowInToolSearch: () => boolean;
+    isEnabled: () => boolean;
+    private isAgentTeamsEnabled;
+    execute(input: {
+        team_name: string;
+        description?: string;
+        agent_type?: string;
+    }, context?: RunContext<Session>): Promise<ToolResult>;
+}

package/cli/dist-server/types/node/tools/team-delete-tool.d.ts

@@ -0,0 +1,38 @@
+import { Logger } from '../../workspace/telemetry/lib/common/index.js';
+import { z } from 'zod';
+import { RunContext } from '../../vendor/cbc-shared/node/index.js';
+import { Session } from '../../vendor/cbc-core/node/index.js';
+import { BaseTool } from './base-tool';
+import { Tool, ToolResult } from './tool-protocol';
+import { ToolNames } from '../../vendor/cbc-shared/node/index.js';
+/**
+ * TeamDelete tool - removes team and task directories.
+ *
+ * Refuses if the team still has truly-active members (i.e. teammates whose
+ * `isActive()` returns true: in-process tasks in `running`/`pending` state,
+ * or out-of-process backends that have not yet reported finished). Idle /
+ * completed teammates do NOT block deletion — they have no in-flight work
+ * to lose.
+ *
+ * The team name is automatically determined from the current session's team context.
+ *
+ * Behaviour aligned with Claude Code's `TeamDeleteTool` (gh-32730 era):
+ * the lead is expected to send `shutdown_request` via SendMessage first,
+ * wait for `shutdown_response` (which marks members idle), then call
+ * TeamDelete. This prevents accidentally killing teammates mid-task.
+ */
+export declare class TeamDeleteTool extends BaseTool implements Tool {
+    protected readonly logger: Logger;
+    name: ToolNames;
+    description: string;
+    /**
+     * Keep deferred-tool discovery aligned with the runtime feature gate.
+     * Otherwise TeamDelete remains visible in ToolSearch after Agent Teams is disabled.
+     */
+    shouldShowInToolSearch: () => boolean;
+    parameters: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    needsApproval: boolean;
+    isEnabled: () => boolean;
+    private isAgentTeamsEnabled;
+    execute(_input: Record<string, never>, context?: RunContext<Session>): Promise<ToolResult>;
+}

package/cli/dist-server/types/node/tools/todo-storage-service.d.ts

@@ -0,0 +1,48 @@
+import { Logger } from '../../workspace/telemetry/lib/common/index.js';
+import { TodoToolItem } from './tool-protocol';
+export declare const TodoStorageService: unique symbol;
+/**
+ * Interface for Todo list persistence
+ */
+export interface TodoStorageService {
+    /**
+     * Save todo list for a session
+     * @param sessionId The session ID
+     * @param todos The todo items to save
+     */
+    save(sessionId: string, todos: TodoToolItem[]): Promise<void>;
+    /**
+     * Load todo list for a session
+     * @param sessionId The session ID
+     * @returns The todo items or undefined if not found
+     */
+    load(sessionId: string): Promise<TodoToolItem[] | undefined>;
+    /**
+     * Get the file path for a session's todo list
+     * @param sessionId The session ID
+     */
+    getTodoFilePath(sessionId: string): string;
+}
+export declare class TodoStorageServiceImpl implements TodoStorageService {
+    protected readonly logger: Logger;
+    /**
+     * Get the base directory for todo storage
+     */
+    protected getTodosDir(): string;
+    /**
+     * Get the file path for a session's todo list
+     */
+    getTodoFilePath(sessionId: string): string;
+    /**
+     * Ensure the todos directory exists
+     */
+    protected ensureTodosDir(): Promise<void>;
+    /**
+     * Save todo list for a session
+     */
+    save(sessionId: string, todos: TodoToolItem[]): Promise<void>;
+    /**
+     * Load todo list for a session
+     */
+    load(sessionId: string): Promise<TodoToolItem[] | undefined>;
+}