@crouton-kit/crouter 0.3.70 → 0.3.78

package/dist/core/keybindings/match.js

@@ -0,0 +1,99 @@
+import { normalizeStroke } from './resolve.js';
+const KEY_LABELS = {
+    enter: 'Enter',
+    escape: 'Esc',
+    tab: 'Tab',
+    backspace: 'Backspace',
+    delete: 'Delete',
+    space: 'Space',
+    up: 'Up',
+    down: 'Down',
+    left: 'Left',
+    right: 'Right',
+    pageup: 'PageUp',
+    pagedown: 'PageDown',
+    home: 'Home',
+    end: 'End',
+};
+export function formatStroke(stroke) {
+    let key;
+    let modifiers;
+    if (stroke === '+') {
+        key = '+';
+        modifiers = [];
+    }
+    else if (stroke.endsWith('++')) {
+        key = '+';
+        modifiers = stroke.slice(0, -2).split('+');
+    }
+    else {
+        const parts = stroke.split('+');
+        key = parts.pop();
+        modifiers = parts;
+    }
+    const labels = modifiers.map((modifier) => modifier[0].toUpperCase() + modifier.slice(1));
+    labels.push(KEY_LABELS[key] ?? (key.length === 1 ? key.toUpperCase() : key));
+    return labels.join('+');
+}
+export function formatGesture(gesture) {
+    return gesture.split(' > ').map(formatStroke).join(' then ');
+}
+export function formatBinding(bindingSet, id) {
+    const gestures = bindingSet.gestures(id);
+    return gestures.length === 0 ? 'Disabled' : gestures.map(formatGesture).join(' / ');
+}
+export function canonicalTerminalStroke(raw) {
+    let key = null;
+    if (raw.upArrow)
+        key = 'up';
+    else if (raw.downArrow)
+        key = 'down';
+    else if (raw.leftArrow)
+        key = 'left';
+    else if (raw.rightArrow)
+        key = 'right';
+    else if (raw.return)
+        key = 'enter';
+    else if (raw.escape)
+        key = 'escape';
+    else if (raw.shiftTab)
+        return 'shift+tab';
+    else if (raw.tab)
+        key = 'tab';
+    else if (raw.backspace)
+        key = 'backspace';
+    else if (raw.delete)
+        key = 'delete';
+    else if (raw.pageUp)
+        key = 'pageup';
+    else if (raw.pageDown)
+        key = 'pagedown';
+    else if (raw.home)
+        key = 'home';
+    else if (raw.end)
+        key = 'end';
+    else if (raw.input?.length === 1)
+        key = raw.input === ' ' ? 'space' : raw.input;
+    if (key === null)
+        return null;
+    const modifiers = [];
+    if (raw.ctrl)
+        modifiers.push('ctrl');
+    if (raw.meta)
+        modifiers.push('alt');
+    if (raw.shift)
+        modifiers.push('shift');
+    try {
+        return normalizeStroke([...modifiers, key].join('+'));
+    }
+    catch {
+        return null;
+    }
+}
+export function matchesTerminalInput(bindingSet, id, raw) {
+    const stroke = canonicalTerminalStroke(raw);
+    return stroke !== null && bindingSet.gestures(id).includes(stroke);
+}
+export function matchesPiTuiInput(bindingSet, id, input, matchesKey) {
+    return bindingSet.gestures(id).some((gesture) => !gesture.includes(' > ') && matchesKey(input, gesture));
+}

package/dist/core/keybindings/persistence.d.ts

@@ -0,0 +1,14 @@
+import type { BindingId } from './catalog.js';
+import type { SparseKeybindingOverrides } from './types.js';
+export declare class KeybindingConcurrentEditError extends Error {
+    readonly latestKeybindings: unknown;
+    constructor(latestKeybindings: unknown);
+}
+export interface PersistKeybindingsOptions {
+    readonly expectedKeybindings?: unknown;
+}
+export interface PersistedKeybindings {
+    readonly path: string;
+    readonly overrides: SparseKeybindingOverrides<BindingId>;
+}
+export declare function persistUserKeybindings(prospectiveOverrides: unknown, options?: PersistKeybindingsOptions): PersistedKeybindings;

package/dist/core/keybindings/persistence.js

