minimal-agent 0.11.0 → 0.13.0

package/src/tools/tasks/taskManagement.js

@@ -0,0 +1,163 @@
+import { z } from 'zod';
+import { toToolParameters } from '../../utils/zodToJson.js';
+import { assertNoDependencyCycle, effectiveTaskStatus, listManagedTasks, mutateManagedTasks, newTaskId, } from './taskStore.js';
+const id = z.string().regex(/^task_[0-9a-f-]{36}$/i);
+const createSchema = z.object({
+    title: z.string().min(1).max(200),
+    description: z.string().max(5000).optional(),
+    activeForm: z.string().max(200).optional(),
+    owner: z.string().max(120).optional(),
+    blockedBy: z.array(id).default([]).optional(),
+    metadata: z.record(z.unknown()).optional(),
+});
+const getSchema = z.object({ task_id: id });
+const updateSchema = z.object({
+    task_id: id,
+    title: z.string().min(1).max(200).optional(),
+    description: z.string().max(5000).optional(),
+    activeForm: z.string().max(200).optional(),
+    owner: z.string().max(120).optional(),
+    blockedBy: z.array(id).optional(),
+    status: z.enum(['pending', 'in_progress', 'completed', 'deleted']).optional(),
+    metadata: z.record(z.unknown()).optional(),
+});
+const listSchema = z.object({
+    status: z.enum(['pending', 'in_progress', 'completed', 'blocked']).optional(),
+    include_completed: z.boolean().default(false).optional(),
+});
+function render(task, all) {
+    return `${task.id} [${effectiveTaskStatus(task, all)}] ${task.title}${task.blockedBy.length ? ` (blockedBy: ${task.blockedBy.join(', ')})` : ''}`;
+}
+export const taskCreateTool = {
+    name: 'TaskCreate',
+    description: 'Creates a durable structured task in the current workspace/session. Use for multi-step work that must survive context compression or another user turn.',
+    inputSchema: createSchema,
+    parameters: toToolParameters(createSchema),
+    isReadOnly: false,
+    isConcurrencySafe: false,
+    call: async () => ({
+        ok: false,
+        error: 'TaskCreate requires session context',
+    }),
+    callWithContext: async (input, _s, ctx) => {
+        const now = Date.now();
+        const task = {
+            id: newTaskId(),
+            title: input.title,
+            description: input.description,
+            activeForm: input.activeForm,
+            owner: input.owner,
+            status: 'pending',
+            blockedBy: input.blockedBy ?? [],
+            metadata: input.metadata,
+            createdAt: now,
+            updatedAt: now,
+        };
+        try {
+            const tasks = await mutateManagedTasks(ctx, (items) => {
+                const next = [...items, task];
+                assertNoDependencyCycle(next);
+                return next;
+            });
+            return { ok: true, content: `已创建 ${render(task, tasks)}` };
+        }
+        catch (e) {
+            return { ok: false, error: e.message };
+        }
+    },
+};
+export const taskGetTool = {
+    name: 'TaskGet',
+    description: 'Reads one durable task and its dependency state.',
+    inputSchema: getSchema,
+    parameters: toToolParameters(getSchema),
+    isReadOnly: true,
+    isConcurrencySafe: true,
+    call: async () => ({ ok: false, error: 'TaskGet requires session context' }),
+    callWithContext: async (input, _s, ctx) => {
+        const tasks = await listManagedTasks(ctx);
+        const task = tasks.find((t) => t.id === input.task_id);
+        return task
+            ? {
+                ok: true,
+                content: JSON.stringify({ ...task, effectiveStatus: effectiveTaskStatus(task, tasks) }, null, 2),
+            }
+            : { ok: false, error: `任务不存在：${input.task_id}` };
+    },
+};
+export const taskUpdateTool = {
+    name: 'TaskUpdate',
+    description: 'Updates task status, dependencies or details. status=deleted removes only the task record and never project files.',
+    inputSchema: updateSchema,
+    parameters: toToolParameters(updateSchema),
+    isReadOnly: false,
+    isConcurrencySafe: false,
+    call: async () => ({
+        ok: false,
+        error: 'TaskUpdate requires session context',
+    }),
+    callWithContext: async (input, _s, ctx) => {
+        try {
+            let found = false;
+            const tasks = await mutateManagedTasks(ctx, (items) => {
+                const target = items.find((t) => t.id === input.task_id);
+                if (!target)
+                    return items;
+                found = true;
+                if (input.status === 'deleted') {
+                    if (items.some((t) => t.blockedBy.includes(target.id)))
+                        throw new Error('仍有任务依赖它，不能删除');
+                    return items.filter((t) => t.id !== target.id);
+                }
+                Object.assign(target, {
+                    ...(input.title !== undefined && { title: input.title }),
+                    ...(input.description !== undefined && {
+                        description: input.description,
+                    }),
+                    ...(input.activeForm !== undefined && {
+                        activeForm: input.activeForm,
+                    }),
+                    ...(input.owner !== undefined && { owner: input.owner }),
+                    ...(input.blockedBy !== undefined && { blockedBy: input.blockedBy }),
+                    ...(input.status !== undefined && { status: input.status }),
+                    ...(input.metadata !== undefined && { metadata: input.metadata }),
+                    updatedAt: Date.now(),
+                });
+                assertNoDependencyCycle(items);
+                return items;
+            });
+            if (!found)
+                return { ok: false, error: `任务不存在：${input.task_id}` };
+            const task = tasks.find((t) => t.id === input.task_id);
+            return {
+                ok: true,
+                content: task
+                    ? `已更新 ${render(task, tasks)}`
+                    : `已删除任务记录 ${input.task_id}`,
+            };
+        }
+        catch (e) {
+            return { ok: false, error: e.message };
+        }
+    },
+};
+export const taskListTool = {
+    name: 'TaskList',
+    description: 'Lists active durable tasks and dependency blockers. Completed tasks are hidden by default.',
+    inputSchema: listSchema,
+    parameters: toToolParameters(listSchema),
+    isReadOnly: true,
+    isConcurrencySafe: true,
+    call: async () => ({ ok: false, error: 'TaskList requires session context' }),
+    callWithContext: async (input, _s, ctx) => {
+        const tasks = await listManagedTasks(ctx);
+        const selected = tasks.filter((t) => (input.include_completed || t.status !== 'completed') &&
+            (!input.status || effectiveTaskStatus(t, tasks) === input.status));
+        return {
+            ok: true,
+            content: selected.length
+                ? selected.map((t) => render(t, tasks)).join('\n')
+                : '(no matching tasks)',
+        };
+    },
+};

