@north-light/crouter 0.3.198 → 0.3.200

package/dist/core/profiles/select.js

@@ -296,10 +296,10 @@ function rootProfileMessage(cwd) {
 /** The one synchronous (pre-boot) decision point: no profile covers cwd, and
  *  the session IS interactive. Ask on the controlling terminal — create a
  *  profile pointing at cwd, or proceed as root — and block until answered.
- *  Deliberately a minimal `readline` prompt, not `crtr human ask`: that bridge
+ *  Deliberately a minimal `readline` prompt, not `crtr human send`: that bridge
  *  is asynchronous (registers an interaction in the ticket store, then waits for
  *  the human to answer it from a separate inbox) and cannot gate pi's boot; those
- *  entry points (`human ask`/`review`) are built for a queued,
+ *  entry points (`human send`/`review`) are built for a queued,
  *  asynchronously-answered interaction, not a two-choice gate on the same TTY pi
  *  is about to take over — a raw `readline` question is the actual minimal
  *  fit here. */

package/dist/core/review/realize.js

@@ -1,8 +1,8 @@
 import { existsSync } from 'node:fs';
-import { basename, join } from 'node:path';
+import { basename } from 'node:path';
 import { getNode, subscribersOf, subscribe } from '../canvas/index.js';
 import { withCanvasWrite } from '../canvas/db.js';
-import { atomicWriteJson } from '../human/convention.js';
+import { bindTicketReplyRoute } from '../human/convention.js';
 import { ticketDir } from '../human/root.js';
 import { submitReview } from '../human/tickets.js';
 import { NodeIdConflictError, spawnNode } from '../runtime/nodes.js';
@@ -108,7 +108,7 @@ function realizeBridge(review) {
             profile_id: origin.profile_id ?? null,
             name: 'human-review',
         });
-        atomicWriteJson(join(ticketDir(bridge.node_id), 'run.json'), { mode: 'review' });
+        bindTicketReplyRoute(ticketDir(bridge.node_id), bridge.node_id);
         if (!bindBridgeNode(current.review_id, bridge.node_id)) {
             cancelInvisibleBridge(bridge.node_id);
             current = requireReview(current.review_id);

package/dist/core/review/store.d.ts

@@ -28,6 +28,12 @@ export declare function listReviews(filter: {
     origin_node_id?: string;
     file?: string;
 }): ReviewRecord[];
+/** Review ids whose immutable origin is one of `nodeIds`, including binding
+ *  rows that normal user-facing review listings intentionally hide. */
+export declare function reviewIdsByOriginNodes(nodeIds: readonly string[]): string[];
+/** Delete review audit state for the selected origins in dependency order.
+ *  Filesystem cleanup is deliberately left to the daemon lifecycle owner. */
+export declare function deleteReviewsByOriginNodes(nodeIds: readonly string[]): string[];
 export declare function listBindingReviews(): ReviewRecord[];
 /** Open reviews the human has already submitted, still waiting on their companion. */
 export declare function listSubmitRequestedReviews(): ReviewRecord[];

package/dist/core/review/store.js

@@ -116,6 +116,37 @@ export function listReviews(filter) {
     }
     return readRecords(openDb(), clauses.join(' AND '), ...params);
 }
+/** Review ids whose immutable origin is one of `nodeIds`, including binding
+ *  rows that normal user-facing review listings intentionally hide. */
+export function reviewIdsByOriginNodes(nodeIds) {
+    const ids = [...new Set(nodeIds)];
+    if (ids.length === 0)
+        return [];
+    const placeholders = ids.map(() => '?').join(',');
+    return openDb()
+        .prepare(`SELECT review_id FROM reviews WHERE origin_node_id IN (${placeholders}) ORDER BY created, review_id`)
+        .all(...ids).map(({ review_id }) => review_id);
+}
+/** Delete review audit state for the selected origins in dependency order.
+ *  Filesystem cleanup is deliberately left to the daemon lifecycle owner. */
+export function deleteReviewsByOriginNodes(nodeIds) {
+    const ids = [...new Set(nodeIds)];
+    if (ids.length === 0)
+        return [];
+    const originPlaceholders = ids.map(() => '?').join(',');
+    return withCanvasWrite((db) => {
+        const reviewIds = db
+            .prepare(`SELECT review_id FROM reviews WHERE origin_node_id IN (${originPlaceholders}) ORDER BY created, review_id`)
+            .all(...ids).map(({ review_id }) => review_id);
+        if (reviewIds.length === 0)
+            return [];
+        const reviewPlaceholders = reviewIds.map(() => '?').join(',');
+        db.prepare(`DELETE FROM review_comment_events WHERE review_id IN (${reviewPlaceholders})`).run(...reviewIds);
+        db.prepare(`DELETE FROM review_comments WHERE review_id IN (${reviewPlaceholders})`).run(...reviewIds);
+        db.prepare(`DELETE FROM reviews WHERE review_id IN (${reviewPlaceholders})`).run(...reviewIds);
+        return reviewIds;
+    });
+}
 export function listBindingReviews() {
     return readRecords(openDb(), "state = 'binding'");
 }

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

