zames_pro 2.71.0 → 2.72.1

package/dist/statusline.js

@@ -0,0 +1,52 @@
+import { spawn } from 'node:child_process';
+/** Run the statusLine command and return its first stdout line (trimmed). */
+export function runStatusLineCommand(workdir, command, info, timeoutMs = 4000) {
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = spawn(command, {
+                cwd: workdir,
+                shell: process.platform === 'win32'
+                    ? process.env.ComSpec || true
+                    : '/bin/sh',
+                windowsHide: true,
+                env: { ...process.env },
+            });
+        }
+        catch {
+            resolve('');
+            return;
+        }
+        let out = '';
+        let done = false;
+        const finish = () => {
+            if (done)
+                return;
+            done = true;
+            const first = String(out).split(/\r?\n/)[0].trim();
+            resolve(first);
+        };
+        const timer = setTimeout(() => {
+            try {
+                child.kill();
+            }
+            catch { }
+            finish();
+        }, timeoutMs);
+        child.stdout?.on('data', (c) => {
+            out += c.toString();
+        });
+        child.on('error', () => {
+            clearTimeout(timer);
+            finish();
+        });
+        child.on('close', () => {
+            clearTimeout(timer);
+            finish();
+        });
+        if (child.stdin) {
+            child.stdin.on('error', () => { });
+            child.stdin.end(JSON.stringify(info) + String.fromCharCode(10));
+        }
+    });
+}

package/dist/subagent.js

@@ -1,3 +1,4 @@
+import { loadHooks, runLifecycleHooks } from './hooks.js';
 // 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.
@@ -13,6 +14,19 @@
 // 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 report is fed back into the PARENT chat as a tool result, so a runaway
