zames_pro 2.70.0 → 2.72.0

package/dist/subagent.js

@@ -0,0 +1,156 @@
+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.
+//
+// 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 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
+ * 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, 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,
+                // 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,
+                        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;
+        }
+        // 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: capReport(hookOut ? report + '\n\n' + hookOut : 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

@@ -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';
@@ -9,7 +10,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
@@ -26,6 +27,17 @@ export function createTools(workdir, { undo, todos, readOnly = false, } = {}) {
     // 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, } = {}) {
             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, } = {}) {
             },
             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, } = {}) {
         {
             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);
             },
         },
         {
@@ -200,11 +272,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;
@@ -220,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.70.0",
+  "version": "2.72.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": {
@@ -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'])