@celestea/core 2.7.1

package/dist/contracts/index.d.ts

@@ -0,0 +1,234 @@
+/**
+ * Machine-readable contract loader (P0; hardened in W807).
+ *
+ * Everything under contracts/ is frozen data; this module only reads and
+ * validates it. Counts are asserted here so a drifted contract fails loudly.
+ *
+ * W807 -- READ ONCE, THEN TRUST THE SNAPSHOT. The loader used to re-read every
+ * JSON file on every call while comparing it against counts baked in at module
+ * load time. A running process was therefore a contradiction waiting to happen:
+ * 2026-09-16 W804 bumped contracts/tools.json from 11 to 12 while production had
+ * 11 in memory, so every compose 500'd ("tools contract must hold 11 tools, got
+ * 12") until an operator restarted. A store now validates a contract file ONCE
+ * and caches it for the process lifetime, so a later disk edit cannot make a
+ * running process contradict itself. verifyContractsAtStartup() is the explicit
+ * boot gate: it refuses to start on a mismatch (naming file, expected and
+ * actual) instead of booting into a later 500.
+ */
+import type { ToolSpec } from "../types.js";
+export interface EndpointField {
+    name: string;
+    type: string;
+    required?: boolean;
+    /** Present only in some response variants (e.g. kept_turns when compacted). */
+    optional?: boolean;
+    note?: string;
+}
+export interface EndpointRequest {
+    kind: "none" | "json" | "query";
+    fields: EndpointField[];
+    note?: string;
+}
+export interface EndpointResponse {
+    status: number;
+    shape: string;
+    fields: EndpointField[];
+    contentType?: string;
+    publicView?: {
+        excluded: string[];
+        note: string;
+    };
+}
+export interface EndpointError {
+    status: number;
+    error: string;
+    note?: string;
+}
+export interface EndpointProbe {
+    checked: boolean;
+    mode?: string;
+    server?: string;
+    reason?: string;
+    [k: string]: unknown;
+}
+export interface EndpointContract {
+    id: string;
+    method: "GET" | "POST" | "DELETE" | "PUT";
+    path: string;
+    group: string;
+    rustHandler: string;
+    docRef: string;
+    request: EndpointRequest;
+    response: EndpointResponse;
+    errors: EndpointError[];
+    notes?: string[];
+    probe?: EndpointProbe;
+}
+export interface EndpointsContract {
+    title: string;
+    generatedAt: string;
+    source: Record<string, string>;
+    conventions: Record<string, string>;
+    errorCodes: Record<string, string>;
+    count: number;
+    endpoints: EndpointContract[];
+}
+export interface SseEventContract {
+    name: string;
+    payload: Record<string, string>;
+    source: string;
+    codeRef: string;
+    frontendListens: boolean;
+    note?: string;
+}
+export interface SseContract {
+    transport: {
+        contentType: string;
+        keepAlive: boolean;
+        busCapacity: number;
+        envelope: Record<string, string>;
+        frameFormat: string;
+    };
+    lagged: {
+        trigger: string;
+        event: string;
+        payload: Record<string, string>;
+        semantics: string;
+        codeRef: string;
+    };
+    count: number;
+    events: SseEventContract[];
+}
+export interface RouteSnapshotEntry {
+    method: string;
+    path: string;
+    rustHandler: string;
+}
+export interface RouteSnapshot {
+    routeDeclarations: number;
+    methodPathCombos: number;
+    apiEndpoints: number;
+    staticRoutes: RouteSnapshotEntry[];
+    routes: RouteSnapshotEntry[];
+    /**
+     * W516: routes that exist ONLY in the TypeScript backend (no legacy
+     * counterpart). The legacy extraction above stays intact; a contract endpoint
+     * must appear in routes or here.
+     */
+    tsOnlyRoutes?: RouteSnapshotEntry[];
+    tsApiEndpoints?: number;
+    tsMethodPathCombos?: number;
+}
+export interface ToolsContract {
+    count: number;
+    tools: Array<ToolSpec & {
+        sourceRef: string;
+    }>;
+}
+export interface DataFileEntry {
+    file: string;
+    schema: string;
+    version: string;
+    mode: string;
+    secret?: boolean;
+    /** W787: free-form ownership / path note (optional, purely documentary). */
+    note?: string;
+}
+export interface DataFilesIndex {
+    freezeRule: string;
+    files: DataFileEntry[];
+    durability: Record<string, string>;
+    roundTripRequirement: string;
+    /**
+     * Per-capability implementation notes (iteration E): which part of a design
+     * section is implemented and which is explicitly deferred. Optional, because
+     * a capability that added no data file has nothing to report here.
+     */
+    recovery?: {
+        implemented: string;
+        notImplemented: string;
+    };
+    /** W787 (capability 2): the worker table's own implementation split. */
+    workerRegistry?: {
+        implemented: string;
+        notImplemented: string;
+    };
+    /** W804 (multimodal P0): the per-session attachment object store. */
+    attachments?: {
+        location: string;
+        kind: string;
+        introduced: string;
+        lifecycle: string;
+        fixtures: string;
+        schema: string;
+    };
+}
+/**
+ * The frozen counts. These are the module-load-time constants a drifted
+ * contracts file used to contradict (W804). They are deliberately NOT derived
+ * from the files, and must never be edited to paper over a contract edit -- the
+ * file change is what gets reviewed and the counts only follow a deliberate
+ * freeze revision.
+ */
+export declare const FROZEN_COUNTS: {
+    readonly endpoints: 64;
+    readonly sseEvents: 9;
+    readonly tools: 18;
+};
+/** One frozen-count divergence, with everything an operator needs to act. */
+export interface ContractMismatch {
+    /** File name relative to the contracts directory (e.g. tools.json). */
+    file: string;
+    /** Absolute path of the file, so the operator can open it directly. */
+    path: string;
+    /** Which number diverged: the declared count field, or the array length. */
+    field: string;
+    expected: number;
+    actual: number;
+}
+/** Raised when a contract file contradicts a frozen count. */
+export declare class ContractValidationError extends Error {
+    readonly mismatches: ContractMismatch[];
+    readonly dir: string;
+    constructor(dir: string, mismatches: ContractMismatch[]);
+}
+/**
+ * A contract store bound to one directory. Every value is read from disk at
+ * most once: the first (validated) read wins and is reused for the rest of the
+ * process lifetime. Tests point a store at a throwaway copy; the process-wide
+ * contractStore() points at the real repository.
+ */
+export interface ContractStore {
+    readonly dir: string;
+    loadEndpoints(): EndpointsContract;
+    loadSse(): SseContract;
+    loadRouteSnapshot(): RouteSnapshot;
+    loadTools(): ToolsContract;
+    loadSessionEventSchema(): Record<string, unknown>;
+    loadDataFilesIndex(): DataFilesIndex;
+    loadDataFileSchema(name: string): Record<string, unknown>;
+    /** Validate the frozen files from disk NOW and prime the cache. Throws on drift. */
+    verifyAtStartup(): void;
+}
+export declare function createContractStore(dir: string): ContractStore;
+/** The process-wide store: one validated snapshot, reused for the process lifetime. */
+export declare function contractStore(): ContractStore;
+export declare function loadEndpoints(): EndpointsContract;
+export declare function loadSse(): SseContract;
+export declare function loadRouteSnapshot(): RouteSnapshot;
+export declare function loadTools(): ToolsContract;
+export declare function loadSessionEventSchema(): Record<string, unknown>;
+export declare function loadDataFilesIndex(): DataFilesIndex;
+export declare function loadDataFileSchema(name: string): Record<string, unknown>;
+/**
+ * The explicit startup gate (W807): Studio calls this once at boot, before it
+ * binds a port. It reads the frozen contract files from disk, throws a
+ * ContractValidationError naming file / expected / actual on any drift, and on
+ * success primes the cache with the exact snapshot that was validated -- so the
+ * running process stays internally consistent for its whole lifetime even if
+ * contracts/*.json changes underneath it.
+ *
+ * A drifted file is a REFUSAL TO START, not a warning: the previous behaviour
+ * was to boot and then 500 on the first request that touched the contract.
+ */
+export declare function verifyContractsAtStartup(): void;

