@north-light/api 0.3.447 → 0.3.449

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

@@ -1,152 +0,0 @@
-// broker-protocol.ts — the client↔broker wire protocol for the headless node
-// Surface (design §5.2). Pure types + a newline-delimited JSON codec; no I/O, no
-// SDK construction. Consumed by the broker (src/core/runtime/broker.ts), the
-// `crtr surface attach` terminal client, and crtrd's attach bridge.
-//
-// The transport is one unix socket per node (`nodeDir(id)/view.sock`) speaking
-// newline-delimited JSON frames. Live engine events are relayed VERBATIM — the
-// broker is a transparent multiplexer, so a broker→client frame is either one of
-// the broker's own control frames (welcome/error) or a raw pi
-// `AgentSessionEvent` / `extension_ui_request`. The `type` namespaces never
-// collide, so the union below stays a clean discriminated union.
-//
-// The extension-dialog frames ARE pi's RPC types (decision §1.15) — imported
-// from the package root and re-exported here, so `broker-protocol` remains the
-// one import site for the wire union while the shapes stay pi's, versioned by
-// pi. pi names the correlation field `id` (design §5.2 wrote `request_id`); we
-// follow pi.
-import { StringDecoder } from 'node:string_decoder';
-// Client → broker frames
-/** Largest transcript window a client may request in its welcome snapshot. */
-export const SNAPSHOT_TAIL_MAX = 500;
-/** Invalid requests preserve the complete welcome; valid requests are capped. */
-export function normalizeSnapshotTail(value) {
-    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 1)
-        return undefined;
-    return Math.min(value, SNAPSHOT_TAIL_MAX);
-}
-// Newline-delimited JSON codec (the framing pi solves with `jsonl`, reproduced
-// locally so the protocol module owns no transport dependency)
-/** Encode one frame as a single newline-terminated JSON line. */
-export function encodeFrame(frame) {
-    return JSON.stringify(frame) + '\n';
-}
-/** Thrown by {@link FrameDecoder.push} when a peer's buffered bytes exceed a cap
- *  (C5). The caller catches it, best-effort sends `error{code:'frame_overflow'}`,
- *  and DESTROYS that socket — cap-and-drop the peer, never grow-to-OOM. `kind`
- *  says which bound tripped: a single oversized frame (`line`) or total backlog
- *  (`total`). */
-export class FrameOverflowError extends Error {
-    kind;
-    bytes;
-    cap;
-    constructor(kind, bytes, cap) {
-        super(`frame decoder overflow (${kind}): ${bytes} bytes exceeds cap ${cap}`);
-        this.kind = kind;
-        this.bytes = bytes;
-        this.cap = cap;
-        this.name = 'FrameOverflowError';
-    }
-}
-/** Caps the CLIENT uses reading BROKER frames. The `welcome.snapshot` carries the
- *  full message history and can be many MiB, so these are generous. Covers
- *  realistic long sessions; snapshot CHUNKING is deferred — the long-lived
- *  broker makes a big welcome a realistic, not pathological, trigger, but the
- *  fixed cap is accepted. */
-export const CLIENT_READ_CAPS = {
-    maxLineBytes: 256 * 1024 * 1024,
-    maxTotalBytes: 256 * 1024 * 1024,
-};
-/** Caps the BROKER uses reading CLIENT frames. Sized so an image-paste frame
- *  fits: a resizeImage-bounded PNG's base64 is a few MiB and would clip a
- *  tighter 4 MiB line cap, so these hold an image-bearing `prompt`/`steer`/
- *  `follow_up` frame. Still bounded, so a malicious/buggy client→broker frame
- *  is cap-and-dropped, never grow-to-OOM (C5). */
-export const BROKER_READ_CAPS = {
-    maxLineBytes: 24 * 1024 * 1024,
-    maxTotalBytes: 48 * 1024 * 1024,
-};
-/** Incremental newline-delimited JSON reader: feed raw socket chunks, get back
- *  the complete frames decoded so far. Buffers a partial trailing line across
- *  pushes; silently drops a malformed (unparseable) line (a viewer must never
- *  crash the broker on bad JSON). The caller narrows the `unknown` against the
- *  frame unions.
- *
- *  BOUNDED (C5): an oversized buffer is the THROW case. If a single push peaks the
- *  internal buffer above `maxTotalBytes`, or the surviving (unterminated) partial
- *  line exceeds `maxLineBytes`, {@link push} throws {@link FrameOverflowError}
- *  instead of returning frames — the caller drops that peer rather than letting a
- *  malicious/buggy stream grow the buffer to OOM. Bytes are measured with
- *  `Buffer.byteLength`, never string length; a running counter makes each push's
- *  size CHECK O(1) (no re-scan of the whole buffer to measure it).
- *
- *  AMORTIZED O(total bytes) (perf regression fix, 2026-06-09): the partial line
- *  carried across pushes is held as an ARRAY of chunk strings (`parts`), joined
- *  only when its terminating `\n` arrives. The `\n` scan looks at each incoming
- *  chunk ONCE — never re-scanning the accumulated carry — so a multi-MiB frame
- *  arriving in ~64 KiB socket chunks costs O(frame) total instead of O(frame ×
- *  chunks). The old `buf += chunk; buf.indexOf('\n')` shape flattened + re-walked
- *  the whole carry per chunk: a 16 MiB welcome snapshot cost ~250 ms of
- *  event-loop stall in `crtr surface attach` (typing lag) and the same again in the
- *  broker; this shape decodes it in ~13 ms.
- *
- *  A `StringDecoder` decodes incoming Buffer chunks: an incomplete trailing
- *  multibyte sequence is held back across pushes instead of being mangled to
- *  U+FFFD, so a char split at a `node:net` chunk boundary is never corrupted, and
- *  `partBytes` counts decoded-string bytes (a raw `chunk.length` would desync
- *  and weaken the C5 cap on multibyte/invalid input). */
-export class FrameDecoder {
-    caps;
-    /** The unterminated partial line carried across pushes, as unjoined chunks
-     *  (never contains a '\n'). Joined lazily when its newline arrives. */
-    parts = [];
-    /** Byte length (Buffer.byteLength) of `parts` joined — kept in exact lockstep. */
-    partBytes = 0;
-    utf8 = new StringDecoder('utf8');
-    constructor(caps) {
-        this.caps = caps;
-    }
-    push(chunk) {
-        // A string input is already complete text; a Buffer goes through the
-        // StringDecoder so a boundary-split multibyte char is buffered, not corrupted.
-        const str = typeof chunk === 'string' ? chunk : this.utf8.write(chunk);
-        const strBytes = Buffer.byteLength(str);
-        // Peak-buffer bound: caps the most we ever hold in one push (carry + this
-        // entire chunk, before draining complete frames) — identical accounting to
-        // the old whole-buffer check.
-        if (this.partBytes + strBytes > this.caps.maxTotalBytes) {
-            throw new FrameOverflowError('total', this.partBytes + strBytes, this.caps.maxTotalBytes);
-        }
-        const out = [];
-        let from = 0; // scan offset into `str` — each chunk is scanned exactly once
-        let nl;
-        while ((nl = str.indexOf('\n', from)) >= 0) {
-            const tail = str.slice(from, nl);
-            // First line of the push completes the carried partial; later lines live
-            // entirely inside `str` (parts is empty after the first join).
-            const line = (this.parts.length > 0 ? this.parts.join('') + tail : tail).trim();
-            this.parts.length = 0;
-            this.partBytes = 0;
-            from = nl + 1;
-            if (line === '')
-                continue;
-            try {
-                out.push(JSON.parse(line));
-            }
-            catch {
-                /* drop a malformed frame — never throw out of the reader for bad JSON */
-            }
-        }
-        if (from < str.length) {
-            const rest = from === 0 ? str : str.slice(from);
-            this.parts.push(rest);
-            this.partBytes += from === 0 ? strBytes : Buffer.byteLength(rest);
-        }
-        // Single-frame bound: a partial line that has grown past one frame's cap is a
-        // peer streaming bytes with no newline — drop it rather than buffer forever.
-        if (this.partBytes > this.caps.maxLineBytes) {
-            throw new FrameOverflowError('line', this.partBytes, this.caps.maxLineBytes);
-        }
-        return out;
-    }
-}