package/src/tools/tasks/taskManagement.ts

@@ -0,0 +1,180 @@
+import { z } from 'zod';
+import type { Tool, ToolCallContext, ToolResult } from '../../types.js';
+import { toToolParameters } from '../../utils/zodToJson.js';
+import {
+  assertNoDependencyCycle,
+  effectiveTaskStatus,
+  listManagedTasks,
+  mutateManagedTasks,
+  newTaskId,
+  type ManagedTask,
+  type ManagedTaskStatus,
+} from './taskStore.js';
+
+const id = z.string().regex(/^task_[0-9a-f-]{36}$/i);
+const createSchema = z.object({
+  title: z.string().min(1).max(200),
+  description: z.string().max(5000).optional(),
+  activeForm: z.string().max(200).optional(),
+  owner: z.string().max(120).optional(),
+  blockedBy: z.array(id).default([]).optional(),
+  metadata: z.record(z.unknown()).optional(),
+});
+const getSchema = z.object({ task_id: id });
+const updateSchema = z.object({
+  task_id: id,
+  title: z.string().min(1).max(200).optional(),
+  description: z.string().max(5000).optional(),
+  activeForm: z.string().max(200).optional(),
+  owner: z.string().max(120).optional(),
+  blockedBy: z.array(id).optional(),
+  status: z.enum(['pending', 'in_progress', 'completed', 'deleted']).optional(),
+  metadata: z.record(z.unknown()).optional(),
+});
+const listSchema = z.object({
+  status: z.enum(['pending', 'in_progress', 'completed', 'blocked']).optional(),
+  include_completed: z.boolean().default(false).optional(),
+});
+
+function render(task: ManagedTask, all: ManagedTask[]): string {
+  return `${task.id} [${effectiveTaskStatus(task, all)}] ${task.title}${task.blockedBy.length ? ` (blockedBy: ${task.blockedBy.join(', ')})` : ''}`;
+}
+export const taskCreateTool: Tool<z.infer<typeof createSchema>> = {
+  name: 'TaskCreate',
+  description:
+    'Creates a durable structured task in the current workspace/session. Use for multi-step work that must survive context compression or another user turn.',
+  inputSchema: createSchema,
+  parameters: toToolParameters(createSchema),
+  isReadOnly: false,
+  isConcurrencySafe: false,
+  call: async () => ({
+    ok: false,
+    error: 'TaskCreate requires session context',
+  }),
+  callWithContext: async (input, _s, ctx) => {
+    const now = Date.now();
+    const task = {
+      id: newTaskId(),
+      title: input.title,
+      description: input.description,
+      activeForm: input.activeForm,
+      owner: input.owner,
+      status: 'pending' as ManagedTaskStatus,
+      blockedBy: input.blockedBy ?? [],
+      metadata: input.metadata,
+      createdAt: now,
+      updatedAt: now,
+    };
+    try {
+      const tasks = await mutateManagedTasks(ctx, (items) => {
+        const next = [...items, task];
+        assertNoDependencyCycle(next);
+        return next;
+      });
+      return { ok: true, content: `已创建 ${render(task, tasks)}` };
+    } catch (e) {
+      return { ok: false, error: (e as Error).message };
+    }
+  },
+};
+export const taskGetTool: Tool<z.infer<typeof getSchema>> = {
+  name: 'TaskGet',
+  description: 'Reads one durable task and its dependency state.',
+  inputSchema: getSchema,
+  parameters: toToolParameters(getSchema),
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  call: async () => ({ ok: false, error: 'TaskGet requires session context' }),
+  callWithContext: async (input, _s, ctx) => {
+    const tasks = await listManagedTasks(ctx);
+    const task = tasks.find((t) => t.id === input.task_id);
+    return task
+      ? {
+          ok: true,
+          content: JSON.stringify(
+            { ...task, effectiveStatus: effectiveTaskStatus(task, tasks) },
+            null,
+            2,
+          ),
+        }
+      : { ok: false, error: `任务不存在：${input.task_id}` };
+  },
+};
+export const taskUpdateTool: Tool<z.infer<typeof updateSchema>> = {
+  name: 'TaskUpdate',
+  description:
+    'Updates task status, dependencies or details. status=deleted removes only the task record and never project files.',
+  inputSchema: updateSchema,
+  parameters: toToolParameters(updateSchema),
+  isReadOnly: false,
+  isConcurrencySafe: false,
+  call: async () => ({
+    ok: false,
+    error: 'TaskUpdate requires session context',
+  }),
+  callWithContext: async (input, _s, ctx) => {
+    try {
+      let found = false;
+      const tasks = await mutateManagedTasks(ctx, (items) => {
+        const target = items.find((t) => t.id === input.task_id);
+        if (!target) return items;
+        found = true;
+        if (input.status === 'deleted') {
+          if (items.some((t) => t.blockedBy.includes(target.id)))
+            throw new Error('仍有任务依赖它，不能删除');
+          return items.filter((t) => t.id !== target.id);
+        }
+        Object.assign(target, {
+          ...(input.title !== undefined && { title: input.title }),
+          ...(input.description !== undefined && {
+            description: input.description,
+          }),
+          ...(input.activeForm !== undefined && {
+            activeForm: input.activeForm,
+          }),
+          ...(input.owner !== undefined && { owner: input.owner }),
+          ...(input.blockedBy !== undefined && { blockedBy: input.blockedBy }),
+          ...(input.status !== undefined && { status: input.status }),
+          ...(input.metadata !== undefined && { metadata: input.metadata }),
+          updatedAt: Date.now(),
+        });
+        assertNoDependencyCycle(items);
+        return items;
+      });
+      if (!found) return { ok: false, error: `任务不存在：${input.task_id}` };
+      const task = tasks.find((t) => t.id === input.task_id);
+      return {
+        ok: true,
+        content: task
+          ? `已更新 ${render(task, tasks)}`
+          : `已删除任务记录 ${input.task_id}`,
+      };
+    } catch (e) {
+      return { ok: false, error: (e as Error).message };
+    }
+  },
+};
+export const taskListTool: Tool<z.infer<typeof listSchema>> = {
+  name: 'TaskList',
+  description:
+    'Lists active durable tasks and dependency blockers. Completed tasks are hidden by default.',
+  inputSchema: listSchema,
+  parameters: toToolParameters(listSchema),
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  call: async () => ({ ok: false, error: 'TaskList requires session context' }),
+  callWithContext: async (input, _s, ctx) => {
+    const tasks = await listManagedTasks(ctx);
+    const selected = tasks.filter(
+      (t) =>
+        (input.include_completed || t.status !== 'completed') &&
+        (!input.status || effectiveTaskStatus(t, tasks) === input.status),
+    );
+    return {
+      ok: true,
+      content: selected.length
+        ? selected.map((t) => render(t, tasks)).join('\n')
+        : '(no matching tasks)',
+    };
+  },
+};