package/dist/contracts/index.js

@@ -0,0 +1,159 @@
+/**
+ * Machine-readable contract loader (P0; hardened in W807).
+ *
+ * Everything under contracts/ is frozen data; this module only reads and
+ * validates it. Counts are asserted here so a drifted contract fails loudly.
+ *
+ * W807 -- READ ONCE, THEN TRUST THE SNAPSHOT. The loader used to re-read every
+ * JSON file on every call while comparing it against counts baked in at module
+ * load time. A running process was therefore a contradiction waiting to happen:
+ * 2026-09-16 W804 bumped contracts/tools.json from 11 to 12 while production had
+ * 11 in memory, so every compose 500'd ("tools contract must hold 11 tools, got
+ * 12") until an operator restarted. A store now validates a contract file ONCE
+ * and caches it for the process lifetime, so a later disk edit cannot make a
+ * running process contradict itself. verifyContractsAtStartup() is the explicit
+ * boot gate: it refuses to start on a mismatch (naming file, expected and
+ * actual) instead of booting into a later 500.
+ */
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { contractsDir } from "../repo.js";
+/**
+ * The frozen counts. These are the module-load-time constants a drifted
+ * contracts file used to contradict (W804). They are deliberately NOT derived
+ * from the files, and must never be edited to paper over a contract edit -- the
+ * file change is what gets reviewed and the counts only follow a deliberate
+ * freeze revision.
+ */
+export const FROZEN_COUNTS = {
+    // W860: 57 -> 60 (GET|PUT /api/sessions/{id}/tools + GET /api/plugins).
+    // W870: 60 -> 61 (PUT /api/sessions/{id}/model, the session-scoped model switch).
+    // G5: 61 -> 62 (GET /api/fs/list, the Win-style file-manager listing);
+    // G2: 62 -> 63 (POST /api/exec, immediate shell execution without the model).
+    // G5 follow-up: 63 -> 64 (GET /api/fs/read, the file manager viewer).
+    endpoints: 64,
+    sseEvents: 9,
+    // W884: 13 -> 14 (`load_skill`, the on-demand half of skill progressive
+    // disclosure; the catalog half adds no tool).
+    // F4: 14 -> 16 (`browser_open` + `browser_act`, the session browser tools).
+    // B2 (F3 P1): 16 -> 18 (`remember` + `forget`, the workspace-memory write pair).
+    tools: 18,
+};
+/** Raised when a contract file contradicts a frozen count. */
+export class ContractValidationError extends Error {
+    mismatches;
+    dir;
+    constructor(dir, mismatches) {
+        const detail = mismatches
+            .map((m) => m.file + " (" + m.field + "): expected " + m.expected + ", got " + m.actual + " [" + m.path + "]")
+            .join("; ");
+        super("frozen contract violated in " + dir + " -- refusing to start: " + detail);
+        this.name = "ContractValidationError";
+        this.dir = dir;
+        this.mismatches = mismatches;
+    }
+}
+/** Every frozen file is checked twice: its declared count and its array length. */
+const FROZEN_CHECKS = [
+    { file: "endpoints.json", field: "count", expected: FROZEN_COUNTS.endpoints, measure: (d) => d.count },
+    { file: "endpoints.json", field: "endpoints[]", expected: FROZEN_COUNTS.endpoints, measure: (d) => d.endpoints.length },
+    { file: "sse-events.json", field: "count", expected: FROZEN_COUNTS.sseEvents, measure: (d) => d.count },
+    { file: "sse-events.json", field: "events[]", expected: FROZEN_COUNTS.sseEvents, measure: (d) => d.events.length },
+    { file: "tools.json", field: "count", expected: FROZEN_COUNTS.tools, measure: (d) => d.count },
+    { file: "tools.json", field: "tools[]", expected: FROZEN_COUNTS.tools, measure: (d) => d.tools.length },
+];
+const FROZEN_FILES = [...new Set(FROZEN_CHECKS.map((c) => c.file))];
+function checkFrozen(file, doc, dir) {
+    return FROZEN_CHECKS.filter((c) => c.file === file)
+        .map((c) => ({ file, path: resolve(dir, file), field: c.field, expected: c.expected, actual: c.measure(doc) }))
+        .filter((m) => m.actual !== m.expected);
+}
+export function createContractStore(dir) {
+    const cache = new Map();
+    function readJson(...parts) {
+        return JSON.parse(readFileSync(resolve(dir, ...parts), "utf8"));
+    }
+    function cached(key, load) {
+        const hit = cache.get(key);
+        if (hit !== undefined)
+            return hit;
+        const value = load();
+        cache.set(key, value);
+        return value;
+    }
+    function loadChecked(file) {
+        return cached(file, () => {
+            const value = readJson(file);
+            const mismatches = checkFrozen(file, value, dir);
+            if (mismatches.length > 0)
+                throw new ContractValidationError(dir, mismatches);
+            return value;
+        });
+    }
+    function verifyAtStartup() {
+        const mismatches = [];
+        const snapshot = new Map();
+        for (const file of FROZEN_FILES) {
+            const value = readJson(file);
+            mismatches.push(...checkFrozen(file, value, dir));
+            snapshot.set(file, value);
+        }
+        if (mismatches.length > 0)
+            throw new ContractValidationError(dir, mismatches);
+        for (const [file, value] of snapshot)
+            cache.set(file, value);
+    }
+    return {
+        dir,
+        loadEndpoints: () => loadChecked("endpoints.json"),
+        loadSse: () => loadChecked("sse-events.json"),
+        loadTools: () => loadChecked("tools.json"),
+        loadRouteSnapshot: () => cached("route-table.snapshot.json", () => readJson("route-table.snapshot.json")),
+        loadSessionEventSchema: () => cached("session-event.schema.json", () => readJson("session-event.schema.json")),
+        loadDataFilesIndex: () => cached("data-files/index.json", () => readJson("data-files", "index.json")),
+        loadDataFileSchema: (name) => cached("data-files/" + name, () => readJson("data-files", name)),
+        verifyAtStartup,
+    };
+}
+let singleton = null;
+/** The process-wide store: one validated snapshot, reused for the process lifetime. */
+export function contractStore() {
+    if (singleton === null)
+        singleton = createContractStore(contractsDir());
+    return singleton;
+}
+export function loadEndpoints() {
+    return contractStore().loadEndpoints();
+}
+export function loadSse() {
+    return contractStore().loadSse();
+}
+export function loadRouteSnapshot() {
+    return contractStore().loadRouteSnapshot();
+}
+export function loadTools() {
+    return contractStore().loadTools();
+}
+export function loadSessionEventSchema() {
+    return contractStore().loadSessionEventSchema();
+}
+export function loadDataFilesIndex() {
+    return contractStore().loadDataFilesIndex();
+}
+export function loadDataFileSchema(name) {
+    return contractStore().loadDataFileSchema(name);
+}
+/**
+ * The explicit startup gate (W807): Studio calls this once at boot, before it
+ * binds a port. It reads the frozen contract files from disk, throws a
+ * ContractValidationError naming file / expected / actual on any drift, and on
+ * success primes the cache with the exact snapshot that was validated -- so the
+ * running process stays internally consistent for its whole lifetime even if
+ * contracts/*.json changes underneath it.
+ *
+ * A drifted file is a REFUSAL TO START, not a warning: the previous behaviour
+ * was to boot and then 500 on the first request that touched the contract.
+ */
+export function verifyContractsAtStartup() {
+    contractStore().verifyAtStartup();
+}

