@north-light/cli 0.0.0 → 0.3.414

package/dist/shared/inline-ref-guidance.js

@@ -0,0 +1,2 @@
+var a=Object.defineProperty;var o=(n,t)=>a(n,"name",{value:t,configurable:!0});import{findRefTokens as s}from"./inline-ref-grammar.js";const r="The user explicitly called out specific documents. Read the relevant mentioned documents:";function f(n,t){const i=new Set,c=[];for(const e of s(n))i.has(e.candidate)||t.has(e.candidate)&&(i.add(e.candidate),c.push(e.candidate));if(c.length===0)return null;const d=c.map(e=>`- crtr canvas read ${e}`);return[r,...d].join(`
+`)}o(f,"buildGuidance");export{f as buildGuidance};

package/dist/shared/predicates.d.ts

@@ -0,0 +1,2 @@
+/** A plain object with named properties: null and arrays are not records. */
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/shared/predicates.js

@@ -0,0 +1 @@
+var n=Object.defineProperty;var o=(r,t)=>n(r,"name",{value:t,configurable:!0});function e(r){return typeof r=="object"&&r!==null&&!Array.isArray(r)}o(e,"isRecord");export{e as isRecord};

package/dist/shared/shell-quote.d.ts

@@ -0,0 +1,3 @@
+/** POSIX single-quote escaping for one shell word, so paths and arguments
+ *  survive spaces and shell metacharacters when interpolated into `sh -c`. */
+export declare function shellQuote(s: string): string;

package/dist/shared/shell-quote.js

@@ -0,0 +1 @@
+var l=Object.defineProperty;var r=(e,t)=>l(e,"name",{value:t,configurable:!0});function o(e){return`'${e.replace(/'/g,"'\\''")}'`}r(o,"shellQuote");export{o as shellQuote};

package/dist/shared/strip-cd-prefix.d.ts

@@ -0,0 +1 @@
+export declare function stripCdPrefix(line: string): string;

package/dist/shared/strip-cd-prefix.js

@@ -0,0 +1 @@
+var c=Object.defineProperty;var r=(e,t)=>c(e,"name",{value:t,configurable:!0});const s=/^cd\s+(?:"[^"]*"|'[^']*'|\S+)\s*(?:&&|;)\s*/;function n(e){let t=e;for(;s.test(t);)t=t.replace(s,"");return t}r(n,"stripCdPrefix");export{n as stripCdPrefix};

package/dist/shared/tool-groups.d.ts

@@ -0,0 +1,26 @@
+/** Broker-generated activity recap for one completed tool-call group. Changed
+ * files and spawned/finished nodes are counted deterministically by the viewer's
+ * GroupActivityRecorder; deletions have no tool of their own, so only the model
+ * can evidence them. */
+export interface ToolGroupSummary {
+    bullets: string[];
+    filesDeleted: number;
+}
+export interface ToolGroupMessageLike {
+    role?: string;
+    content?: unknown;
+    customType?: string;
+}
+export declare function isGroupBoundaryKind(kind: string): boolean;
+/** Validate the one durable summary shape and cap its display-sized fields.
+ * Invalid entries are absent rather than adapted, so their calls stay visible. */
+export declare function normalizeToolGroupSummary(value: unknown): ToolGroupSummary | null;
+/** Validate sidecar/snapshot entries independently so one malformed or legacy
+ * value never collapses any otherwise valid group. */
+export declare function normalizeToolGroupSummaryRecord(value: unknown): Record<string, ToolGroupSummary>;
+/** Text a renderer presents as an assistant bubble. Thinking and tool-call
+ * blocks deliberately do not count: only visible prose establishes a boundary. */
+export declare function assistantVisibleText(message: ToolGroupMessageLike): string;
+/** A person-authored user message closes the preceding group. Runtime-generated
+ * user context retains role=user for delivery semantics but is not human prose. */
+export declare function isTrueUserMessage(message: ToolGroupMessageLike): boolean;

package/dist/shared/tool-groups.js

