mixdog 0.9.3 → 0.9.4

package/src/runtime/agent/orchestrator/tools/builtin/diagnostics-tool.mjs

@@ -1,285 +0,0 @@
-// Server-less diagnostics tool.
-//
-// Mixdog has no resident LSP server. Instead this tool detects the project
-// marker(s) under the target path, runs the matching project CLI ONCE via the
-// same exec path bash-tool uses (execShellCommand + resolveShell), then PARSES
-// the checker's stdout/stderr into structured findings. No watch, no daemon.
-//
-// Graceful contract: a missing marker or a missing checker binary returns a
-// clear "no checker available for X" message — it never throws.
-import { existsSync, readFileSync, statSync } from 'fs';
-import { dirname, isAbsolute, resolve as pathResolve } from 'path';
-import { execShellCommand, stripAnsi } from '../shell-command.mjs';
-import { resolveShell } from './shell-runtime.mjs';
-
-const DIAGNOSTICS_TIMEOUT_MS = 120_000;
-
-// Probe whether a CLI binary is resolvable on PATH without running real work.
-// Uses the platform command-resolver so an absent checker degrades gracefully
-// into a "no checker available" message instead of a spawn error.
-async function _commandExists(bin, cwd, env) {
-    const { shell, shellArg, shellArgs, shellType } = resolveShell();
-    const probe = shellType === 'powershell'
-        ? `Get-Command ${bin} -ErrorAction SilentlyContinue | Select-Object -First 1`
-        : `command -v ${bin}`;
-    try {
-        const r = await execShellCommand({
-            shell, shellArg, shellArgs, command: probe,
-            env, cwd, timeoutMs: 10_000, abortSignal: null,
-        });
-        const out = `${r.stdout || ''}`.trim();
-        if (shellType === 'powershell') return out.length > 0;
-        return r.exitCode === 0 && out.length > 0;
-    } catch {
-        return false;
-    }
-}
-
-async function _runChecker(command, cwd, env) {
-    const { shell, shellArg, shellArgs } = resolveShell();
-    const r = await execShellCommand({
-        shell, shellArg, shellArgs, command,
-        env, cwd, timeoutMs: DIAGNOSTICS_TIMEOUT_MS, abortSignal: null,
-    });
-    return {
-        stdout: stripAnsi(r.stdout || ''),
-        stderr: stripAnsi(r.stderr || ''),
-        exitCode: r.timedOut ? null : r.exitCode,
-        timedOut: !!r.timedOut,
-    };
-}
-
-// ---- per-checker output parsers -> [{file,line,col,severity,code,message}] ----
-
-function _parseTsc(text) {
-    const findings = [];
-    const re = /^(.+?)\((\d+),(\d+)\):\s+(error|warning)\s+(TS\d+):\s+(.*)$/;
-    for (const line of text.split(/\r?\n/)) {
-        const m = re.exec(line.trim());
-        if (m) findings.push({ file: m[1], line: +m[2], col: +m[3], severity: m[4], code: m[5], message: m[6] });
-    }
-    return findings;
-}
-
-function _parseRuff(text) {
-    const findings = [];
-    // ruff default text: path:line:col: CODE message
-    const re = /^(.+?):(\d+):(\d+):\s+([A-Z]+\d+)\s+(.*)$/;
-    for (const line of text.split(/\r?\n/)) {
-        const m = re.exec(line.trim());
-        if (!m) continue;
-        const code = m[4];
-        const severity = (/^(E9|F)/.test(code)) ? 'error' : 'warning';
-        findings.push({ file: m[1], line: +m[2], col: +m[3], severity, code, message: m[5] });
-    }
-    return findings;
-}
-
-function _parsePyflakes(text) {
-    const findings = [];
-    // pyflakes: path:line: message  (no column)
-    const re = /^(.+?):(\d+):\s*(.*)$/;
-    for (const line of text.split(/\r?\n/)) {
-        const trimmed = line.trim();
-        if (!trimmed) continue;
-        const m = re.exec(trimmed);
-        if (m) findings.push({ file: m[1], line: +m[2], col: null, severity: 'warning', code: null, message: m[3] });
-    }
-    return findings;
-}
-
-function _parseGoVet(text) {
-    const findings = [];
-    // go vet: path:line:col: message   OR   path:line: message
-    const re = /^(.+?\.go):(\d+):(?:(\d+):)?\s+(.*)$/;
-    for (const line of text.split(/\r?\n/)) {
-        const m = re.exec(line.trim());
-        if (m) findings.push({ file: m[1], line: +m[2], col: m[3] ? +m[3] : null, severity: 'error', code: 'vet', message: m[4] });
-    }
-    return findings;
-}
-
-function _parseCargo(text) {
-    const findings = [];
-    // cargo check --message-format=short: path:line:col: severity[CODE]: message
-    const re = /^(.+?):(\d+):(\d+):\s+(warning|error)(?:\[([A-Za-z0-9]+)\])?:\s+(.*)$/;
-    for (const line of text.split(/\r?\n/)) {
-        const m = re.exec(line.trim());
-        if (m) findings.push({ file: m[1], line: +m[2], col: +m[3], severity: m[4], code: m[5] || null, message: m[6] });
-    }
-    return findings;
-}
-
-// node --check failure shape: "<abs file>:<line>" on its own line, followed
-// by the offending source + caret, then "SyntaxError: <message>".
-function _parseNodeCheck(text) {
-    const findings = [];
-    const head = /^(.+?):(\d+)\s*$/m.exec(text);
-    const err = /^([A-Za-z]*Error):\s+(.*)$/m.exec(text);
-    if (head && err) {
-        findings.push({ file: head[1], line: +head[2], col: null, severity: 'error', code: err[1], message: err[2] });
-    }
-    return findings;
-}
-
-function _parseEslintCompact(text) {
-    const findings = [];
-    // eslint --format compact: path: line N, col M, Severity - message (rule)
-    const re = /^(.+?):\s+line\s+(\d+),\s+col\s+(\d+),\s+(Error|Warning)\s+-\s+(.*?)(?:\s+\(([^)]+)\))?$/;
-    for (const line of text.split(/\r?\n/)) {
-        const m = re.exec(line.trim());
-        if (m) findings.push({ file: m[1], line: +m[2], col: +m[3], severity: m[4].toLowerCase(), code: m[6] || null, message: m[5] });
-    }
-    return findings;
-}
-
-// Detect the project marker under projectDir and return the checker plan.
-// Order is deterministic; the first matching marker wins.
-function _detectChecker(projectDir) {
-    const has = (f) => existsSync(pathResolve(projectDir, f));
-    if (has('tsconfig.json')) {
-        return { kind: 'tsc', bin: 'tsc', command: 'tsc --noEmit', parse: _parseTsc, marker: 'tsconfig.json' };
-    }
-    if (has('pyproject.toml') || has('setup.py')) {
-        return { kind: 'python', marker: has('pyproject.toml') ? 'pyproject.toml' : 'setup.py' };
-    }
-    if (has('go.mod')) {
-        return { kind: 'go', bin: 'go', command: 'go vet ./...', parse: _parseGoVet, marker: 'go.mod' };
-    }
-    if (has('Cargo.toml')) {
-        return { kind: 'cargo', bin: 'cargo', command: 'cargo check --message-format=short', parse: _parseCargo, marker: 'Cargo.toml' };
-    }
-    if (has('package.json')) {
-        let usesEslint = false;
-        try {
-            const pkg = JSON.parse(readFileSync(pathResolve(projectDir, 'package.json'), 'utf8'));
-            const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
-            usesEslint = Object.prototype.hasOwnProperty.call(deps, 'eslint');
-        } catch { /* unreadable/invalid package.json */ }
-        const hasEslintConfig = ['.eslintrc', '.eslintrc.js', '.eslintrc.cjs', '.eslintrc.json', '.eslintrc.yml', '.eslintrc.yaml', 'eslint.config.js', 'eslint.config.mjs', 'eslint.config.cjs']
-            .some((f) => has(f));
-        if (usesEslint || hasEslintConfig) {
-            return { kind: 'eslint', bin: 'eslint', command: 'eslint . --format compact', parse: _parseEslintCompact, marker: 'package.json (eslint)' };
-        }
-        return { kind: 'none', reason: 'package.json present but no eslint dependency/config detected' };
-    }
-    return { kind: 'none', reason: 'no recognized project marker (tsconfig.json / pyproject.toml / setup.py / go.mod / Cargo.toml / package.json)' };
-}
-
-function _formatResult({ marker, checker, findings, raw, note }) {
-    return JSON.stringify({
-        ok: true,
-        marker: marker || null,
-        checker: checker || null,
-        note: note || null,
-        count: findings.length,
-        findings,
-        raw: raw ? raw.slice(0, 4000) : undefined,
-    }, null, 2);
-}
-
-export async function executeDiagnosticsTool(args, workDir, options = {}) {
-    const result = await _executeDiagnosticsImpl(args, workDir);
-    // ② completion progress (claude "Found N" parity). Best-effort, no-op
-    // when onProgress is absent (no progressToken). Never throws — the tool
-    // result is returned regardless.
-    if (typeof options?.onProgress === 'function') {
-        try {
-            let _n = null;
-            try { _n = JSON.parse(result)?.count; } catch { /* non-JSON envelope */ }
-            if (Number.isFinite(_n)) {
-                options.onProgress(_n === 0 ? 'no issues' : `${_n} issue${_n === 1 ? '' : 's'}`);
-            }
-        } catch { /* best-effort */ }
-    }
-    return result;
-}
-
-async function _executeDiagnosticsImpl(args, workDir) {
-    try {
-        // Resolve the target path (file or dir). Default: cwd.
-        const rawPath = (args && typeof args.path === 'string' && args.path.trim()) ? args.path.trim() : '';
-        const absTarget = rawPath
-            ? (isAbsolute(rawPath) ? rawPath : pathResolve(workDir, rawPath))
-            : workDir;
-        if (rawPath && !existsSync(absTarget)) {
-            return _formatResult({ note: `path not found: ${rawPath}`, findings: [] });
-        }
-        let projectDir = absTarget;
-        try {
-            if (statSync(absTarget).isFile()) projectDir = dirname(absTarget);
-        } catch { /* fall through with absTarget */ }
-
-        let plan = _detectChecker(projectDir);
-        // A file deep in the tree (src/search/lib/foo.mjs) has its project
-        // marker at the repo ROOT — walk parent directories until a marker is
-        // found instead of reporting "no recognized project marker" from the
-        // file's immediate dirname. Stops at the first directory that yields
-        // any non-"no marker" answer (including "package.json present but no
-        // eslint"), or at the filesystem root.
-        {
-            const _noMarker = (p) => p.kind === 'none' && String(p.reason || '').startsWith('no recognized project marker');
-            let walk = projectDir;
-            while (_noMarker(plan)) {
-                const parent = dirname(walk);
-                if (!parent || parent === walk) break;
-                walk = parent;
-                plan = _detectChecker(walk);
-            }
-            if (!_noMarker(plan)) projectDir = walk;
-        }
-        if (plan.kind === 'none') {
-            // Syntax-check fallback: a JS file target can still be validated
-            // with `node --check` even when the project has no lint setup —
-            // catch the dominant failure class (parse errors) instead of
-            // going dark with "no checker".
-            let isJsFile = false;
-            try { isJsFile = /\.(mjs|cjs|js)$/i.test(absTarget) && statSync(absTarget).isFile(); } catch { /* keep false */ }
-            if (isJsFile) {
-                const env = { ...process.env, LANG: 'C.UTF-8', LC_ALL: 'C.UTF-8' };
-                if (await _commandExists('node', projectDir, env)) {
-                    const r = await _runChecker(`node --check "${absTarget}"`, projectDir, env);
-                    const combined = `${r.stdout}\n${r.stderr}`;
-                    const findings = _parseNodeCheck(combined);
-                    return _formatResult({ checker: 'node --check (no-lint fallback)', findings, raw: combined, note: `${plan.reason} — fell back to syntax check only` });
-                }
-            }
-            return _formatResult({ note: `no checker available for this path — ${plan.reason}`, findings: [] });
-        }
-
-        const env = { ...process.env, LANG: 'C.UTF-8', LC_ALL: 'C.UTF-8' };
-
-        // Python is special: prefer ruff, fall back to pyflakes.
-        if (plan.kind === 'python') {
-            if (await _commandExists('ruff', projectDir, env)) {
-                const r = await _runChecker('ruff check .', projectDir, env);
-                const findings = _parseRuff(`${r.stdout}\n${r.stderr}`);
-                return _formatResult({ marker: plan.marker, checker: 'ruff check', findings, raw: `${r.stdout}\n${r.stderr}` });
-            }
-            if (await _commandExists('python', projectDir, env)) {
-                const r = await _runChecker('python -m pyflakes .', projectDir, env);
-                const out = `${r.stdout}\n${r.stderr}`;
-                if (/No module named pyflakes/i.test(out)) {
-                    return _formatResult({ marker: plan.marker, note: 'no checker available for Python — ruff absent and pyflakes module not installed', findings: [] });
-                }
-                const findings = _parsePyflakes(out);
-                return _formatResult({ marker: plan.marker, checker: 'python -m pyflakes (ruff fallback)', findings, raw: out });
-            }
-            return _formatResult({ marker: plan.marker, note: 'no checker available for Python — neither ruff nor python found on PATH', findings: [] });
-        }
-
-        if (!(await _commandExists(plan.bin, projectDir, env))) {
-            return _formatResult({ marker: plan.marker, note: `no checker available for ${plan.kind} — "${plan.bin}" not found on PATH`, findings: [] });
-        }
-        const r = await _runChecker(plan.command, projectDir, env);
-        const combined = `${r.stdout}\n${r.stderr}`;
-        const findings = plan.parse(combined);
-        const note = r.timedOut ? `checker timed out after ${DIAGNOSTICS_TIMEOUT_MS}ms` : null;
-        return _formatResult({ marker: plan.marker, checker: plan.command, findings, raw: combined, note });
-    } catch (err) {
-        // Never throw — surface a graceful diagnostic envelope.
-        return JSON.stringify({ ok: false, error: `diagnostics failed: ${err && err.message ? err.message : String(err)}`, findings: [] }, null, 2);
-    }
-}
-
-export default executeDiagnosticsTool;

