@north-light/api 0.3.580 → 0.3.588

package/dist/core/preview-registry.js

@@ -0,0 +1,403 @@
+// Bundle-safe mirror of LeafHelp.preview metadata (see help.ts's PreviewMeta),
+// keyed by the leaf's full help name (e.g. "canvas snapshot", matching
+// LeafHelp.name exactly).
+//
+// This file has NO imports. The attach viewer is bundled as a separate
+// esbuild process from the one that runs a leaf, so it cannot read a leaf's
+// command-owned `preview` field directly — walking the live command tree
+// to find it would pull every subtree's module graph into the attach bundle.
+// A flat, zero-dependency static map avoids that entirely.
+//
+// Source of truth: this Set must mirror every leaf that declares
+// `help.preview.suppressOutput: true` in its own command file (currently
+// canvas roster, canvas snapshot, node inspect snapshot, node inspect show,
+// and sys context sysprompt). There is no automated sync — when you add or remove a leaf's
+// `preview.suppressOutput`, update this Set in the same commit.
+export const SUPPRESS_OUTPUT_LEAVES = new Set([
+    'canvas roster',
+    'canvas snapshot',
+    'node inspect snapshot',
+    'node inspect show',
+    'sys context sysprompt',
+]);
+/** True when the leaf at this full help-name path (e.g. "canvas snapshot")
+ *  declares `preview.suppressOutput: true`. */
+export function suppressOutputForLeaf(helpName) {
+    return SUPPRESS_OUTPUT_LEAVES.has(helpName);
+}
+/** Same lookup from argv tokens (e.g. ['node', 'inspect', 'snapshot', 'abc'])
+ *  instead of a pre-joined help name. Matches a registered leaf name against
+ *  a *prefix* of the tokens, not the whole joined tail, so a leaf's own
+ *  positional arguments (e.g. the snapshot id in `node inspect snapshot
+ *  abc`) don't prevent the match. */
+export function suppressOutputForPath(tokens) {
+    for (const leaf of SUPPRESS_OUTPUT_LEAVES) {
+        const words = leaf.split(' ');
+        if (words.length <= tokens.length && words.every((word, i) => tokens[i] === word))
+            return true;
+    }
+    return false;
+}
+// Icon registry (rule 12, inline-ui-placement: real Nerd Font glyphs, not the
+// generic ◆ diamond). Every leaf's glyph is looked up first in LEAF_ICON_CP
+// (longest-prefix match, same shape as SUPPRESS_OUTPUT_LEAVES); an unmapped
+// leaf falls back to its root family's glyph in FAMILY_ICON_CP.
+/** question-circle — the header glyph for a `-h`/`--help` invocation,
+ *  regardless of which command's help was requested. */
+const HELP_ICON_CP = 0xf059;
+export const HELP_ICON = String.fromCodePoint(HELP_ICON_CP);
+/** Glyphs for the plain agent tools the attach viewer re-skins (render/tool-calls.ts).
+ *  Same registry as the crtr command icons so every Nerd Font codepoint the viewer
+ *  paints lives in one file: terminal for `bash`, file-text for `read`, floppy for
+ *  `write` (content committed to disk), pencil-square for `edit`. */
+export const TOOL_ICON = {
+    bash: String.fromCodePoint(0xf120),
+    read: String.fromCodePoint(0xf15c),
+    write: String.fromCodePoint(0xf0c7),
+    edit: String.fromCodePoint(0xf044),
+};
+/** One glyph per root family (`crtr <family> ...`) — the fallback for any
+ *  leaf not listed in LEAF_ICON_CP below. Codepoints are Nerd Font
+ *  private-use-area icons chosen per family concept (see command-icons.md).
+ *  Families a plugin mounts (capture, device, exa-search) are listed here too: this
+ *  registry is keyed by command path, not by who owns the command. */
+const FAMILY_ICON_CP = {
+    canvas: 0xf0e8,
+    capture: 0xf03d,
+    device: 0xf109,
+    doc: 0xf02d,
+    human: 0xf007,
+    node: 0xf192,
+    pkg: 0xf1b2,
+    profile: 0xf2bd,
+    push: 0xf0ee,
+    'exa-search': 0xf002,
+    surface: 0xf108,
+    sys: 0xf013,
+};
+/** Per-leaf overrides, keyed by full leaf help-name path (e.g. "doc
+ *  lint"), same shape as SUPPRESS_OUTPUT_LEAVES. */
+export const LEAF_ICON_CP = {
+    'canvas dashboard': 0xf0e4,
+    'canvas snapshot': 0xf030,
+    'canvas browse': 0xf14e,
+    'canvas attention count': 0xf292,
+    'canvas attention list': 0xf03a,
+    'canvas attention map': 0xf279,
+    'canvas revive': 0xf021,
+    'node lifecycle revive': 0xf021,
+    'canvas list': 0xf03a,
+    'canvas read': 0xf02d,
+    'canvas search': 0xf002,
+    'canvas history search': 0xf002,
+    'canvas history grep': 0xf0b0,
+    'sys daemon start': 0xf04b,
+    'sys daemon status': 0xf111,
+    'sys daemon stop': 0xf04d,
+    'canvas chord': 0xf001,
+    'surface tmux-spread': 0xf009,
+    'canvas issue new': 0xf188,
+    'canvas prune': 0xf0c4,
+    'human send': 0xf059,
+    'human review': 0xf044,
+    'human show': 0xf108,
+    'human cancel': 0xf00d,
+    'human list': 0xf03a,
+    'human resolve': 0xf00c,
+    'doc write': 0xf040,
+    'doc edit': 0xf044,
+    'doc history': 0xf1da,
+    'doc lint': 0xf14a,
+    'node new': 0xf067,
+    'node message send': 0xf0e0,
+    'node message request': 0xf0e0,
+    'cron add': 0xf017,
+    'node wait deadline': 0xf017,
+    'node subscription add': 0xf0f3,
+    'node subscription remove': 0xf1f6,
+    'node promote': 0xf102,
+    'node yield': 0xf28d,
+    'surface node focus': 0xf05b,
+    'surface node cycle': 0xf021,
+    'node inspect list': 0xf03a,
+    'node inspect show': 0xf06e,
+    'node inspect snapshot': 0xf030,
+    'node inspect context': 0xf07c,
+    'node lifecycle recycle': 0xf1b8,
+    'node lifecycle close': 0xf00d,
+    'node lifecycle demote': 0xf103,
+    'node config': 0xf013,
+    'cron list': 0xf017,
+    'cron cancel': 0xf05e,
+    'pkg plugin install': 0xf019,
+    'pkg plugin remove': 0xf014,
+    'pkg plugin enable': 0xf00c,
+    'pkg plugin disable': 0xf05e,
+    'pkg plugin update': 0xf021,
+    'pkg plugin list': 0xf03a,
+    'pkg plugin show': 0xf06e,
+    'pkg market add': 0xf067,
+    'pkg market remove': 0xf014,
+    'pkg market update': 0xf021,
+    'pkg market list': 0xf03a,
+    'pkg market browse': 0xf14e,
+    'push update': 0xf093,
+    'push final': 0xf11e,
+    'exa-search web': 0xf0ac,
+    'exa-search answer': 0xf075,
+    'exa-search contents': 0xf0f6,
+    'surface attach to': 0xf1e6,
+    'sys config get': 0xf019,
+    'sys config set': 0xf040,
+    'sys config path': 0xf07b,
+    'sys settings': 0xf013,
+    'sys setup': 0xf0ad,
+    'sys doctor': 0xf0f1,
+    'sys context sysprompt': 0xf15c,
+    'sys context prompt-review': 0xf002,
+    'sys feedback': 0xf075,
+    'sys update': 0xf021,
+    'sys version': 0xf02b,
+    'sys sync': 0xf079,
+};
+/** Resolve the Nerd Font glyph for a command's argv tokens: the longest
+ *  matching LEAF_ICON_CP prefix, else the tokens[0] family glyph, else the
+ *  generic ◆ fallback for an unmapped family. */
+export function iconForPath(tokens) {
+    let best;
+    for (const [leaf, cp] of Object.entries(LEAF_ICON_CP)) {
+        const words = leaf.split(' ');
+        if (words.length <= tokens.length && words.every((word, i) => tokens[i] === word)) {
+            if (best === undefined || words.length > best.words)
+                best = { words: words.length, cp };
+        }
+    }
+    if (best !== undefined)
+        return String.fromCodePoint(best.cp);
+    const familyCp = tokens.length > 0 ? FAMILY_ICON_CP[tokens[0]] : undefined;
+    return familyCp !== undefined ? String.fromCodePoint(familyCp) : '◆';
+}
+function plainObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+/** Every crtr invocation's own structured result in one bash tool result, in
+ *  invocation order — mirrored onto `details` by the canvas preview extension
+ *  (pi-extensions/canvas-preview-result.ts), and present on live tool events and
+ *  on rebuilt snapshot messages alike.
+ *
+ *  `crtrPreviews` carries every invocation in the call; `crtrPreview` (the last
+ *  record alone) is all a transcript persisted before the channel became a list
+ *  can offer, so both are read. This validates only the transport envelope —
+ *  command-owned summaries validate the fields they use. */
+export function crtrPreviewRecords(result) {
+    const details = plainObject(plainObject(result)?.['details']);
+    if (details === undefined)
+        return [];
+    const all = details['crtrPreviews'];
+    const records = Array.isArray(all) ? all : [details['crtrPreview']];
+    return records.flatMap((entry) => {
+        const record = plainObject(entry);
+        if (record === undefined || typeof record['path'] !== 'string')
+            return [];
+        const jsonl = record['jsonl'];
+        return [{
+                path: record['path'],
+                result: plainObject(record['result']),
+                jsonl: Array.isArray(jsonl) ? jsonl.flatMap((row) => {
+                    const parsed = plainObject(row);
+                    return parsed === undefined ? [] : [parsed];
+                }) : undefined,
+                error: plainObject(record['error']),
+            }];
+    });
+}
+const CANVAS_READ_LINES = 4;
+function record(input) {
+    return input.result;
+}
+function stringField(value, name) {
+    const field = value[name];
+    return typeof field === 'string' && field !== '' ? field : undefined;
+}
+function booleanField(value, name) {
+    return typeof value[name] === 'boolean' ? value[name] : undefined;
+}
+function numberField(value, name) {
+    return typeof value[name] === 'number' && Number.isFinite(value[name]) ? value[name] : undefined;
+}
+function arrayField(value, name) {
+    const field = value[name];
+    return Array.isArray(field) && field.every((item) => item !== null && typeof item === 'object' && !Array.isArray(item))
+        ? field
+        : undefined;
+}
+function basename(path) {
+    const trimmed = path.replace(/[\\/]+$/, '');
+    const idx = Math.max(trimmed.lastIndexOf('/'), trimmed.lastIndexOf('\\'));
+    return idx === -1 ? trimmed : trimmed.slice(idx + 1);
+}
+function truncateLine(line, max) {
+    return line.length > max ? `${line.slice(0, max).trimEnd()}…` : line;
+}
+function topNames(rows, key, cap = 5) {
+    const names = rows.map((row) => stringField(row, key));
+    if (names.some((name) => name === undefined))
+        return undefined;
+    const shown = names.slice(0, cap);
+    const remaining = names.length - shown.length;
+    return remaining > 0 ? `${shown.join(', ')}, … ${remaining} more` : shown.join(', ');
+}
+function summarizeError(input) {
+    const error = input.error;
+    if (error === undefined)
+        return null;
+    const code = stringField(error, 'error');
+    const message = stringField(error, 'message');
+    if (code === undefined || message === undefined)
+        return null;
+    return [{ text: code, tone: 'error' }, { text: truncateLine(message, 160), tone: 'muted' }];
+}
+/** `canvas read`: the object's header line and the first lines under it; a deleted or remote
+ *  answer is its one line. */
+function summarizeCanvasRead(input) {
+    const value = record(input);
+    if (value === undefined)
+        return null;
+    const other = stringField(value, 'deleted') ?? stringField(value, 'remote');
+    if (other !== undefined)
+        return [{ text: other.trim().split('\n')[0] ?? '', tone: 'warning' }];
+    const object = stringField(value, 'readMetadata') ?? stringField(value, 'object');
+    if (object === undefined)
+        return null;
+    const lines = object.split('\n').filter((line) => line.trim() !== '' && !line.startsWith('<auto-loaded-context') && !line.startsWith('</auto-loaded-context'));
+    if (lines.length === 0)
+        return null;
+    return [{ text: lines[0] }, ...lines.slice(1, CANVAS_READ_LINES).map((text) => ({ text, tone: 'muted' }))];
+}
+function summarizeCount(label, successZero = false) {
+    return (input) => {
+        const value = record(input);
+        const count = value === undefined ? undefined : numberField(value, 'count') ?? numberField(value, 'total');
+        if (count === undefined)
+            return null;
+        if (count === 0 && successZero)
+            return [{ text: `PASS · no ${label}`, tone: 'success' }];
+        return [{ text: `${count} ${label}`, tone: count === 0 ? 'muted' : 'plain' }];
+    };
+}
+function summarizeArray(label, field = 'items') {
+    return (input) => {
+        const value = record(input);
+        if (value === undefined)
+            return null;
+        const rows = arrayField(value, field);
+        const total = numberField(value, 'total') ?? (rows?.length);
+        if (rows === undefined || total === undefined)
+            return null;
+        const lines = [{ text: `${total} ${label}`, tone: total === 0 ? 'muted' : 'plain' }];
+        const names = topNames(rows, 'name');
+        if (names !== undefined && names !== '')
+            lines.push({ text: names, tone: 'muted' });
+        return lines;
+    };
+}
+function summarizeAttentionMap(input) {
+    const value = record(input);
+    const counts = value?.['counts'];
+    if (counts === null || typeof counts !== 'object' || Array.isArray(counts))
+        return null;
+    const entries = Object.entries(counts);
+    if (entries.some(([, count]) => typeof count !== 'number'))
+        return null;
+    const total = entries.reduce((sum, [, count]) => sum + count, 0);
+    if (total === 0)
+        return [{ text: 'PASS · no pending asks', tone: 'success' }];
+    const hottest = entries.filter(([, count]) => count > 0).sort((a, b) => b[1] - a[1])[0];
+    return hottest === undefined ? null : [{ text: `${total} asks`, tone: 'warning' }, { text: `hottest: ${hottest[0]} (${hottest[1]})`, tone: 'muted' }];
+}
+function summarizeDaemon(field, active, inactive) {
+    return (input) => {
+        const value = record(input);
+        if (value === undefined)
+            return null;
+        const state = booleanField(value, field);
+        if (state === undefined)
+            return null;
+        const pid = numberField(value, 'pid') ?? numberField(value, 'existing_pid');
+        return [{ text: state ? `${active}${pid === undefined ? '' : ` · pid ${pid}`}` : inactive, tone: state ? 'success' : 'muted' }];
+    };
+}
+function summarizeHumanSend(input) {
+    const value = record(input);
+    if (value === undefined || stringField(value, 'page_id') === undefined)
+        return null;
+    const reply = booleanField(value, 'reply');
+    if (reply === undefined)
+        return null;
+    return [{ text: reply ? 'page sent → waiting on human' : 'announcement sent', tone: reply ? 'accent' : 'success' }];
+}
+function summarizeHumanResolve(input) {
+    const value = record(input);
+    if (value === undefined)
+        return null;
+    const resolved = booleanField(value, 'resolved');
+    const job = stringField(value, 'job_id');
+    if (resolved === undefined || job === undefined)
+        return null;
+    return [{ text: `${resolved ? 'resolved' : 'not resolved'} ${job}`, tone: resolved ? 'success' : 'warning' }];
+}
+function summarizeStatus(input) {
+    const value = record(input);
+    if (value === undefined)
+        return null;
+    const status = stringField(value, 'status');
+    if (status === undefined)
+        return null;
+    return [{ text: status, tone: ['done', 'success', 'submitted', 'filed'].includes(status) ? 'success' : status === 'failed' ? 'error' : 'plain' }];
+}
+function summarizeProfileList(input) {
+    const records = input.jsonl;
+    if (records === undefined)
+        return null;
+    const profiles = records.filter((item) => stringField(item, 'name') !== undefined && numberField(item, 'projects_count') !== undefined);
+    if (profiles.length === 0 && records.length > 0)
+        return null;
+    return [
+        { text: `${profiles.length} profile${profiles.length === 1 ? '' : 's'}` },
+        ...profiles.slice(0, 5).map((profile) => ({ text: `${stringField(profile, 'name')} · ${numberField(profile, 'projects_count')} projects`, tone: 'muted' })),
+    ];
+}
+export const SUMMARIZERS = [
+    { path: 'canvas read', run: summarizeCanvasRead },
+    { path: 'canvas list', run: summarizeArray('objects') },
+    { path: 'canvas search', run: summarizeArray('hits') },
+    { path: 'canvas attention count', run: summarizeCount('pending asks', true) },
+    { path: 'canvas attention list', run: summarizeArray('pending asks') },
+    { path: 'canvas attention map', run: summarizeAttentionMap },
+    { path: 'human send', run: summarizeHumanSend },
+    { path: 'human list', run: summarizeArray('pending') },
+    { path: 'human resolve', run: summarizeHumanResolve },
+    { path: 'pkg plugin list', run: summarizeArray('plugins') },
+    { path: 'pkg market list', run: summarizeArray('marketplaces') },
+    { path: 'pkg market browse', run: summarizeArray('plugins') },
+    { path: 'canvas dashboard', run: summarizeArray('nodes', 'rows') },
+    { path: 'node inspect list', run: summarizeArray('nodes', 'nodes') },
+    { path: 'sys daemon start', run: summarizeDaemon('started', 'started', 'already running') },
+    { path: 'sys daemon status', run: summarizeDaemon('running', 'running', 'not running') },
+    { path: 'sys daemon stop', run: summarizeDaemon('stopped', 'stopped', 'was not running') },
+    { path: 'sys update', run: summarizeStatus },
+    { path: 'sys feedback', run: summarizeStatus },
+    { path: 'profile list', run: summarizeProfileList },
+];
+/** Summarize an exact CLI result record. The recorded path is authoritative:
+ * shell tokenization is used only for an invocation's static icon/help chrome,
+ * never to identify or decode the returned leaf data. */
+export function summarizePath(preview, tokens = []) {
+    const error = summarizeError(preview);
+    if (error !== null)
+        return error;
+    const best = SUMMARIZERS.find(({ path }) => path === preview.path);
+    return best?.run(preview, tokens) ?? null;
+}

