@north-light/crouter 0.3.170 → 0.3.172

package/dist/core/runtime/naming.js

@@ -3,30 +3,25 @@
 //
 // A node's editor label is `<mode-icon> <name> <kind>` (see editorLabel in
 // labels.ts). The `<name>` is a 3-8 word kebab-case "description" derived from
-// the first prompt by asking pi headlessly (`pi -p`), persisted on the node's
-// meta so it survives revives and updates the live session name.
+// the first prompt by asking Pi headlessly, persisted on the node's meta so it
+// survives revives and updates the live session name.
 //
 // The namer returns a STRUCTURED result — {name, icon} — produced by constrained
-// sampling against the `name_session` tool in `pi-extensions/naming-tool.ts`,
-// not by parsing prose. The icon is a Nerd Font glyph the model picks freely
+// sampling through the one-shot `name_session` tool, not by parsing prose. The
+// icon is a Nerd Font glyph the model picks freely
 // (guided by example blocks, not a closed enum) and is stored as its own meta
 // field, so each surface decides whether to render it.
 //
-// One entry point: generateAndPersistName — async (execFile, non-blocking).
+// One entry point: generateAndPersistName — async and non-blocking.
 // Naming happens INSIDE the named node's own pi process, off the first real
 // message (the kickoff task or a human's first line), never on the spawn path:
-// blocking spawn on an LLM round-trip used to freeze the caller's terminal for
-// 2-3s on every `crtr node new`. The headless namer runs with --no-extensions,
-// so it loads no canvas hooks and can never recurse into another spawn/name.
+// the one-shot runs asynchronously, so it delays only its eventual label. The
+// headless namer loads only provider rotation, so it carries no canvas hooks and
+// cannot recurse into spawn/name.
 //
 // Best-effort: a failed/slow/garbled pi call falls back to a local slug of the
 // prompt, so a node always gets a sane name.
-import { execFile } from 'node:child_process';
-import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { bundledPiSubprocessEnv, resolveBundledPiCliPath } from './pi-cli.js';
-import { NAMING_TOOL_PATH } from './canvas-extensions.js';
+import { headlessText, headlessToolCall } from './headless-pi.js';
 import { defaultProvider, modelLadders, stripThinkingSuffix } from './model-selection.js';
 /** Cap on prompt text fed to the namer — a name needs only the gist. */
 const PROMPT_CAP = 2000;
@@ -76,12 +71,12 @@ const NAME_SYSTEM_PROMPT = 'You name coding-agent work sessions. The name is a l
     'is actually about something.\n\n' +
     'Generic fallback set, by kind of work:\n' +
     ICON_EXAMPLES;
