@cueframe/kernel 0.1.1 → 0.1.2

package/dist/_members/animate/animations/Write.d.ts

@@ -1,35 +1,15 @@
 import React from 'react';
 interface WriteProps {
-    /** Text to reveal character-by-character */
     text: string;
-    /** Duration of the full reveal animation in frames (default: 60) */
     durationInFrames?: number;
-    /** Delay before writing starts (in frames) */
     delay?: number;
-    /** Easing function for each character's appearance (default: smooth) */
     easing?: (t: number) => number;
-    /** Text color */
     color?: string;
-    /** Font family */
     fontFamily?: string;
-    /** Font size */
     fontSize?: number | string;
-    /** Font weight */
     fontWeight?: number;
-    /** Letter spacing */
     letterSpacing?: number | string;
-    /** Additional text style */
     style?: React.CSSProperties;
 }
-/**
- * Text reveal animation — characters "write themselves into existence".
- *
- * Each character fades in and slides up with staggered timing, creating the
- * appearance of text being written. Uses Manim-quality smooth easing per character.
- *
- * Usage:
- *   <Write text="Hello World" durationInFrames={60} color="#fff" />
- *   <Write text="API Gateway" fontFamily={FONTS.bebasNeue} fontSize={64} />
- */
 export declare const Write: React.FC<WriteProps>;
 export {};

package/dist/_members/animate/composition/AnimationGroup.d.ts

@@ -1,32 +1,11 @@
 import React from 'react';
 interface AnimationGroupProps {
     children: React.ReactNode;
-    /**
-     * Per-child stagger delay in frames (default: 0 = simultaneous).
-     * Each successive child starts this many frames after the previous.
-     */
     stagger?: number;
-    /** Delay before the group starts animating (in frames) */
     delay?: number;
-    /** Duration each child animates for (in frames, default: 30) */
     durationInFrames?: number;
-    /** Easing function applied to each child's progress (default: smooth) */
     easing?: (t: number) => number;
-    /** Additional wrapper style */
     style?: React.CSSProperties;
 }
-/**
- * Parallel animation container with optional per-child stagger.
- *
- * All children animate simultaneously when stagger=0. With stagger > 0,
- * each child starts progressively later, creating a fan-out effect.
- *
- * Usage:
- *   <AnimationGroup stagger={5} durationInFrames={30}>
- *     <GrowFromCenter><Circle /></GrowFromCenter>
- *     <GrowFromCenter><Circle /></GrowFromCenter>
- *     <GrowFromCenter><Circle /></GrowFromCenter>
- *   </AnimationGroup>
- */
 export declare const AnimationGroup: React.FC<AnimationGroupProps>;
 export {};

package/dist/_members/animate/composition/LaggedStart.d.ts

@@ -1,33 +1,11 @@
 import React from 'react';
 interface LaggedStartProps {
     children: React.ReactNode;
-    /**
-     * Controls timing overlap between children.
-     * 0 = all simultaneous, 1 = fully sequential, 0.3 = sweet spot (Manim default).
-     */
     lagRatio?: number;
-    /** Total animation duration in frames (default: 60) */
     durationInFrames?: number;
-    /** Delay before the first child starts (in frames) */
     delay?: number;
-    /** Easing function applied to each child's progress (default: smooth) */
     easing?: (t: number) => number;
-    /** Additional wrapper style */
     style?: React.CSSProperties;
 }
-/**
- * Staggered cascade animation — children animate in sequence with configurable overlap.
- *
- * Each child's start frame = index * lagRatio * totalDuration.
- * lagRatio of 0.3 means each child starts when the previous is 30% through,
- * creating the characteristic Manim "lagged start" look.
- *
- * Usage:
- *   <LaggedStart lagRatio={0.3} durationInFrames={90}>
- *     <FadeIn><div>First</div></FadeIn>
- *     <FadeIn><div>Second</div></FadeIn>
- *     <FadeIn><div>Third</div></FadeIn>
- *   </LaggedStart>
- */
 export declare const LaggedStart: React.FC<LaggedStartProps>;
 export {};

package/dist/_members/animate/composition/Succession.d.ts

