zames_pro 2.70.0 → 2.71.0

package/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.71.0] - 2026-10-08
+
+### Added
+
+- **subagent:** add the Task tool, enable subagents by default and instruct the model when to delegate
+
 ## [2.70.0] - 2026-10-08
 
 ### Added

package/README.md

@@ -100,6 +100,10 @@ Key pieces:
 - **Project context** — reads `AGENTS.md`, `MEMORY.md`, skills (`SKILL.md`) and
   custom commands from the repo and `~/.zames`, the same idea as Codex / Claude
   Code.
+- **Subagents** — the `Task` tool delegates a self-contained sub-task to an
+  agent in its own separate chat (isolated context), which returns only a
+  report, so heavy research does not flood the main context. On by default;
+  tune with `browser.subagents` / `browser.maxSubagents`.
 - **MCP support** — plug in external tool servers (e.g. `@playwright/mcp`).
 - **Scheduling** — `/loop`, `/cron` and `/jobs` repeat tasks on a timer.
 - **Bilingual UI** — Russian / English (`/config lang`).
@@ -573,6 +577,10 @@ zames не вызывает API модели. Он запускает headless C
 - **Контекст проекта** — читает `AGENTS.md`, `MEMORY.md`, навыки (`SKILL.md`) и
   пользовательские команды из репозитория и `~/.zames`, как в Codex / Claude
   Code.
+- **Субагенты** — инструмент `Task` поручает самодостаточную подзадачу агенту
+  в отдельном чате (изолированный контекст), который возвращает только отчёт,
+  так что тяжёлая разведка не засоряет основной контекст. Включены по
+  умолчанию; настраиваются через `browser.subagents` / `browser.maxSubagents`.
 - **Поддержка MCP** — подключение внешних серверов инструментов (например,
   `@playwright/mcp`).
 - **Планировщик** — `/loop`, `/cron` и `/jobs` повторяют задачи по таймеру.

package/dist/agent-loop.js

@@ -7,7 +7,7 @@ import { substituteAttachmentMarkers } from './commands.js';
 import { normText } from './browser.js';
 import { loadHooks, runPreToolUse, runPostToolUse, } from './hooks.js';
 import { loadPermissions, decidePermission, } from './permissions.js';