package/dist/core/profiles/default-binding.d.ts

@@ -0,0 +1,15 @@
+export declare function resolveBindingCwd(cwd: string): string;
+export declare function getDefaultProfileId(cwd: string): string | null;
+export declare function setDefaultProfileId(cwd: string, profileId: string): Promise<void>;
+export declare function clearDefaultProfile(cwd: string): Promise<void>;
+export declare function defaultProfileDirs(profileId: string): string[];
+export declare function clearDefaultProfileId(profileId: string): Promise<string[]>;
+export declare function listDefaultPins(): Array<{
+    dir: string;
+    profileId: string;
+}>;
+/** Drop every pin whose directory no longer exists; returns what was removed. */
+export declare function clearMissingDefaultDirs(): Promise<Array<{
+    dir: string;
+    profile_id: string;
+}>>;

package/dist/core/profiles/default-binding.js

@@ -0,0 +1,29 @@
+// Per-directory default-profile pins are user-root SQL state. Profile identity
+// remains stable across renames, so the pin stores only the generated id.
+import { existsSync, realpathSync } from 'node:fs';
+import { resolve as resolvePath } from 'node:path';
+import { cachedDefaults, writeSettings } from '../scoped-state/person-store.js';
+export function resolveBindingCwd(cwd) {
+    const abs = resolvePath(cwd);
+    if (!existsSync(abs))
+        return abs;
+    try {
+        return realpathSync(abs);
+    }
+    catch {
+        return abs;
+    }
+}
+function bindings() { return cachedDefaults(); }
+export function getDefaultProfileId(cwd) { return bindings()[resolveBindingCwd(cwd)] ?? null; }
+async function replaceDefaults(mutate) {
+    await writeSettings((snapshot) => [{ op: 'defaults.replace', defaults: mutate({ ...snapshot.defaults }) }]);
+}
+export async function setDefaultProfileId(cwd, profileId) { const directory = resolveBindingCwd(cwd); await replaceDefaults((current) => ({ ...current, [directory]: profileId })); }
+export async function clearDefaultProfile(cwd) { const directory = resolveBindingCwd(cwd); await replaceDefaults((current) => { const next = { ...current }; delete next[directory]; return next; }); }
+export function defaultProfileDirs(profileId) { return Object.entries(bindings()).filter(([, id]) => id === profileId).map(([directory]) => directory).sort(); }
+export async function clearDefaultProfileId(profileId) { let cleared = []; await replaceDefaults((current) => { cleared = Object.entries(current).filter(([, id]) => id === profileId).map(([directory]) => directory).sort(); const next = { ...current }; for (const directory of cleared)
+    delete next[directory]; return next; }); return cleared; }
+export function listDefaultPins() { return Object.entries(bindings()).map(([dir, profileId]) => ({ dir, profileId })).sort((a, b) => a.dir.localeCompare(b.dir)); }
+/** Drop every pin whose directory no longer exists; returns what was removed. */
+export async function clearMissingDefaultDirs() { let removed = []; await replaceDefaults((current) => { removed = Object.entries(current).filter(([directory]) => !existsSync(directory)).map(([dir, profile_id]) => ({ dir, profile_id })).sort((a, b) => a.dir.localeCompare(b.dir)); const gone = new Set(removed.map((r) => r.dir)); return Object.fromEntries(Object.entries(current).filter(([directory]) => !gone.has(directory))); }); return removed; }