@@ -0,0 +1,31 @@
+import { isDeepStrictEqual } from 'node:util';
+import { configPath, updateRawConfigAtomically } from '../config.js';
+import { normalizeSparseOverrides } from './resolve.js';
+export class KeybindingConcurrentEditError extends Error {
+    latestKeybindings;
+    constructor(latestKeybindings) {
+        super('keybindings changed on disk; reload before saving');
+        this.name = 'KeybindingConcurrentEditError';
+        this.latestKeybindings = latestKeybindings;
+    }
+}
+export function persistUserKeybindings(prospectiveOverrides, options = {}) {
+    const overrides = normalizeSparseOverrides(prospectiveOverrides);
+    const path = configPath('user');
+    if (path === null)
+        throw new Error('user config path is unavailable');
+    updateRawConfigAtomically('user', (latest) => {
+        if (Object.hasOwn(options, 'expectedKeybindings')
+            && !isDeepStrictEqual(latest['keybindings'], options.expectedKeybindings)) {
+            throw new KeybindingConcurrentEditError(latest['keybindings']);
+        }
+        const next = { ...latest };
+        delete next['canvasNav'];
+        if (Object.keys(overrides).length === 0)
+            delete next['keybindings'];
+        else
+            next['keybindings'] = overrides;
+        return next;
+    });
+    return Object.freeze({ path, overrides: Object.freeze({ ...overrides }) });
+}

package/dist/core/keybindings/resolve.d.ts

@@ -0,0 +1,14 @@
+import type { BindingId } from './catalog.js';
+import type { BindingDefinition, BindingResolution, KeybindingDiagnostic, SparseKeybindingOverrides } from './types.js';
+export declare class GestureSyntaxError extends Error {
+    constructor(message: string);
+}
+export declare function normalizeStroke(raw: string): string;
+export declare function normalizeGesture(raw: string, definition?: Pick<BindingDefinition, 'inputKind'>): string;
+export declare function resolveKeybindings(rawOverrides?: unknown): BindingResolution<BindingId>;
+export declare function resolveUserKeybindings(): BindingResolution<BindingId>;
+export declare function normalizeSparseOverrides(rawOverrides: unknown): SparseKeybindingOverrides<BindingId>;
+export declare class KeybindingValidationError extends Error {
+    readonly diagnostics: readonly KeybindingDiagnostic[];
+    constructor(diagnostics: readonly KeybindingDiagnostic[]);
+}

package/dist/core/keybindings/resolve.js