package/dist/errors.d.ts

@@ -0,0 +1,16 @@
+/** HTTP error contract helpers (the {ok:false,error} envelope). */
+import type { ErrorEnvelope } from "./types.js";
+export declare class StudioError extends Error {
+    readonly status: number;
+    readonly detail?: unknown;
+    constructor(status: number, message: string, detail?: unknown);
+    toEnvelope(): ErrorEnvelope;
+}
+/** Shared session-id resolution errors (src/workspaces.rs:611-652). */
+export declare const SessionIdErrors: {
+    readonly malformed: (id: string) => StudioError;
+    readonly unknownWorkspace: (name: string) => StudioError;
+    readonly invalid: (id: string) => StudioError;
+    readonly unknownSession: (id: string) => StudioError;
+    readonly busy: (what: string) => StudioError;
+};

package/dist/errors.js

@@ -0,0 +1,22 @@
+/** HTTP error contract helpers (the {ok:false,error} envelope). */
+export class StudioError extends Error {
+    status;
+    detail;
+    constructor(status, message, detail) {
+        super(message);
+        this.name = "StudioError";
+        this.status = status;
+        this.detail = detail;
+    }
+    toEnvelope() {
+        return { ok: false, error: this.message };
+    }
+}
+/** Shared session-id resolution errors (src/workspaces.rs:611-652). */
+export const SessionIdErrors = {
+    malformed: (id) => new StudioError(400, `invalid session id '${id}': expected '<workspace>/<session>'`),
+    unknownWorkspace: (name) => new StudioError(404, `unknown workspace '${name}'`),
+    invalid: (id) => new StudioError(400, `invalid session id '${id}'`),
+    unknownSession: (id) => new StudioError(404, `unknown session '${id}'`),
+    busy: (what) => new StudioError(409, `turn in progress; ${what} applies between turns`),
+};