package/dist/core/profiles/deletion-reservation.d.ts

@@ -0,0 +1,12 @@
+/** Reserve one profile identity for its complete daemon-owned deletion lifecycle.
+ * The caller must release the returned lease after completion or failure. */
+export declare function reserveProfileDeletion(profileId: string): () => void;
+/** The synchronous birth gate. spawnNode calls this immediately before the
+ * canvas row is persisted, so EVERY birth passes here — the API create, forks,
+ * cron spawns, warm-pool mints, `/new` relaunch, and recycle alike. A
+ * reservation rejects a birth that reaches the gate during deletion; the exact
+ * manifest read rejects one whose async preflight started before a fast hard
+ * deletion and resumed after its lease was released; a paused profile is inert
+ * and creates nothing. `POST /v1/nodes` gates earlier only to phrase the paused
+ * refusal against the operand the caller actually typed. */
+export declare function assertProfileAvailableForBirth(profileId: string | null): void;

package/dist/core/profiles/deletion-reservation.js

@@ -0,0 +1,42 @@
+import { usage } from '../errors.js';
+import { assertProfileEntryActive, loadExactProfileManifest } from './manifest.js';
+const deletingProfileIds = new Set();
+/** Reserve one profile identity for its complete daemon-owned deletion lifecycle.
+ * The caller must release the returned lease after completion or failure. */
+export function reserveProfileDeletion(profileId) {
+    if (deletingProfileIds.has(profileId)) {
+        throw usage(`profile deletion is already in progress: ${profileId}`, {
+            error: 'profile_deletion_in_progress',
+            profile_id: profileId,
+            next: 'Wait for the accepted deletion to finish before using this profile again.',
+        });
+    }
+    deletingProfileIds.add(profileId);
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        deletingProfileIds.delete(profileId);
+    };
+}
+/** The synchronous birth gate. spawnNode calls this immediately before the
+ * canvas row is persisted, so EVERY birth passes here — the API create, forks,
+ * cron spawns, warm-pool mints, `/new` relaunch, and recycle alike. A
+ * reservation rejects a birth that reaches the gate during deletion; the exact
+ * manifest read rejects one whose async preflight started before a fast hard
+ * deletion and resumed after its lease was released; a paused profile is inert
+ * and creates nothing. `POST /v1/nodes` gates earlier only to phrase the paused
+ * refusal against the operand the caller actually typed. */
+export function assertProfileAvailableForBirth(profileId) {
+    if (profileId === null)
+        return;
+    if (deletingProfileIds.has(profileId)) {
+        throw usage(`cannot create a node while its profile is being deleted: ${profileId}`, {
+            error: 'profile_deletion_in_progress',
+            profile_id: profileId,
+            next: 'Choose another profile or wait for this deletion to finish.',
+        });
+    }
+    assertProfileEntryActive(loadExactProfileManifest(profileId));
+}

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