package/dist/core/runtime/managed-provider-cooling.d.ts

@@ -1,24 +0,0 @@
-import type { AssistantMessageDiagnostic } from '@earendil-works/pi-ai';
-/** Diagnostic `type` tag carrying the cooling deadline; also the wire contract the
- *  stophook matches on. */
-export declare const MANAGED_PROVIDER_COOLING_DIAGNOSTIC = "crtr:managed-provider-cooling";
-/** Stable error code so a caller can recognize the typed error without message parsing. */
-export declare const MANAGED_PROVIDER_COOLING_CODE = "managed_provider_cooling";
-/** Every managed provider pool tried this turn is cooling; `rateLimitedUntil` is
- *  the earliest future deadline (epoch ms) across those pools. */
-export declare class ManagedProviderCoolingError extends Error {
-    readonly code = "managed_provider_cooling";
-    readonly rateLimitedUntil: number;
-    constructor(message: string, rateLimitedUntil: number);
-    /** The diagnostic to attach to the terminal assistant error so the deadline
-     *  reaches the stophook without regex-parsing the message. Built inline (not via
-     *  pi-ai's `createAssistantMessageDiagnostic`) to keep this module's runtime
-     *  import graph pi-free — the shape matches `AssistantMessageDiagnostic`. */
-    toDiagnostic(): AssistantMessageDiagnostic;
-}
-/** Strictly read the managed-cooling deadline (epoch ms) off an assistant
- *  message's diagnostics. Returns the finite, strictly-positive `rateLimitedUntil`
- *  from the first cooling diagnostic, or undefined when the message carries none
- *  (or a malformed one). */
-export declare function hasManagedProviderCoolingDiagnostic(message: unknown): boolean;
-export declare function extractCoolingDeadline(message: unknown): number | undefined;

