@qduc/term2 0.7.1 → 0.7.3

package/dist/services/subagents/subagent-manager.test.js

@@ -2,8 +2,20 @@ import test from 'ava';
 import fs from 'node:fs';
 import path from 'node:path';
 import { ModelBehaviorError } from '@openai/agents';
-import { SubagentManager } from './subagent-manager.js';
+import { SubagentManager as RealSubagentManager } from './subagent-manager.js';
 import { registerProvider } from '../../providers/registry.js';
+const createSessionContextService = () => ({
+    runWithContext: (_context, fn) => fn(),
+    getContext: () => null,
+});
+const SubagentManager = class extends RealSubagentManager {
+    constructor(deps) {
+        super({
+            ...deps,
+            sessionContextService: deps.sessionContextService ?? createSessionContextService(),
+        });
+    }
+};
 // ========== Mock Utilities ==========
 function createMockLogger() {
     return {
@@ -27,6 +39,9 @@ function createMockSettings(values = {}) {
         },
     };
 }
+function getAgentTool(agent, name) {
+    return agent.tools.find((tool) => tool.name === name);
+}
 // ========== Provider Mocks ==========
 let mentorManagerRunnerCalls = [];
 let mentorManagerResponseCounter = 0;
@@ -90,7 +105,11 @@ test.serial('run() returns failed result for unknown role', async (t) => {
         'agent.model': 'mock-model',
         'agent.provider': 'mock-mentor-manager',
     });
-    const manager = new SubagentManager({ logger: createMockLogger(), settings });
+    const manager = new SubagentManager({
+        logger: createMockLogger(),
+        settings,
+        sessionContextService: createSessionContextService(),
+    });
     const result = await manager.run({ role: 'nonexistent-role-xyz', task: 'do something' });
     t.is(result.status, 'failed');
     t.truthy(result.error);
@@ -104,7 +123,11 @@ test.serial('run() with mentor role uses mentorModel setting', async (t) => {
         'agent.mentorModel': 'mentor-model',
         'agent.mentorProvider': 'mock-mentor-manager',
     });
-    const manager = new SubagentManager({ logger: createMockLogger(), settings });
+    const manager = new SubagentManager({
+        logger: createMockLogger(),
+        settings,
+        sessionContextService: createSessionContextService(),
+    });
     const result = await manager.run({ role: 'mentor', task: 'advise me' });
     t.is(result.status, 'completed');
     t.is(result.role, 'mentor');
@@ -117,7 +140,11 @@ test.serial('run() with mentor role fails when mentorModel is not set', async (t
         'agent.model': 'main-model',
         'agent.provider': 'mock-mentor-manager',
     });
-    const manager = new SubagentManager({ logger: createMockLogger(), settings });
+    const manager = new SubagentManager({
+        logger: createMockLogger(),
+        settings,
+        sessionContextService: createSessionContextService(),
+    });
     const result = await manager.run({ role: 'mentor', task: 'advise me' });
     t.is(result.status, 'failed');
     t.true(result.error.includes('Mentor model is not configured'));
@@ -129,7 +156,11 @@ test.serial('run() mentor maintains conversation history across calls', async (t
         'agent.mentorModel': 'mentor-model',
         'agent.mentorProvider': 'mock-mentor-manager',
     });
-    const manager = new SubagentManager({ logger: createMockLogger(), settings });
+    const manager = new SubagentManager({
+        logger: createMockLogger(),
+        settings,
+        sessionContextService: createSessionContextService(),
+    });
     await manager.run({ role: 'mentor', task: 'first question' });
     await manager.run({ role: 'mentor', task: 'second question' });
     t.is(mentorManagerRunnerCalls.length, 2);
@@ -144,7 +175,11 @@ test.serial('resetMentorSession() clears conversation history', async (t) => {
         'agent.mentorModel': 'mentor-model',
         'agent.mentorProvider': 'mock-mentor-manager',
     });
-    const manager = new SubagentManager({ logger: createMockLogger(), settings });
+    const manager = new SubagentManager({
+        logger: createMockLogger(),
+        settings,
+        sessionContextService: createSessionContextService(),
+    });
     await manager.run({ role: 'mentor', task: 'first question' });
     t.true(mentorManagerRunnerCalls[0].input.length >= 1);
     manager.resetMentorSession();
@@ -158,7 +193,11 @@ test.serial('run() with explorer role returns SubagentResult', async (t) => {
         'agent.model': 'mock-model',
         'agent.provider': 'mock-explorer-provider',
     });
-    const manager = new SubagentManager({ logger: createMockLogger(), settings });
+    const manager = new SubagentManager({
+        logger: createMockLogger(),
+        settings,
+        sessionContextService: createSessionContextService(),
+    });
     const result = await manager.run({ role: 'explorer', task: 'find all TypeScript files' });
     t.is(result.status, 'completed');
     t.is(result.role, 'explorer');
