sanook-cli 0.5.2 → 0.5.7

package/dist/memory-log.js

@@ -0,0 +1,90 @@
+// `sanook memory log` — a read-only viewer over the BI-TEMPORAL memory store: see how a belief about
+// the project evolved over time (what was true, when it was superseded, and by what). The store keeps
+// superseded/archived facts with validFrom/invalidatedAt/supersededBy/supersedes edges — most coding
+// CLIs overwrite memory, so this "decision evolution" view is genuinely differentiated. Pure +
+// deterministic (no disk/clock of its own) → fully testable.
+import { tokens } from './memory-store.js';
+function relevance(query, fact) {
+    const q = [...tokens(query)];
+    if (!q.length)
+        return 0;
+    const ft = [...tokens(fact.text)];
+    // forgiving match for a human-facing viewer: exact OR a shared prefix (deploy↔deploys↔deployment)
+    const matches = (t) => ft.some((w) => w === t || (t.length >= 3 && (w.startsWith(t) || t.startsWith(w))));
+    let overlap = 0;
+    for (const t of q)
+        if (matches(t))
+            overlap++;
+    return overlap;
+}
+/**
+ * Facts matching `query` across ALL statuses (active + superseded + archived), each with its
+ * evolution edges resolved. Empty query → the most recently CHANGED facts (superseded/archived first)
+ * so `sanook memory log` with no args surfaces "what beliefs changed recently".
+ */
+export function memoryLog(store, query = '', limit = 12) {
+    const byId = new Map(store.facts.map((f) => [f.id, f]));
+    const q = query.trim();
+    const ranked = q
+        ? store.facts
+            .map((f) => ({ f, score: relevance(q, f) }))
+            .filter((x) => x.score > 0)
+            .sort((a, b) => b.score - a.score || b.f.updated - a.f.updated)
+            .map((x) => x.f)
+        : [...store.facts]
+            .filter((f) => f.status !== 'active') // no query → highlight what CHANGED
+            .sort((a, b) => (b.invalidatedAt ?? b.updated) - (a.invalidatedAt ?? a.updated));
+    return ranked.slice(0, limit).map((f) => ({
+        fact: f,
+        supersededBy: f.supersededBy ? byId.get(f.supersededBy) : undefined,
+        supersedes: f.supersedes.map((id) => byId.get(id)).filter((x) => !!x),
+    }));
+}
+export function memoryStats(store) {
+    const byTier = {};
+    let active = 0, superseded = 0, archived = 0;
+    for (const f of store.facts) {
+        byTier[f.tier] = (byTier[f.tier] ?? 0) + 1;
+        if (f.status === 'active')
+            active++;
+        else if (f.status === 'superseded')
+            superseded++;
+        else if (f.status === 'archived')
+            archived++;
+    }
+    return { total: store.facts.length, active, superseded, archived, byTier };
+}
+function day(ms) {
+    try {
+        return new Date(ms).toISOString().slice(0, 10);
+    }
+    catch {
+        return '?';
+    }
+}
+const BADGE = { active: '● active', superseded: '↻ superseded', archived: '⌁ archived' };
+export function renderMemoryLog(entries, query = '') {
+    if (!entries.length) {
+        return query ? `ไม่เจอ fact ที่ตรงกับ "${query}" ใน memory (รวม superseded/archived)` : 'ยังไม่มี belief ที่เปลี่ยน (superseded/archived) — memory ยังนิ่ง';
+    }
+    const lines = [query ? `memory log — "${query}" (${entries.length})` : `memory log — recent changes (${entries.length})`];
+    for (const e of entries) {
+        const f = e.fact;
+        const when = f.invalidatedAt ? `${day(f.validFrom)} → ${day(f.invalidatedAt)}` : `since ${day(f.validFrom)}`;
+        lines.push('', `${BADGE[f.status] ?? f.status}  [${f.noteType}/${f.tier}]  ${when}`);
+        lines.push(`  ${f.text}`);
+        if (e.supersededBy)
+            lines.push(`  ↳ superseded by: ${e.supersededBy.text} (${day(e.supersededBy.validFrom)})`);
+        for (const s of e.supersedes)
+            lines.push(`  ↳ supersedes: ${s.text}`);
+    }
+    return lines.join('\n');
+}
+export function renderMemoryStats(s) {
+    const tiers = Object.entries(s.byTier).map(([t, n]) => `${t}:${n}`).join(' · ') || '(none)';
+    return [
+        `memory: ${s.total} fact(s)`,
+        `  ● active ${s.active} · ↻ superseded ${s.superseded} · ⌁ archived ${s.archived}`,
+        `  tiers: ${tiers}`,
+    ].join('\n');
+}