-export async function runAgentLoop({ browser, tools, task, workdir, maxIterations = 0, freshChat = false, sendSystemPrompt = false, transcript = null, attachments = [], onThinking = () => { }, onSendPause = () => { }, onSendState = () => { }, onNotice = () => { }, onAssistantThought = () => { }, onToolCall = () => { }, onToolResult = () => { }, onAssistantMessage = () => { }, onChatReady = () => { }, onWarning = () => { }, debugLog = false, locale = 'ru', askDeadlineMs = 240_000, maxAfterToolRetries = 6, onAutoCompact = null, autoCompactPct = 95, contextLimit = 1_000_000, getTokenUsage = null, hooks = undefined, permissions = undefined, onAskPermission = undefined, selfImprovement = false, }) {
+export async function runAgentLoop({ browser, tools, task, workdir, maxIterations = 0, freshChat = false, sendSystemPrompt = false, transcript = null, attachments = [], onThinking = () => { }, onSendPause = () => { }, onSendState = () => { }, onNotice = () => { }, onAssistantThought = () => { }, onToolCall = () => { }, onToolResult = () => { }, onAssistantMessage = () => { }, onChatReady = () => { }, onWarning = () => { }, debugLog = false, locale = 'ru', askDeadlineMs = 240_000, maxAfterToolRetries = 6, onAutoCompact = null, autoCompactPct = 95, contextLimit = 1_000_000, getTokenUsage = null, hooks = undefined, permissions = undefined, onAskPermission = undefined, selfImprovement = false, onSubagent = null, }) {
     // Resolve the hook config ONCE per task: a read per tool call would be
     // wasteful, and a mid-task edit of hooks.json is not something to chase.
     // `undefined` means "read .zames/hooks.json"; an explicit null disables
@@ -705,6 +705,76 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
             continue;
         }
         for (const call of callsToRun) {
+            // `Task` is a SEAM, not an ordinary tool: it is handled by the caller's
+            // onSubagent callback (a separate chat with its own context). It is not
+            // in `tools` when subagents are disabled, so it is matched by name here
+            // BEFORE the unknown-tool branch. With no callback we answer honestly
+            // instead of pretending the tool exists.
+            if (call.tool === 'Task') {
+                const rawPrompt = typeof call.args.prompt === 'string' ? call.args.prompt.trim() : '';
+                const rawType = String(call.args.subagent_type ?? '').toLowerCase();
+                const subType = rawType === 'explore' ? 'explore' : 'general';
+                const rawDesc = typeof call.args.description === 'string' ? call.args.description : '';
+                if (!onSubagent || !rawPrompt) {
+                    const err = !onSubagent
+                        ? 'Subagents are not available in this run. Do the work yourself with the other tools.'
+                        : 'Task requires a non-empty `prompt` argument.';
+                    safeToolResult(err);
+                    transcript?.log('tool_error', { tool: 'Task', error: err });
+                    results.push({ tool: 'Task', result: err });
+                    continue;
+                }
+                syncToolAbort();
+                safeToolCall('Task', call.args);
+                transcript?.log('subagent_start', {
+                    type: subType,
+                    description: rawDesc,
+                    prompt: rawPrompt,
+                });
+                const poll = setInterval(syncToolAbort, 100);
+                if (typeof poll.unref === 'function')
+                    poll.unref();
+                const subStart = Date.now();
+                let subResult;
+                try {
+                    subResult = await onSubagent({
+                        prompt: rawPrompt,
+                        description: rawDesc,
+                        type: subType,
+                    });
+                }
+                catch (e) {
+                    subResult = {
+                        ok: false,
+                        text: `Subagent error: ${e.message}`,
+                    };
+                }
+                finally {
+                    clearInterval(poll);
+                }
+                const subText = String(subResult.text || '').trim();
+                const subOut = subResult.ok
+                    ? subText || '(the subagent returned no report)'
+                    : `Subagent failed: ${subText || 'unknown error'}`;
+                safeToolResult(subOut);
+                transcript?.log('subagent_done', {
+                    type: subType,
+                    ok: subResult.ok,
+                    chars: subText.length,
+                    durationMs: Date.now() - subStart,
+                });
+                results.push({ tool: 'Task', result: subOut });
+                // The subagent switched the chat underneath us and the callback has
+                // already restored the parent chat. Clear the stale-echo baseline:
+                // the capture left over from the subagent's chat would otherwise make
+                // the watchdog compare the parent's next answer against IT and fire.
+                lastRaw = '';
+                if (browser._abort || browser._stopped) {
+                    transcript?.log('user_aborted');
+                    return '(прервано пользователем)';
+                }
+                continue;
+            }
             const tool = tools.find((t) => t.name === call.tool);
             if (!tool) {
                 const err = `Unknown tool: ${call.tool}`;

package/dist/config.js

@@ -50,6 +50,10 @@ export const DEFAULTS = {
         autoCompact: false,
         autoCompactPct: 95,
         resendPromptOnResume: false,
+        // Subagents on by default: the Task tool is what keeps heavy exploration
+        // out of the main context, and the main chat is restored afterwards.
+        subagents: true,
+        maxSubagents: 3,
         deepThinking: false,
         webSearch: true,
         auth: {
@@ -318,6 +322,20 @@ export const CONFIG_SCHEMA = [
         labelKey: 'cfg.f.browser_resendPromptOnResume',
         groupKey: 'cfg.group.browser',
     },
+    {
+        path: 'browser.subagents',
+        type: 'boolean',
+        labelKey: 'cfg.f.browser_subagents',
+        groupKey: 'cfg.group.browser',
+    },
+    {
+        path: 'browser.maxSubagents',
+        type: 'number',
+        min: 0,
+        max: 20,
+        labelKey: 'cfg.f.browser_maxSubagents',
+        groupKey: 'cfg.group.browser',
+    },
     {
         path: 'browser.deepThinking',
         type: 'boolean',

package/dist/i18n/config.js

@@ -119,6 +119,14 @@ export const configMessages = {
         ru: 'Пересылать системный промпт при возобновлении чата',
         en: 'Resend the system prompt on chat resume',
     },
+    'cfg.f.browser_subagents': {
+        ru: 'Субагенты: инструмент Task (отдельный чат)',
+        en: 'Subagents: the Task tool (separate chat)',
+    },
+    'cfg.f.browser_maxSubagents': {
+        ru: 'Максимум субагентов на задачу',
+        en: 'Max subagents per task',
+    },
     'cfg.f.browser_deepThinking': {
         ru: 'Глубокое мышление (долго; размышления не выводятся)',
         en: 'Deep thinking (slow; reasoning is hidden)',

package/dist/index.js

@@ -6,9 +6,10 @@ import { existsSync, statSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { theme } from './theme.js';
 import { DeepSeekBrowser, headlessUACacheReady } from './browser.js';
-import { createTools, mergeTools } from './tools.js';
+import { createTools, mergeTools, filterToolsForReadOnly } from './tools.js';
 import { createTodoStore, getTodos, setTodos, resetTodos, renderTodos, } from './extraTools.js';
 import { runAgentLoop } from './agent-loop.js';
+import { createSubagentRunner } from './subagent.js';
 import { createSpinner } from './spinner.js';
 import { LineEditor } from './input.js';
 import { parseImagePaste, extForMime, saveToTemp, guessMime, formatSize, readClipboardImageDetailed, sniffMime, readWindowsClipboardFiles, hasClipboardTool, writeClipboardText, contentHash, } from './attachments.js';
@@ -1121,6 +1122,33 @@ async function main() {
     // Write the checklist whenever the agent changes it, so a restart/resume
     // brings the tasks back (they used to be in-memory only).
     todoStore.onChange = () => persistTodos();
+    // Subagents (BACKLOG N36): the `Task` tool delegates a self-contained
+    // sub-task to a nested agent loop in its OWN chat (context isolation — in
+    // zames "context" IS the chat), then restores this chat and returns only
+    // the report. Sequential by design (one browser, one send slot). On by
+    // default via browser.subagents (its own budget caps the extra sends).
+    const makeSubagentRunner = () => config.browser.subagents
+        ? createSubagentRunner({
+            browser,
+            workdir: currentWorkdir,
+            locale: currentLocale,
+            runAgentLoop: mod.runAgentLoop,
+            buildTools: (readOnly) => {
+                const base = mod.createTools(currentWorkdir, {
+                    undo,
+                    todos: todoStore,
+                    readOnly: false,
+                    subagents: false,
+                });
+                return readOnly ? filterToolsForReadOnly(base) : base;
+            },
+            transcript,
+            maxSubagents: config.browser.maxSubagents,
+            askDeadlineMs: config.browser.askDeadlineMs,
+            maxAfterToolRetries: config.browser.maxAfterToolRetries,
+            selfImprovement: devMode,
+        })
+        : null;
     // A compact "tasks: 2/5" summary for the status line. Empty when the list
     // is empty, so an idle status is not cluttered.
     const todosSummary = () => {
@@ -3395,6 +3423,9 @@ async function main() {
             undo,
             todos: todoStore,
             readOnly: planMode,
+            // `Task` is only offered when subagents are enabled AND we are not in
+            // plan (read-only) mode — a `general` subagent could write otherwise.
+            subagents: config.browser.subagents && !planMode,
         });
         const tools = mergeTools(baseTools, mcpPool?.tools, planMode);
         if (editor)
@@ -3452,6 +3483,7 @@ async function main() {
                 goal: sessionGoal,
                 todosQuery: () => todosSummary(),
                 selfImprovement: devMode,
+                onSubagent: makeSubagentRunner(),
             }, inputAttachments);
         }
         finally {

package/dist/run-task.js

@@ -237,7 +237,7 @@ export function watchInput({ onEscape, onChange, onQueue, } = {}) {
 }
 export async function runTask(deps, browser, tools, taskText, workdir, opts, attachments = []) {
     const { t, locale, debug, maxIter, config, runAgentLoop, createSpinner } = deps;
-    const { transcript, freshChat, sendSystemPrompt, queue = [], ui: editor, onChatReady, onAutoCompact = null, autoCompactPct = 95, contextLimit = 1_000_000, getTokenUsage = null, goal = null, todosQuery = null, selfImprovement = false, } = opts;
+    const { transcript, freshChat, sendSystemPrompt, queue = [], ui: editor, onChatReady, onAutoCompact = null, autoCompactPct = 95, contextLimit = 1_000_000, getTokenUsage = null, goal = null, todosQuery = null, selfImprovement = false, onSubagent = null, } = opts;
     // In TTY mode the UI is a LineEditor: it owns the input (queue, Esc,
     // Ctrl+C) and draws the status ABOVE the permanent input line. In non-TTY
     // mode (pipes) - a regular spinner + watchInput.
@@ -358,6 +358,7 @@ export async function runTask(deps, browser, tools, taskText, workdir, opts, att
                 contextLimit,
                 getTokenUsage,
                 selfImprovement,
+                onSubagent,
             });
             // The loop may end WITHOUT a model answer: an exhausted iteration limit
             // or an ask() watchdog. Surface it instead of a silent stop.

package/dist/subagent.js

@@ -0,0 +1,119 @@
+// Subagent runner (BACKLOG N36). A `Task` tool call from the model is handled
+// by the agent loop as a SEAM (like onAutoCompact): it calls back into the
+// caller, which owns the whole lifecycle. This module builds that callback.
+//
+// Why a SEPARATE chat: in zames "context" IS the DeepSeek chat, so context
+// isolation can only be achieved by opening a new chat, running a nested
+// agent loop there, and restoring the parent chat afterwards. The nested loop
+// returns ONLY the subagent's final `respond` report; the parent never sees
+// the subagent's raw turns, which is the whole point.
+//
+// This is deliberately SEQUENTIAL: one browser, one send slot. Parallel
+// subagents would need a second page and a shared send scheduler (a change to
+// browser.ts, which owns the live Playwright context) — out of scope here.
+/** Hard cap on iterations for one subagent run. */
+export const SUBAGENT_MAX_ITER = 30;
+/**
+ * The subagent persona, prepended to the task message. It is deliberately NOT
+ * injected as a replacement system prompt: the nested runAgentLoop builds the
+ * standard system prompt itself (tool list + call format), and the model needs
+ * exactly that to work. The persona only adds role + output contract.
+ */
+export function subagentPersona(type) {
+    const base = 'You are a SUBAGENT launched by a main coding agent to complete ONE ' +
+        'self-contained sub-task in an ISOLATED chat. You do NOT see the main ' +
+        "conversation's history, so rely only on the instructions below and on " +
+        'the files/tools available. You cannot talk to the operator, so do not ' +
+        'ask questions. When the sub-task is done, call respond with a concise, ' +
+        'information-dense report: findings, exact file paths, relevant code ' +
+        'snippets and a clear conclusion. Do NOT call respond until the work is ' +
+        'complete.';
+    if (type === 'explore') {
+        return (base +
+            '\n\nYou are in EXPLORE (read-only) mode: you may search and read files ' +
+            'but you CANNOT modify anything or run mutating commands. Investigate ' +
+            'and report your findings.');
+    }
+    return base;
+}
+/**
+ * Build the `onSubagent` callback for runAgentLoop. It enforces the per-task
+ * budget, opens a fresh chat, runs a nested loop (with the subagent's own
+ * task text and a restricted or full tool set), restores the parent chat and
+ * returns only the report.
+ */
+export function createSubagentRunner(opts) {
+    const { browser, workdir, locale, runAgentLoop, buildTools, transcript = null, maxSubagents, askDeadlineMs, maxAfterToolRetries, selfImprovement = false, onAskPermission, } = opts;
+    let used = 0;
+    return async (req) => {
+        if (used >= maxSubagents) {
+            return {
+                ok: false,
+                text: 'Subagent budget exhausted (' +
+                    maxSubagents +
+                    ' per task). Do the remaining work yourself with the other tools.',
+            };
+        }
+        used++;
+        const parentChatId = await browser.getCurrentChatId().catch(() => null);
+        const subTools = buildTools(req.type === 'explore');
+        const taskText = subagentPersona(req.type) + '\n\n--- SUB-TASK ---\n' + req.prompt;
+        // Save the parent's send hooks: the nested loop OVERWRITES them on
+        // browser, and leaving the nested (no-op) callbacks in place would kill
+        // the parent's spinner/status for the rest of the task.
+        const savedHooks = {
+            onSendStart: browser.onSendStart ?? null,
+            onSendPause: browser.onSendPause ?? null,
+            onSendState: browser.onSendState ?? null,
+            onNotice: browser.onNotice ?? null,
+        };
+        let report = '';
+        let failed = '';
+        try {
+            report = await runAgentLoop({
+                browser,
+                tools: subTools,
+                task: taskText,
+                workdir,
+                maxIterations: SUBAGENT_MAX_ITER,
+                // A fresh chat gives the subagent an isolated context; the nested loop
+                // opens it AND sends the standard system prompt itself.
+                freshChat: true,
+                sendSystemPrompt: true,
+                transcript,
+                locale,
+                askDeadlineMs,
+                maxAfterToolRetries,
+                selfImprovement,
+                // No recursion: the subagent cannot spawn its own subagents.
+                onSubagent: null,
+                // Do not persist the subagent chat as a session.
+                onChatReady: () => { },
+                onAskPermission: onAskPermission
+                    ? (info) => onAskPermission({
+                        tool: info.tool,
+                        reason: info.reason,
+                        action: info.action,
+                    })
+                    : undefined,
+            });
+        }
+        catch (e) {
+            failed = e.message;
+        }
+        finally {
+            // Restore the parent chat, then the hooks, so a failure in openChat
+            // still leaves the hooks correct.
+            if (parentChatId) {
+                await browser.openChat(parentChatId).catch(() => false);
+            }
+            browser.onSendStart = savedHooks.onSendStart;
+            browser.onSendPause = savedHooks.onSendPause;
+            browser.onSendState = savedHooks.onSendState;
+            browser.onNotice = savedHooks.onNotice;
+        }
+        if (failed)
+            return { ok: false, text: failed };
+        return { ok: true, text: report };
+    };
+}

package/dist/system-prompt.js

@@ -21,6 +21,35 @@ Rules for that note:
 - this is the ONE exception to "do not touch unrelated files". If nothing
   worth noting, add nothing.
 `;
+// Guidance for the `Task` tool (subagents), injected only when that tool is in
+// the model's set. Without it the model under-uses subagents (it does every
+// broad search itself and floods the main context) or misuses them (delegates
+// work that needs THIS conversation's history, which the isolated subagent
+// cannot see). Kept short: it competes with the tool list for space.
+const SUBAGENT_SECTION = `
+## Task tool (subagents)
+
+The Task tool delegates a self-contained sub-task to a subagent that works in
+its OWN separate chat with an ISOLATED context and returns ONLY a final
+report. The subagent does NOT see this conversation, so the prompt you pass
+must be fully self-contained (goal, exact questions, file paths, context).
+
+Use it to PROTECT this chat's context and to parallelize independent work:
+
+- Broad exploration whose raw hits would flood this chat ("find every use of
+  X", "map how module Y works end to end"): delegate it with
+  subagent_type "explore" (read-only) and keep only the report.
+- A self-contained research or verification sub-task you can specify in a
+  paragraph: delegate it and continue the main line meanwhile.
+- Several INDEPENDENT investigations: emit several Task calls in ONE batch.
+
+Do NOT use it for:
+- work that depends on this conversation's history (the subagent cannot see
+  it) - pass everything needed in the prompt, or do the work yourself;
+- a trivial single read/edit you can do directly (a subagent costs a full
+  extra chat with its own system prompt and sends);
+- edits that must run strictly in order with the rest of this chat.
+`;
 /** Render the AGENTS.md / MEMORY / skills / commands blocks of the prompt. */
 export function renderContextSection(context) {
     if (!context)
@@ -112,6 +141,12 @@ export function renderToolSection(tools) {
 export function buildSystemPrompt({ workdir, tools, gitContext = null, locale = 'ru', attachments = [], context = null, selfImprovement = false, }) {
     const t = translate(locale);
     const toolDescriptions = renderToolSection(tools);
+    // Emit the subagent guidance ONLY when the Task tool is actually in the set
+    // (subagents enabled and not in plan mode), so the prompt never tells the
+    // model about a tool it does not have.
+    const subagentSection = tools.some((x) => x.name === 'Task')
+        ? SUBAGENT_SECTION
+        : '';
     const gitSection = gitContext
         ? `\n## Git context\n\n${gitContext}\n`
         : '\n## Git context\n\nNot a git repository (or git is not installed).\n';
@@ -186,7 +221,9 @@ Prefer the most specific tool; a wrong choice wastes a turn:
   directory -> LS.
 - Git operations -> the Git* tools, not Bash.
 - Reading a file whose path you already know -> Read, not Bash cat.
-
+- A broad search/exploration that would flood this chat -> the Task tool
+  (a subagent in its own chat) if it is available, then work from its report.
+${subagentSection}
 ## MCP tools
 
 Some tools are provided by external MCP servers and their names look

package/dist/tools.js

@@ -9,7 +9,7 @@ import { createExtraTools } from './extraTools.js';
 // user-facing. They must be in ENGLISH (like Claude Code / Codex). Only the
 // strings the OPERATOR sees (help, spinner, service messages) are localized —
 // those live in src/i18n.ts (CATALOG) and are picked by the locale setting.
-export function createTools(workdir, { undo, todos, readOnly = false, } = {}) {
+export function createTools(workdir, { undo, todos, readOnly = false, subagents = false, } = {}) {
     const root = path.resolve(workdir);
     const safe = (p) => safePath(root, p);
     // Extracts text from content/content_base64. base64 is needed because the
@@ -200,11 +200,34 @@ export function createTools(workdir, { undo, todos, readOnly = false, } = {}) {
         parameters: { message: 'string' },
         fn: async ({ message }) => message,
     };
+    // `Task` is a SEAM handled by the agent loop (onSubagent), not an ordinary
+    // fn. Its body here is only a fallback for a direct unit-test call; the live
+    // path never reaches it because agent-loop intercepts the name first.
+    const taskTool = {
+        name: 'Task',
+        description: 'Delegate a self-contained sub-task to a SUBAGENT that works in its own ' +
+            'separate chat with an isolated context, then returns ONLY a final ' +
+            'report. Use it to keep heavy research out of the main context. ' +
+            'subagent_type: "explore" (read-only: search/read, cannot modify) or ' +
+            '"general" (full tools). The subagent does NOT see this conversation, so ' +
+            '`prompt` must be fully self-contained: state the goal, the exact ' +
+            'questions, and any file paths/context it needs. Returns the subagent ' +
+            'report as text.',
+        parameters: {
+            description: 'string',
+            prompt: 'string',
+            subagent_type: 'string?',
+        },
+        fn: async () => 'Subagents are not available in this run. Do the work yourself.',
+    };
+    // In plan (read-only) mode `Task` is dropped too: a `general` subagent could
+    // otherwise write through it and defeat the read-only promise.
     const all = [
         ...baseTools,
         ...extraTools,
         ...gitTools,
         ...webTools,
+        ...(subagents && !readOnly ? [taskTool] : []),
         respondTool,
     ];
     return readOnly ? filterToolsForReadOnly(all) : all;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.70.0",
+  "version": "2.71.0",
   "description": "Terminal coding agent that drives chat.deepseek.com through Playwright — no API key required. Reads and edits files, runs commands, commits to git, like Claude Code / Codex CLI.",
   "type": "module",
   "bin": {

package/scripts/self-smoke.mjs

@@ -42,8 +42,9 @@ fs.mkdirSync(WORK, { recursive: true })
 
 // --- project modules (dynamic: they read HOME at import) --------------------
 const { DeepSeekBrowser } = await import('../src/browser.ts')
-const { createTools } = await import('../src/tools.ts')
+const { createTools, filterToolsForReadOnly } = await import('../src/tools.ts')
 const { runAgentLoop } = await import('../src/agent-loop.ts')
+const { createSubagentRunner } = await import('../src/subagent.ts')
 const { loadConfig } = await import('../src/config.ts')
 const { Transcript } = await import('../src/transcript.ts')
 
@@ -149,6 +150,49 @@ async function main() {
     maxAfterToolRetries: cfg.browser.maxAfterToolRetries,
   })
   record('follow-up answered', outC.trim().length > 0, JSON.stringify(outC.slice(0, 80)))
+  const onSubagent = createSubagentRunner({
+    browser,
+    workdir: WORK,
+    locale: 'ru',
+    runAgentLoop,
+    buildTools: (readOnly) => {
+      const base = createTools(WORK, {})
+      return readOnly ? filterToolsForReadOnly(base) : base
+    },
+    transcript,
+    maxSubagents: 2,
+    askDeadlineMs: cfg.browser.askDeadlineMs,
+    maxAfterToolRetries: cfg.browser.maxAfterToolRetries,
+  })
+
+  // Scenario D — subagents (N36): the model delegates via Task; the runner
+  // opens a separate chat, returns only the report, and restores the parent
+  // chat. Requires browser.subagents (off by default).
+  const subTools = createTools(WORK, { subagents: true })
+  const outD = await runAgentLoop({
+    browser,
+    tools: subTools,
+    task:
+      'Use the Task tool with subagent_type "explore" to find which word is written in the file smoke.txt. ' +
+      'prompt the subagent in a self-contained way. Then, based on its report, call respond with that word.',
+    workdir: WORK,
+    maxIterations: 20,
+    freshChat: true,
+    sendSystemPrompt: true,
+    transcript,
+    onSubagent,
+    onToolCall: (n) => console.log('  tool: ' + n),
+    onAssistantMessage: (m) => console.log('  answer: ' + m),
+    onWarning: (m) => console.log('  warn: ' + m),
+    locale: 'ru',
+    askDeadlineMs: cfg.browser.askDeadlineMs,
+    maxAfterToolRetries: cfg.browser.maxAfterToolRetries,
+  })
+  record(
+    'subagent: parent used the report',
+    /HELLO_SMOKE/i.test(outD),
+    JSON.stringify(outD.slice(0, 120)),
+  )
 }
 
 let failed = false