@north-light/crouter 0.3.197 → 0.3.199

package/dist/core/runtime/broker/frame-dispatch.js

@@ -14,7 +14,7 @@ import { clearFault, readFault } from '../fault.js';
 import { isManagedProvider, readSubscriptionPool, } from '../../subscription-state.js';
 import { SessionListCache } from '../session-list-cache.js';
 import { sessionListCachePath } from '../../canvas/paths.js';
-import { REVIEW_BOUNDARY_CUSTOM_TYPE } from '../session-visibility.js';
+import { isReviewBoundary } from '../session-visibility.js';
 import { isUnknownModel, parseModelSpec } from '../model-selection.js';
 import { buildCommandList, buildGetTreeData, buildListMemoryRefsData, buildListModelsData, buildScopedModelsData, buildSessionsData, buildSettingsData, modelKey, } from './read-ops.js';
 export const REVIEW_BOUNDARY_NAVIGATION_CODE = 'review_boundary_navigation';
@@ -279,7 +279,7 @@ export function stripHiddenEntriesFromJsonlExport(filePath) {
 }
 /** Owns frame-local input state while dispatching through explicit broker collaborators. */
 export function createFrameDispatchContext(deps) {
-    const { nodeId, cfg, registry, toolGroups, projection, rebind, reviewCompanion, pendingDialogs, sendWelcome, replayExtraPendingDialogsTo, reWelcomeAll, disposeAndExit, persistModelChoice, broadcastModelChanged, registryOf, formatModelSpec, formatExactModelSpec, resolveLaunchModel, } = deps;
+    const { nodeId, cfg, registry, toolGroups, projection, rebind, boundaryReviewId, pendingDialogs, sendWelcome, replayExtraPendingDialogsTo, reWelcomeAll, disposeAndExit, persistModelChoice, broadcastModelChanged, registryOf, formatModelSpec, formatExactModelSpec, resolveLaunchModel, } = deps;
     const currentSession = () => rebind.session();
     const currentServices = () => rebind.services();
     let kickoffPending;
@@ -657,11 +657,10 @@ export function createFrameDispatchContext(deps) {
         // pass no id (unchanged behavior).
         ...(id !== undefined ? { id } : {}),
     });
-    const isPreBoundaryReviewEntry = (entryId) => reviewCompanion &&
+    const isPreBoundaryReviewEntry = (entryId) => boundaryReviewId !== undefined &&
         !currentSession()
             .sessionManager.getBranch(entryId)
