@north-light/crouter 0.3.170 → 0.3.172

package/dist/core/runtime/canvas-extensions.d.ts

@@ -3,17 +3,16 @@ export declare const CANVAS_INBOX_WATCHER_PATH: string;
 export declare const CANVAS_RECAP_PATH: string;
 export declare const CANVAS_GOAL_CAPTURE_PATH: string;
 export declare const CANVAS_PASSIVE_CONTEXT_PATH: string;
+export declare const CANVAS_REVIEW_BOUNDARY_PATH: string;
 export declare const CANVAS_CONTEXT_INTRO_PATH: string;
 export declare const CANVAS_TOOL_GUIDE_PATH: string;
 export declare const CANVAS_DOC_SUBSTRATE_PATH: string;
 export declare const CANVAS_STRUCTURED_OUTPUT_PATH: string;
 export declare const CANVAS_BASH_VALVE_PATH: string;
-/** NOT a canvas extension — loaded only by the headless namer subprocess
- *  (`runtime/naming.ts`) to give it a constrained-schema `name_session` tool.
- *  Deliberately absent from CANVAS_EXTENSIONS: a node must never carry it. */
-export declare const NAMING_TOOL_PATH: string;
 /** The canvas extensions every node loads, in order. The inbox watcher commits
- *  its cursor at agent_settled before the stophook checks it for idle release. */
+ *  its cursor at agent_settled before the stophook checks it for idle release.
+ *  The review boundary must run before the stophook commits companion session
+ *  coordinates, and before the context intro appends fork bearings. */
 export declare const CANVAS_EXTENSIONS: string[];
 /** Preserve the invariant: mandatory extensions are always present exactly once.
  *

package/dist/core/runtime/canvas-extensions.js

@@ -15,19 +15,19 @@ export const CANVAS_INBOX_WATCHER_PATH = resolveExtension('canvas-inbox-watcher'
 export const CANVAS_RECAP_PATH = resolveExtension('canvas-recap');
 export const CANVAS_GOAL_CAPTURE_PATH = resolveExtension('canvas-goal-capture');
 export const CANVAS_PASSIVE_CONTEXT_PATH = resolveExtension('canvas-passive-context');
+export const CANVAS_REVIEW_BOUNDARY_PATH = resolveExtension('canvas-review-boundary');
 export const CANVAS_CONTEXT_INTRO_PATH = resolveExtension('canvas-context-intro');
 export const CANVAS_TOOL_GUIDE_PATH = resolveExtension('canvas-tool-guide');
 export const CANVAS_DOC_SUBSTRATE_PATH = resolveExtension('canvas-doc-substrate');
 export const CANVAS_STRUCTURED_OUTPUT_PATH = resolveExtension('canvas-structured-output');
 export const CANVAS_BASH_VALVE_PATH = resolveExtension('canvas-bash-valve');
-/** NOT a canvas extension — loaded only by the headless namer subprocess
- *  (`runtime/naming.ts`) to give it a constrained-schema `name_session` tool.
- *  Deliberately absent from CANVAS_EXTENSIONS: a node must never carry it. */
-export const NAMING_TOOL_PATH = resolveExtension('naming-tool');
 /** The canvas extensions every node loads, in order. The inbox watcher commits
- *  its cursor at agent_settled before the stophook checks it for idle release. */
+ *  its cursor at agent_settled before the stophook checks it for idle release.
+ *  The review boundary must run before the stophook commits companion session
+ *  coordinates, and before the context intro appends fork bearings. */
 export const CANVAS_EXTENSIONS = [
     CANVAS_INBOX_WATCHER_PATH,
+    CANVAS_REVIEW_BOUNDARY_PATH,
     CANVAS_STOPHOOK_PATH,
     CANVAS_RECAP_PATH,
     CANVAS_GOAL_CAPTURE_PATH,

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

@@ -151,7 +151,7 @@ export async function maybeBootRoot(argv) {
     // Unambiguous front-door launch → boot a resident root inline (exec pi in
     // this terminal). Does not return. Load the heavy boot-path deps lazily now
     // that we've committed to booting (see the import note at the top of file).
-    const [{ bootRoot }, { resumeRoot }, { globalHumanloopWarning, missingPackageWarning, piAgentDir }] = await Promise.all([
+    const [{ bootRoot }, { resumeRoot }, { rendererWarning, missingPackageWarning, piAgentDir }] = await Promise.all([
         import('./boot-root.js'),
         import('./resume-root.js'),
         import('./package-health.js'),
@@ -164,9 +164,9 @@ export async function maybeBootRoot(argv) {
         const warn = missingPackageWarning(piAgentDir());
         if (warn !== null)
             process.stderr.write(`\n${warn}\n\n`);
-        const humanloopWarn = globalHumanloopWarning();
-        if (humanloopWarn !== null)
-            process.stderr.write(`\n${humanloopWarn}\n\n`);
+        const rendererWarn = rendererWarning();
+        if (rendererWarn !== null)
+            process.stderr.write(`\n${rendererWarn}\n\n`);
     }
     catch {
         /* best-effort diagnostic — never block a boot */

package/dist/core/runtime/headless-pi.d.ts

@@ -0,0 +1,24 @@
+import type { ConstrainedSamplingConfig } from '@earendil-works/pi-ai';
+import type { TSchema } from 'typebox';
+export interface HeadlessTool {
+    name: string;
+    label: string;
+    description: string;
+    parameters: TSchema;
+    constrainedSampling?: false | ConstrainedSamplingConfig;
+}
+export interface HeadlessRequest {
+    systemPrompt: string;
+    userPrompt: string;
+    modelSpec: string;
+    /** Logical `family/strength` intent. Omit for a concrete model request. */
+    modelIntent?: string;
+    timeoutMs: number;
+    tool?: HeadlessTool;
+}
+/** Run a one-shot call whose only output channel is one structured tool call. */
+export declare function headlessToolCall(request: HeadlessRequest & {
+    tool: HeadlessTool;
+}): Promise<unknown>;
+/** Run a one-shot call and return the final assistant text. */
+export declare function headlessText(request: HeadlessRequest): Promise<string>;

package/dist/core/runtime/headless-pi.js

@@ -0,0 +1,152 @@
+// Isolated in-process Pi one-shots for lightweight model work.
+//
+// Each call uses crouter's credential pool and route policy, an in-memory session,
+// and only the inline provider-rotation extension. No conversation resources or
+// canvas lifecycle hooks enter the helper session.
+import { join } from 'node:path';
+import { PoolCredentialStore } from '../pool-credential-store.js';
+import { modelRequestFromConfig, selectInitialModelRoute } from '../model-routes.js';
+function lastAssistantText(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (message?.role !== 'assistant')
+            continue;
+        if (typeof message.content === 'string')
+            return message.content.trim();
+        if (!Array.isArray(message.content))
+            continue;
+        const text = message.content
+            .map((part) => {
+            const value = part;
+            return value.type === 'text' && typeof value.text === 'string' ? value.text : '';
+        })
+            .join('')
+            .trim();
+        if (text !== '')
+            return text;
+    }
+    return '';
+}
+async function runHeadless(request, fallback, collect) {
+    let session;
+    let disposed = false;
+    let timedOut = false;
+    let timeout;
+    const disposeSession = (abort) => {
+        if (session === undefined || disposed)
+            return;
+        disposed = true;
+        if (abort)
+            void session.abort().catch(() => undefined);
+        session.dispose();
+    };
+    const deadline = new Promise((resolve) => {
+        timeout = setTimeout(() => {
+            timedOut = true;
+            disposeSession(true);
+            resolve(fallback);
+        }, request.timeoutMs);
+    });
+    const run = (async () => {
+        try {
+            const [sdk, rotation] = await Promise.all([
+                import('@earendil-works/pi-coding-agent'),
+                import('../../builtin-pi-packages/pi-crtr-extensions/extensions/provider-rotation.js'),
+            ]);
+            if (timedOut)
+                return fallback;
+            const nodeCwd = process.env['CRTR_NODE_CWD'] ?? process.cwd();
+            const profileId = process.env['CRTR_PROFILE_ID'];
+            const agentDir = sdk.getAgentDir();
+            const modelRuntime = await sdk.ModelRuntime.create({
+                credentials: new PoolCredentialStore(join(agentDir, 'auth.json')),
+                modelsPath: join(agentDir, 'models.json'),
+            });
+            if (timedOut)
+                return fallback;
+            const services = await sdk.createAgentSessionServices({
+                cwd: nodeCwd,
+                agentDir,
+                modelRuntime,
+                settingsManager: sdk.SettingsManager.inMemory(),
+                resourceLoaderOptions: {
+                    noExtensions: true,
+                    noContextFiles: true,
+                    noSkills: true,
+                    noPromptTemplates: true,
+                    noThemes: true,
+                    systemPrompt: request.systemPrompt,
+                    extensionFactories: [rotation.createProviderRotationExtension({
+                            modelIntent: request.modelIntent,
+                            nodeCwd,
+                            profileId,
+                        })],
+                },
+            });
+            if (timedOut)
+                return fallback;
+            const modelRequest = modelRequestFromConfig(request.modelSpec, request.modelIntent, false);
+            if (modelRequest === undefined)
+                return fallback;
+            const selected = selectInitialModelRoute(modelRequest, new sdk.ModelRegistry(services.modelRuntime), {
+                cwd: nodeCwd,
+                profileId,
+            }).selected;
+            if (selected === undefined)
+                return fallback;
+            let captured;
+            const tool = request.tool;
+            const customTool = tool === undefined ? undefined : sdk.defineTool({
+                name: tool.name,
+                label: tool.label,
+                description: tool.description,
+                parameters: tool.parameters,
+                ...(tool.constrainedSampling === undefined ? {} : { constrainedSampling: tool.constrainedSampling }),
+                async execute(_toolCallId, params) {
+                    captured = params;
+                    return {
+                        content: [{ type: 'text', text: 'Recorded.' }],
+                        details: { recorded: true },
+                        terminate: true,
+                    };
+                },
+            });
+            ({ session } = await sdk.createAgentSessionFromServices({
+                services,
+                sessionManager: sdk.SessionManager.inMemory(nodeCwd),
+                model: selected.model,
+                thinkingLevel: 'off',
+                ...(tool === undefined
+                    ? { noTools: 'all' }
+                    : { tools: [tool.name], customTools: [customTool] }),
+            }));
+            if (timedOut)
+                return fallback;
+            await session.bindExtensions({});
+            if (timedOut)
+                return fallback;
+            await session.prompt(request.userPrompt);
+            return timedOut ? fallback : collect(session, captured);
+        }
+        catch {
+            return fallback;
+        }
+        finally {
+            disposeSession(false);
+        }
+    })();
+    try {
+        return await Promise.race([run, deadline]);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/** Run a one-shot call whose only output channel is one structured tool call. */
+export function headlessToolCall(request) {
+    return runHeadless(request, null, (_session, captured) => captured);
+}
+/** Run a one-shot call and return the final assistant text. */
+export function headlessText(request) {
+    return runHeadless(request, '', (session) => lastAssistantText(session.messages));
+}

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

@@ -1,6 +1,6 @@
 import { type NodeMeta } from '../canvas/index.js';
 import { type WakeOrigin } from './bearings.js';
-export { REVIVE_KICKOFF_SENTINEL } from '../../shared/generated-context.js';
+export { REVIVE_KICKOFF_SENTINEL, RUNTIME_RESTART_CONTINUATION, } from '../../shared/generated-context.js';
 /** The goal file — the prompt/task a node was spawned with, persisted at birth
  *  so a fresh revive can re-read its mandate. */
 export declare function goalPath(nodeId: string): string;
@@ -16,10 +16,6 @@ export declare function captureGoalIfAbsent(nodeId: string, text: string): boole
 /** Sentinel opening the fresh-revive kickoff message (see buildReviveKickoff).
  *  The goal-capture extension and attached renderers share its pure definition,
  *  so the same exact contract controls both prompt exclusion and display. */
-/** Injected only when a broker cleanly persisted an aborted in-flight turn
- * before a daemon restart. The transcript already carries the full picture, so
- * this is a bare nudge — a longer explanation only destabilizes the resume. */
-export declare const RUNTIME_RESTART_CONTINUATION = "continue";
 /** The yield-message file — a short note `crtr node yield` records for the next
  *  fresh/cycling revive ("on wake, do X"). It remains durable through failed
  *  launch attempts and is cleared only when session_start confirms a boot. */

package/dist/core/runtime/kickoff.js

@@ -25,7 +25,7 @@ import { buildWakeBearings } from './bearings.js';
 import { personaDrift, commitPersonaAck } from './persona.js';
 import { readInboxSince, readCursor, writeCursor, coalesce, } from '../feed/inbox.js';
 import { REVIVE_KICKOFF_SENTINEL } from '../../shared/generated-context.js';
-export { REVIVE_KICKOFF_SENTINEL } from '../../shared/generated-context.js';
+export { REVIVE_KICKOFF_SENTINEL, RUNTIME_RESTART_CONTINUATION, } from '../../shared/generated-context.js';
 // ---------------------------------------------------------------------------
 // Companion context files: the goal (the spawning mandate) and the one-shot
 // yield message (a note from the prior self to the revived self).
@@ -65,10 +65,6 @@ export function captureGoalIfAbsent(nodeId, text) {
 /** Sentinel opening the fresh-revive kickoff message (see buildReviveKickoff).
  *  The goal-capture extension and attached renderers share its pure definition,
  *  so the same exact contract controls both prompt exclusion and display. */
-/** Injected only when a broker cleanly persisted an aborted in-flight turn
- * before a daemon restart. The transcript already carries the full picture, so
- * this is a bare nudge — a longer explanation only destabilizes the resume. */
-export const RUNTIME_RESTART_CONTINUATION = 'continue';
 /** The yield-message file — a short note `crtr node yield` records for the next
  *  fresh/cycling revive ("on wake, do X"). It remains durable through failed
  *  launch attempts and is cleared only when session_start confirms a boot. */

package/dist/core/runtime/model-registry.d.ts

@@ -0,0 +1,3 @@
+import { ModelRegistry } from '@earendil-works/pi-coding-agent';
+/** Open pi's credential-backed model registry for runtime model resolution. */
+export declare function openModelRegistry(): Promise<ModelRegistry>;

package/dist/core/runtime/model-registry.js

@@ -0,0 +1,13 @@
+import { join } from 'node:path';
+import { ModelRegistry, ModelRuntime } from '@earendil-works/pi-coding-agent';
+import { PoolCredentialStore } from '../pool-credential-store.js';
+import { piAgentDir } from './package-health.js';
+/** Open pi's credential-backed model registry for runtime model resolution. */
+export async function openModelRegistry() {
+    const agentDir = piAgentDir();
+    const runtime = await ModelRuntime.create({
+        credentials: new PoolCredentialStore(join(agentDir, 'auth.json')),
+        modelsPath: join(agentDir, 'models.json'),
+    });
+    return new ModelRegistry(runtime);
+}

package/dist/core/runtime/naming-persist.d.ts

@@ -10,3 +10,7 @@ import type { NodeMeta } from '../canvas/index.js';
  *  pi.setSessionName(editorLabel(meta)) so the LIVE editor label updates in the
  *  same session, instead of waiting for the next revive/cycle. */
 export declare function generateAndPersistName(nodeId: string, prompt: string, onNamed?: (meta: NodeMeta) => void): void;
+/** Re-name an automatically titled node from its current conversation. The caller
+ *  supplies the guard that distinguishes the original generated editor title from
+ *  a title a person changed while this headless request was in flight. */
+export declare function regenerateAndPersistName(nodeId: string, conversation: string, isStillAutomatic: () => boolean, onNamed?: (meta: NodeMeta) => void): void;

package/dist/core/runtime/naming-persist.js

@@ -5,7 +5,7 @@
 // in canvas state. This one function is the only naming path that writes to a
 // node's meta, so it lives here — broker-side (canvas-goal-capture), never on a
 // CLI leaf's import graph.
-import { headlessName, sanitizeSessionName, slugFromPrompt } from './naming.js';
+import { headlessName, headlessNameFromConversation, sanitizeSessionName, slugFromPrompt } from './naming.js';
 import { getNode, updateNode } from '../canvas/index.js';
 /** Asynchronously generate a name for `prompt` and persist it to the node's
  *  meta as `description` + `icon` — only if the node has none yet (so a later
@@ -40,3 +40,29 @@ export function generateAndPersistName(nodeId, prompt, onNamed) {
     };
     void headlessName(body).then(persist);
 }
+/** Re-name an automatically titled node from its current conversation. The caller
+ *  supplies the guard that distinguishes the original generated editor title from
+ *  a title a person changed while this headless request was in flight. */
+export function regenerateAndPersistName(nodeId, conversation, isStillAutomatic, onNamed) {
+    const body = (conversation ?? '').trim();
+    if (body === '')
+        return;
+    const persist = (generated) => {
+        try {
+            if (!isStillAutomatic())
+                return;
+            const meta = getNode(nodeId);
+            if (meta === null)
+                return;
+            const clean = sanitizeSessionName(generated.name);
+            const description = clean !== '' ? clean : slugFromPrompt(body);
+            const icon = generated.icon.trim();
+            const updated = updateNode(nodeId, { description, icon: icon !== '' ? icon : undefined });
+            onNamed?.(updated);
+        }
+        catch {
+            // best-effort
+        }
+    };
+    void headlessNameFromConversation(body).then(persist);
+}

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

@@ -5,6 +5,12 @@ export declare function sanitizeSessionName(raw: string): string;
 /** Local fallback: derive a name straight from the prompt (no pi call). Drops
  *  stop-words, takes the first few content words. */
 export declare function slugFromPrompt(prompt: string): string;
+/** The namer's model: the `light` rung of the DEFAULT provider's ladder, with
+ *  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. */
+export declare function lightModel(overrideEnv?: string): string;
 /** A generated session name: the kebab-case handle plus the Nerd Font glyph the
  *  namer chose for it. `icon` is '' when the model returned nothing usable —
  *  every surface renders the name alone in that case. */
@@ -24,23 +30,22 @@ export interface SessionName {
  *  `nf-fa-bug`, a bare ASCII letter, and anything multi-glyph, all of which
  *  would render as noise or tofu in a label. */
 export declare function sanitizeIcon(raw: string): string;
-/** 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 declare function headlessName(body: string): Promise<SessionName>;
+export declare function headlessName(body: string, sourceCap?: number): Promise<SessionName>;
+/** 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 declare function headlessNameFromConversation(conversation: string): Promise<SessionName>;
 /** A filesystem-safe slug for the `.todos/<slug>.md` fallback path: lowercase,
  *  [a-z0-9] kept, everything else → single hyphen, clamped to 8 words. */
 export declare function titleSlug(title: string): string;
-/** 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. */
+/** 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 declare function generateIssueTitle(note: string): Promise<string>;