@cueframe/kernel 0.1.1 → 0.1.2

package/dist/_members/director/domain/chat.d.ts

@@ -0,0 +1,357 @@
+import { z } from "zod";
+import { type Envelope } from "../../errors/index.js";
+export declare const ConversationId: z.ZodBranded<z.ZodString, "Id<conversation>">;
+export type ConversationId = z.infer<typeof ConversationId>;
+export declare const DirectorRunId: z.ZodBranded<z.ZodString, "Id<directorRun>">;
+export type DirectorRunId = z.infer<typeof DirectorRunId>;
+export declare const ProjectRef: z.ZodObject<{
+    id: z.ZodString;
+    home: z.ZodEnum<["local", "cloud"]>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    home: "local" | "cloud";
+}, {
+    id: string;
+    home: "local" | "cloud";
+}>;
+export type ProjectRef = z.infer<typeof ProjectRef>;
+export declare const DirectorTurnContext: z.ZodObject<{
+    location: z.ZodString;
+    project: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        home: z.ZodEnum<["local", "cloud"]>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        home: "local" | "cloud";
+    }, {
+        id: string;
+        home: "local" | "cloud";
+    }>>>;
+    selectedMediaIds: z.ZodDefault<z.ZodArray<z.ZodBranded<z.ZodString, "Id<media>">, "many">>;
+    fastMode: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    location: string;
+    project: {
+        id: string;
+        home: "local" | "cloud";
+    } | null;
+    selectedMediaIds: (string & z.BRAND<"Id<media>">)[];
+    fastMode: boolean;
+}, {
+    location: string;
+    project?: {
+        id: string;
+        home: "local" | "cloud";
+    } | null | undefined;
+    selectedMediaIds?: string[] | undefined;
+    fastMode?: boolean | undefined;
+}>;
+export type DirectorTurnContext = z.infer<typeof DirectorTurnContext>;
+export declare const DirectorTurnEnvelope: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    context: z.ZodObject<{
+        location: z.ZodString;
+        project: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            home: z.ZodEnum<["local", "cloud"]>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            home: "local" | "cloud";
+        }, {
+            id: string;
+            home: "local" | "cloud";
+        }>>>;
+        selectedMediaIds: z.ZodDefault<z.ZodArray<z.ZodBranded<z.ZodString, "Id<media>">, "many">>;
+        fastMode: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        location: string;
+        project: {
+            id: string;
+            home: "local" | "cloud";
+        } | null;
+        selectedMediaIds: (string & z.BRAND<"Id<media>">)[];
+        fastMode: boolean;
+    }, {
+        location: string;
+        project?: {
+            id: string;
+            home: "local" | "cloud";
+        } | null | undefined;
+        selectedMediaIds?: string[] | undefined;
+        fastMode?: boolean | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    context: {
+        location: string;
+        project: {
+            id: string;
+            home: "local" | "cloud";
+        } | null;
+        selectedMediaIds: (string & z.BRAND<"Id<media>">)[];
+        fastMode: boolean;
+    };
+}, {
+    version: 1;
+    context: {
+        location: string;
+        project?: {
+            id: string;
+            home: "local" | "cloud";
+        } | null | undefined;
+        selectedMediaIds?: string[] | undefined;
+        fastMode?: boolean | undefined;
+    };
+}>;
+export type DirectorTurnEnvelope = z.infer<typeof DirectorTurnEnvelope>;
+export declare const ChatErrorView: z.ZodObject<{
+    code: z.ZodString;
+    title: z.ZodString;
+    recovery: z.ZodOptional<z.ZodString>;
+    retryable: z.ZodBoolean;
+    source: z.ZodOptional<z.ZodEnum<["provider", "generation", "materialisation", "agent", "transport"]>>;
+    correlationId: z.ZodOptional<z.ZodString>;
+    details: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    title: string;
+    retryable: boolean;
+    recovery?: string | undefined;
+    source?: "provider" | "generation" | "materialisation" | "agent" | "transport" | undefined;
+    correlationId?: string | undefined;
+    details?: string | undefined;
+}, {
+    code: string;
+    title: string;
+    retryable: boolean;
+    recovery?: string | undefined;
+    source?: "provider" | "generation" | "materialisation" | "agent" | "transport" | undefined;
+    correlationId?: string | undefined;
+    details?: string | undefined;
+}>;
+export type ChatErrorView = z.infer<typeof ChatErrorView>;
+export declare function chatErrorViewFromEnvelope(envelope: Envelope, source?: ChatErrorView["source"]): ChatErrorView;
+export declare function chatErrorViewFromUnknown(error: unknown, source?: ChatErrorView["source"]): ChatErrorView;
+export declare const DirectorEvent: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"text-delta">;
+    text: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "text-delta";
+    text: string;
+}, {
+    type: "text-delta";
+    text: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"reasoning-delta">;
+    text: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "reasoning-delta";
+    text: string;
+}, {
+    type: "reasoning-delta";
+    text: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"phase">;
+    phase: z.ZodString;
+    detail: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "phase";
+    phase: string;
+    detail?: string | undefined;
+}, {
+    type: "phase";
+    phase: string;
+    detail?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"generation">;
+    artifact: z.ZodObject<{
+        artifactVersion: z.ZodLiteral<1>;
+        clientRequestId: z.ZodBranded<z.ZodString, "Id<generationRequest>">;
+        generationId: z.ZodBranded<z.ZodString, "Id<generation>">;
+        mediaId: z.ZodBranded<z.ZodString, "Id<media>">;
+        generationGroupId: z.ZodBranded<z.ZodString, "Id<generationGroup>">;
+        version: z.ZodNumber;
+        kind: z.ZodEnum<["image", "video", "audio"]>;
+        requestSummary: z.ZodString;
+        status: z.ZodEnum<["draft", "submitting", "queued", "generating", "provider_complete", "materialising", "processing", "ready", "cancelling", "cancelled", "failed"]>;
+        progress: z.ZodOptional<z.ZodNumber>;
+        placementReady: z.ZodDefault<z.ZodBoolean>;
+        parentMediaId: z.ZodOptional<z.ZodBranded<z.ZodString, "Id<media>">>;
+        estimateUsd: z.ZodOptional<z.ZodNumber>;
+        failure: z.ZodOptional<z.ZodObject<{
+            code: z.ZodString;
+            title: z.ZodString;
+            recovery: z.ZodOptional<z.ZodString>;
+            retryable: z.ZodBoolean;
+            correlationId: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            code: string;
+            title: string;
+            retryable: boolean;
+            recovery?: string | undefined;
+            correlationId?: string | undefined;
+        }, {
+            code: string;
+            title: string;
+            retryable: boolean;
+            recovery?: string | undefined;
+            correlationId?: string | undefined;
+        }>>;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        kind: "video" | "audio" | "image";
+        status: "generating" | "processing" | "cancelled" | "ready" | "failed" | "draft" | "submitting" | "queued" | "provider_complete" | "materialising" | "cancelling";
+        mediaId: string & z.BRAND<"Id<media>">;
+        createdAt: number;
+        updatedAt: number;
+        clientRequestId: string & z.BRAND<"Id<generationRequest>">;
+        generationGroupId: string & z.BRAND<"Id<generationGroup>">;
+        generationId: string & z.BRAND<"Id<generation>">;
+        version: number;
+        artifactVersion: 1;
+        requestSummary: string;
+        placementReady: boolean;
+        parentMediaId?: (string & z.BRAND<"Id<media>">) | undefined;
+        estimateUsd?: number | undefined;
+        progress?: number | undefined;
+        failure?: {
+            code: string;
+            title: string;
+            retryable: boolean;
+            recovery?: string | undefined;
+            correlationId?: string | undefined;
+        } | undefined;
+    }, {
+        kind: "video" | "audio" | "image";
+        status: "generating" | "processing" | "cancelled" | "ready" | "failed" | "draft" | "submitting" | "queued" | "provider_complete" | "materialising" | "cancelling";
+        mediaId: string;
+        createdAt: number;
+        updatedAt: number;
+        clientRequestId: string;
+        generationGroupId: string;
+        generationId: string;
+        version: number;
+        artifactVersion: 1;
+        requestSummary: string;
+        parentMediaId?: string | undefined;
+        estimateUsd?: number | undefined;
+        progress?: number | undefined;
+        placementReady?: boolean | undefined;
+        failure?: {
+            code: string;
+            title: string;
+            retryable: boolean;
+            recovery?: string | undefined;
+            correlationId?: string | undefined;
+        } | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "generation";
+    artifact: {
+        kind: "video" | "audio" | "image";
+        status: "generating" | "processing" | "cancelled" | "ready" | "failed" | "draft" | "submitting" | "queued" | "provider_complete" | "materialising" | "cancelling";
+        mediaId: string & z.BRAND<"Id<media>">;
+        createdAt: number;
+        updatedAt: number;
+        clientRequestId: string & z.BRAND<"Id<generationRequest>">;
+        generationGroupId: string & z.BRAND<"Id<generationGroup>">;
+        generationId: string & z.BRAND<"Id<generation>">;
+        version: number;
+        artifactVersion: 1;
+        requestSummary: string;
+        placementReady: boolean;
+        parentMediaId?: (string & z.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: "generation";
+    artifact: {
+        kind: "video" | "audio" | "image";
+        status: "generating" | "processing" | "cancelled" | "ready" | "failed" | "draft" | "submitting" | "queued" | "provider_complete" | "materialising" | "cancelling";
+        mediaId: string;
+        createdAt: number;
+        updatedAt: number;
+        clientRequestId: string;
+        generationGroupId: string;
+        generationId: string;
+        version: number;
+        artifactVersion: 1;
+        requestSummary: string;
+        parentMediaId?: string | undefined;
+        estimateUsd?: number | undefined;
+        progress?: number | undefined;
+        placementReady?: boolean | undefined;
+        failure?: {
+            code: string;
+            title: string;
+            retryable: boolean;
+            recovery?: string | undefined;
+            correlationId?: string | undefined;
+        } | undefined;
+    };
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        title: z.ZodString;
+        recovery: z.ZodOptional<z.ZodString>;
+        retryable: z.ZodBoolean;
+        source: z.ZodOptional<z.ZodEnum<["provider", "generation", "materialisation", "agent", "transport"]>>;
+        correlationId: z.ZodOptional<z.ZodString>;
+        details: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        title: string;
+        retryable: boolean;
+        recovery?: string | undefined;
+        source?: "provider" | "generation" | "materialisation" | "agent" | "transport" | undefined;
+        correlationId?: string | undefined;
+        details?: string | undefined;
+    }, {
+        code: string;
+        title: string;
+        retryable: boolean;
+        recovery?: string | undefined;
+        source?: "provider" | "generation" | "materialisation" | "agent" | "transport" | undefined;
+        correlationId?: string | undefined;
+        details?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    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: "error";
+    error: {
+        code: string;
+        title: string;
+        retryable: boolean;
+        recovery?: string | undefined;
+        source?: "provider" | "generation" | "materialisation" | "agent" | "transport" | undefined;
+        correlationId?: string | undefined;
+        details?: string | undefined;
+    };
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"finish">;
+}, "strip", z.ZodTypeAny, {
+    type: "finish";
+}, {
+    type: "finish";
+}>]>;
+export type DirectorEvent = z.infer<typeof DirectorEvent>;

package/dist/_members/director/domain/generation.d.ts

@@ -0,0 +1 @@
+export * from "../../media-model/generation.js";

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

@@ -0,0 +1,3 @@
+export * from "./generation.js";
+export * from "./chat.js";
+export * from "./ports.js";

package/dist/_members/director/domain/ports.d.ts

@@ -0,0 +1,32 @@
+import type { GenerationArtifact, GenerateMediaCommand, GenerationCapabilities, GenerationId, GenerationReceipt, MediaId } from "./generation.js";
+import type { DirectorEvent, DirectorTurnContext } from "./chat.js";
+export interface DirectorRuntimeRequest {
+    conversationId: string;
+    context: DirectorTurnContext;
+    messages: Array<{
+        role: "user" | "assistant" | "system";
+        content: string;
+    }>;
+}
+export interface DirectorRuntime {
+    run(request: DirectorRuntimeRequest, signal?: AbortSignal): AsyncIterable<DirectorEvent>;
+}
+export interface GenerationGateway {
+    capabilities(context: DirectorTurnContext): Promise<GenerationCapabilities>;
+    enqueue(command: GenerateMediaCommand, context: DirectorTurnContext): Promise<GenerationReceipt>;
+    resolveByClientRequestId(clientRequestId: string, context: DirectorTurnContext): Promise<GenerationReceipt | null>;
+    cancel(generationId: GenerationId, context: DirectorTurnContext): Promise<void>;
+    retryMaterialisation(mediaId: MediaId, context: DirectorTurnContext): Promise<void>;
+    subscribe(generationId: GenerationId, listener: (artifact: GenerationArtifact) => void): () => void;
+}
+export interface ConversationRecord<MESSAGE> {
+    id: string;
+    messages: MESSAGE[];
+    context: DirectorTurnContext;
+    updatedAt: number;
+}
+export interface ConversationRepository<MESSAGE> {
+    load(id: string, context: DirectorTurnContext): Promise<ConversationRecord<MESSAGE> | null>;
+    save(record: ConversationRecord<MESSAGE>): Promise<void>;
+    remove(id: string): Promise<void>;
+}

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

@@ -0,0 +1,2 @@
+export * from "./domain/index.js";
+export * from "./ai-sdk/index.js";

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;