@@ -171,7 +210,11 @@ test.serial('run() passes parent abort signal into the delegated provider run',
         'agent.model': 'mock-model',
         'agent.provider': 'mock-explorer-provider',
     });
-    const manager = new SubagentManager({ logger: createMockLogger(), settings });
+    const manager = new SubagentManager({
+        logger: createMockLogger(),
+        settings,
+        sessionContextService: createSessionContextService(),
+    });
     const abortController = new AbortController();
     await manager.run({
         role: 'explorer',
@@ -200,7 +243,11 @@ test.serial('run() cancels a delegated provider run when the parent signal abort
         'agent.model': 'mock-model',
         'agent.provider': 'mock-aborted-subagent-provider',
     });
-    const manager = new SubagentManager({ logger: createMockLogger(), settings });
+    const manager = new SubagentManager({
+        logger: createMockLogger(),
+        settings,
+        sessionContextService: createSessionContextService(),
+    });
     const abortController = new AbortController();
     const resultPromise = manager.run({
         role: 'explorer',
@@ -212,12 +259,85 @@ test.serial('run() cancels a delegated provider run when the parent signal abort
     t.is(result.status, 'cancelled');
     t.true(result.error?.includes('aborted') ?? false);
 });
+test.serial('explorer shell tool executes GREEN commands and blocks YELLOW and RED commands', async (t) => {
+    const settings = createMockSettings({
+        'agent.model': 'mock-model',
+        'agent.provider': 'mock-explorer-provider',
+    });
+    const manager = new SubagentManager({
+        logger: createMockLogger(),
+        settings,
+        sessionContextService: createSessionContextService(),
+    });
+    await manager.run({ role: 'explorer', task: 'inspect the workspace' });
+    t.is(explorerRunnerCalls.length, 1);
+    const agent = explorerRunnerCalls[0].agent;
+    const shell = getAgentTool(agent, 'shell');
+    t.truthy(shell);
+    t.is(await shell.needsApproval({}, { command: 'pwd' }), false);
+    const invokeShell = async (command) => shell.invoke({}, JSON.stringify({ command }), {});
+    const blockedPrefix = 'Error: command blocked - explorer can only run read-only (GREEN) shell commands. Command: ';
+    for (const command of ['pwd', 'ls', 'cat package.json', 'git status', 'git log --oneline']) {
+        const output = await invokeShell(command);
+        t.true(output.includes('exit 0'), `expected GREEN command to execute: ${command}`);
+        t.false(output.startsWith(blockedPrefix), `expected GREEN command to not be blocked: ${command}`);
+    }
+    for (const command of ['touch blocked.txt', 'npm test', 'unknown_tool_name', 'cat ../outside.txt']) {
+        const output = await invokeShell(command);
+        t.true(output.startsWith(blockedPrefix), `expected YELLOW command to be blocked: ${command}`);
+        t.true(output.includes(command), `blocked output should mention the command: ${command}`);
+    }
+    for (const command of ['rm -rf x', 'sudo ls']) {
+        const output = await invokeShell(command);
+        t.true(output.startsWith(blockedPrefix), `expected RED command to be blocked: ${command}`);
+        t.true(output.includes(command), `blocked output should mention the command: ${command}`);
+    }
+});
+test.serial('explorer shell tool blocks write-like shell commands without creating files in a temp workspace', async (t) => {
+    const tmpDir = fs.mkdtempSync(path.join('/tmp', 'term2-test-explorer-shell-block-'));
+    t.teardown(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
+    fs.writeFileSync(path.join(tmpDir, 'source.txt'), 'source content');
+    const settings = createMockSettings({
+        'agent.model': 'mock-model',
+        'agent.provider': 'mock-explorer-provider',
+    });
+    const manager = new SubagentManager({
+        logger: createMockLogger(),
+        settings,
+        sessionContextService: createSessionContextService(),
+        executionContext: {
+            getCwd: () => tmpDir,
+            isRemote: () => false,
+            getSSHService: () => undefined,
+        },
+    });
+    await manager.run({ role: 'explorer', task: 'inspect a temp workspace' });
+    const agent = explorerRunnerCalls[explorerRunnerCalls.length - 1].agent;
+    const shell = getAgentTool(agent, 'shell');
+    t.truthy(shell);
+    const blockedPrefix = 'Error: command blocked - explorer can only run read-only (GREEN) shell commands. Command: ';
+    const cases = [
+        { command: 'touch blocked-touch.txt', path: 'blocked-touch.txt' },
+        { command: 'echo marker > blocked-redirect.txt', path: 'blocked-redirect.txt' },
+        { command: 'cat source.txt > blocked-copy.txt', path: 'blocked-copy.txt' },
+        { command: 'printf marker | tee blocked-tee.txt', path: 'blocked-tee.txt' },
+    ];
+    for (const { command, path: relativePath } of cases) {
+        const output = await shell.invoke({}, JSON.stringify({ command }), {});
+        t.true(output.startsWith(blockedPrefix), `expected command to be blocked: ${command}`);
+        t.false(fs.existsSync(path.join(tmpDir, relativePath)), `expected no file to be created: ${relativePath}`);
+    }
+});
 test.serial('run() with explorer role uses read-only tools only', async (t) => {
     const settings = createMockSettings({
         'agent.model': 'mock-model',
         'agent.provider': 'mock-explorer-provider',
     });
-    const manager = new SubagentManager({ logger: createMockLogger(), settings });
+    const manager = new SubagentManager({
+        logger: createMockLogger(),
+        settings,
+        sessionContextService: createSessionContextService(),
+    });
     await manager.run({ role: 'explorer', task: 'find files' });
     t.is(explorerRunnerCalls.length, 1);
     const agent = explorerRunnerCalls[0].agent;
@@ -233,7 +353,7 @@ test.serial('run() with explorer role uses read-only tools only', async (t) => {
     // Explorer should NOT have web tools by default
     t.false(toolNames.includes('web_search'));
     t.false(toolNames.includes('web_fetch'));
-    t.false(toolNames.includes('shell'));
+    t.true(toolNames.includes('shell'));
 });
 // ========== Researcher role ==========
 let researcherRunnerCalls = [];
@@ -268,7 +388,11 @@ test.serial('run() with researcher role includes web tools', async (t) => {
         'agent.model': 'mock-model',
         'agent.provider': 'mock-researcher-provider',
     });
-    const manager = new SubagentManager({ logger: createMockLogger(), settings });
+    const manager = new SubagentManager({
+        logger: createMockLogger(),
+        settings,
+        sessionContextService: createSessionContextService(),
+    });
     await manager.run({ role: 'researcher', task: 'look up the latest TypeScript release' });
     t.is(researcherRunnerCalls.length, 1);
     const agent = researcherRunnerCalls[0].agent;
@@ -313,7 +437,11 @@ test.serial('run() with worker role includes write and shell tools for non-gpt m
         'agent.model': 'mock-model',
         'agent.provider': 'mock-worker-provider',
     });
-    const manager = new SubagentManager({ logger: createMockLogger(), settings });
+    const manager = new SubagentManager({
+        logger: createMockLogger(),
+        settings,
+        sessionContextService: createSessionContextService(),
+    });
     await manager.run({ role: 'worker', task: 'update the README.md file' });
     t.is(workerRunnerCalls.length, 1);
     const agent = workerRunnerCalls[0].agent;
@@ -332,7 +460,11 @@ test.serial('run() with worker role includes write and shell tools for gpt model
         'agent.model': 'gpt-5',
         'agent.provider': 'mock-worker-provider',
     });
-    const manager = new SubagentManager({ logger: createMockLogger(), settings });
+    const manager = new SubagentManager({
+        logger: createMockLogger(),
+        settings,
+        sessionContextService: createSessionContextService(),
+    });
     await manager.run({ role: 'worker', task: 'update the README.md file' });
     t.is(workerRunnerCalls.length, 1);
     const agent = workerRunnerCalls[0].agent;
@@ -703,6 +835,7 @@ test.serial('run() emits started, tool_started and completed events', async (t)
     const manager = new SubagentManager({
         logger: createMockLogger(),
         settings,
+        sessionContextService: createSessionContextService(),
         onEvent: (event) => events.push(event),
     });
     const result = await manager.run({ role: 'explorer', task: 'search the code' });
@@ -726,6 +859,7 @@ test.serial('run() emits a completed event even when the role is unknown', async
     const manager = new SubagentManager({
         logger: createMockLogger(),
         settings,
+        sessionContextService: createSessionContextService(),
         onEvent: (event) => events.push(event),
     });
     await manager.run({ role: 'definitely-not-a-role', task: 'x' });
@@ -743,7 +877,11 @@ test.serial('mentor base instructions come from the mentor role markdown', async
         'agent.mentorProvider': 'mock-mentor-manager',
         'app.mentorMode': false,
     });
-    const manager = new SubagentManager({ logger: createMockLogger(), settings });
+    const manager = new SubagentManager({
+        logger: createMockLogger(),
+        settings,
+        sessionContextService: createSessionContextService(),
+    });
     await manager.run({ role: 'mentor', task: 'advise me' });
     t.is(mentorManagerRunnerCalls.length, 1);
     const instructions = mentorManagerRunnerCalls[0].agent.instructions;
@@ -785,7 +923,11 @@ test.serial('finalText is the assistant message after the last tool item', async
         'agent.model': 'mock-model',
         'agent.provider': 'mock-post-tool-provider',
     });
-    const manager = new SubagentManager({ logger: createMockLogger(), settings });
+    const manager = new SubagentManager({
+        logger: createMockLogger(),
+        settings,
+        sessionContextService: createSessionContextService(),
+    });
     const result = await manager.run({ role: 'explorer', task: 'where is it' });
     t.is(result.finalText, 'Final answer: it is in foo.ts.');
     t.false(result.finalText.includes('Let me look into this first.'));
@@ -821,6 +963,7 @@ test.serial('worker shell tool executes safe command without triggering approval
             'agent.model': 'mock-model',
             'agent.provider': 'mock-worker-shell-safe-provider',
         }),
+        sessionContextService: createSessionContextService(),
         executionContext: {
             getCwd: () => tmpDir,
             isRemote: () => false,
@@ -862,6 +1005,7 @@ test.serial('worker shell tool blocks dangerous/destructive commands and returns
             'agent.model': 'mock-model',
             'agent.provider': 'mock-worker-shell-dangerous-provider',
         }),
+        sessionContextService: createSessionContextService(),
         executionContext: {
             getCwd: () => tmpDir,
             isRemote: () => false,
@@ -906,6 +1050,7 @@ test.serial('worker shell tool allows YELLOW command when auto-approval evaluato
             'agent.autoApproveModel': 'mock-auto-approve-model',
             'agent.autoApproveProvider': 'mock-worker-shell-yellow-approved-provider',
         }),
+        sessionContextService: createSessionContextService(),
         agentClient: {
             chat: async (message) => {
                 chatCalls++;
@@ -956,6 +1101,7 @@ test.serial('worker shell tool blocks YELLOW command when auto-approval evaluato
             'agent.autoApproveModel': 'mock-auto-approve-model',
             'agent.autoApproveProvider': 'mock-worker-shell-yellow-rejected-provider',
         }),
+        sessionContextService: createSessionContextService(),
         agentClient: {
             chat: async () => {
                 chatCalls++;
@@ -995,7 +1141,11 @@ test.serial('run() extracts usage from error.state.usage when subagent run fails
         'agent.model': 'mock-model',
         'agent.provider': 'mock-failed-usage-provider',
     });
-    const manager = new SubagentManager({ logger: createMockLogger(), settings });
+    const manager = new SubagentManager({
+        logger: createMockLogger(),
+        settings,
+        sessionContextService: createSessionContextService(),
+    });
     const result = await manager.run({
         role: 'explorer',
         task: 'find files',
@@ -1043,6 +1193,7 @@ test.serial('run() retries on recoverable model error (hallucinated tool) and su
             'agent.provider': 'mock-retry-recoverable-provider',
             'agent.retryAttempts': 2,
         }),
+        sessionContextService: createSessionContextService(),
         onEvent: (event) => events.push(event),
     });
     const result = await manager.run({ role: 'explorer', task: 'find all files' });
@@ -1078,6 +1229,7 @@ test.serial('run() exhausts retries on repeated recoverable model errors and ret
             'agent.provider': 'mock-retry-exhaust-provider',
             'agent.retryAttempts': 2,
         }),
+        sessionContextService: createSessionContextService(),
         onEvent: (event) => events.push(event),
     });
     const result = await manager.run({ role: 'explorer', task: 'find all files' });