package/dist/core/runtime/managed-provider-cooling.js

@@ -1,62 +0,0 @@
-// managed-provider-cooling.ts — the typed carrier for "every managed provider
-// pool tried this turn is temporarily cooling down".
-//
-// runManagedProvider (provider-rotation.ts) raises this once every attempted
-// managed-pool credential is rate-limited with at least one finite future
-// deadline. The error converts to an AssistantMessageDiagnostic that survives
-// verbatim into the terminal error message and therefore into agent_end.messages
-// (pi-ai's AssistantMessageEventStream.result() returns the exact error message
-// object). The canvas-stophook reads the earliest deadline back off that message
-// and stamps it onto the pi→provider fault's retry.nextAt, so the broker's
-// existing auto-retry re-drives the pre-content turn exactly when the soonest
-// pool frees up — turning a transient pool cooldown into an auto (not fatal)
-// fault instead of a permanent one.
-/** Diagnostic `type` tag carrying the cooling deadline; also the wire contract the
- *  stophook matches on. */
-export const MANAGED_PROVIDER_COOLING_DIAGNOSTIC = "crtr:managed-provider-cooling";
-/** Stable error code so a caller can recognize the typed error without message parsing. */
-export const MANAGED_PROVIDER_COOLING_CODE = "managed_provider_cooling";
-/** Every managed provider pool tried this turn is cooling; `rateLimitedUntil` is
- *  the earliest future deadline (epoch ms) across those pools. */
-export class ManagedProviderCoolingError extends Error {
-    code = MANAGED_PROVIDER_COOLING_CODE;
-    rateLimitedUntil;
-    constructor(message, rateLimitedUntil) {
-        super(message);
-        this.name = "ManagedProviderCoolingError";
-        this.rateLimitedUntil = rateLimitedUntil;
-    }
-    /** The diagnostic to attach to the terminal assistant error so the deadline
-     *  reaches the stophook without regex-parsing the message. Built inline (not via
-     *  pi-ai's `createAssistantMessageDiagnostic`) to keep this module's runtime
-     *  import graph pi-free — the shape matches `AssistantMessageDiagnostic`. */
-    toDiagnostic() {
-        return {
-            type: MANAGED_PROVIDER_COOLING_DIAGNOSTIC,
-            timestamp: Date.now(),
-            details: { rateLimitedUntil: this.rateLimitedUntil },
-        };
-    }
-}
-/** Strictly read the managed-cooling deadline (epoch ms) off an assistant
- *  message's diagnostics. Returns the finite, strictly-positive `rateLimitedUntil`
- *  from the first cooling diagnostic, or undefined when the message carries none
- *  (or a malformed one). */
-export function hasManagedProviderCoolingDiagnostic(message) {
-    const diagnostics = message?.diagnostics;
-    return Array.isArray(diagnostics) && diagnostics.some((diagnostic) => diagnostic?.type === MANAGED_PROVIDER_COOLING_DIAGNOSTIC);
-}
-export function extractCoolingDeadline(message) {
-    const diagnostics = message?.diagnostics;
-    if (!Array.isArray(diagnostics))
-        return undefined;
-    for (const diagnostic of diagnostics) {
-        if (diagnostic?.type !== MANAGED_PROVIDER_COOLING_DIAGNOSTIC)
-            continue;
-        const raw = diagnostic?.details?.rateLimitedUntil;
-        const value = typeof raw === "number" ? raw : Number(raw);
-        if (Number.isFinite(value) && value > 0)
-            return value;
-    }
-    return undefined;
-}