package/dist/event-bus.d.ts

@@ -0,0 +1,60 @@
+/**
+ * EventBus seam — port of `crates/core/src/event_bus.rs`.
+ *
+ * A typed bus with three independent dispatch modes, keyed by event type:
+ *   - on / emit          observe-only broadcast;
+ *   - bail / runBail     intercept chain: first non-`undefined` answer
+ *                        short-circuits (the guard primitive);
+ *   - waterfall / runWaterfall
+ *                        transform chain: each listener maps the running value
+ *                        handed to the next one.
+ *
+ * The three modes live in separate maps, so a listener registered in one mode
+ * never interferes with another. The event type is an explicit token — a
+ * well-known string, a symbol, or a class constructor used by identity (see
+ * `context.ts:ServiceToken`).
+ *
+ * `undefined` is `None`: a bail listener that returns `undefined` passes, and a
+ * `null`/`false`/`0` answer short-circuits (unlike a truthiness check).
+ * `runWaterfall` cannot verify at runtime that every listener shares one value
+ * type (the legacy engine panics on a failed downcast); the TS generic makes
+ * one value type per event type a compile-time contract — pass a `transform`
+ * that keeps it.
+ */
+import type { ServiceToken } from "./context.js";
+export type EventKey<E> = ServiceToken<E>;
+export interface EventBus {
+    /** Observe-only broadcast listener. */
+    on<E>(key: EventKey<E>, listener: (event: E) => void): void;
+    /** Deliver to every listener registered with `on` for this key. */
+    emit<E>(key: EventKey<E>, event: E): void;
+    /** Intercept listener; returning `undefined` passes to the next one. */
+    bail<E, R>(key: EventKey<E>, listener: (event: E) => R | undefined): void;
+    /** First non-`undefined` answer in registration order, else undefined. */
+    runBail<E, R>(key: EventKey<E>, event: E): R | undefined;
+    /** Transform listener; each layer receives the previous layer's value. */
+    waterfall<E, R>(key: EventKey<E>, listener: (event: E, value: R) => R): void;
+    /** The value after every waterfall listener has run, in order. */
+    runWaterfall<E, R>(key: EventKey<E>, event: E, init: R): R;
+    /**
+     * W783: ASYNC delegate chain. Each layer receives `(event, next)`: returning a
+     * value CLAIMS the request, calling `next()` delegates to the layer behind it.
+     * This is the cordis waterfall the sync `waterfall` cannot express, because a
+     * claiming layer may have to PARK on a promise (user questions, §5.2).
+     */
+    waterfallAsync<E, R>(key: EventKey<E>, listener: (event: E, next: () => Promise<R>) => Promise<R>): void;
+    /**
+     * W783: run the async chain outermost-first. `init` is the bottom of the
+     * chain (the fallback), reached only when every layer delegates.
+     */
+    runWaterfallAsync<E, R>(key: EventKey<E>, event: E, init: () => Promise<R>): Promise<R>;
+    /** Registered listener counts per mode (diagnostics / tests). */
+    counts(key: EventKey<unknown>): {
+        on: number;
+        bail: number;
+        waterfall: number;
+    };
+}
+export declare function createEventBus(): EventBus;
+/** Well-known token for the engine event bus service. */
+export declare const EVENT_BUS_SERVICE = "celestea.core.EventBus";