@@ -0,0 +1,305 @@
+import { isDeepStrictEqual } from 'node:util';
+import { BINDING_CATALOG, BINDING_IDS, SAFETY_REQUIREMENTS } from './catalog.js';
+import { readRawScopeConfig } from '../config.js';
+const MODIFIER_ORDER = ['ctrl', 'alt', 'shift'];
+const INPUT_MODIFIERS = new Set(['ctrl', 'alt', 'shift', 'meta']);
+const NAMED_KEYS = new Set([
+    'enter', 'escape', 'tab', 'backspace', 'delete', 'space', 'up', 'down',
+    'left', 'right', 'pageup', 'pagedown', 'home', 'end',
+]);
+const KEY_ALIASES = { return: 'enter', esc: 'escape' };
+export class GestureSyntaxError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'GestureSyntaxError';
+    }
+}
+function tmuxNotation(value) {
+    const match = value.match(/^((?:[CMS]-)+)(.+)$/i);
+    if (match === null)
+        return value;
+    const modifiers = match[1].split('-').filter(Boolean).map((token) => {
+        if (token.toUpperCase() === 'C')
+            return 'ctrl';
+        if (token.toUpperCase() === 'M')
+            return 'alt';
+        return 'shift';
+    });
+    return `${modifiers.join('+')}+${match[2]}`;
+}
+export function normalizeStroke(raw) {
+    const value = tmuxNotation(raw.trim());
+    if (value === '')
+        throw new GestureSyntaxError('a stroke cannot be empty');
+    let rawKey;
+    let modifierParts;
+    if (value === '+') {
+        rawKey = '+';
+        modifierParts = [];
+    }
+    else if (value.endsWith('++')) {
+        rawKey = '+';
+        modifierParts = value.slice(0, -2).split('+');
+    }
+    else {
+        const parts = value.split('+');
+        if (parts.some((part) => part === ''))
+            throw new GestureSyntaxError(`invalid stroke "${raw}"`);
+        rawKey = parts.pop();
+        modifierParts = parts;
+    }
+    const inputModifiers = modifierParts.map((part) => part.toLowerCase());
+    if (inputModifiers.some((modifier) => !INPUT_MODIFIERS.has(modifier))) {
+        throw new GestureSyntaxError(`unsupported modifier in "${raw}"`);
+    }
+    const modifiers = inputModifiers.map((modifier) => modifier === 'meta' ? 'alt' : modifier);
+    if (new Set(modifiers).size !== modifiers.length) {
+        throw new GestureSyntaxError(`duplicate modifier in "${raw}"`);
+    }
+    let key = KEY_ALIASES[rawKey.toLowerCase()] ?? rawKey;
+    if (key.length === 1 && key >= 'A' && key <= 'Z') {
+        key = key.toLowerCase();
+        if (!modifiers.includes('shift'))
+            modifiers.push('shift');
+    }
+    else if (key.length !== 1) {
+        key = key.toLowerCase();
+    }
+    if (!(key.length === 1 && key.charCodeAt(0) >= 32 && key.charCodeAt(0) <= 126) && !NAMED_KEYS.has(key)) {
+        throw new GestureSyntaxError(`unsupported key "${rawKey}"`);
+    }
+    const ordered = MODIFIER_ORDER.filter((modifier) => modifiers.includes(modifier));
+    return [...ordered, key].join('+');
+}
+export function normalizeGesture(raw, definition) {
+    const parts = raw.trim().split(/\s+>\s+/);
+    if (parts.length > 2)
+        throw new GestureSyntaxError('a gesture may contain at most two strokes');
+    const normalized = parts.map(normalizeStroke);
+    if (normalized.length === 2 && definition?.inputKind !== 'tmux-sequence') {
+        throw new GestureSyntaxError('two-stroke sequences are supported only by tmux sequence actions');
+    }
+    if (definition?.inputKind === 'tmux-sequence' && normalized.length !== 2) {
+        throw new GestureSyntaxError('this action requires a two-stroke tmux sequence');
+    }
+    if (definition?.inputKind === 'tmux-menu-selector') {
+        if (normalized.length !== 1)
+            throw new GestureSyntaxError('a menu selector must be one stroke');
+        const stroke = normalized[0];
+        const pieces = stroke.split('+');
+        const key = pieces.at(-1);
+        const modifiers = pieces.slice(0, -1);
+        if ((key.length !== 1 && key !== 'space') || modifiers.some((modifier) => modifier !== 'shift')) {
+            throw new GestureSyntaxError('a menu selector must be one printable character');
+        }
+    }
+    return normalized.join(' > ');
+}
+function normalizeList(raw, definition) {
+    if (!Array.isArray(raw))
+        throw new GestureSyntaxError('the override must be an array of gesture strings');
+    const normalized = [];
+    for (const item of raw) {
+        if (typeof item !== 'string')
+            throw new GestureSyntaxError('every override entry must be a gesture string');
+        const gesture = normalizeGesture(item, definition);
+        if (!normalized.includes(gesture))
+            normalized.push(gesture);
+    }
+    return Object.freeze(normalized);
+}
+function contextsOverlap(a, b) {
+    return a.contexts.some((context) => b.contexts.includes(context));
+}
+function isTmuxRoot(definition) {
+    return definition.contexts.includes('tmux.root');
+}
+function isInPane(definition) {
+    return !isTmuxRoot(definition)
+        && definition.inputKind !== 'tmux-menu-selector'
+        && definition.inputKind !== 'tmux-sequence';
+}
+function firstStroke(gesture) {
+    return gesture.split(' > ')[0];
+}
+function gesturesConflict(leftDefinition, leftGesture, rightDefinition, rightGesture) {
+    const leftSequence = leftGesture.includes(' > ');
+    const rightSequence = rightGesture.includes(' > ');
+    if (contextsOverlap(leftDefinition, rightDefinition)) {
+        if (leftSequence && rightSequence)
+            return leftGesture === rightGesture;
+        if (leftSequence || rightSequence)
+            return firstStroke(leftGesture) === firstStroke(rightGesture);
+        return leftGesture === rightGesture;
+    }
+    const leftRoot = isTmuxRoot(leftDefinition);
+    const rightRoot = isTmuxRoot(rightDefinition);
+    if (!leftRoot && !rightRoot)
+        return false;
+    if (leftRoot && rightRoot && leftSequence && rightSequence)
+        return leftGesture === rightGesture;
+    if (leftRoot && rightRoot)
+        return firstStroke(leftGesture) === firstStroke(rightGesture);
+    if (leftRoot && isInPane(rightDefinition))
+        return firstStroke(leftGesture) === rightGesture;
+    if (rightRoot && isInPane(leftDefinition))
+        return leftGesture === firstStroke(rightGesture);
+    return false;
+}
+function defaultGestures(definition) {
+    return Object.freeze(definition.defaults.map((gesture) => normalizeGesture(gesture, definition)));
+}
+class FrozenBindingMap {
+    #map;
+    constructor(entries) { this.#map = new Map(entries); }
+    get size() { return this.#map.size; }
+    get(key) { return this.#map.get(key); }
+    has(key) { return this.#map.has(key); }
+    entries() { return this.#map.entries(); }
+    keys() { return this.#map.keys(); }
+    values() { return this.#map.values(); }
+    forEach(callbackfn, thisArg) {
+        for (const [key, value] of this.#map)
+            callbackfn.call(thisArg, value, key, this);
+    }
+    [Symbol.iterator]() { return this.#map[Symbol.iterator](); }
+}
+function diagnostic(code, message, offendingValue, bindingId, relatedBindingIds) {
+    return Object.freeze({ severity: 'error', code, message, offendingValue, ...(bindingId ? { bindingId } : {}), ...(relatedBindingIds ? { relatedBindingIds: Object.freeze([...relatedBindingIds]) } : {}) });
+}
+function collisionPairs(records) {
+    const out = [];
+    for (let leftIndex = 0; leftIndex < records.length; leftIndex += 1) {
+        const left = records[leftIndex];
+        for (let rightIndex = leftIndex + 1; rightIndex < records.length; rightIndex += 1) {
+            const right = records[rightIndex];
+            for (const leftGesture of left.gestures) {
+                const conflict = right.gestures.find((rightGesture) => gesturesConflict(left.definition, leftGesture, right.definition, rightGesture));
+                if (conflict !== undefined) {
+                    out.push([left, right, leftGesture.includes(' > ') ? leftGesture : conflict]);
+                    break;
+                }
+            }
+        }
+    }
+    return out;
+}
+function requirementSatisfied(records, context, capability) {
+    return records.some((record) => record.definition.safety === capability
+        && record.gestures.length > 0
+        && record.definition.contexts.includes(context));
+}
+function rejectCollidingUserOverrides(records, diagnostics) {
+    while (true) {
+        const rejected = new Set();
+        for (const [left, right, gesture] of collisionPairs(records)) {
+            if (left.source === 'user')
+                rejected.add(left);
+            if (right.source === 'user')
+                rejected.add(right);
+            if (left.source === 'default' && right.source === 'default') {
+                throw new Error(`keybinding catalog default collision: ${left.definition.id} / ${right.definition.id} (${gesture})`);
+            }
+            diagnostics.push(diagnostic('collision', `${left.definition.id} and ${right.definition.id} both claim ${gesture} in overlapping contexts`, gesture, left.source === 'user' ? left.definition.id : right.definition.id, [left.definition.id, right.definition.id]));
+        }
+        if (rejected.size === 0)
+            return;
+        for (const record of rejected) {
+            record.gestures = defaultGestures(record.definition);
+            record.source = 'default';
+        }
+    }
+}
+export function resolveKeybindings(rawOverrides = undefined) {
+    const diagnostics = [];
+    let overrides = {};
+    if (rawOverrides !== undefined) {
+        if (rawOverrides === null || typeof rawOverrides !== 'object' || Array.isArray(rawOverrides)) {
+            diagnostics.push(diagnostic('invalid-keybindings', 'keybindings must be an object keyed by catalog binding ID', rawOverrides));
+        }
+        else {
+            overrides = rawOverrides;
+        }
+    }
+    for (const [id, value] of Object.entries(overrides)) {
+        if (!BINDING_IDS.has(id)) {
+            diagnostics.push(diagnostic('unknown-binding', `unknown keybinding ID: ${id}`, value, id));
+        }
+    }
+    const records = BINDING_CATALOG.map((definition) => {
+        const defaults = defaultGestures(definition);
+        if (!Object.hasOwn(overrides, definition.id))
+            return { definition, gestures: defaults, source: 'default' };
+        const rawOverride = overrides[definition.id];
+        try {
+            return { definition, gestures: normalizeList(rawOverride, definition), source: 'user', rawOverride };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            diagnostics.push(diagnostic('invalid-override', `${definition.id}: ${message}`, rawOverride, definition.id));
+            return { definition, gestures: defaults, source: 'default' };
+        }
+    });
+    rejectCollidingUserOverrides(records, diagnostics);
+    for (const requirement of SAFETY_REQUIREMENTS) {
+        if (requirementSatisfied(records, requirement.context, requirement.capability))
+            continue;
+        const offenders = records.filter((record) => record.source === 'user'
+            && record.definition.safety === requirement.capability
+            && record.definition.contexts.includes(requirement.context));
+        diagnostics.push(diagnostic('unreachable', `${requirement.context} must retain an enabled ${requirement.capability} binding`, offenders.map((record) => record.rawOverride), offenders[0]?.definition.id, offenders.map((record) => record.definition.id)));
+        for (const offender of offenders) {
+            offender.gestures = defaultGestures(offender.definition);
+            offender.source = 'default';
+        }
+    }
+    rejectCollidingUserOverrides(records, diagnostics);
+    const entries = records.map((record) => {
+        const effective = Object.freeze({
+            definition: record.definition,
+            gestures: record.gestures,
+            source: record.source,
+        });
+        return [record.definition.id, effective];
+    });
+    const bindings = new FrozenBindingMap(entries);
+    const result = {
+        bindings,
+        diagnostics: Object.freeze(diagnostics),
+        get(id) {
+            const found = bindings.get(id);
+            if (found === undefined)
+                throw new Error(`unknown crouter keybinding ID: ${id}`);
+            return found;
+        },
+        gestures(id) { return this.get(id).gestures; },
+    };
+    return Object.freeze(result);
+}
+export function resolveUserKeybindings() {
+    const raw = readRawScopeConfig('user');
+    return resolveKeybindings(raw?.keybindings);
+}
+export function normalizeSparseOverrides(rawOverrides) {
+    const resolved = resolveKeybindings(rawOverrides);
+    if (resolved.diagnostics.length > 0) {
+        throw new KeybindingValidationError(resolved.diagnostics);
+    }
+    const sparse = {};
+    for (const definition of BINDING_CATALOG) {
+        const effective = resolved.get(definition.id);
+        const defaults = defaultGestures(definition);
+        if (effective.source === 'user' && !isDeepStrictEqual(effective.gestures, defaults)) {
+            sparse[definition.id] = [...effective.gestures];
+        }
+    }
+    return sparse;
+}
+export class KeybindingValidationError extends Error {
+    diagnostics;
+    constructor(diagnostics) {
+        super(diagnostics[0]?.message ?? 'invalid keybindings');
+        this.name = 'KeybindingValidationError';
+        this.diagnostics = diagnostics;
+    }
+}

package/dist/core/keybindings/types.d.ts

@@ -0,0 +1,37 @@
+export type BindingInputKind = 'terminal' | 'tmux-sequence' | 'tmux-menu-selector' | 'host-global';
+export type BindingSafetyCapability = 'dismiss-modal' | 'leave-screen' | 'save-keybindings';
+export interface BindingDefinition<Id extends string = string> {
+    readonly id: Id;
+    readonly group: string;
+    readonly name: string;
+    readonly description: string;
+    readonly defaults: readonly string[];
+    readonly inputKind: BindingInputKind;
+    readonly contexts: readonly string[];
+    readonly safety?: BindingSafetyCapability;
+}
+export interface EffectiveBinding<Id extends string = string> {
+    readonly definition: BindingDefinition<Id>;
+    readonly gestures: readonly string[];
+    readonly source: 'default' | 'user';
+}
+export type KeybindingDiagnosticCode = 'invalid-keybindings' | 'unknown-binding' | 'invalid-override' | 'collision' | 'unreachable';
+export interface KeybindingDiagnostic {
+    readonly severity: 'error';
+    readonly code: KeybindingDiagnosticCode;
+    readonly bindingId?: string;
+    readonly relatedBindingIds?: readonly string[];
+    readonly offendingValue: unknown;
+    readonly message: string;
+}
+export interface SafetyRequirement {
+    readonly context: string;
+    readonly capability: BindingSafetyCapability;
+}
+export interface BindingResolution<Id extends string = string> {
+    readonly bindings: ReadonlyMap<Id, EffectiveBinding<Id>>;
+    readonly diagnostics: readonly KeybindingDiagnostic[];
+    get(id: Id): EffectiveBinding<Id>;
+    gestures(id: Id): readonly string[];
+}
+export type SparseKeybindingOverrides<Id extends string = string> = Partial<Record<Id, string[]>>;

package/dist/core/keybindings/types.js

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

package/dist/core/memory-resolver.d.ts

@@ -1,4 +1,4 @@
-import type { InstalledPlugin, Scope } from '../types.js';
+import { type InstalledPlugin, type Scope } from '../types.js';
 /**
  * Thin memory-document resolver for the document substrate. Precedence is the
  * OUTER loop, not a global scan: scopes/sources are tried NEAREST-FIRST

package/dist/core/memory-resolver.js

@@ -1,5 +1,6 @@
 import { join, relative, sep } from 'node:path';
 import { readdirSync } from 'node:fs';
+import { CRTR_DIR_NAME } from '../types.js';
 import { pathExists, readText, walkFiles } from './fs-utils.js';
 import { parseFrontmatterGeneric } from './frontmatter.js';
 import { listInstalledPlugins, listInstalledPluginsInRoot, parseSkillQualifier } from './resolver.js';
@@ -117,8 +118,14 @@ function listMemoryDocsInDir(scope, dir, quiet = false) {
             continue;
         }
         for (const e of entries) {
-            if (e.isDirectory())
-                stack.push(join(d, e.name));
+            // Enumeration stops at store boundaries: a nested `.crouter/` is another
+            // scope's mount point (e.g. a dir-scoped store inside a dir that is itself
+            // a store, like builtin-memory in the crouter repo), never this store's
+            // own content — walking into it would register a different tier's docs.
+            if (e.isDirectory()) {
+                if (e.name !== CRTR_DIR_NAME)
+                    stack.push(join(d, e.name));
+            }
             else if (e.isFile() && e.name.endsWith('.md') && e.name !== 'SKILL.md') {
                 const file = join(d, e.name);
                 const raw = relative(dir, file).replace(/\.md$/i, '').split(sep).join('/');
@@ -182,7 +189,7 @@ export function listPluginMemoryDocs(plugin, scope, quiet = false) {
     if (!pathExists(dir))
         return [];
     const docs = [];
-    for (const file of walkFiles(dir, (n) => n.endsWith('.md') && n !== 'SKILL.md')) {
+    for (const file of walkFiles(dir, (n) => n.endsWith('.md') && n !== 'SKILL.md', (d) => d === CRTR_DIR_NAME)) {
         const derived = normalizeDocName(relative(dir, file).replace(/\.md$/i, '').split(sep).join('/'));
         if (!derived)
             continue;

package/dist/core/predicate.d.ts

@@ -2,14 +2,16 @@
  * Predicate matcher engine — vendored verbatim from pi's frontmatter-rules
  * extension.
  *
- * Source: pi-personal-extensions/extensions/frontmatter-rules/index.ts
+ * Source: src/builtin-pi-packages/pi-crtr-extensions/extensions/frontmatter-rules/index.ts
  *         (the "Condition language" block, functions `asArray` … `evalCondition`).
  *
  * The unified document substrate uses this to evaluate a document's `gate`
  * predicate against a node-config subject (e.g. `orchestration.depth: { gte: 2 }`).
  *
- * This is intentionally a COPY, not an import: the source lives in a separate,
- * private, unpublished repo that crtr cannot depend on. The functions are pure
+ * This is intentionally a COPY, not an import: the bundled pi package is
+ * excluded from crouter's tsc compile unit (tsconfig `exclude`) — it is loaded
+ * by pi's own TS loader at runtime — so compiled core cannot import from it;
+ * cross-boundary imports go extension→core only. The functions are pure
  * TS over `unknown` / `Record<string, unknown>` with zero external imports, so
  * vendoring them keeps this module standalone and dependency-free. Keep it in
  * sync with the source by hand if the matcher language ever changes.

package/dist/core/predicate.js

@@ -2,14 +2,16 @@
  * Predicate matcher engine — vendored verbatim from pi's frontmatter-rules
  * extension.
  *
- * Source: pi-personal-extensions/extensions/frontmatter-rules/index.ts
+ * Source: src/builtin-pi-packages/pi-crtr-extensions/extensions/frontmatter-rules/index.ts
  *         (the "Condition language" block, functions `asArray` … `evalCondition`).
  *
  * The unified document substrate uses this to evaluate a document's `gate`
  * predicate against a node-config subject (e.g. `orchestration.depth: { gte: 2 }`).
  *
- * This is intentionally a COPY, not an import: the source lives in a separate,
- * private, unpublished repo that crtr cannot depend on. The functions are pure
+ * This is intentionally a COPY, not an import: the bundled pi package is
+ * excluded from crouter's tsc compile unit (tsconfig `exclude`) — it is loaded
+ * by pi's own TS loader at runtime — so compiled core cannot import from it;
+ * cross-boundary imports go extension→core only. The functions are pure
  * TS over `unknown` / `Record<string, unknown>` with zero external imports, so
  * vendoring them keeps this module standalone and dependency-free. Keep it in
  * sync with the source by hand if the matcher language ever changes.

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

@@ -169,6 +169,15 @@ export interface CycleModelFrame {
     type: 'cycle_model';
     direction?: 'forward' | 'backward';
 }
+/** `cycleLadder(direction)` — alt+m forward / alt+shift+m backward. Walks the INTERLEAVED model ladder
+ *  (anthropic/ultra → openai/ultra → anthropic/strong → openai/strong → …),
+ *  starting from the current model, applying each rung's own thinking level.
+ *  Distinct from `cycle_model`, which steps the flat registry list. `direction`
+ *  defaults to `'forward'` when absent. */
+export interface CycleLadderFrame {
+    type: 'cycle_ladder';
+    direction?: 'forward' | 'backward';
+}
 /** `cycleThinkingLevel()` — shift+tab. Cycles to the next thinking level; the new
  *  level reaches viewers via the relayed `thinking_level_changed` event, so the
  *  broker replies a plain `ack` (no payload). Distinct from `set_thinking_level`,
@@ -303,7 +312,7 @@ export interface ShareFrame {
 export interface ReloadAuthFrame {
     type: 'reload_auth';
 }
-export type ClientToBroker = HelloFrame | PromptFrame | SteerFrame | FollowUpFrame | AbortFrame | BashFrame | RequestControlFrame | ReleaseControlFrame | ByeFrame | ShutdownFrame | SetModelFrame | CycleModelFrame | CycleThinkingFrame | SetThinkingLevelFrame | DequeueFrame | SetAutoRetryFrame | SetAutoCompactionFrame | CompactFrame | NewSessionFrame | SwitchSessionFrame | ForkFrame | SetSessionNameFrame | GetCommandsFrame | NavigateTreeFrame | ReloadFrame | ExportFrame | ListModelsFrame | ListSessionsFrame | GetTreeFrame | GetSettingsFrame | ListScopedModelsFrame | ExtensionUIResponseFrame | CloneFrame | ShareFrame | ReloadAuthFrame;
+export type ClientToBroker = HelloFrame | PromptFrame | SteerFrame | FollowUpFrame | AbortFrame | BashFrame | RequestControlFrame | ReleaseControlFrame | ByeFrame | ShutdownFrame | SetModelFrame | CycleModelFrame | CycleLadderFrame | CycleThinkingFrame | SetThinkingLevelFrame | DequeueFrame | SetAutoRetryFrame | SetAutoCompactionFrame | CompactFrame | NewSessionFrame | SwitchSessionFrame | ForkFrame | SetSessionNameFrame | GetCommandsFrame | NavigateTreeFrame | ReloadFrame | ExportFrame | ListModelsFrame | ListSessionsFrame | GetTreeFrame | GetSettingsFrame | ListScopedModelsFrame | ExtensionUIResponseFrame | CloneFrame | ShareFrame | ReloadAuthFrame;
 export interface WelcomeFrame {
     type: 'welcome';
     snapshot: BrokerSnapshot;
@@ -330,6 +339,13 @@ export interface ControlChangedFrame {
 export interface ModelChangedFrame {
     type: 'model_changed';
     model: string | undefined;
+    /** The full resolved `provider/id[:thinking]` spec (`formatModelSpec`) — what
+     *  the broker persists into the node's own launch recipe. Viewers use it to
+     *  persist a non-portable explicit pick as a kind DEFAULT
+     *  (`persistDefaultKindModel`) without guessing the provider from the bare
+     *  id. Null when the engine has no model. Optional so older brokers'
+     *  frames still parse. */
+    spec?: string | null;
 }
 export interface ErrorFrame {
     type: 'error';
@@ -380,9 +396,10 @@ export interface WireScopedModel {
     model: Model<Api>;
     thinkingLevel?: AgentSession['thinkingLevel'];
 }
-/** Wire form of pi's `SessionInfo`: identical EXCEPT `created`/`modified` are ISO
- *  strings (pi's are `Date`, which JSON cannot round-trip) — the viewer revives
- *  them with `new Date(...)` before handing them to `SessionSelectorComponent`. */
+/** Wire form of pi's `SessionInfo`: `created`/`modified` are ISO strings (pi's
+ *  are `Date`, which JSON cannot round-trip), and `allMessagesText` is a bounded
+ *  opening/latest search excerpt rather than the unbounded transcript text. The
+ *  viewer revives the dates before handing them to `SessionSelectorComponent`. */
 export interface WireSessionInfo extends Omit<SessionInfo, 'created' | 'modified'> {
     created: string;
     modified: string;
@@ -494,10 +511,21 @@ export interface DisplayTitleFrame {
 }
 /** A blocking dialog routed to the controller — pi's public RPC request type. */
 export type ExtensionUIRequestFrame = RpcExtensionUIRequest;
+/** Broker → client: dismiss a previously-forwarded blocking dialog by request id,
+ *  WITHOUT a client answer. The broker sends this exactly when it resolves a pending
+ *  dialog ITSELF rather than the client answering it — the extension aborted the
+ *  request out-of-band (e.g. a local OAuth loopback callback won the race against a
+ *  still-open manual-paste dialog) or the broker-side timeout fired. The client tears
+ *  down ONLY the overlay whose `id` matches; every other dialog stays exactly as it
+ *  was, so an unrelated request can never dismiss an unrelated blocking dialog. */
+export interface ExtensionUIDismissFrame {
+    type: 'extension_ui_dismiss';
+    id: string;
+}
 /** Everything the broker can send. Live `AgentSessionEvent`s are relayed
  *  verbatim (the broker adds nothing); the broker's own control frames carry
  *  non-colliding `type` discriminants. */
-export type BrokerToClient = WelcomeFrame | ControlChangedFrame | ModelChangedFrame | ErrorFrame | AckFrame | BrokerDataFrame | DisplayStatusFrame | DisplayWidgetFrame | DisplayTitleFrame | BashStartFrame | BashOutputFrame | BashEndFrame | ExtensionUIRequestFrame | AgentSessionEvent;
+export type BrokerToClient = WelcomeFrame | ControlChangedFrame | ModelChangedFrame | ErrorFrame | AckFrame | BrokerDataFrame | DisplayStatusFrame | DisplayWidgetFrame | DisplayTitleFrame | BashStartFrame | BashOutputFrame | BashEndFrame | ExtensionUIRequestFrame | ExtensionUIDismissFrame | AgentSessionEvent;
 /** Encode one frame as a single newline-terminated JSON line. */
 export declare function encodeFrame(frame: ClientToBroker | BrokerToClient): string;
 /** Byte bounds for a {@link FrameDecoder} (C5). */