@@ -0,0 +1,46 @@
+import { type ProfileEntry } from './manifest.js';
+import { type BindingId, type BindingResolution, type RawTerminalInput } from '../keybindings/index.js';
+declare const PROFILE_MENU_ACTIONS: readonly ["crtr.profile.menu.abort", "crtr.profile.menu.up", "crtr.profile.menu.down", "crtr.profile.menu.select", "crtr.profile.menu.accept-default", "crtr.profile.menu.slot.1", "crtr.profile.menu.slot.2", "crtr.profile.menu.slot.3", "crtr.profile.menu.slot.4", "crtr.profile.menu.slot.5", "crtr.profile.menu.slot.6", "crtr.profile.menu.slot.7", "crtr.profile.menu.slot.8", "crtr.profile.menu.slot.9", "crtr.profile.menu.create", "crtr.profile.menu.search-existing", "crtr.profile.menu.use-root", "crtr.profile.menu.set-default", "crtr.profile.menu.add-directory", "crtr.profile.menu.unpin", "crtr.profile.menu.manage"];
+declare const PROFILE_SEARCH_ACTIONS: readonly ["crtr.profile.search.abort", "crtr.profile.search.back", "crtr.profile.search.pick", "crtr.profile.search.up", "crtr.profile.search.down", "crtr.profile.search.delete"];
+export declare function resolveProfileMenuAction(bindings: BindingResolution<BindingId>, raw: RawTerminalInput): (typeof PROFILE_MENU_ACTIONS)[number] | null;
+export declare function resolveProfileSearchAction(bindings: BindingResolution<BindingId>, raw: RawTerminalInput): (typeof PROFILE_SEARCH_ACTIONS)[number] | null;
+/** Whether a profile's purview covers `cwd` (cwd at/under one of its project
+ *  dirs, or a project dir under cwd — the workspace-root case). Exported for
+ *  `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 it as a user-typed operand (exact id,
+ *     exact name, then the closest fuzzy match — nobody recalls the generated
+ *     `<slug>-<8hex>` id, and a near-miss name should still start the session). If
+ *     its manifest does not already cover `cwd` and the session is interactive,
+ *     offer to add `cwd` to its purview (default yes). Bump `last_used_at`,
+ *     return the id.
+ *  1b. Else, a per-cwd PINNED default (menu `d`) that still covers `cwd` is
+ *     auto-picked outright — interactive and headless alike, no prompt (that is
+ *     what "default" means). Interactive prints a breadcrumb naming it and how
+ *     to change it. `forcePicker` (`crtr --pick-profile`) bypasses the pin to
+ *     re-open the menu. A stale pin (profile gone / no longer covering) is
+ *     cleared and ignored.
+ *  2. Else, if EXACTLY ONE profile's project dir IS `cwd` (you're at a project
+ *     root, unambiguously one owner), auto-pick it with no prompt — the
+ *     strongest signal. If SEVERAL profiles claim `cwd` exactly, it's genuinely
+ *     ambiguous: interactive → menu among them + create; headless → MRU.
+ *  3. Else, among profiles whose project list otherwise COVERS `cwd` (cwd sits
+ *     in a subdir of, or a workspace above, one of their project dirs):
+ *       - Interactive: prompt with a MENU of those covering profiles + "create
+ *         a new profile here", BEFORE pi boots (no root option — the directory
+ *         is covered). Default is the MRU covering profile.
+ *       - Non-interactive: auto-pick the MRU covering profile, no prompt.
+ *  4. Else — nothing covers cwd walking all the way up. Interactive: prompt to
+ *     create a profile here, select an existing profile (a searchable list of
+ *     every profile, for when you started somewhere none of them cover and
+ *     can't recall the exact name — the pick then offers to adopt cwd), or use
+ *     the root profile. Non-interactive (no TTY):
+ *     default to the root profile and print the recovery instruction to STDERR —
+ *     never stdout, which the caller may be piping. */
+export declare function selectProfileForCwd(cwd: string, explicitProfile?: string | null, forcePicker?: boolean): Promise<string>;
+export {};