@@ -61,10 +61,6 @@ export declare function cronWakeOrigin(c: Cron, kind: WakeOrigin['kind']): WakeO
  *  carry the signal, and a raw ISO instant is noise an agent cannot cheaply turn
  *  into an elapsed delta. */
 export declare function buildWakeBearings(origin: WakeOrigin): string;
-/** The node-scoped update for a fork whose copied branch already contains a
- *  full crouter baseline. Shared project and operating context stays in the
- *  inherited branch; this block replaces only source-owned facts. */
-export declare function buildForkBearings(nodeId: string): string;
 /** The full boot intro, four top-level sections:
  *
  *   1. `<crtr-bearings>` — the orienting facts about THIS node: the identity

package/dist/core/runtime/bearings.js

@@ -3,9 +3,10 @@
 // A conversation with no inherited crouter bearings receives the full baseline:
 // node identity and graph position, context-directory guidance, routed knowledge,
 // auto-loaded project docs, situational context, and the current environment.
-// A fork whose copied branch already carries that baseline receives only
-// buildForkBearings(): the new node-scoped facts that supersede its source's
-// identity. The copied baseline remains useful reference without being repeated.
+// A fork whose copied branch already carries that baseline receives only the
+// new node-scoped facts that supersede its source's identity — rendered by
+// buildForkBearingsFromState() in broker-extension-render.ts, the broker-side
+// mirror. The copied baseline remains useful reference without being repeated.
 //
 // promote.ts separately delivers orchestratorContextNote() when a base node
 // becomes an orchestrator after birth.
@@ -329,65 +330,6 @@ function managedWorktreeNote(node) {
         return '';
     return `Branch: \`${wt.branch}\`\nWorktree: \`${wt.path}\`\nBase: \`${wt.base_ref}\` @ \`${wt.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 review-companion block — rendered ONLY when a node carries its immutable
- *  review binding. Names the target file (the document under review), clarifies
- *  that inherited context belongs to the origin node and is not visible to the
- *  person, and notes that the visible transcript begins at the boundary marker
- *  above. */
-function reviewCompanionBlock(meta) {
-    if (meta?.review_binding === undefined || meta?.review_binding === null)
-        return '';
-    const targetFile = meta.review_binding.target_file;
-    return (`You exist for one human review of \`${targetFile}\`. 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.`);
-}
-/** The node-scoped update for a fork whose copied branch already contains a
- *  full crouter baseline. Shared project and operating context stays in the
- *  inherited branch; this block replaces only source-owned facts. */
-export function buildForkBearings(nodeId) {
-    const node = getNode(nodeId);
-    const bearings = [
-        '<crtr-bearings>',
-        buildIdentityAssertion(nodeId),
-        '',
-        'The source node’s earlier task, graph position, lifecycle, children, schedules, worktree, situational context, and context-directory path do not carry over. Shared conversation, project, and operating context remain reference material.',
-        '',
-        '## Your node now',
-        `Lifecycle: ${node?.lifecycle ?? 'terminal'}.`,
-    ];
-    const map = buildGraphMap(nodeId);
-    if (map === '') {
-        bearings.push('Canvas: independent root with no parent or inherited graph edges.');
-    }
-    else {
-        bearings.push('', map);
-    }
-    bearings.push(`Context directory: \`${contextDir(nodeId)}\` (\`$CRTR_CONTEXT_DIR\`). Use this path in place of every source-node context path above.`);
-    const forkFrom = node?.fork_from;
-    const source = forkFrom !== undefined && forkFrom !== null && isSafeNodeId(forkFrom)
-        ? getNode(forkFrom)
-        : null;
-    if (node !== null && (source === null || source.cwd !== node.cwd)) {
-        bearings.push(`Working directory: \`${node.cwd}\`.`);
-    }
-    if (node !== null && (source === null || source.profile_id !== node.profile_id)) {
-        const profileSection = profileNote(nodeId);
-        if (profileSection !== '')
-            bearings.push(profileSection);
-    }
-    const worktree = managedWorktreeNote(node);
-    if (worktree !== '')
-        bearings.push('', '## Your managed worktree', worktree);
-    if (node?.mode === 'orchestrator')
-        bearings.push('', orchestratorContextNote(nodeId));
-    const review = reviewCompanionBlock(node);
-    if (review !== '')
-        bearings.push('', review);
-    bearings.push('', 'The first real user message after these bearings is your mandate.', '</crtr-bearings>');
-    const situational = situationalContextBlock(nodeId);
-    return [bearings.join('\n'), situational].filter((s) => s !== '').join('\n');
-}
 /** The full boot intro, four top-level sections:
  *
  *   1. `<crtr-bearings>` — the orienting facts about THIS node: the identity

package/dist/core/runtime/bin-contributions.d.ts

@@ -0,0 +1,44 @@
+import type { Scope } from '../../types.js';
+/** One resolved bare command: the name a node's bash sees, and the absolute
+ *  real path the shim links to. */
+export interface ResolvedBin {
+    name: string;
+    /** Absolute target validated inside the contributing root when this set resolved. */
+    target: string;
+    /** Human-readable contributor, e.g. `plugin "deploy-tools"` or
+     *  `config.json (/repo/.crouter)`. */
+    origin: string;
+    scope: Scope;
+}
+/** A declaration that did NOT become a bare command, with why. Surfaced by
+ *  `crtr sys doctor`; never thrown, so one bad entry can never stop a node
+ *  from launching. */
+export interface BinIssue {
+    name: string;
+    origin: string;
+    scope: Scope;
+    message: string;
+}
+export interface BinResolution {
+    /** Effective name → resolved bin, after layering. */
+    bins: Map<string, ResolvedBin>;
+    issues: BinIssue[];
+}
+/** The effective bare-command set for one node's cwd/profile, plus every
+ *  declaration that failed to become one.
+ *
+ *  Layers ascend in precedence (see `contributionLayers`). A name claimed by
+ *  two contributors in the SAME layer selects no winner: it is reported and
+ *  removed, so an ambiguous name resolves to nothing rather than to whichever
+ *  plugin sorted first. A higher layer may still claim that name explicitly —
+ *  that is an unambiguous choice, not a collision. */
+export declare function resolveBinContributions(targetCwd: string, targetProfileId: string | null): BinResolution;
+/** Materialize (idempotently) the shim directory for one effective set and
+ *  return its absolute path, or null when the set is empty. Built in a staging
+ *  dir and renamed into place, so a concurrent launch either sees no directory
+ *  or sees a complete one. */
+export declare function ensureBinShimDir(bins: Map<string, ResolvedBin>): string | null;
+/** The shim directory to prepend to a target node's PATH, or null when that
+ *  node's scopes declare no bare command. The one entry point the spawn-env
+ *  boundary calls. */
+export declare function binShimDirFor(targetCwd: string, targetProfileId: string | null): string | null;