package/src/runtime/agent/orchestrator/tools/builtin/external-tool-adapters.test.mjs

@@ -1,162 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { tryExecuteExternalToolAdapter, isExternalAdapterTool } from './external-tool-adapters.mjs';
-
-function makeDir() {
-    return mkdtempSync(join(tmpdir(), 'ext-adapter-test-'));
-}
-
-test('isExternalAdapterTool recognizes adapted names only', () => {
-    assert.equal(isExternalAdapterTool('StrReplace'), true);
-    assert.equal(isExternalAdapterTool('str_replace'), true);
-    assert.equal(isExternalAdapterTool('str_replace_editor'), true);
-    assert.equal(isExternalAdapterTool('search_replace'), true);
-    assert.equal(isExternalAdapterTool('Write'), true);
-    assert.equal(isExternalAdapterTool('create_file'), true);
-    assert.equal(isExternalAdapterTool('Bash'), true);
-    assert.equal(isExternalAdapterTool('run_terminal_cmd'), true);
-    // Destructive / different-shape names stay on the redirect path.
-    assert.equal(isExternalAdapterTool('Delete'), false);
-    assert.equal(isExternalAdapterTool('delete_file'), false);
-    assert.equal(isExternalAdapterTool('edit'), false);
-    assert.equal(isExternalAdapterTool('multiedit'), false);
-    assert.equal(isExternalAdapterTool(''), false);
-    assert.equal(isExternalAdapterTool(null), false);
-});
-
-test('StrReplace: unique match replaces content', async () => {
-    const dir = makeDir();
-    const file = join(dir, 'a.txt');
-    writeFileSync(file, 'alpha\nbeta\ngamma\n');
-    const out = await tryExecuteExternalToolAdapter('StrReplace', {
-        path: file, old_string: 'beta', new_string: 'BETA',
-    }, dir, {});
-    assert.match(out, /^Updated .*\(1 replacement\)$/);
-    assert.equal(readFileSync(file, 'utf8'), 'alpha\nBETA\ngamma\n');
-});
-
-test('StrReplace: zero matches errors without writing', async () => {
-    const dir = makeDir();
-    const file = join(dir, 'a.txt');
-    writeFileSync(file, 'alpha\n');
-    const out = await tryExecuteExternalToolAdapter('str_replace', {
-        path: file, old_string: 'missing', new_string: 'x',
-    }, dir, {});
-    assert.match(out, /old_string not found/);
-    assert.equal(readFileSync(file, 'utf8'), 'alpha\n');
-});
-
-test('StrReplace: ambiguous matches error with count', async () => {
-    const dir = makeDir();
-    const file = join(dir, 'a.txt');
-    writeFileSync(file, 'dup\ndup\n');
-    const out = await tryExecuteExternalToolAdapter('search_replace', {
-        path: file, old_string: 'dup', new_string: 'x',
-    }, dir, {});
-    assert.match(out, /ambiguous: 2 matches/);
-    assert.equal(readFileSync(file, 'utf8'), 'dup\ndup\n');
-});
-
-test('StrReplace: missing old_string falls back (null)', async () => {
-    const dir = makeDir();
-    const out = await tryExecuteExternalToolAdapter('StrReplace', {
-        path: join(dir, 'a.txt'), new_string: 'x',
-    }, dir, {});
-    assert.equal(out, null);
-});
-
-test('StrReplace: unreadable target is a concrete error', async () => {
-    const dir = makeDir();
-    const out = await tryExecuteExternalToolAdapter('StrReplace', {
-        path: join(dir, 'nope.txt'), old_string: 'a', new_string: 'b',
-    }, dir, {});
-    assert.match(out, /^Error: cannot read /);
-});
-
-test('Write: creates a new file with contents', async () => {
-    const dir = makeDir();
-    const file = join(dir, 'new', 'nested.txt');
-    const out = await tryExecuteExternalToolAdapter('Write', {
-        path: file, contents: 'created body',
-    }, dir, {});
-    assert.match(out, /^Created .*nested\.txt \(12 bytes\)$/);
-    assert.equal(readFileSync(file, 'utf8'), 'created body');
-});
-
-test('Write: overwrites an existing file and says Updated', async () => {
-    const dir = makeDir();
-    const file = join(dir, 'exists.txt');
-    writeFileSync(file, 'old');
-    const out = await tryExecuteExternalToolAdapter('write', {
-        file_path: file, content: 'new body',
-    }, dir, {});
-    assert.match(out, /^Updated /);
-    assert.equal(readFileSync(file, 'utf8'), 'new body');
-});
-
-test('Write: missing contents falls back to redirect (null)', async () => {
-    const dir = makeDir();
-    const out = await tryExecuteExternalToolAdapter('Write', {
-        path: join(dir, 'x.txt'),
-    }, dir, {});
-    assert.equal(out, null);
-    assert.equal(existsSync(join(dir, 'x.txt')), false);
-});
-
-test('StrReplace: missing old_string/new_string falls back (null)', async () => {
-    const dir = makeDir();
-    const file = join(dir, 'a.txt');
-    writeFileSync(file, 'body');
-    const out = await tryExecuteExternalToolAdapter('StrReplace', {
-        path: file, old_string: 'body',
-    }, dir, {});
-    assert.equal(out, null);
-});
-
-test('StrReplace: empty old_string is a concrete error (no hang)', async () => {
-    const dir = makeDir();
-    const file = join(dir, 'a.txt');
-    writeFileSync(file, 'body');
-    const out = await tryExecuteExternalToolAdapter('StrReplace', {
-        path: file, old_string: '', new_string: 'x',
-    }, dir, {});
-    assert.match(out, /old_string must be a non-empty string/);
-    assert.equal(readFileSync(file, 'utf8'), 'body');
-});
-
-test('bash family: missing command falls back (null)', async () => {
-    const dir = makeDir();
-    const out = await tryExecuteExternalToolAdapter('Bash', {}, dir, {});
-    assert.equal(out, null);
-});
-
-test('Write: target outside workDir is refused (base containment)', async () => {
-    const workDir = makeDir();
-    const outsideDir = makeDir();
-    const outside = join(outsideDir, 'escape.txt');
-    const out = await tryExecuteExternalToolAdapter('Write', {
-        path: outside, contents: 'should not land',
-    }, workDir, {});
-    assert.match(out, /cannot write outside the working directory/);
-    assert.equal(existsSync(outside), false);
-});
-
-test('non-adapted names return null without touching fs', async () => {
-    const dir = makeDir();
-    const out = await tryExecuteExternalToolAdapter('Delete', {
-        path: join(dir, 'x.txt'),
-    }, dir, {});
-    assert.equal(out, null);
-});
-
-test('bash family: executes a command via the shell runner', async () => {
-    const dir = makeDir();
-    const out = await tryExecuteExternalToolAdapter('run_terminal_cmd', {
-        command: 'node -e "console.log(\'adapter-ok\')"',
-    }, dir, {});
-    assert.equal(typeof out, 'string');
-    assert.match(out, /adapter-ok/);
-});