-/** Put the raw task text FIRST in a delimited block, then the instruction, so the
- *  model reads the content before being told what to do and never mistakes the
- *  prompt's own text for the instruction. The prompt is capped first, so the
- *  closing tag is always present. */
-function nameUserPrompt(prompt) {
-    return `<prompt>\n${prompt.slice(0, PROMPT_CAP)}\n</prompt>\n\nName this session based on the task above, and pick an icon depicting it. Call \`name_session\` once, then stop.`;
+/** Put the source text FIRST in a delimited block, then the instruction, so the
+ *  model reads the work before being told what to do and never mistakes source
+ *  text for the instruction. The source is capped first, so the closing tag is
+ *  always present. */
+function nameUserPrompt(source, sourceCap = PROMPT_CAP) {
+    return `<source>\n${source.slice(0, sourceCap)}\n</source>\n\nName this session based on the work described above, and pick an icon depicting it. Call \`name_session\` once, then stop.`;
 }
 /** A short stop-word set so the local-slug fallback skips filler words. */
 const STOPWORDS = new Set([
@@ -114,63 +109,43 @@ export function slugFromPrompt(prompt) {
     return sanitizeSessionName(picked.join('-')) || 'session';
 }
 /** The namer's model: the `light` rung of the DEFAULT provider's ladder, with
- *  any thinking suffix stripped (we pass `--thinking off` explicitly — naming is
- *  a trivial classification that never needs a reasoning budget). Reading the
- *  ladder rather than pinning a concrete model id keeps naming working for a
+ *  any thinking suffix stripped because the one-shot session uses thinking off.
+ *  Reading the ladder rather than pinning a concrete model id keeps naming working for a
  *  user who never configured Anthropic: an OpenAI default provider resolves to
  *  its own light rung. `CRTR_NAME_MODEL` still overrides. */
-function nameModel() {
-    const override = process.env['CRTR_NAME_MODEL'];
+export function lightModel(overrideEnv) {
+    const override = overrideEnv === undefined ? undefined : process.env[overrideEnv];
     if (override !== undefined && override.trim() !== '')
         return override.trim();
     const ladders = modelLadders();
     return stripThinkingSuffix(ladders[defaultProvider(ladders)].light);
 }
-/** The pi argv for a headless TEXT request (issue titles). Stripped down (no
- *  tools, session, context files, extensions, skills, templates, themes) so
- *  it's fast and side-effect free. */
-function piTextArgs(systemPrompt, userPrompt) {
-    const model = nameModel();
-    return [
-        '-p',
-        '--no-session',
-        '--no-context-files',
-        '--no-extensions',
-        '--no-skills',
-        '--no-prompt-templates',
-        '--no-themes',
-        '--no-tools',
-        '--mode', 'text',
-        // A trivial one-line classification — no thinking budget, ever.
-        '--thinking', 'off',
-        '--model', model,
-        '--system-prompt', systemPrompt,
-        userPrompt,
-    ];
-}
-/** The pi argv for a headless STRUCTURED name request: same stripped-down run,
- *  but with the naming tool loaded explicitly (`-e` still works under
- *  `--no-extensions`) and the tool allowlist narrowed to it, so the model's only
- *  possible action is one constrained-schema emission. */
-function nameArgs(prompt) {
-    return [
-        '-p',
-        '--no-session',
-        '--no-context-files',
-        '--no-extensions',
-        '--no-skills',
-        '--no-prompt-templates',
-        '--no-themes',
-        '-e', NAMING_TOOL_PATH,
-        '--tools', 'name_session',
-        '--mode', 'text',
-        // A trivial one-shot classification — no thinking budget, ever.
-        '--thinking', 'off',
-        '--model', nameModel(),
-        '--system-prompt', NAME_SYSTEM_PROMPT,
-        nameUserPrompt(prompt),
-    ];
+function nameModelRequest() {
+    const override = process.env['CRTR_NAME_MODEL'];
+    if (override !== undefined && override.trim() !== '')
+        return { modelSpec: override.trim() };
+    const ladders = modelLadders();
+    const provider = defaultProvider(ladders);
+    return {
+        modelSpec: stripThinkingSuffix(ladders[provider].light),
+        modelIntent: `${provider}/light`,
+    };
 }
+const NAME_SESSION_SCHEMA = {
+    type: 'object',
+    properties: {
+        name: {
+            type: 'string',
+            description: 'A 3-8 word kebab-case session name: lowercase words joined by single hyphens, e.g. refactor-auth-token-flow. No punctuation, quotes, or prose.',
+        },
+        icon: {
+            type: 'string',
+            description: 'The Nerd Font glyph depicting this session, as a codepoint in U+XXXX form (e.g. U+F188).',
+        },
+    },
+    required: ['name', 'icon'],
+    additionalProperties: false,
+};
 /** Normalize a model-supplied icon to a single renderable glyph, or '' when
  *  nothing usable came back.
  *
@@ -206,64 +181,41 @@ export function sanitizeIcon(raw) {
         return '';
     return points[0].codePointAt(0) >= 0x2000 ? trimmed : '';
 }
-/** Ask pi headlessly for a structured {name, icon} for `body`, async. Resolves
- *  to a sanitized SessionName, or `{name:'',icon:''}` on any failure (non-zero
- *  exit, timeout, no tool call, garbled emission) so the caller can fall back to
- *  a local slug. Owns the subprocess mechanics — crucially it hands pi an
- *  immediate stdin EOF: `pi -p` reads stdin, and execFile's default stdin is an
- *  OPEN pipe that never closes, so without this pi blocks waiting for EOF and
- *  the call exits non-zero (the regression that silently lost every LLM name to
- *  the slug fallback).
+/** Ask Pi headlessly for a structured {name, icon} for `body`, async. Resolves
+ *  to a sanitized SessionName, or `{name:'',icon:''}` on timeout, a missing tool
+ *  call, or a malformed emission so the caller can fall back to a local slug.
  *
  *  Exported (not just for tests): the canvas-coupled persistence wrapper
  *  generateAndPersistName lives in naming-persist.ts to keep this module
  *  canvas-free, and imports this pure helper. */
-export function headlessName(body) {
+export async function headlessName(body, sourceCap = PROMPT_CAP) {
     const empty = { name: '', icon: '' };
-    return new Promise((resolve) => {
-        let dir = null;
-        try {
-            dir = mkdtempSync(join(tmpdir(), 'crtr-name-'));
-            const resultFile = join(dir, 'name.json');
-            const done = (value) => {
-                if (dir !== null) {
-                    try {
-                        rmSync(dir, { recursive: true, force: true });
-                    }
-                    catch { /* temp */ }
-                }
-                resolve(value);
-            };
-            const child = execFile(process.execPath, [resolveBundledPiCliPath(), ...nameArgs(body)], {
-                encoding: 'utf8',
-                timeout: NAME_TIMEOUT_MS,
-                env: { ...bundledPiSubprocessEnv(), CRTR_NAME_RESULT_FILE: resultFile },
-            }, () => {
-                // The tool call is the ONLY channel: a non-zero exit still counts when
-                // the emission already landed (pi print-mode can exit oddly after a
-                // terminating tool), and a clean exit without the file is a failure.
-                try {
-                    const parsed = JSON.parse(readFileSync(resultFile, 'utf8'));
-                    const name = sanitizeSessionName(typeof parsed['name'] === 'string' ? parsed['name'] : '');
-                    const icon = sanitizeIcon(typeof parsed['icon'] === 'string' ? parsed['icon'] : '');
-                    done(name !== '' ? { name, icon } : empty);
-                }
-                catch {
-                    done(empty);
-                }
-            });
-            child.stdin?.end(); // immediate EOF — see the doc above
-        }
-        catch {
-            if (dir !== null) {
-                try {
-                    rmSync(dir, { recursive: true, force: true });
-                }
-                catch { /* temp */ }
-            }
-            resolve(empty);
-        }
+    const route = nameModelRequest();
+    const emitted = await headlessToolCall({
+        systemPrompt: NAME_SYSTEM_PROMPT,
+        userPrompt: nameUserPrompt(body, sourceCap),
+        ...route,
+        timeoutMs: NAME_TIMEOUT_MS,
+        tool: {
+            name: 'name_session',
+            label: 'Name session',
+            description: 'Record the name and icon for this coding session. Call exactly once, then stop.',
+            parameters: NAME_SESSION_SCHEMA,
+            constrainedSampling: { type: 'json_schema', strict: 'prefer' },
+        },
     });
+    if (emitted === null || typeof emitted !== 'object')
+        return empty;
+    const parsed = emitted;
+    const name = sanitizeSessionName(typeof parsed['name'] === 'string' ? parsed['name'] : '');
+    const icon = sanitizeIcon(typeof parsed['icon'] === 'string' ? parsed['icon'] : '');
+    return name !== '' ? { name, icon } : empty;
+}
+/** Generate a name from a bounded conversation source rather than a single
+ *  kickoff message. The caller owns selecting representative conversation text;
+ *  this cap keeps the one-shot prompt compact. */
+export function headlessNameFromConversation(conversation) {
+    return headlessName(conversation, 30_000);
 }
 // ---------------------------------------------------------------------------
 // Issue titles — turn a free-text todo/idea/bug note into a short, human-readable
@@ -293,25 +245,24 @@ export function titleSlug(title) {
         .filter((w) => w !== '');
     return words.slice(0, 8).join('-') || 'untitled';
 }
-/** Ask pi headlessly for a one-line issue title for `note`. Resolves to the
- *  generated title, or a local first-line fallback on any failure (non-zero
- *  exit, timeout, empty output). Async; never throws. */
-export function generateIssueTitle(note) {
+/** Ask Pi headlessly for a one-line issue title for `note`. Resolves to the
+ *  generated title, or a local first-line fallback on timeout or empty output.
+ *  Async; never throws. */
+export async function generateIssueTitle(note) {
     const body = (note ?? '').trim();
     if (body === '')
-        return Promise.resolve('untitled');
-    return new Promise((resolve) => {
-        try {
-            const child = execFile(process.execPath, [resolveBundledPiCliPath(), ...piTextArgs(TITLE_SYSTEM_PROMPT, titleUserPrompt(body))], { encoding: 'utf8', timeout: NAME_TIMEOUT_MS, env: bundledPiSubprocessEnv() }, (err, stdout) => {
-                if (err || typeof stdout !== 'string')
-                    return resolve(firstLineTitle(body));
-                const t = stdout.trim().split('\n').map((l) => l.trim()).find((l) => l !== '') ?? '';
-                resolve(t !== '' ? t.replace(/^["']|["']$/g, '').replace(/\.$/, '') : firstLineTitle(body));
-            });
-            child.stdin?.end(); // immediate EOF — pi -p reads stdin (see headlessName)
-        }
-        catch {
-            resolve(firstLineTitle(body));
-        }
-    });
+        return 'untitled';
+    try {
+        const reply = await headlessText({
+            systemPrompt: TITLE_SYSTEM_PROMPT,
+            userPrompt: titleUserPrompt(body),
+            ...nameModelRequest(),
+            timeoutMs: NAME_TIMEOUT_MS,
+        });
+        const title = reply.split('\n').map((line) => line.trim()).find((line) => line !== '') ?? '';
+        return title !== '' ? title.replace(/^["']|["']$/g, '').replace(/\.$/, '') : firstLineTitle(body);
+    }
+    catch {
+        return firstLineTitle(body);
+    }
 }

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

@@ -8,17 +8,18 @@
 // and were imported into the handlers from there; Stage B-3 relocated them here
 // so the CLI leaves' import graph reaches no canvas state store (spec §1/§10).
 import { copyFileSync, existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { readJsonIfExists } from '../fs-utils.js';
 import { tmpdir } from 'node:os';
 import { basename, join } from 'node:path';
 import { InputError } from '../io.js';
 import { fullName, getNode } from '../canvas/index.js';
 import { jobDir, nodeDir, sessionPtrPath } from '../canvas/paths.js';
 import { SessionManager } from './broker-sdk.js';
-import { piAgentDir } from './package-health.js';
+import { openModelRegistry } from './model-registry.js';
 import { BUILTIN_SLASH_COMMANDS } from './pi-vendored.js';
 import { cycleAwareMessages } from './session-cycles.js';
-import { ModelRegistry, ModelRuntime } from '@earendil-works/pi-coding-agent';
-import { PoolCredentialStore } from '../pool-credential-store.js';
+import { visibleMessages } from './session-visibility.js';
+import { normalizeToolGroupSummaryRecord } from '../../shared/tool-groups.js';
 /** A session `.jsonl` records only `{ provider, modelId }` — pi never persists a
  *  whole `Model`. Resolve it back through pi's own registry so a dormant
  *  snapshot's `state.model` is the SAME `Model` a live broker's `get_state`
@@ -35,12 +36,7 @@ async function resolveRecordedModel(recorded) {
     if (recorded === null)
         return undefined;
     try {
-        const agentDir = piAgentDir();
-        const runtime = await ModelRuntime.create({
-            credentials: new PoolCredentialStore(join(agentDir, 'auth.json')),
-            modelsPath: join(agentDir, 'models.json'),
-        });
-        return new ModelRegistry(runtime).find(recorded.provider, recorded.modelId);
+        return (await openModelRegistry()).find(recorded.provider, recorded.modelId);
     }
     catch {
         return undefined;
@@ -131,6 +127,15 @@ function readIfPresent(path) {
         return null;
     }
 }
+function readToolGroupSummaries(nodeId) {
+    try {
+        const raw = readJsonIfExists(join(jobDir(nodeId), 'tool-summaries.json'));
+        return normalizeToolGroupSummaryRecord(raw);
+    }
+    catch {
+        return {};
+    }
+}
 /** Reconstruct a persisted session without launching its broker. Backs the
  * machine-readable snapshot endpoint and the human transcript render. */
 export async function readNodeSnapshot(nodeId) {
@@ -148,7 +153,7 @@ export async function readNodeSnapshot(nodeId) {
         copyFileSync(sessionFile, copy);
         const manager = SessionManager.open(copy);
         const context = manager.buildSessionContext();
-        const messages = cycleAwareMessages(manager);
+        const messages = visibleMessages(cycleAwareMessages(manager), { reviewCompanion: node.review_binding != null });
         const sessionId = manager.getSessionId();
         const sessionName = manager.getSessionName();
         const snapshot = {
@@ -175,6 +180,10 @@ 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 },
+            // 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.
+            toolGroupSummaries: readToolGroupSummaries(nodeId),
         };
         return {
             nodeId,

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

@@ -1,4 +1,4 @@
-import { type NodeMeta, type Mode, type Lifecycle, type LaunchSpec, type ManagedWorktree, type HumanWorkTarget, type PrivateForkPhase, type PrivateForkRecipe } from '../canvas/index.js';
+import { type NodeMeta, type Mode, type Lifecycle, type LaunchSpec, type ManagedWorktree, type ReviewBinding } from '../canvas/index.js';
 /** Explicitly set the resolved install id. crtrd calls this once at boot,
  *  immediately after `resolveInstallId()` — see crtrd.ts — so a provisioning
  *  mismatch fails the daemon loudly at STARTUP rather than lazily on first
@@ -70,14 +70,12 @@ export interface SpawnNodeOpts {
      *  the boot intro can re-assert this node's OWN identity over the source's
      *  copied-in conversation. Omit for a fresh node. */
     forkFrom?: string | null;
-    /** Immutable private-human-work binding. Omit for every ordinary node. */
-    humanWorkTarget?: HumanWorkTarget | null;
-    /** Explicit private-fork birth phase. Set with `privateForkRecipe` only for a
-     *  lifecycle-owned human-work child. */
-    privateForkPhase?: PrivateForkPhase | null;
-    /** Immutable one-shot kickoff consumed only while `privateForkPhase` is
-     *  `fork_pending`; the recipe remains persisted after session bind for audit. */
-    privateForkRecipe?: PrivateForkRecipe | null;
+    /** Suppress the spawn-time parent→child ACTIVE subscription. Default true
+     *  (every existing caller keeps its edge). False gives ordinary canvas
+     *  placement with no wake path back to the parent. */
+    subscribe?: boolean;
+    /** Immutable review-companion provenance. Omit for every ordinary node. */
+    reviewBinding?: ReviewBinding | null;
     /** New subscriptions this node opens default to passive when true. */
     passiveDefault?: boolean;
     /** Resolved pi launch recipe (from resolve(kind,mode)). */
@@ -96,12 +94,9 @@ export interface SpawnNodeOpts {
     profile_id?: string | null;
     /** Managed worktree already created for this node, if any. */
     managedWorktree?: ManagedWorktree;
-    /** Keep a private human-work child inert until its request has been rechecked
-     * and `reviveNode()` authorizes its one lifecycle-owned launch. */
-    initialStatus?: 'canceled';
     /** Override the generated id — either an internally pre-allocated id
-     *  (worktree naming, private-fork births; always valid+fresh) or an
-     *  external caller's explicit id (`--node-id`), which is format-validated
+     *  (worktree naming; always valid+fresh) or an external caller's explicit id
+     *  (`--node-id`), which is format-validated
      *  and duplicate-rejected (`NodeIdConflictError`) here. */
     nodeId?: string;
 }

package/dist/core/runtime/nodes.js

@@ -14,7 +14,6 @@
 //             is also recorded.
 import { randomBytes } from 'node:crypto';
 import { mkdirSync } from 'node:fs';
-import { isAbsolute } from 'node:path';
 import { createNode, getNode, getRow, subscribe, recordSpawn, contextDir, } from '../canvas/index.js';
 import { memoryDir } from './memory.js';
 import { resolveInstallId } from '../canvas/install-id.js';
@@ -207,59 +206,12 @@ export function nodeEnv(meta) {
     // Merge any launch-spec env last (it may override / extend).
     return { ...env, ...(meta.launch?.env ?? {}) };
 }
-// ---------------------------------------------------------------------------
-// Birth
-// ---------------------------------------------------------------------------
-function isHumanWorkTarget(value) {
-    if (value === null || typeof value !== 'object')
-        return false;
-    const target = value;
-    return ((target.work_kind === 'follow_up' || target.work_kind === 'visual') &&
-        typeof target.dir === 'string' && target.dir !== '' &&
-        typeof target.request_id === 'string' && target.request_id !== '' &&
-        typeof target.root === 'string' && target.root !== '');
-}
-/** Refuse malformed private claims before createNode leaves a durable half-node.
- *  This is intentionally private to the lifecycle-owned human-work birth API;
- *  ordinary spawn callers do not acquire a second generic validation surface. */
-function validatePrivateForkBirth(opts) {
-    const hasTarget = opts.humanWorkTarget != null;
-    const hasPhase = opts.privateForkPhase != null;
-    const hasRecipe = opts.privateForkRecipe != null;
-    if (!hasTarget && !hasPhase && !hasRecipe) {
-        if (opts.initialStatus !== undefined)
-            throw new Error('only private human-work births may start inert');
-        return;
-    }
-    if (!isHumanWorkTarget(opts.humanWorkTarget)) {
-        throw new Error('private human-work birth requires a recognized humanWorkTarget');
-    }
-    if (opts.privateForkPhase !== 'fork_pending') {
-        throw new Error('private human-work birth requires privateForkPhase=fork_pending');
-    }
-    if (typeof opts.privateForkRecipe?.kickoff !== 'string' || opts.privateForkRecipe.kickoff.trim() === '') {
-        throw new Error('private human-work birth requires a non-empty kickoff recipe');
-    }
-    if (typeof opts.forkFrom !== 'string' || !isAbsolute(opts.forkFrom)) {
-        throw new Error('private human-work birth requires an absolute forkFrom provenance file');
-    }
-    if (opts.parent !== null && opts.parent !== undefined) {
-        throw new Error('private human-work birth must be parent-null');
-    }
-    if ((opts.lifecycle ?? 'terminal') !== 'terminal') {
-        throw new Error('private human-work birth must be terminal');
-    }
-    if (opts.launch?.modelExact !== true || typeof opts.launch.model !== 'string' || opts.launch.model.trim() === '') {
-        throw new Error('private human-work birth requires an exact persisted model');
-    }
-}
 /** Create a node on the canvas and wire its spawn-time edges.
  *
  *  For a child (parent given): the parent auto-subscribes ACTIVE to the child
  *  (so it's woken when the child finishes), and a spawned_by audit edge is
  *  recorded. For a root (no parent): no edges, resident by default. */
 export function spawnNode(opts) {
-    validatePrivateForkBirth(opts);
     const nodeId = opts.nodeId !== undefined ? validatedExplicitNodeId(opts.nodeId) : newNodeId();
     const parent = opts.parent ?? null;
     const isRoot = parent === null;
@@ -288,13 +240,11 @@ export function spawnNode(opts) {
         // guidance" for the state it starts in (its bearings carry it), so the
         // persona injector sees no drift on its first turn boundary.
         persona_ack: { mode, lifecycle },
-        status: opts.initialStatus ?? 'active',
+        status: 'active',
         parent,
         spawned_by: spawnedBy,
         fork_from: opts.forkFrom,
-        human_work_target: opts.humanWorkTarget,
-        private_fork_phase: opts.privateForkPhase,
-        private_fork_recipe: opts.privateForkRecipe,
+        review_binding: opts.reviewBinding,
         model_override: opts.modelOverride ?? null,
         passive_default: opts.passiveDefault ?? false,
         ...(opts.managedWorktree !== undefined ? { managed_worktree: opts.managedWorktree } : {}),
@@ -316,7 +266,7 @@ export function spawnNode(opts) {
     if (meta.kind !== 'human') {
         mkdirSync(memoryDir(meta.node_id), { recursive: true });
     }
-    if (parent !== null) {
+    if (parent !== null && opts.subscribe !== false) {
         // The load-bearing seed: parent subscribes (active) to child so it learns
         // when the work finishes. This mirrors spawn structure into the spine.
         // A root (parent=null) gets NO subscription — nobody is woken by it.

package/dist/core/runtime/package-health.d.ts

@@ -4,27 +4,12 @@ export interface MissingPackage {
     /** Absolute path it resolved to (which does not exist). */
     resolved: string;
 }
-export interface GlobalHumanloopHealth {
-    bundledVersion: string | null;
-    globalVersion: string | null;
-    current: boolean;
-}
-/** Read the installed library's version rather than coupling this check to the
- * dependency range in crouter's package.json. The bundled copy is the floor
- * required by crouter's generated `hl inbox toggle` binding. */
-export declare function bundledHumanloopVersion(): string | null;
-/** Read the PATH-visible `hl` package directly. Spawning `npm ls -g` here
- * makes every front-door boot pay for npm's global dependency-tree scan; a
- * linked development install can make that scan take many seconds. The real
- * executable points into the package for both ordinary and npm-linked installs,
- * so walking upward to its package.json is authoritative for the CLI crtr will
- * actually invoke. */
-export declare function globalHumanloopVersion(): string | null;
-export declare function globalHumanloopHealth(): GlobalHumanloopHealth;
-/** A non-fatal action-oriented diagnostic for a missing, unreadable, or stale
- * global `hl` executable. */
-export declare function globalHumanloopWarning(): string | null;
-export declare function globalHumanloopInstallCommand(): string;
+/** A non-fatal, action-oriented diagnostic for an unprovisioned managed
+ * renderer — the one remaining out-of-tree dependency. Deliberately calls
+ * `isRendererReady()`, NOT `ensureRenderer()`: this runs on the front-door boot
+ * path and at crtrd startup, where a `uv pip install` (up to 180s) must never
+ * happen. Readiness is a handful of fs stats, no subprocess. */
+export declare function rendererWarning(): string | null;
 /**
  * The pi agent config dir (`~/.pi/agent`, or `$PI_CODING_AGENT_DIR`) — a local
  * reimplementation of pi's `getAgentDir()`. Reimplemented (not imported) ON