package/dist/event-bus.js

@@ -0,0 +1,100 @@
+/**
+ * EventBus seam — port of `crates/core/src/event_bus.rs`.
+ *
+ * A typed bus with three independent dispatch modes, keyed by event type:
+ *   - on / emit          observe-only broadcast;
+ *   - bail / runBail     intercept chain: first non-`undefined` answer
+ *                        short-circuits (the guard primitive);
+ *   - waterfall / runWaterfall
+ *                        transform chain: each listener maps the running value
+ *                        handed to the next one.
+ *
+ * The three modes live in separate maps, so a listener registered in one mode
+ * never interferes with another. The event type is an explicit token — a
+ * well-known string, a symbol, or a class constructor used by identity (see
+ * `context.ts:ServiceToken`).
+ *
+ * `undefined` is `None`: a bail listener that returns `undefined` passes, and a
+ * `null`/`false`/`0` answer short-circuits (unlike a truthiness check).
+ * `runWaterfall` cannot verify at runtime that every listener shares one value
+ * type (the legacy engine panics on a failed downcast); the TS generic makes
+ * one value type per event type a compile-time contract — pass a `transform`
+ * that keeps it.
+ */
+function busKey(key) {
+    return typeof key === "string" ? `event:${key}` : key;
+}
+export function createEventBus() {
+    const subs = new Map();
+    const bailers = new Map();
+    const waterfalls = new Map();
+    // W783: the async delegate chain lives in its own map, so a listener
+    // registered in one mode can never interfere with another (same rule as the
+    // three original modes).
+    const asyncWaterfalls = new Map();
+    const push = (map, key, fn) => {
+        const k = busKey(key);
+        const list = map.get(k);
+        if (list)
+            list.push(fn);
+        else
+            map.set(k, [fn]);
+    };
+    return {
+        on(key, listener) {
+            push(subs, key, listener);
+        },
+        emit(key, event) {
+            for (const fn of subs.get(busKey(key)) ?? [])
+                fn(event);
+        },
+        bail(key, listener) {
+            push(bailers, key, listener);
+        },
+        runBail(key, event) {
+            for (const fn of bailers.get(busKey(key)) ?? []) {
+                const answer = fn(event);
+                if (answer !== undefined)
+                    return answer;
+            }
+            return undefined;
+        },
+        waterfall(key, listener) {
+            push(waterfalls, key, listener);
+        },
+        runWaterfall(key, event, init) {
+            let value = init;
+            for (const fn of waterfalls.get(busKey(key)) ?? []) {
+                value = fn(event, value);
+            }
+            return value;
+        },
+        waterfallAsync(key, listener) {
+            push(asyncWaterfalls, key, listener);
+        },
+        runWaterfallAsync(key, event, init) {
+            // Outermost-first: each layer gets a `next` that walks to the layer
+            // behind it and finally to `init`. Building the chain lazily (inside
+            // `next`) keeps a delegating layer from running anything downstream
+            // until it actually delegates.
+            const layers = asyncWaterfalls.get(busKey(key)) ?? [];
+            const step = (index) => {
+                const fn = layers[index];
+                if (fn === undefined)
+                    return init();
+                return fn(event, () => step(index + 1));
+            };
+            return step(0);
+        },
+        counts(key) {
+            const k = busKey(key);
+            return {
+                on: (subs.get(k) ?? []).length,
+                bail: (bailers.get(k) ?? []).length,
+                waterfall: (waterfalls.get(k) ?? []).length + (asyncWaterfalls.get(k) ?? []).length,
+            };
+        },
+    };
+}
+/** Well-known token for the engine event bus service. */
+export const EVENT_BUS_SERVICE = "celestea.core.EventBus";