@@ -1110,6 +1262,7 @@ test.serial('run() does not retry on non-recoverable ModelBehaviorError', async
             'agent.provider': 'mock-no-retry-non-recoverable-provider',
             'agent.retryAttempts': 2,
         }),
+        sessionContextService: createSessionContextService(),
         onEvent: (event) => events.push(event),
     });
     const result = await manager.run({ role: 'explorer', task: 'find all files' });
@@ -1139,6 +1292,7 @@ test.serial('run() aborted subagent returns cancelled status without model-error
             'agent.provider': 'mock-abort-no-retry-provider',
             'agent.retryAttempts': 2,
         }),
+        sessionContextService: createSessionContextService(),
         onEvent: (event) => events.push(event),
     });
     const result = await manager.run({ role: 'explorer', task: 'find all files' });
@@ -1183,6 +1337,7 @@ test.serial('run() retries on transient upstream error via executeWithRetry', as
             'agent.provider': 'mock-transient-retry-provider',
             'agent.retryAttempts': 2,
         }),
+        sessionContextService: createSessionContextService(),
     });
     const result = await manager.run({ role: 'explorer', task: 'find all files' });
     t.is(result.status, 'completed');
@@ -1218,6 +1373,7 @@ test.serial('run() does not retry worker after a mutating write tool was invoked
             'agent.provider': 'mock-write-then-crash-provider',
             'agent.retryAttempts': 2,
         }),
