@renxqoo/renx-code 0.0.3 → 0.0.5

package/vendor/agent-root/src/agent/tool/__test__/task-tools-runtime-edges.test.ts

@@ -0,0 +1,732 @@
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as fsPromises from 'node:fs/promises';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { TaskCreateTool } from '../task-create';
+import { TaskGetTool } from '../task-get';
+import { TaskOutputTool } from '../task-output';
+import { TaskStopTool } from '../task-stop';
+import { TaskStore } from '../task-store';
+import { TaskTool } from '../task';
+import type { SubagentRunnerAdapter } from '../task-runner-adapter';
+import type { AgentRunEntity, TaskEntity, TaskNamespaceState } from '../task-types';
+import type { ToolExecutionContext } from '../types';
+
+function parseOutput<T>(output: string | undefined): T {
+  return JSON.parse(output || '{}') as T;
+}
+
+function makeRun(overrides: Partial<AgentRunEntity> = {}): AgentRunEntity {
+  const now = Date.now();
+  return {
+    agentId: overrides.agentId || 'agent-x',
+    status: overrides.status || 'running',
+    subagentType: overrides.subagentType || 'Plan',
+    prompt: overrides.prompt || 'prompt',
+    description: overrides.description,
+    model: overrides.model,
+    maxTurns: overrides.maxTurns,
+    allowedTools: overrides.allowedTools,
+    linkedTaskId: overrides.linkedTaskId,
+    output: overrides.output,
+    error: overrides.error,
+    progress: overrides.progress,
+    createdAt: overrides.createdAt || now,
+    startedAt: overrides.startedAt || now,
+    endedAt: overrides.endedAt,
+    updatedAt: overrides.updatedAt || now,
+    outputFile: overrides.outputFile,
+    metadata: overrides.metadata || {},
+    version: overrides.version || 1,
+  };
+}
+
+function makeTask(overrides: Partial<TaskEntity> = {}): TaskEntity {
+  const now = 1;
+  return {
+    id: overrides.id || 'task-x',
+    subject: overrides.subject || 'Subject',
+    description: overrides.description || 'Long enough description field.',
+    activeForm: overrides.activeForm || 'Active subject',
+    status: overrides.status || 'pending',
+    priority: overrides.priority || 'normal',
+    owner: overrides.owner === undefined ? null : overrides.owner,
+    blockedBy: overrides.blockedBy || [],
+    blocks: overrides.blocks || [],
+    progress: overrides.progress || 0,
+    checkpoints: overrides.checkpoints || [],
+    retryConfig: overrides.retryConfig || {
+      maxRetries: 3,
+      retryDelayMs: 100,
+      backoffMultiplier: 2,
+      retryOn: ['timeout'],
+    },
+    retryCount: overrides.retryCount || 0,
+    tags: overrides.tags || [],
+    metadata: overrides.metadata || {},
+    history: overrides.history || [],
+    createdAt: overrides.createdAt || now,
+    updatedAt: overrides.updatedAt || now,
+    version: overrides.version || 1,
+    agentId: overrides.agentId,
+    startedAt: overrides.startedAt,
+    completedAt: overrides.completedAt,
+    cancelledAt: overrides.cancelledAt,
+    lastError: overrides.lastError,
+    lastErrorAt: overrides.lastErrorAt,
+    timeoutMs: overrides.timeoutMs,
+  };
+}
+
+describe('task tool runtime edge branches', () => {
+  let baseDir: string;
+  let store: TaskStore;
+  let taskCreate: TaskCreateTool;
+
+  beforeEach(async () => {
+    baseDir = await fsPromises.mkdtemp(path.join(os.tmpdir(), 'renx-task-runtime-edge-'));
+    store = new TaskStore({ baseDir });
+    taskCreate = new TaskCreateTool({ store });
+  });
+
+  afterEach(async () => {
+    await fsPromises.rm(baseDir, { recursive: true, force: true });
+  });
+
+  it('covers task schema preprocess, concurrency metadata and linked-task validation errors', async () => {
+    const runner: SubagentRunnerAdapter = {
+      start: async () => makeRun({ status: 'completed' }),
+      poll: async () => null,
+      cancel: async () => null,
+    };
+    const taskTool = new TaskTool({ store, runner, defaultNamespace: 'def' });
+
+    const parsedTrue = taskTool.safeValidateArgs({
+      subagent_type: 'Plan',
+      prompt: 'x',
+      run_in_background: 'true',
+    });
+    const parsedFalse = taskTool.safeValidateArgs({
+      subagent_type: 'Plan',
+      prompt: 'x',
+      run_in_background: 'false',
+    });
+    const parsedBoolean = taskTool.safeValidateArgs({
+      subagent_type: 'Plan',
+      prompt: 'x',
+      run_in_background: true,
+    });
+    expect(parsedTrue.success && parsedTrue.data.run_in_background).toBe(true);
+    expect(parsedFalse.success && parsedFalse.data.run_in_background).toBe(false);
+    expect(parsedBoolean.success && parsedBoolean.data.run_in_background).toBe(true);
+
+    expect(taskTool.getConcurrencyMode()).toBe('exclusive');
+    expect(taskTool.getConcurrencyLockKey({} as never)).toBe('taskns:def');
+    expect(taskTool.getConcurrencyLockKey({ namespace: 'n1' } as never)).toBe('taskns:n1');
+
+    const linkedMissing = await taskTool.execute({
+      namespace: 'n1',
+      subagent_type: 'Plan',
+      prompt: 'x',
+      linked_task_id: 'missing',
+    });
+    expect(linkedMissing.success).toBe(false);
+    expect(linkedMissing.output).toContain('TASK_NOT_FOUND');
+
+    const blocker = parseOutput<{ task: { id: string } }>(
+      (
+        await taskCreate.execute({
+          namespace: 'n2',
+          subject: 'blocker',
+          description: 'blocker description long enough.',
+        })
+      ).output
+    ).task.id;
+    const blocked = parseOutput<{ task: { id: string } }>(
+      (
+        await taskCreate.execute({
+          namespace: 'n2',
+          subject: 'blocked',
+          description: 'blocked description long enough.',
+        })
+      ).output
+    ).task.id;
+    await store.updateState('n2', (state) => {
+      state.tasks[blocked].blockedBy = [blocker];
+      return null;
+    });
+
+    const blockedResult = await taskTool.execute({
+      namespace: 'n2',
+      subagent_type: 'Plan',
+      prompt: 'x',
+      linked_task_id: blocked,
+    });
+    expect(blockedResult.success).toBe(false);
+    expect(blockedResult.output).toContain('TASK_BLOCKED');
+  });
+
+  it('covers task linked mapping for cancelled run, missing task on post-run update, and catch fallback', async () => {
+    const cancelledRunner: SubagentRunnerAdapter = {
+      start: async () => makeRun({ agentId: 'agent-cancel', status: 'cancelled' }),
+      poll: async () => null,
+      cancel: async () => null,
+    };
+    const taskToolCancelled = new TaskTool({ store, runner: cancelledRunner });
+    const taskGet = new TaskGetTool({ store });
+    const linked = parseOutput<{ task: { id: string } }>(
+      (
+        await taskCreate.execute({
+          namespace: 'n3',
+          subject: 'cancel-me',
+          description: 'cancel me with enough detail text.',
+        })
+      ).output
+    ).task.id;
+
+    const cancelled = await taskToolCancelled.execute({
+      namespace: 'n3',
+      subagent_type: 'Plan',
+      prompt: 'x',
+      linked_task_id: linked,
+    });
+    expect(cancelled.success).toBe(true);
+    const taskAfterCancelled = await taskGet.execute({
+      namespace: 'n3',
+      task_id: linked,
+    });
+    expect(taskAfterCancelled.success).toBe(true);
+    expect(parseOutput<{ task: { status: string } }>(taskAfterCancelled.output).task.status).toBe(
+      'cancelled'
+    );
+
+    const fakeStore = {
+      normalizeNamespace: (ns?: string) => (ns || 'default').trim() || 'default',
+      getState: async () => ({
+        namespace: 'fake',
+        tasks: { t1: makeTask({ id: 't1' }) },
+        agentRuns: {},
+        graph: { adjacency: {}, reverse: {} },
+        updatedAt: 0,
+        schemaVersion: 1 as const,
+      }),
+      updateState: async (
+        _ns: string | undefined,
+        updater: (state: TaskNamespaceState) => unknown
+      ) => {
+        const state: TaskNamespaceState = {
+          namespace: 'fake',
+          tasks: {},
+          agentRuns: {},
+          graph: { adjacency: {}, reverse: {} },
+          updatedAt: 0,
+          schemaVersion: 1 as const,
+        };
+        const result = await updater(state);
+        return { state, result };
+      },
+    } as unknown as TaskStore;
+    const fakeRunner: SubagentRunnerAdapter = {
+      start: async () => makeRun({ status: 'completed', agentId: 'a1' }),
+      poll: async () => null,
+      cancel: async () => null,
+    };
+    const taskToolMissingPostLink = new TaskTool({ store: fakeStore, runner: fakeRunner });
+    const postLinkResult = await taskToolMissingPostLink.execute({
+      namespace: 'fake',
+      subagent_type: 'Plan',
+      prompt: 'x',
+      linked_task_id: 't1',
+    });
+    expect(postLinkResult.success).toBe(true);
+
+    const throwRunner: SubagentRunnerAdapter = {
+      start: async () => {
+        throw 'runner failed';
+      },
+      poll: async () => null,
+      cancel: async () => null,
+    };
+    const taskToolError = new TaskTool({ store, runner: throwRunner });
+    const failed = await taskToolError.execute({
+      namespace: 'n4',
+      subagent_type: 'Plan',
+      prompt: 'x',
+    });
+    expect(failed.success).toBe(false);
+    expect(failed.output).toContain('TASK_OPERATION_FAILED');
+  });
+
+  it('covers task default constructor, namespace fallback, failed run fallback error, and Error catch path', async () => {
+    const defaultTool = new TaskTool();
+    expect(defaultTool.getConcurrencyLockKey({} as never)).toBe('taskns:default');
+
+    const failedRunner: SubagentRunnerAdapter = {
+      start: async () => makeRun({ status: 'failed', error: undefined, agentId: 'agent-failed' }),
+      poll: async () => null,
+      cancel: async () => null,
+    };
+    const taskTool = new TaskTool({ store, runner: failedRunner });
+
+    const linked = parseOutput<{ task: { id: string } }>(
+      (
+        await taskCreate.execute({
+          subject: 'default namespace linked',
+          description: 'Task in default namespace for failed fallback branch.',
+        })
+      ).output
+    ).task.id;
+    const failedLinked = await taskTool.execute({
+      subagent_type: 'Plan',
+      prompt: 'x',
+      linked_task_id: linked,
+    });
+    expect(failedLinked.success).toBe(true);
+    const detail = await new TaskGetTool({ store }).execute({
+      task_id: linked,
+    });
+    expect(parseOutput<{ task: { lastError?: string } }>(detail.output).task.lastError).toContain(
+      'linked agent failed'
+    );
+
+    const noNamespace = await taskTool.execute({
+      subagent_type: 'Plan',
+      prompt: 'no namespace run',
+    });
+    expect(noNamespace.success).toBe(true);
+
+    const errorRunner: SubagentRunnerAdapter = {
+      start: async () => {
+        throw new Error('TASK_CUSTOM_ERROR: exploded');
+      },
+      poll: async () => null,
+      cancel: async () => null,
+    };
+    const errorTool = new TaskTool({ store, runner: errorRunner });
+    const err = await errorTool.execute({
+      subagent_type: 'Plan',
+      prompt: 'x',
+    });
+    expect(err.success).toBe(false);
+    expect(err.output).toContain('TASK_CUSTOM_ERROR');
+  });
+
+  it('covers blocked-message fallback branch via mocked evaluateTaskCanStart', async () => {
+    vi.resetModules();
+    vi.doMock('../task-types', async () => {
+      const actual = await vi.importActual<typeof import('../task-types')>('../task-types');
+      return {
+        ...actual,
+        evaluateTaskCanStart: () => ({ canStart: false }),
+      };
+    });
+    const { TaskTool: MockedTaskTool } = await import('../task');
+
+    await store.updateState('m1', (state) => {
+      state.tasks.t1 = makeTask({ id: 't1', status: 'pending' });
+      return null;
+    });
+    const runner: SubagentRunnerAdapter = {
+      start: async () => makeRun({ status: 'completed' }),
+      poll: async () => null,
+      cancel: async () => null,
+    };
+    const mockedTool = new MockedTaskTool({ store, runner });
+    const result = await mockedTool.execute({
+      namespace: 'm1',
+      subagent_type: 'Plan',
+      prompt: 'x',
+      linked_task_id: 't1',
+    });
+    expect(result.success).toBe(false);
+    expect(result.output).toContain('linked task is blocked');
+
+    vi.doUnmock('../task-types');
+    vi.resetModules();
+  });
+});
+
+describe('task_output edge branches', () => {
+  let baseDir: string;
+  let store: TaskStore;
+
+  beforeEach(async () => {
+    baseDir = await fsPromises.mkdtemp(path.join(os.tmpdir(), 'renx-task-output-edge-'));
+    store = new TaskStore({ baseDir });
+  });
+
+  afterEach(async () => {
+    await fsPromises.rm(baseDir, { recursive: true, force: true });
+  });
+
+  it('covers schema preprocess and concurrency metadata', () => {
+    const runner: SubagentRunnerAdapter = {
+      start: async () => makeRun(),
+      poll: async () => null,
+      cancel: async () => null,
+    };
+    const tool = new TaskOutputTool({ store, runner, defaultNamespace: 'def-out' });
+    const defaultTool = new TaskOutputTool();
+    expect(defaultTool.getConcurrencyLockKey({} as never)).toBe('taskns:default:agent:unknown');
+
+    const parsedTrue = tool.safeValidateArgs({ agent_id: 'a', block: 'true' });
+    const parsedFalse = tool.safeValidateArgs({ agent_id: 'a', block: 'false' });
+    const parsedBoolean = tool.safeValidateArgs({ agent_id: 'a', block: true });
+    expect(parsedTrue.success && parsedTrue.data.block).toBe(true);
+    expect(parsedFalse.success && parsedFalse.data.block).toBe(false);
+    expect(parsedBoolean.success && parsedBoolean.data.block).toBe(true);
+
+    expect(tool.getConcurrencyMode()).toBe('parallel-safe');
+    expect(tool.getConcurrencyLockKey({} as never)).toBe('taskns:def-out:agent:unknown');
+    expect(tool.getConcurrencyLockKey({ namespace: 'n1', agent_id: 'a1' } as never)).toBe(
+      'taskns:n1:agent:a1'
+    );
+    expect(tool.getConcurrencyLockKey({ namespace: 'n1', task_id: 't1' } as never)).toBe(
+      'taskns:n1:agent:t1'
+    );
+  });
+
+  it('covers resolve target errors and poll-not-found branches', async () => {
+    const runnerMissing: SubagentRunnerAdapter = {
+      start: async () => makeRun(),
+      poll: async () => null,
+      cancel: async () => null,
+    };
+    const outputTool = new TaskOutputTool({ store, runner: runnerMissing });
+
+    const targetRequired = await outputTool.execute({ namespace: 'n1' });
+    expect(targetRequired.success).toBe(false);
+    expect(targetRequired.output).toContain('TASK_OUTPUT_TARGET_REQUIRED');
+
+    const taskNotFound = await outputTool.execute({
+      namespace: 'n1',
+      task_id: 'missing',
+    });
+    expect(taskNotFound.success).toBe(false);
+    expect(taskNotFound.output).toContain('TASK_NOT_FOUND');
+
+    await store.updateState('n1', (state) => {
+      state.tasks.t1 = makeTask({ id: 't1', agentId: undefined });
+      return null;
+    });
+    const noAgent = await outputTool.execute({
+      namespace: 'n1',
+      task_id: 't1',
+    });
+    expect(noAgent.success).toBe(false);
+    expect(noAgent.output).toContain('AGENT_RUN_NOT_FOUND');
+
+    const nonBlockingMissing = await outputTool.execute({
+      namespace: 'n1',
+      agent_id: 'missing-agent',
+      block: false,
+    });
+    expect(nonBlockingMissing.success).toBe(false);
+    expect(nonBlockingMissing.output).toContain('AGENT_RUN_NOT_FOUND');
+
+    const blockingMissing = await outputTool.execute({
+      namespace: 'n1',
+      agent_id: 'missing-agent',
+      timeout_ms: 50,
+      poll_interval_ms: 20,
+    });
+    expect(blockingMissing.success).toBe(false);
+    expect(blockingMissing.output).toContain('AGENT_RUN_NOT_FOUND');
+
+    const defaultNamespaceMissing = await outputTool.execute({
+      agent_id: 'missing-agent',
+      block: false,
+    });
+    expect(defaultNamespaceMissing.success).toBe(false);
+
+    const byTaskRunner: SubagentRunnerAdapter = {
+      start: async () => makeRun(),
+      poll: async () =>
+        makeRun({ status: 'completed', agentId: 'agent-by-task', endedAt: Date.now() }),
+      cancel: async () => null,
+    };
+    await store.updateState('n1', (state) => {
+      state.tasks.t2 = makeTask({ id: 't2', agentId: 'agent-by-task' });
+      return null;
+    });
+    const byTaskTool = new TaskOutputTool({ store, runner: byTaskRunner });
+    const byTask = await byTaskTool.execute({
+      namespace: 'n1',
+      task_id: 't2',
+      block: false,
+    });
+    expect(byTask.success).toBe(true);
+  });
+
+  it('covers timeout hit, final-poll missing, and abort branches in blocking mode', async () => {
+    const alwaysRunning: SubagentRunnerAdapter = {
+      start: async () => makeRun(),
+      poll: async () => makeRun({ status: 'running', agentId: 'a-time' }),
+      cancel: async () => null,
+    };
+    const outputTimeout = new TaskOutputTool({ store, runner: alwaysRunning });
+    const timeoutRes = await outputTimeout.execute(
+      {
+        namespace: 'n2',
+        agent_id: 'a-time',
+        timeout_ms: 40,
+        poll_interval_ms: 20,
+      },
+      {
+        toolCallId: 'timeout-with-signal',
+        loopIndex: 1,
+        agent: {},
+        toolAbortSignal: new AbortController().signal,
+      }
+    );
+    expect(timeoutRes.success).toBe(true);
+    const timeoutPayload = parseOutput<{ completed: boolean; timeout_hit: boolean }>(
+      timeoutRes.output
+    );
+    expect(timeoutPayload.completed).toBe(false);
+    expect(timeoutPayload.timeout_hit).toBe(true);
+
+    let pollCount = 0;
+    const latestMissingRunner: SubagentRunnerAdapter = {
+      start: async () => makeRun(),
+      poll: async () => {
+        pollCount += 1;
+        return pollCount === 1 ? makeRun({ status: 'running', agentId: 'a-latest' }) : null;
+      },
+      cancel: async () => null,
+    };
+    const outputLatestMissing = new TaskOutputTool({ store, runner: latestMissingRunner });
+    const latestMissing = await outputLatestMissing.execute({
+      namespace: 'n3',
+      agent_id: 'a-latest',
+      timeout_ms: 1,
+      poll_interval_ms: 1,
+    });
+    expect(latestMissing.success).toBe(false);
+    expect(latestMissing.output).toContain('AGENT_RUN_NOT_FOUND');
+
+    const abortRunner: SubagentRunnerAdapter = {
+      start: async () => makeRun(),
+      poll: async () => makeRun({ status: 'running', agentId: 'a-abort' }),
+      cancel: async () => null,
+    };
+    const outputAbort = new TaskOutputTool({ store, runner: abortRunner });
+
+    const controller1 = new AbortController();
+    controller1.abort();
+    const context1 = {
+      toolCallId: 'c1',
+      loopIndex: 1,
+      agent: {},
+      toolAbortSignal: controller1.signal,
+    } as ToolExecutionContext;
+    await expect(
+      outputAbort.execute(
+        {
+          namespace: 'n4',
+          agent_id: 'a-abort',
+          timeout_ms: 50,
+          poll_interval_ms: 20,
+        },
+        context1
+      )
+    ).rejects.toThrow('TASK_OUTPUT_ABORTED');
+
+    const controller2 = new AbortController();
+    const context2 = {
+      toolCallId: 'c2',
+      loopIndex: 2,
+      agent: {},
+      toolAbortSignal: controller2.signal,
+    } as ToolExecutionContext;
+    const promise = outputAbort.execute(
+      {
+        namespace: 'n4',
+        agent_id: 'a-abort',
+        timeout_ms: 1000,
+        poll_interval_ms: 200,
+      },
+      context2
+    );
+    setTimeout(() => controller2.abort(), 30);
+    await expect(promise).rejects.toThrow('TASK_OUTPUT_ABORTED');
+  });
+});
+
+describe('task_stop edge branches', () => {
+  let baseDir: string;
+  let store: TaskStore;
+
+  beforeEach(async () => {
+    baseDir = await fsPromises.mkdtemp(path.join(os.tmpdir(), 'renx-task-stop-edge-'));
+    store = new TaskStore({ baseDir });
+  });
+
+  afterEach(async () => {
+    await fsPromises.rm(baseDir, { recursive: true, force: true });
+  });
+
+  it('covers schema preprocess and concurrency metadata', () => {
+    const runner: SubagentRunnerAdapter = {
+      start: async () => makeRun(),
+      poll: async () => null,
+      cancel: async () => null,
+    };
+    const stopTool = new TaskStopTool({ store, runner, defaultNamespace: 'def-stop' });
+    const defaultTool = new TaskStopTool();
+    expect(defaultTool.getConcurrencyLockKey({} as never)).toBe('taskns:default');
+    const parsedTrue = stopTool.safeValidateArgs({ agent_id: 'a', cancel_linked_task: 'true' });
+    const parsedFalse = stopTool.safeValidateArgs({ agent_id: 'a', cancel_linked_task: 'false' });
+    const parsedBoolean = stopTool.safeValidateArgs({ agent_id: 'a', cancel_linked_task: true });
+    expect(parsedTrue.success && parsedTrue.data.cancel_linked_task).toBe(true);
+    expect(parsedFalse.success && parsedFalse.data.cancel_linked_task).toBe(false);
+    expect(parsedBoolean.success && parsedBoolean.data.cancel_linked_task).toBe(true);
+
+    expect(stopTool.getConcurrencyMode()).toBe('exclusive');
+    expect(stopTool.getConcurrencyLockKey({} as never)).toBe('taskns:def-stop');
+    expect(stopTool.getConcurrencyLockKey({ namespace: 'n1' } as never)).toBe('taskns:n1');
+  });
+
+  it('covers resolve errors, pre-cancel error branches, and cancel returns null', async () => {
+    const running = makeRun({ status: 'running', agentId: 'a1' });
+    const terminal = makeRun({ status: 'completed', agentId: 'a2', endedAt: Date.now() });
+
+    const runnerBase: SubagentRunnerAdapter = {
+      start: async () => makeRun(),
+      poll: async (_ns, id) => {
+        if (id === 'a1') return running;
+        if (id === 'a2') return terminal;
+        return null;
+      },
+      cancel: async () => null,
+    };
+    const stopTool = new TaskStopTool({ store, runner: runnerBase });
+
+    const targetRequired = await stopTool.execute({ namespace: 'n1' });
+    expect(targetRequired.success).toBe(false);
+    expect(targetRequired.output).toContain('TASK_STOP_TARGET_REQUIRED');
+
+    const notFound = await stopTool.execute({
+      namespace: 'n1',
+      task_id: 'missing',
+    });
+    expect(notFound.success).toBe(false);
+    expect(notFound.output).toContain('TASK_NOT_FOUND');
+
+    await store.updateState('n1', (state) => {
+      state.tasks.t1 = makeTask({ id: 't1' });
+      return null;
+    });
+    const noAgent = await stopTool.execute({
+      namespace: 'n1',
+      task_id: 't1',
+    });
+    expect(noAgent.success).toBe(false);
+    expect(noAgent.output).toContain('AGENT_RUN_NOT_FOUND');
+
+    const beforeMissing = await stopTool.execute({
+      namespace: 'n1',
+      agent_id: 'missing-agent',
+    });
+    expect(beforeMissing.success).toBe(false);
+    expect(beforeMissing.output).toContain('AGENT_RUN_NOT_FOUND');
+
+    const beforeTerminal = await stopTool.execute({
+      namespace: 'n1',
+      agent_id: 'a2',
+    });
+    expect(beforeTerminal.success).toBe(false);
+    expect(beforeTerminal.output).toContain('AGENT_RUN_ALREADY_TERMINAL');
+
+    const cancelNull = await stopTool.execute({
+      namespace: 'n1',
+      agent_id: 'a1',
+    });
+    expect(cancelNull.success).toBe(false);
+    expect(cancelNull.output).toContain('AGENT_RUN_NOT_FOUND');
+  });
+
+  it('covers cancel_linked_task false and true(with skip completed/cancelled)', async () => {
+    const runner: SubagentRunnerAdapter = {
+      start: async () => makeRun(),
+      poll: async () => makeRun({ status: 'running', agentId: 'agent-main' }),
+      cancel: async () =>
+        makeRun({ status: 'cancelled', agentId: 'agent-main', endedAt: Date.now() }),
+    };
+    const stopTool = new TaskStopTool({ store, runner });
+
+    await store.updateState('n2', (state) => {
+      state.tasks.p1 = makeTask({ id: 'p1', status: 'pending', agentId: 'agent-main', owner: 'x' });
+      return null;
+    });
+
+    const noLinkedCancel = await stopTool.execute({
+      namespace: 'n2',
+      agent_id: 'agent-main',
+      cancel_linked_task: false,
+    });
+    expect(noLinkedCancel.success).toBe(true);
+    const noLinkedPayload = parseOutput<{ cancelled_task_ids: string[] }>(noLinkedCancel.output);
+    expect(noLinkedPayload.cancelled_task_ids).toEqual([]);
+    const p1State = await store.getState('n2');
+    expect(p1State.tasks.p1.status).toBe('pending');
+
+    const defaultLinkedCancel = await stopTool.execute({
+      namespace: 'n2',
+      task_id: 'p1',
+    });
+    expect(defaultLinkedCancel.success).toBe(true);
+    const defaultLinkedPayload = parseOutput<{ cancelled_task_ids: string[] }>(
+      defaultLinkedCancel.output
+    );
+    expect(defaultLinkedPayload.cancelled_task_ids).toContain('p1');
+
+    await store.updateState('n3', (state) => {
+      state.tasks.t_pending = makeTask({
+        id: 't_pending',
+        status: 'in_progress',
+        owner: 'agent:agent-main',
+        agentId: 'agent-main',
+      });
+      state.tasks.t_completed = makeTask({
+        id: 't_completed',
+        status: 'completed',
+        agentId: 'agent-main',
+      });
+      state.tasks.t_cancelled = makeTask({
+        id: 't_cancelled',
+        status: 'cancelled',
+        agentId: 'agent-main',
+      });
+      return null;
+    });
+
+    const linkedCancel = await stopTool.execute({
+      namespace: 'n3',
+      agent_id: 'agent-main',
+      cancel_linked_task: true,
+    });
+    expect(linkedCancel.success).toBe(true);
+    const linkedPayload = parseOutput<{ cancelled_task_ids: string[] }>(linkedCancel.output);
+    expect(linkedPayload.cancelled_task_ids).toEqual(['t_pending']);
+
+    const stateAfter = await store.getState('n3');
+    expect(stateAfter.tasks.t_pending.status).toBe('cancelled');
+    expect(stateAfter.tasks.t_completed.status).toBe('completed');
+    expect(stateAfter.tasks.t_cancelled.status).toBe('cancelled');
+
+    await store.updateState(undefined, (state) => {
+      state.tasks.default_task = makeTask({
+        id: 'default_task',
+        status: 'in_progress',
+        owner: 'agent:agent-main',
+        agentId: 'agent-main',
+      });
+      return null;
+    });
+    const noNamespaceStop = await stopTool.execute({
+      task_id: 'default_task',
+    });
+    expect(noNamespaceStop.success).toBe(true);
+  });
+});