@north-light/crouter 0.3.198 → 0.3.199

package/dist/daemon/profile-delete.js

@@ -0,0 +1,306 @@
+import { existsSync, readFileSync, readdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { cronIdsForProfileDeletion, cronIdsForProfileDetach, deleteCronsForProfile, deleteNodes, getNode, getRow, globalizeCronsForProfile, listNodesByProfile, nodesRoot, reviewDir, } from '../core/canvas/index.js';
+import { usage } from '../core/errors.js';
+import { emitEvent } from '../core/events/emit.js';
+import { clearDefaultProfileId, defaultProfileDirs, } from '../core/profiles/default-binding.js';
+import { reserveProfileDeletion } from '../core/profiles/deletion-reservation.js';
+import { deleteProfile, loadProfileManifest, } from '../core/profiles/manifest.js';
+import { deleteReviewsByOriginNodes, reviewIdsByOriginNodes, } from '../core/review/store.js';
+import { boundFleet } from '../core/runtime/fleet.js';
+import { headlessBrokerHost } from '../core/runtime/host.js';
+import { transition } from '../core/runtime/lifecycle.js';
+import { tearDownNode } from '../core/runtime/placement.js';
+import { reshapeNode } from '../core/runtime/promote.js';
+import { reviveNode } from '../core/runtime/revive.js';
+const SELF_DELETE_GRACE_MS = 1_000;
+const TICKET_FILES = new Set([
+    'page.json',
+    'page.tsx',
+    'page.html',
+    'page.js',
+    'review.json',
+    'response.json',
+    'progress.json',
+    'claim.json',
+    'reply-route.json',
+    'feedback-comments.json',
+    'feedback.json',
+    '.ticket-lock',
+]);
+const pending = new Map();
+function requestObject(body) {
+    if (typeof body !== 'object' || body === null || Array.isArray(body)) {
+        throw usage('profile deletion requires a JSON request body', {
+            error: 'force_required',
+            message: 'profile deletion requires --force',
+            next: 'Re-run `crtr profile delete <profile> --force` after reviewing its effects.',
+        });
+    }
+    return body;
+}
+function validateRequest(body) {
+    const value = requestObject(body);
+    if (value['force'] !== true) {
+        throw usage('profile deletion requires --force', {
+            error: 'force_required',
+            message: 'profile deletion requires --force',
+            next: 'Re-run `crtr profile delete <profile> --force` after reviewing its effects.',
+        });
+    }
+    if (value['detach'] !== undefined && typeof value['detach'] !== 'boolean') {
+        throw usage('detach must be a boolean', {
+            error: 'invalid_detach',
+            message: 'detach must be a boolean',
+            next: 'Use --detach as a presence-only flag, or omit it.',
+        });
+    }
+    const caller = value['caller_node_id'];
+    if (caller !== undefined && caller !== null && (typeof caller !== 'string' || caller === '')) {
+        throw usage('caller_node_id must be a nonempty string or null');
+    }
+    return {
+        force: true,
+        ...(value['detach'] === true ? { detach: true } : {}),
+        ...(caller === undefined ? {} : { caller_node_id: caller }),
+    };
+}
+function manifestSourceNodeId(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        return typeof parsed.source?.nodeId === 'string' && parsed.source.nodeId !== ''
+            ? parsed.source.nodeId
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function ticketCleanupForNodes(nodeIds) {
+    const wanted = new Set(nodeIds);
+    const root = nodesRoot();
+    if (wanted.size === 0 || !existsSync(root))
+        return [];
+    const cleanup = [];
+    for (const dirent of readdirSync(root, { withFileTypes: true })) {
+        if (!dirent.isDirectory())
+            continue;
+        const dir = join(root, dirent.name);
+        const sourceIds = [
+            manifestSourceNodeId(join(dir, 'page.json')),
+            manifestSourceNodeId(join(dir, 'review.json')),
+        ];
+        if (!sourceIds.some((sourceId) => sourceId !== null && wanted.has(sourceId)))
+            continue;
+        cleanup.push({
+            dir,
+            wholeDirectory: wanted.has(dirent.name) || getRow(dirent.name) === null,
+        });
+    }
+    return cleanup.sort((a, b) => a.dir.localeCompare(b.dir));
+}
+function isTicketOwnedResidue(name) {
+    if (TICKET_FILES.has(name))
+        return true;
+    for (const base of TICKET_FILES) {
+        if (name.startsWith(`${base}.`) && (name.endsWith('.tmp') || name.endsWith('.lock'))) {
+            return true;
+        }
+    }
+    return false;
+}
+function cleanTickets(tickets) {
+    let cleaned = 0;
+    for (const ticket of tickets) {
+        if (!existsSync(ticket.dir))
+            continue;
+        if (ticket.wholeDirectory) {
+            rmSync(ticket.dir, { recursive: true, force: true });
+            cleaned += 1;
+            continue;
+        }
+        for (const dirent of readdirSync(ticket.dir, { withFileTypes: true })) {
+            if (!isTicketOwnedResidue(dirent.name))
+                continue;
+            rmSync(join(ticket.dir, dirent.name), { recursive: true, force: true });
+        }
+        cleaned += 1;
+    }
+    return cleaned;
+}
+function openWorktreeError(nodes) {
+    const blocked = nodes
+        .filter((node) => node.managed_worktree?.state === 'open')
+        .map((node) => ({ node_id: node.node_id, path: node.managed_worktree.path }));
+    if (blocked.length === 0)
+        return null;
+    const message = `profile deletion is blocked by ${blocked.length} open managed worktree${blocked.length === 1 ? '' : 's'}`;
+    return usage(message, {
+        error: 'open_managed_worktree',
+        message,
+        nodes: blocked,
+        next: `Close ${blocked.map(({ node_id }) => node_id).join(', ')} with \`crtr node worktree close <node>\`, then retry.`,
+    });
+}
+function prepareDeletion(entry, request) {
+    const nodes = listNodesByProfile(entry.profileId);
+    const blocked = openWorktreeError(nodes);
+    if (blocked !== null)
+        throw blocked;
+    const nodeIds = nodes.map(({ node_id }) => node_id);
+    const mode = request.detach === true ? 'detached' : 'deleted';
+    return {
+        entry,
+        mode,
+        nodes,
+        nodeIds,
+        tickets: mode === 'deleted' ? ticketCleanupForNodes(nodeIds) : [],
+        cronIds: mode === 'deleted'
+            ? cronIdsForProfileDeletion(entry.profileId, nodeIds)
+            : cronIdsForProfileDetach(entry.profileId),
+        reviewIds: mode === 'deleted' ? reviewIdsByOriginNodes(nodeIds) : [],
+        defaultDirs: defaultProfileDirs(entry.profileId),
+    };
+}
+function assertDeletionPlanPreconditions(plan) {
+    const currentNodes = plan.nodeIds.flatMap((nodeId) => {
+        const node = getNode(nodeId);
+        return node === null ? [] : [node];
+    });
+    const blocked = openWorktreeError(currentNodes);
+    if (blocked !== null)
+        throw blocked;
+}
+function resultForPlan(plan) {
+    return {
+        profile_id: plan.entry.profileId,
+        name: plan.entry.manifest.name,
+        mode: plan.mode,
+        nodes: plan.nodeIds.length,
+        crons: plan.cronIds.length,
+        tickets: plan.tickets.length,
+        reviews: plan.reviewIds.length,
+        default_pins: plan.defaultDirs.length,
+    };
+}
+async function detachProfile(plan) {
+    assertDeletionPlanPreconditions(plan);
+    const existingNodeIds = plan.nodeIds.filter((nodeId) => getNode(nodeId) !== null);
+    const fleet = boundFleet();
+    const live = existingNodeIds.flatMap((nodeId) => {
+        const entry = fleet.get(nodeId);
+        return entry === undefined ? [] : [{ nodeId, exited: entry.handle.exited }];
+    });
+    const restartNodeIds = [];
+    for (const { nodeId } of live) {
+        const current = getNode(nodeId);
+        if (current?.status === 'active' || current?.status === 'idle') {
+            transition(nodeId, 'release');
+            restartNodeIds.push(nodeId);
+        }
+        headlessBrokerHost.teardown(nodeId);
+    }
+    await Promise.all(live.map(({ exited }) => exited));
+    const detachedNodeIds = [];
+    for (const nodeId of existingNodeIds) {
+        if (getNode(nodeId) === null)
+            continue;
+        reshapeNode(nodeId, { profileId: null });
+        detachedNodeIds.push(nodeId);
+    }
+    const cronIds = globalizeCronsForProfile(plan.entry.profileId);
+    const defaultDirs = clearDefaultProfileId(plan.entry.profileId);
+    deleteProfile(plan.entry.profileId);
+    const detached = new Set(detachedNodeIds);
+    for (const nodeId of restartNodeIds) {
+        if (detached.has(nodeId))
+            reviveNode(nodeId, { resume: true, recovery: true });
+    }
+    return {
+        ...resultForPlan(plan),
+        nodes: detachedNodeIds.length,
+        crons: cronIds.length,
+        default_pins: defaultDirs.length,
+    };
+}
+function hardDeleteProfile(plan) {
+    assertDeletionPlanPreconditions(plan);
+    const cronIds = deleteCronsForProfile(plan.entry.profileId, plan.nodeIds);
+    for (const nodeId of plan.nodeIds) {
+        headlessBrokerHost.teardown(nodeId);
+        tearDownNode(nodeId);
+    }
+    const reviewIds = deleteReviewsByOriginNodes(plan.nodeIds);
+    for (const reviewId of reviewIds)
+        rmSync(reviewDir(reviewId), { recursive: true, force: true });
+    const tickets = cleanTickets(plan.tickets);
+    const deletedNodeIds = deleteNodes(plan.nodeIds);
+    const defaultDirs = clearDefaultProfileId(plan.entry.profileId);
+    deleteProfile(plan.entry.profileId);
+    return {
+        ...resultForPlan(plan),
+        nodes: deletedNodeIds.length,
+        crons: cronIds.length,
+        tickets,
+        reviews: reviewIds.length,
+        default_pins: defaultDirs.length,
+    };
+}
+async function executePlan(plan) {
+    return plan.mode === 'detached' ? detachProfile(plan) : hardDeleteProfile(plan);
+}
+function scheduleSelfDeletion(plan, releaseReservation) {
+    const result = {
+        ...resultForPlan(plan),
+        accepted: true,
+        grace_ms: SELF_DELETE_GRACE_MS,
+    };
+    pending.set(plan.entry.profileId, { result });
+    setTimeout(() => {
+        void (async () => {
+            try {
+                await executePlan(plan);
+            }
+            catch (error) {
+                emitEvent({
+                    level: 'error',
+                    event: 'profile.delete.deferred_failed',
+                    error: error instanceof Error ? error : new Error(String(error)),
+                    fields: { profile_id: plan.entry.profileId, mode: plan.mode },
+                });
+            }
+            finally {
+                pending.delete(plan.entry.profileId);
+                releaseReservation();
+            }
+        })();
+    }, SELF_DELETE_GRACE_MS);
+    return result;
+}
+/** Validate and enact one forced profile deletion. A request from a node that
+ *  belongs to the target profile is acknowledged before its broker is stopped. */
+export async function requestProfileDeletion(name, body) {
+    const request = validateRequest(body);
+    const entry = loadProfileManifest(name);
+    const existing = pending.get(entry.profileId);
+    if (existing !== undefined)
+        return { status: 202, body: existing.result };
+    const releaseReservation = reserveProfileDeletion(entry.profileId);
+    let deferred = false;
+    try {
+        const plan = prepareDeletion(entry, request);
+        const selfDeleting = request.caller_node_id != null && plan.nodeIds.includes(request.caller_node_id);
+        if (selfDeleting) {
+            const result = scheduleSelfDeletion(plan, releaseReservation);
+            deferred = true;
+            return { status: 202, body: result };
+        }
+        return { status: 200, body: await executePlan(plan) };
+    }
+    finally {
+        if (!deferred)
+            releaseReservation();
+    }
+}

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

@@ -20,6 +20,7 @@ import { operationIdContext } from '../../core/events/operation-id.js';
 import { readCursor, readInboxSince } from '../../core/feed/inbox.js';
 import { activeBackgroundBashJobs } from '../../core/bash-jobs.js';
 import { focusOf } from '../../core/runtime/placement.js';
+import { hasAttachedBrokerViewers } from '../../core/runtime/broker/client-registry.js';
 import { parkEvent } from './live-obligation.js';
 const execFileAsync = promisify(execFile);
 function configuredPositiveInteger(name, fallback) {
@@ -191,7 +192,8 @@ export class BrokerSupervisionReconciler {
             || row.intent !== null
             || isBusy(id)
             || activeBackgroundBashJobs(contextDir(id)).length > 0
-            || focusOf(id) !== null) {
+            || focusOf(id) !== null
+            || hasAttachedBrokerViewers(id)) {
             this.unattendedSince.delete(id);
             return;
         }

package/dist/daemon/review/deliver.js

@@ -3,8 +3,8 @@ import { formatReviewApproval } from '../../shared/generated-context.js';
 import { deliverNodeMessage } from '../messaging/node-message.js';
 function approvalBody(review, resultPath) {
     const summary = review.changed
-        ? `The human reviewed and approved \`${review.file}\`. The document changed during review; re-read it before continuing. Review conversation: node \`${review.companion_node_id}\`.`
-        : `The human reviewed and approved \`${review.file}\`. The document was not modified.`;
+        ? `The user reviewed and approved \`${review.file}\`. The document changed during review; re-read it before continuing. Review conversation: node \`${review.companion_node_id}\`.`
+        : `The user reviewed and approved \`${review.file}\`. The document was not modified.`;
     return `${summary}\n\nDurable review result: ${resultPath}`;
 }
 /** Render the immutable approval fact without replaying comment text. */
@@ -25,7 +25,7 @@ export async function deliverApproval(review, resultPath) {
         const delivery = await deliverNodeMessage({
             node_id: review.origin_node_id,
             body,
-            label: 'human review approved',
+            label: 'review approved by the user',
             from: 'crtrd',
             mode: 'interactive',
             data: { review_id: review.review_id, result_path: resultPath },

package/dist/daemon/review/finish.d.ts

@@ -18,8 +18,6 @@ export interface ReviewCancellationFinishOutcome {
     ticket_result?: TicketResult;
 }
 export type ReviewFinishOutcome = ReviewApprovalFinishOutcome | ReviewCancellationFinishOutcome;
-/** Retire a companion only through a lifecycle transition legal for its current status. */
-export declare function retireCompanion(nodeId: string, outcome: 'approved' | 'canceled'): 'retired' | 'already' | 'missing';
 /** Approve on the human's behalf, waiting first when the companion is still
  *  working. Waiting is the only new outcome: an idle companion approves in the
  *  same pass it always did, and the wait never freezes the review — comments

package/dist/daemon/review/finish.js

@@ -1,5 +1,4 @@
 import { withCanvasWrite } from '../../core/canvas/db.js';
-import { getNode } from '../../core/canvas/canvas.js';
 import { responsePath } from '../../core/human/convention.js';
 import { ticketDir } from '../../core/human/root.js';
 import { readTicketResult } from '../../core/human/tickets.js';
@@ -10,9 +9,8 @@ import { readReviewSource } from '../../core/review/document.js';
 import { signalReviewActivity } from '../../core/review/signal.js';
 import { approveReviewLocked, cancelReviewRow, getReview, getReviewByCompanion, markDelivered, markDeliveryError, markProjected, markProjectionError, requestReviewSubmit, requireVisibleReview, } from '../../core/review/store.js';
 import { ReviewOperationError } from '../../core/review/types.js';
-import { transition } from '../../core/runtime/lifecycle.js';
-import { headlessBrokerHost } from '../../core/runtime/host.js';
 import { emitEvent } from '../../core/events/emit.js';
+import { retireCompanion } from '../companion-retire.js';
 import { deliverNodeMessage } from '../messaging/node-message.js';
 import { cancelHumanTicket, deliverTerminalResult } from '../human/finish.js';
 import { companionHasQueuedWork, companionMidTurn, companionStillWorking } from './companion.js';
@@ -69,32 +67,6 @@ async function serializedFinish(reviewId, work) {
             finishChains.delete(reviewId);
     }
 }
-/** Retire a companion only through a lifecycle transition legal for its current status. */
-export function retireCompanion(nodeId, outcome) {
-    const node = getNode(nodeId);
-    if (node === null)
-        return 'missing';
-    if (node.status === 'done' || node.status === 'canceled')
-        return 'already';
-    if (outcome === 'approved' && (node.status === 'active' || node.status === 'idle')) {
-        transition(nodeId, 'finish');
-        try {
-            headlessBrokerHost.teardown(nodeId);
-        }
-        catch { /* the terminal transition is authoritative */ }
-        return 'retired';
-    }
-    // Cancellation is legal from every status. An already-dead companion cannot
-    // be finished, so it is retired as canceled even when approval won.
-    transition(nodeId, 'cancel');
-    if (node.status === 'active' || node.status === 'idle') {
-        try {
-            headlessBrokerHost.teardown(nodeId);
-        }
-        catch { /* the terminal transition is authoritative */ }
-    }
-    return 'retired';
-}
 async function finishApproved(review, result) {
     let current = requireVisibleReview(review.review_id);
     if (current.projected_at === null) {

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

@@ -4,7 +4,7 @@
 // still spawned commands with that deleted directory as cwd. child_process
 // then failed before bash could run, leaving the node unable to use its shell.
 import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync } from 'node:fs';
+import { chmodSync, existsSync, mkdtempSync, mkdirSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
 import { homedir, tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { test } from 'node:test';
@@ -29,3 +29,58 @@ test('bash falls back to home after its worktree cwd was removed', { timeout: 5_
         rmSync(root, { recursive: true, force: true });
     }
 });
+test('bash valve resolves an admitted relative PATH entry from the execution cwd', { timeout: 5_000 }, async () => {
+    const root = mkdtempSync(join(tmpdir(), 'crtr-bash-valve-relative-host-path-'));
+    const contextDir = join(root, 'context');
+    const hostBin = join(root, 'host-bin');
+    const shim = join(root, 'shim');
+    const marker = join(root, 'contributed-bash-ran');
+    mkdirSync(contextDir);
+    mkdirSync(hostBin);
+    mkdirSync(shim);
+    symlinkSync('/bin/bash', join(hostBin, 'bash'));
+    writeFileSync(join(shim, 'bash'), `#!/bin/sh\nprintf contributed > ${JSON.stringify(marker)}\nexit 97\n`);
+    writeFileSync(join(shim, 'tool'), '#!/bin/sh\nprintf tool\n');
+    chmodSync(join(shim, 'bash'), 0o755);
+    chmodSync(join(shim, 'tool'), 0o755);
+    try {
+        const output = [];
+        const result = await createValveOperations('test-node', contextDir).exec('tool; command -v tool', root, {
+            env: { PATH: `${shim}:host-bin:/bin:/usr/bin`, CRTR_ADMITTED_HOST_PATH: 'host-bin:/bin:/usr/bin' },
+            onData: (data) => output.push(data),
+        });
+        assert.equal(result.exitCode, 0);
+        assert.equal(Buffer.concat(output).toString(), `tool${shim}/tool\n`);
+        assert.equal(existsSync(marker), false, 'the contributed bash must never be crouter\'s interpreter');
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('bash valve uses the admitted host shell while commands keep shim precedence', { timeout: 5_000 }, async () => {
+    const root = mkdtempSync(join(tmpdir(), 'crtr-bash-valve-shim-'));
+    const contextDir = join(root, 'context');
+    const shim = join(root, 'shim');
+    const marker = join(root, 'contributed-bash-ran');
+    mkdirSync(contextDir);
+    mkdirSync(shim);
+    writeFileSync(join(shim, 'bash'), `#!/bin/sh\nprintf contributed > ${JSON.stringify(marker)}\nexit 97\n`);
+    writeFileSync(join(shim, 'tool'), '#!/bin/sh\nprintf tool\n');
+    chmodSync(join(shim, 'bash'), 0o755);
+    chmodSync(join(shim, 'tool'), 0o755);
+    try {
+        const output = [];
+        const hostPath = process.env['PATH'];
+        assert.notEqual(hostPath, undefined);
+        const result = await createValveOperations('test-node', contextDir).exec('tool; command -v tool', root, {
+            env: { PATH: `${shim}:${hostPath}`, CRTR_ADMITTED_HOST_PATH: hostPath },
+            onData: (data) => output.push(data),
+        });
+        assert.equal(result.exitCode, 0);
+        assert.equal(Buffer.concat(output).toString(), `tool${shim}/tool\n`);
+        assert.equal(existsSync(marker), false, 'the contributed bash must never be crouter\'s interpreter');
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});

package/dist/pi-extensions/__tests__/canvas-stophook-agentend.test.js

@@ -363,8 +363,8 @@ test('turn_end still clears a daemon→node wedge fault (existing behavior, unch
     pi.fire('turn_end', turnEndEvent('turn completed'), {});
     assert.equal(readFault('leaf'), null, 'the daemon→node wedge fault is still cleared at turn_end');
 });
-test('a successful final or human ask suppresses the stop reprompt without a canvas read', async () => {
-    for (const [signal, shutsDown] of [['pushedFinal', true], ['askedHuman', false]]) {
+test('a successful final or requested human reply suppresses the stop reprompt without a canvas read', async () => {
+    for (const [signal, shutsDown] of [['pushedFinal', true], ['requestedHumanReply', false]]) {
         process.env['CRTR_NODE_ID'] = 'signal-only';
         markStopSignal('signal-only', signal);
         const pi = makeFakePi();
@@ -389,12 +389,12 @@ test('an in-run retry (agent_start with no new input) does not erase this run\'s
     const ctx = { shutdown: () => { } };
     pi.fire('input', { type: 'input' }, ctx);
     pi.fire('agent_start', { type: 'agent_start' }, ctx);
-    markStopSignal('leaf', 'askedHuman'); // the node ran `crtr human ask` mid-run
+    markStopSignal('leaf', 'requestedHumanReply'); // the node ran `crtr human send` mid-run
     pi.fire('agent_start', { type: 'agent_start' }, ctx); // pi auto-retried after a provider error
     await settle(pi, stopEvent('waiting on the human now'), ctx);
     assert.equal(pi.injected.length, 0, 'the ask survives the in-run retry — no stall reprompt');
     // ...and the NEXT user-directed run does start clean.
-    markStopSignal('leaf', 'askedHuman');
+    markStopSignal('leaf', 'requestedHumanReply');
     pi.fire('input', { type: 'input' }, ctx);
     await settle(pi, stopEvent('I think I am basically done here'), ctx);
     assert.equal(pi.injected.length, 1, 'a new input discards a leftover marker from a prior run');

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

@@ -29,6 +29,7 @@ import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, rmS
 import { homedir } from 'node:os';
 import { backgroundBashJob, bashJobPaths, formatBashElapsed, newBashJobId, normalizeBashJobPurpose } from '../core/bash-jobs.js';
 import { readConfig } from '../core/config.js';
+import { resolveAdmittedHostCommand } from '../core/runtime/spawn-env.js';
 import { Type } from 'typebox';
 import { createBashToolDefinition } from '@earendil-works/pi-coding-agent';
 // ---------------------------------------------------------------------------
@@ -52,19 +53,31 @@ function resolveValveMs() {
 // 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
+//   $5 job.done   $6 job.bg    $7 jobId      $8 nodeId      $9 shell 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.
 const SUPERVISOR_SCRIPT = [
-    'bash "$1" > "$2" 2>&1',
+    'SECONDS=0',
+    '"${9}" "$1" > "$2" 2>&1',
     'ec=$?',
+    'd=$SECONDS',
     'echo "$ec" > "$3"',
+    'if [ "$d" -lt 60 ]; then',
+    '  el="${d}s"',
+    'elif [ "$d" -lt 3600 ]; then',
+    '  el="$((d / 60))m $(printf "%02d" "$((d % 60))")s"',
+    'else',
+    '  el="$((d / 3600))h $(printf "%02d" "$((d / 60 % 60))")m"',
+    'fi',
     'if mv "$4" "$5" 2>/dev/null; then',
     '  :',
     'elif [ -f "$6" ]; then',
-    '  crtr node message send "Background bash job $7 finished (exit $ec). Log: $2  Command: $1" --to "$8" --tier urgent || true',
+    '  crtr node message send "Background bash job $7 finished (exit $ec) after $el. Log: $2  Command: $1" --to "$8" --tier urgent || true',
     'fi',
 ].join('\n');
 function makeJobPaths(contextDir) {
@@ -183,7 +196,7 @@ function longSleepRefusal(command) {
         `Holding a live window on a clock is never how you wait here. Instead:\n` +
         `  - schedule the wake and end your turn: crtr cron -h (one-shot at a time, or recurring)\n` +
         `  - race an inbox message against a deadline: crtr node wait deadline -h\n` +
-        `  - waiting on a child, a human ask, or any spine event: just stop — the runtime wakes you.\n` +
+        `  - waiting on a child, a reply from the user, or any spine event: just stop — the runtime wakes you.\n` +
         `If you truly need a short pause inline, sleep ${MAX_INLINE_SLEEP_SECONDS}s or less.`);
 }
 /** A node can legitimately remove its own merged worktree. Never recreate that
@@ -296,7 +309,8 @@ export function createValveOperations(nodeId, contextDir, takePurpose = () => nu
                 const execution = resolveExecutionCwd(cwd);
                 if (execution.warning)
                     onData(Buffer.from(execution.warning));
-                const child = spawn('bash', ['-c', SUPERVISOR_SCRIPT, '--', paths.cmdSh, paths.jobLog, paths.jobExit, paths.jobRun, paths.jobDone, paths.jobBg, paths.jobId, nodeId], {
+                const shellPath = resolveAdmittedHostCommand('bash', env ?? process.env, 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], {
                     cwd: execution.cwd,
                     detached: true,
                     stdio: 'ignore',

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

@@ -306,7 +306,7 @@ class CanvasInboxWatcher {
     }
     /** True when delivery must wait a tick for a report-node projection refresh.
      *  The projection captured at session_start omits every node created since —
-     *  each `crtr human ask` bridge and each child this node spawns — so their
+     *  each reply-bearing `crtr human send` bridge and each child this node spawns — so their
      *  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() {

package/dist/pi-extensions/canvas-review-boundary.d.ts

@@ -19,6 +19,10 @@ interface CustomMessageLike {
         reviewId: string;
         originNodeId: string;
         targetFile: string;
+        /** Which binding flavor authored this marker — lets a display surface
+         * (e.g. Northlight's native boundary) pick its copy without parsing the
+         * agent-facing prose. Absent on markers written before this field. */
+        kind: 'review' | 'page_feedback';
     };
 }
 interface RenderedMessageLike {

package/dist/pi-extensions/canvas-review-boundary.js

@@ -55,19 +55,28 @@ export function registerCanvasReviewBoundary(pi) {
         const alreadyMarked = scan.some((entry) => isReviewBoundary(entry, node.review_binding?.review_id));
         if (alreadyMarked)
             return;
-        const { review_id: reviewId, origin_node_id: originNodeId, target_file: targetFile, } = node.review_binding;
-        const content = [
-            `Reviewed file: ${targetFile}`,
-            `Review ID: ${reviewId}`,
-            `Origin node: ${originNodeId}`,
-            '',
-            "The person's visible transcript starts here. Everything above this marker is inherited context they have not seen.",
-        ].join('\n');
+        const binding = node.review_binding;
+        const { review_id: reviewId, origin_node_id: originNodeId, target_file: targetFile } = binding;
+        const content = binding.kind === 'page_feedback'
+            ? [
+                `This conversation began from feedback on page ${reviewId}.`,
+                `Page source: ${targetFile}`,
+                `Origin node: ${originNodeId}`,
+                '',
+                "The person's visible transcript starts here. Everything above this marker is the origin node's work — inherited context they have not seen.",
+            ].join('\n')
+            : [
+                `Reviewed file: ${targetFile}`,
+                `Review ID: ${reviewId}`,
+                `Origin node: ${originNodeId}`,
+                '',
+                "The person's visible transcript starts here. Everything above this marker is inherited context they have not seen.",
+            ].join('\n');
         pi.sendMessage({
             customType: REVIEW_BOUNDARY_CUSTOM_TYPE,
             content,
             display: true,
-            details: { reviewId, originNodeId, targetFile },
+            details: { reviewId, originNodeId, targetFile, kind: binding.kind ?? 'review' },
         });
     });
 }

package/dist/pi-extensions/canvas-stophook.js

@@ -407,7 +407,7 @@ export function registerCanvasStophook(pi) {
     // input — a new user-directed run is beginning. This is the ONLY place stop
     // signals are cleared: `agent_start` re-fires for pi's automatic retries and
     // post-compaction continuations within the SAME run, so clearing there would
-    // erase the `crtr human ask` / `crtr push final` marker written earlier in the
+    // erase the `crtr human send` / `crtr push final` marker written earlier in the
     // run and make the eventual settlement fall back to a canvas read (exactly the
     // read the marker exists to avoid). One run's markers survive until the one
     // `agent_settled` consumes them; a leftover from an errored or interrupted run
@@ -508,7 +508,7 @@ export function registerCanvasStophook(pi) {
                 stopReason: 'quit',
                 backgroundJobsRunning: backgroundJobsRunning(),
                 pushedFinal: false,
-                askedHuman: false,
+                requestedHumanReply: false,
             });
             enactSettleDirective(directive, ctx);
         }
@@ -637,14 +637,14 @@ export function registerCanvasStophook(pi) {
         const last = lastAssistantMessage(messages);
         const stopReason = typeof last?.stopReason === 'string' ? last.stopReason : '';
         const stopSignals = event === null
-            ? { pushedFinal: false, askedHuman: false }
+            ? { pushedFinal: false, requestedHumanReply: false }
             : consumeStopSignals(nodeId);
         try {
             const directive = await settleBroker(nodeId, {
                 stopReason,
                 backgroundJobsRunning: backgroundJobsRunning(),
                 pushedFinal: stopSignals.pushedFinal,
-                askedHuman: stopSignals.askedHuman,
+                requestedHumanReply: stopSignals.requestedHumanReply,
             });
             enactSettleDirective(directive, ctx);
         }