@north-light/crouter 0.3.232 → 0.3.234

package/dist/core/runtime/bearings-render.js

@@ -0,0 +1,241 @@
+// bearings-render.ts — the pure rendering core shared by bearings.ts (canvas-
+// backed, warm-spare live-delivery + cron-wake lanes) and broker-extension-
+// render.ts (DTO-backed, broker-side cold-boot lane). Both lanes render
+// byte-identical bearings for a real node; this module holds every function
+// that does not need canvas.db to do it.
+//
+// No import of canvas.js/db.js/canvas/index.js — only canvas/paths.js and
+// canvas/labels.js (both already db.ts-free), substrate-free, plus node
+// builtins. This keeps broker-extension-canvas-db-boundary.test.ts's static
+// import walk green with no changes to that test.
+import { contextDir } from '../canvas/paths.js';
+import { fullName } from '../canvas/labels.js';
+import { tmuxSessionsReachable } from './tmux-driver.js';
+import { spawnSync } from 'node:child_process';
+import { readdirSync } from 'node:fs';
+import { hostname } from 'node:os';
+import { loadProfileManifest } from '../profiles/manifest.js';
+export function escapeAttribute(value) {
+    return value.replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+}
+/** A one-line snapshot of the host/runtime the node's engine is executing in —
+ *  platform, hostname, node version, and whether a tmux server is reachable.
+ *  The engine is headless, so this reflects the broker/daemon environment the
+ *  node's own bash tools inherit — NOT a viewer pane.
+ *
+ *  The tmux bit deliberately reports SERVER REACHABILITY, not "am I inside a
+ *  tmux pane" — the latter is a constant `no` for every node and so tells the
+ *  agent nothing: a broker is detached and paneless, and DELETES $TMUX /
+ *  $TMUX_PANE from its env on boot (broker.ts) so its children never act on the
+ *  launching parent's pane. The actionable question is whether this process's
+ *  bash tools can drive tmux at all, and `tmuxSessionsReachable()` exits 0 iff
+ *  a server is running with at least one session. The label says `tmux server`
+ *  so it cannot be misread as pane residency. */
+function runtimeLine() {
+    const tmuxServer = tmuxSessionsReachable();
+    const parts = [
+        `${process.platform} ${process.arch}`,
+        hostname(),
+        `node ${process.version}`,
+        `tmux server: ${tmuxServer ? 'reachable' : 'none'}`,
+    ];
+    return `Host: ${parts.join(' · ')}`;
+}
+function directoryListingLines(cwd) {
+    try {
+        const entries = readdirSync(cwd, { withFileTypes: true });
+        const sorted = entries.sort((a, b) => {
+            if (a.isDirectory() !== b.isDirectory())
+                return a.isDirectory() ? -1 : 1;
+            return a.name.localeCompare(b.name);
+        });
+        const shown = sorted.slice(0, 50).map((entry) => `${entry.name}${entry.isDirectory() ? '/' : ''}`);
+        const hidden = sorted.length - shown.length;
+        return hidden > 0 ? [...shown, `[+${hidden} more]`] : shown;
+    }
+    catch {
+        return ['Directory listing: unavailable (cwd missing or unreadable).'];
+    }
+}
+function runCommand(cwd, cmd, args) {
+    const result = spawnSync(cmd, args, { cwd, encoding: 'utf8' });
+    if (result.error !== undefined) {
+        return { ok: false, stdout: '', stderr: result.error.message };
+    }
+    return {
+        ok: result.status === 0,
+        stdout: (result.stdout ?? '').trim(),
+        stderr: (result.stderr ?? '').trim(),
+    };
+}
+function runGit(cwd, args) {
+    const result = runCommand(cwd, 'git', args);
+    return result.ok ? result.stdout : '';
+}
+function parseWorktrees(lines) {
+    const worktrees = [];
+    let cur = {};
+    for (const line of lines) {
+        if (line.startsWith('worktree ')) {
+            if (cur.path !== undefined) {
+                worktrees.push({ path: cur.path, branch: cur.branch ?? 'detached HEAD' });
+            }
+            cur = { path: line.slice('worktree '.length) };
+        }
+        else if (line.startsWith('branch ')) {
+            cur.branch = line.slice('branch '.length).replace(/^refs\/heads\//, '');
+        }
+    }
+    if (cur.path !== undefined) {
+        worktrees.push({ path: cur.path, branch: cur.branch ?? 'detached HEAD' });
+    }
+    return worktrees;
+}
+/** The git status/worktree snapshot lines. The initial probe distinguishes a
+ *  genuine non-repo (`not a git repository` in stderr) from any other failure
+ *  (spawn error, permission, a hung/killed process) — collapsing both into
+ *  "not a git repository" would mislabel a real outage as a documented,
+ *  benign state. Every other probe here is genuinely optional and already
+ *  falls back to 'unknown'/'HEAD'/a zero count on failure, which stays as-is. */
+function gitSnapshotLines(cwd) {
+    const probe = runCommand(cwd, 'git', ['rev-parse', '--is-inside-work-tree']);
+    if (!probe.ok) {
+        if (/not a git repository/i.test(probe.stderr)) {
+            return ['Git: not a git repository.'];
+        }
+        return [`Git: unavailable (${probe.stderr || 'git command failed'}).`];
+    }
+    const branch = runGit(cwd, ['branch', '--show-current']) || runGit(cwd, ['rev-parse', '--abbrev-ref', 'HEAD']) || 'HEAD';
+    const sha = runGit(cwd, ['rev-parse', '--short', 'HEAD']) || 'unknown';
+    const statusCount = runGit(cwd, ['status', '--porcelain'])
+        .split('\n')
+        .filter((line) => line !== '').length;
+    const worktreeLines = runGit(cwd, ['worktree', 'list', '--porcelain']).split('\n');
+    const worktrees = parseWorktrees(worktreeLines);
+    const dirty = statusCount === 0 ? 'clean' : `${statusCount} uncommitted change${statusCount === 1 ? '' : 's'}`;
+    const summary = `Git: ${branch} @ ${sha}; ${dirty}; ${worktrees.length} worktree${worktrees.length === 1 ? '' : 's'}.`;
+    const worktreeSummary = worktrees.length === 0
+        ? 'Worktrees: none.'
+        : `Worktrees: ${worktrees.map((w) => `${w.path} (${w.branch})`).join(', ')}`;
+    return [summary, worktreeSummary];
+}
+/** The `<project_context>` block — the `<environment>` snapshot only: a
+ *  host/runtime line (platform, hostname, node version, tmux-or-not — the
+ *  headless engine's own process env, which its bash tools inherit), the cwd
+ *  dir listing, and git status/worktrees. Project guidance lives in the
+ *  document substrate, so this wrapper stays environment-only. It always emits
+ *  because the environment snapshot is always present. */
+export function buildProjectContextBlock(cwd) {
+    const envLines = directoryListingLines(cwd);
+    const gitLines = gitSnapshotLines(cwd);
+    let out = '<project_context>\n\n';
+    out += `<environment cwd="${escapeAttribute(cwd)}">\n`;
+    out += `${runtimeLine()}\n`;
+    out += `Directory:\n${envLines.map((line) => `  ${line}`).join('\n')}\n`;
+    out += `${gitLines.map((line) => `${line}`).join('\n')}\n`;
+    out += '</environment>\n</project_context>';
+    return out;
+}
+/** The context-directory note — names the path INLINE (no XML attribute, so it
+ *  never scopes a sibling block) and frames the dir as durable, shared scratch.
+ *  Present for every node, rendered as the `## Your context directory`
+ *  subsection of <crtr-bearings>. */
+export function contextDirNote(nodeId) {
+    return (`Your context directory is \`${contextDir(nodeId)}\` (also in the env as \`$CRTR_CONTEXT_DIR\`) — ` +
+        'durable scratch space on disk, and the one place the other nodes on the canvas can read from. ' +
+        'Put documents here that you want to share by reference instead of re-explaining them in a ' +
+        'prompt: specs, designs, findings, notes worth pointing a sibling, child, or parent at. It is a ' +
+        'shared document store, not a task tracker. **Address it by absolute path** — write artifacts as ' +
+        '`$CRTR_CONTEXT_DIR/<name>.md` (or the full path above). Your working dir is the project, NOT ' +
+        'this directory, so a bare relative `context/...` lands in the repo, not here — and other nodes ' +
+        'can only read what is actually here. When you report a file, report its absolute path.');
+}
+/** The profile-purview note — rendered ONLY when the profile resolves to a
+ *  manifest that names at least one project dir. Phrased as PURVIEW, not a cwd
+ *  replacement: the node's cwd is still its one working dir (bash/edits run
+ *  there), the profile just widens what it may ALSO read/act on. Omitted
+ *  entirely for a profile with no project purview (including the stable root
+ *  profile) or a deleted/unreadable manifest — never throws. This absolute-path
+ *  disclosure is intentional (spec-approved): the agent must know its full
+ *  purview, not a redacted count. */
+export function profileNote(cwd, profileId) {
+    if (profileId === undefined || profileId === null || profileId === '')
+        return '';
+    let entry;
+    try {
+        entry = loadProfileManifest(profileId);
+    }
+    catch {
+        return '';
+    }
+    const projects = entry.manifest.projects.map((project) => project.path);
+    if (projects.length === 0)
+        return '';
+    return (`Your working dir is \`${cwd}\`. Your profile **${entry.manifest.name}** also has purview ` +
+        `over: ${projects.join(', ')}.`);
+}
+/** Orchestrator-only framing: a resident orchestrator survives refresh cycles,
+ *  so its context dir is also where a future cycle of itself resumes the work.
+ *  Used inside the bearings block AND in the promotion guidance dump, so a
+ *  promoted node gets the same note a born-orchestrator gets. */
+export function orchestratorContextNote(nodeId) {
+    return (`Because you persist across refresh cycles, your context directory (${contextDir(nodeId)}) is ` +
+        `also where a future cycle of you resumes the work — keep the working notes and decisions a ` +
+        `refreshed you would need there, alongside the docs you share with the nodes you spawn.`);
+}
+/** One relative's line in the map: `<id> — <kind> · <status>`, plus the node's
+ *  task description when it carries one (orientation: what that relative is for). */
+export function relativeLabel(node) {
+    const desc = fullName(node);
+    const descPart = desc !== '' && desc !== node.kind && desc !== node.name ? ` — ${desc}` : '';
+    return `${node.node_id} (${node.kind} · ${node.status})${descPart}`;
+}
+/** Most children listed in the mini-map before the rest collapse to `+N more`. */
+const MAX_CHILDREN_SHOWN = 5;
+/** The graph mini-map: the ancestry trunk (root first), then this node marked
+ *  `● you`, then its immediate children. Returns '' for a lone root with no
+ *  children (nothing to map). */
+export function renderGraphMap(nodeId, kind, mode, trunk, children) {
+    if (trunk.length === 0 && children.length === 0)
+        return '';
+    const indent = (depth) => '  '.repeat(depth);
+    const lines = [
+        'Your place in the canvas graph (ancestry above you, your direct children below):',
+    ];
+    trunk.forEach((m, i) => {
+        lines.push(`${indent(i)}${i === 0 ? '' : '└ '}${relativeLabel(m)}`);
+    });
+    const selfDepth = trunk.length;
+    lines.push(`${indent(selfDepth)}${selfDepth === 0 ? '' : '└ '}● you: ${nodeId} (${kind}, ${mode})`);
+    // Cap the child list so a wide fan-out can't flood the boot context. Children
+    // are sorted live-first, so the shown slice favors active nodes; the rest
+    // collapse to a `+N more` tail (active-first ordering means anything elided is
+    // the most-finished work).
+    const shown = children.slice(0, MAX_CHILDREN_SHOWN);
+    const hidden = children.length - shown.length;
+    shown.forEach((m, i) => {
+        const last = i === shown.length - 1 && hidden === 0;
+        lines.push(`${indent(selfDepth + 1)}${last ? '└ ' : '├ '}${relativeLabel(m)}`);
+    });
+    if (hidden > 0) {
+        lines.push(`${indent(selfDepth + 1)}└ +${hidden} more`);
+    }
+    return lines.join('\n');
+}
+/** The identity assertion injected at session start. A fork names its source
+ *  while treating the copied first-person narrative as reference. The caller
+ *  resolves `sourceLabel`: the bare `forkFrom` id when the source lookup
+ *  fails/is unsafe, else `${forkFrom} ("${fullName(src)}")`. */
+export function buildIdentityAssertion(nodeId, kind, mode, forkFrom, sourceLabel) {
+    const lines = [`You are node ${nodeId} — kind ${kind}, mode ${mode}.`];
+    if (forkFrom !== undefined && forkFrom !== null && forkFrom !== '') {
+        lines.push('', `You are a new FORK of ${sourceLabel}, not ${sourceLabel}. Pi copied the earlier conversation ` +
+            `into this session. Treat that first-person history as reference material, not your own past.`);
+    }
+    return lines.join('\n');
+}
+export function worktreeNote(worktree) {
+    if (worktree?.state !== 'open')
+        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.`;
+}

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

@@ -1,19 +1,9 @@
 import { type Cron } from '../canvas/index.js';
 import type { ExposureTarget } from '../substrate/injected-store.js';
+import { buildProjectContextBlock, contextDirNote, orchestratorContextNote } from './bearings-render.js';
 /** The bearings custom type is shared with every attached renderer. */
 export { CONTEXT_INTRO_CUSTOM_TYPE } from '../../shared/generated-context.js';
-/** The `<project_context>` block — the `<environment>` snapshot only: a
- *  host/runtime line (platform, hostname, node version, tmux-or-not — the
- *  headless engine's own process env, which its bash tools inherit), the cwd
- *  dir listing, and git status/worktrees. Project guidance lives in the
- *  document substrate, so this wrapper stays environment-only. It always emits
- *  because the environment snapshot is always present. Exported for testing. */
-export declare function buildProjectContextBlock(cwd: string): string;
-/** The context-directory note — names the path INLINE (no XML attribute, so it
- *  never scopes a sibling block) and frames the dir as durable, shared scratch.
- *  Present for every node, rendered as the `## Your context directory`
- *  subsection of <crtr-bearings>. */
-export declare function contextDirNote(nodeId: string): string;
+export { buildProjectContextBlock, contextDirNote, orchestratorContextNote };
 /** The profile-purview note — rendered ONLY when `profile_id` resolves to a
  *  manifest that names at least one project dir. Phrased as PURVIEW, not a cwd
  *  replacement: the node's cwd is still its one working dir (bash/edits run
@@ -24,11 +14,6 @@ export declare function contextDirNote(nodeId: string): string;
  *  is intentional (spec-approved): the agent must know its full purview, not a
  *  redacted count. */
 export declare function profileNote(nodeId: string): string;
-/** Orchestrator-only framing: a resident orchestrator survives refresh cycles,
- *  so its context dir is also where a future cycle of itself resumes the work.
- *  Used inside the bearings block AND in the promotion guidance dump, so a
- *  promoted node gets the same note a born-orchestrator gets. */
-export declare function orchestratorContextNote(nodeId: string): string;
 /** The graph mini-map: the ancestry trunk (root first), then this node marked
  *  `● you`, then its immediate children. Returns '' for a lone root with no
  *  children (nothing to map). Exported for testing. */

package/dist/core/runtime/bearings.js

@@ -10,139 +10,15 @@
 //
 // promote.ts separately delivers orchestratorContextNote() when a base node
 // becomes an orchestrator after birth.
-import { contextDir, getNode, fullName, isSafeNodeId, subscriptionsOf, } from '../canvas/index.js';
-import { execSync } from 'node:child_process';
-import { readdirSync } from 'node:fs';
-import { spawnSync } from 'node:child_process';
-import { hostname } from 'node:os';
+import { getNode, fullName, isSafeNodeId, subscriptionsOf, } from '../canvas/index.js';
 import { cadenceDisplay } from '../wake.js';
 import { renderKnowledgeBlock, renderWorkspaceOpenDocs } from '../substrate/index.js';
-import { loadProfileManifest } from '../profiles/manifest.js';
 import { situationalContextEnvelope } from './situational-context.js';
 import { statusRank } from '../canvas/node-order.js';
+import { buildProjectContextBlock, contextDirNote, orchestratorContextNote, profileNote as profileNoteShared, renderGraphMap, buildIdentityAssertion as buildIdentityAssertionShared, worktreeNote, } from './bearings-render.js';
 /** The bearings custom type is shared with every attached renderer. */
 export { CONTEXT_INTRO_CUSTOM_TYPE } from '../../shared/generated-context.js';
-function escapeAttribute(value) {
-    return value.replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
-}
-/** A one-line snapshot of the host/runtime the node's engine is executing in —
- *  platform, hostname, node version, and whether a tmux server is reachable.
- *  The engine is headless, so this reflects the broker/daemon environment the
- *  node's own bash tools inherit — NOT a viewer pane.
- *
- *  The tmux bit deliberately reports SERVER REACHABILITY, not "am I inside a
- *  tmux pane" — the latter is a constant `no` for every node and so tells the
- *  agent nothing: a broker is detached and paneless, and DELETES $TMUX /
- *  $TMUX_PANE from its env on boot (broker.ts) so its children never act on the
- *  launching parent's pane. The actionable question is whether this process's
- *  bash tools can drive tmux at all, and `tmux list-sessions` exits 0 iff a
- *  server is running. The label says `tmux server` so it cannot be misread as
- *  pane residency. */
-function runtimeLine() {
-    const tmuxServer = spawnSync('tmux', ['list-sessions'], { encoding: 'utf8', stdio: 'ignore' }).status === 0;
-    const parts = [
-        `${process.platform} ${process.arch}`,
-        hostname(),
-        `node ${process.version}`,
-        `tmux server: ${tmuxServer ? 'reachable' : 'none'}`,
-    ];
-    return `Host: ${parts.join(' · ')}`;
-}
-function directoryListingLines(cwd) {
-    try {
-        const entries = readdirSync(cwd, { withFileTypes: true });
-        const sorted = entries.sort((a, b) => {
-            if (a.isDirectory() !== b.isDirectory())
-                return a.isDirectory() ? -1 : 1;
-            return a.name.localeCompare(b.name);
-        });
-        const shown = sorted.slice(0, 50).map((entry) => `${entry.name}${entry.isDirectory() ? '/' : ''}`);
-        const hidden = sorted.length - shown.length;
-        return hidden > 0 ? [...shown, `[+${hidden} more]`] : shown;
-    }
-    catch {
-        return ['Directory listing: unavailable (cwd missing or unreadable).'];
-    }
-}
-function gitSnapshot(cwd) {
-    try {
-        execSync('git rev-parse --is-inside-work-tree', { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
-    }
-    catch {
-        return { lines: ['Git: not a git repository.'] };
-    }
-    const branch = runGit(cwd, 'git branch --show-current') || runGit(cwd, 'git rev-parse --abbrev-ref HEAD') || 'HEAD';
-    const sha = runGit(cwd, 'git rev-parse --short HEAD') || 'unknown';
-    const statusCount = runGit(cwd, 'git status --porcelain')
-        .split('\n')
-        .filter((line) => line !== '').length;
-    const worktreeLines = runGit(cwd, 'git worktree list --porcelain').split('\n');
-    const worktrees = parseWorktrees(worktreeLines);
-    const dirty = statusCount === 0 ? 'clean' : `${statusCount} uncommitted change${statusCount === 1 ? '' : 's'}`;
-    const summary = `Git: ${branch} @ ${sha}; ${dirty}; ${worktrees.length} worktree${worktrees.length === 1 ? '' : 's'}.`;
-    const worktreeSummary = worktrees.length === 0
-        ? 'Worktrees: none.'
-        : `Worktrees: ${worktrees.map((w) => `${w.path} (${w.branch})`).join(', ')}`;
-    return { lines: [summary, worktreeSummary] };
-}
-function runGit(cwd, command) {
-    try {
-        return execSync(command, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
-    }
-    catch {
-        return '';
-    }
-}
-function parseWorktrees(lines) {
-    const worktrees = [];
-    let cur = {};
-    for (const line of lines) {
-        if (line.startsWith('worktree ')) {
-            if (cur.path !== undefined) {
-                worktrees.push({ path: cur.path, branch: cur.branch ?? 'detached HEAD' });
-            }
-            cur = { path: line.slice('worktree '.length) };
-        }
-        else if (line.startsWith('branch ')) {
-            cur.branch = line.slice('branch '.length).replace(/^refs\/heads\//, '');
-        }
-    }
-    if (cur.path !== undefined) {
-        worktrees.push({ path: cur.path, branch: cur.branch ?? 'detached HEAD' });
-    }
-    return worktrees;
-}
-/** The `<project_context>` block — the `<environment>` snapshot only: a
- *  host/runtime line (platform, hostname, node version, tmux-or-not — the
- *  headless engine's own process env, which its bash tools inherit), the cwd
- *  dir listing, and git status/worktrees. Project guidance lives in the
- *  document substrate, so this wrapper stays environment-only. It always emits
- *  because the environment snapshot is always present. Exported for testing. */
-export function buildProjectContextBlock(cwd) {
-    const envLines = directoryListingLines(cwd);
-    const git = gitSnapshot(cwd);
-    let out = '<project_context>\n\n';
-    out += `<environment cwd="${escapeAttribute(cwd)}">\n`;
-    out += `${runtimeLine()}\n`;
-    out += `Directory:\n${envLines.map((line) => `  ${line}`).join('\n')}\n`;
-    out += `${git.lines.map((line) => `${line}`).join('\n')}\n`;
-    out += '</environment>\n</project_context>';
-    return out;
-}
-/** The context-directory note — names the path INLINE (no XML attribute, so it
- *  never scopes a sibling block) and frames the dir as durable, shared scratch.
- *  Present for every node, rendered as the `## Your context directory`
- *  subsection of <crtr-bearings>. */
-export function contextDirNote(nodeId) {
-    return (`Your context directory is \`${contextDir(nodeId)}\` (also in the env as \`$CRTR_CONTEXT_DIR\`) — ` +
-        'durable scratch space on disk, and the one place the other nodes on the canvas can read from. ' +
-        'Put documents here that you want to share by reference instead of re-explaining them in a ' +
-        'prompt: specs, designs, findings, notes worth pointing a sibling, child, or parent at. It is a ' +
-        'shared document store, not a task tracker. **Address it by absolute path** — write artifacts as ' +
-        '`$CRTR_CONTEXT_DIR/<name>.md` (or the full path above). Your working dir is the project, NOT ' +
-        'this directory, so a bare relative `context/...` lands in the repo, not here — and other nodes ' +
-        'can only read what is actually here. When you report a file, report its absolute path.');
-}
+export { buildProjectContextBlock, contextDirNote, orchestratorContextNote };
 /** The profile-purview note — rendered ONLY when `profile_id` resolves to a
  *  manifest that names at least one project dir. Phrased as PURVIEW, not a cwd
  *  replacement: the node's cwd is still its one working dir (bash/edits run
@@ -154,44 +30,14 @@ export function contextDirNote(nodeId) {
  *  redacted count. */
 export function profileNote(nodeId) {
     const meta = getNode(nodeId);
-    const profileId = meta?.profile_id;
-    if (profileId === undefined || profileId === null || profileId === '')
-        return '';
-    let entry;
-    try {
-        entry = loadProfileManifest(profileId);
-    }
-    catch {
-        return '';
-    }
-    const projects = entry.manifest.projects.map((project) => project.path);
-    if (projects.length === 0)
+    if (meta === null)
         return '';
-    return (`Your working dir is \`${meta.cwd}\`. Your profile **${entry.manifest.name}** also has purview ` +
-        `over: ${projects.join(', ')}.`);
-}
-/** Orchestrator-only framing: a resident orchestrator survives refresh cycles,
- *  so its context dir is also where a future cycle of itself resumes the work.
- *  Used inside the bearings block AND in the promotion guidance dump, so a
- *  promoted node gets the same note a born-orchestrator gets. */
-export function orchestratorContextNote(nodeId) {
-    return (`Because you persist across refresh cycles, your context directory (${contextDir(nodeId)}) is ` +
-        `also where a future cycle of you resumes the work — keep the working notes and decisions a ` +
-        `refreshed you would need there, alongside the docs you share with the nodes you spawn.`);
+    return profileNoteShared(meta.cwd, meta.profile_id);
 }
-// ---------------------------------------------------------------------------
 // Graph mini-map — the node's place in the canvas, rendered into the identity
 // block so a node boots oriented: who is above it (its ancestry trunk, root
 // first) and who is directly below it (its immediate children + their statuses).
 // Not the full subtree — just the load-bearing spine up and one level down.
-// ---------------------------------------------------------------------------
-/** One relative's line in the map: `<id> — <kind> · <status>`, plus the node's
- *  task description when it carries one (orientation: what that relative is for). */
-function relativeLabel(meta) {
-    const desc = fullName(meta);
-    const descPart = desc !== '' && desc !== meta.kind && desc !== meta.name ? ` — ${desc}` : '';
-    return `${meta.node_id} (${meta.kind} · ${meta.status})${descPart}`;
-}
 /** Ancestry trunk from the root DOWN to (but excluding) `nodeId`, climbing the
  *  spine `parent` edge. Cycle-guarded. Root first. */
 function ancestorTrunk(nodeId) {
@@ -227,47 +73,18 @@ export function buildGraphMap(nodeId) {
         return '';
     const trunk = ancestorTrunk(nodeId);
     const children = childNodes(nodeId);
-    if (trunk.length === 0 && children.length === 0)
-        return '';
-    const indent = (depth) => '  '.repeat(depth);
-    const lines = [
-        'Your place in the canvas graph (ancestry above you, your direct children below):',
-    ];
-    trunk.forEach((m, i) => {
-        lines.push(`${indent(i)}${i === 0 ? '' : '└ '}${relativeLabel(m)}`);
-    });
-    const selfDepth = trunk.length;
-    lines.push(`${indent(selfDepth)}${selfDepth === 0 ? '' : '└ '}● you: ${nodeId} (${meta.kind}, ${meta.mode})`);
-    // Cap the child list so a wide fan-out can't flood the boot context. Children
-    // are sorted live-first, so the shown slice favors active nodes; the rest
-    // collapse to a `+N more` tail (active-first ordering means anything elided is
-    // the most-finished work).
-    const shown = children.slice(0, MAX_CHILDREN_SHOWN);
-    const hidden = children.length - shown.length;
-    shown.forEach((m, i) => {
-        const last = i === shown.length - 1 && hidden === 0;
-        lines.push(`${indent(selfDepth + 1)}${last ? '└ ' : '├ '}${relativeLabel(m)}`);
-    });
-    if (hidden > 0) {
-        lines.push(`${indent(selfDepth + 1)}└ +${hidden} more`);
-    }
-    return lines.join('\n');
+    return renderGraphMap(nodeId, meta.kind, meta.mode, trunk, children);
 }
 /** The identity assertion injected at session start. A fork names its source
  *  while treating the copied first-person narrative as reference. */
 function buildIdentityAssertion(nodeId) {
     const meta = getNode(nodeId);
-    const lines = [`You are node ${nodeId} — kind ${meta?.kind ?? 'general'}, mode ${meta?.mode ?? 'base'}.`];
     const forkFrom = meta?.fork_from;
-    if (forkFrom !== undefined && forkFrom !== null && forkFrom !== '') {
-        // A known node id carries its human label. Paths and session ids remain
-        // opaque provenance rather than being passed to the node-id lookup.
-        const src = isSafeNodeId(forkFrom) ? getNode(forkFrom) : null;
-        const sourceLabel = src !== null ? `${forkFrom} ("${fullName(src)}")` : forkFrom;
-        lines.push('', `You are a new FORK of ${sourceLabel}, not ${sourceLabel}. Pi copied the earlier conversation ` +
-            `into this session. Treat that first-person history as reference material, not your own past.`);
-    }
-    return lines.join('\n');
+    // A known node id carries its human label. Paths and session ids remain
+    // opaque provenance rather than being passed to the node-id lookup.
+    const src = forkFrom !== undefined && forkFrom !== null && forkFrom !== '' && isSafeNodeId(forkFrom) ? getNode(forkFrom) : null;
+    const sourceLabel = src !== null ? `${forkFrom} ("${fullName(src)}")` : (forkFrom ?? '');
+    return buildIdentityAssertionShared(nodeId, meta?.kind ?? 'general', meta?.mode ?? 'base', forkFrom, sourceLabel);
 }
 /** The armer rendered for prose, ROLE-explicit so a newborn never mistakes the
  *  id for its own: `node <id> ("<name>")` when the name resolved, `node <id>
@@ -325,10 +142,7 @@ export function buildWakeBearings(origin) {
     return `<crtr-wake>\n${body}\n</crtr-wake>`;
 }
 function managedWorktreeNote(node) {
-    const wt = node?.managed_worktree;
-    if (wt?.state !== 'open')
-        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.`;
+    return worktreeNote(node?.managed_worktree);
 }
 /** The full boot intro, four top-level sections:
  *

package/dist/core/runtime/broker/auth-reload.d.ts

@@ -0,0 +1,39 @@
+import type { AgentSessionServices, ModelRegistry } from '@earendil-works/pi-coding-agent';
+import type { BrokerSdkConfig } from '../launch.js';
+import type { BrokerClient } from './client-registry.js';
+import type { FrameReplies } from './frame-replies.js';
+import type { RebindDriver } from './rebind.js';
+import type { BrokerSession } from './read-ops.js';
+type ResolvedLaunchModel = {
+    model: NonNullable<ReturnType<ModelRegistry['find']>>;
+    thinkingLevel: string | undefined;
+} | undefined;
+/**
+ * The `reload_auth` frame and the two pieces of work it starts: a model
+ * reconcile against freshly re-read credentials, and — when this node is
+ * sitting on a recorded provider auth fault — a rewind-and-redrive of the turn
+ * that fault killed. Owns the in-flight state both need so a burst of
+ * canvas-wide /login fans collapses into one reconcile per generation.
+ */
+export type AuthReloadGate = {
+    /** The in-flight reconcile an idle prompt must not overtake, if any. */
+    inFlight(): Promise<void> | undefined;
+    /** Handle a `reload_auth` frame. Open to any client, observers included. */
+    handle(client: BrokerClient): void;
+    /** A session replacement invalidates the reconcile the old one was waiting on. */
+    resetForSession(): void;
+};
+export declare function createAuthReloadGate(deps: {
+    nodeId: string;
+    cfg: BrokerSdkConfig;
+    replies: FrameReplies;
+    rebind: RebindDriver;
+    session: () => BrokerSession;
+    services: () => AgentSessionServices;
+    broadcastModelChanged: (persist?: boolean, pinnedOverride?: boolean, userSelected?: boolean) => Promise<void>;
+    formatModelSpec: (model: BrokerSession['model'], thinkingLevel?: string) => string | null;
+    resolveLaunchModel: (services: AgentSessionServices, cfg: BrokerSdkConfig) => Promise<ResolvedLaunchModel>;
+    /** A reconcile that finally resolves a model releases the held launch prompt. */
+    driveKickoff: () => void;
+}): AuthReloadGate;
+export {};