package/src/tools/tasks/taskOutput.js

@@ -1,28 +1,78 @@
 import { z } from 'zod';
 import { toToolParameters } from '../../utils/zodToJson.js';
 import { DEFAULT_MAX_RESULT_SIZE_CHARS } from '../types.js';
-import { getBackgroundTask, readTaskLog } from './backgroundTaskService.js';
+import { getBackgroundTask, readTaskLog, } from './backgroundTaskService.js';
 import { processExecutionMetadata } from './processEvidence.js';
+import { getLiveAgentTask, loadAgentRecord, } from '../agent/agentTaskService.js';
 const inputSchema = z.object({
-    task_id: z.string().uuid(),
-    offset: z.number().int().nonnegative().optional().describe('从该字节偏移读取；使用上次返回的 next_offset 增量读取'),
-    tail_chars: z.number().int().min(1).max(DEFAULT_MAX_RESULT_SIZE_CHARS).optional(),
-    block: z.boolean().optional().describe('任务仍运行时，是否等待新输出或任务结束'),
-    timeout: z.number().int().min(1).max(120_000).optional().describe('block=true 时的最长等待毫秒数'),
+    task_id: z.string().regex(/^(?:proc_|agent_)?[0-9a-f-]{36}$/i),
+    offset: z
+        .number()
+        .int()
+        .nonnegative()
+        .optional()
+        .describe('从该字节偏移读取；使用上次返回的 next_offset 增量读取'),
+    tail_chars: z
+        .number()
+        .int()
+        .min(1)
+        .max(DEFAULT_MAX_RESULT_SIZE_CHARS)
+        .optional(),
+    block: z
+        .boolean()
+        .optional()
+        .describe('任务仍运行时，是否等待新输出或任务结束'),
+    timeout: z
+        .number()
+        .int()
+        .min(1)
+        .max(120_000)
+        .optional()
+        .describe('block=true 时的最长等待毫秒数'),
 });
 async function waitForChange(task, offset, timeout) {
-    if (task.status !== 'running' || readTaskLog(task, offset, 1).totalBytes > offset)
+    if (task.status !== 'running' ||
+        readTaskLog(task, offset, 1).totalBytes > offset)
         return;
     await new Promise((resolvePromise) => {
-        const done = () => { clearTimeout(timer); task.events.off('change', done); resolvePromise(); };
+        const done = () => {
+            clearTimeout(timer);
+            task.events.off('change', done);
+            resolvePromise();
+        };
         const timer = setTimeout(done, timeout);
         timer.unref?.();
         task.events.once('change', done);
-        if (task.status !== 'running' || readTaskLog(task, offset, 1).totalBytes > offset)
+        if (task.status !== 'running' ||
+            readTaskLog(task, offset, 1).totalBytes > offset)
             done();
     });
 }