@@ -1,27 +1,10 @@
 import React from 'react';
 interface SuccessionProps {
     children: React.ReactNode;
-    /** Duration each child animates for (in frames, default: 30) */
     durationPerChild?: number;
-    /** Delay before the sequence starts (in frames) */
     delay?: number;
-    /** Easing function applied to each child's progress (default: smooth) */
     easing?: (t: number) => number;
-    /** Additional wrapper style */
     style?: React.CSSProperties;
 }
-/**
- * Sequential animation — each child waits for the previous to complete before starting.
- *
- * Unlike LaggedStart (overlap) or AnimationGroup (parallel), Succession is strictly
- * sequential: child 0 plays fully, then child 1, then child 2, etc.
- *
- * Usage:
- *   <Succession durationPerChild={30}>
- *     <FadeIn direction="left"><div>Step 1</div></FadeIn>
- *     <FadeIn direction="left"><div>Step 2</div></FadeIn>
- *     <FadeIn direction="left"><div>Step 3</div></FadeIn>
- *   </Succession>
- */
 export declare const Succession: React.FC<SuccessionProps>;
 export {};

package/dist/_members/animate/easing/rush.d.ts

@@ -1,16 +1,2 @@
-/**
- * Fast start, gradual arrival. Based on Manim's rush_into.
- * Useful for elements entering aggressively then settling.
- *
- * @param t - Progress value (0 to 1)
- * @param inflection - Controls curve steepness (default 10)
- */
 export declare function rushInto(t: number, inflection?: number): number;
-/**
- * Gradual start, fast arrival. Based on Manim's rush_from.
- * Useful for elements easing out then snapping to destination.
- *
- * @param t - Progress value (0 to 1)
- * @param inflection - Controls curve steepness (default 10)
- */
 export declare function rushFrom(t: number, inflection?: number): number;

package/dist/_members/animate/easing/smooth.d.ts

@@ -1,8 +1 @@
-/**
- * Manim's smooth easing — sigmoid curve with zero velocity at both endpoints.
- * Objects start from rest, accelerate smoothly, and arrive at rest.
- *
- * @param t - Progress value (0 to 1)
- * @param inflection - Controls the steepness of the curve (default 10)
- */
 export declare function smooth(t: number, inflection?: number): number;

package/dist/_members/animate/easing/smootherstep.d.ts

@@ -1,7 +1 @@
-/**
- * Ken Perlin's smootherstep — zero velocity AND zero acceleration at endpoints.
- * Even silkier than smooth(). The 6th-degree Hermite interpolation polynomial.
- *
- * @param t - Progress value (0 to 1)
- */
 export declare function smootherstep(t: number): number;

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

@@ -19,7 +19,5 @@ export { Graph } from './mobjects/Graph.js';
 export { DiGraph } from './mobjects/DiGraph.js';
 export { ThreeCanvas } from './three/ThreeCanvas.js';
 export { Box, Sphere, Cylinder, Cone, Torus, TorusKnot, Plane, Circle, Ring, Dodecahedron, Icosahedron, Octahedron, Tetrahedron, Capsule, Extrude, Lathe, Tube, Text, Text3D, Center, Float, Environment, ContactShadows, AccumulativeShadows, RandomizedLight, Lightformer, Stage, Sky, Stars, Sparkles, Cloud, Line, QuadraticBezierLine, CubicBezierLine, CatmullRomLine, MeshDistortMaterial, MeshWobbleMaterial, MeshReflectorMaterial, MeshTransmissionMaterial, Edges, Outlines, GradientTexture, RoundedBox, Billboard, Html, PivotControls, Grid, Backdrop, } from './three/drei.js';
-/** All animate endowments for sandbox injection. */
 export declare const sandboxScope: Record<string, unknown>;
-/** Animate scope names for validation and error messages. */
 export declare const sandboxScopeNames: string[];

package/dist/_members/animate/mobjects/Arrow.d.ts

@@ -1,41 +1,16 @@
 import React from 'react';
 interface ArrowProps {
-    /** Start point [x, y] */
     from: [number, number];
-    /** End point [x, y] */
     to: [number, number];
-    /** Stroke color */
     color?: string;
-    /** Stroke width (default: 2) */
     strokeWidth?: number;
-    /** Arrowhead size in pixels (default: 12) */
     tipSize?: number;
-    /** SVG width */
     width?: number | string;
-    /** SVG height */
     height?: number | string;
-    /** SVG viewBox */
     viewBox?: string;
-    /** Draw arrowhead at start too (default: false) */
     doubleEnded?: boolean;
-    /** Additional SVG style */
     style?: React.CSSProperties;
 }