-            .some((entry) => entry.type === 'custom_message' &&
-            entry.customType === REVIEW_BOUNDARY_CUSTOM_TYPE);
+            .some((entry) => isReviewBoundary(entry, boundaryReviewId));
     const reviewBoundaryRefusalTo = (client, targetId) => {
         const refusal = new ReviewBoundaryNavigationError(targetId);
         registry.sendFrame(client, {
@@ -1112,7 +1111,7 @@ export function createFrameDispatchContext(deps) {
             }
             case 'get_tree': {
                 try {
-                    registry.sendFrame(client, buildGetTreeData(frame.id, currentSession(), reviewCompanion));
+                    registry.sendFrame(client, buildGetTreeData(frame.id, currentSession(), boundaryReviewId));
                 }
                 catch (err) {
                     engineErrorTo(client, frame.id)(err);

package/dist/core/runtime/broker/read-ops.d.ts

@@ -18,6 +18,6 @@ export declare function buildCommandList(session: BrokerSession): CommandDisclos
 export declare function buildListMemoryRefsData(id: string, refs: RefMeta[], engineLeadingCommandNames: string[]): ListMemoryRefsData;
 export declare function buildListModelsData(id: string, session: BrokerSession): ListModelsData;
 export declare function buildScopedModelsData(id: string, session: BrokerSession): ListScopedModelsData;
-export declare function buildGetTreeData(id: string, session: BrokerSession, reviewCompanion: boolean): GetTreeData;
+export declare function buildGetTreeData(id: string, session: BrokerSession, boundaryReviewId: string | undefined): GetTreeData;
 export declare function buildSettingsData(id: string, session: BrokerSession): GetSettingsData;
 export declare function buildSessionsData(id: string, scope: 'cwd' | 'all', session: BrokerSession, cache: SessionListCache): Promise<ListSessionsData>;

package/dist/core/runtime/broker/read-ops.js

@@ -67,9 +67,9 @@ export function buildScopedModelsData(id, session) {
         enabledModelIds: session.settingsManager.getEnabledModels() ?? null,
     };
 }
-export function buildGetTreeData(id, session, reviewCompanion) {
+export function buildGetTreeData(id, session, boundaryReviewId) {
     const manager = session.sessionManager;
-    const tree = reviewCompanion ? boundaryRootedTree(manager.getTree()) : manager.getTree();
+    const tree = boundaryReviewId !== undefined ? boundaryRootedTree(manager.getTree(), boundaryReviewId) : manager.getTree();
     const visibleEntryIds = new Set();
     const collectEntryIds = (nodes) => {
         for (const node of nodes) {

package/dist/core/runtime/broker/rebind.d.ts

@@ -17,6 +17,7 @@ export interface SubscriptionGeneration {
         messages?: unknown[];
     } | null;
     stagedWatchdogAbort: boolean;
+    stagedRefreshAbort: boolean;
     stagedOverflowFailure: {
         errorMessage: string;
     } | null;

package/dist/core/runtime/broker/rebind.js

@@ -56,7 +56,11 @@ export class RebindDriver {
             await candidateSession.bindExtensions({
                 uiContext: this.deps.uiContext(),
                 mode: 'rpc',
-                abortHandler: () => abortSessionFromExtension(candidateSession),
+                abortHandler: () => abortSessionFromExtension(candidateSession, () => {
+                    const generation = this.installed;
+                    if (generation?.session === candidateSession)
+                        generation.stagedRefreshAbort = true;
+                }),
                 shutdownHandler: () => this.requestShutdown(),
             });
             if (ticket !== this.latestRebindRequest)
@@ -92,6 +96,7 @@ export class RebindDriver {
                 fallback: { blocked: false },
                 stagedProviderAgentEnd: null,
                 stagedWatchdogAbort: false,
+                stagedRefreshAbort: false,
                 stagedOverflowFailure: null,
                 executingTools: new Set(),
             };

package/dist/core/runtime/broker-extension-render.js

@@ -114,10 +114,29 @@ function worktreeNote(node) {
         return '';
     return `Branch: \`${worktree.branch}\`\nWorktree: \`${worktree.path}\`\nBase: \`${worktree.base_ref}\` @ \`${worktree.base_sha}\`\nCommit work here. Land it with \`crtr node worktree close\` before finishing. Auto-drop applies only when the worktree is clean (no uncommitted changes) and nothing remains to land (zero commits ahead of the base, or its commits are already contained in the base); unlanded commits (commits not already contained in the base) or uncommitted changes require an explicit close/landing decision.`;
 }
+/** The companion note — rendered ONLY when a node carries its immutable
+ *  companion binding. Names the target (the document under review, or the page
+ *  the feedback is about), and for a page-feedback companion carries the whole
+ *  behavioral contract — the companion is an ordinary fork of the sending node,
+ *  so this note is the only place it learns the role. */
 function reviewNote(node) {
     const review = node.review_binding;
     if (review === null || review === undefined)
         return '';
+    if (review.kind === 'page_feedback') {
+        const ticketId = review.review_id;
+        const targetFile = review.target_file;
+        return (`You exist for one page's feedback conversation — ticket \`${ticketId}\`, page source \`${targetFile}\`. ` +
+            `Think with the person about this one page and answer in a few plain sentences from the context you already carry. ` +
+            `Revise the page in place with \`crtr human send --replace ${ticketId} --page ${targetFile}\` — it swaps in on their screen immediately — and briefly say what changed; a silent swap leaves them guessing. ` +
+            `After dealing with an open feedback item — by revising the page or answering it here — resolve it with \`crtr human feedback resolve <comment_id>\`; ` +
+            `\`crtr human feedback list ${ticketId}\` shows each item's id and status. ` +
+            `Never author feedback or resolve an item before dealing with it — a sent comment is immutable, and resolution is your report that the work is done. ` +
+            `Asked to act beyond this page, give your advice and point the person at submitting it: the submitted answer is what reaches the task's owner, while work done here is invisible to it and ends when the ticket settles. ` +
+            `When a question needs real exploration, delegate it to a child node and keep talking while it runs. ` +
+            `The inherited conversation belongs to the origin node, not you — its task stays with it; carry only the context needed for this page. ` +
+            `The person's visible transcript begins at the boundary marker above; everything earlier is context they cannot see — never treat it as shared ground; when they ask about it, answer plainly in your own words rather than replaying it.`);
+    }
     return `You exist for one human review of \`${review.target_file}\`. The inherited conversation belongs to the origin node, not you — carry only the context needed for this review. The person's visible transcript begins at the boundary marker above; everything earlier is context they cannot see.`;
 }
 export function buildContextBearingsFromState(state, projectContext, situational = '', seen) {

package/dist/core/runtime/broker-protocol.d.ts

@@ -46,6 +46,20 @@ export interface BrokerSnapshot {
         }>;
         title: string | undefined;
     };
+    /** The engine's UNRUN queue — the steer/follow-up texts a writable client
+     *  sent mid-turn that have not started yet (pi's `_steeringMessages` +
+     *  `_followUpMessages`, read non-destructively). `state.pendingMessageCount`
+     *  is the same queue's SIZE; without the texts a (re)attaching viewer can say
+     *  how many messages are waiting but not which, so it cannot render the
+     *  queued rows it renders from `queue_update` while attached — the welcome
+     *  would no longer fully determine viewer state.
+     *
+     *  Ingest defensively: a broker pinned to a pre-`queued` runtime generation is
+     *  still live and sends `welcome` without it. */
+    queued?: {
+        steering: string[];
+        followUp: string[];
+    };
     /** Broker-owned summaries keyed by the first tool-call id in each group.
      * Structured objects with bullets and filesDeleted.
      * Optional so snapshots from an older live runtime remain readable. */

package/dist/core/runtime/broker.d.ts

@@ -29,7 +29,7 @@ interface PendingDialog {
  *  bash children. No-op before the session is built or after a clean dispose. */
 export declare function disposeActiveSession(): void;
 export declare function runBroker(nodeId: string, startupAt?: bigint, startupTs?: string): Promise<void>;
-export declare function snapshotMessages(session: CreateAgentSessionResult['session'], reviewCompanion?: boolean): BrokerSnapshot['messages'];
+export declare function snapshotMessages(session: CreateAgentSessionResult['session'], boundaryReviewId?: string): BrokerSnapshot['messages'];
 export declare function buildBrokerSession(engine: BrokerEngine, cfg: BrokerSdkConfig): Promise<{
     session: CreateAgentSessionResult['session'];
     services: AgentSessionServices;

package/dist/core/runtime/broker.js

@@ -120,7 +120,8 @@ export function disposeActiveSession() {
 // ---------------------------------------------------------------------------
 export async function runBroker(nodeId, startupAt = process.hrtime.bigint(), startupTs = new Date().toISOString()) {
     // A clean-abort certificate belongs only to the dead broker that wrote it.
-    // Fleet classification consumes it before launching this successor.
+    // Fleet classification consumes it as proof that the dead broker had a turn
+    // in flight even though Pi's settled abort already cleared the busy marker.
     clearCleanAbort(nodeId);
     // The canonical broker event source (job/log.jsonl) is bound before any other
     // work in this function — no path/env/state setup may precede it, and the
@@ -215,8 +216,11 @@ export async function runBroker(nodeId, startupAt = process.hrtime.bigint(), sta
     let { session, services, resuming, runtime } = await buildBrokerSession(engine, cfg);
     // Review identity is immutable for the broker's lifetime. Snapshot producers
     // close over this one construction-time classification rather than re-reading
-    // canvas metadata for every welcome or session replacement.
-    const reviewCompanion = (await brokerExtensionState(nodeId)).node.review_binding != null;
+    // canvas metadata for every welcome or session replacement. The BOUND review
+    // id (not a mere boolean) is what selects this companion's own boundary
+    // marker — a fork of another companion inherits that companion's earlier
+    // marker, and slicing at any marker would reveal its transcript.
+    const boundaryReviewId = (await brokerExtensionState(nodeId)).node.review_binding?.review_id;
     // M3: name the boot session as the process-fatal disposal target immediately —
     // enqueueRebind reassigns this on every later replacement, but without this
     // initial assignment `activeSession` stays null (and disposeActiveSession() a
@@ -354,7 +358,7 @@ export async function runBroker(nodeId, startupAt = process.hrtime.bigint(), sta
     const buildSnapshot = () => {
         const liveSession = rebind.session();
         return ({
-            messages: snapshotMessages(liveSession, reviewCompanion),
+            messages: snapshotMessages(liveSession, boundaryReviewId),
             stats: liveSession.getSessionStats(),
             // pi's `get_state` (rpc-mode.js), field for field, from the same getters.
             // The ONE divergence: a model-less session (undefined OR the SDK
@@ -381,6 +385,14 @@ export async function runBroker(nodeId, startupAt = process.hrtime.bigint(), sta
             },
             toolGroupSummaries: toolGroups.summaries(),
             workingActivity: projection.currentWorkingActivity(),
+            // The UNRUN queue's texts, read non-destructively (`clearQueue()` would
+            // consume them). Same two arrays a live `queue_update` carries, so a client
+            // that attaches mid-queue lands on the state its next `queue_update` would
+            // have produced.
+            queued: {
+                steering: [...liveSession.getSteeringMessages()],
+                followUp: [...liveSession.getFollowUpMessages()],
+            },
         });
     };
     // Send a client its catch-up snapshot. welcome.pending_dialog carries a single
@@ -508,7 +520,7 @@ export async function runBroker(nodeId, startupAt = process.hrtime.bigint(), sta
     rebind.setRebindSession();
     await rebind.enqueueRebind(session, services);
     const frameDispatch = createFrameDispatchContext({
-        nodeId, cfg, registry, toolGroups, projection, rebind, reviewCompanion,
+        nodeId, cfg, registry, toolGroups, projection, rebind, boundaryReviewId,
         pendingDialogs, sendWelcome, replayExtraPendingDialogsTo, reWelcomeAll, disposeAndExit,
         persistModelChoice, broadcastModelChanged, registryOf, formatModelSpec,
         formatExactModelSpec, resolveLaunchModel,
@@ -594,9 +606,10 @@ export async function runBroker(nodeId, startupAt = process.hrtime.bigint(), sta
     // A daemon fleet bounce gives a busy Pi a short, bounded chance to persist
     // its aborted turn before teardown. `session.abort()` resolves only after Pi
     // reaches idle (and thus after its message_end persistence); only then may we
-    // leave the durable clean-abort certificate that changes recovery to resume.
-    // A timeout/rejection deliberately leaves no certificate, preserving dirty
-    // crash → recovery-cycle behavior and the fleet's shared SIGKILL deadline.
+    // leave the durable clean-abort certificate that preserves the otherwise
+    // cleared evidence that this broker had a turn in flight. A timeout/rejection
+    // deliberately leaves no certificate: the surviving busy marker carries the
+    // same interrupted-turn fact through the fleet's shared SIGKILL deadline.
     const ABORT_BEFORE_EXIT_MS = 2_500;
     let signalExitInFlight = false;
     const abortAndExit = async (reason) => {
@@ -633,8 +646,8 @@ export async function runBroker(nodeId, startupAt = process.hrtime.bigint(), sta
             }
             else if (frameDispatch.pendingPromptDispatches() > 0 || rebind.isAgentRunActive()) {
                 // The engine never reached an abortable persisted turn in the budget.
-                // Preserve the existing dirty-death recovery cycle rather than certifying
-                // a session that may not contain the prompt it was preparing.
+                // Preserve the dirty interrupted-turn witness so recovery resumes the
+                // saved transcript and explicitly re-drives the stopped work.
                 markBusy(nodeId);
             }
         }
@@ -671,13 +684,13 @@ export async function runBroker(nodeId, startupAt = process.hrtime.bigint(), sta
 // conversation instead of just the post-yield window; single-cycle sessions and
 // the fake-engine fixture (no tree accessors) fall through to plain
 // `buildSessionContext().messages` unchanged.
-export function snapshotMessages(session, reviewCompanion = false) {
+export function snapshotMessages(session, boundaryReviewId) {
     // Cast: the real SDK's `SessionEntry.data` is `unknown` (untyped custom-entry
     // payload), narrower than `CycleSessionManagerLike`'s structural read of the
     // `crtr-cycle` marker's `{cycle, fromLeaf}` shape — the fields we read off it
     // are ones ONLY this module's own `appendCustomEntry` call (above) ever writes.
     const messages = cycleAwareMessages(session.sessionManager);
-    return visibleMessages(messages, { reviewCompanion });
+    return visibleMessages(messages, { boundaryReviewId });
 }
 // ---------------------------------------------------------------------------
 // resolveLaunchModel — the SOLE launch model-selection policy, module-scoped

package/dist/core/runtime/busy.d.ts

@@ -4,12 +4,13 @@ export declare function markBusy(nodeId: string): void;
 /** Clear the mid-run marker after Pi settles, however it routed. Best-effort. */
 export declare function clearBusy(nodeId: string): void;
 /** Certify that this broker aborted a busy turn and Pi persisted its settled
- * aborted entry before teardown. The daemon consumes this durable certificate
- * once to resume with a continuation; a dirty death never writes it. */
+ * aborted entry before teardown. Settling clears the busy marker, so the daemon
+ * consumes this durable certificate as the surviving interrupted-turn witness
+ * and resumes with a continuation. A dirty death instead leaves `busy` behind. */
 export declare function markCleanAbort(nodeId: string): void;
 /** Remove a consumed clean-abort certificate as a broker boots. */
 export declare function clearCleanAbort(nodeId: string): void;
-/** Whether the dead broker left a persisted clean-abort certificate. */
+/** Whether the dead broker left a persisted clean-abort turn witness. */
 export declare function hasCleanAbort(nodeId: string): boolean;
 /** Is the node currently inside a turn? AND this with `pidAlive` at the call
  *  site — a stale marker from a crashed pi is harmless because the dead pid

package/dist/core/runtime/busy.js

@@ -44,8 +44,9 @@ export function clearBusy(nodeId) {
     }
 }
 /** Certify that this broker aborted a busy turn and Pi persisted its settled
- * aborted entry before teardown. The daemon consumes this durable certificate
- * once to resume with a continuation; a dirty death never writes it. */
+ * aborted entry before teardown. Settling clears the busy marker, so the daemon
+ * consumes this durable certificate as the surviving interrupted-turn witness
+ * and resumes with a continuation. A dirty death instead leaves `busy` behind. */
 export function markCleanAbort(nodeId) {
     try {
         mkdirSync(jobDir(nodeId), { recursive: true });
@@ -64,7 +65,7 @@ export function clearCleanAbort(nodeId) {
         /* best-effort */
     }
 }
-/** Whether the dead broker left a persisted clean-abort certificate. */
+/** Whether the dead broker left a persisted clean-abort turn witness. */
 export function hasCleanAbort(nodeId) {
     return existsSync(cleanAbortPath(nodeId));
 }

package/dist/core/runtime/front-door-env.d.ts

@@ -0,0 +1,5 @@
+/** Env marker set on every pi the front door boots. Its presence means we are
+ *  already inside a front-door-booted root, so a nested front-door launch must
+ *  be refused — otherwise a removed/renamed subcommand that a child pi re-runs
+ *  (e.g. `crtr node -h`) fork-bombs pi until the machine must be rebooted. */
+export declare const FRONT_DOOR_ENV = "CRTR_FRONT_DOOR";

package/dist/core/runtime/front-door-env.js

@@ -0,0 +1,16 @@
+// The front-door recursion-guard env name, alone in a dependency-free module.
+//
+// `front-door.ts` owns the boot path and reaches the canvas through the
+// dynamic imports inside `maybeBootRoot`; every module that only needs the
+// MARKER NAME must not inherit that reach. The shipped broker extensions are
+// gated on their static import graph, which cannot tell a lazily-imported boot
+// dependency from an eagerly-loaded one, so importing the constant from
+// `front-door.js` reads as an extension reaching canvas.db.
+//
+// `front-door.ts` re-exports this, so `FRONT_DOOR_ENV` stays importable from
+// either module and every pi-booting path keeps setting the same marker.
+/** Env marker set on every pi the front door boots. Its presence means we are
+ *  already inside a front-door-booted root, so a nested front-door launch must
+ *  be refused — otherwise a removed/renamed subcommand that a child pi re-runs
+ *  (e.g. `crtr node -h`) fork-bombs pi until the machine must be rebooted. */
+export const FRONT_DOOR_ENV = 'CRTR_FRONT_DOOR';

package/dist/core/runtime/front-door.d.ts

@@ -1,8 +1,4 @@
-/** Env marker set on every pi the front door boots. Its presence means we are
- *  already inside a front-door-booted root, so a nested front-door launch must
- *  be refused — otherwise a removed/renamed subcommand that a child pi re-runs
- *  (e.g. `crtr node -h`) fork-bombs pi until the machine must be rebooted. */
-export declare const FRONT_DOOR_ENV = "CRTR_FRONT_DOOR";
+export { FRONT_DOOR_ENV } from './front-door-env.js';
 /** If this invocation is a front-door (root) launch, boot it and never return.
  *  Returns false when it's a recognized subcommand / help / unknown token (let
  *  the dispatcher handle it — for unknown tokens it errors cleanly).

package/dist/core/runtime/front-door.js

@@ -21,6 +21,7 @@
 import { existsSync, statSync } from 'node:fs';
 import { resolve as resolvePath } from 'node:path';
 import { SUBTREE_NAMES } from '../../build-root.js';
+import { FRONT_DOOR_ENV } from './front-door-env.js';
 // NOTE: the boot-path deps — ./boot-root.js (bootRoot), ./resume-root.js (resumeRoot),
 // ./package-health.js (missingPackageWarning + piAgentDir) — are DYNAMICALLY
 // imported inside maybeBootRoot, NOT statically here. `cli.ts` calls
@@ -89,11 +90,7 @@ function parseRootArgs(tokens) {
     const prompt = positionals.length > 0 ? positionals.join(' ') : undefined;
     return { cwd, prompt, name, kind, profile, pickProfile, resume };
 }
-/** Env marker set on every pi the front door boots. Its presence means we are
- *  already inside a front-door-booted root, so a nested front-door launch must
- *  be refused — otherwise a removed/renamed subcommand that a child pi re-runs
- *  (e.g. `crtr node -h`) fork-bombs pi until the machine must be rebooted. */
-export const FRONT_DOOR_ENV = 'CRTR_FRONT_DOOR';
+export { FRONT_DOOR_ENV } from './front-door-env.js';
 /** If this invocation is a front-door (root) launch, boot it and never return.
  *  Returns false when it's a recognized subcommand / help / unknown token (let
  *  the dispatcher handle it — for unknown tokens it errors cleanly).

package/dist/core/runtime/host.d.ts

@@ -1,5 +1,5 @@
 import { type NodeRow } from '../canvas/index.js';
-import type { PiInvocation } from './launch.js';
+import type { PiInvocation } from './invocation.js';
 /** View-side launch hints the broker host needs beyond the PiInvocation. The
  *  broker uses `cwd` + `resuming`; `name` is carried for the node's display. */
 export interface LaunchPlacement {

package/dist/core/runtime/invocation.d.ts

@@ -0,0 +1,6 @@
+export interface PiInvocation {
+    /** argv after the `pi` binary. */
+    argv: string[];
+    /** env to merge into the process. */
+    env: Record<string, string>;
+}

package/dist/core/runtime/invocation.js

@@ -0,0 +1,10 @@
+// The broker-launch recipe shape, alone in a dependency-free module.
+//
+// `launch.ts` builds a PiInvocation and therefore reaches canvas state; the
+// modules that only need to READ the recipe shape (spawn-env, host) must not.
+// A type-only import is erased at compile time, but the shipped broker
+// extensions are gated on their STATIC import graph — the gate cannot tell an
+// erased edge from a live one, so an extension that reaches spawn-env would
+// read as reaching canvas.db through launch.ts. Keeping the interface here
+// makes the graph say what the runtime already does.
+export {};

package/dist/core/runtime/kickoff.js

@@ -20,6 +20,7 @@
 import { existsSync, readFileSync, writeFileSync, rmSync, mkdirSync, readdirSync, } from 'node:fs';
 import { join } from 'node:path';
 import { contextDir, reportsDir, getNode, subscriptionsOf, subscribersOf, } from '../canvas/index.js';
+import { activeBackgroundBashJobs, bashJobCommandLine, formatBashElapsed } from '../bash-jobs.js';
 import { readRoadmap, roadmapPath } from './roadmap.js';
 import { buildWakeBearings } from './bearings.js';
 import { personaDrift, commitPersonaAck } from './persona.js';
@@ -205,6 +206,33 @@ function feedBlock(nodeId, unreadDigest) {
     }
     return `<feed>\n${lines.join('\n')}\n</feed>`;
 }
+/** One-line label for a job: its purpose when the caller gave one, else its real
+ *  command line, clipped so a long pipeline stays scannable. */
+function jobLabel(purpose, command) {
+    const raw = (purpose ?? bashJobCommandLine(command)).trim() || '(no command)';
+    return raw.length > 120 ? `${raw.slice(0, 117)}…` : raw;
+}
+/** Live file-backed background bash jobs this node owns. A fresh revive has no
+ *  memory of handing anything off, so without this block the node cannot tell a
+ *  command it started is still running: it can neither read the log nor decide
+ *  whether to wait, and may relaunch the same work. Returns null — and the
+ *  kickoff omits the block entirely — when nothing is live. */
+function backgroundJobsBlock(nodeId) {
+    const jobs = activeBackgroundBashJobs(contextDir(nodeId));
+    if (jobs.length === 0)
+        return null;
+    const now = Date.now();
+    const one = jobs.length === 1;
+    const lines = [
+        `${jobs.length} background bash job${one ? '' : 's'} you started ${one ? 'is' : 'are'} STILL RUNNING, detached from any turn and unaffected by your refresh. ` +
+            `Each one sends you a message when it exits — that wake is automatic, so do not poll it and do not relaunch the same command.`,
+    ];
+    for (const job of jobs) {
+        lines.push(`  - ${job.jobId} — ${jobLabel(job.purpose, job.command)} · running ${formatBashElapsed(now - job.startedAtMs)} · log ${job.logPath}`);
+    }
+    lines.push('', 'Read output so far: `tail -n 50 <log>` (or `crtr node bash list --tail 20`). Abandon one: `crtr node bash kill <job-id>`.');
+    return `<background-jobs>\n${lines.join('\n')}\n</background-jobs>`;
+}
 // ---------------------------------------------------------------------------
 // buildReviveKickoff — assemble the full fresh-revive first message.
 // ---------------------------------------------------------------------------
@@ -257,6 +285,12 @@ export function buildReviveKickoff(meta, bearings, wakeReason) {
     // revive (a new pi process boot) and re-injects buildContextIntro(), which
     // already carries the sidecar as a hidden sibling of <crtr-bearings>; that seam
     // covers this path, so duplicating it into the visible prompt would leak it.
+    // Live background bash jobs sit beside the context-dir listing: both describe
+    // this node's OWN in-flight state, and both precede <feed>, which is about the
+    // other nodes it awaits. Absent when nothing is running.
+    const jobsBlock = backgroundJobsBlock(nodeId);
+    if (jobsBlock !== null)
+        parts.push(jobsBlock);
     parts.push(feedBlock(nodeId, bearings.unreadDigest));
     parts.push(bearings.yieldMsg !== null
         ? `<yield-message>\n${bearings.yieldMsg.trim()}\n</yield-message>`

package/dist/core/runtime/launch.d.ts

@@ -1,3 +1,4 @@
+import type { PiInvocation } from './invocation.js';
 export { CANVAS_EXTENSIONS, CANVAS_STOPHOOK_PATH, CANVAS_INBOX_WATCHER_PATH, CANVAS_RECAP_PATH, CANVAS_GOAL_CAPTURE_PATH, CANVAS_PASSIVE_CONTEXT_PATH, CANVAS_CONTEXT_INTRO_PATH, CANVAS_TOOL_GUIDE_PATH, CANVAS_DOC_SUBSTRATE_PATH, CANVAS_STRUCTURED_OUTPUT_PATH, CANVAS_BASH_VALVE_PATH, } from './canvas-extensions.js';
 import type { NodeMeta, LaunchSpec, Mode, Lifecycle } from '../canvas/index.js';
 import type { ModelProvider, ModelStrength, ScopeConfig } from '../../types.js';
@@ -104,12 +105,7 @@ export declare function buildLaunchSpec(kind: string, mode: Mode, opts: {
     launch: LaunchSpec;
     lifecycle: 'terminal' | 'resident';
 };
-export interface PiInvocation {
-    /** argv after the `pi` binary. */
-    argv: string[];
-    /** env to merge into the process. */
-    env: Record<string, string>;
-}
+export type { PiInvocation } from './invocation.js';
 /** Construct the pi invocation for a node.
  *  - fresh start: pass `prompt` (the node's first user message), no resume.
  *  - fork start: pass `forkFrom` (absolute .jsonl path or partial uuid) to `--fork`

package/dist/core/runtime/node-read.js

@@ -152,7 +152,7 @@ export async function readNodeSnapshot(nodeId) {
         copyFileSync(sessionFile, copy);
         const manager = SessionManager.open(copy);
         const context = manager.buildSessionContext();
-        const messages = visibleMessages(cycleAwareMessages(manager), { reviewCompanion: node.review_binding != null });
+        const messages = visibleMessages(cycleAwareMessages(manager), { boundaryReviewId: node.review_binding?.review_id });
         const sessionId = manager.getSessionId();
         const sessionName = manager.getSessionName();
         const snapshot = {
@@ -179,6 +179,9 @@ export async function readNodeSnapshot(nodeId) {
             // process state (last setStatus/setWidget/setTitle) and is not persisted,
             // so an offline read has none.
             display: { statuses: {}, widgets: {}, title: undefined },
+            // The unrun queue lives in the engine's memory; a dormant node has no
+            // engine, so nothing is waiting to run.
+            queued: { steering: [], followUp: [] },
             // Sidecar summaries survive broker exit so a dormant transcript receives
             // the same completed-group data as a live welcome snapshot. Malformed or
             // absent sidecars are deliberately ignored: tool calls remain visible.

package/dist/core/runtime/nodes.js

@@ -19,6 +19,7 @@ import { memoryDir } from './memory.js';
 import { resolveInstallId } from '../canvas/install-id.js';
 import { canvasDbPath } from '../canvas/paths.js';
 import { usage } from '../errors.js';
+import { assertProfileAvailableForBirth } from '../profiles/deletion-reservation.js';
 // crtrd sets this once at boot (setInstallId) and it wins unconditionally —
 // a daemon process only ever serves one canvas home for its whole lifetime,
 // so no keying is needed there. Every OTHER in-process caller (tests,
@@ -259,6 +260,7 @@ export function spawnNode(opts) {
     if (parent !== null && getNode(parent) === null) {
         throw new Error(`cannot spawn under unknown parent node: ${parent}`);
     }
+    assertProfileAvailableForBirth(meta.profile_id ?? null);
     createNode(meta);
     // Create the node-local memory directory so substrate docs can be written
     // directly into it without a separate mkdir. Skip for ephemeral human-bridge

package/dist/core/runtime/promote.d.ts

@@ -19,6 +19,7 @@ export declare function reshapeNode(nodeId: string, opts?: {
     model?: string;
     mode?: Mode;
     lifecycle?: Lifecycle;
+    profileId?: string | null;
 }, beforePersist?: () => void): NodeMeta;
 /** Promote a node to an orchestrator (mode→orchestrator), optionally
  *  specializing its kind (e.g. a `general` worker becoming a

package/dist/core/runtime/promote.js

@@ -42,6 +42,7 @@ export function reshapeNode(nodeId, opts = {}, beforePersist) {
     const targetModel = opts.model ?? node.model_override ?? undefined;
     const targetMode = opts.mode ?? node.mode;
     const targetLifecycle = opts.lifecycle ?? node.lifecycle;
+    const targetProfileId = opts.profileId === undefined ? node.profile_id : opts.profileId;
     // Rewrite the launch spec to the target kind/mode's persona so the *next*
     // revive comes back as this exact shape (polymorph stage 2). nodeEnv reads
     // meta.{kind,mode}, so CRTR_KIND/CRTR_MODE flip immediately for the live
@@ -66,7 +67,7 @@ export function reshapeNode(nodeId, opts = {}, beforePersist) {
         // Resolve kind/ladder config against the NODE's own cwd + profile, not
         // this process's ambient scope.
         cwd: node.cwd,
-        profileId: node.profile_id,
+        profileId: targetProfileId,
     });
     // Promotion seeds after its target launch has been built but before the
     // mutation is persisted, preserving the original promote() failure order.
@@ -81,6 +82,7 @@ export function reshapeNode(nodeId, opts = {}, beforePersist) {
         kind: targetKind,
         mode: targetMode,
         lifecycle: targetLifecycle,
+        profile_id: targetProfileId,
         launch,
         ...(carriesDefaultHandle ? { name: targetKind } : {}),
         // Persist a newly-chosen tier so it is durable across future revives; omit

package/dist/core/runtime/session-cycles.d.ts

@@ -20,6 +20,12 @@ export interface CycleSessionManagerLike {
      *  path root-first. */
     getBranch?(fromId?: string): SessionEntry[];
 }
+/** True when an assistant turn ended because its own abort fired — an ESC, a
+ *  critical-tier interrupt, or the self-abort a refresh-yield performs. */
+export declare function endedByAbort(message: {
+    stopReason?: string;
+    errorMessage?: string;
+}): boolean;
 /** A refresh-yield deliberately aborts its own turn before the next cycle is
  * rooted. Preserve that assistant message (including tool calls and prose), but
  * omit the failure annotation: the cycle divider is the truthful visible seam. */

package/dist/core/runtime/session-cycles.js

@@ -32,11 +32,25 @@ function cycleDivider(cycle, timestamp) {
         timestamp: new Date(timestamp).getTime(),
     };
 }
+/** Text a provider attaches when the request's own AbortSignal fired. Pi's
+ *  providers stamp `stopReason: 'aborted'` when they observe the signal
+ *  themselves, but an abort that lands while the next request is starting
+ *  reaches their catch as a bare AbortError instead, and is recorded as
+ *  `stopReason: 'error'` carrying this text. Both spellings are the same healthy
+ *  event — a turn that stopped because something asked it to stop. */
+const ABORT_ERROR_TEXT = /\b(?:request|operation) was aborted\b|\bthe user aborted\b/i;
+/** True when an assistant turn ended because its own abort fired — an ESC, a
+ *  critical-tier interrupt, or the self-abort a refresh-yield performs. */
+export function endedByAbort(message) {
+    if (message.stopReason === 'aborted')
+        return true;
+    return message.stopReason === 'error' && ABORT_ERROR_TEXT.test(message.errorMessage ?? '');
+}
 /** A refresh-yield deliberately aborts its own turn before the next cycle is
  * rooted. Preserve that assistant message (including tool calls and prose), but
  * omit the failure annotation: the cycle divider is the truthful visible seam. */
 export function withoutYieldAbort(message) {
-    if (message.role !== 'assistant' || message.stopReason !== 'aborted')
+    if (message.role !== 'assistant' || !endedByAbort(message))
         return message;
     const { stopReason: _stopReason, errorMessage: _errorMessage, ...visible } = message;
     return visible;

package/dist/core/runtime/session-visibility.d.ts

@@ -12,18 +12,23 @@ export declare function isReviewBoundary(entry: unknown, reviewId?: string): boo
 /**
  * Project snapshot messages to the visible window for a review companion.
  *
+ * A companion passes its binding's review id so the slice starts at ITS OWN
+ * boundary marker: a node forked from another companion inherits that
+ * companion's earlier marker, and slicing at the first marker of any review
+ * would reveal the origin companion's transcript.
+ *
  * Contract (in evaluation order):
- * 1. Marker present → slice from the **first** occurrence (marker included) to
- *    the end. Everything before the marker is inherited context, hidden from
- *    the person.
- * 2. Not a review companion → return input unchanged (same reference). Ordinary
- *    nodes are not filtered.
- * 3. No marker and review companion → a leading compaction summary is replaced
+ * 1. This binding's marker present (any marker when the node has no binding) →
+ *    slice from the **first** occurrence (marker included) to the end.
+ *    Everything before the marker is inherited context, hidden from the person.
+ * 2. Not a companion (`boundaryReviewId` undefined) → return input unchanged
+ *    (same reference). Ordinary nodes are not filtered.
+ * 3. Bound but no matching marker → a leading compaction summary is replaced
  *    with a synthetic boundary while its retained tail remains visible. Every
  *    other markerless shape fails closed with the synthetic boundary alone.
  */
 export declare function visibleMessages(messages: BrokerSnapshot['messages'], opts: {
-    reviewCompanion: boolean;
+    boundaryReviewId: string | undefined;
 }): BrokerSnapshot['messages'];
 /**
  * Project a session tree to the review companion's visible transcript boundary.
@@ -33,5 +38,9 @@ export declare function visibleMessages(messages: BrokerSnapshot['messages'], op
  * boundary is crossed, its complete descendant subtree remains navigable. An
  * absent boundary produces an empty tree, so picker previews never disclose an
  * inherited entry before a mutation guard can reject its selection.
+ *
+ * `boundaryReviewId` selects only this binding's marker as a root, so a
+ * companion forked from another companion never navigates into the inherited
+ * subtree rooted at the origin's earlier marker.
  */
-export declare function boundaryRootedTree(tree: readonly WireSessionTreeNode[]): WireSessionTreeNode[];
+export declare function boundaryRootedTree(tree: readonly WireSessionTreeNode[], boundaryReviewId?: string): WireSessionTreeNode[];