+        sessionContextService: createSessionContextService(),
         executionContext: {
             getCwd: () => tmpDir,
             isRemote: () => false,
@@ -1259,6 +1415,7 @@ test.serial('run() retries read-only subagent (explorer) even after read tools w
             'agent.provider': 'mock-explorer-read-then-crash-provider',
             'agent.retryAttempts': 2,
         }),
+        sessionContextService: createSessionContextService(),
     });
     const result = await manager.run({ role: 'explorer', task: 'search for something' });
     t.is(result.status, 'completed');
@@ -1288,6 +1445,7 @@ test.serial('corrective retry task for hallucination names the specific bad tool
             'agent.provider': 'mock-corrective-hallucination-provider',
             'agent.retryAttempts': 2,
         }),
+        sessionContextService: createSessionContextService(),
     });
     await manager.run({ role: 'explorer', task: 'do something' });
     t.is(runInputs.length, 2);
@@ -1319,6 +1477,7 @@ test.serial('corrective retry task for behavior error instructs model to produce
             'agent.provider': 'mock-corrective-behavior-provider',
             'agent.retryAttempts': 2,
         }),
+        sessionContextService: createSessionContextService(),
     });
     await manager.run({ role: 'explorer', task: 'do something' });
     t.is(runInputs.length, 2);