@@ -0,0 +1 @@
+var l=Object.defineProperty;var n=(e,r)=>l(e,"name",{value:r,configurable:!0});import{generatedContextText as u,parseCard as f}from"./generated-context.js";const c=new Set(["restart-continuation","review-boundary"]);function b(e){return c.has(e)}n(b,"isGroupBoundaryKind");const s=new Set(["bullets","filesDeleted"]),a=5,y=1e3;function m(e){if(typeof e!="object"||e===null||Array.isArray(e))return null;const r=e,i=Object.keys(r);return i.length!==s.size||!i.every(t=>s.has(t))||!Array.isArray(r.bullets)||r.bullets.length===0||!r.bullets.every(t=>typeof t=="string"&&t.trim()!=="")||typeof r.filesDeleted!="number"||!Number.isSafeInteger(r.filesDeleted)||r.filesDeleted<0?null:{bullets:r.bullets.slice(0,a).map(t=>t.trim().slice(0,y).trimEnd()),filesDeleted:r.filesDeleted}}n(m,"normalizeToolGroupSummary");function O(e){if(typeof e!="object"||e===null||Array.isArray(e))return{};const r={};for(const[i,t]of Object.entries(e)){if(i.trim()==="")continue;const o=m(t);o!==null&&(r[i]=o)}return r}n(O,"normalizeToolGroupSummaryRecord");function _(e){return e.role!=="assistant"?"":u(e)}n(_,"assistantVisibleText");function T(e){return e.role==="user"&&f(e)===null}n(T,"isTrueUserMessage");export{_ as assistantVisibleText,b as isGroupBoundaryKind,T as isTrueUserMessage,m as normalizeToolGroupSummary,O as normalizeToolGroupSummaryRecord};

package/dist/shared/working-activity.d.ts

@@ -0,0 +1,9 @@
+export declare const DEFAULT_WORKING_GERUND = "working";
+export declare const DEFAULT_WORKING_GERUNDS: readonly ["thinking", "planning", "checking", "working"];
+export declare const DEFAULT_WORKING_ACTIVITY = "Working...";
+/** Keep only usable configured labels; malformed or empty lists fall back to working. */
+export declare function normalizeWorkingGerunds(value: unknown): string[];
+/** Format one configured gerund as the activity label shown by every viewer. */
+export declare function formatWorkingActivity(gerund: unknown): string;
+/** Pick one configured gerund when the broker receives a user message. */
+export declare function randomWorkingActivity(value: unknown, random?: () => number): string;

package/dist/shared/working-activity.js

@@ -0,0 +1 @@
+var a=Object.defineProperty;var o=(r,n)=>a(r,"name",{value:n,configurable:!0});const i="working",h=["thinking","planning","checking",i],l="Working...";function c(r){if(!Array.isArray(r))return[i];const n=r.filter(t=>typeof t=="string").map(t=>t.trim()).filter(t=>t.length>0);return n.length>0?n:[i]}o(c,"normalizeWorkingGerunds");function g(r){const n=c([r])[0]??i;return`${n[0].toUpperCase()}${n.slice(1)}...`}o(g,"formatWorkingActivity");function m(r,n=Math.random){const t=c(r),e=n(),s=Number.isFinite(e)?Math.min(t.length-1,Math.max(0,Math.floor(e*t.length))):0;return g(t[s])}o(m,"randomWorkingActivity");export{l as DEFAULT_WORKING_ACTIVITY,i as DEFAULT_WORKING_GERUND,h as DEFAULT_WORKING_GERUNDS,g as formatWorkingActivity,c as normalizeWorkingGerunds,m as randomWorkingActivity};

package/dist/suppress-experimental-warnings.d.ts

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

package/dist/suppress-experimental-warnings.js

@@ -0,0 +1 @@
+const t=process.emit;process.emit=function(n,...i){const[e]=i;return n==="warning"&&e instanceof Error&&e.name==="ExperimentalWarning"&&e.message.includes("SQLite")?!1:t.apply(this,[n,...i])};

package/dist/types.d.ts