package/dist/core/runtime/stamp/protocol.d.ts

@@ -1,90 +0,0 @@
-export declare const CRTR_STAMP_CUSTOM_TYPE = "crtr-stamp";
-/** Envelope version. Readers switch on `(kind, v)`. */
-export declare const STAMP_SCHEMA_VERSION = 1;
-export interface StampEnvelope<K extends string = string, P = object> {
-    v: number;
-    kind: K;
-    payload: P;
-    /** Plugin/contributor fields, namespaced. The core writer never interprets them. */
-    ext?: Record<string, Record<string, unknown>>;
-}
-/** One session file belongs to one node: which node, and which crtr wrote it.
- *  Makes the file self-describing off-box, where canvas.db is unavailable. */
-export interface SessionStampPayload {
-    node: string;
-    crtr: string;
-}
-/** Transport a person's words arrived on. crouter core knows the attach viewer;
- *  other front doors announce their own channel. */
-export interface HumanOrigin {
-    type: 'human';
-    channel?: {
-        type: string;
-    };
-}
-/** The runtime kinds mirror the `<runtime kind="…">` card vocabulary. */
-export type RuntimeOriginKind = 'inbox' | 'wake' | 'revive' | 'restart-continuation' | 'stop-guard' | 'park' | 'recovery' | 'context-nudge' | 'kickoff';
-/** One durable inbox entry's attribution, as delivered. */
-export interface InboxOriginEntry {
-    from?: string;
-    fromName?: string;
-    kind: string;
-    tier: string;
-    ref?: string;
-}
-export interface RuntimeOrigin {
-    type: 'runtime';
-    kind: RuntimeOriginKind;
-    /** `wake` carries the fired cron's `WakeOrigin` under this key rather than
-     *  spread flat: WakeOrigin has its own `kind` (`node_birth` /
-     *  `schedule_revive`), which flat would overwrite the origin kind. */
-    wake?: {
-        kind: string;
-        ownerId: string | null;
-        ownerName?: string;
-        armedAt: string;
-        recur?: string | null;
-    };
-    /** `inbox` carries one element per delivered entry. */
-    entries?: InboxOriginEntry[];
-    /** Other kind-specific structured fields — the structure the seam holds,
-     *  where the card carries only prose. */
-    [field: string]: unknown;
-}
-export type MessageOrigin = HumanOrigin | RuntimeOrigin;
-export type MessageVisibility = 'visible' | 'internal';
-export interface MessageStampPayload {
-    /** The target message's own `timestamp` (unix ms) — the join key. */
-    msgTs: number;
-    /** Absent means the message arrived with no announced origin (unknown),
-     *  never a guess. */
-    origin?: MessageOrigin;
-    /** Absent means visible. Internal messages remain in the raw session and
-     *  carry their classification through transcript projections. */
-    visibility?: MessageVisibility;
-}
-export type SessionStamp = StampEnvelope<'session', SessionStampPayload>;
-export type MessageStamp = StampEnvelope<'message', MessageStampPayload>;
-/** A kickoff prompt is composed by the daemon but sent by the broker, in a
- *  different process, so its origin rides the broker's spawn env instead of the
- *  in-process announcement channel. */
-export declare const KICKOFF_ORIGIN_ENV = "CRTR_KICKOFF_ORIGIN";
-export declare function encodeKickoffOrigin(origin: MessageOrigin): string;
-/** The kickoff origin the spawner recorded, or null when this launch carried
- *  none (an idle broker, or a launch predating the variable). */
-export declare function decodeKickoffOrigin(raw: string | undefined): MessageOrigin | null;
-/** The stamp envelope carried by one session entry, or null when the entry is
- *  not a well-formed crtr-stamp. */
-export declare function readStampEntry(entry: unknown): StampEnvelope | null;
-/** Every well-formed stamp in `entries`, in file order. */
-export declare function readStamps(entries: readonly unknown[]): StampEnvelope[];
-/** The session stamp in force at the end of `entries` — a fork carries the
- *  source node's stamp until the new node appends its own, so "latest" is what
- *  a reader wants. */
-export declare function latestSessionStamp(entries: readonly unknown[]): SessionStamp | null;
-/** The stamp for the message persisted at `msgTs`. Late or revised metadata is
- *  a second stamp with the same key, so the last one wins. */
-export declare function messageStampFor(entries: readonly unknown[], msgTs: number): MessageStamp | null;
-/** Who authored the message persisted at `msgTs`, or null when nothing
- *  announced an origin for it. */
-export declare function originFor(entries: readonly unknown[], msgTs: number): MessageOrigin | null;

