@cueframe/kernel 0.1.0 → 0.1.2

package/dist/_members/director/testing/contract.d.ts

@@ -0,0 +1,52 @@
+import type { DirectorRuntime } from "../domain/ports.js";
+export declare function collectRuntime(runtime: DirectorRuntime, prompt?: string): Promise<({
+    type: "text-delta";
+    text: string;
+} | {
+    type: "reasoning-delta";
+    text: string;
+} | {
+    type: "phase";
+    phase: string;
+    detail?: string | undefined;
+} | {
+    type: "generation";
+    artifact: {
+        kind: "video" | "audio" | "image";
+        status: "generating" | "processing" | "cancelled" | "ready" | "failed" | "draft" | "submitting" | "queued" | "provider_complete" | "materialising" | "cancelling";
+        mediaId: string & import("zod").BRAND<"Id<media>">;
+        createdAt: number;
+        updatedAt: number;
+        clientRequestId: string & import("zod").BRAND<"Id<generationRequest>">;
+        generationGroupId: string & import("zod").BRAND<"Id<generationGroup>">;
+        generationId: string & import("zod").BRAND<"Id<generation>">;
+        version: number;
+        artifactVersion: 1;
+        requestSummary: string;
+        placementReady: boolean;
+        parentMediaId?: (string & import("zod").BRAND<"Id<media>">) | undefined;
+        estimateUsd?: number | undefined;
+        progress?: number | undefined;
+        failure?: {
+            code: string;
+            title: string;
+            retryable: boolean;
+            recovery?: string | undefined;
+            correlationId?: string | undefined;
+        } | undefined;
+    };
+} | {
+    type: "error";
+    error: {
+        code: string;
+        title: string;
+        retryable: boolean;
+        recovery?: string | undefined;
+        source?: "provider" | "generation" | "materialisation" | "agent" | "transport" | undefined;
+        correlationId?: string | undefined;
+        details?: string | undefined;
+    };
+} | {
+    type: "finish";
+})[]>;
+export declare function assertDirectorRuntimeContract(runtime: DirectorRuntime): Promise<void>;

package/dist/_members/director/testing/index.d.ts

@@ -0,0 +1 @@
+export * from "./contract.js";

package/dist/_members/errors/registry.d.ts