package/dist/core/runtime/bin-contributions.js

@@ -0,0 +1,186 @@
+// Bare-binary contributions — the plain executables a node's bash can call by
+// name, with no `crtr` command leaf and no exec-command JSON protocol between
+// them and the agent.
+//
+// A plugin declares them in its manifest (`bin`), a user or project scope in
+// its own `config.json` (`bin`); both are a small name → root-relative-path
+// map. This module resolves those declarations across the same layering the
+// rest of the config uses (project stack > user, and within one root: that
+// root's own config > its enabled plugins), materializes one crouter-owned
+// shim directory of symlinks, and hands its path to the spawn-env boundary
+// (`spawn-env.ts`), which PREPENDS it to every broker child's PATH while
+// leaving the host PATH intact behind it.
+//
+// The shim directory exists so the declaration stays a per-name grant: crouter
+// links exactly the names that were declared, rather than putting a
+// contributor's whole `bin/` directory on the agent's PATH and admitting every
+// sibling file in it.
+//
+// These binaries are trusted local code running with the caller's authority —
+// the same authority the agent's bash tool already has. There is no sandbox,
+// no install hook, and no shell evaluation anywhere in this path. Containment
+// is checked while resolving the effective set; a contributor can change later
+// because it is trusted local code, not a sandboxed artifact.
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, realpathSync, renameSync, rmSync, statSync, symlinkSync } from 'node:fs';
+import { dirname, join, resolve, sep } from 'node:path';
+import { binDeclarationIssues, normalizeBin, readRawConfigAtRoot } from '../config.js';
+import { listInstalledPluginsInRoot } from '../installed-plugins.js';
+import { crtrHome } from '../canvas/paths.js';
+import { findProjectScopeRoots, scopeRoot } from '../scope.js';
+function contributorIssues(origin, scope, raw) {
+    return binDeclarationIssues(raw).map((issue) => ({ name: issue.name, origin, scope, message: issue.message }));
+}
+function pluginContributors(scope, root) {
+    return listInstalledPluginsInRoot(scope, root)
+        .filter((plugin) => plugin.enabled && plugin.manifest.bin !== undefined)
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map((plugin) => {
+        const origin = `plugin "${plugin.name}"`;
+        return { origin, scope, root: plugin.root, bin: normalizeBin(plugin.manifest.bin), issues: contributorIssues(origin, scope, plugin.manifest.bin) };
+    });
+}
+/** A scope's own `config.json` contributions. Paths resolve against the scope's
+ *  AUTHORING root: the project directory for a project scope (so a repo writes
+ *  `tools/repoctl`, where its tools actually live, not `../tools/repoctl` out
+ *  of `.crouter/`), and `~/.crouter` itself for the user scope, which has no
+ *  enclosing project. */
+function configContributor(scope, scopeRootPath) {
+    const raw = readRawConfigAtRoot(scopeRootPath)?.bin;
+    if (raw === undefined)
+        return [];
+    const origin = `config.json (${scopeRootPath})`;
+    const bin = normalizeBin(raw);
+    const root = scope === 'project' ? dirname(scopeRootPath) : scopeRootPath;
+    return [{ origin, scope, root, bin, issues: contributorIssues(origin, scope, raw) }];
+}
+/** The contribution LAYERS in ascending precedence: a later layer's entry
+ *  replaces an earlier layer's same name. Within one root the root's own
+ *  `config.json` outranks its plugins (the rule `layerPluginKinds` follows for
+ *  `kinds`), and the project stack — nearest root last — outranks the user
+ *  scope entirely. Contributors WITHIN one layer never outrank each other:
+ *  two of them claiming one name is a collision, not a precedence question. */
+function contributionLayers(targetCwd, targetProfileId) {
+    const layers = [];
+    const userRoot = scopeRoot('user');
+    if (userRoot !== null) {
+        layers.push(pluginContributors('user', userRoot), configContributor('user', userRoot));
+    }
+    const projectRootsNearestFirst = findProjectScopeRoots(targetCwd, targetProfileId);
+    for (const root of [...projectRootsNearestFirst].reverse()) {
+        layers.push(pluginContributors('project', root), configContributor('project', root));
+    }
+    return layers.filter((layer) => layer.length > 0);
+}
+/** Resolve one declared path against its contributing root: it must stay
+ *  inside that root, be a regular file, and carry a POSIX exec bit when the
+ *  effective set is resolved. Returns the absolute real path, or the reason it
+ *  is not usable. */
+function resolveTarget(root, relative) {
+    let rootReal;
+    let target;
+    try {
+        rootReal = realpathSync(root);
+        target = realpathSync(resolve(root, relative));
+    }
+    catch {
+        return { reason: `target does not exist: ${join(root, relative)}` };
+    }
+    if (target !== rootReal && !target.startsWith(rootReal + sep)) {
+        return { reason: `target escapes its contributing root: ${relative}` };
+    }
+    const stat = statSync(target);
+    if (!stat.isFile())
+        return { reason: `target is not a regular file: ${target}` };
+    if ((stat.mode & 0o111) === 0)
+        return { reason: `target lacks the POSIX exec bit: ${target}` };
+    return { target };
+}
+/** The effective bare-command set for one node's cwd/profile, plus every
+ *  declaration that failed to become one.
+ *
+ *  Layers ascend in precedence (see `contributionLayers`). A name claimed by
+ *  two contributors in the SAME layer selects no winner: it is reported and
+ *  removed, so an ambiguous name resolves to nothing rather than to whichever
+ *  plugin sorted first. A higher layer may still claim that name explicitly —
+ *  that is an unambiguous choice, not a collision. */
+export function resolveBinContributions(targetCwd, targetProfileId) {
+    const bins = new Map();
+    const issues = [];
+    for (const layer of contributionLayers(targetCwd, targetProfileId)) {
+        const claims = new Map();
+        for (const contributor of layer) {
+            issues.push(...contributor.issues);
+            for (const name of Object.keys(contributor.bin)) {
+                const existing = claims.get(name);
+                if (existing === undefined)
+                    claims.set(name, [contributor]);
+                else
+                    existing.push(contributor);
+            }
+        }
+        for (const [name, claimants] of claims) {
+            if (claimants.length > 1) {
+                const origins = claimants.map((claimant) => claimant.origin).join(', ');
+                bins.delete(name);
+                for (const claimant of claimants) {
+                    issues.push({ name, origin: claimant.origin, scope: claimant.scope, message: `bare command "${name}" is claimed by ${origins} at the same precedence — no winner is selected and the name is not installed` });
+                }
+                continue;
+            }
+            const contributor = claimants[0];
+            const resolved = resolveTarget(contributor.root, contributor.bin[name]);
+            if ('reason' in resolved) {
+                issues.push({ name, origin: contributor.origin, scope: contributor.scope, message: resolved.reason });
+                continue;
+            }
+            bins.set(name, { name, target: resolved.target, origin: contributor.origin, scope: contributor.scope });
+        }
+    }
+    return { bins, issues };
+}
+/** Content address of one effective bare-command set — the shim directory's
+ *  name. Because the address covers every name and target, an existing
+ *  directory is already correct: nothing is ever rewritten in place, a changed
+ *  set simply materializes beside the old one, and two processes racing the
+ *  same set produce byte-identical trees. */
+function shimAddress(bins) {
+    const lines = [...bins.values()]
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map((bin) => `${bin.name}\u0000${bin.target}`)
+        .join('\n');
+    return createHash('sha256').update(lines).digest('hex').slice(0, 32);
+}
+/** Materialize (idempotently) the shim directory for one effective set and
+ *  return its absolute path, or null when the set is empty. Built in a staging
+ *  dir and renamed into place, so a concurrent launch either sees no directory
+ *  or sees a complete one. */
+export function ensureBinShimDir(bins) {
+    if (bins.size === 0)
+        return null;
+    const dir = join(crtrHome(), 'bin-shims', shimAddress(bins));
+    if (existsSync(dir))
+        return dir;
+    const staging = `${dir}.staging-${process.pid}-${Date.now().toString(36)}`;
+    mkdirSync(staging, { recursive: true });
+    try {
+        for (const bin of bins.values())
+            symlinkSync(bin.target, join(staging, bin.name));
+        renameSync(staging, dir);
+    }
+    catch (error) {
+        rmSync(staging, { recursive: true, force: true });
+        // Another launch materializing the same address won the rename — its tree
+        // is identical by construction, so the address is still correct.
+        if (existsSync(dir))
+            return dir;
+        throw error;
+    }
+    return dir;
+}
+/** The shim directory to prepend to a target node's PATH, or null when that
+ *  node's scopes declare no bare command. The one entry point the spawn-env
+ *  boundary calls. */
+export function binShimDirFor(targetCwd, targetProfileId) {
+    return ensureBinShimDir(resolveBinContributions(targetCwd, targetProfileId).bins);
+}