package/dist/memory-store.js

@@ -503,6 +503,8 @@ export async function loadStore(now = Date.now()) {
         const parsed = StoreSchema.safeParse(JSON.parse(await readFile(MEMORY_JSON, 'utf8')));
         if (parsed.success)
             return parsed.data;
+        // parseable but schema-invalid (version bump / partial write): DON'T lose it — saveStore
+        // preserves the original to a .corrupt backup before the next overwrite (loadStore stays pure).
     }
     catch {
         /* no json yet, or malformed → fall through */
@@ -536,12 +538,46 @@ async function writeSecure(path, content) {
  * Both files are 0o600. On the very first json write, the legacy MEMORY.md is backed up
  * to MEMORY.md.bak so raw legacy text is never destroyed. No-op when persistence is disabled.
  */
+/**
+ * If an existing memory.json cannot be validated (schema bump / corruption / partial write),
+ * copy it verbatim to memory.json.<ts>.corrupt before it gets overwritten — so a single schema
+ * mismatch never silently destroys the entire auto-memory. Best-effort, idempotent per `now`.
+ */
+async function preserveUnvalidatableStore(now) {
+    let raw;
+    try {
+        raw = await readFile(MEMORY_JSON, 'utf8');
+    }
+    catch {
+        return;
+    }
+    try {
+        if (StoreSchema.safeParse(JSON.parse(raw)).success)
+            return; // valid → nothing to rescue
+    }
+    catch {
+        /* unparseable → preserve below */
+    }
+    const backup = `${MEMORY_JSON}.${now}.corrupt`;
+    if (await exists(backup))
+        return;
+    try {
+        await writeFile(backup, raw, { mode: 0o600 });
+        await chmod(backup, 0o600).catch(() => { });
+    }
+    catch {
+        /* best-effort */
+    }
+}
 export async function saveStore(store, now = Date.now()) {
     if (!persistenceEnabled())
         return;
     await mkdir(MEMORY_DIR, { recursive: true });
     const firstJson = !(await exists(MEMORY_JSON));
-    if (firstJson && (await exists(AUTO_MEMORY_FILE))) {
+    if (!firstJson) {
+        await preserveUnvalidatableStore(now); // data-loss guard before overwriting an unvalidatable store
+    }
+    else if (await exists(AUTO_MEMORY_FILE)) {
         await copyFile(AUTO_MEMORY_FILE, MEMORY_BAK).catch(() => { });
         await chmod(MEMORY_BAK, 0o600).catch(() => { });
     }

package/dist/memory.js

@@ -1,5 +1,7 @@
 import { readFile, writeFile, stat } from 'node:fs/promises';
 import { join, dirname, resolve } from 'node:path';
+import { buildContextPackBlock, listContextPacks, readContextPackExcerpt, selectContextPack } from './context-pack.js';
+import { buildProjectContextBlock, resolveVaultProject } from './project-registry.js';
 import { appHomePath, BRAND, persistenceEnabled, worklogEnabled } from './brand.js';
 import { redactKey } from './providers/keys.js';
 import { loadStore, saveStore, mergeFact, maybeConsolidate, consolidate, renderPromptBlock } from './memory-store.js';
@@ -77,12 +79,12 @@ export async function loadAutoMemory() {
  * "รู้จัก" vault: inject Shared/AI-Context-Index.md (ไฟล์ที่ vault บอกให้อ่านก่อน) เข้า system prompt
  * brainPath มาจาก ~/.sanook/config.json · ไม่มี/ไฟล์หาย → คืน '' (เงียบ)
  */
-export async function loadBrainContext() {
+export async function loadBrainContext(cwd = process.cwd()) {
     const brainPath = await getBrainPath();
-    return brainPath ? buildBrainContext(brainPath) : '';
+    return brainPath ? buildBrainContext(brainPath, { cwd }) : '';
 }
 /** ประกอบ source parts ชุดเดียวกับที่ inject เข้า prompt จริง — ให้ CLI inspect ได้โดยไม่ drift */
-export async function buildBrainContextParts(brainPath) {
+export async function buildBrainContextParts(brainPath, options = {}) {
     const idx = await readTrimmedPart({
         id: 'ai-context-index',
         label: 'AI Context Index',
@@ -99,7 +101,47 @@ export async function buildBrainContextParts(brainPath) {
         wrap: (content) => `## current-state\n${content}`,
     });
     const inbox = await readInboxPart(brainPath, 'Shared/Memory-Inbox/memory-inbox.md', 1200);
-    return [idx, currentState, inbox];
+    const parts = [idx, currentState, inbox];
+    const project = await resolveVaultProject({
+        brainPath,
+        cwd: options.cwd,
+        slug: options.projectSlug,
+    });
+    if (project) {
+        const block = await buildProjectContextBlock(brainPath, project);
+        parts.push({
+            id: 'project-workspace',
+            label: `Project (${project.slug})`,
+            relPath: `${project.relDir}/`,
+            path: join(brainPath, project.relDir),
+            content: block,
+            chars: block.length,
+            maxChars: 3500,
+            status: block ? 'present' : 'empty',
+        });
+    }
+    const taskQuery = options.taskQuery?.trim();
+    if (taskQuery) {
+        const packs = await listContextPacks(brainPath);
+        const selected = selectContextPack(taskQuery, packs);
+        if (selected) {
+            const relPath = selected.pack.relPath;
+            const path = join(brainPath, relPath);
+            const maxChars = 1200;
+            const excerpt = await readContextPackExcerpt(brainPath, selected.pack, maxChars);
+            parts.push({
+                id: 'context-pack',
+                label: `Context Pack (${selected.pack.slug})`,
+                relPath,
+                path,
+                content: excerpt,
+                chars: excerpt.length,
+                maxChars,
+                status: excerpt ? 'present' : 'empty',
+            });
+        }
+    }
+    return parts;
 }
 export function renderBrainContext(brainPath, parts) {
     const content = parts.map((part) => part.content).filter(Boolean);
@@ -107,10 +149,12 @@ export function renderBrainContext(brainPath, parts) {
         return '';
     return `<brain_vault path="${brainPath}" note="second-brain ของ user — สิ่งที่จำไว้/state ปัจจุบันอยู่ใน block นี้; route โน้ตตาม Vault Structure Map; อ่าน/เขียนไฟล์ใน vault ด้วย absolute path ได้">\n${content.join('\n\n')}\n</brain_vault>`;
 }
-/** ประกอบ brain context จาก vault path (pure → testable) — entry + current-state + remembered facts */
-export async function buildBrainContext(brainPath) {
-    return renderBrainContext(brainPath, await buildBrainContextParts(brainPath));
+/** ประกอบ brain context จาก vault path (pure → testable) — entry + current-state + remembered facts + optional context pack */
+export async function buildBrainContext(brainPath, options = {}) {
+    return renderBrainContext(brainPath, await buildBrainContextParts(brainPath, options));
 }
+/** Build a standalone context-pack block for per-turn injection (turn-retrieval path). */
+export { buildContextPackBlock };
 async function readTrimmedPart(input) {
     const p = join(input.brainPath, input.relPath);
     try {

package/dist/model-picker.js

@@ -0,0 +1,58 @@
+import { canonicalSpec, hasUsableEnvKey, PROVIDERS, parseSpec } from './providers/registry.js';
+function statusFor(provider) {
+    const cfg = PROVIDERS[provider];
+    if (cfg.kind === 'delegate')
+        return 'delegate';
+    if (!cfg.requiresKey)
+        return 'local';
+    return hasUsableEnvKey(provider) ? 'ready' : 'needs-key';
+}
+function statusLabel(status) {
+    if (status === 'needs-key')
+        return 'needs key';
+    return status;
+}
+export function modelPickerOptions(current) {
+    const currentSpec = canonicalSpec(current);
+    return Object.entries(PROVIDERS).flatMap(([provider, cfg]) => {
+        const grouped = new Map();
+        for (const [alias, model] of Object.entries(cfg.models)) {
+            const aliases = grouped.get(model) ?? [];
+            aliases.push(alias);
+            grouped.set(model, aliases);
+        }
+        const status = statusFor(provider);
+        return [...grouped.entries()].map(([model, aliases]) => {
+            const nonDefaultAliases = aliases.filter((alias) => alias !== 'default');
+            const displayAliases = nonDefaultAliases.length ? nonDefaultAliases.join('/') : 'default';
+            const spec = `${provider}:${model}`;
+            return {
+                aliases: displayAliases,
+                current: spec === currentSpec,
+                label: `${provider}:${displayAliases}`,
+                meta: `${cfg.label} · ${statusLabel(status)}`,
+                model,
+                provider,
+                spec,
+                status,
+            };
+        });
+    });
+}
+export function initialModelPickerIndex(options) {
+    const current = options.findIndex((option) => option.current);
+    return current === -1 ? 0 : current;
+}
+export function modelProviderEntries() {
+    return Object.entries(PROVIDERS).map(([id, cfg]) => ({
+        id,
+        label: cfg.label,
+        status: statusFor(id),
+        modelCount: new Set(Object.values(cfg.models)).size,
+    }));
+}
+export function filterModelPickerOptions(options, providerId) {
+    if (!providerId)
+        return options;
+    return options.filter((option) => option.provider === providerId);
+}

package/dist/orchestrate.js

@@ -1,20 +1,22 @@
 import { inspect } from 'node:util';
+import { redactKey, redactUnknown } from './providers/keys.js';
 export function formatSubagentError(e) {
     if (e instanceof Error)
-        return e.message || e.name;
+        return redactKey(e.message || e.name);
     if (typeof e === 'string')
-        return e;
+        return redactKey(e);
     if (e == null)
         return String(e);
+    const safe = redactUnknown(e);
     try {
-        const json = JSON.stringify(e);
+        const json = JSON.stringify(safe);
         if (json)
             return json;
     }
     catch {
-        return inspect(e, { breakLength: Infinity, depth: 2 });
+        return inspect(safe, { breakLength: Infinity, depth: 2 });
     }
-    return String(e);
+    return redactKey(String(e));
 }
 const DEFAULT_CONCURRENCY = 5;
 const DEFAULT_GLOBAL_SUBAGENT_CONCURRENCY = 16;

package/dist/plan-handoff.js

@@ -0,0 +1,17 @@
+import { BRAND } from './brand.js';
+/** Shell-safe double-quoted string for handoff hints (task may contain quotes/newlines). */
+export function shellQuoteDouble(value) {
+    return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\r?\n/g, '\\n')}"`;
+}
+/** Hint printed after plan mode completes — stderr so stdout stays pipe-friendly. */
+export function formatPlanExecuteHandoff(originalTask) {
+    const task = originalTask.trim();
+    const quoted = task ? shellQuoteDouble(task) : '<task>';
+    return [
+        '---',
+        'Plan complete. Execute with:',
+        `  ${BRAND.cliName} --yes ${quoted}`,
+        `  ${BRAND.cliName} plan ${quoted} | ${BRAND.cliName} --yes ${shellQuoteDouble('Execute this plan:')}`,
+        `  (plan text on stdout → pipe into ${BRAND.cliName} --yes "Execute this plan:" with stdin)`,
+    ].join('\n');
+}

package/dist/polyglot.js

@@ -0,0 +1,162 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { BRAND } from './brand.js';
+import { findBinary } from './lsp/servers.js';
+import { safeProcessEnv } from './process-runner.js';
+const execFileAsync = promisify(execFile);
+const MAX_VERSION_TEXT = 160;
+const RUNTIME_SPECS = [
+    {
+        id: 'python',
+        label: 'Python',
+        candidates: ['python3', 'python'],
+        versionArgs: ['--version'],
+        role: 'data/doc/ML glue, JSON/CSV transforms, OCR/transcription helpers, one-off research scripts via run_python',
+        install: 'Install Python 3.11+ (python.org, Homebrew, pyenv, or uv).',
+    },
+    {
+        id: 'uv',
+        label: 'uv',
+        candidates: ['uv'],
+        versionArgs: ['--version'],
+        role: 'fast Python project/env management when Sanook grows optional Python packs',
+        install: 'Install uv: https://docs.astral.sh/uv/',
+    },
+    {
+        id: 'rustc',
+        label: 'Rust compiler',
+        candidates: ['rustc'],
+        versionArgs: ['--version'],
+        role: 'compile small high-speed/safe helpers and future native accelerators via run_rust',
+        install: 'Install Rust via rustup: https://rustup.rs/',
+    },
+    {
+        id: 'cargo',
+        label: 'Cargo',
+        candidates: ['cargo'],
+        versionArgs: ['--version'],
+        role: 'build/test packaged Rust helpers when a native crate becomes worth shipping',
+        install: 'Install Rust via rustup: https://rustup.rs/',
+    },
+    {
+        id: 'pyright',
+        label: 'Pyright LSP',
+        candidates: ['pyright-langserver'],
+        versionArgs: ['--version'],
+        role: 'Python diagnostics through Sanook diagnostics tool',
+        install: 'npm i -g pyright',
+    },
+    {
+        id: 'rust-analyzer',
+        label: 'rust-analyzer LSP',
+        candidates: ['rust-analyzer'],
+        versionArgs: ['--version'],
+        role: 'Rust diagnostics through Sanook diagnostics tool',
+        install: 'rustup component add rust-analyzer',
+    },
+];
+async function defaultVersion(command, args, cwd) {
+    const { stdout, stderr } = await execFileAsync(command, args, { cwd, env: safeProcessEnv(), timeout: 5_000, maxBuffer: 256 * 1024 });
+    return stdout.trim() ? stdout : stderr;
+}
+function normalizeVersionText(version) {
+    const firstLine = version.trim().split(/\r?\n/)[0]?.trim() || '(version unavailable)';
+    if (firstLine.length <= MAX_VERSION_TEXT)
+        return firstLine;
+    return `${firstLine.slice(0, MAX_VERSION_TEXT - '... [truncated]'.length)}... [truncated]`;
+}
+async function detectSpec(spec, cwd, findBinaryImpl, versionImpl) {
+    for (const candidate of spec.candidates) {
+        const command = await findBinaryImpl(candidate, cwd);
+        if (!command)
+            continue;
+        let version;
+        try {
+            version = normalizeVersionText(await versionImpl(command, [...spec.versionArgs], cwd));
+        }
+        catch {
+            version = '(installed; version probe failed)';
+        }
+        return {
+            id: spec.id,
+            label: spec.label,
+            status: 'ready',
+            command,
+            version,
+            role: spec.role,
+            install: spec.install,
+        };
+    }
+    return {
+        id: spec.id,
+        label: spec.label,
+        status: 'missing',
+        role: spec.role,
+        install: spec.install,
+    };
+}
+export async function inspectPolyglotRuntimes(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const findBinaryImpl = options.findBinaryImpl ?? findBinary;
+    const versionImpl = options.versionImpl ?? defaultVersion;
+    const optional = await Promise.all(RUNTIME_SPECS.map((spec) => detectSpec(spec, cwd, findBinaryImpl, versionImpl)));
+    return {
+        cwd,
+        runtimes: [
+            {
+                id: 'typescript',
+                label: 'TypeScript / Node.js',
+                status: 'core',
+                command: process.execPath,
+                version: `node ${process.versions.node}`,
+                role: 'core Sanook runtime: agent loop, TUI, gateway, MCP, second-brain, packaging',
+            },
+            ...optional,
+        ],
+        strategy: [
+            'TypeScript stays the control plane and npm-distributed default.',
+            'Python is the optional analysis/data plane: scripts, data wrangling, document/ML/OCR workflows, and research helpers.',
+            'Rust is the optional performance/safety plane: single-binary helpers, high-throughput parsing/search, and future native accelerators.',
+            'Optional runtimes must degrade gracefully; missing Python/Rust should never break basic Sanook install or chat.',
+        ],
+        notes: [
+            '`run_python` and `run_rust` are approval-gated tools because arbitrary code can mutate files.',
+            'The diagnostics tool already understands Python and Rust when Pyright/rust-analyzer are installed.',
+            'Use `sanook mcp list --tools` for external runtime capabilities exposed through MCP servers.',
+        ],
+    };
+}
+function fmtStatus(status) {
+    if (status === 'core')
+        return 'CORE ';
+    if (status === 'ready')
+        return 'READY';
+    return 'MISS ';
+}
+export function renderPolyglotReport(report) {
+    const missingRuntimes = report.runtimes.filter((runtime) => runtime.status === 'missing');
+    const lines = [
+        `${BRAND.productName} runtimes`,
+        `cwd: ${report.cwd}`,
+        '',
+        'Runtime surface:',
+        ...report.runtimes.map((runtime) => {
+            const version = runtime.version ? ` — ${runtime.version}` : '';
+            const command = runtime.command ? ` (${runtime.command})` : '';
+            return `  [${fmtStatus(runtime.status)}] ${runtime.label}${version}${command}`;
+        }),
+        '',
+        'Role map:',
+        ...report.runtimes.map((runtime) => `  - ${runtime.label}: ${runtime.role}`),
+        '',
+        'Strategy:',
+        ...report.strategy.map((item) => `  - ${item}`),
+        '',
+        'Missing install hints:',
+        ...(missingRuntimes.length > 0 ? missingRuntimes.map((runtime) => `  - ${runtime.label}: ${runtime.install}`) : ['  - None']),
+        '',
+        'Notes:',
+        ...report.notes.map((note) => `  - ${note}`),
+    ];
+    return `${lines.join('\n')}\n`;
+}

package/dist/process-runner.js

@@ -0,0 +1,96 @@
+import { spawn } from 'node:child_process';
+import { clamp } from './tools/util.js';
+const SAFE_ENV_KEYS = ['PATH', 'HOME', 'TMPDIR', 'TEMP', 'TMP', 'LANG', 'LC_ALL', 'USER', 'SHELL', 'TERM', 'NODE_PATH', 'NVM_DIR', 'APPDATA'];
+const DEFAULT_MAX_BUFFER = 10 * 1024 * 1024;
+export function safeProcessEnv(env = process.env) {
+    const out = {};
+    for (const key of SAFE_ENV_KEYS) {
+        const value = env[key];
+        if (value != null)
+            out[key] = value;
+    }
+    return out;
+}
+function appendChunk(chunks, chunk, state, maxBuffer) {
+    if (state.bytes >= maxBuffer) {
+        state.truncated = true;
+        return;
+    }
+    const remaining = maxBuffer - state.bytes;
+    const kept = chunk.length > remaining ? chunk.subarray(0, remaining) : chunk;
+    chunks.push(kept);
+    state.bytes += kept.length;
+    if (kept.length < chunk.length)
+        state.truncated = true;
+}
+export function runProcess(file, args, options = {}) {
+    const timeoutMs = Math.max(1, Math.min(options.timeoutMs ?? 120_000, 300_000));
+    const maxBuffer = Math.max(1, options.maxBuffer ?? DEFAULT_MAX_BUFFER);
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    const stdoutState = { bytes: 0, truncated: false };
+    const stderrState = { bytes: 0, truncated: false };
+    return new Promise((resolve) => {
+        let timedOut = false;
+        let settled = false;
+        const child = spawn(file, args, {
+            cwd: options.cwd,
+            env: safeProcessEnv(),
+            shell: false,
+            windowsHide: true,
+        });
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGTERM');
+            setTimeout(() => {
+                if (!settled)
+                    child.kill('SIGKILL');
+            }, 1_000).unref();
+        }, timeoutMs);
+        child.stdout.on('data', (chunk) => appendChunk(stdoutChunks, chunk, stdoutState, maxBuffer));
+        child.stderr.on('data', (chunk) => appendChunk(stderrChunks, chunk, stderrState, maxBuffer));
+        child.on('error', (err) => {
+            clearTimeout(timer);
+            settled = true;
+            resolve({
+                ok: false,
+                stdout: Buffer.concat(stdoutChunks).toString('utf8'),
+                stderr: Buffer.concat(stderrChunks).toString('utf8'),
+                code: null,
+                signal: null,
+                timedOut,
+                truncated: stdoutState.truncated || stderrState.truncated,
+                error: err.message,
+            });
+        });
+        child.on('close', (code, signal) => {
+            clearTimeout(timer);
+            settled = true;
+            resolve({
+                ok: code === 0 && !timedOut,
+                stdout: Buffer.concat(stdoutChunks).toString('utf8'),
+                stderr: Buffer.concat(stderrChunks).toString('utf8'),
+                code,
+                signal,
+                timedOut,
+                truncated: stdoutState.truncated || stderrState.truncated,
+            });
+        });
+        if (options.input != null)
+            child.stdin.end(options.input);
+        else
+            child.stdin.end();
+    });
+}
+export function formatProcessResult(result) {
+    const body = (result.stdout + (result.stderr ? `\n[stderr]\n${result.stderr}` : '')).trim();
+    const truncated = result.truncated ? '\n... [process output truncated]' : '';
+    if (result.ok)
+        return clamp(`${body}${truncated}`.trim()) || '(no output)';
+    const status = result.timedOut
+        ? 'timeout'
+        : result.error
+            ? result.error
+            : `exit ${result.code ?? 'unknown'}${result.signal ? ` (${result.signal})` : ''}`;
+    return clamp(`ERROR: process failed — ${status}${body ? `\n${body}` : ''}${truncated}`);
+}