@north-light/crouter 0.3.221 → 0.3.222

package/dist/core/profiles/select.d.ts

@@ -9,6 +9,8 @@ export declare function resolveProfileSearchAction(bindings: BindingResolution<B
  *  `crtr profile default set`, which rejects pinning a profile that doesn't
  *  cover cwd (the selector would ignore/self-heal such a pin anyway). */
 export declare function profileCoversCwd(entry: ProfileEntry, cwd: string): boolean;
+/** Resolve the headless selector against existing state without changing it. */
+export declare function selectProfileForCwdReadOnly(cwd: string): string;
 /** Select the profile a node about to boot at `cwd` should run under.
  *
  *  1. `explicitProfile` present → resolve id/name via `loadProfileManifest`. If

package/dist/core/profiles/select.js

@@ -93,6 +93,26 @@ function isMoreRecent(a, b) {
 function pickMostRecent(entries) {
     return entries.reduce((best, cur) => isMoreRecent(cur.manifest.last_used_at, best.manifest.last_used_at) ? cur : best);
 }
+function profileSelectionState(cwd) {
+    const resolvedCwd = resolveCwd(cwd);
+    const covering = listProfiles().filter((profile) => profileCoversCwd(profile, resolvedCwd));
+    const exact = covering.filter((profile) => profile.manifest.projects.some((project) => project.path === resolvedCwd));
+    const pinnedId = getDefaultProfileId(resolvedCwd);
+    const pinned = pinnedId === null ? null : covering.find((profile) => profile.profileId === pinnedId) ?? null;
+    return { covering, exact, pinnedId, pinned };
+}
+/** Resolve the headless selector against existing state without changing it. */
+export function selectProfileForCwdReadOnly(cwd) {
+    const { covering, exact, pinned } = profileSelectionState(cwd);
+    if (pinned !== null)
+        return pinned.profileId;
+    if (exact.length === 1)
+        return exact[0].profileId;
+    const pool = exact.length > 0 ? exact : covering;
+    if (pool.length > 0)
+        return pickMostRecent(pool).profileId;
+    return ROOT_PROFILE_ID;
+}
 function isInteractive() {
     return Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY);
 }
@@ -620,14 +640,11 @@ export async function selectProfileForCwd(cwd, explicitProfile, forcePicker = fa
         updateProfileLastUsed(entry.profileId);
         return entry.profileId;
     }
-    const covering = listProfiles().filter((p) => profileCoversCwd(p, resolvedCwd));
-    const exact = covering.filter((p) => p.manifest.projects.some((proj) => proj.path === resolvedCwd));
+    const { covering, exact, pinnedId, pinned } = profileSelectionState(resolvedCwd);
     // A per-cwd pinned default (set from the menu with `d`) is the user's
     // explicit "default to THIS profile HERE". It outranks both the exact-single
     // auto-pick and global-MRU, so long as it still covers cwd; a stale pin
     // (profile deleted, or its dir removed from purview) is self-healed away.
-    const pinnedId = getDefaultProfileId(resolvedCwd);
-    const pinned = pinnedId !== null ? covering.find((p) => p.profileId === pinnedId) ?? null : null;
     if (pinnedId !== null && pinned === null)
         clearDefaultProfile(resolvedCwd);
     // A valid pin decides it outright and STOPS ASKING — the whole point of

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

@@ -9,7 +9,7 @@ import { operationIdContext } from '../../events/operation-id.js';
 import { buildRefInventory } from '../../memory/inline-ref-inventory.js';
 import { buildGuidance } from '../../memory/inline-ref-guidance.js';
 import { clearSessionCache } from '../../substrate/session-cache.js';
-import { captureSessionPromptTemplateChatSurfaces } from '../command-surface.js';
+import { captureSessionChatCapabilities } from '../command-surface.js';
 import { promptWithAdvertisedCommandInvocation } from '../advertised-command-invocation.js';
 export { promptWithAdvertisedCommandInvocation } from '../advertised-command-invocation.js';
 import { configuredLadderProviders, isProviderPinnedModelToken, nextLadderModel, normalizeModel, } from '../launch.js';