package/dist/index.d.ts

@@ -0,0 +1,66 @@
+/**
+ * `@celestea/core` — the semantic kernel: the frozen contract types, the
+ * serde-exact SessionEvent codec, the model-visible Message model, and the
+ * plugin seams (Plugin / Context / EventBus / SessionLog / Llm / ToolGuard).
+ *
+ * Dependency direction: core imports NOTHING from the other packages. Every
+ * concrete implementation (session log, llm provider, tools, agent loop) is a
+ * plugin mounted into a Context at compose time.
+ *
+ * Module map:
+ *   types.ts         frozen P0 contracts (SessionEvent union, SSE, endpoints…)
+ *   message.ts       Role / Content / ToolCall / Message / Usage   (message.rs)
+ *   stream.ts        ModelRequest / StreamEvent / LlmError         (message.rs, llm.rs)
+ *   session-event.ts SessionEvent JSONL codec (validate / serialize)  (session_log.rs)
+ *   session-log.ts   SessionLog seam + storage half + default projection (A2)
+ *   projection.ts    derive_messages / balance_tool_calls      (session/log.rs, A2)
+ *   turn-id.ts       turn id math + audit                      (A2)
+ *   injection.ts     mid-turn delivery seam: lanes / placement / envelope (W513)
+ *   plugin.ts        Plugin seam + NamedRegistry                   (plugin.rs)
+ *   context.ts       Context service container                     (context.rs)
+ *   event-bus.ts     EventBus seam (on/bail/waterfall/waterfallAsync) (event_bus.rs)
+ *   question.ts      user-question seam: service iface + error codes (W783)
+ *   llm.ts           Llm seam + LlmRegistry                        (llm.rs)
+ *   tool.ts          Tool / ToolGuard / ToolRegistry seams         (tool.rs)
+ *   sandbox.ts       Sandbox seam (execution boundary)             (tools/src/sandbox.rs)
+ *   agent.ts         AgentLoop seam + AgentConfig                  (agent.rs)
+ *   json.ts          JSON helpers + serde-exact text
+ *   sse-bus.ts       SDK-side SSE broadcast bus
+ *   redact.ts        secret redaction for fixtures / reports
+ *   repo.ts          repository-relative path helpers
+ *   celestea-home.ts CELESTEA_HOME data-root resolution (W880)
+ *   celestea-sources.ts project/global source layers (W882)
+ *   skills.ts        skill discovery + frontmatter contract (W882)
+ *   skill-catalog.ts skill catalog text for the per-turn injection (W884)
+ *   memory.ts        workspace MEMORY.md turn-context injection (F3)
+ *   errors.ts        shared error types
+ *   contracts/       contract-file loaders (frozen data in contracts/)
+ */
+export * from "./types.js";
+export * from "./message.js";
+export * from "./stream.js";
+export * from "./session-event.js";
+export * from "./session-log.js";
+export * from "./projection.js";
+export * from "./tool-surface.js";
+export * from "./turn-id.js";
+export * from "./injection.js";
+export * from "./plugin.js";
+export * from "./context.js";
+export * from "./event-bus.js";
+export * from "./question.js";
+export * from "./llm.js";
+export * from "./tool.js";
+export * from "./sandbox.js";
+export * from "./agent.js";
+export * from "./json.js";
+export * from "./sse-bus.js";
+export * from "./errors.js";
+export * from "./redact.js";
+export * from "./repo.js";
+export * from "./celestea-home.js";
+export * from "./celestea-sources.js";
+export * from "./skills.js";
+export * from "./skill-catalog.js";
+export * from "./memory.js";
+export * from "./contracts/index.js";