-async function call(input, state) {
+async function call(input, state, context) {
+    if (input.task_id.startsWith('agent_') && context) {
+        const live = getLiveAgentTask(context.sessionState?.agentTasks, input.task_id);
+        const record = live ?? (await loadAgentRecord(context, input.task_id));
+        if (!record)
+            return { ok: false, error: `当前会话中不存在 Agent ${input.task_id}` };
+        if (input.block && live?.status === 'running')
+            await Promise.race([
+                live.completion,
+                new Promise((r) => setTimeout(r, input.timeout ?? 30_000)),
+            ]);
+        const current = getLiveAgentTask(context.sessionState?.agentTasks, input.task_id) ??
+            (await loadAgentRecord(context, input.task_id)) ??
+            record;
+        const body = current.result
+            ? current.result.ok
+                ? current.result.content
+                : current.result.error
+            : (current.progress ?? '<agent is still running>');
+        return {
+            ok: true,
+            content: `${body}\n\n[agent ${current.id}: ${current.status}]`,
+            metadata: current.result?.metadata,
+        };
+    }
     const task = getBackgroundTask(input.task_id, state);
     if (!task)
         return { ok: false, error: `当前会话中不存在后台任务 ${input.task_id}` };
@@ -33,7 +83,7 @@ async function call(input, state) {
     const text = output.text || '<no new output>';
     return {
         ok: true,
-        content: `${text}\n\n[task ${task.id}: ${task.status}; exit=${task.exitCode ?? 'pending'}; next_offset=${output.nextOffset}; total_bytes=${output.totalBytes}]`,
+        content: `${text}\n\n[task ${task.id}: ${task.status}; exit=${task.exitCode ?? 'pending'}; next_offset=${output.nextOffset}; total_bytes=${output.totalBytes}${task.outputSha256 ? `; sha256=${task.outputSha256}; complete=${task.complete}` : ''}; log=${task.logPath}]`,
         metadata: processExecutionMetadata({
             shell: task.shell,
             mode: 'background',
@@ -52,12 +102,12 @@ async function call(input, state) {
 }
 export const taskOutputTool = {
     name: 'TaskOutput',
-    description: 'Reads incremental output from a Bash or PowerShell background task in the current session. Use block=true to wait efficiently for new output or completion instead of polling repeatedly.',
+    description: 'Reads incremental output from a Bash/PowerShell process or progress/results from an Agent task in the current session. Use block=true to wait efficiently instead of polling repeatedly.',
     inputSchema,
     parameters: toToolParameters(inputSchema),
     isReadOnly: true,
     isConcurrencySafe: true,
     maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
-    call: (input) => call(input),
-    callWithContext: (input, _signal, context) => call(input, context.sessionState?.backgroundTasks),
+    call: (input) => call(input, undefined),
+    callWithContext: (input, _signal, context) => call(input, context.sessionState?.backgroundTasks, context),
 };

package/src/tools/tasks/taskOutput.ts

@@ -3,51 +3,128 @@ import { z } from 'zod';
 import type { Tool, ToolCallContext, ToolResult } from '../../types.js';
 import { toToolParameters } from '../../utils/zodToJson.js';
 import { DEFAULT_MAX_RESULT_SIZE_CHARS } from '../types.js';
-import { getBackgroundTask, readTaskLog, type BackgroundTaskState } from './backgroundTaskService.js';
+import {
+  getBackgroundTask,
+  readTaskLog,
+  type BackgroundTaskState,
+} from './backgroundTaskService.js';
 import { processExecutionMetadata } from './processEvidence.js';
+import {
+  getLiveAgentTask,
+  loadAgentRecord,
+} from '../agent/agentTaskService.js';
 
 const inputSchema = z.object({
-  task_id: z.string().uuid(),
-  offset: z.number().int().nonnegative().optional().describe('从该字节偏移读取；使用上次返回的 next_offset 增量读取'),
-  tail_chars: z.number().int().min(1).max(DEFAULT_MAX_RESULT_SIZE_CHARS).optional(),
-  block: z.boolean().optional().describe('任务仍运行时，是否等待新输出或任务结束'),
-  timeout: z.number().int().min(1).max(120_000).optional().describe('block=true 时的最长等待毫秒数'),
+  task_id: z.string().regex(/^(?:proc_|agent_)?[0-9a-f-]{36}$/i),
+  offset: z
+    .number()
+    .int()
+    .nonnegative()
+    .optional()
+    .describe('从该字节偏移读取；使用上次返回的 next_offset 增量读取'),
+  tail_chars: z
+    .number()
+    .int()
+    .min(1)
+    .max(DEFAULT_MAX_RESULT_SIZE_CHARS)
+    .optional(),
+  block: z
+    .boolean()
+    .optional()
+    .describe('任务仍运行时，是否等待新输出或任务结束'),
+  timeout: z
+    .number()
+    .int()
+    .min(1)
+    .max(120_000)
+    .optional()
+    .describe('block=true 时的最长等待毫秒数'),
 });
 type TaskOutputInput = z.infer<typeof inputSchema>;
 
-async function waitForChange(task: NonNullable<ReturnType<typeof getBackgroundTask>>, offset: number, timeout: number): Promise<void> {
-  if (task.status !== 'running' || readTaskLog(task, offset, 1).totalBytes > offset) return;
+async function waitForChange(
+  task: NonNullable<ReturnType<typeof getBackgroundTask>>,
+  offset: number,
+  timeout: number,
+): Promise<void> {
+  if (
+    task.status !== 'running' ||
+    readTaskLog(task, offset, 1).totalBytes > offset
+  )
+    return;
   await new Promise<void>((resolvePromise) => {
-    const done = () => { clearTimeout(timer); task.events.off('change', done); resolvePromise(); };
+    const done = () => {
+      clearTimeout(timer);
+      task.events.off('change', done);
+      resolvePromise();
+    };
     const timer = setTimeout(done, timeout);
     timer.unref?.();
     task.events.once('change', done);
-    if (task.status !== 'running' || readTaskLog(task, offset, 1).totalBytes > offset) done();
+    if (
+      task.status !== 'running' ||
+      readTaskLog(task, offset, 1).totalBytes > offset
+    )
+      done();
   });
 }
 
-async function call(input: TaskOutputInput, state?: BackgroundTaskState): Promise<ToolResult> {
+async function call(
+  input: TaskOutputInput,
+  state: BackgroundTaskState | undefined,
+  context?: ToolCallContext,
+): Promise<ToolResult> {
+  if (input.task_id.startsWith('agent_') && context) {
+    const live = getLiveAgentTask(
+      context.sessionState?.agentTasks,
+      input.task_id,
+    );
+    const record = live ?? (await loadAgentRecord(context, input.task_id));
+    if (!record)
+      return { ok: false, error: `当前会话中不存在 Agent ${input.task_id}` };
+    if (input.block && live?.status === 'running')
+      await Promise.race([
+        live.completion,
+        new Promise<void>((r) => setTimeout(r, input.timeout ?? 30_000)),
+      ]);
+    const current =
+      getLiveAgentTask(context.sessionState?.agentTasks, input.task_id) ??
+      (await loadAgentRecord(context, input.task_id)) ??
+      record;
+    const body = current.result
+      ? current.result.ok
+        ? current.result.content
+        : current.result.error
+      : (current.progress ?? '<agent is still running>');
+    return {
+      ok: true,
+      content: `${body}\n\n[agent ${current.id}: ${current.status}]`,
+      metadata: current.result?.metadata,
+    };
+  }
   const task = getBackgroundTask(input.task_id, state);
-  if (!task) return { ok: false, error: `当前会话中不存在后台任务 ${input.task_id}` };
+  if (!task)
+    return { ok: false, error: `当前会话中不存在后台任务 ${input.task_id}` };
   const offset = input.offset ?? 0;
   if (input.block) await waitForChange(task, offset, input.timeout ?? 30_000);
   const output = readTaskLog(task, offset, input.tail_chars ?? 20_000);
   const text = output.text || '<no new output>';
   return {
     ok: true,
-    content: `${text}\n\n[task ${task.id}: ${task.status}; exit=${task.exitCode ?? 'pending'}; next_offset=${output.nextOffset}; total_bytes=${output.totalBytes}]`,
+    content: `${text}\n\n[task ${task.id}: ${task.status}; exit=${task.exitCode ?? 'pending'}; next_offset=${output.nextOffset}; total_bytes=${output.totalBytes}${task.outputSha256 ? `; sha256=${task.outputSha256}; complete=${task.complete}` : ''}; log=${task.logPath}]`,
     metadata: processExecutionMetadata({
       shell: task.shell,
       mode: 'background',
       command: task.command,
       taskId: task.id,
-      status: task.status === 'completed'
-        ? 'completed'
-        : task.status === 'failed'
-          ? 'failed'
-          : task.status === 'stopped'
-            ? 'stopped'
-            : 'running',
+      status:
+        task.status === 'completed'
+          ? 'completed'
+          : task.status === 'failed'
+            ? 'failed'
+            : task.status === 'stopped'
+              ? 'stopped'
+              : 'running',
       exitCode: task.exitCode,
     }),
   };
@@ -55,12 +132,14 @@ async function call(input: TaskOutputInput, state?: BackgroundTaskState): Promis
 
 export const taskOutputTool: Tool<TaskOutputInput> = {
   name: 'TaskOutput',
-  description: 'Reads incremental output from a Bash or PowerShell background task in the current session. Use block=true to wait efficiently for new output or completion instead of polling repeatedly.',
+  description:
+    'Reads incremental output from a Bash/PowerShell process or progress/results from an Agent task in the current session. Use block=true to wait efficiently instead of polling repeatedly.',
   inputSchema,
   parameters: toToolParameters(inputSchema),
   isReadOnly: true,
   isConcurrencySafe: true,
   maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
-  call: (input) => call(input),
-  callWithContext: (input, _signal, context: ToolCallContext) => call(input, context.sessionState?.backgroundTasks),
+  call: (input) => call(input, undefined),
+  callWithContext: (input, _signal, context: ToolCallContext) =>
+    call(input, context.sessionState?.backgroundTasks, context),
 };