@@ -1326,4 +1485,376 @@ test.serial('corrective retry task for behavior error instructs model to produce
     t.true(retryInput.includes('final'), 'corrective prompt for behavior should instruct to produce a final answer');
     t.true(retryInput.includes('Do not call'), 'should tell model not to call more tools');
 });
+test.serial('subagent run injects warning into tool output when turns left <= 5', async (t) => {
+    let executeOutput = null;
+    registerProvider({
+        id: 'mock-subagent-maxturns-provider',
+        label: 'Mock Subagent MaxTurns Provider',
+        createRunner: () => ({
+            run: async (agent, _input, options) => {
+                if (options.callModelInputFilter) {
+                    // Simulate 96 turns
+                    for (let i = 0; i < 96; i++) {
+                        await options.callModelInputFilter({
+                            modelData: { input: [] },
+                            agent,
+                            context: options.context,
+                        });
+                    }
+                }
+                // Execute a tool to see if the warning is injected
+                const readFileTool = agent.tools.find((tool) => tool.name === 'read_file');
+                if (readFileTool) {
+                    const mockRunContext = {
+                        context: options.context,
+                    };
+                    executeOutput = await readFileTool.invoke(mockRunContext, JSON.stringify({ path: 'package.json' }), {});
+                }
+                return {
+                    status: 'completed',
+                    finalOutput: 'done',
+                    history: [],
+                    messages: [],
+                };
+            },
+        }),
+        fetchModels: async () => [{ id: 'mock-model' }],
+    });
+    const manager = new SubagentManager({
+        logger: createMockLogger(),
+        settings: createMockSettings({
+            'agent.model': 'mock-model',
+            'agent.provider': 'mock-subagent-maxturns-provider',
+        }),
+        sessionContextService: createSessionContextService(),
+    });
+    await manager.run({ role: 'explorer', task: 'mock task' });
+    t.truthy(executeOutput);
+    t.true(executeOutput.includes('approaching the maximum turn limit'), 'should contain max turns warning');
+    t.true(executeOutput.includes('4 turns left'), 'should indicate correct number of turns left');
+});
+test.serial('execution subagents select subagent-safe model-family prompts and append role instructions', async (t) => {
+    let constructedAgentExplorer = null;
+    let constructedAgentWorker = null;
+    let constructedAgentResearcher = null;
+    registerProvider({
+        id: 'mock-prompt-test-provider-gpt-5-codex',
+        label: 'Mock Prompt Test Provider GPT-5 Codex',
+        createRunner: () => ({
+            run: async (agent) => {
+                constructedAgentExplorer = agent;
+                return { status: 'completed', finalOutput: 'done', history: [], messages: [] };
+            },
+        }),
+        fetchModels: async () => [{ id: 'gpt-5-codex' }],
+    });
+    registerProvider({
+        id: 'mock-prompt-test-provider-claude-3-sonnet',
+        label: 'Mock Prompt Test Provider Claude 3 Sonnet',
+        createRunner: () => ({
+            run: async (agent) => {
+                constructedAgentWorker = agent;
+                return { status: 'completed', finalOutput: 'done', history: [], messages: [] };
+            },
+        }),
+        fetchModels: async () => [{ id: 'claude-3-sonnet' }],
+    });
+    registerProvider({
+        id: 'mock-prompt-test-provider-gpt-5-modern',
+        label: 'Mock Prompt Test Provider GPT-5 Modern',
+        createRunner: () => ({
+            run: async (agent) => {
+                constructedAgentResearcher = agent;
+                return { status: 'completed', finalOutput: 'done', history: [], messages: [] };
+            },
+        }),
+        fetchModels: async () => [{ id: 'gpt-5' }],
+    });
+    // 1. Run explorer subagent with gpt-5-codex
+    const managerExplorer = new SubagentManager({
+        logger: createMockLogger(),
+        settings: createMockSettings({
+            'agent.model': 'gpt-5-codex',
+            'agent.provider': 'mock-prompt-test-provider-gpt-5-codex',
+        }),
+        sessionContextService: createSessionContextService(),
+    });
+    await managerExplorer.run({ role: 'explorer', task: 'explorer task' });
+    t.truthy(constructedAgentExplorer);
+    t.true(constructedAgentExplorer.instructions.includes('nested Codex-family subagent'));
+    t.true(constructedAgentExplorer.instructions.includes('You are an explorer subagent.'));
+    t.true(constructedAgentExplorer.instructions.includes('## Worktree Hygiene'));
+    t.true(constructedAgentExplorer.instructions.includes('## Available Tool Guidance'));
+    const codexIdx = constructedAgentExplorer.instructions.indexOf('nested Codex-family subagent');
+    const explorerIdx = constructedAgentExplorer.instructions.indexOf('You are an explorer subagent');
+    t.true(codexIdx < explorerIdx, 'Model prompt must come before role prompt');
+    // 2. Run worker subagent with claude-3-sonnet
+    const managerWorker = new SubagentManager({
+        logger: createMockLogger(),
+        settings: createMockSettings({
+            'agent.model': 'claude-3-sonnet',
+            'agent.provider': 'mock-prompt-test-provider-claude-3-sonnet',
+        }),
+        sessionContextService: createSessionContextService(),
+    });
+    await managerWorker.run({ role: 'worker', task: 'worker task' });
+    t.truthy(constructedAgentWorker);
+    t.true(constructedAgentWorker.instructions.includes('nested Anthropic-family subagent'));
+    t.true(constructedAgentWorker.instructions.includes('You are a worker subagent.'));
+    const sonnetIdx = constructedAgentWorker.instructions.indexOf('nested Anthropic-family subagent');
+    const workerIdx = constructedAgentWorker.instructions.indexOf('You are a worker subagent');
+    t.true(sonnetIdx < workerIdx, 'Model prompt must come before role prompt');
+    const managerResearcher = new SubagentManager({
+        logger: createMockLogger(),
+        settings: createMockSettings({
+            'agent.model': 'gpt-5',
+            'agent.provider': 'mock-prompt-test-provider-gpt-5-modern',
+        }),
+        sessionContextService: createSessionContextService(),
+    });
+    await managerResearcher.run({ role: 'researcher', task: 'research task' });
+    t.truthy(constructedAgentResearcher);
+    t.true(constructedAgentResearcher.instructions.includes('nested GPT-5-family subagent'));
+    t.true(constructedAgentResearcher.instructions.includes('You are a researcher subagent.'));
+});
+test.serial('execution subagent prompts exclude top-level-only prompt content', async (t) => {
+    let constructedAgent = null;
+    registerProvider({
+        id: 'mock-top-level-exclusion-provider',
+        label: 'Mock Top Level Exclusion Provider',
+        createRunner: () => ({
+            run: async (agent) => {
+                constructedAgent = agent;
+                return { status: 'completed', finalOutput: 'done', history: [], messages: [] };
+            },
+        }),
+        fetchModels: async () => [{ id: 'gpt-5-codex' }],
+    });
+    const manager = new SubagentManager({
+        logger: createMockLogger(),
+        settings: createMockSettings({
+            'agent.model': 'gpt-5-codex',
+            'agent.provider': 'mock-top-level-exclusion-provider',
+        }),
+        sessionContextService: createSessionContextService(),
+    });
+    await manager.run({ role: 'worker', task: 'worker task' });
+    t.truthy(constructedAgent);
+    t.false(constructedAgent.instructions.includes('commentary channel'));
+    t.false(constructedAgent.instructions.includes('final channel'));
+    t.false(constructedAgent.instructions.includes('Intermediary updates'));
+    t.false(constructedAgent.instructions.includes('Plan Mode Workflow'));
+    t.false(constructedAgent.instructions.includes('You are Codex, a coding agent based on GPT-5.'));
+});
+test.serial('mentor subagent is NOT affected by prompt profiles', async (t) => {
+    let mentorAgent = null;
+    registerProvider({
+        id: 'mock-prompt-test-provider-mentor',
+        label: 'Mock Prompt Test Provider Mentor',
+        createRunner: () => ({
+            run: async (agent) => {
+                mentorAgent = agent;
+                return { status: 'completed', finalOutput: 'done', history: [], messages: [] };
+            },
+        }),
+        fetchModels: async () => [{ id: 'gpt-5-codex' }],
+    });
+    const manager = new SubagentManager({
+        logger: createMockLogger(),
+        settings: createMockSettings({
+            'agent.model': 'main-model',
+            'agent.provider': 'mock-prompt-test-provider-mentor',
+            'agent.mentorModel': 'gpt-5-codex',
+            'agent.mentorProvider': 'mock-prompt-test-provider-mentor',
+            'app.mentorMode': false,
+        }),
+        sessionContextService: createSessionContextService(),
+    });
+    await manager.run({ role: 'mentor', task: 'advise me' });
+    t.truthy(mentorAgent);
+    t.false(mentorAgent.instructions.includes('You are Codex, a coding agent based on GPT-5.'));
+    t.false(mentorAgent.instructions.includes('nested Codex-family subagent'));
+    t.false(mentorAgent.instructions.includes('## Available Tool Guidance'));
+    t.false(mentorAgent.instructions.includes('## Worktree Hygiene'));
+    t.true(mentorAgent.instructions.includes('You are a helpful mentor assistant.'));
+});
+test.serial('subagent tool definitions conditional registration for search tools', async (t) => {
+    let workerAgentShellTrue = null;
+    let workerAgentShellFalse = null;
+    registerProvider({
+        id: 'mock-tool-test-provider-shell-true',
+        label: 'Mock Tool Test Provider Shell True',
+        createRunner: () => ({
+            run: async (agent) => {
+                workerAgentShellTrue = agent;
+                return { status: 'completed', finalOutput: 'done', history: [], messages: [] };
+            },
+        }),
+        fetchModels: async () => [{ id: 'gpt-5' }],
+    });
+    registerProvider({
+        id: 'mock-tool-test-provider-shell-false',
+        label: 'Mock Tool Test Provider Shell False',
+        createRunner: () => ({
+            run: async (agent) => {
+                workerAgentShellFalse = agent;
+                return { status: 'completed', finalOutput: 'done', history: [], messages: [] };
+            },
+        }),
+        fetchModels: async () => [{ id: 'gpt-4o' }],
+    });
+    // 1. Model: gpt-5 (searchViaShell is true by default), canRunShell: true (from worker.md)
+    // Explorer/worker tools should NOT contain dedicated search tools: grep and find_files.
+    const managerShellTrue = new SubagentManager({
+        logger: createMockLogger(),
+        settings: createMockSettings({
+            'agent.model': 'gpt-5',
+            'agent.provider': 'mock-tool-test-provider-shell-true',
+            'app.searchViaShell': 'auto',
+        }),
+        sessionContextService: createSessionContextService(),
+    });
+    await managerShellTrue.run({ role: 'worker', task: 'some task' });
+    t.truthy(workerAgentShellTrue);
+    const toolNamesShellTrue = workerAgentShellTrue.tools.map((tool) => tool.name);
+    t.false(toolNamesShellTrue.includes('grep'), 'grep tool should be omitted when searchViaShell is active and canRunShell is true');
+    t.false(toolNamesShellTrue.includes('find_files'), 'find_files tool should be omitted when searchViaShell is active and canRunShell is true');
+    t.true(toolNamesShellTrue.includes('shell'), 'shell tool must be registered');
+    t.true(workerAgentShellTrue.instructions.includes('Registered tools:'));
+    t.true(workerAgentShellTrue.instructions.includes('use `shell` with commands like `rg`'));
+    t.true(workerAgentShellTrue.instructions.includes('`fd` for file search'));
+    t.false(workerAgentShellTrue.instructions.includes('Use `grep` to search'));
+    t.false(workerAgentShellTrue.instructions.includes('Use `find_files` to locate'));
+    t.false(workerAgentShellTrue.instructions.includes('For workspace search, use the dedicated search tools'));
+    // 2. Model: gpt-4o (searchViaShell is false by default), canRunShell: true
+    // Tools should include dedicated grep and find_files.
+    const managerShellFalse = new SubagentManager({
+        logger: createMockLogger(),
+        settings: createMockSettings({
+            'agent.model': 'gpt-4o',
+            'agent.provider': 'mock-tool-test-provider-shell-false',
+            'app.searchViaShell': 'auto',
+        }),
+        sessionContextService: createSessionContextService(),
+    });
+    await managerShellFalse.run({ role: 'worker', task: 'some task' });
+    t.truthy(workerAgentShellFalse);
+    const toolNamesShellFalse = workerAgentShellFalse.tools.map((tool) => tool.name);
+    t.true(toolNamesShellFalse.includes('grep'), 'grep tool should be registered when searchViaShell is inactive');
+    t.true(toolNamesShellFalse.includes('find_files'), 'find_files tool should be registered when searchViaShell is inactive');
+    t.true(toolNamesShellFalse.includes('shell'), 'shell tool must be registered');
+    t.true(workerAgentShellFalse.instructions.includes('For workspace search, use the dedicated search tools'));
+    t.true(workerAgentShellFalse.instructions.includes('`grep`'));
+    t.true(workerAgentShellFalse.instructions.includes('`find_files`'));
+    t.false(workerAgentShellFalse.instructions.includes('use `shell` with commands like `rg`'));
+    // 3. Model: gpt-5 with searchViaShell explicitly disabled still keeps dedicated search tools.
+    const managerShellOff = new SubagentManager({
+        logger: createMockLogger(),
+        settings: createMockSettings({
+            'agent.model': 'gpt-5',
+            'agent.provider': 'mock-tool-test-provider-shell-true',
+            'app.searchViaShell': 'off',
+        }),
+        sessionContextService: createSessionContextService(),
+    });
+    await managerShellOff.run({ role: 'worker', task: 'some task' });
+    const toolNamesShellOff = workerAgentShellTrue.tools.map((tool) => tool.name);
+    t.true(toolNamesShellOff.includes('grep'), 'grep tool should remain registered when searchViaShell is off');
+    t.true(toolNamesShellOff.includes('find_files'), 'find_files tool should remain registered when searchViaShell is off');
+    t.true(toolNamesShellOff.includes('shell'), 'shell tool must still be registered');
+    t.true(workerAgentShellTrue.instructions.includes('For workspace search, use the dedicated search tools'));
+    t.false(workerAgentShellTrue.instructions.includes('use `shell` with commands like `rg`'));
+});
+test.serial('explorer uses shell search when available and researcher keeps dedicated search tools', async (t) => {
+    let explorerAgent = null;
+    let researcherAgent = null;
+    registerProvider({
+        id: 'mock-tool-test-provider-explorer-shell',
+        label: 'Mock Tool Test Provider Explorer Shell',
+        createRunner: () => ({
+            run: async (agent) => {
+                explorerAgent = agent;
+                return { status: 'completed', finalOutput: 'done', history: [], messages: [] };
+            },
+        }),
+        fetchModels: async () => [{ id: 'gpt-5' }],
+    });
+    registerProvider({
+        id: 'mock-tool-test-provider-researcher-dedicated',
+        label: 'Mock Tool Test Provider Researcher Dedicated',
+        createRunner: () => ({
+            run: async (agent) => {
+                researcherAgent = agent;
+                return { status: 'completed', finalOutput: 'done', history: [], messages: [] };
+            },
+        }),
+        fetchModels: async () => [{ id: 'gpt-5' }],
+    });
+    await new SubagentManager({
+        logger: createMockLogger(),
+        settings: createMockSettings({
+            'agent.model': 'gpt-5',
+            'agent.provider': 'mock-tool-test-provider-explorer-shell',
+            'app.searchViaShell': 'auto',
+        }),
+        sessionContextService: createSessionContextService(),
+    }).run({ role: 'explorer', task: 'find files' });
+    await new SubagentManager({
+        logger: createMockLogger(),
+        settings: createMockSettings({
+            'agent.model': 'gpt-5',
+            'agent.provider': 'mock-tool-test-provider-researcher-dedicated',
+            'app.searchViaShell': 'auto',
+        }),
+        sessionContextService: createSessionContextService(),
+    }).run({ role: 'researcher', task: 'research files' });
+    t.truthy(explorerAgent);
+    let toolNames = explorerAgent.tools.map((tool) => tool.name);
+    t.true(toolNames.includes('shell'));
+    t.false(toolNames.includes('grep'));
+    t.false(toolNames.includes('find_files'));
+    t.true(explorerAgent.instructions.includes('For workspace search, use `shell` with commands like `rg`'));
+    t.false(explorerAgent.instructions.includes('For workspace search, use the dedicated search tools'));
+    t.truthy(researcherAgent);
+    toolNames = researcherAgent.tools.map((tool) => tool.name);
+    t.false(toolNames.includes('shell'));
+    t.true(toolNames.includes('grep'));
+    t.true(toolNames.includes('find_files'));
+    t.true(researcherAgent.instructions.includes('For workspace search, use the dedicated search tools'));
+    t.false(researcherAgent.instructions.includes('use `shell` with commands like `rg`'));
+});
+test.serial('remote execution disables code-context tools and guidance', async (t) => {
+    let remoteAgent = null;
+    registerProvider({
+        id: 'mock-tool-test-provider-remote',
+        label: 'Mock Tool Test Provider Remote',
+        createRunner: () => ({
+            run: async (agent) => {
+                remoteAgent = agent;
+                return { status: 'completed', finalOutput: 'done', history: [], messages: [] };
+            },
+        }),
+        fetchModels: async () => [{ id: 'gpt-4o' }],
+    });
+    const manager = new SubagentManager({
+        logger: createMockLogger(),
+        settings: createMockSettings({
+            'agent.model': 'gpt-4o',
+            'agent.provider': 'mock-tool-test-provider-remote',
+        }),
+        executionContext: {
+            getCwd: () => '/tmp/remote-workspace',
+            isRemote: () => true,
+            getSSHService: () => undefined,
+        },
+        sessionContextService: createSessionContextService(),
+    });
+    await manager.run({ role: 'explorer', task: 'inspect remote files' });
+    t.truthy(remoteAgent);
+    const toolNames = remoteAgent.tools.map((tool) => tool.name);
+    t.false(toolNames.includes('read_code_outline'));
+    t.false(toolNames.includes('code_context_search'));
+    t.true(remoteAgent.instructions.includes('Code-context tools are not available in this run.'));
+    t.false(remoteAgent.instructions.includes('For code structure and symbol context, use:'));
+});
 //# sourceMappingURL=subagent-manager.test.js.map