package/dist/core/runtime/broker/client-registry.d.ts

@@ -1,5 +1,9 @@
 import type { Socket } from 'node:net';
 import { FrameDecoder, type BrokerSnapshot, type BrokerToClient, type ClientRole } from '../broker-protocol.js';
+/** True when the live broker has at least one helloed terminal or web viewer.
+ *  Callers establish broker liveness separately because a crash can leave the
+ *  last persisted count behind. */
+export declare function hasAttachedBrokerViewers(nodeId: string): boolean;
 export interface BrokerClient {
     id: string;
     role: ClientRole;

package/dist/core/runtime/broker/client-registry.js

@@ -1,10 +1,22 @@
-import { existsSync, mkdirSync, unlinkSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
 import { jobDir } from '../../canvas/paths.js';
 import { emitEvent } from '../../events/emit.js';
 import { encodeFrame, FrameDecoder, BROKER_READ_CAPS, } from '../broker-protocol.js';
 /** Per-viewer outbound high-water mark. Slow viewers are shed rather than allowed to backpressure the shared engine indefinitely. */
 const MAX_QUEUED_FRAMES = 1000;
 const MAX_PENDING_BYTES = 32 * 1024 * 1024;
+/** True when the live broker has at least one helloed terminal or web viewer.
+ *  Callers establish broker liveness separately because a crash can leave the
+ *  last persisted count behind. */
+export function hasAttachedBrokerViewers(nodeId) {
+    try {
+        const record = JSON.parse(readFileSync(`${jobDir(nodeId)}/attach.json`, 'utf8'));
+        return typeof record.viewers === 'number' && record.viewers > 0;
+    }
+    catch {
+        return false;
+    }
+}
 /** Owns connected viewers, their outbound backpressure, and durable attach presence. */
 export class BrokerClientRegistry {
     nodeId;

package/dist/core/runtime/broker/extension-abort.d.ts

@@ -5,5 +5,5 @@ interface AbortableSession {
 /** Mark one synchronous ExtensionContext.abort() call as a refresh boundary. */
 export declare function runRefreshAbort(abort: () => void): void;
 /** Bound into Pi's extension context by the broker for every session generation. */
-export declare function abortSessionFromExtension(session: AbortableSession): void;
+export declare function abortSessionFromExtension(session: AbortableSession, stageRefreshAbort?: () => void): void;
 export {};

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

@@ -16,8 +16,10 @@ export function runRefreshAbort(abort) {
     }
 }
 /** Bound into Pi's extension context by the broker for every session generation. */
-export function abortSessionFromExtension(session) {
-    if (refreshAbortScope)
+export function abortSessionFromExtension(session, stageRefreshAbort) {
+    if (refreshAbortScope) {
         session.clearQueue();
+        stageRefreshAbort?.();
+    }
     void session.abort();
 }

package/dist/core/runtime/broker/fault-retry.js

@@ -48,9 +48,11 @@ export class FaultRetry {
     publishSettledProviderFault(generation) {
         const agentEnd = generation.stagedProviderAgentEnd;
         const watchdogAbort = generation.stagedWatchdogAbort;
+        const refreshAbort = generation.stagedRefreshAbort;
         const overflowFailure = generation.stagedOverflowFailure;
         generation.stagedProviderAgentEnd = null;
         generation.stagedWatchdogAbort = false;
+        generation.stagedRefreshAbort = false;
         generation.stagedOverflowFailure = null;
         const settledSession = generation.session;
         // A failed daemon retry settles here with the episode's fault marker still
@@ -84,6 +86,8 @@ export class FaultRetry {
         }
         if (last?.stopReason !== 'error')
             return;
+        if (refreshAbort)
+            return;
         const raw = typeof last.errorMessage === 'string' ? last.errorMessage : 'engine error (no errorMessage recorded)';
         const uncompactedOverflow = isContextOverflow(last, settledSession.model?.contextWindow);
         const classified = classify('pi→provider', last);

package/dist/core/runtime/broker/frame-dispatch.d.ts

@@ -181,7 +181,9 @@ export type FrameDispatchDeps = {
     toolGroups: ToolGroupTracker;
     projection: EventProjection;
     rebind: RebindDriver;
-    reviewCompanion: boolean;
+    /** The bound review id whose boundary marker opens this companion's visible
+     *  transcript; undefined for ordinary nodes. */
+    boundaryReviewId: string | undefined;
     pendingDialogs: Map<string, PendingDialog>;
     sendWelcome: (client: BrokerClient) => void;
     replayExtraPendingDialogsTo: (client: BrokerClient) => void;

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) {