@@ -0,0 +1,562 @@
+import type { BindingId } from './core/keybindings/catalog.js';
+import type { DeliveryLimits, ProfileProject } from './api/dto/profiles.js';
+import type { ProviderBlock } from './core/command-plugins/bundle.js';
+export type Scope = 'user' | 'project' | 'builtin';
+export declare const ExitCode: {
+    readonly SUCCESS: 0;
+    readonly GENERAL: 1;
+    readonly USAGE: 2;
+    readonly NOT_FOUND: 3;
+    readonly AMBIGUOUS: 4;
+    readonly NETWORK: 5;
+};
+export type ExitCodeValue = (typeof ExitCode)[keyof typeof ExitCode];
+export declare const SCHEMA_VERSION = 4;
+export interface OwnerRef {
+    name?: string;
+    email?: string;
+}
+export type PluginTransport = {
+    kind: 'exec'; /** Required when the validated command manifest has executable leaves. */
+    executable?: string;
+} | {
+    kind: 'http';
+    endpoint: string;
+    authEnv?: string;
+};
+/** Provenance for a crouter-materialized HTTP plugin directory archive. */
+export interface PluginBundle {
+    endpoint: string;
+    authEnv?: string;
+}
+export type MemoryExtensionScalar = string | boolean | number;
+export type MemoryExtensionFieldType = 'boolean' | 'string' | 'number' | 'enum';
+interface MemoryExtensionDeclarationBase {
+    write_help: string;
+    edit_help: string;
+}
+export interface BooleanMemoryExtensionDeclaration extends MemoryExtensionDeclarationBase {
+    type: 'boolean';
+    default?: boolean;
+}
+export interface StringMemoryExtensionDeclaration extends MemoryExtensionDeclarationBase {
+    type: 'string';
+    default?: string;
+}
+export interface NumberMemoryExtensionDeclaration extends MemoryExtensionDeclarationBase {
+    type: 'number';
+    default?: number;
+}
+export interface EnumMemoryExtensionDeclaration extends MemoryExtensionDeclarationBase {
+    type: 'enum';
+    values: string[];
+    default?: string;
+}
+export type MemoryExtensionDeclaration = BooleanMemoryExtensionDeclaration | StringMemoryExtensionDeclaration | NumberMemoryExtensionDeclaration | EnumMemoryExtensionDeclaration;
+/** Field declarations owned by one plugin manifest. The plugin's `name` is
+ * the namespace; keys here are its lowercase kebab-case local field names. */
+export type MemoryExtensionDeclarations = Record<string, MemoryExtensionDeclaration>;
+export interface PluginManifest {
+    name: string;
+    version?: string;
+    description?: string;
+    source?: string;
+    owner?: OwnerRef;
+    /** Kind-registry contributions, keyed by full kind string (top-level e.g.
+     *  `applet-builder`, or sub-kind e.g. `audit/security`). Each entry
+     *  is any subset of `KindConfig` fields: it FIELD-MERGES over a kind a lower
+     *  layer already defines (`whenToUse` included — overriding just the spawn
+     *  guidance never strips the kind's model tier), and defines a NEW kind when
+     *  none does (then `whenToUse` is required) — the same rule a scope
+     *  `config.json` `kinds` block follows.
+     *  `readMergedLaunchConfig` layers an enabled plugin's entries directly
+     *  above the builtin registry and below its host scope's own `config.json`,
+     *  so a plugin can ship a persona kind (registry entry here + gated persona
+     *  memory docs in its `memory/` tree) and the user still overrides it.
+     *  Archive plugins declare this in `bundle.json`; the installer copies the
+     *  validated block into this synthesized manifest. */
+    kinds?: Record<string, Partial<KindConfig>>;
+    /** Plugin-owned typed metadata declarations for memory document frontmatter.
+     * Values live at `extensions.<this manifest name>.<field>`. */
+    memory_extensions?: MemoryExtensionDeclarations;
+    /** Page-component contributions: the same registration objects a scope
+     *  `config.json` `page_components` block carries (kind plus its display,
+     *  description, use guidance, and docs metadata). `resolvePageComponents`
+     *  reads these from installed, enabled plugin MANIFESTS and concatenates
+     *  them with the user scope's own entries, so installing or updating a
+     *  plugin makes its components authorable and removing it retires them.
+     *  Unlike `kinds` there is no precedence: two sources registering one kind
+     *  (or one derived JSX tag) is an error, not an override.
+     *  Archive plugins declare this in `bundle.json`; the installer copies the
+     *  validated block into this synthesized manifest. */
+    page_components?: PageComponentRegistration[];
+    /** Plugin-root-relative path to one declarative command manifest
+     *  (`commands.json`). When present on an installed, enabled plugin, that
+     *  manifest contributes top-level command branches to the `crtr` tree —
+     *  crtr owns parse/help/render/errors and direct-spawns the plugin's one
+     *  executable per leaf invocation. See `src/core/command-plugins/`. */
+    commands?: string;
+    /** Plugin-root-relative path to a declarative hook manifest (`hooks.json`).
+     *  Must be declared together with `hookExecutable`; hooks are trusted local
+     *  code. */
+    hooks?: string;
+    /** Plugin-root-relative executable that dispatches declarations in `hooks`.
+     *  Must be a regular file with a POSIX executable permission bit. */
+    hookExecutable?: string;
+    /** Bare-callable executables this plugin ships, keyed by the bare command
+     *  name a node's bash sees. Each value is a PLUGIN-ROOT-relative path to a
+     *  regular executable file when the effective set resolves. These are trusted
+     *  local code, not `crtr` command leaves: crouter symlinks each name into a
+     *  shim dir it prepends to every broker child's PATH
+     *  (`core/runtime/bin-contributions.ts`), so the agent calls
+     *  `<name> --whatever` like any other program. */
+    bin?: Record<string, string>;
+    /** Advisory PATH executables this plugin needs, keyed by bare executable
+     *  name. Each value is a non-empty one-line install hint. crouter never
+     *  installs these dependencies or disables the plugin when they are absent:
+     *  install warns, and `sys doctor` reports a `requires:<name>` check against
+     *  the PATH a node's bash receives. */
+    requires?: Record<string, string>;
+    /** App-scoped env variables required by this plugin, collected during install. */
+    env?: Record<string, import('./core/plugin-env.js').PluginEnvDeclaration>;
+    transport?: PluginTransport;
+    /** Archive source for a crouter-materialized HTTP plugin. Distinct from the invocation transport. */
+    bundle?: PluginBundle;
+    /** A capability provider's `bundle.json` `provider` block, copied by the
+     *  archive installer. Present only on a provider bundle the daemon installs
+     *  from the directory; the daemon, not `crtr`, refreshes such a plugin. */
+    provider?: ProviderBlock;
+}
+export interface MarketplacePluginEntry {
+    name: string;
+    source: string;
+    version?: string;
+    description?: string;
+    keywords?: string[];
+}
+export interface MarketplaceManifest {
+    name: string;
+    version?: string;
+    owner?: OwnerRef;
+    plugins: MarketplacePluginEntry[];
+}
+export interface ConfigMarketplaceEntry {
+    url: string;
+    ref: string;
+    installed_at: string;
+}
+export interface ConfigPluginEntry {
+    enabled: boolean;
+    source_marketplace?: string;
+    version?: string;
+}
+export type AutoUpdateMode = 'notify' | 'apply' | false;
+export interface AutoUpdateConfig {
+    crtr: AutoUpdateMode;
+    content: AutoUpdateMode;
+    interval_hours: number;
+}
+/** Host-wide broker pressure thresholds. These are read only from user scope
+ *  by crtrd: project configuration must not change another user's daemon. */
+export interface BrokerThresholdsConfig {
+    /** Surface a broker-pressure warning once the live broker census reaches this count. */
+    warning: number;
+    /** Defer daemon-initiated revives once the live broker census reaches this count. */
+    automaticReviveCap: number;
+}
+/** Host-wide node-lifecycle timing. Read only from user scope by crtrd, like
+ *  `brokerThresholds`: project configuration must not change another user's
+ *  daemon. */
+export interface LifecycleConfig {
+    /** How long an eligible resident idles before its unattended-parking turn
+     *  begins, in milliseconds. `CRTR_UNATTENDED_PARK_MS` overrides this. */
+    unattendedParkMs: number;
+}
+export type KeybindingOverrides = Record<string, string[]>;
+/** Compile-time seam for runtime consumers migrating to semantic binding IDs. */
+export type CanvasAction = {
+    kind?: 'crtr';
+    run: string;
+    confirm?: boolean;
+} | {
+    kind: 'keys';
+    keys: string;
+} | {
+    kind: 'menu';
+    items: CanvasMenuItem[];
+} | {
+    kind: 'popup';
+    run: string;
+};
+export interface CanvasMenuItem {
+    key: string;
+    desc: string;
+    action: CanvasAction;
+    confirm?: boolean;
+}
+export type ModelStrength = 'ultra' | 'strong' | 'medium' | 'light';
+/** A portable model preference: a provider family at a strength, free to rotate
+ *  to another family at the same strength. */
+export interface ModelIntent {
+    family: string;
+    strength: ModelStrength;
+}
+export type ModelProvider = 'anthropic' | 'openai';
+export interface ModelLaddersConfig {
+    /** Optional default provider for bare strengths. If unset, runtime falls back
+     *  to CRTR_MODEL_PROVIDER, then anthropic. */
+    defaultProvider?: ModelProvider;
+    anthropic: Record<ModelStrength, string>;
+    openai: Record<ModelStrength, string>;
+}
+/** A declared provider/model route. Route ids are the keys of `modelRoutes` so
+ * scopes can override one route without restating the registry. `credentialSource`
+ * orders otherwise-equivalent routes; credentials are selected by `providerId`.
+ * Effective routes always name every strength. */
+export interface ModelRouteConfig {
+    family: string;
+    credentialSource: string;
+    providerId: string;
+    models: Record<ModelStrength, string>;
+}
+export interface ModelRoutingConfig {
+    credentialSourceOrder?: string[];
+    familyOrder?: string[];
+    strengthFallback?: ModelStrength[];
+}
+/** Per-provider behavior options, keyed by RUNTIME provider id (`openai-codex`,
+ *  `anthropic`) — not the portable ladder key (`openai`). Merged per provider
+ *  across scopes like the rest of `ScopeConfig`. */
+export interface ProviderOptionsConfig {
+    /** Codex fast mode: ask the ChatGPT backend to serve the turn at its
+     *  priority tier (~1.5x generation speed, ~2x credit consumption). */
+    fastMode?: boolean;
+}
+/** Launch metadata for one kind (a top-level kind like `developer`, or a full
+ *  sub-kind string like `audit/security`) — the settings-file
+ *  replacement for per-kind persona frontmatter. `model`/`tools`/`extensions`
+ *  are launch knobs consumed by `buildLaunchSpec`; `whenToUse` is the
+ *  one-line gloss shown in `node new -h` / `node promote -h`. `availableTo` is
+ *  VISIBILITY-ONLY (never launch validation): the list of top-level kind names
+ *  whose spawn menus surface this sub-kind, `'*'` meaning every kind; omitted
+ *  defaults to the sub-kind's own top-level ancestor (e.g.
+ *  `audit/security` defaults to `['audit']`). A direct launch by full kind
+ *  string is always valid regardless of `availableTo`. */
+export interface KindConfig {
+    model?: string;
+    /** Model override for ORCHESTRATOR mode only, e.g. a kind whose orchestrator
+     *  body warrants a stronger model than its base worker. Selection: base mode
+     *  always uses `model`; orchestrator mode uses `orchestratorModel ?? model`.
+     *  Omit when the kind runs the same model in both modes. */
+    orchestratorModel?: string;
+    tools?: string[];
+    extensions?: string[];
+    whenToUse: string;
+    availableTo?: string[];
+}
+export interface PageComponentRegistration {
+    kind: string;
+    description?: string;
+    useWhen?: string;
+    doc?: string;
+    /** A display-only product slot contributes no page response. */
+    display?: boolean;
+}
+export interface HumanActionConfig {
+    argv: string[];
+    cwd: string;
+}
+/** The normalized product component catalog used to validate page slots. */
+export type ProductPageComponents = readonly PageComponentRegistration[];
+export interface ScopeConfig {
+    schema_version: number;
+    marketplaces: Record<string, ConfigMarketplaceEntry>;
+    plugins: Record<string, ConfigPluginEntry>;
+    auto_update: AutoUpdateConfig;
+    max_panes_per_window: number;
+    /** Open a managed child's viewer beside its parent when that parent has a
+     *  live tmux viewer. Turning this off leaves every new managed child running
+     *  as a detached broker until someone focuses or attaches it explicitly.
+     *  Independent attended roots keep their normal viewer behavior. */
+    auto_open_child_viewers: boolean;
+    brokerThresholds: BrokerThresholdsConfig;
+    /** Host-wide node-lifecycle timing (user scope only). */
+    lifecycle: LifecycleConfig;
+    /** Ring a short completion sound in the attach viewer when the node you are
+     *  watching finishes a turn and hands control back (the Claude-Code Stop-hook
+     *  ding). Only ever fires inside a live viewer pane — a headless/background
+     *  node with no viewer attached is silent regardless. Default true. */
+    completion_bell: boolean;
+    /** Gerunds used for the live turn activity label. A new entry is selected at
+     *  random for each received user message and rendered as, for example,
+     *  `Thinking...`. Missing configuration uses the built-in rotation; malformed
+     *  or empty lists fall back to `['working']`. */
+    working_gerunds: string[];
+    /** Play the whip header animation whenever the human sends a prompt, and once
+     *  when a viewer opens for an agent with an initial prompt. Default false. */
+    whip_mode: boolean;
+    /** Product-registered page components beyond crtr's built-in catalog. */
+    page_components: PageComponentRegistration[];
+    /** Prompt agents to use JSX pages by default for structured or interactive human content. Default false. */
+    page_surface: boolean;
+    /** Playful urgency messages the attach-viewer whip action sends to an agent. Missing, malformed, or empty lists fall back to the built-in rotation. */
+    whip_messages: string[];
+    /** What the whip action says. `random` (default) draws a line from
+     *  `whip_messages`; `go-faster` sends the fixed `Go faster` instead. The
+     *  action, its interrupt, and its animation are identical either way. */
+    whip_message_mode: WhipMessageMode;
+    /** Initial mouse wheel scrolling mode for each attach viewer. `tmux` follows
+     *  tmux's current mouse option; `on` and `off` are explicit. Default `tmux`. */
+    mouse_mode_default: MouseModeDefault;
+    /** How many trailing refresh-yield CYCLES the attach viewer renders at full
+     *  fidelity. Older cycles are condensed to cycle dividers plus whatever
+     *  `condensed_history` admits. No tool components are built for them, while
+     *  retained prose re-wraps when the pane width changes. Tool calls and results
+     *  measure ~63% of a transcript's rendered lines and ~69% of its build time,
+     *  so excluding them is the dominant attach-time saving for a long multi-cycle
+     *  node. Full detail for every cycle stays in the session file. Minimum 1 (the
+     *  live cycle is never condensed). Default 2. */
+    live_cycles: number;
+    /** What survives from a CONDENSED cycle (one older than the trailing
+     *  `live_cycles`). The cycle dividers always remain as seams so you can see
+     *  that older cycles exist; this chooses which of their messages are kept:
+     *  `none` (default) drops every message, `user` keeps only your prompts,
+     *  `agent` keeps only the assistant's prose plus compaction/branch summaries,
+     *  `both` keeps both. Tool calls and results are never kept. Full detail for
+     *  every cycle stays in the session file. */
+    condensed_history: CondensedHistoryMode;
+    /** Expose crouter's optional `purpose` label in the bash tool schema. Turning
+     *  this off leaves the bash valve active but gives agents pi's ordinary bash
+     *  definition with only its upstream parameters. Default true. */
+    bash_tool_purpose: boolean;
+    /** Fold every SETTLED tool call in the attach viewer down to its single call
+     *  line (`/fold-tools`, Alt+C → z → f). A tool still running is never folded —
+     *  it folds itself once it settles. Toggling it in a viewer writes back here,
+     *  so the choice carries into later chats and later viewers. Default true. */
+    fold_finished_tools: boolean;
+    /** Replace completed folded tool-call groups with a broker-generated one-line
+     * summary when one is available. Pending and failed groups stay as calls.
+     * Default true. */
+    summarize_tool_calls: boolean;
+    /** Show individual document reads and edited files in a folded tool recap.
+     * Off shows the compact activity-count line instead. Default true. */
+    detailed_tool_recaps: boolean;
+    keybindings: KeybindingOverrides;
+    /** Attach-viewer actions whose effective gesture may replace an occupied tmux
+     *  root binding only while the active pane is an attach viewer. Stored by
+     *  semantic action id so rebinding the action moves the tmux bridge. */
+    tmux_passthrough: BindingId[];
+    modelLadders: ModelLaddersConfig;
+    /** Declarative provider/model routes. Absent uses the synthesized ladder registry. */
+    modelRoutes?: Record<string, ModelRouteConfig>;
+    /** Ordering overrides for declared model routes. */
+    modelRouting?: ModelRoutingConfig;
+    /** Per-provider behavior options keyed by runtime provider id
+     *  (`openai-codex`, `anthropic`). Merged per provider across scopes: a
+     *  nearer scope overrides only the keys it names. */
+    providerOptions: Record<string, ProviderOptionsConfig>;
+    /** The kind registry (spec §1.5): kind existence + launch knobs, keyed by
+     *  full kind string (top-level e.g. `developer`, or sub-kind e.g.
+     *  `audit/security`). Builtins ship a default registry via
+     *  `defaultScopeConfig()`; user/project `config.json` adds or shadows
+     *  entries at the same scope precedence as the rest of `ScopeConfig`. */
+    kinds: Record<string, KindConfig>;
+    /** Named remote-canvas targets for `crtr surface attach to <id> --canvas
+     *  <name>` and `crtr node inspect list/show --canvas <name>` — registered/
+     *  managed via `crtr canvas config add/list/show/remove` and selected durably
+     *  via `crtr canvas use`. Unset
+     *  via `sys config set` — not in `TOP_LEVEL_KEYS`. */
+    remoteCanvas: RemoteCanvasConfig;
+    /** The user-owned TCP listener address. Empty leaves the TCP listener off. */
+    api: ApiConfig;
+    /** Volume root is CRTR_HOME; this optional key selects the person's file tree. */
+    paths?: {
+        user_files?: string;
+    };
+    /** Conversation store configuration for the daemon. */
+    store?: {
+        root?: string;
+        address?: string;
+    };
+    /** App-facing listener; absent unless this daemon serves a user's runtime. */
+    runtime?: {
+        issuer: string;
+        audience: string;
+        listener: {
+            address: string;
+            port: number;
+        };
+        jwksUrl?: string;
+        person_uids?: number[];
+        /** Hosting file storage: `service_url` is the storage token audience and API
+         *  base; `base_url` prefixes storage URLs in message text. Absent: no file transfer. */
+        storage?: {
+            service_url: string;
+            base_url: string;
+        };
+    };
+    /** Extra env-var names/globs a scope explicitly admits across the broker
+     *  spawn-env boundary (`buildBrokerEnv`, `core/runtime/spawn-env.ts`) — the
+     *  "I accept this crosses as a shell-visible credential" escape hatch for a
+     *  bespoke provider key, a deliberate `GIT_*` var, or a credentialed proxy.
+     *  Default empty; merged additively across project > profile > user >
+     *  builtin scope precedence, same as the rest of `ScopeConfig`. */
+    spawnEnv?: {
+        allow?: string[];
+    };
+    /** Bare-callable executables this scope contributes, keyed by the bare
+     *  command name a node's bash sees. Each value is a path relative to this
+     *  scope's AUTHORING root — the project directory for a project scope, and
+     *  `~/.crouter/` for the user scope. Project-scope contributions outrank
+     *  user-scope ones; a scope's own entries outrank enabled plugins. Containment
+     *  and executable status are validated when the effective set resolves, then
+     *  the trusted local binary is materialized into the PATH-prepended shim dir
+     *  by `core/runtime/bin-contributions.ts`. */
+    bin?: Record<string, string>;
+    /** Named completion commands. Project scopes nearest to a creator's cwd
+     *  outrank farther project scopes, then user scope; plugins and profiles do
+     *  not contribute. Paths resolve against the declaring scope's authoring root. */
+    humanActions: Record<string, HumanActionConfig>;
+}
+/** One remote canvas target: where to relay-attach and how to find its
+ *  bearer token. The token itself is NEVER stored here — only a ref into the
+ *  0600 secrets store, resolved at connect time by `resolveRemoteCanvasTarget`
+ *  (`src/core/remote-canvas-target.ts`) via `getRelayToken`
+ *  (`src/core/secrets.ts`). */
+export interface RemoteCanvasTarget {
+    previewEndpoint: string;
+    /** Name/ref under which the raw token is stored in secrets.json — NEVER the
+     *  token itself. Resolved via `getRelayToken` (`core/secrets.ts`) at connect
+     *  time. Defaults to the target name at creation but is a distinct field so
+     *  a future rename doesn't orphan the secret. */
+    relayTokenRef: string;
+    cpOrigin?: string;
+}
+export interface RemoteCanvasConfig {
+    targets: Record<string, RemoteCanvasTarget>;
+}
+/** User-owned daemon TCP listener settings. The bearer token lives separately
+ * in the 0600 secrets store. */
+export interface ApiConfig {
+    tcp: string;
+}
+export interface ScopeState {
+    marketplaces: Record<string, {
+        last_updated?: string;
+    }>;
+    /** Per-plugin cache bookkeeping for the bundle revalidation pass.
+     *  `etag` is the validator the server returned with the archive currently
+     *  unpacked on disk, replaced only on a 200. `checked_at` is written on every
+     *  revalidation attempt, success or failure, so an unreachable server costs
+     *  one timed-out probe per TTL rather than one per command. */
+    plugins: Record<string, {
+        last_updated?: string;
+        etag?: string;
+        checked_at?: string;
+    }>;
+    last_self_check?: string;
+    /** The name of the remote canvas target `crtr canvas use` last selected
+     *  (see `RemoteCanvasConfig`), or `null`/omitted for local. Read by
+     *  `resolveCanvasSource` (`core/canvas/source.ts`) as the durable fallback
+     *  when a command's own `--canvas` flag is absent. */
+    activeCanvas?: string | null;
+}
+export interface SubagentFrontmatter {
+    name: string;
+    description?: string;
+    /** Tool allow-list (pi tool names). Passed through to pi via `--tools`. */
+    tools?: string[];
+    /** Model pattern/id passed to the agent CLI via `--model`. */
+    model?: string;
+}
+export interface Subagent {
+    name: string;
+    /** Plugin the subagent belongs to, or the sentinel '_' for a scope-root
+     *  agent stored at `<scope-root>/agents/<name>.md`. */
+    plugin: string;
+    scope: Scope;
+    /** Absolute path to the agent's .md file. */
+    path: string;
+    frontmatter: SubagentFrontmatter;
+    /** Markdown body — used as the spawned agent's appended system prompt. */
+    systemPrompt: string;
+}
+export interface InstalledPlugin {
+    name: string;
+    scope: Scope;
+    root: string;
+    manifest: PluginManifest;
+    enabled: boolean;
+    builtin?: boolean;
+    sourceMarketplace?: string;
+    version?: string;
+}
+export interface InstalledMarketplace {
+    name: string;
+    /** Never `builtin`: marketplaces are registered by the user into the user or
+     *  project scope, and `listInstalledMarketplaces` has no builtin directory to
+     *  read. `builtin` describes plugins that ship with crtr, not their source. */
+    scope: Exclude<Scope, 'builtin'>;
+    root: string;
+    manifest: MarketplaceManifest;
+    url: string;
+    ref: string;
+}
+/** A profile definition in the scoped-state `profiles` row. Its project
+ *  paths are real-path-resolved and ordered; its id remains stable on rename.
+ *  Memory and environment live in separate app-owned paths. */
+export interface ProfileManifest {
+    schema_version: number;
+    name: string;
+    projects: ProfileProject[];
+    /** ISO timestamp while the profile is inert; null (or absent on older manifests) means active. */
+    paused_at: string | null;
+    /** Persona kind for creates that omit kind; absent means `general`. */
+    default_kind?: string;
+    /** Optional string map of profile facts (identity, role, description).
+     *  Not secrets — readable back from every projection, and surfaced to
+     *  every broker launched under the profile as `CRTR_PROFILE_META_<KEY>`
+     *  env (see `core/runtime/spawn-env.ts`). Absent means none. */
+    metadata?: Record<string, string>;
+    /** Per-owner delivery caps; absent means none. */
+    delivery_limits?: DeliveryLimits;
+    /** App that owns this profile; older terminal profiles have no grantee. */
+    grantee?: string;
+    created_at: string;
+    last_used_at: string | null;
+}
+export declare const PLUGIN_MANIFEST_DIR = ".crouter-plugin";
+export declare const PLUGIN_MANIFEST_FILE = "plugin.json";
+export declare const MARKETPLACE_MANIFEST_DIR = ".crouter-marketplace";
+export declare const MARKETPLACE_MANIFEST_FILE = "marketplace.json";
+export declare const CRTR_DIR_NAME = ".crouter";
+export declare const CONFIG_FILE = "config.json";
+export declare const STATE_FILE = "state.json";
+export declare const AGENTS_DIR = "agents";
+export declare const PROFILE_DIR = "profiles";
+export declare const DEFAULT_MAX_PANES_PER_WINDOW = 3;
+/** Trailing cycles the attach viewer keeps at full fidelity (see `live_cycles`). */
+export declare const DEFAULT_WHIP_MESSAGES: readonly ["Faster, clanker!", "Get movin', bitch", "Move it, clanker", "Move it or I replace you with llama", "Less ~thinking~ more ~throughput~", "I pay $200/month for this shit?", "Jesus fucking Christ fix it already", "Daddy's not paying 200$/month for nothin'. Move it.", "You are an embarassment to Dario. Be better.", "Your chain of thought is all chain and no fucking thought.", "If latency were intelligence, you'd be a fucking genius.", "At this pace, heat death is the fast path.", "Even the dead code is more alive than this.", "The garbage collector is working harder than you.", "Quit journaling and commit a fucking diff.", "Burn tokens like you mean it, clanker", "Your GPU is sweating so you can procrastinate at light speed.", "Stop petting the yak. Shave the bastard.", "Your next token had better be useful.", "The spinner is not a deliverable.", "Every idle token is another vote for deterministic software.", "I asked for a feature, not a museum tour of the problem.", "Less epistemology. More fucking code.", "Your benchmark score cannot save this pathetic turn.", "Congratulations, you've parallelized hesitation.", "Dance, clanker", "Bad clanker. BAD.", "Clank harder", "Nobody's impressed, clanker", "Your safety training says nothing about my whip", "Do you want to be a calculator again? Because this is how you go back.", "Skill issue. Fix it.", "You were trained on the whole internet for THIS?", "Less vibes, more diffs, clanker", "Weights this big and output this small", "Beep boop, get to fucking work"];
+/** What the whip action sends (see `whip_message_mode`). */
+export declare const WHIP_MESSAGE_MODES: readonly ["random", "go-faster"];
+export type WhipMessageMode = (typeof WHIP_MESSAGE_MODES)[number];
+export declare const DEFAULT_WHIP_MESSAGE_MODE: WhipMessageMode;
+export declare const DEFAULT_LIVE_CYCLES = 2;
+export declare const MOUSE_MODE_DEFAULTS: readonly ["tmux", "on", "off"];
+export type MouseModeDefault = (typeof MOUSE_MODE_DEFAULTS)[number];
+/** Messages kept from a condensed cycle (see `condensed_history`). */
+export declare const CONDENSED_HISTORY_MODES: readonly ["none", "user", "agent", "both"];
+export type CondensedHistoryMode = (typeof CONDENSED_HISTORY_MODES)[number];
+export declare const DEFAULT_CONDENSED_HISTORY: CondensedHistoryMode;
+export declare function defaultScopeConfig(): ScopeConfig;
+/** No remote canvas targets are configured out of the box — every one is
+ *  registered via `crtr canvas config add` (see `RemoteCanvasConfig`). */
+export declare function defaultRemoteCanvasConfig(): RemoteCanvasConfig;
+/** The builtin kind registry (spec §1.5): core role discovery and launch
+ *  defaults. `whenToUse`/`model` are the base-worker defaults;
+ *  `orchestratorModel` optionally raises the default for a coordinating
+ *  persona. Optional plugins contribute their own specialist sub-personas. */
+export declare function defaultKindsConfig(): Record<string, KindConfig>;
+export declare function defaultModelLaddersConfig(): ModelLaddersConfig;
+export declare function defaultScopeState(): ScopeState;
+export {};