-/**
- * Static SVG arrow between two points with triangular arrowhead.
- * A "mobject" — wrap in <Create>, <GrowFromCenter>, or <FadeIn> to animate.
- *
- * Usage:
- *   <Arrow from={[100, 300]} to={[500, 300]} color="#fff" />
- *
- *   <FadeIn durationInFrames={20}>
- *     <Arrow from={[100, 200]} to={[400, 200]} color={params.accentColor} />
- *   </FadeIn>
- */
 export declare const Arrow: React.FC<ArrowProps>;
-/**
- * Generate an SVG path string for an arrow line (without arrowhead).
- * Useful for animating with <Create> or <Transform>.
- */
 export declare function makeArrowPath(from: [number, number], to: [number, number]): string;
 export {};

package/dist/_members/animate/mobjects/BrandBox.d.ts

@@ -1,43 +1,18 @@
 import React from 'react';
 interface BrandBoxProps {
-    /** Label text displayed inside the box */
     label?: string;
-    /** Box background color */
     color?: string;
-    /** Box width in pixels (default: 160) */
     width?: number;
-    /** Box height in pixels (default: 80) */
     height?: number;
-    /** Border radius in pixels (default: 12) */
     borderRadius?: number;
-    /** Label font family */
     fontFamily?: string;
-    /** Label font size (default: 18) */
     fontSize?: number | string;
-    /** Label font weight (default: 600) */
     fontWeight?: number;
-    /** Label text color (default: '#fff') */
     textColor?: string;
-    /** Border style (default: none) */
     border?: string;
-    /** Box shadow */
     shadow?: string;
-    /** Children rendered inside the box (alternative to label) */
     children?: React.ReactNode;
-    /** Additional wrapper style */
     style?: React.CSSProperties;
 }
-/**
- * Rounded rectangle with centered label — a reusable "mobject" for diagrams.
- * Designed to be wrapped in animation components for entrance effects.
- *
- * Usage:
- *   <BrandBox label="API" color={params.accentColor} />
- *
- *   <GrowFromCenter>
- *     <BrandBox label="Server" color="#1a1a2e" border="2px solid #e94560"
- *       fontFamily={FONTS.bebasNeue} fontSize={24} />
- *   </GrowFromCenter>
- */
 export declare const BrandBox: React.FC<BrandBoxProps>;
 export {};

package/dist/_members/animate/mobjects/DiGraph.d.ts

@@ -1,21 +1,3 @@
 import React from 'react';
 import { Graph } from './Graph.js';
-/**
- * Directed graph — alias for <Graph directed />.
- * Renders edges with arrowheads to show direction.
- *
- * Usage:
- *   <DiGraph
- *     nodes={[
- *       { id: 'client', label: 'Client' },
- *       { id: 'api', label: 'API' },
- *       { id: 'db', label: 'DB' },
- *     ]}
- *     edges={[
- *       { source: 'client', target: 'api', label: 'REST' },
- *       { source: 'api', target: 'db', label: 'SQL' },
- *     ]}
- *     nodeColor={params.accentColor}
- *   />
- */
 export declare const DiGraph: React.FC<Omit<React.ComponentProps<typeof Graph>, 'directed'>>;

package/dist/_members/animate/mobjects/Graph.d.ts