@@ -1,15 +1,3 @@
-/**
- * @cueframe/errors — the cross-cutting error contract SSOT.
- *
- * Zero `@cueframe/*` dependencies (enforced by the `errors-is-a-pure-leaf`
- * dependency-cruiser rule) so it can be imported by every framework leaf
- * (incl. perception + composition) and every service without a cycle.
- *
- * One vocabulary (`ERROR_CODES`), one carrier (`CueframeError`), one wire
- * shape (`Envelope`), one Lambda-boundary codec (`encodeError`/`decodeError`),
- * and one sanitization chokepoint (`toWireEnvelope`) that EVERY emit channel
- * routes through before anything reaches an agent.
- */
 export type ErrorStage = "auth" | "billing" | "import" | "validate" | "compose" | "render" | "export" | "system";
 export type ErrorCategory = "authoring" | "transient" | "internal";
 export interface ErrorSpec {
@@ -682,27 +670,7 @@ export declare class CueframeError extends Error {
 }
 export declare function encodeError(e: CueframeError): string;
 export declare function decodeError(msg: string): CueframeError | null;
-/** Scrub SENSITIVE tokens from a raw message that will be PERSISTED or shipped
- *  over a webhook without passing through toWireEnvelope — e.g. failRenderJob's
- *  non-CFERR fallback, where the deep root cause can carry fs paths, presigned
- *  URLs, or Lambda hosts verbatim. */
 export declare function scrubSensitive(s: string): string;
-/**
- * The single sanitization chokepoint. EVERY emit channel routes through it.
- *
- * `opts.trusted` marks an author-curated envelope (a route-built `ApiError`) whose
- * `message` and `fix` we wrote ourselves — vs an UNtrusted envelope translated from a
- * raw/deep error (Lambda/processing/unmapped `ConvexError`) whose text/fields may carry a
- * stack or infra detail. Never set `trusted` for a translated error.
- *
- * - TRUSTED: keep the message (scrubbed defensively) and all `fix` keys (values scrubbed),
- *   so curated fields like `currentEtag`/`projectIds`/`name`/`reason`/`retryAfter` survive
- *   on errors of ANY category — except `internal`, where `fix` is always dropped.
- * - UNTRUSTED: `internal`/`transient` get a generic message; `authoring` keeps a scrubbed
- *   message. `fix` is dropped for `internal` and otherwise reduced to the allow-list +
- *   scrubbed (so `retryAfter` survives but a raw `filePath`/URL cannot).
- * - `locator`: always reduced to the safe key set.
- */
 export declare function toWireEnvelope(e: Envelope, opts?: {
     trusted?: boolean;
 }): Envelope;

package/dist/_members/foundation/codes/index.d.ts

@@ -1,24 +1,3 @@
-/**
- * Cross-cutting invariant code registry.
- *
- * Each domain package declares its own typed code union and constructs
- * `InvariantError` for failures. The shared `InvariantViolation` /
- * `InvariantError` shape gives every domain a uniform error contract
- * (HTTP error mapping, log shape, projection-failure reporting) without
- * forcing all codes into one enum.
- *
- * Usage from a domain package:
- *
- *   import { InvariantError, type InvariantViolation } from "./index.js";
- *
- *   export type CompositionInvariantCode =
- *     | "track_clips_overlap"
- *     | "transition_no_predecessor";
- *
- *   export function trackClipsOverlap(details: { trackId: string }): InvariantViolation<CompositionInvariantCode> {
- *     return { code: "track_clips_overlap", message: "...", details };
- *   }
- */
 export interface InvariantViolation<TCode extends string = string> {
     code: TCode;
     message: string;

package/dist/_members/mcp/adapter.d.ts

@@ -3,42 +3,17 @@ import { type Executor } from './core.js';
 export { CURATED_TOOLS } from './curation.js';
 export { INTERNAL_LOOP_TOOLS } from './internalLoopTools.js';
 export type { CuratedTool } from './curation.js';
-/**
- * The typed sentinel for infra-class tool failures. Thrown from a curated
- * tool's execute(); the AI SDK catches it into a `tool-error` step part, so the
- * throw ALONE changes nothing — the agent loop (authoring/agent.ts) detects the
- * sentinel STRUCTURALLY (name+infra, no package import — mcp↔authoring stay
- * decoupled per Constraint 3(d)), halts the run, and rethrows; the director
- * (mcpSurface) maps it to a nonRetryable ApplicationFailure so the candidate
- * fails loud with the REAL code instead of a design-lock 49 renders later.
- */
 export declare class InfraToolError extends Error {
     readonly code: string;
     readonly infra: true;
     constructor(code: string, message: string);
 }
-/** Structural guard (mirror of the authoring-side local guard). */
 export declare function isInfraToolError(v: unknown): v is InfraToolError;
-/**
- * Classify a non-2xx op response: an infra-class code returns the sentinel to
- * THROW; anything else returns null (caller keeps the Contract-3(a) JSON-string
- * return). Pure + exported for tests. Parses the error envelope itself so it
- * has no dependency on ApiError's shape.
- */
 export declare function infraToolErrorFromResponse(res: {
     status: number;
     text: string;
     requestId?: string;
 }): InfraToolError | null;
-/**
- * Structural progress event/callback — a local, dependency-free mirror of
- * `@cueframe/authoring`'s `OnProgressCallback` (types.ts:368-381). Declared here
- * so `packages/mcp` never imports `@cueframe/authoring` (Constraint 3(d): progress
- * stays external to tool-building; the adapter only *emits* the same shape the
- * in-process `buildDirectorTools` does — buildTools.ts:131-171). `agent:'router'`
- * is a subtype of authoring's `AgentRole`, so an authoring callback is assignable
- * to this param type (contravariance) when threaded through in T7.
- */
 export type AdapterProgressEvent = {
     type: 'tool-call';
     agent: 'router';
@@ -52,87 +27,29 @@ export type AdapterProgressEvent = {
     toolName: string;
     success: boolean;
     message: string;
+    data?: unknown;
     toolCallId: string;
     timestamp: number;
 };
 export type OnProgressCallback = (event: AdapterProgressEvent) => void;
 export interface CuratedToolSetOpts {
-    /**
-     * Which curated tool names to build. REQUIRED — there is no default
-     * surface: the caller owns its allowlist (the director's role scopes live
-     * in its own composeToolScopes.ts since the 2026-08-22 steering
-     * extraction; the desktop and editor lanes pass their own).
-     */
     allowedNames: readonly string[];
-    /**
-     * Optional progress sink — fires a `tool-call` before each op and a
-     * `tool-result` after, mirroring the in-process store (buildTools.ts:131-171).
-     */
     onProgress?: OnProgressCallback;
-    /**
-     * The scratch compose session (Subsystem 1). When present, the adapter injects
-     * `projectId`/`sessionId` from here and HIDES them from every tool schema — the
-     * LLM must never manage session identity — and `apply_composition` stamps
-     * `body.session_id` so writes hit the session SCRATCH, not the project's active
-     * composition (compositions.ts:331 resolves the scratch; the server never mutates
-     * active until commit_session → promoteScratch).
-     */
     session?: {
         projectId: string;
         sessionId: string;
     };
-    /**
-     * Fetch a presigned still URL and return its bytes as base64 (T4). Injectable
-     * for tests; the default streams the R2 presigned PNG to base64, mirroring the
-     * in-process capture path (inLoopCapture.ts:173-174). `render_frame` uses this
-     * to inline each still so the LLM can actually SEE the pixels — the base64 is
-     * returned RAW from execute() and only becomes a vision block in `toModelOutput`
-     * (Constraint 3(b): image bytes never leave execute() content-shaped).
-     */
     fetchImage?: (url: string) => Promise<string>;
-    /**
-     * Per-run in-loop COGS budget (T5). On the MCP path the box-direct
-     * `buildInLoopCapture`/`buildInLoopVerify` caps are gone, so the budget lives in
-     * the tool wrapper: `render_frame` costs a *capture*, `verify_composition` costs
-     * a *verify*. The counters are per-`buildCuratedToolSet` call, so one budget
-     * spans the whole author run (a fresh ToolSet is built per author invocation —
-     * matches the in-process per-run cap, director.ts:282/290). Over budget, the
-     * tool returns a JSON-string error tool output (NOT a throw — Constraint 3(a))
-     * so the LLM sees "you're out of renders — verify or commit" and stops looping.
-     * Read/mutate tools (`apply_composition`, `get_media_context`, …) are un-budgeted
-     * — only capture/verify cost COGS. Dedup (`DEDUP_MAX`) + `stepCountIs` stay in
-     * `agent.ts`, external to tool-building (Constraint 3(d)).
-     */
     budgets?: {
         captures: number;
         verifies: number;
         styleViews: number;
     };
-    /**
-     * The brand kit bound to this project (T3, brand-kit-from-inspiration). When
-     * present, `view_style_reference` presigns THIS kit's inspiration exemplar
-     * frames so the maker SEES the reference pixels; absent ⇒ the tool returns a
-     * `{note}` (no kit, no style reference) rather than an error — the kit is
-     * optional, so its absence is not a failure.
-     */
     brandKitId?: string;
-    /**
-     * Async-job poll knobs for the tools whose API op ENQUEUES a job
-     * (`verify_composition`, `preview_component`). The curated tool blocks until
-     * the job is terminal and returns the RESULT — the author/designer tool set
-     * has no `wait_job`, so a receipt-shaped tool output is a verdict the LLM can
-     * never read (the 2026-07-07 prod LBO run verified into the void exactly this
-     * way). Injectable for tests.
-     */
     jobPoll?: {
         pollMs?: number;
         timeoutMs?: number;
         sleep?: (ms: number) => Promise<void>;
     };
 }
-/**
- * Build an `ai` `ToolSet` from the curated SSOT, filtered to the caller's
- * `allowedNames`. Uses the REAL generated manifest (via opById) so a
- * missing/renamed operationId fails loud — that is the drift signal.
- */
 export declare function buildCuratedToolSet(ex: Executor, opts: CuratedToolSetOpts): ToolSet;

package/dist/_members/mcp/burnedNames.d.ts

@@ -1,22 +1,6 @@
-/**
- * Burned tool names (amendment A12, plan 2026-07-10-flow-verbs) — names that
- * DIED in the verb cutover and may NEVER be reused for a different job: a
- * reused name is a silent behavior change for every old caller.
- *
- * Each burned name registers as a TOMBSTONE tool: calling it hard-errors with
- * the replacement (an agent with a stale memory of the surface gets taught,
- * not a bare method-not-found), and the tools/list entry itself documents the
- * cutover. The gate in curation.test.ts ("burned names stay dead") asserts no
- * curated/infrastructure tool ever takes a burned name back, that the
- * internal-loop overlap stays exactly the documented four, and that every
- * tombstone's replacement is a live tool.
- */
 export interface BurnedName {
-    /** The dead tool name. */
     name: string;
-    /** What to call instead (a live tool name, or a short instruction). */
     replacement: string;
-    /** One line of why — shown in the tombstone error. */
     reason: string;
 }
 export declare const BURNED_NAMES: readonly BurnedName[];

package/dist/_members/mcp/core.d.ts

@@ -1,32 +1,12 @@
-/**
- * Transport-agnostic primitives shared by every MCP layer (raw tools, curated
- * tools, resources, wait_job) and BOTH transports (stdio + hosted). The only
- * thing that varies between transports is the `Executor` — how a tool's HTTP
- * call is actually performed:
- *
- *   - stdio  → network fetch against api.cueframe.ai with the env API key (single-tenant)
- *   - hosted → in-process app.fetch with the caller's forwarded auth (multi-tenant)
- *
- * Everything else (paths from the generated manifest, zod input schemas, result
- * formatting, error advice) is identical, so it lives here once.
- */
 import { z } from 'zod';
 import { ApiError } from '@cueframe/sdk';
 import { type GeneratedOperation } from './generated/operations.js';
-/** The one seam between transports: perform an HTTP call, return status + body text. */
 export interface Executor {
     invoke(req: {
         method: string;
         path: string;
         body?: unknown;
-        /** Query string (without leading `?`), for ops that take query params. */
         query?: string;
-        /**
-         * base64 `PAYMENT-SIGNATURE` for a paid tool call over x402. Forwarded onto
-         * the underlying request so the REST x402 middleware verifies + settles it
-         * (mints `x402:<payer>`) — the SAME money path as a direct REST call. Absent
-         * for key/OAuth-authed calls.
-         */
         payment?: string;
     }): Promise<{
         status: number;
@@ -34,7 +14,6 @@ export interface Executor {
         requestId?: string;
     }>;
 }
-/** MCP content blocks we emit. The protocol also defines `resource`; add when used. */
 export type TextBlock = {
     type: 'text';
     text: string;
@@ -53,34 +32,13 @@ export type ContentBlock = TextBlock | ImageBlock | AudioBlock;
 export type ToolResult = {
     content: ContentBlock[];
     isError?: boolean;
-    /** x402 payment-required envelope (PaymentRequired) — read by the @x402/mcp client. */
     structuredContent?: Record<string, unknown>;
 };
 export declare function text(s: string): ToolResult;
 export declare function errText(s: string): ToolResult;
-/**
- * The JSON payload of a tool result. Since `content` gained image/audio blocks,
- * callers can no longer assume `content[0].text` — but every result still leads
- * with its text block (see `withMedia`), so this is the stable accessor.
- */
 export declare function firstText(r: ToolResult): string;
 export declare function sniffImageMediaType(base64: string): string;
-/** Sniff an audio media type from magic bytes; unknown ⇒ mpeg (Freesound previews are mp3). */
 export declare function sniffAudioMediaType(base64: string): string;
-/**
- * A tool result that carries the JSON payload as text AND the pixels/samples the
- * agent needs to judge it.
- *
- * THE CONTRACT, and why it is shaped this way:
- *  - Media is ADDITIVE. The JSON text block is always first and unchanged, so ids,
- *    urls and flags keep flowing and nothing downstream breaks.
- *  - Zero media ⇒ NO media blocks at all, just the text. An empty content array is
- *    the one failure the old `(b) images never leave execute() content-shaped`
- *    constraint was written to avoid (adapter.ts:384-390) — the fix for "empty
- *    array is invalid" is to omit the block, not to convert every image to text
- *    forever.
- *  - Media types are SNIFFED per item, never declared by the caller.
- */
 export declare function withMedia(payload: string, media: {
     data: string;
     kind: 'image' | 'audio';
@@ -89,33 +47,16 @@ export declare function fetchAsBase64(url: string, opts?: {
     timeoutMs?: number;
     maxBytes?: number;
 }): Promise<string | undefined>;
-/** Test seam — the cache is module-level and outlives a single test. */
 export declare function __resetPreviewCache(): void;
-/**
- * Fetch up to `cap` previews, preserving input order and dropping failures.
- *
- * Bounded by BOTH a count and a cumulative byte budget: the count keeps the
- * contact sheet legible, the bytes keep the response inside Convex's 20MB
- * httpAction ceiling. Sequential rather than parallel because the budget has to
- * be spent in order — a parallel batch cannot know it has already overspent.
- */
 export declare function fetchPreviews(urls: (string | undefined)[], cap?: number, opts?: {
     timeoutMs?: number;
     maxBytes?: number;
-    /**
-     * Injected fetcher (adapter test seam / caller-owned transport). Bypasses
-     * the module cache both ways — an injected fetcher's bytes must not read
-     * from or leak into another caller's cache. Failures (undefined or throw)
-     * drop that url, matching fetchAsBase64's contract.
-     */
     fetchOne?: (url: string) => Promise<string | undefined>;
 }): Promise<string[]>;
-/** MCP tool-callback `extra` (2nd arg) — carries the per-call request `_meta`. */
 export type ToolExtra = {
     _meta?: Record<string, unknown>;
 } | undefined;
 export declare function fmtErr(err: unknown): string;
-/** Reconstruct an ApiError from a non-2xx executor response so adviseError works. */
 export declare function apiErrorFrom(res: {
     status: number;
     text: string;
@@ -123,35 +64,14 @@ export declare function apiErrorFrom(res: {
 }): ApiError;
 export declare function isOk(status: number): boolean;
 export declare function safeParse(textBody: string): unknown;
-/** Look up a generated operation by id; throws (fail-loud) if absent. */
 export declare function opById(operationId: string): GeneratedOperation;
-/** The bound zod body schema for an operation, or undefined for body-less ops. */
 export declare function bodySchemaFor(op: GeneratedOperation): z.ZodTypeAny | undefined;
-/**
- * Substitute path params into an op's template. `mapArg(opParamName)` returns the
- * concrete value (raw layer: the arg of the same name; curated layer: the friendly
- * arg mapped to this op param). Values are URL-encoded.
- */
 export declare function buildPath(op: GeneratedOperation, mapArg: (opParam: string) => unknown): string;
-/** Run an operation through the executor. `body` is sent only for bodied ops. */
-export declare function invokeOp(ex: Executor, op: GeneratedOperation, mapArg: (opParam: string) => unknown, body: unknown, 
-/** base64 PAYMENT-SIGNATURE for a paid (x402) tool call; omitted for authed calls. */
-payment?: string, 
-/** Pre-encoded query string (no leading '?') — curated queryArgs filters. */
-query?: string): Promise<{
+export declare function invokeOp(ex: Executor, op: GeneratedOperation, mapArg: (opParam: string) => unknown, body: unknown, payment?: string, query?: string): Promise<{
     status: number;
     text: string;
     requestId?: string;
 }>;
-/**
- * Run an op through the executor with x402 pay-per-call support (used by every
- * tool). Reads the client's signed payment from the tool call `_meta`, forwards
- * it as `PAYMENT-SIGNATURE` so the REST x402 middleware verifies + settles (the
- * SAME money path as a direct REST call), turns an inner 402 into a
- * payment-required result, and attaches the settle receipt on success.
- * `formatOk` builds the success result from the executor response; `label` names
- * the tool for the error message. Payment-free (key/OAuth) calls are unaffected.
- */
 export declare function dispatchOp(ex: Executor, op: GeneratedOperation, mapArg: (opParam: string) => unknown, body: unknown, extra: ToolExtra, label: string, formatOk: (res: {
     status: number;
     text: string;

package/dist/_members/mcp/curation.d.ts

@@ -2,154 +2,42 @@ export interface CuratedTool {
     name: string;
     operationId: string;
     description: string;
-    /** friendly input arg name → op path-param name (e.g. { projectId: 'id' }). */
     pathArgs?: Record<string, string>;
-    /** Optional query-string filters: arg name → one-line teaching description.
-     *  The arg name IS the query-param name; the adapter exposes each as an
-     *  optional string input and threads provided values onto the request URL.
-     *  Without this, a description teaching a filter the curated layer can't
-     *  pass returns the UNFILTERED page silently (end review 2026-07-10). */
     queryArgs?: Record<string, string>;
-    /** Format a successful JSON body. Defaults to pretty JSON. */
     okFormat?: (json: any, args: Record<string, any>) => string;
-    /** Fixed success text (204 / body-less). Takes precedence over okFormat. */
     okText?: (args: Record<string, any>) => string;
-    /**
-     * Human-facing title. Defaults to Title Case of `name` (`create_render` →
-     * "Create Render"); set explicitly only where that reads badly (`wait_job` →
-     * "Wait for Job"). Required by the Anthropic connectors and OpenAI plugin
-     * reviews — an untitled tool is flagged.
-     */
     title?: string;
-    /**
-     * MCP tool annotations — client-side hints (Langfuse pattern).
-     *
-     * OPTIONAL BECAUSE IT OVERRIDES, NOT BECAUSE IT MAY BE ABSENT: when unset,
-     * server.ts falls back to the underlying operation's method-derived
-     * annotations from the generated manifest. Set a value here only where the
-     * curated semantics differ from the HTTP verb — this file stays the semantic
-     * SSOT (only `delete_*` is destructive; `cancel_*` is idempotent, not
-     * destructive), and the generator mirrors that reasoning.
-     */
     annotations?: {
         readOnlyHint?: boolean;
         destructiveHint?: boolean;
         idempotentHint?: boolean;
         openWorldHint?: boolean;
     };
-    /**
-     * Worked input examples (K4, e2e 2026-07-17) — serialized as Anthropic
-     * `input_examples` (the AI SDK core Tool field; the provider adds the
-     * advanced-tool-use beta itself). Use to teach CADENCE the schema can't:
-     * patch-style edits over full re-emissions, batched inspection timestamps.
-     */
     inputExamples?: Array<{
         input: Record<string, unknown>;
     }>;
-    /**
-     * Maturity VISIBILITY mirror (spec 2026-07-20-client-lane-v1-launch §2.0).
-     * Execution gating is server-side (the server capability registry — the
-     * SSOT; this npm-shipped package can go stale, so it only controls listing):
-     * 'expert' hides the tool from the public listing unless the expert layer is
-     * on. Default 'stable'. Drift-gated against the server map in
-     * the backend's capabilities drift test.
-     */
     maturity?: 'stable' | 'expert';
-    /**
-     * Preview media to attach to a successful result, so the agent can SEE (or
-     * HEAR) what it is being asked to judge.
-     *
-     * The MCP surface used to convert every image to text at the boundary, so an
-     * external agent picked stock from resolution/duration/author and never saw
-     * its own previews. `urls` pulls the preview links out of the SAME JSON the
-     * text block already carries — media is purely ADDITIVE, the JSON is
-     * unchanged, and zero usable urls emits NO media block (see `withMedia`).
-     *
-     * `cap` is a TOKEN budget, not a correctness one: a contact sheet of a dozen
-     * thumbnails is the difference between an agent that can see and one that
-     * spends its whole context on a single full-size still.
-     */
     preview?: {
         urls: (json: any) => (string | undefined)[];
-        /** Static kind, or derived from the body (stock sfx returns audio). */
         kind?: 'image' | 'audio' | ((json: any) => 'image' | 'audio');
         cap?: number;
-        /**
-         * Gate on the RESPONSE: attach media only when it buys a decision.
-         * Defaults to always (a `preview_frame` still IS the answer).
-         *
-         * `search_resources` sets this because the measured default was pure waste:
-         * one session shipped 68 previews (~9.24 MB, 99.76% of the tool's bytes) of
-         * which 62 came from `limit:1` calls — a picture attached to a search that
-         * returned ONE candidate decorates a decision already made. Worse, nobody
-         * saw them: base64 blocks enter the MODEL's context, and the CLI host does
-         * not render images, so the human's first sight of any frame was the
-         * finished 3:17 render. The URL is in the text payload either way.
-         */
         attach?: (json: any) => boolean;
     };
 }
-/** Per-resource CRUD coverage. A verb is a curated tool name, or null = gap. */
 export interface ResourceCrud {
     resource: string;
     create?: string[] | null;
     read?: string[] | null;
     update?: string | null;
     delete?: string | null;
-    /** Justify any null/omitted verb so the coverage test passes knowingly. */
     notes?: Record<string, string>;
 }
 export declare function formatMediaList(json: any): string;
 export declare function formatComponentList(json: any): string;
 export declare function formatResourceCandidates(json: any): string;
-/**
- * Render a composition for reading. Verbatim JSON while it fits — that is the
- * documented contract (it is what you hand to validate_composition) — and a
- * STRUCTURAL SUMMARY when the full body would exceed what the host will accept.
- * Every clip is still listed; only the unbounded blobs (card html, caption
- * words) are elided, and the header says so explicitly. Degrading loudly beats
- * returning nothing, and beats a silent truncation that reads like the whole
- * composition.
- */
 export declare function formatComposition(json: any): string;
-/**
- * The `warnings[]` advisory channel, rendered for the reader. One idiom across
- * every verb that carries it (create_render, apply_composition) so an agent
- * learns to look for `⚠` exactly once.
- */
 export declare function formatWarnings(json: any): string;
 export declare const CURATED_TOOLS: CuratedTool[];
-/**
- * THE editor allowlist — the ONE tool vocabulary an editing agent speaks,
- * whichever side of the Executor seam it runs on (the Convex editor agent over
- * the platform executor; the desktop agent over the local one). Passed as
- * `buildCuratedToolSet(executor, { allowedNames: INTERNAL_EDITOR_TOOLS })`, so
- * every name here MUST resolve in `[...INTERNAL_LOOP_TOOLS, ...CURATED_TOOLS]` —
- * the builder SILENTLY SKIPS an unknown name (adapter.ts), which is how a
- * renamed tool becomes a quietly missing capability. curation.test.ts gates the
- * subset relation; the web editor agent re-checks at module
- * load so the failure is loud at boot, not at the turn that needed the tool.
- *
- * INTERNAL, as in "not the hosted MCP server's list": three of these
- * (`get_context`, `search_library`, `analyze_transcript`) live in
- * INTERNAL_LOOP_TOOLS precisely so they stay OFF that server, and `wait_job` is
- * registered there by its own procedure. Membership here is NOT publication.
- */
 export declare const INTERNAL_EDITOR_TOOLS: readonly string[];
-/**
- * Resources whose CRUD is INTENTIONALLY incomplete because the backend op does
- * not exist yet. The coverage gate treats `${resource}.${verb}` keys here as a
- * documented absence — but `known backend gaps are real` in curation.test.ts
- * also asserts no generated op exists for them, so a gap CANNOT silently linger
- * after a backend route ships: the day the op appears, curate it and DELETE the
- * key. These are follow-up specs, not permanent design.
- */
 export declare const KNOWN_BACKEND_GAPS: Set<string>;
-/**
- * Per-resource CRUD coverage map — completeness as an invariant. The coverage
- * tests in curation.test.ts gate this: every referenced tool must be a real
- * CURATED_TOOLS name, and every absent verb must be either curated, justified
- * in `notes`, or a KNOWN_BACKEND_GAPS entry. It fails loud the day a curated
- * tool references a renamed op or a new resource verb lands unjustified.
- */
 export declare const CRUD_COVERAGE: ResourceCrud[];

package/dist/_members/mcp/executor.d.ts

@@ -1,60 +1,11 @@
-/**
- * Network `Executor` factory + the public API base-URL table.
- *
- * Extracted from ./index.ts so it is importable WITHOUT triggering the stdio
- * boot: ./index.ts runs `await main()` at module top-level (outside VITEST), so
- * importing the barrel from a long-running service (e.g. the Director worker,
- * Subsystem 3) would try to open a StdioServerTransport. This module carries
- * only the pure factory + the URL table, so the Director imports it (and the
- * `./adapter` / `./core` subpaths) with no boot side effect. ./index.ts
- * re-exports `makeNetworkExecutor` so the stdio entry API is unchanged.
- */
 import { type Executor } from './core.js';
-/** Public API hosts by target. `baseUrl` carries no `/v1` — paths are `/v1/…`-prefixed. */
 export declare const API_URLS: Record<string, string>;
-/**
- * Network executor: one bearer token, one base URL (single-tenant). `baseUrl`
- * carries no `/v1` — the manifest pathTemplate is `/v1/…`-prefixed, so
- * `baseUrl + path` is the correct single-`/v1` URL.
- */
 export declare function makeNetworkExecutor(baseUrl: string, apiKey: string): Executor;
-/**
- * Platform executor: CueFrame's OWN internal services (the Director) drive the
- * public /v1 tools as the PLATFORM — the deploy key + an explicit target org —
- * instead of a per-client `Bearer <apiKey>`. One privileged identity, org as a
- * per-call header (`x-org-id`); the `/v1` auth middleware verifies the deploy key
- * server-side (timing-safe) and treats these as internal (billing/rate-limit
- * skipped). No per-run credential lifecycle — the run builds this in one line.
- */
-/**
- * Session executor — the EDITOR clients' transport (unified-surface spec's
- * cloud leg): web + signed-in desktop drive /v1 with the Better Auth SESSION
- * as Bearer (the same credential class `cueframe login` uses; billed like any
- * customer identity). No API key, no deploy key, nothing stored beyond the
- * session the client already holds.
- *
- * Contracts:
- *  - OFFLINE-ABSENCE: a null token yields a synthetic
- *    `{status:0, error.code:"offline"}` WITHOUT a network round-trip —
- *    consumers render cloud capabilities as ABSENT, never as error stubs.
- *  - Idempotency: mutations carry the same content-derived key as the
- *    platform executor, so a retried mutation dedups instead of repeating.
- *  - X-Client-Version: every request states its build, so requestLog can
- *    answer "who breaks if this changes" before /v1 evolves.
- *  - Retry: idempotent GETs retry ONCE on network failure; mutations never
- *    auto-retry (the key makes a caller-driven retry safe).
- */
 export declare function makeSessionExecutor(opts: {
     baseUrl: string;
     getToken: () => Promise<string | null>;
     clientVersion: string;
 }): Executor;
 export declare function makePlatformExecutor(baseUrl: string, deployKey: string, orgId: string, opts?: {
-    /**
-     * Bill this traffic to the org AS this user (X-Acting-User-Id →
-     * auth.delegated). Set by user-facing agent surfaces (editor/clips chat);
-     * omitted by internal execution (Director in-loop — already paid at the
-     * compose terminal).
-     */
     actingUserId?: string;
 }): Executor;

package/dist/_members/mcp/format.d.ts

@@ -1,7 +1 @@
-/**
- * Tiny shared formatting helpers, server-free so both server.ts and the
- * curation SSOT (curation.ts) can import them without a circular dependency
- * and without pulling in the MCP transport.
- */
-/** Format seconds as `M:SS` (e.g. 75 → "1:15"). */
 export declare function fmtClock(sec: number): string;

package/dist/_members/mcp/generated/catalogPreviews.d.ts

@@ -1,2 +1 @@
-/** Catalog primitive id → published poster still (https://cdn.cueframe.ai). */
 export declare const CATALOG_PREVIEWS: Record<string, string>;