package/dist/core/runtime/stamp/protocol.js

@@ -1,113 +0,0 @@
-// crtr-stamp — the durable per-message metadata crouter hangs on a pi session
-// jsonl. One customType carries every record; the record shape is discriminated
-// inside `data` by `kind`.
-//
-// A stamp is a pi CustomEntry: a standalone jsonl line that pi's
-// buildSessionContext ignores, so nothing here ever reaches the LLM. Stamps are
-// correlated to messages by the target message's own `timestamp` (`msgTs`), not
-// by tree position — an extension's message_end handler runs BEFORE pi persists
-// the message, so a stamp is physically the message's parent, never its child.
-//
-// Readers MUST ignore unknown envelope keys: that is what makes adding an
-// optional field later non-breaking. `v` bumps only for a rename, a removal, or
-// a change of meaning.
-//
-// The writer is `src/pi-extensions/canvas-stamp.ts` and nothing else.
-export const CRTR_STAMP_CUSTOM_TYPE = 'crtr-stamp';
-/** Envelope version. Readers switch on `(kind, v)`. */
-export const STAMP_SCHEMA_VERSION = 1;
-/** A kickoff prompt is composed by the daemon but sent by the broker, in a
- *  different process, so its origin rides the broker's spawn env instead of the
- *  in-process announcement channel. */
-export const KICKOFF_ORIGIN_ENV = 'CRTR_KICKOFF_ORIGIN';
-export function encodeKickoffOrigin(origin) {
-    return JSON.stringify(origin);
-}
-/** The kickoff origin the spawner recorded, or null when this launch carried
- *  none (an idle broker, or a launch predating the variable). */
-export function decodeKickoffOrigin(raw) {
-    if (raw === undefined || raw.trim() === '')
-        return null;
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-    if (!isRecord(parsed))
-        return null;
-    if (parsed['type'] !== 'human' && parsed['type'] !== 'runtime')
-        return null;
-    return parsed;
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-/** The stamp envelope carried by one session entry, or null when the entry is
- *  not a well-formed crtr-stamp. */
-export function readStampEntry(entry) {
-    if (!isRecord(entry))
-        return null;
-    const candidate = entry;
-    if (candidate.type !== 'custom' || candidate.customType !== CRTR_STAMP_CUSTOM_TYPE)
-        return null;
-    const data = candidate.data;
-    if (!isRecord(data))
-        return null;
-    if (typeof data['v'] !== 'number' || typeof data['kind'] !== 'string')
-        return null;
-    if (!isRecord(data['payload']))
-        return null;
-    const ext = data['ext'];
-    if (ext !== undefined && !isRecord(ext))
-        return null;
-    return data;
-}
-/** Every well-formed stamp in `entries`, in file order. */
-export function readStamps(entries) {
-    const stamps = [];
-    for (const entry of entries) {
-        const stamp = readStampEntry(entry);
-        if (stamp !== null)
-            stamps.push(stamp);
-    }
-    return stamps;
-}
-function isSessionStamp(stamp) {
-    if (stamp.kind !== 'session' || stamp.v !== STAMP_SCHEMA_VERSION)
-        return false;
-    const payload = stamp.payload;
-    return typeof payload.node === 'string' && typeof payload.crtr === 'string';
-}
-function isMessageStamp(stamp) {
-    if (stamp.kind !== 'message' || stamp.v !== STAMP_SCHEMA_VERSION)
-        return false;
-    return typeof stamp.payload.msgTs === 'number';
-}
-/** The session stamp in force at the end of `entries` — a fork carries the
- *  source node's stamp until the new node appends its own, so "latest" is what
- *  a reader wants. */
-export function latestSessionStamp(entries) {
-    let latest = null;
-    for (const stamp of readStamps(entries)) {
-        if (isSessionStamp(stamp))
-            latest = stamp;
-    }
-    return latest;
-}
-/** The stamp for the message persisted at `msgTs`. Late or revised metadata is
- *  a second stamp with the same key, so the last one wins. */
-export function messageStampFor(entries, msgTs) {
-    let match = null;
-    for (const stamp of readStamps(entries)) {
-        if (isMessageStamp(stamp) && stamp.payload.msgTs === msgTs)
-            match = stamp;
-    }
-    return match;
-}
-/** Who authored the message persisted at `msgTs`, or null when nothing
- *  announced an origin for it. */
-export function originFor(entries, msgTs) {
-    return messageStampFor(entries, msgTs)?.payload.origin ?? null;
-}

package/dist/core/scopes.d.ts

@@ -1,17 +0,0 @@
-import { scopeAllowed } from '../shared/env.js';
-export { scopeAllowed };
-/** The scopes an unrestricted local terminal run presents to the document substrate. */
-export declare const SCOPE_VOCABULARY: readonly ["crtr:llm", "crtr:act", "crtr:schedule", "crtr:memory:rw:user", "crtr:memory:manage:user", "crtr:files:rw:user:."];
-/** Reject unknown scope strings before they can silently change an allow-list. */
-export declare function validateScopes(value: unknown): string[];
-export declare function assertScope(meta: {
-    node_id: string;
-    scopes?: readonly string[] | null;
-}, scope: string): void;
-/** `holder` names who lacks the scope in prose — `node <id>` for a node's own
- *  allow-list, `the bearer token` for a scoped API token's ceiling. */
-export declare class ScopeDeniedError extends Error {
-    readonly holder: string;
-    readonly scope: string;
-    constructor(holder: string, scope: string);
-}

package/dist/core/scopes.js

@@ -1,42 +0,0 @@
-import { parseScope } from '@north-light/crouter-identity';
-import { scopeAllowed } from '../shared/env.js';
-import { InputError } from './io.js';
-export { scopeAllowed };
-/** The scopes an unrestricted local terminal run presents to the document substrate. */
-export const SCOPE_VOCABULARY = [
-    'crtr:llm', 'crtr:act', 'crtr:schedule', 'crtr:memory:rw:user',
-    'crtr:memory:manage:user', 'crtr:files:rw:user:.',
-];
-/** Reject unknown scope strings before they can silently change an allow-list. */
-export function validateScopes(value) {
-    if (!Array.isArray(value))
-        throw new InputError({ error: 'unknown_scope', message: 'scopes must be a list', received: value, field: 'scopes', next: 'Pass identity scope strings.' });
-    for (const scope of value) {
-        try {
-            if (typeof scope !== 'string')
-                throw new TypeError('scope is not a string');
-            parseScope(scope);
-        }
-        catch {
-            throw new InputError({ error: 'unknown_scope', message: `unknown scope: ${String(scope)}`, received: scope, field: 'scopes', next: 'Pass identity scope strings.' });
-        }
-    }
-    return [...value];
-}
-export function assertScope(meta, scope) {
-    if (scopeAllowed(meta.scopes, scope))
-        return;
-    throw new ScopeDeniedError(`node ${meta.node_id}`, scope);
-}
-/** `holder` names who lacks the scope in prose — `node <id>` for a node's own
- *  allow-list, `the bearer token` for a scoped API token's ceiling. */
-export class ScopeDeniedError extends Error {
-    holder;
-    scope;
-    constructor(holder, scope) {
-        super(`${holder} does not hold the ${scope} scope`);
-        this.holder = holder;
-        this.scope = scope;
-        this.name = 'ScopeDeniedError';
-    }
-}

package/dist/core/substrate/subject-fields.d.ts

@@ -1,48 +0,0 @@
-import type { Mode, Lifecycle } from '../canvas/types.js';
-/** The gate input: a node's configuration as a structured object. Field names
- *  and shape are the predicate vocabulary's dotted paths (`orchestration.depth`,
- *  `hasManager`, …). There is intentionally NO `tags` field — NodeMeta has none. */
-export interface NodeConfigSubject {
-    /** The node's role, free-form (developer | explore | design | …). NodeMeta.kind. */
-    kind: string;
-    /** base (hands-on worker) | orchestrator (delegating manager). NodeMeta.mode. */
-    mode: Mode;
-    /** terminal (worker) | resident (manager). NodeMeta.lifecycle. */
-    lifecycle: Lifecycle;
-    /** Spine position: does this node have a manager? (= parent !== null). */
-    hasManager: boolean;
-    /** The node's working directory on disk. NodeMeta.cwd. */
-    cwd: string;
-    /** DERIVED: the scope scope.ts resolves for `cwd` — `project` when a
-     *  nearest-ancestor `.crouter/` exists at/above cwd, else `user`. */
-    scope: 'user' | 'project';
-    /** DERIVED orchestration metrics. */
-    orchestration: {
-        /** Spine distance (hops) from this node up to its root orchestrator. The
-         *  root itself is 0; a direct child of the root is 1; etc. */
-        depth: number;
-    };
-    /** DERIVED: `meta.profile_id` resolved to its manifest's mutable `name` (NOT
-     *  the stable directory id — gate authors write `gate: {profile: <name>}`).
-     *  null for historical null-profile rows, and null (never throwing) when the
-     *  profile has been deleted or its manifest is unreadable — this is a HOT,
-     *  every-doc-render path and must never brick boot/on-read gating. */
-    profile: string | null;
-    /** Effective per-run scopes. */
-    scopes: readonly string[];
-    /** DERIVED: handles of the repos enclosing `cwd`, nearest first. A rule's
-     *  `if: {repo: crouter}` holds when any element is `crouter`. */
-    repo: readonly string[];
-}
-export declare function effectiveScopes(scopes: readonly string[] | null | undefined): string[];
-/** The scope a cwd resolves into: `project` when scope.ts finds a
- *  nearest-ancestor `.crouter/` at/above it, else `user`. Reuses the existing
- *  resolver (`projectScopeRoot`). */
-export declare function scopeForCwd(cwd: string): 'user' | 'project';
-/** Resolve `profile_id` to the manifest's mutable `name` for the gate subject.
- *  NEVER throws: a missing/deleted profile resolves to `null` silently (the
- *  ordinary lifecycle of a node whose profile was deleted out from under it);
- *  any OTHER failure (e.g. an unreadable/corrupt manifest slipping past
- *  `loadProfileManifest`'s own tolerance) is logged and still resolves to
- *  `null` rather than throwing — this runs on every gated-doc render. */
-export declare function profileNameFor(profileId: string | null | undefined): string | null;

package/dist/core/substrate/subject-fields.js

@@ -1,39 +0,0 @@
-// subject-fields.ts — the PURE half of subject assembly: the NodeConfigSubject
-// shape plus the two derived-field resolvers (`scopeForCwd`, `profileNameFor`)
-// that read scope/profile config but NEVER the canvas-db. Split out of
-// subject.ts so CLI consumers (`sys context prompt-review`) can build a subject from an
-// API-fetched node without pulling subject.ts's canvas-db reach (getNode/getRow).
-// The canvas-db assembler (`assembleNodeSubject`, `spineDepth`) stays in
-// subject.ts for broker/daemon-side callers.
-import { projectScopeRoot } from '../scope.js';
-import { loadProfileManifest } from '../profiles/manifest.js';
-import { CrtrError } from '../errors.js';
-import { SCOPE_VOCABULARY } from '../scopes.js';
-export function effectiveScopes(scopes) {
-    return scopes === null || scopes === undefined ? [...SCOPE_VOCABULARY] : [...scopes];
-}
-/** The scope a cwd resolves into: `project` when scope.ts finds a
- *  nearest-ancestor `.crouter/` at/above it, else `user`. Reuses the existing
- *  resolver (`projectScopeRoot`). */
-export function scopeForCwd(cwd) {
-    return projectScopeRoot(cwd) !== null ? 'project' : 'user';
-}
-/** Resolve `profile_id` to the manifest's mutable `name` for the gate subject.
- *  NEVER throws: a missing/deleted profile resolves to `null` silently (the
- *  ordinary lifecycle of a node whose profile was deleted out from under it);
- *  any OTHER failure (e.g. an unreadable/corrupt manifest slipping past
- *  `loadProfileManifest`'s own tolerance) is logged and still resolves to
- *  `null` rather than throwing — this runs on every gated-doc render. */
-export function profileNameFor(profileId) {
-    if (profileId === undefined || profileId === null || profileId === '')
-        return null;
-    try {
-        return loadProfileManifest(profileId).manifest.name;
-    }
-    catch (err) {
-        if (err instanceof CrtrError && err.code === 'not_found')
-            return null;
-        console.warn(`[subject] profile "${profileId}" failed to resolve for node subject assembly: ${err.message}`);
-        return null;
-    }
-}

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

@@ -1,26 +0,0 @@
-/** 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;