@@ -3,7 +3,6 @@ interface GraphNode {
     id: string;
     label?: string;
     color?: string;
-    /** Fixed position override [x, y] — skips force layout for this node */
     position?: [number, number];
 }
 interface GraphEdge {
@@ -15,58 +14,21 @@ interface GraphEdge {
 interface GraphProps {
     nodes: GraphNode[];
     edges: GraphEdge[];
-    /** Whether edges are directed (arrows) or undirected (lines). Default: false */
     directed?: boolean;
-    /** SVG width */
     width?: number;
-    /** SVG height */
     height?: number;
-    /** Node circle radius (default: 24) */
     nodeRadius?: number;
-    /** Node default color */
     nodeColor?: string;
-    /** Edge default color */
     edgeColor?: string;
-    /** Edge stroke width (default: 2) */
     edgeWidth?: number;
-    /** Label font family */
     fontFamily?: string;
-    /** Label font size (default: 14) */
     fontSize?: number;
-    /** Label text color (default: '#fff') */
     textColor?: string;
-    /** D3 force strength — repulsion between nodes (default: -300) */
     chargeStrength?: number;
-    /** Staggered entrance animation duration in frames (default: 60) */
     durationInFrames?: number;
-    /** Delay before animation starts (in frames) */
     delay?: number;
-    /** Easing function (default: smooth) */
     easing?: (t: number) => number;
-    /** Additional SVG style */
     style?: React.CSSProperties;
 }
-/**
- * Force-directed graph visualization with animated entrance.
- *
- * Nodes appear with staggered scale-in, edges draw themselves.
- * Uses D3-force for layout, SVG for rendering.
- *
- * Usage:
- *   <Graph
- *     nodes={[
- *       { id: 'a', label: 'API' },
- *       { id: 'b', label: 'Gateway' },
- *       { id: 'c', label: 'DB' },
- *     ]}
- *     edges={[
- *       { source: 'a', target: 'b' },
- *       { source: 'b', target: 'c' },
- *     ]}
- *     directed
- *     nodeColor={params.accentColor}
- *     durationInFrames={60}
- *   />
- */
 export declare const Graph: React.FC<GraphProps>;
 export {};

package/dist/_members/animate/three/ThreeCanvas.d.ts

@@ -1,36 +1,13 @@
 import React from 'react';
 interface ThreeCanvasProps {
     children: React.ReactNode;
-    /** Canvas width in pixels (default: 1920) */
     width?: number;
-    /** Canvas height in pixels (default: 1080) */
     height?: number;
-    /** Camera field of view (default: 75) */
     fov?: number;
-    /** Camera near clipping plane */
     near?: number;
-    /** Camera far clipping plane */
     far?: number;
-    /** Camera position [x, y, z] (default: [0, 0, 5]) */
     cameraPosition?: [number, number, number];
-    /** Additional style for the canvas wrapper */
     style?: React.CSSProperties;
 }
-/**
- * Remotion-compatible Three.js canvas — handles frame-perfect 3D rendering.
- *
- * Wraps @remotion/three's ThreeCanvas with sensible defaults for
- * video production (1920x1080, perspective camera).
- *
- * Usage:
- *   <ThreeCanvas>
- *     <mesh rotation={[0, rotation, 0]}>
- *       <boxGeometry />
- *       <meshStandardMaterial color={params.accentColor} />
- *     </mesh>
- *     <ambientLight intensity={0.5} />
- *     <pointLight position={[10, 10, 10]} />
- *   </ThreeCanvas>
- */
 export declare const ThreeCanvas: React.FC<ThreeCanvasProps>;
 export {};

package/dist/_members/animate/three/drei.d.ts

@@ -1,10 +1,3 @@
-/**
- * Whitelisted @react-three/drei components for the AI sandbox.
- *
- * Only safe, commonly-needed helpers are exposed.
- * No controls (OrbitControls etc) — video is non-interactive.
- * No loaders that access filesystem (useGLTF, useFBX etc).
- */
 export { Box, Sphere, Cylinder, Cone, Torus, TorusKnot, Plane, Circle, Ring, Dodecahedron, Icosahedron, Octahedron, Tetrahedron, Capsule, Extrude, Lathe, Tube, } from '@react-three/drei';
 export { Text, Text3D } from '@react-three/drei';
 export { Center, Float, Environment, ContactShadows, AccumulativeShadows, RandomizedLight, Lightformer, Stage, Sky, Stars, Sparkles, Cloud, } from '@react-three/drei';

package/dist/_members/authoring/agent/buildTools.d.ts

@@ -1,54 +1,17 @@
-/**
- * Build an AI SDK ToolSet for the IN-PROCESS compose roles.
- *
- * This used to iterate `TOOL_SCHEMAS` — 81 hand-written tools that were the
- * desktop's private vocabulary. That registry is deleted; the source here is
- * `COMPOSE_ROLE_TOOLS` (tools/composeRoleTools.ts), the ten verbs the compose
- * PLANNER and MOTION roles need and which have no `/v1` equivalent. Every other
- * agent surface builds from the curated manifest via `buildCuratedToolSet`.
- *
- * Handles: scope filtering, dedup detection, progress events, approval
- * callbacks, and image content formatting.
- */
 import { type ToolSet } from 'ai';
 import type { OnProgressCallback, DirectorContext } from '../types.js';
 import type { AgentCapabilities } from '../capabilities.js';
 export interface BuildToolsParams {
-    /** Agent capabilities — handlers receive this directly. */
     capabilities: AgentCapabilities;
-    /** Additional tool handler options. */
     toolOptions?: Record<string, unknown>;
-    /** Pre-built context for get_context tool. */
     cachedContext?: DirectorContext;
-    /** Progress callback for tool-call / tool-result events. */
     onProgress: OnProgressCallback;
-    /** Tool names to include. If omitted, every in-process role tool is built. */
     allowedTools?: string[];
-    /** Tool names requiring user approval before execution. */
     approvalRequired?: Set<string>;
-    /** Callback to request user approval. */
     requestApproval?: (toolCallId: string, toolName: string, args?: Record<string, unknown>) => Promise<boolean>;
 }
-/**
- * Build an AI SDK ToolSet from `COMPOSE_ROLE_TOOLS`.
- * Each tool wraps `dispatchComposeRoleTool` with dedup, progress, approval, and
- * image formatting.
- *
- * This is the shared generic loop-body every role-scoped factory funnels through
- * (`buildDirectorTools`, `buildPlannerTools`); logic lives here ONCE.
- */
 export declare function buildToolsFromSchemas(params: BuildToolsParams): ToolSet;
-/**
- * The generic full-set factory. The in-process roles (and the Agent swap-seam
- * fallback) build the whole in-process tool set through this.
- */
 export declare const buildDirectorTools: typeof buildToolsFromSchemas;
-/**
- * The compose PLANNER's minimal in-process factory: the SAME shared core, scoped
- * to `COMPOSE_PLANNER_TOOLS` (get_context, get_word_timings, search_library,
- * capture_frames, submit_compose_plan). The role owns the tool SCOPE; zero logic
- * is duplicated. `allowedTools` is fixed here, so callers pass everything else.
- */
 export declare const buildPlannerTools: (p: Omit<BuildToolsParams, "allowedTools"> & {
     toolNames?: readonly string[];
 }) => ToolSet;

package/dist/_members/authoring/agent/contextManagement.d.ts

@@ -1,73 +1,8 @@
-/**
- * Context-management for the tool loop — the seam that keeps a long, tool-heavy
- * agent run under the model's context window.
- *
- * The ONLY ai@6 hook that can rewrite the messages sent to the model between
- * steps is `prepareStep` (a ToolLoopAgent constructor option). `onStepFinish`
- * is observe-only; per-tool wrappers can't see cross-step history. So eviction
- * lives here, as a `prepareStep` built from a per-scope policy.
- *
- * The growth this caps (measured on the live compose author): ~197k of
- * accumulating tool-result content — get_context / search_library /
- * get_word_timings results, and (once the craftsman captures) base64 image
- * blocks — none of which ever leave the conversation across the up-to-20 steps
- * of one generate() call. `pruneMessages` is the SDK's pairing-safe primitive:
- * `before-last-N-messages` strips OLD tool-call/result content while keeping
- * tool_use/tool_result pairing intact and the recent N messages whole. It only
- * rewrites the OLD tail, so the stable system/instruction prefix (where the
- * Anthropic ephemeral cache breakpoint lives) is untouched and keeps hitting.
- */
 import { type PrepareStepFunction, type ToolSet } from 'ai';
 export interface ContextManagementPolicy {
-    /**
-     * Keep this many trailing messages' tool content intact; strip tool
-     * calls/results (incl. base64 image blocks) older than that. Clamped to >= 1
-     * (keepRecentToolMessages=0 maps to 'all', which can strip a still-pending
-     * tool call). Default 2 — one beat of lookback for the craftsman's
-     * capture→refine→re-capture loop.
-     */
     keepRecentToolMessages?: number;
-    /**
-     * RETIRED — reasoning pruning is FORCED ON (before-last-message) whenever
-     * this prepareStep runs; the field is kept only so existing policy literals
-     * typecheck. Why not optional: adaptive-thinking models (claude-sonnet-5+)
-     * attach SIGNED thinking blocks to tool-use turns, and Anthropic rejects a
-     * request whose history keeps a thinking block on an assistant message whose
-     * tool_use we pruned ("`thinking` blocks ... cannot be modified",
-     * invalid_request_error). That half-prune killed every claude-sonnet-5
-     * planner run at step 3 — the loop's first eviction with keep=2 (2026-07-12).
-     * Dropping the WHOLE thinking block from an older turn is allowed; the
-     * latest assistant message's thinking is never touched (before-last-message).
-     */
     pruneReasoning?: boolean;
-    /**
-     * Evict only IMAGE payloads from old tool results; keep compact TEXT results
-     * (get_context / word timings / apply receipts) for the whole run.
-     *
-     * Why: positional whole-result eviction gave the agent AMNESIA — the planner
-     * re-issued near-identical get_context/capture_frames recon up to 20 steps
-     * and never planned (staging compose v17555bj…, 2026-07-14: both "stalled"
-     * tries were this loop; the designer's ghost clip.remove thrash was the same
-     * disease). The context cost worth capping is the base64 stills (~10k+ tok
-     * each); the text results the model needs to REMEMBER are a few hundred
-     * tokens. So: image parts older than the keep window are replaced with a
-     * one-line stub; text results survive; tool_use/tool_result pairing is
-     * untouched (no thinking-block 400s — nothing structural is removed).
-     */
     evictImagesOnly?: boolean;
-    /**
-     * Tool names whose results are NEVER evicted — not even image payloads (K3,
-     * e2e 2026-07-17): the designer's style reference (view_style_reference) was
-     * evicted like any working capture, so the agent re-viewed it 3× in a row.
-     * The reference is the GROUND TRUTH being reproduced, not a disposable
-     * capture. Pinning trades bounded context growth (a few exemplar images) for
-     * zero re-view turns; capture_frames / render_frame stills still evict.
-     */
     pinnedTools?: string[];
 }
-/**
- * Build the `prepareStep` that evicts stale tool content each step. Pure
- * function of the messages it is handed (the override is per-step and not
- * persisted into SDK history), so it is safe to recompute every step.
- */
 export declare function buildPrepareStep(policy: ContextManagementPolicy): PrepareStepFunction<ToolSet>;

package/dist/_members/authoring/agent/errors.d.ts

@@ -1,12 +1,3 @@
-/**
- * Error extraction and usage utilities for the agent loop.
- * Extracted from agentLoop.ts — pure helpers, no loop logic.
- */
 import { type LanguageModelUsage } from 'ai';
-/**
- * Extract a clean error message from AI SDK / gateway errors.
- * Uses typed error classes from the AI SDK instead of regex matching.
- */
 export declare function extractProviderError(err: unknown): string;
-/** Empty usage for error/abort paths where the SDK doesn't return totalUsage. */
 export declare const ZERO_USAGE: LanguageModelUsage;

package/dist/_members/authoring/agent/memoryTool.d.ts

@@ -1,8 +1,6 @@
 import type { ToolSet } from 'ai';
 export interface AgentMemory {
-    /** The memory tool entry to merge into the agent's ToolSet (key `memory`). */
     tools: ToolSet;
-    /** The store after the run — thread this into the next run's seed. */
     snapshot(): Record<string, string>;
 }
 export declare function createAgentMemory(seed?: Record<string, string>): AgentMemory;

package/dist/_members/authoring/agent/promptCache.d.ts

@@ -1,34 +1,3 @@
-/**
- * Moving prompt-cache breakpoint for the tool loop — the AI SDK "dynamic
- * prompt caching" recipe (ai-sdk.dev/cookbook/node/dynamic-prompt-caching),
- * applied per step via `prepareStep`.
- *
- * Why: the static breakpoint on the system message only caches tools+system.
- * Anthropic writes cache entries ONLY at explicit breakpoints, and the
- * server-side continuation caching that happens to cover text tool-results
- * does NOT cover image blocks — measured on a capture_frames-shaped loop
- * (scripts/audit-cache-breakpoints.ts), every step re-paid full vision-token
- * price for ALL accumulated images (~1.2k tokens/image/step, growing
- * quadratically with step count). Stamping cacheControl on the LAST message
- * of each step's request makes the whole tail (incl. images) a cached prefix
- * the next step reads at 0.1x instead of re-paying at 1x.
- *
- * The stamp is a per-step request override: `prepareStep` results are not
- * persisted into SDK history, so markers don't accumulate across steps — each
- * request carries exactly two breakpoints (system + moving tail), well inside
- * Anthropic's 4-breakpoint limit.
- *
- * Two known limits:
- * - Do NOT compose with contextManagement eviction: the sliding prune window
- *   rewrites messages before the prior step's breakpoint, so tail entries are
- *   written (1.25x) but never read. Agent.executeWithTools gates on this.
- * - Anthropic's cache-hit lookback is 20 content blocks. Typical steps add
- *   2-4 blocks, but a burst step (e.g. parallel capture_frames calls, up to
- *   4 frames each) can exceed 20 — that one step's successor misses the tail
- *   entry and re-bills the accumulated history once before re-establishing.
- */
 import type { ModelMessage, PrepareStepFunction, ToolSet } from 'ai';
-/** Stamp cacheControl on the last message (the moving breakpoint). */
 export declare function addCacheControlToLastMessage(messages: ModelMessage[]): ModelMessage[];
-/** `prepareStep` that applies the moving breakpoint (Anthropic models only). */
 export declare const cachePrepareStep: PrepareStepFunction<ToolSet>;

package/dist/_members/authoring/agent.d.ts

@@ -1,31 +1,6 @@
-/**
- * Agent — the public API for @cueframe/authoring.
- *
- * One class, one run() method. Supports:
- * - Tool-based runs (with capabilities → tools)
- * - Text-generation runs (no capabilities → pure text)
- * - Optional criteria-based quality loop (evaluate → refine → retry)
- */
 import { type PrepareStepFunction, type ToolSet } from 'ai';
 import type { AgentConfig, AgentRunOptions, AgentRunResult } from './types.js';
-/**
- * RESERVE-VERIFY-STEP (P0.2): wrap a base `prepareStep` so the LAST budgeted
- * step exposes only `finalStepTools` (∩ the run's tool set). A mutation can
- * then never be the loop's unread final act — the last possible mutation lands
- * one step earlier and its result (or error) is READ on the reserved step.
- * Deterministic enforcement at the loop layer, not a prompt plea. Exported for
- * tests.
- */
 export declare function reserveFinalStep(base: PrepareStepFunction<ToolSet>, maxSteps: number, finalStepTools: readonly string[], toolNames: readonly string[]): PrepareStepFunction<ToolSet>;
-/**
- * B6: an INFRA-class tool failure (dead scratch/session — codes minted by
- * @cueframe/mcp's InfraToolError) is unfixable by the model: the AI SDK catches
- * the tool's throw into a `tool-error` step part and would render it back as
- * text, burning the step budget (prod dogfood: ×49 renders → design-lock).
- * Detect the sentinel STRUCTURALLY (name+infra flag — deliberately no import
- * edge to @cueframe/mcp, mirroring its structural guard) so the loop can halt
- * at that step and the run can rethrow the original error. Exported for tests.
- */
 export declare function infraErrorFromSteps(steps: ReadonlyArray<unknown>): Error | null;
 export declare class Agent {
     private config;
@@ -33,18 +8,9 @@ export declare class Agent {
     private messages;
     private excludedTools;
     private log;
-    /** Monotonic step index for onStepMetrics; reset per run(). */
     private stepCounter;
     constructor(config: AgentConfig);
-    /** Reset conversation history (new session). */
     reset(): void;
-    /**
-     * Run the agent with a prompt.
-     *
-     * Without criteria/rubric: single generation pass.
-     * With criteria + maxAttempts > 1: generate → evaluate → refine loop (criteria mode).
-     * With rubric + maxAttempts > 1: generate → evaluate → refine loop (rubric mode).
-     */
     run(prompt: string, opts?: AgentRunOptions): Promise<AgentRunResult>;
     private runWithCriteria;
     private runWithRubric;