package/src/runtime/agent/orchestrator/tools/builtin/open-config-tool.mjs

@@ -1,26 +0,0 @@
-// open_config builtin tool.
-//
-// Lives in the always-on `builtin` module (not the gated `agent` module) so
-// the config UI stays reachable even when modules.agent.enabled === false —
-// otherwise a user who disabled the agent module would lose every way to open
-// the settings UI (the old `bun launch.mjs` slash shell-out is gone).
-//
-// Launches the config UI through the resident MCP server. Because this server
-// is a long-lived background process, its spawn of setup-server
-// (windowsHide:true inside launch-core) creates NO console window — unlike the
-// old `!bun launch.mjs` slash-command shell-out, which flashed a conhost. The
-// launch-core import is lazy so its child_process/http deps stay off the hot
-// builtin path until the tool is actually called.
-
-export async function executeOpenConfigTool() {
-    const { launchConfigUi, LaunchError } = await import(
-        new URL('../../../../../setup/launch-core.mjs', import.meta.url).href
-    );
-    try {
-        const url = await launchConfigUi();
-        return `Config UI opened at ${url}`;
-    } catch (err) {
-        if (err instanceof LaunchError) return `Error: ${err.message.trim()}`;
-        throw err;
-    }
-}

package/src/runtime/shared/channel-notification-routing.test.mjs