+// subagent must not be able to blow up the parent's context with one answer.
+// The tail is trimmed with a marker, not silently dropped.
+export const SUBAGENT_REPORT_CAP = 20_000;
+/** Cap a subagent report before it becomes a parent-context tool result. */
+export function capReport(text, cap = SUBAGENT_REPORT_CAP) {
+    if (text.length <= cap)
+        return text;
+    return (text.slice(0, cap) +
+        '\n… [report truncated: ' +
+        (text.length - cap) +
+        ' chars omitted]');
+}
 /**
  * The subagent persona, prepended to the task message. It is deliberately NOT
  * injected as a replacement system prompt: the nested runAgentLoop builds the
@@ -43,7 +57,7 @@ export function subagentPersona(type) {
  * returns only the report.
  */
 export function createSubagentRunner(opts) {
-    const { browser, workdir, locale, runAgentLoop, buildTools, transcript = null, maxSubagents, askDeadlineMs, maxAfterToolRetries, selfImprovement = false, onAskPermission, } = opts;
+    const { browser, workdir, locale, runAgentLoop, buildTools, transcript = null, maxSubagents, askDeadlineMs, maxAfterToolRetries, onAskPermission, } = opts;
     let used = 0;
     return async (req) => {
         if (used >= maxSubagents) {
@@ -84,11 +98,24 @@ export function createSubagentRunner(opts) {
                 locale,
                 askDeadlineMs,
                 maxAfterToolRetries,
-                selfImprovement,
+                // A subagent NEVER touches BACKLOG.md, even in the operator's dev
+                // mode: its sub-task is scoped, and a general subagent appending
+                // "improvement" notes would be unrelated, unsupervised edits.
+                selfImprovement: false,
                 // No recursion: the subagent cannot spawn its own subagents.
                 onSubagent: null,
                 // Do not persist the subagent chat as a session.
                 onChatReady: () => { },
+                // Keep the PARENT's UI alive during the nested run. The nested loop
+                // OVERWRITES browser.onSendStart/… with its own callbacks; without
+                // forwarding the parent's hooks the spinner and the throttle countdown
+                // would go blank for the whole subagent run (a long subagent looked
+                // like a frozen, dead agent). The nested loop, not this runner, owns
+                // the assignment, so we hand it the functions it should install.
+                onThinking: savedHooks.onSendStart ?? undefined,
+                onSendPause: savedHooks.onSendPause ?? undefined,
+                onSendState: savedHooks.onSendState ?? undefined,
+                onNotice: savedHooks.onNotice ?? undefined,
                 onAskPermission: onAskPermission
                     ? (info) => onAskPermission({
                         tool: info.tool,
@@ -112,8 +139,18 @@ export function createSubagentRunner(opts) {
             browser.onSendState = savedHooks.onSendState;
             browser.onNotice = savedHooks.onNotice;
         }
+        // SubagentStop hook (N32): fires after the nested loop finishes, so a hook
+        // can clean up or notify. Best-effort; its stdout is appended to the report.
+        let hookOut = '';
+        try {
+            hookOut = await runLifecycleHooks(loadHooks(workdir), 'SubagentStop', workdir, { type: req.type, ok: failed ? 'false' : 'true' });
+        }
+        catch { }
         if (failed)
             return { ok: false, text: failed };
-        return { ok: true, text: report };
+        return {
+            ok: true,
+            text: capReport(hookOut ? report + '\n\n' + hookOut : report),
+        };
     };
 }

package/dist/tools.js

@@ -1,6 +1,7 @@
 import fs from 'fs/promises';
 import path from 'path';
-import { assertCommandInsideRoot, runFile, runShell } from './shell.js';
+import { assertCommandInsideRoot, runFile, runShell, startBackground, pollBackground, killBackground, } from './shell.js';
+import { isImageName, guessMime, formatSize } from './attachments.js';
 import { safePath } from './sandbox.js';
 import { createGitTools } from './gitTools.js';
 import { createWebTools } from './web.js';
@@ -26,6 +27,17 @@ export function createTools(workdir, { undo, todos, readOnly = false, subagents
     // that omits `path` (or sends it as null) becomes String(undefined) ===
     // "undefined" and the tool silently creates a file literally named
     // "undefined" in the working directory. `req()` rejects that up front.
+    // A NUL byte is the classic binary signal (text files essentially never
+    // contain one). We only scan the head: a huge archive must not be walked
+    // byte-by-byte just to decide it is not text.
+    const isBinaryBuffer = (buf) => {
+        const n = Math.min(buf.length, 8000);
+        for (let i = 0; i < n; i++) {
+            if (buf[i] === 0)
+                return true;
+        }
+        return false;
+    };
     const req = (v, name) => {
         if (v === undefined || v === null) {
             throw new Error(`Missing required argument: ${name}`);
@@ -42,7 +54,10 @@ export function createTools(workdir, { undo, todos, readOnly = false, subagents
             description: 'Read a file. Optional: offset and limit (lines). ' +
                 'numbered=true adds cat -n style line numbers (1-based) for reference ' +
                 'only — do NOT copy the numbers into Edit old_string. ' +
-                'Lines longer than 2000 chars are truncated.',
+                'Lines longer than 2000 chars are truncated. ' +
+                'Binary files (images, archives) are not decoded: an image returns its ' +
+                'path/size as a marker (the operator can paste it to attach it), and ' +
+                'other binaries return a short hex header instead of mojibake.',
             parameters: {
                 path: 'string',
                 offset: 'number?',
@@ -51,7 +66,34 @@ export function createTools(workdir, { undo, todos, readOnly = false, subagents
             },
             fn: async ({ path: p, offset, limit, numbered }) => {
                 const file = safe(req(p, 'path'));
-                const content = await fs.readFile(file, 'utf-8');
+                // Binary guard (N35): reading an image/archive as utf-8 produced
+                // mojibake the model tried to reason about. Detect a binary buffer
+                // BEFORE decoding and answer with useful metadata instead.
+                const buf = await fs.readFile(file);
+                if (isImageName(file)) {
+                    return ('[image: ' +
+                        p +
+                        '] (' +
+                        guessMime(file) +
+                        ', ' +
+                        formatSize(buf.length) +
+                        ') — this is an image; its pixels cannot be read as text. To have ' +
+                        'the model SEE it, the operator can paste/drag the file into the ' +
+                        'chat (it becomes an [image#N] attachment).');
+                }
+                if (isBinaryBuffer(buf)) {
+                    const head = buf.subarray(0, 16);
+                    return ('(binary file: ' +
+                        p +
+                        ', ' +
+                        formatSize(buf.length) +
+                        ', ' +
+                        guessMime(file) +
+                        ')\nFirst bytes (hex): ' +
+                        Buffer.from(head).toString('hex') +
+                        '\nUse Bash (e.g. `file`, `xxd`, `unzip -l`) to inspect it.');
+                }
+                const content = buf.toString('utf-8');
                 if (content === '')
                     return '(file is empty)';
                 const lines = content.split('\n');
@@ -126,13 +168,43 @@ export function createTools(workdir, { undo, todos, readOnly = false, subagents
         {
             name: 'Bash',
             description: 'Run a shell command in the working directory (cmd.exe on Windows, sh on Linux/macOS). ' +
-                'Do not use for long-running processes (servers) — they will hit the timeout. ' +
                 'Do not use for commands that require interactive input. ' +
+                'For a long-running process (dev server, watch, long build) set ' +
+                'run_in_background=true: it starts the command and returns an id ' +
+                'immediately; poll its output with BashOutput and stop it with BashOutput kill. ' +
                 'For git use the Git* tools. For the web use WebFetch / WebSearch.',
-            parameters: { command: 'string', timeout: 'number?' },
-            fn: async ({ command, timeout }, ctx) => {
-                assertCommandInsideRoot(root, req(command, 'command'));
-                return runShell(workdir, req(command, 'command'), timeout, ctx?.signal);
+            parameters: {
+                command: 'string',
+                timeout: 'number?',
+                run_in_background: 'boolean?',
+            },
+            fn: async ({ command, timeout, run_in_background }, ctx) => {
+                const cmd = req(command, 'command');
+                assertCommandInsideRoot(root, cmd);
+                if (run_in_background) {
+                    const id = startBackground(workdir, cmd);
+                    return ('Started in background with id ' +
+                        id +
+                        '. Poll it with BashOutput (id="' +
+                        id +
+                        '") and stop it with BashOutput (id="' +
+                        id +
+                        '", kill=true).');
+                }
+                return runShell(workdir, cmd, timeout, ctx?.signal);
+            },
+        },
+        {
+            name: 'BashOutput',
+            description: 'Read the accumulated stdout+stderr of a process started with Bash ' +
+                'run_in_background=true, and optionally kill it. id — the id returned ' +
+                'by Bash. kill=true terminates the process (and its children).',
+            parameters: { id: 'string', kill: 'boolean?' },
+            fn: async ({ id, kill }) => {
+                const pid = req(id, 'id');
+                if (kill)
+                    return killBackground(pid);
+                return pollBackground(pid);
             },
         },
         {
@@ -243,6 +315,7 @@ export const MUTATING_TOOLS = new Set([
     'MultiEdit',
     'ApplyPatch',
     'Bash',
+    'BashOutput',
     'GitAdd',
     'GitCommit',
     'GitPush',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.71.0",
+  "version": "2.72.1",
   "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": {
@@ -17,21 +17,23 @@
   "scripts": {
     "start": "node ./dist/index.js",
     "dev": "ZAMES_NET_DEBUG=1 tsx ./src/index.ts --dev --headed",
-    "clean": "node scripts/clean-dist.mjs",
-    "build": "node scripts/clean-dist.mjs && tsc -p tsconfig.build.json",
-    "coverage:gate": "node scripts/coverage-gate.mjs",
+    "clean": "tsx scripts/clean-dist.mts",
+    "build": "tsx scripts/clean-dist.mts && tsc -p tsconfig.build.json",
+    "coverage:gate": "tsx scripts/coverage-gate.mts",
     "changelog:draft": "tsx scripts/changelog-draft.mts",
+    "changelog:sync": "tsx scripts/changelog-draft.mts --write",
+    "changelog:check": "tsx scripts/changelog-draft.mts --check",
     "release": "tsx scripts/release.mts",
     "typecheck": "tsc --noEmit",
-    "lint": "node scripts/eslint-ts6.mjs",
-    "lint:fix": "node scripts/eslint-ts6.mjs --fix",
+    "lint": "tsx scripts/eslint-ts6.mts",
+    "lint:fix": "tsx scripts/eslint-ts6.mts --fix",
     "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\" \"*.{js,json,md}\"",
     "format:check": "prettier --check \"src/**/*.ts\" \"test/**/*.ts\"",
     "prepublishOnly": "npm run build:readme && npm run build",
     "test": "tsx --test test/*.test.ts",
     "test:watch": "tsx --test --watch test/*.test.ts",
-    "self-smoke": "tsx scripts/self-smoke.mjs",
-    "render-demo": "node scripts/render-demo.mjs",
+    "self-smoke": "tsx scripts/self-smoke.mts",
+    "render-demo": "tsx scripts/render-demo.mts",
     "build:readme": "tsx scripts/build-readme.mts",
     "postinstall": "node scripts/postinstall.mjs",
     "prepare": "husky"

package/scripts/changelog-draft.mts

@@ -1,8 +1,12 @@
 import { spawnSync } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
 import {
   parseConventionalCommit,
   groupCommits,
   renderChangelogDraft,
+  syncUnreleased,
 } from '../src/changelog.js'
 
 // Draft a CHANGELOG section from conventional commits since a ref (BACKLOG
@@ -13,6 +17,8 @@ import {
 // Usage:
 //   npm run changelog:draft            # since the latest tag, or an explicit ref
 //   npm run changelog:draft -- v2.63.0
+//   npm run changelog:draft -- --write  # update the Unreleased section in place
+//   npm run changelog:draft -- --check  # exit 1 if Unreleased is out of date
 
 function git(args: string[]): string {
   const r = spawnSync('git', args, { encoding: 'utf-8' })
@@ -20,7 +26,10 @@ function git(args: string[]): string {
   return (r.stdout || '').toString()
 }
 
-const argRef = process.argv.slice(2).find((a) => !a.startsWith('-'))
+const argv = process.argv.slice(2)
+const write = argv.includes('--write')
+const check = argv.includes('--check')
+const argRef = argv.find((a) => !a.startsWith('-'))
 
 // Resolve the start ref: an explicit arg, otherwise the latest tag,
 // otherwise the root commit.
@@ -46,6 +55,34 @@ const parsed = subjects
   .filter((c): c is NonNullable<typeof c> => c !== null)
 const body = renderChangelogDraft(groupCommits(parsed))
 
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
+const changelogPath = path.join(root, 'CHANGELOG.md')
+
+// D2: sync the `## [Unreleased]` section in CHANGELOG.md from the conventional
+// commits since the last tag. `--write` edits the file; `--check` fails when
+// the committed section is out of date (for CI); neither just prints the body.
+if (write || check) {
+  const onDisk = fs.readFileSync(changelogPath, 'utf-8')
+  const nextText = syncUnreleased(onDisk, body)
+  if (write) {
+    if (nextText !== onDisk) {
+      fs.writeFileSync(changelogPath, nextText)
+      console.log('changelog: updated the Unreleased section')
+    } else {
+      console.log('changelog: Unreleased already up to date')
+    }
+    process.exit(0)
+  }
+  if (nextText !== onDisk) {
+    console.error(
+      'changelog: the Unreleased section is out of date — run `npm run changelog:sync`',
+    )
+    process.exit(1)
+  }
+  console.log('changelog: Unreleased is up to date')
+  process.exit(0)
+}
+
 if (!body) {
   console.error('no conventional commits since ' + ref)
   process.exit(0)

package/scripts/{eslint-ts6.mjs → eslint-ts6.mts}

@@ -11,6 +11,12 @@ import Module from 'module'
 import path from 'path'
 import { fileURLToPath } from 'url'
 
+// Module._resolveFilename is a private Node field (not in @types/node), so it
+// is reached through a small structural type instead of `any`.
+type ModuleWithResolve = typeof Module & {
+  _resolveFilename: (request: string, ...rest: unknown[]) => string
+}
+
 const require = createRequire(import.meta.url)
 const here = path.dirname(fileURLToPath(import.meta.url))
 const ts6 = path.join(here, '..', 'node_modules', 'typescript-6')
@@ -26,16 +32,17 @@ try {
 
 // Patch Module._resolveFilename so any require('typescript') resolves to the
 // TS 6 package instead of the TS 7 the project depends on.
-const origResolve = Module._resolveFilename
-Module._resolveFilename = function (request, ...rest) {
+const M = Module as ModuleWithResolve
+const origResolve = M._resolveFilename
+M._resolveFilename = (request: string, ...rest: unknown[]) => {
   if (request === 'typescript') {
     try {
       return require.resolve(path.join(ts6, 'lib', 'typescript.js'))
     } catch {
-      return origResolve.call(this, request, ...rest)
+      return origResolve(request, ...rest)
     }
   }
-  return origResolve.call(this, request, ...rest)
+  return origResolve(request, ...rest)
 }
 
 const { ESLint } = await import('eslint')

package/scripts/release.mts

@@ -23,7 +23,9 @@ import {
 //   npm run release patch --dry-run  # print the plan, change nothing
 //
 // Run via tsx so it can reuse src/changelog.ts (the conventional-commit
-// parser) — a plain .mjs cannot import the TypeScript sources.
+// parser) — a plain .mjs cannot import the TypeScript sources. The other
+// helper scripts are .mts for the same reason; postinstall stays .mjs because
+// it runs before tsx is guaranteed to be installed.
 
 const NL = String.fromCharCode(10)
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
@@ -43,7 +45,11 @@ function fail(msg: string): never {
 }
 
 function run(cmd: string, args: string[]): void {
-  const r = spawnSync(cmd, args, { cwd: root, stdio: 'inherit', shell: process.platform === 'win32' })
+  const r = spawnSync(cmd, args, {
+    cwd: root,
+    stdio: 'inherit',
+    shell: process.platform === 'win32',
+  })
   if (r.status !== 0) fail(cmd + ' ' + args.join(' ') + ' exited ' + r.status)
 }
 
@@ -100,8 +106,16 @@ if (git(['tag', '--list', tag]).trim()) {
 // last tag. English commit subjects become the section body; the operator can
 // still reword the section afterwards.
 const latestTag = git(['describe', '--tags', '--abbrev=0'], true).trim()
-const ref = latestTag || git(['rev-list', '--max-parents=0', 'HEAD']).trim().split(NL).pop() || 'HEAD'
-const subjects = git(['log', '--no-merges', '--pretty=format:%s', ref + '..HEAD'])
+const ref =
+  latestTag ||
+  git(['rev-list', '--max-parents=0', 'HEAD']).trim().split(NL).pop() ||
+  'HEAD'
+const subjects = git([
+  'log',
+  '--no-merges',
+  '--pretty=format:%s',
+  ref + '..HEAD',
+])
   .split(NL)
   .map((s) => s.trim())
   .filter(Boolean)
@@ -129,7 +143,14 @@ const sectionBody = body
   .join(NL)
 const date = new Date().toISOString().slice(0, 10)
 const section =
-  '## [' + next + '] - ' + date + NL + NL + (sectionBody || '### Changed' + NL + NL + '- Internal improvements.') + NL
+  '## [' +
+  next +
+  '] - ' +
+  date +
+  NL +
+  NL +
+  (sectionBody || '### Changed' + NL + NL + '- Internal improvements.') +
+  NL
 
 if (dryRun) {
   console.log('release(dry-run): ' + pkg.version + ' -> ' + next)
@@ -148,14 +169,22 @@ if (idx < 0) fail('CHANGELOG.md has no "' + anchor + '" heading')
 const afterAnchor = idx + anchor.length
 const updated =
   changelog.slice(0, afterAnchor) +
-  NL + NL + section +
+  NL +
+  NL +
+  section +
   changelog.slice(afterAnchor).replace(/^\n+/, NL)
 fs.writeFileSync(changelogPath, updated)
 
 // 6. Bump package.json, preserving its exact formatting (single-line replace
 // of the version value only).
 const pkgText = fs.readFileSync(pkgPath, 'utf-8')
-fs.writeFileSync(pkgPath, pkgText.replace('"version": "' + pkg.version + '"', '"version": "' + next + '"'))
+fs.writeFileSync(
+  pkgPath,
+  pkgText.replace(
+    '"version": "' + pkg.version + '"',
+    '"version": "' + next + '"',
+  ),
+)
 
 // 7. Commit + tag. The push is intentionally NOT done here.
 git(['add', 'package.json', 'CHANGELOG.md'])

package/scripts/{render-demo.mjs → render-demo.mts}

@@ -7,7 +7,7 @@
 // theme palette (src/theme.ts) with the DejaVu Sans Mono font that the
 // container actually ships, then screenshots it with headless Chromium.
 //
-// Run:  node scripts/render-demo.mjs
+// Run:  npm run render-demo  (tsx scripts/render-demo.mts)
 //
 // Isolation: chromium.launch() uses a THROWAWAY profile, never ~/.zames/profile
 // (see AGENTS.md — never touch the live agent's browser/profile).
@@ -33,9 +33,9 @@ const C = {
   toggleOn: '#6fd0b0',
 }
 
-const esc = (s) =>
+const esc = (s: unknown): string =>
   String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
-const span = (color, text, bold = false) =>
+const span = (color: string, text: string, bold = false): string =>
   '<span style="color:' +
   color +
   (bold ? ';font-weight:700' : '') +
@@ -44,13 +44,18 @@ const span = (color, text, bold = false) =>
   '</span>'
 
 // One rendered session, line by line (mirrors the real banner + answer flow).
-const lines = []
-const push = (html) => lines.push('<div class="l">' + html + '</div>')
+const lines: string[] = []
+const push = (html: string): void => {
+  lines.push('<div class="l">' + html + '</div>')
+}
 const blank = () => push('&nbsp;')
 
 push(span(C.system, 'Working directory: ') + span(C.dir, '/home/dev/zames_pro'))
 push(span(C.system, 'Version: ') + span(C.user, '2.64.1'))
-push(span(C.system, 'Transcript: ') + span(C.dim, '~/.zames/logs/zames_pro-2026-10-07.log'))
+push(
+  span(C.system, 'Transcript: ') +
+    span(C.dim, '~/.zames/logs/zames_pro-2026-10-07.log'),
+)
 blank()
 push(
   span(
@@ -78,11 +83,7 @@ push(
     span(C.user, 'Show the version from package.json.'),
 )
 blank()
-push(
-  span(C.tool, '🔧 Read') +
-    ' ' +
-    span(C.dim, '{"path":"package.json"}'),
-)
+push(span(C.tool, '🔧 Read') + ' ' + span(C.dim, '{"path":"package.json"}'))
 push(
   span(C.toolResult, '   → ') +
     span(

package/scripts/{self-smoke.mjs → self-smoke.mts}

@@ -48,8 +48,13 @@ const { createSubagentRunner } = await import('../src/subagent.ts')
 const { loadConfig } = await import('../src/config.ts')
 const { Transcript } = await import('../src/transcript.ts')
 
-const results = []
-const record = (name, ok, note) => {
+interface SmokeResult {
+  name: string
+  ok: boolean
+  note?: string
+}
+const results: SmokeResult[] = []
+const record = (name: string, ok: boolean, note?: string): void => {
   results.push({ name, ok, note })
   console.log((ok ? 'PASS ' : 'FAIL ') + name + (note ? '  — ' + note : ''))
 }
@@ -149,7 +154,11 @@ async function main() {
     askDeadlineMs: cfg.browser.askDeadlineMs,
     maxAfterToolRetries: cfg.browser.maxAfterToolRetries,
   })
-  record('follow-up answered', outC.trim().length > 0, JSON.stringify(outC.slice(0, 80)))
+  record(
+    'follow-up answered',
+    outC.trim().length > 0,
+    JSON.stringify(outC.slice(0, 80)),
+  )
   const onSubagent = createSubagentRunner({
     browser,
     workdir: WORK,
@@ -193,13 +202,41 @@ async function main() {
     /HELLO_SMOKE/i.test(outD),
     JSON.stringify(outD.slice(0, 120)),
   )
+
+  // Scenario E — background Bash + BashOutput (N33): start a process that
+  // keeps running, poll its output, then kill it.
+  const outE = await runAgentLoop({
+    browser,
+    tools,
+    task:
+      'Do exactly this, then report: (1) Start the Bash command ' +
+      '`echo BG_MARKER_7 && sleep 120` in the BACKGROUND (run_in_background=true). ' +
+      '(2) Poll it once with BashOutput. (3) Kill it with BashOutput kill=true. ' +
+      'Then call respond with one short line containing BG_MARKER_7.',
+    workdir: WORK,
+    maxIterations: 20,
+    freshChat: true,
+    sendSystemPrompt: true,
+    transcript,
+    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(
+    'background bash: started, polled and killed',
+    /BG_MARKER_7/.test(outE),
+    JSON.stringify(outE.slice(0, 120)),
+  )
 }
 
 let failed = false
 try {
   await main()
 } catch (e) {
-  record('run', false, e.message)
+  record('run', false, (e as Error).message)
   failed = true
 } finally {
   await browser.close().catch(() => {})