@@ -1210,7 +1210,7 @@ export function createFrameDispatchContext(deps) {
                 // cached docs. A FAILED reload (`.catch`) leaves both untouched: nothing
                 // about the corpus is known to have changed.
                 void currentSession()
-                    .reload()
+                    .reload({ beforeSessionStart: () => captureSessionChatCapabilities(currentSession()) })
                     .then(() => {
                     // pi's reload() re-syncs queue modes from the shared settings.json
                     // (its ONE post-bind syncQueueModesFromSettings call site) —
@@ -1221,9 +1221,6 @@ export function createFrameDispatchContext(deps) {
                         agent.steeringMode = 'all';
                         agent.followUpMode = 'all';
                     }
-                    // `session.reload()` has replaced pi's loaded template objects;
-                    // capture their crouter-only metadata before any observer refresh.
-                    captureSessionPromptTemplateChatSurfaces(currentSession());
                     memoizedRefInventory = null;
                     clearSessionCache();
                     registry.forEachHelloed((observer) => {

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

@@ -1,5 +1,4 @@
-import type { ChatInventoryDTO, ChatInventoryMemoryRefDTO } from '../../api/dto/chat-inventory.js';
-export declare function gatewayMemoryRows(refs: unknown): ChatInventoryMemoryRefDTO[];
+import type { ChatInventoryDTO } from '../../api/dto/chat-inventory.js';
 /** Collect the chat inventories for one node. Always resolves — every failure
  *  mode is expressed in the returned document, not thrown. */
 export declare function readChatInventory(nodeId: string): Promise<ChatInventoryDTO>;

package/dist/core/runtime/broker-inventory.js

@@ -24,7 +24,7 @@
 import { randomUUID } from 'node:crypto';
 import { getNode } from '../canvas/canvas.js';
 import { BrokerClient } from '../broker-client/index.js';
-import { isDeterministicCommandExpansion } from './command-expansion.js';
+import { gatewayCommandRowsFromDetail, gatewayMemoryRows } from './chat-inventory-rows.js';
 import { isBrokerLive } from './model-swap.js';
 /** Same budget as `broker-request.ts`: this is local engine work, so it is
  *  generous slack rather than a tuned deadline. One budget covers BOTH answers —
@@ -36,81 +36,6 @@ const READ_TIMEOUT_MS = 15_000;
  *  throws away — on every activation and reconnect, worst on the longest
  *  conversations. One entry is the smallest legal request. */
 const SNAPSHOT_TAIL = 1;
-const MEMORY_KINDS = new Set(['knowledge', 'preference']);
-const MEMORY_SCOPES = new Set(['node', 'project', 'profile', 'user', 'builtin']);
-function nonEmptyString(value) {
-    return typeof value === 'string' && value !== '';
-}
-/** Keep the rows a chat surface can actually use and drop the rest. Malformed
- *  rows are discarded individually so one bad registration cannot take down the
- *  whole inventory.
- *
- *  This validation lives here rather than reusing the attach viewer's parser:
- *  `src/core` does not import `src/clients`, and adding that import would invert
- *  the layering. */
-function commandRows(detail) {
-    if (detail === undefined)
-        return [];
-    let parsed;
-    try {
-        parsed = JSON.parse(detail);
-    }
-    catch {
-        return [];
-    }
-    if (!Array.isArray(parsed))
-        return [];
-    const out = [];
-    for (const row of parsed) {
-        if (typeof row !== 'object' || row === null)
-            continue;
-        const record = row;
-        if (record['gatewayCapable'] !== true)
-            continue;
-        const source = record['source'];
-        if (source !== 'command' && source !== 'template')
-            continue;
-        if (!nonEmptyString(record['name']) || typeof record['description'] !== 'string')
-            continue;
-        const expansion = record['expansion'];
-        const template = record['template'];
-        const argumentHint = record['argumentHint'];
-        out.push({
-            name: record['name'],
-            description: record['description'],
-            source,
-            ...(nonEmptyString(argumentHint) ? { argument_hint: argumentHint } : {}),
-            ...(isDeterministicCommandExpansion(expansion) ? { expansion } : {}),
-            ...(typeof template === 'string' ? { template } : {}),
-        });
-    }
-    return out;
-}
-export function gatewayMemoryRows(refs) {
-    if (!Array.isArray(refs))
-        return [];
-    const out = [];
-    for (const row of refs) {
-        if (typeof row !== 'object' || row === null)
-            continue;
-        const record = row;
-        if (record['gatewayVisible'] !== true)
-            continue;
-        if (!nonEmptyString(record['name']) || typeof record['shortForm'] !== 'string')
-            continue;
-        if (typeof record['kind'] !== 'string' || !MEMORY_KINDS.has(record['kind']))
-            continue;
-        if (typeof record['scope'] !== 'string' || !MEMORY_SCOPES.has(record['scope']))
-            continue;
-        out.push({
-            name: record['name'],
-            kind: record['kind'],
-            scope: record['scope'],
-            shortForm: record['shortForm'],
-        });
-    }
-    return out;
-}
 const empty = (nodeId) => ({
     node_id: nodeId,
     broker_live: false,
@@ -174,7 +99,7 @@ export function readChatInventory(nodeId) {
         client.on('frame', (frame) => {
             // `get_commands` carries no id, so its ack is matched on `for` alone.
             if (frame.type === 'ack' && frame.for === 'get_commands') {
-                commands = frame.ok ? commandRows(frame.detail) : [];
+                commands = frame.ok ? gatewayCommandRowsFromDetail(frame.detail) : [];
                 settleWhenComplete();
                 return;
             }

package/dist/core/runtime/broker-persona-guidance.js

@@ -44,7 +44,7 @@ export function transitionGuidanceFromBrokerState(node, from, to) {
         sections.push(to.mode === 'orchestrator' ? orchestrationGuidance(node) : baseModeGuidance());
     }
     if (from.lifecycle !== to.lifecycle) {
-        sections.push(loadMemoryBody(to.lifecycle === 'resident' ? 'lifecycle/resident' : 'lifecycle/terminal'));
+        sections.push(loadMemoryBody(to.lifecycle === 'resident' ? 'turn-lifecycle/resident' : 'turn-lifecycle/terminal'));
     }
     return sections.join('\n\n');
 }

package/dist/core/runtime/broker.js

@@ -31,7 +31,7 @@ import { FRONT_DOOR_ENV } from './front-door.js';
 import { CANVAS_EXTENSIONS, piInvocationToSdkConfig, } from './launch.js';
 import { assertEngineVersion, loadBrokerEngine } from './broker-sdk.js';
 import { resolveBundledPiPackageDir } from './pi-cli.js';
-import { captureSessionPromptTemplateChatSurfaces } from './command-surface.js';
+import { captureSessionChatCapabilities } from './command-surface.js';
 import { PoolCredentialStore } from '../pool-credential-store.js';
 import { clearCleanAbort, markBusy, markCleanAbort } from './busy.js';
 import { recordFaultForCurrentNode } from './fault.js';
@@ -899,9 +899,9 @@ export async function buildBrokerSession(engine, cfg) {
             sessionStartEvent: o.sessionStartEvent,
         });
         installAdvertisedCommandInvocationContract(created.session);
-        // The resource loader has completed its initial template load. Capture
-        // crouter-only template metadata before command disclosure can observe it.
-        captureSessionPromptTemplateChatSurfaces(created.session);
+        // The resource loader has completed its initial load, but extensions have
+        // not received session_start yet. Freeze the Gateway capability boundary.
+        captureSessionChatCapabilities(created.session);
         // CONSTRUCTION-ONLY MASK — see modelLessRegistry: reveal now that model
         // selection (construction-time only) is done, so a later /login re-drive's
         // list_models/cycle_model/provider-rotation see the real registry.

package/dist/core/runtime/chat-inventory-rows.d.ts

@@ -0,0 +1,8 @@
+import type { ChatInventoryCommandDTO, ChatInventoryMemoryRefDTO } from '../../api/dto/chat-inventory.js';
+/** Keep the command rows a Gateway can use. Malformed registrations are
+ * discarded individually so one producer cannot take down the inventory. */
+export declare function gatewayCommandRows(rows: unknown): ChatInventoryCommandDTO[];
+export declare function chatInventoryCommandRows(rows: unknown): ChatInventoryCommandDTO[];
+export declare function gatewayCommandRowsFromDetail(detail: string | undefined): ChatInventoryCommandDTO[];
+export declare function chatInventoryMemoryRows(rows: unknown): ChatInventoryMemoryRefDTO[];
+export declare function gatewayMemoryRows(refs: unknown): ChatInventoryMemoryRefDTO[];

package/dist/core/runtime/chat-inventory-rows.js

@@ -0,0 +1,105 @@
+import { isDeterministicCommandExpansion } from './command-expansion.js';
+const MEMORY_KINDS = new Set(['knowledge', 'preference']);
+const MEMORY_SCOPES = new Set(['node', 'project', 'profile', 'user', 'builtin']);
+function nonEmptyString(value) {
+    return typeof value === 'string' && value !== '';
+}
+/** Keep the command rows a Gateway can use. Malformed registrations are
+ * discarded individually so one producer cannot take down the inventory. */
+export function gatewayCommandRows(rows) {
+    if (!Array.isArray(rows))
+        return [];
+    const out = [];
+    for (const row of rows) {
+        if (typeof row !== 'object' || row === null)
+            continue;
+        const record = row;
+        if (record['gatewayCapable'] !== true)
+            continue;
+        const source = record['source'];
+        if (source !== 'command' && source !== 'template')
+            continue;
+        if (!nonEmptyString(record['name']) || typeof record['description'] !== 'string')
+            continue;
+        const expansion = record['expansion'];
+        const template = record['template'];
+        const argumentHint = record['argumentHint'];
+        out.push({
+            name: record['name'],
+            description: record['description'],
+            source,
+            ...(nonEmptyString(argumentHint) ? { argument_hint: argumentHint } : {}),
+            ...(isDeterministicCommandExpansion(expansion) ? { expansion } : {}),
+            ...(typeof template === 'string' ? { template } : {}),
+        });
+    }
+    return out;
+}
+export function chatInventoryCommandRows(rows) {
+    if (!Array.isArray(rows))
+        return [];
+    return rows.filter((row) => {
+        if (typeof row !== 'object' || row === null)
+            return false;
+        const record = row;
+        if (!nonEmptyString(record['name']) || typeof record['description'] !== 'string')
+            return false;
+        if (record['source'] !== 'command' && record['source'] !== 'template')
+            return false;
+        if (record['argument_hint'] !== undefined && !nonEmptyString(record['argument_hint']))
+            return false;
+        if (record['template'] !== undefined && typeof record['template'] !== 'string')
+            return false;
+        return record['expansion'] === undefined || isDeterministicCommandExpansion(record['expansion']);
+    });
+}
+export function gatewayCommandRowsFromDetail(detail) {
+    if (detail === undefined)
+        return [];
+    try {
+        return gatewayCommandRows(JSON.parse(detail));
+    }
+    catch {
+        return [];
+    }
+}
+export function chatInventoryMemoryRows(rows) {
+    if (!Array.isArray(rows))
+        return [];
+    return rows.filter((row) => {
+        if (typeof row !== 'object' || row === null)
+            return false;
+        const record = row;
+        return nonEmptyString(record['name'])
+            && typeof record['shortForm'] === 'string'
+            && typeof record['kind'] === 'string'
+            && MEMORY_KINDS.has(record['kind'])
+            && typeof record['scope'] === 'string'
+            && MEMORY_SCOPES.has(record['scope']);
+    });
+}
+export function gatewayMemoryRows(refs) {
+    if (!Array.isArray(refs))
+        return [];
+    const out = [];
+    for (const row of refs) {
+        if (typeof row !== 'object' || row === null)
+            continue;
+        const record = row;
+        if (record['gatewayVisible'] !== true)
+            continue;
+        if (!nonEmptyString(record['name']) || typeof record['shortForm'] !== 'string')
+            continue;
+        if (typeof record['kind'] !== 'string' || !MEMORY_KINDS.has(record['kind']))
+            continue;
+        if (typeof record['scope'] !== 'string' || !MEMORY_SCOPES.has(record['scope']))
+            continue;
+        out.push({
+            name: record['name'],
+            kind: record['kind'],
+            scope: record['scope'],
+            shortForm: record['shortForm'],
+        });
+    }
+    return out;
+}

package/dist/core/runtime/command-surface.d.ts

@@ -25,9 +25,14 @@ export declare function registrationChatSurface(command: unknown): ChatCommandSu
  *  is pi's already-parsed `argument-hint`. A missing file, unreadable path, or
  *  invalid YAML is not chat-capable. */
 export declare function capturePromptTemplateChatSurfaces(templates: unknown): void;
-/** Capture every prompt template a session currently exposes. A broken getter
- *  leaves its templates uncaptured and therefore fail-closed. */
-export declare function captureSessionPromptTemplateChatSurfaces(session: unknown): void;
+/** Capture the Gateway capabilities declared by one completed resource load. */
+export declare function captureChatCapabilities(input: {
+    commands: unknown;
+    templates: unknown;
+}): void;
+/** Capture every startup-declared command and prompt template a session
+ *  currently exposes. A broken getter leaves that surface fail-closed. */
+export declare function captureSessionChatCapabilities(session: unknown): void;
 /** Read the chat surface captured for this loaded template. An uncaptured
  *  template is not disclosed to chat surfaces. */
 export declare function templateChatSurface(template: unknown): ChatCommandSurface;

package/dist/core/runtime/command-surface.js

@@ -18,6 +18,10 @@
 import { readFileSync } from 'node:fs';
 import { parseFrontmatterGeneric } from '../frontmatter.js';
 const NOT_CAPABLE = { gatewayCapable: false };
+// One resource load declares Gateway capability by extension identity and pi's
+// collision-resolved invocation name. Later registrations from that extension
+// retain only names the load declared.
+let startupGatewayNames = new WeakMap();
 // Pi drops unknown prompt frontmatter keys. This cache restores crouter's
 // metadata without re-reading a template during command disclosure.
 const templateChatSurfaces = new WeakMap();
@@ -31,10 +35,33 @@ export function registrationChatSurface(command) {
     if (typeof command !== 'object' || command === null)
         return NOT_CAPABLE;
     const record = command;
-    if (record['gateway'] !== true)
+    const { sourceInfo, invocationName } = record;
+    if (typeof sourceInfo !== 'object' ||
+        sourceInfo === null ||
+        typeof invocationName !== 'string' ||
+        !startupGatewayNames.get(sourceInfo)?.has(invocationName))
         return NOT_CAPABLE;
     return { gatewayCapable: true, ...hintOf(record['argumentHint']) };
 }
+function captureExtensionCommandSurfaces(commands) {
+    startupGatewayNames = new WeakMap();
+    if (!Array.isArray(commands))
+        return;
+    for (const command of commands) {
+        if (typeof command !== 'object' || command === null)
+            continue;
+        const record = command;
+        const { sourceInfo, invocationName } = record;
+        if (record['gateway'] !== true ||
+            typeof sourceInfo !== 'object' ||
+            sourceInfo === null ||
+            typeof invocationName !== 'string')
+            continue;
+        const names = startupGatewayNames.get(sourceInfo) ?? new Set();
+        names.add(invocationName);
+        startupGatewayNames.set(sourceInfo, names);
+    }
+}
 /** Capture prompt-template chat metadata immediately after pi loads or reloads
  *  its templates. The opt-in is the template file's own frontmatter; the hint
  *  is pi's already-parsed `argument-hint`. A missing file, unreadable path, or
@@ -60,16 +87,25 @@ export function capturePromptTemplateChatSurfaces(templates) {
         templateChatSurfaces.set(template, surface);
     }
 }
-/** Capture every prompt template a session currently exposes. A broken getter
- *  leaves its templates uncaptured and therefore fail-closed. */
-export function captureSessionPromptTemplateChatSurfaces(session) {
+/** Capture the Gateway capabilities declared by one completed resource load. */
+export function captureChatCapabilities(input) {
+    captureExtensionCommandSurfaces(input.commands);
+    capturePromptTemplateChatSurfaces(input.templates);
+}
+/** Capture every startup-declared command and prompt template a session
+ *  currently exposes. A broken getter leaves that surface fail-closed. */
+export function captureSessionChatCapabilities(session) {
     try {
         if (typeof session !== 'object' || session === null)
             return;
-        capturePromptTemplateChatSurfaces(session.promptTemplates);
+        const value = session;
+        captureChatCapabilities({
+            commands: value.extensionRunner?.getRegisteredCommands?.(),
+            templates: value.promptTemplates,
+        });
     }
     catch {
-        // Fail closed when an engine cannot expose its prompt templates.
+        // Fail closed when an engine cannot expose its loaded resources.
     }
 }
 /** Read the chat surface captured for this loaded template. An uncaptured

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

@@ -0,0 +1,25 @@
+import type { CreateNodeRequest } from '../../api/dto/nodes.js';
+import type { Mode } from '../canvas/types.js';
+import { type ProfileEntry } from '../profiles/manifest.js';
+import { buildLaunchSpecAsync } from './launch.js';
+export interface ResolvedLaunchTarget {
+    profileId: string | null;
+    profile: ProfileEntry | null;
+    kind: string;
+    mode: Mode;
+    cwd: string;
+    launch: Awaited<ReturnType<typeof buildLaunchSpecAsync>>['launch'];
+}
+export declare function resolveCreateKind(kind: string | undefined, profile: ProfileEntry | null): string;
+/** Validate a kind against the same cwd/profile configuration used to build its launch.
+ *  Resolution is subprocess-isolated: crtrd is single-threaded and a config read can
+ *  block indefinitely on a network filesystem. */
+export declare function assertLaunchKind(kind: string, cwd?: string, profileId?: string | null): Promise<void>;
+/** Resolve the exact profile, kind, cwd, mode and launch recipe a create will use. */
+export declare function resolveLaunchTarget(req: CreateNodeRequest, options?: {
+    readOnlyProfileSelection?: boolean;
+    /** Preserve an existing caller's validation boundary before target resolution. */
+    validateKind?: (kind: string) => void | Promise<void>;
+}): Promise<ResolvedLaunchTarget>;
+/** The directory a new node is pinned to. */
+export declare function resolveNodeCwd(req: CreateNodeRequest, parent: string | undefined, profileId: string | null, contextCwd: string): string;

package/dist/core/runtime/launch-target.js

@@ -0,0 +1,54 @@
+import { resolve } from 'node:path';
+import { getNode } from '../canvas/canvas.js';
+import { usage } from '../errors.js';
+import { assertProfileActive, profileHome } from '../profiles/manifest.js';
+import { buildLaunchSpecAsync, readMergedLaunchConfigAsync } from './launch.js';
+import { resolveProfileId } from './spawn.js';
+export function resolveCreateKind(kind, profile) {
+    return kind ?? profile?.manifest.default_kind ?? 'general';
+}
+/** Validate a kind against the same cwd/profile configuration used to build its launch.
+ *  Resolution is subprocess-isolated: crtrd is single-threaded and a config read can
+ *  block indefinitely on a network filesystem. */
+export async function assertLaunchKind(kind, cwd = process.cwd(), profileId = process.env['CRTR_PROFILE_ID'] || null) {
+    const kinds = Object.keys((await readMergedLaunchConfigAsync(cwd, profileId)).kinds);
+    if (!kinds.includes(kind)) {
+        throw usage(`unknown kind: ${kind}`, { received: kind, next: `Valid kinds: ${kinds.sort().join(', ')}.` });
+    }
+}
+/** Resolve the exact profile, kind, cwd, mode and launch recipe a create will use. */
+export async function resolveLaunchTarget(req, options = {}) {
+    const parent = req.parent ?? undefined;
+    const contextCwd = req.cwd ?? process.cwd();
+    const profileId = await resolveProfileId(req.profile, parent ?? null, contextCwd, {
+        readOnlySelection: options.readOnlyProfileSelection,
+    });
+    const profile = assertProfileActive(profileId);
+    const kind = resolveCreateKind(req.kind, profile);
+    await options.validateKind?.(kind);
+    const cwd = resolveNodeCwd({ ...req, kind }, parent, profileId, contextCwd);
+    if (options.validateKind === undefined)
+        await assertLaunchKind(kind, cwd, profileId);
+    const mode = (req.mode ?? 'base');
+    const launch = (await buildLaunchSpecAsync(kind, mode, {
+        lifecycle: req.root === true ? (req.root_lifecycle ?? 'resident') : 'terminal',
+        hasManager: req.root !== true,
+        ...(req.model !== undefined ? { model: req.model } : {}),
+        cwd,
+        profileId,
+    })).launch;
+    return { profileId, profile, kind, mode, cwd, launch };
+}
+/** The directory a new node is pinned to. */
+export function resolveNodeCwd(req, parent, profileId, contextCwd) {
+    if (req.pin_cwd !== undefined && req.pin_cwd !== '')
+        return resolve(req.pin_cwd);
+    if (parent != null) {
+        const spawner = getNode(parent);
+        if (spawner !== null)
+            return spawner.cwd;
+    }
+    if (req.cwd !== undefined && req.cwd !== '')
+        return resolve(req.cwd);
+    return profileHome(profileId) ?? contextCwd;
+}

package/dist/core/runtime/persona.js

@@ -79,15 +79,15 @@ function baseModeGuidance() {
 }
 // The lifecycle transition prose is the SAME contract that's baked into the
 // static system prompt at birth — so both load from the one source
-// (`personas/lifecycle/{terminal,resident}.md`) and can never drift. The flip
+// (`turn-lifecycle/{terminal,resident}.md`) and can never drift. The flip
 // only re-delivers that fragment as the node's new-state steer.
 /** terminal → resident: interactable, never forced to submit. */
 function residentLifecycleGuidance() {
-    return loadMemoryBody('lifecycle/resident');
+    return loadMemoryBody('turn-lifecycle/resident');
 }
 /** resident → terminal: owes a final, reaps when done. */
 function terminalLifecycleGuidance() {
-    return loadMemoryBody('lifecycle/terminal');
+    return loadMemoryBody('turn-lifecycle/terminal');
 }
 /** Build the injected transition prompt for a `from → to` persona change.
  *  Concatenates the relevant section per changed axis (both when both changed).

package/dist/core/runtime/prospective-inventory-cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/runtime/prospective-inventory-cli.js

@@ -0,0 +1,61 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { DefaultResourceLoader, ExtensionRunner, getAgentDir, } from '@earendil-works/pi-coding-agent';
+import { buildRefInventory } from '../memory/inline-ref-inventory.js';
+import { gatewayCommandRows, gatewayMemoryRows } from './chat-inventory-rows.js';
+import { captureChatCapabilities, registrationChatSurface, templateChatSurface, } from './command-surface.js';
+function parseInput() {
+    const parsed = JSON.parse(readFileSync(0, 'utf8'));
+    if (typeof parsed !== 'object' || parsed === null)
+        throw new Error('preflight input must be an object');
+    const extensions = parsed.extensions;
+    if (!Array.isArray(extensions) || !extensions.every((value) => typeof value === 'string')) {
+        throw new Error('preflight input extensions must be strings');
+    }
+    return { extensions };
+}
+async function main() {
+    const { extensions } = parseInput();
+    const cwd = process.cwd();
+    const loader = new DefaultResourceLoader({
+        cwd,
+        agentDir: getAgentDir(),
+        additionalExtensionPaths: extensions,
+        noContextFiles: true,
+    });
+    await loader.reload();
+    const loaded = loader.getExtensions();
+    const templates = loader.getPrompts().prompts;
+    // getRegisteredCommands only reads extension maps and applies pi's collision
+    // naming. The unbound placeholders make every action path unavailable.
+    const runner = new ExtensionRunner(loaded.extensions, loaded.runtime, cwd, undefined, undefined);
+    const commands = runner.getRegisteredCommands();
+    captureChatCapabilities({ commands, templates });
+    const disclosures = [
+        ...commands.map((command) => {
+            const expansion = command.expansion;
+            return {
+                name: command.invocationName,
+                description: command.description ?? '',
+                source: 'command',
+                ...(expansion !== undefined ? { expansion } : {}),
+                ...registrationChatSurface(command),
+            };
+        }),
+        ...templates.map((template) => ({
+            name: template.name,
+            description: template.description,
+            source: 'template',
+            template: template.content,
+            ...templateChatSurface(template),
+        })),
+    ];
+    const memory = buildRefInventory();
+    writeFileSync(3, `${JSON.stringify({
+        commands: gatewayCommandRows(disclosures),
+        memory_refs: gatewayMemoryRows(memory.refs),
+    })}\n`);
+}
+main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
+    process.exitCode = 1;
+});

package/dist/core/runtime/prospective-inventory.d.ts

@@ -0,0 +1,10 @@
+import type { ChatInventoryCommandDTO, ChatInventoryMemoryRefDTO } from '../../api/dto/chat-inventory.js';
+export interface ProspectiveInventoryRows {
+    commands: ChatInventoryCommandDTO[];
+    memory_refs: ChatInventoryMemoryRefDTO[];
+}
+export declare function runProspectiveInventory(input: {
+    cwd: string;
+    profileId: string | null;
+    extensions: string[];
+}): Promise<ProspectiveInventoryRows>;