@north-light/crouter 0.3.303 → 0.3.305

package/dist/daemon/reconcilers/broker-supervision.js

@@ -573,6 +573,14 @@ export class BrokerSupervisionReconciler {
         const name = meta !== null ? fullName(meta) : id;
         const isAuth = fault.kind === 'auth';
         const firstLine = (fault.message.split('\n')[0] ?? '').slice(0, 200);
+        const providerError = fault.providerError;
+        const providerDetail = providerError === undefined
+            ? ''
+            : ` Provider: ${providerError.provider}/${providerError.model}.` +
+                (providerError.status === undefined ? '' : ` HTTP status: ${providerError.status}.`) +
+                (providerError.errno === undefined ? '' : ` Errno: ${providerError.errno}.`) +
+                (providerError.code === undefined ? '' : ` Code: ${providerError.code}.`) +
+                (providerError.body === undefined ? '' : ` Body: ${providerError.body.slice(0, 200)}.`);
         const terminalOverflow = fault.kind === 'context-overflow';
         const label = terminalOverflow
             ? `Child failed — ${name} (${id}) exceeded its model context window and is now dead. ` +
@@ -582,7 +590,7 @@ export class BrokerSupervisionReconciler {
                 (isAuth
                     ? `Its provider credential is dead — re-authenticate (\`/login\`, or re-auth crtr); the child recovers on its next wake once the auth reloads. `
                     : ``) +
-                `Error: ${firstLine}`;
+                `Error: ${firstLine}.${providerDetail}`;
         if (terminalOverflow) {
             try {
                 transition(id, 'crash', {
@@ -618,6 +626,7 @@ export class BrokerSupervisionReconciler {
             child: id,
             kind: fault.kind,
             message: firstLine,
+            ...(providerError === undefined ? {} : { provider_error: providerError }),
         });
     }
     async handleAuthReload(fleet) {

package/dist/daemon/reconcilers/managed-worktree-sweep.js

@@ -30,6 +30,12 @@ const TERMINAL_STATUSES = ['done', 'dead', 'canceled'];
 function isTerminal(row) {
     return TERMINAL_STATUSES.includes(row.status);
 }
+/** A closed record already has an explicit close disposition. An open record
+ *  reaches the sweep only when its owner published a final result; a crash or
+ *  cancellation leaves its managed checkout available for explicit recovery. */
+function hasSweepDisposition(row, wt) {
+    return wt?.state === 'closed' || (wt?.state === 'open' && row.status === 'done' && row.final_report !== null);
+}
 /** Is this node's engine definitively gone?
  *
  *  Terminal status alone is not enough: `push final` marks a node `done` while
@@ -49,6 +55,8 @@ function engineIsGone(row, fleet, snapshot) {
         return false;
     if (!isTerminal(row))
         return false;
+    if (!hasSweepDisposition(row, getNode(row.node_id)?.managed_worktree))
+        return false;
     return recordedPidLiveness(row.pi_pid, row.pi_pid_identity, snapshot) === 'dead';
 }
 /** The eligibility recheck the reconciliation runs immediately before EVERY Git
@@ -70,6 +78,8 @@ function eligibilityGuard(row, fleet) {
             const current = getRow(nodeId);
             if (current === null || !isTerminal(current) || current.frozen_at !== null)
                 return false;
+            if (!hasSweepDisposition(current, getNode(nodeId)?.managed_worktree))
+                return false;
             return current.pi_pid === pid && current.pi_pid_identity === identity;
         },
     };
@@ -120,6 +130,8 @@ export class ManagedWorktreeSweepReconciler {
             }
             if (!isReconcilable(wt) || wt == null)
                 continue;
+            if (!hasSweepDisposition(row, wt))
+                continue;
             if (!isDueForSweep(wt, now))
                 continue;
             due.push(row.node_id);

package/dist/daemon/reconcilers/node-lifecycle/tick.d.ts

@@ -7,12 +7,6 @@ export interface NodeLifecycleContext {
     rows: readonly NodeRow[];
     fleet: FleetRegistry;
 }
-/** Whether this row should have a live engine right now. An active row always
- *  should — that status IS the claim that it is executing. An idle row was
- *  deliberately released and holds no engine on purpose: only mail it has not
- *  seen brings one back, because a live obligation keeps a node WAKEABLE rather
- *  than awake, and relaunching on one would re-release it every tick. */
-export declare function wantsExecution(row: NodeRow): boolean;
 export declare class NodeLifecycleReconciler {
     private readonly freezeLane;
     run(now: number, ctx: NodeLifecycleContext): Promise<FrozenCounts>;

package/dist/daemon/reconcilers/node-lifecycle/tick.js

@@ -12,7 +12,6 @@ import { isSafeNodeId } from '../../../core/canvas/paths.js';
 import { recordedPidLiveness } from '../../../core/canvas/pid.js';
 import { emitEvent } from '../../../core/events/emit.js';
 import { operationIdContext } from '../../../core/events/operation-id.js';
-import { hasUnseenWakeMail } from '../../../core/feed/inbox.js';
 import { hasCleanAbort, isBusy } from '../../../core/runtime/busy.js';
 import { isProfilePaused } from '../../../core/profiles/manifest.js';
 import { classifyDeadNode } from '../../fleet.js';
@@ -20,21 +19,10 @@ import { applyParkEvent, hasPendingWake, parkEvent } from '../live-obligation.js
 import { FreezeLaneReconciler } from './freeze-lane.js';
 import { isInBackoff } from './respawn-policy.js';
 import { handleTerminatingRow } from './terminating.js';
+import { wantsExecution } from './wants-execution.js';
 function isTerminal(row) {
     return row.status === 'done' || row.status === 'canceled' || row.status === 'dead';
 }
-/** Whether this row should have a live engine right now. An active row always
- *  should — that status IS the claim that it is executing. An idle row was
- *  deliberately released and holds no engine on purpose: only mail it has not
- *  seen brings one back, because a live obligation keeps a node WAKEABLE rather
- *  than awake, and relaunching on one would re-release it every tick. */
-export function wantsExecution(row) {
-    if (row.status === 'active')
-        return true;
-    if (row.status !== 'idle')
-        return false;
-    return hasUnseenWakeMail(row.node_id);
-}
 export class NodeLifecycleReconciler {
     freezeLane = new FreezeLaneReconciler();
     async run(now, ctx) {

package/dist/daemon/reconcilers/node-lifecycle/wants-execution.d.ts

@@ -0,0 +1,5 @@
+import type { NodeRow } from '../../../core/canvas/index.js';
+/** Whether the lifecycle tick must ensure this row has an engine. The durable
+ * message handler calls this after appending its entry: that append makes the
+ * idle branch's unseen-wake-mail check true for a wake-capable entry. */
+export declare function wantsExecution(row: Pick<NodeRow, 'node_id' | 'status'>): boolean;

package/dist/daemon/reconcilers/node-lifecycle/wants-execution.js

@@ -0,0 +1,11 @@
+import { hasUnseenWakeMail } from '../../../core/feed/inbox.js';
+/** Whether the lifecycle tick must ensure this row has an engine. The durable
+ * message handler calls this after appending its entry: that append makes the
+ * idle branch's unseen-wake-mail check true for a wake-capable entry. */
+export function wantsExecution(row) {
+    if (row.status === 'active')
+        return true;
+    if (row.status !== 'idle')
+        return false;
+    return hasUnseenWakeMail(row.node_id);
+}

package/dist/pi-extensions/__tests__/canvas-context-intro.test.js

@@ -5,12 +5,16 @@
 import { test, before, after, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert/strict';
 import { existsSync, mkdtempSync, mkdirSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { createServer } from 'node:http';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { registerCanvasContextIntro, CONTEXT_INTRO_CUSTOM_TYPE, } from '../canvas-context-intro.js';
 import { registerCanvasDocSubstrate } from '../canvas-doc-substrate.js';
 import { buildContextBearings as buildContextIntro } from '../../core/runtime/bearings.js';
 import { installPersonaTransitionGate } from '../../core/runtime/broker-persona-guidance.js';
+import { FaultRetry } from '../../core/runtime/broker/fault-retry.js';
+import { readFault } from '../../core/runtime/fault.js';
+import { ApiError } from '../../api/errors.js';
 import { createNode, deleteNode, getNode, updateNode } from '../../core/canvas/canvas.js';
 import { apiSocketPath } from '../../core/canvas/paths.js';
 import { createApiServer } from '../../daemon/api/server.js';
@@ -32,6 +36,23 @@ async function waitForSocket(path) {
     }
     throw new Error(`api socket never bound at ${path}`);
 }
+async function listenUnavailableApi(path) {
+    const unavailable = createServer((_request, response) => {
+        response.writeHead(503, { 'content-type': 'application/json' });
+        response.end(JSON.stringify({ error: { code: 'daemon_unavailable', message: 'local daemon connection refused' } }));
+    });
+    await new Promise((resolve, reject) => {
+        unavailable.once('error', reject);
+        unavailable.listen(path, () => {
+            unavailable.off('error', reject);
+            resolve();
+        });
+    });
+    return unavailable;
+}
+function closeHttpServer(server) {
+    return new Promise((resolve, reject) => server.close((error) => error === undefined ? resolve() : reject(error)));
+}
 function node(id, over = {}) {
     return {
         node_id: id,
@@ -322,6 +343,68 @@ test('child /new commits its baseline before ack and the provider gate delivers
             process.env['CRTR_PROFILE_ID'] = previousProfile;
     }
 });
+test('a typed local API error remains a retryable broker-to-daemon fault after settlement', async () => {
+    createNode(node('persona-transport', {
+        persona_ack: { kind: 'review', mode: 'base', lifecycle: 'terminal' },
+    }));
+    await server.close();
+    let unavailable;
+    try {
+        unavailable = await listenUnavailableApi(apiSocketPath());
+        const messages = [];
+        const agent = {
+            state: { messages },
+            transformContext: async (context) => context,
+        };
+        installPersonaTransitionGate('persona-transport', {
+            agent,
+            sessionManager: {
+                appendCustomMessageEntry: () => undefined,
+            },
+        });
+        await assert.rejects(() => agent.transformContext([{ role: 'user', content: 'continue' }]), (error) => error instanceof ApiError && error.status === 503 && error.code === 'daemon_unavailable');
+        assert.deepEqual(readFault('persona-transport'), {
+            link: 'broker↔crtrd',
+            op: 'persona transition',
+            kind: 'connection',
+            retry: { disposition: 'manual' },
+            message: 'local daemon connection refused',
+            since: readFault('persona-transport')?.since,
+            operation_id: readFault('persona-transport')?.operation_id,
+        }, 'the typed daemon transport error is recorded before Pi turns it into a generic agent error');
+        const session = {
+            sessionManager: { getLeafId: () => 'persona-transport-leaf' },
+            model: undefined,
+        };
+        const generation = {
+            id: 1,
+            session,
+            fallback: { blocked: false },
+            stagedProviderAgentEnd: {
+                messages: [{ role: 'assistant', stopReason: 'error', errorMessage: 'local daemon connection refused' }],
+            },
+            stagedWatchdogAbort: false,
+            stagedRefreshAbort: false,
+            stagedOverflowFailure: null,
+            executingTools: new Set(),
+        };
+        new FaultRetry({
+            nodeId: 'persona-transport',
+            currentSession: () => session,
+            installedGeneration: () => generation,
+        }).publishSettledProviderFault(generation);
+        const fault = readFault('persona-transport');
+        assert.equal(fault?.link, 'broker↔crtrd');
+        assert.equal(fault?.kind, 'connection');
+        assert.equal(fault?.retry.disposition, 'manual');
+    }
+    finally {
+        if (unavailable !== undefined)
+            await closeHttpServer(unavailable);
+        server = createApiServer();
+        await waitForSocket(apiSocketPath());
+    }
+});
 test('resume idempotency uses the exact details stamp independent of block text', async () => {
     createNode(node('stampD'));
     // The exact node-id stamp is authoritative even when prose carries no id.

package/dist/pi-extensions/__tests__/integration/canvas-bash-valve.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/pi-extensions/__tests__/integration/canvas-bash-valve.test.js

@@ -0,0 +1,133 @@
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { test } from 'node:test';
+import { backgroundRunningBashJobs, bashJobsDir, bashJobPaths, readJobPgid, stopBackgroundBashJob } from '../../../core/bash-jobs.js';
+import { capturePidIdentities, isPidAlive } from '../../../core/canvas/pid.js';
+import { BACKGROUND_BASH_LOG_TRUNCATION_MARKER, MAX_BACKGROUND_BASH_LOG_BYTES, createValveOperations } from '../../canvas-bash-valve.js';
+const POLL_MS = 20;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function waitFor(condition, message) {
+    const deadline = Date.now() + 4_000;
+    while (Date.now() < deadline) {
+        if (condition())
+            return;
+        await sleep(POLL_MS);
+    }
+    throw new Error(message);
+}
+async function backgroundOneJob(contextDir) {
+    await waitFor(() => backgroundRunningBashJobs(contextDir).length === 1, 'bash job did not start');
+    await waitFor(() => {
+        try {
+            return readdirSync(bashJobsDir(contextDir)).length === 1;
+        }
+        catch {
+            return false;
+        }
+    }, 'background job directory was not created');
+    return readdirSync(bashJobsDir(contextDir))[0];
+}
+function killOwnedProcess(pid) {
+    if (pid === undefined)
+        return;
+    try {
+        process.kill(pid, 'SIGKILL');
+    }
+    catch {
+        // The test already stopped this exact process.
+    }
+}
+test('background cancellation reaches a descendant that changed process groups', { timeout: 10_000 }, async () => {
+    const root = mkdtempSync(join(tmpdir(), 'crtr-bash-tree-'));
+    const contextDir = join(root, 'context');
+    const escapedPidPath = join(root, 'escaped.pid');
+    let escapedPid;
+    try {
+        const python = [
+            'import os, pathlib, time',
+            'os.setpgrp()',
+            `pathlib.Path(${JSON.stringify(escapedPidPath)}).write_text(f"{os.getpid()} {os.getpgrp()}")`,
+            'time.sleep(30)',
+        ].join('; ');
+        const run = createValveOperations('test-node', contextDir).exec(`python3 -c ${JSON.stringify(python)}`, root, { onData: () => { } });
+        const jobId = await backgroundOneJob(contextDir);
+        await run;
+        await waitFor(() => existsSync(escapedPidPath), 'escaped descendant did not start');
+        const [pidText, pgidText] = readFileSync(escapedPidPath, 'utf8').split(' ');
+        escapedPid = Number(pidText);
+        const escapedPgid = Number(pgidText);
+        assert.ok(Number.isInteger(escapedPid) && escapedPid > 1);
+        assert.notEqual(escapedPgid, readJobPgid(contextDir, jobId));
+        const stopped = await stopBackgroundBashJob(contextDir, jobId);
+        assert.equal(stopped.kind, 'stopped');
+        assert.equal(stopped.signaled, true);
+        await waitFor(() => {
+            try {
+                process.kill(escapedPid, 0);
+                return false;
+            }
+            catch {
+                return true;
+            }
+        }, 'escaped descendant survived background cancellation');
+    }
+    finally {
+        killOwnedProcess(escapedPid);
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('stale background metadata never signals a reused supervisor PID', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'crtr-bash-stale-pid-'));
+    const contextDir = join(root, 'context');
+    const child = spawn(process.execPath, ['-e', 'setTimeout(() => {}, 30_000)']);
+    try {
+        assert.notEqual(child.pid, undefined);
+        const actualIdentity = capturePidIdentities([child.pid])?.get(child.pid);
+        assert.notEqual(actualIdentity, undefined);
+        const paths = bashJobPaths(contextDir, '1234567890-stale');
+        mkdirSync(paths.dir, { recursive: true });
+        writeFileSync(paths.jobBg, '');
+        writeFileSync(paths.jobPgid, String(child.pid));
+        writeFileSync(paths.jobPgidIdentity, 'stale-supervisor');
+        const stopped = await stopBackgroundBashJob(contextDir, paths.jobId);
+        assert.deepEqual(stopped, { kind: 'stopped', signaled: false, pgid: child.pid, logPath: paths.jobLog });
+        assert.equal(isPidAlive(child.pid), true, 'a process with a reused supervisor PID was signaled');
+    }
+    finally {
+        child.kill('SIGKILL');
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('background log retains a capped prefix, truncation marker, and does not grow afterward', { timeout: 10_000 }, async () => {
+    const root = mkdtempSync(join(tmpdir(), 'crtr-bash-log-'));
+    const contextDir = join(root, 'context');
+    try {
+        const writer = [
+            'const chunk = Buffer.alloc(1024 * 1024, 120)',
+            'setTimeout(() => {',
+            '  for (let i = 0; i < 11; i += 1) process.stdout.write(chunk)',
+            '  setTimeout(() => process.stdout.write("after-cap"), 200)',
+            '}, 200)',
+            'setTimeout(() => {}, 1_000)',
+        ].join('; ');
+        const run = createValveOperations('test-node', contextDir).exec(`${process.execPath} -e ${JSON.stringify(writer)}`, root, { onData: () => { } });
+        const jobId = await backgroundOneJob(contextDir);
+        await run;
+        const { jobExit, jobLog } = bashJobPaths(contextDir, jobId);
+        await waitFor(() => existsSync(jobLog) && readFileSync(jobLog, 'utf8').includes(BACKGROUND_BASH_LOG_TRUNCATION_MARKER), 'log did not record truncation');
+        const sizeAtCap = statSync(jobLog).size;
+        assert.ok(sizeAtCap <= MAX_BACKGROUND_BASH_LOG_BYTES);
+        await sleep(500);
+        assert.equal(statSync(jobLog).size, sizeAtCap, 'discarded output continued growing the log');
+        await waitFor(() => existsSync(jobExit), 'writer did not finish');
+        assert.equal(readFileSync(jobExit, 'utf8').trim(), '0', 'collector changed the writer exit status');
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});

package/dist/pi-extensions/canvas-bash-valve.d.ts

@@ -1,5 +1,7 @@
 import { createBashToolDefinition, type BashOperations } from '@earendil-works/pi-coding-agent';
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+export declare const MAX_BACKGROUND_BASH_LOG_BYTES: number;
+export declare const BACKGROUND_BASH_LOG_TRUNCATION_MARKER = "\n[background bash job output truncated at 10 MiB; remaining output discarded]\n";
 /** The valve's BashOperations backend. Each tool execution closes over its own
  * `takePurpose` and its own preview-result path, so concurrent calls cannot
  * exchange labels or result mirrors. The purpose is consumed even when the

package/dist/pi-extensions/canvas-bash-valve.js

@@ -18,8 +18,9 @@
 // SIGPIPE, and its exit code is observable by nobody. So every command is
 // file-backed from birth via a tiny detached supervisor (a `bash -c` process
 // group leader) that redirects the real command's stdout+stderr to a log
-// file and records its exit code to a sentinel file — both readable, and
-// tail-able, independent of whether this pi process is even still alive.
+// file through a bounded collector and records its exit code to a sentinel
+// file — both readable and tail-able, independent of whether this pi process
+// is even still alive.
 //
 // Deviation from upstream: this backend pins `bash` as the shell (upstream
 // consults user shell config via non-exported helpers). Acceptable — crtr's
@@ -30,8 +31,9 @@ import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, rmS
 import { homedir } from 'node:os';
 import { dirname } from 'node:path';
 import { performance } from 'node:perf_hooks';
-import { backgroundBashJob, bashJobPaths, formatBashElapsed, newBashJobId, normalizeBashJobPurpose, readBashNiceness, writeJobDeadlineMs } from '../core/bash-jobs.js';
+import { backgroundBashJob, bashJobPaths, cancelBashJobProcessTree, formatBashElapsed, newBashJobId, normalizeBashJobPurpose, readBashNiceness, writeJobDeadlineMs } from '../core/bash-jobs.js';
 import { bashCommandRefusal } from '../core/bash-guard.js';
+import { capturePidIdentities } from '../core/canvas/pid.js';
 import { readConfig } from '../core/config.js';
 import { PREVIEW_RESULT_PATH_ENV, previewResultPath } from '../core/preview-result-path.js';
 import { resolveAdmittedHostCommand } from '../core/runtime/spawn-env.js';
@@ -43,18 +45,44 @@ const POLL_MS = 200;
 function resolveValveMs() {
     return envBashValveMs();
 }
-// The detached supervisor. Spawned with `detached: true` so it becomes its
-// own process-group leader (pgid === its pid) — killing `-pgid` reaches the
-// real command and anything it forked, even after this pi process exits.
-//
-// Positional argv (never interpolated into the script — the command text
-// lives only in cmd.sh):
+export const MAX_BACKGROUND_BASH_LOG_BYTES = 10 * 1024 * 1024;
+export const BACKGROUND_BASH_LOG_TRUNCATION_MARKER = '\n[background bash job output truncated at 10 MiB; remaining output discarded]\n';
+// This process owns one bounded prefix of the command stream. It keeps
+// draining after the cap so the command never sees a closed pipe/SIGPIPE, and
+// uses synchronous fixed-size stdin chunks plus direct file writes so neither
+// the collector nor the log can grow without bound.
+const LOG_COLLECTOR_SCRIPT = [
+    'const fs = require("node:fs");',
+    `const cap = ${MAX_BACKGROUND_BASH_LOG_BYTES};`,
+    `const marker = Buffer.from(${JSON.stringify(BACKGROUND_BASH_LOG_TRUNCATION_MARKER)});`,
+    'const prefixCap = cap - marker.length;',
+    'const fd = fs.openSync(process.argv[1], "w");',
+    'let written = 0;',
+    'let truncated = false;',
+    'process.stdin.on("data", (chunk) => {',
+    '  if (truncated) return;',
+    '  const available = prefixCap - written;',
+    '  if (available > 0) {',
+    '    const prefix = chunk.subarray(0, available);',
+    '    fs.writeSync(fd, prefix);',
+    '    written += prefix.length;',
+    '    if (prefix.length === chunk.length) return;',
+    '  }',
+    '  fs.writeSync(fd, marker);',
+    '  truncated = true;',
+    '});',
+    'process.stdin.on("end", () => fs.closeSync(fd));',
+].join(' ');
+// The detached supervisor owns the command and its bounded stream collector.
+// Positional argv (never interpolated into the script — the command text lives
+// only in cmd.sh):
 //   $1 cmd.sh     $2 job.log   $3 job.exit   $4 job.run
 //   $5 job.done   $6 job.bg    $7 jobId      $8 nodeId      $9 shell path
-//   ${10} niceness
+//   ${10} niceness ${11} node path
 //
 // `--` before the paths is a dummy $0 (a standard `bash -c script -- args`
 // idiom) so the real payload lands at $1 onward.
+//
 // The elapsed rendering mirrors formatBashElapsed() in core/bash-jobs.ts
 // (`12s` / `3m 40s` / `1h 04m`) so the completion message reads the same as the
 // handoff notice; it measures TOTAL runtime, foreground portion included.
@@ -64,8 +92,8 @@ function resolveValveMs() {
 const SUPERVISOR_SCRIPT = [
     'SECONDS=0',
     'n=$(command -v nice)',
-    '${n:+"$n" -n "${10}"} "${9}" "$1" > "$2" 2>&1',
-    'ec=$?',
+    '${n:+"$n" -n "${10}"} "${9}" "$1" 2>&1 | "${11}" -e ' + JSON.stringify(LOG_COLLECTOR_SCRIPT) + ' "$2"',
+    'ec=${PIPESTATUS[0]}',
     'd=$SECONDS',
     'echo "$ec" > "$3"',
     'if [ "$d" -lt 60 ]; then',
@@ -107,25 +135,9 @@ function installTerminationHandoff() {
     if (process.platform !== 'win32')
         process.prependListener('SIGHUP', backgroundLiveJobsForTermination);
 }
-function killGroup(pgid) {
-    try {
-        process.kill(-pgid, 'SIGTERM');
-    }
-    catch {
-        /* already gone */
-    }
-    const killer = setTimeout(() => {
-        try {
-            process.kill(-pgid, 'SIGKILL');
-        }
-        catch {
-            /* already gone */
-        }
-    }, 2000);
-    killer.unref?.();
-}
+const TAIL_CHUNK_BYTES = 64 * 1024;
 /** Read bytes appended to `path` since `offset`, feed them to onData, return
- *  the new offset. Best-effort — a not-yet-created log file is not an error. */
+ * the new offset. Best-effort — a not-yet-created log file is not an error. */
 function tailOnce(path, offset, onData) {
     let stat;
     try {
@@ -138,10 +150,16 @@ function tailOnce(path, offset, onData) {
         return offset;
     const fd = openSync(path, 'r');
     try {
-        const buf = Buffer.alloc(stat.size - offset);
-        readSync(fd, buf, 0, buf.length, offset);
-        onData(buf);
-        return stat.size;
+        while (offset < stat.size) {
+            const length = Math.min(TAIL_CHUNK_BYTES, stat.size - offset);
+            const buf = Buffer.allocUnsafe(length);
+            const bytesRead = readSync(fd, buf, 0, length, offset);
+            if (bytesRead === 0)
+                break;
+            onData(buf.subarray(0, bytesRead));
+            offset += bytesRead;
+        }
+        return offset;
     }
     finally {
         closeSync(fd);
@@ -211,6 +229,7 @@ export function createValveOperations(nodeId, contextDir, takePurpose = () => nu
                 let offset = 0;
                 let settled = false;
                 let pgid;
+                let pgidIdentity;
                 const startedAt = performance.now();
                 const valveMs = resolveValveMs();
                 let interval;
@@ -245,7 +264,7 @@ export function createValveOperations(nodeId, contextDir, takePurpose = () => nu
                     const notice = `\n[backgrounded as job ${paths.jobId} after ${elapsed} in the foreground${auto ? ' (auto)' : ''}. ` +
                         deadlineNotice +
                         `It will interrupt you with a message when it exits. ` +
-                        `Watch: tail -f ${paths.jobLog} ; stop: kill -- -${pgid}]`;
+                        `Watch: tail -f ${paths.jobLog} ; stop: crtr node bash kill ${paths.jobId}]`;
                     onData(Buffer.from(notice));
                     finish(() => resolve({ exitCode: 0 }));
                     // Backgrounded — job dir persists (inspectable); no cleanup here.
@@ -279,8 +298,8 @@ export function createValveOperations(nodeId, contextDir, takePurpose = () => nu
                     // finish the job.run → job.done transition before cleanup.
                     if (existsSync(paths.jobExit))
                         return;
-                    if (pgid)
-                        killGroup(pgid);
+                    if (pgid !== undefined && pgidIdentity !== undefined)
+                        void cancelBashJobProcessTree(pgid, pgidIdentity);
                     finish(() => reject(new Error('aborted')));
                     cleanupJobDir(paths.dir);
                 }
@@ -302,7 +321,7 @@ export function createValveOperations(nodeId, contextDir, takePurpose = () => nu
                     childEnv = { ...childEnv, [PREVIEW_RESULT_PATH_ENV]: previewPath };
                 }
                 const shellPath = resolveAdmittedHostCommand('bash', childEnv, execution.cwd);
-                const child = spawn(shellPath, ['-c', SUPERVISOR_SCRIPT, '--', paths.cmdSh, paths.jobLog, paths.jobExit, paths.jobRun, paths.jobDone, paths.jobBg, paths.jobId, nodeId, shellPath, String(readBashNiceness(contextDir))], {
+                const child = spawn(shellPath, ['-c', SUPERVISOR_SCRIPT, '--', paths.cmdSh, paths.jobLog, paths.jobExit, paths.jobRun, paths.jobDone, paths.jobBg, paths.jobId, nodeId, shellPath, String(readBashNiceness(contextDir)), process.execPath], {
                     cwd: execution.cwd,
                     detached: true,
                     stdio: 'ignore',
@@ -313,11 +332,22 @@ export function createValveOperations(nodeId, contextDir, takePurpose = () => nu
                     cleanupJobDir(paths.dir);
                 });
                 pgid = child.pid;
-                // The detached supervisor IS the group leader, so its pid is the pgid.
-                // Persisting it is what lets a human stop the job from the Inspector
-                // later; the agent's own handoff notice quotes the same number.
+                // The detached supervisor starts this process tree. Its launch-time
+                // identity lets cancellation reject a stale PID that now belongs to an
+                // unrelated process; it is not a containment guarantee.
                 if (pgid !== undefined) {
+                    pgidIdentity = capturePidIdentities([pgid])?.get(pgid);
+                    if (pgidIdentity === undefined) {
+                        try {
+                            process.kill(-pgid, 'SIGKILL');
+                        }
+                        catch { /* the just-started supervisor already exited */ }
+                        finish(() => reject(new Error(`bash job ${paths.jobId} started without a process identity`)));
+                        cleanupJobDir(paths.dir);
+                        return;
+                    }
                     writeFileSync(paths.jobPgid, String(pgid));
+                    writeFileSync(paths.jobPgidIdentity, pgidIdentity);
                     liveForegroundJobs.add(paths);
                 }
                 child.unref();
@@ -338,8 +368,8 @@ export function createValveOperations(nodeId, contextDir, takePurpose = () => nu
                     const elapsedMs = performance.now() - startedAt;
                     if (timeout !== undefined && timeout > 0) {
                         if (elapsedMs >= timeout * 1000) {
-                            if (pgid)
-                                killGroup(pgid);
+                            if (pgid !== undefined && pgidIdentity !== undefined)
+                                void cancelBashJobProcessTree(pgid, pgidIdentity);
                             finish(() => reject(new Error(`timeout:${timeout}`)));
                             cleanupJobDir(paths.dir);
                         }

package/dist/pi-extensions/canvas-inbox-watcher.js

@@ -344,8 +344,6 @@ class CanvasInboxWatcher {
      *  reports would render as bare refs instead of inlined bodies. One refresh
      *  per unknown node id keeps a genuinely missing node from stalling delivery. */
     refreshForUnknownReportRefs() {
-        if (this.reportNodesRefreshing)
-            return true;
         const unknown = [];
         for (const entry of this.buffer) {
             const refNodeId = reportRefNodeId(entry.ref);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.303",
+  "version": "0.3.305",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",

package/runtime.lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.303",
+  "version": "0.3.305",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.303",
+      "version": "0.3.305",
       "hasInstallScript": true,
       "license": "MIT",
       "workspaces": [
@@ -5206,17 +5206,17 @@
     },
     "packages/crouter-api": {
       "name": "@north-light/crouter-api",
-      "version": "0.3.303",
+      "version": "0.3.305",
       "license": "UNLICENSED"
     },
     "packages/crouter-env-docker": {
       "name": "@north-light/crouter-env-docker",
-      "version": "0.3.303",
+      "version": "0.3.305",
       "license": "UNLICENSED"
     },
     "packages/crouter-sdk": {
       "name": "@north-light/crouter-sdk",
-      "version": "0.3.303",
+      "version": "0.3.305",
       "license": "UNLICENSED",
       "dependencies": {
         "@north-light/crouter-api": "^0.3.295"