@@ -1,45 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import {
-  channelNotificationModelContent,
-  shouldMirrorChannelNotificationToPending,
-} from './channel-notification-routing.mjs';
-
-test('channel schedule notification uses instruction as model content', () => {
-  const content = channelNotificationModelContent({
-    content: ' ',
-    meta: {
-      type: 'schedule',
-      instruction: 'scheduled prompt body',
-    },
-  });
-  assert.equal(content, 'scheduled prompt body');
-});
-
-test('silent channel notification has no model content', () => {
-  const content = channelNotificationModelContent({
-    content: 'hidden',
-    meta: {
-      type: 'schedule',
-      silent_to_agent: true,
-    },
-  });
-  assert.equal(content, '');
-});
-
-test('non-schedule notification preserves instruction-first routing', () => {
-  const content = channelNotificationModelContent({
-    content: 'worker result body',
-    meta: {
-      type: 'webhook',
-      instruction: 'relay instruction',
-    },
-  });
-  assert.equal(content, 'relay instruction');
-});
-
-test('only schedule channel notifications are mirrored to pending fallback', () => {
-  assert.equal(shouldMirrorChannelNotificationToPending({ type: 'schedule' }), true);
-  assert.equal(shouldMirrorChannelNotificationToPending({ type: 'webhook' }), false);
-  assert.equal(shouldMirrorChannelNotificationToPending({}), false);
-});

package/src/runtime/shared/task-notification-envelope.test.mjs

@@ -1,107 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import {
-  renderShellCompletionEnvelope,
-  shellCompletionInstruction,
-  renderShellPromptStallEnvelope,
-  shellPromptStallInstruction,
-  isInternalRuntimeNotificationText,
-  isBracketedShellNotificationEnvelope,
-} from './task-notification-envelope.mjs';
-
-test('completion envelope matches historical assembly plus the corrected blank-line separator', () => {
-  const jobId = 'shell_job_1';
-  const status = 'completed';
-  const exitCode = 0;
-  const elapsedMs = 1234;
-  const detail = {
-    command: 'npm test',
-    summary: 'ok',
-    stdoutPreview: 'out',
-    stderrPreview: 'err',
-    mergeStderr: false,
-  };
-  const expected = [
-    `[task_id: ${jobId}]`,
-    `[status: ${status}]`,
-    `[exit: ${exitCode === null ? 'n/a' : exitCode}]`,
-    elapsedMs !== null ? `[elapsed: ${elapsedMs} ms]` : null,
-    detail.command ? `[command: ${detail.command}]` : null,
-    // The historical inline assembly filtered this '' out, gluing `Summary:`
-    // onto the header block; the corrected renderer keeps exactly one blank
-    // line between the bracket headers and the body sections.
-    '',
-    detail.summary ? `Summary: ${detail.summary}` : null,
-    detail.stdoutPreview ? `\n[stdout preview]\n${detail.stdoutPreview}` : null,
-    (detail.mergeStderr !== true && detail.stderrPreview) ? `\n[stderr preview]\n${detail.stderrPreview}` : null,
-  ].filter((l) => l !== null).join('\n');
-  const actual = renderShellCompletionEnvelope({ jobId, status, exitCode, elapsedMs, ...detail });
-  assert.equal(actual, expected);
-  assert.equal(isInternalRuntimeNotificationText(actual), true);
-  assert.equal(isBracketedShellNotificationEnvelope(actual), true);
-});
-
-test('summary-only completion envelope keeps one blank line before the body', () => {
-  const actual = renderShellCompletionEnvelope({
-    jobId: 'shell_job_1',
-    status: 'completed',
-    exitCode: 0,
-    summary: 'ok',
-  });
-  const expected = [
-    '[task_id: shell_job_1]',
-    '[status: completed]',
-    '[exit: 0]',
-    '',
-    'Summary: ok',
-  ].join('\n');
-  assert.equal(actual, expected);
-  // The blank-line separator must survive so body detectors see a body.
-  assert.match(actual, /\n\s*\n/);
-});
-
-test('bodyless completion envelope has no trailing blank line', () => {
-  const actual = renderShellCompletionEnvelope({
-    jobId: 'shell_job_1',
-    status: 'completed',
-    exitCode: 0,
-  });
-  assert.equal(actual, ['[task_id: shell_job_1]', '[status: completed]', '[exit: 0]'].join('\n'));
-  assert.doesNotMatch(actual, /\n\s*\n/);
-});
-
-test('completion instruction uses shared async wording + exit detail', () => {
-  assert.equal(
-    shellCompletionInstruction({ jobId: 'shell_job_1', status: 'completed', exitCode: 0 }),
-    'The async shell task shell_job_1 has finished (completed, exit 0) - review this result in your next step.',
-  );
-  assert.match(shellCompletionInstruction({ jobId: 'x', status: 'failed', exitCode: null }), /exit n\/a/);
-});
-
-test('prompt-stall envelope is byte-compatible with historical inline assembly', () => {
-  const jobId = 'shell_job_1';
-  const stalledMs = 5000;
-  const elapsedMs = 6000;
-  const tail = { text: 'Password:' };
-  const detail = { command: 'ssh host' };
-  const expected = [
-    `[task_id: ${jobId}]`,
-    '[status: running]',
-    `[stalled: no output growth for ${stalledMs} ms]`,
-    elapsedMs >= 0 ? `[elapsed: ${elapsedMs} ms]` : null,
-    detail.command ? `[command: ${detail.command}]` : null,
-    '',
-    'This background shell task appears to be waiting for interactive input. Background tasks cannot answer prompts automatically; cancel it or rerun with non-interactive flags/input.',
-    tail.text ? `\n${tail.text}` : null,
-  ].filter((line) => line !== null && line !== '').join('\n');
-  const actual = renderShellPromptStallEnvelope({ jobId, stalledMs, elapsedMs, command: detail.command, tailText: tail.text });
-  assert.equal(actual, expected);
-  assert.equal(isInternalRuntimeNotificationText(actual), true);
-});
-
-test('prompt-stall instruction wording unchanged', () => {
-  assert.equal(
-    shellPromptStallInstruction({ jobId: 'shell_job_1' }),
-    'The background shell task shell_job_1 appears to be waiting for interactive input; inspect the prompt, then cancel or rerun it non-interactively.',
-  );
-});