@tryvitris/website-harness 0.0.0-stage → 0.1.0-beta.5

package/bin/types/src/agent/composition-authoring.d.ts

@@ -0,0 +1,12 @@
+export declare const COMPOSITION_LESSON_RELEASE = "2026-09-28.1";
+export type DesignAuthoringPolicy = {
+    mode: "blocks-v0";
+    lessonRelease: null;
+    hash: string;
+} | {
+    mode: "composition-v1";
+    lessonRelease: typeof COMPOSITION_LESSON_RELEASE;
+    hash: string;
+};
+/** Site-owned policy. A missing field is a deliberate compatibility default. */
+export declare function resolveDesignAuthoring(root: string): DesignAuthoringPolicy;

package/bin/types/src/agent/composition-context.d.ts

@@ -0,0 +1,63 @@
+import { type CompositionPack } from "../knowledge/composition.ts";
+export declare const COMPOSITION_SELECTOR_VERSION = "composition-selector-1";
+export type CompositionSignal = {
+    id: string;
+    state: "known" | "unknown" | "absent";
+    origin: string;
+};
+export type CompositionSelection = {
+    schemaVersion: 1;
+    selectorVersion: string;
+    stage: string;
+    page: string | null;
+    policyHash: string;
+    manifestHash: string;
+    inputSignalHash: string;
+    signals: CompositionSignal[];
+    eligible: {
+        id: string;
+        score: number;
+        reasons: string[];
+    }[];
+    excluded: {
+        id: string;
+        reason: string;
+    }[];
+    selected: {
+        id: string;
+        version: number;
+        contentHash: string;
+        bodyHash: string;
+        summary: string;
+        expansionHandle: string;
+        reason: string;
+    }[];
+    alternatives: {
+        id: string;
+        summary: string;
+        expansionHandle: string;
+    }[];
+    ties: {
+        score: number;
+        ids: string[];
+    }[];
+};
+/** A missing field stays unknown. We only assert absent media after an inspected inventory exists. */
+export declare function compositionSignalsFromSite(root: string, page?: string): CompositionSignal[];
+export declare function selectCompositionLessons(input: {
+    pack: CompositionPack;
+    stage: string;
+    page?: string;
+    signals: CompositionSignal[];
+    policyHash: string;
+    limit?: number;
+}): CompositionSelection;
+export declare function compositionContextForStage(root: string, stage: string, page?: string, limit?: number): {
+    policy: {
+        mode: "composition-v1";
+        lessonRelease: typeof import("./composition-authoring.ts").COMPOSITION_LESSON_RELEASE;
+        hash: string;
+    };
+    pack: CompositionPack;
+    receipt: CompositionSelection;
+} | undefined;

package/bin/types/src/agent/composition-contract.d.ts

@@ -0,0 +1,4 @@
+import type { Business, MediaInventory, Storyboard } from "./artifacts.ts";
+import type { CompositionPack } from "../knowledge/composition.ts";
+/** Structural and referential checks only. Rendered quality is judged separately. */
+export declare function validateCompositionStoryboard(story: Storyboard, pack: CompositionPack, business: Business, media: MediaInventory): string[];

package/bin/types/src/agent/composition-decisions.d.ts

@@ -0,0 +1,43 @@
+import { type Storyboard } from "./artifacts.ts";
+export type AuthoringDecision = {
+    id: string;
+    route: string;
+    sectionIds: string[];
+    elementIds: string[];
+    intent: string;
+    lessonRefs: {
+        id: string;
+        version: number;
+        contentHash: string;
+    }[];
+    alternatives?: {
+        description: string;
+        tradeoff: string;
+    }[];
+    chosenApproach: string;
+    implementationPaths: string[];
+    reuse: {
+        kind: "site-component" | "kernel-behavior" | "block";
+        source: string;
+        sourceHash?: string;
+        adaptation: string;
+    }[];
+    inspectedExamples: {
+        id: string;
+        sourceHash: string;
+        captureHash: string;
+    }[];
+    observationIds: string[];
+};
+export type AuthoringDecisions = {
+    schemaVersion: 1;
+    authoringPolicy: {
+        mode: "composition-v1";
+        lessonRelease: string;
+        hash: string;
+    };
+    storyboardHash: string;
+    preparationId: string;
+    records: AuthoringDecision[];
+};
+export declare function validateAuthoringDecisions(root: string, story: Storyboard): string[];

package/bin/types/src/agent/composition-preflight.d.ts

@@ -0,0 +1,16 @@
+import type { Storyboard } from "./artifacts.ts";
+export type CompositionFinding = {
+    id: string;
+    route: string;
+    section: string;
+    evidence: string;
+    severity: "advisory" | "major";
+    problem: string;
+    repair: string;
+    owner: "agent";
+    kind: "useful-repetition" | "monotonous-stack" | "palette-only" | "obscured-action";
+};
+/** Deterministic reading of the storyboard. Palette words alone never clear a finding. */
+export declare function assessComposition(story: Storyboard): CompositionFinding[];
+export declare function formatCompositionAssistSummary(findings: CompositionFinding[]): string;
+export declare function paletteChangeResolves(previous: CompositionFinding[], next: CompositionFinding[]): boolean;

package/bin/types/src/agent/creative-change-context.d.ts

@@ -0,0 +1,21 @@
+import type { CreativeRevisionPlan } from "./creative-contract.ts";
+export type CreativeChangeContext = {
+    changedPaths: string[];
+    affectedRoutes: string[];
+    scope: "local" | "broad";
+    reason: string;
+    findings: string[];
+    acceptance: string[];
+    attemptedChanges: string[];
+    remainingRisks: string[];
+};
+/** Exact route mapping. Unknown or shared dependencies conservatively reach every route. */
+export declare function selectCreativeChangeContext(paths: string[], routes: string[], plan: CreativeRevisionPlan, findings?: unknown[], result?: {
+    changes?: {
+        target?: string;
+        change?: string;
+        acceptance?: string;
+    }[];
+    remainingRisks?: string[];
+}): CreativeChangeContext;
+export declare function acceptedCreativeChangeContext(child: string, runId: string, round: number, routes: string[], plan: CreativeRevisionPlan, findings: unknown[]): CreativeChangeContext | undefined;

package/bin/types/src/agent/creative-context.d.ts

@@ -0,0 +1,56 @@
+import type { GraphNode } from "./graph.ts";
+import type { EvidenceIndex } from "./creative-evidence.ts";
+import type { CreativeEfficiencyPolicy } from "./creative-efficiency.ts";
+import type { JevClient } from "./jev/client.ts";
+import { type CoverageManifest } from "./jev/packets.ts";
+import type { JevConfig } from "./jev/types.ts";
+import type { TrustedPilotContext } from "./jev/calibration.ts";
+export declare const CREATIVE_REPAIR_OBLIGATION = "Classify the located repair domain";
+export declare const CREATIVE_REPAIR_SEMANTICS_HASH: string;
+export type CreativePacketRole = "plan" | "study-review" | "decision" | "revision" | "final-review";
+export type CreativePacketInput = {
+    root: string;
+    kernel: string;
+    node: GraphNode;
+    role: CreativePacketRole;
+    objective: string;
+    candidateId?: string;
+    sourceRevision: string;
+    baseContract: string;
+    policy: CreativeEfficiencyPolicy;
+    config: JevConfig;
+    client?: JevClient;
+    evidence: EvidenceIndex;
+    retrievedIds: string[];
+    requiredEvidenceIds?: string[];
+    mandatorySkillIds: string[];
+    optionalSkillIds: string[];
+    constraints: string[];
+    obligations: string[];
+    findings: string[];
+    renderIds: string[];
+    priorOutcomes?: string[];
+    sourceChanges?: string[];
+    renderBindings?: {
+        id: string;
+        path: string;
+        viewport?: number;
+        route?: string;
+        state?: string;
+        subjectHash?: string;
+        receiptPath?: string;
+        current: boolean;
+        reason?: string;
+    }[];
+    softTargetBytes?: number;
+    pilotContext?: TrustedPilotContext;
+    budgetRoot?: string;
+};
+export type CreativePacketResult = {
+    prompt: string;
+    manifest: CoverageManifest & Record<string, unknown>;
+    receiptPaths: string[];
+    fallback?: string;
+};
+/** The same source-bound inventory feeds deterministic, shadow, and assist packets. */
+export declare function buildCreativeContextPacket(input: CreativePacketInput): Promise<CreativePacketResult>;

package/bin/types/src/agent/creative-contract.d.ts

@@ -0,0 +1,123 @@
+/** Site-local creative records. Validation deliberately rejects persuasive prose without evidence links. */
+export type CreativeSourceKind = "observed" | "operator" | "hypothesis" | "measured";
+export type CreativeLink = {
+    objective: string;
+    visitorTask: string;
+    evidenceIds: string[];
+    hypothesis: string;
+    observableOutcome: string;
+};
+export type CreativeBrief = {
+    schemaVersion: 1;
+    audience: string;
+    goal: string;
+    goalKind: "lead" | "discovery" | "trust" | "recruitment" | "self_service" | "information" | "other";
+    differentiator: string;
+    strongestProof: string;
+    mediaOpportunities: string[];
+    constraints: string[];
+    uncertainties: string[];
+    emotionalCharacter: string;
+    links: CreativeLink[];
+};
+export type CreativeCandidate = {
+    schemaVersion: 1;
+    id: string;
+    centralIdea: string;
+    experienceHypothesis: string;
+    hierarchy: string;
+    narrative: string;
+    composition: string;
+    imagery: string;
+    typography: string;
+    interaction: string;
+    evidenceIds: string[];
+    judgmentTask: string;
+    risks: string[];
+};
+export type CreativeFinding = {
+    schemaVersion: 1;
+    candidateId: string;
+    source: CreativeSourceKind;
+    page: string;
+    viewport: number;
+    state: string;
+    section: string;
+    observation: string;
+    hypothesis: string;
+    expectedImprovement: string;
+    evidenceIds: string[];
+};
+export type CreativeDecision = {
+    schemaVersion: 1;
+    selectedCandidateId: string;
+    candidateRevision: string;
+    observations: string[];
+    tradeoffs: string[];
+    counterarguments: string[];
+    identityInvariants: string[];
+    confidenceLimitations: string[];
+    rejectedCandidateIds: string[];
+    evidenceIds: string[];
+    action?: "select" | "revise" | "retire" | "challenge";
+    reason?: string;
+    revisionPlan?: CreativeRevisionPlan;
+    challengerCandidateId?: string;
+};
+export type CreativeRevisionPlan = {
+    objective: string;
+    findingIndexes: number[];
+    targets: string[];
+    skillIds: string[];
+    evidenceIds: string[];
+    acceptance: string[];
+};
+export type CreativeExperiment = {
+    schemaVersion: 1;
+    sourceHash: string;
+    profile: "creative-v1";
+    baseline: {
+        elapsedMs: number | null;
+        measuredTokens: number | null;
+        coverage: string;
+    };
+    limits: {
+        iterations: number;
+        durationMs: number;
+        tokens: number | null;
+    };
+    outcomes: {
+        technical: string;
+        factual: string;
+        visual: string;
+        distinctiveness: string;
+        businessFit: string;
+        visitorTask: string;
+        humanPreference: "unlabeled" | "labeled";
+    };
+};
+export declare function validateCreativeBrief(value: unknown): string[];
+export declare function validateCreativeCandidates(value: unknown, evidenceIds: Set<string>): string[];
+export declare function validateCreativeDecision(value: unknown, candidates: CreativeCandidate[], revisions: Record<string, string>, evidenceIds: Set<string>): string[];
+export declare function validateCreativeRevisionPlan(value: unknown, evidenceIds: Set<string>, findingCount?: number): string[];
+export type CreativeFinalAudit = {
+    schemaVersion: 1;
+    sourceRevision: string;
+    identity: {
+        invariant: string;
+        outcome: "preserved" | "adapted";
+        observation: string;
+        evidenceIds: string[];
+    }[];
+    journeys: {
+        task: string;
+        outcome: "observed" | "unverified";
+        observation: string;
+        evidenceIds: string[];
+    }[];
+    limitations: string[];
+    blockers: string[];
+    revisionPlan?: CreativeRevisionPlan;
+};
+export declare function validateCreativeFinalAudit(value: unknown, revision: string, invariants: string[], evidenceIds: Set<string>, visitorTasks?: string[]): string[];
+export declare function validateCreativeFindings(value: unknown, candidates: CreativeCandidate[], evidenceIds: Set<string>): string[];

package/bin/types/src/agent/creative-efficiency.d.ts

@@ -0,0 +1,18 @@
+import type { JevConfig } from "./jev/types.ts";
+export type CreativeEfficiencyPolicy = {
+    schemaVersion: 1;
+    enabled: boolean;
+    config: JevConfig;
+    endpointHash: string;
+    questionVersion: string;
+    policyVersion: string;
+    packetVersion: string;
+    policyHash: string;
+};
+export declare const CREATIVE_PACKET_VERSION = "creative-compact-2";
+export declare function createCreativeEfficiencyPolicy(root: string, argv: string[]): CreativeEfficiencyPolicy;
+export declare function readCreativeEfficiencyPolicy(root: string, runId: string, argv?: string[]): {
+    policy: CreativeEfficiencyPolicy;
+    config: JevConfig;
+};
+export declare function saveCreativeEfficiencyPolicy(root: string, runId: string, policy: CreativeEfficiencyPolicy): void;

package/bin/types/src/agent/creative-evidence.d.ts

@@ -0,0 +1,57 @@
+export type EvidenceNode = {
+    id: string;
+    kind: "source" | "fact" | "asset" | "visitor_need" | "hypothesis" | "candidate" | "finding" | "render" | "decision" | "section";
+    label: string;
+    sourcePath: string;
+    sourceHash: string;
+    excerpt?: string;
+    provenance: "customer" | "operator" | "derived" | "external_untrusted";
+    uncertainty?: string;
+};
+export type EvidenceEdge = {
+    from: string;
+    to: string;
+    relation: "supports" | "depicts" | "answers" | "expresses" | "implements" | "contradicts" | "supersedes" | "uses" | "evaluates";
+    sourcePath: string;
+    sourceHash: string;
+    uncertainty?: string;
+};
+export type EvidenceIndex = {
+    schemaVersion: 1;
+    inputHash: string;
+    nodes: EvidenceNode[];
+    edges: EvidenceEdge[];
+    unresolvedAliases: string[];
+};
+/** Rebuilds from authoritative site files. Direction: from subject to object, e.g. fact supports need. */
+export declare function buildEvidenceIndex(root: string, creativeRoot?: string): EvidenceIndex;
+export declare function writeEvidenceIndex(root: string, outputPath: string, creativeRoot?: string): EvidenceIndex;
+export declare function connectedEvidence(index: EvidenceIndex, id: string, depth?: number): {
+    nodes: EvidenceNode[];
+    edges: EvidenceEdge[];
+};
+/** Rank an objective's seeds and their bounded neighborhoods. Preserve provenance in the packet. */
+export declare function retrieveCreativeEvidence(index: EvidenceIndex, opts: {
+    query: string;
+    seedIds?: string[];
+    maxNodes?: number;
+    maxChars?: number;
+    depth?: number;
+}): {
+    nodes: EvidenceNode[];
+    omitted: number;
+    chars: number;
+    reasons: {
+        [k: string]: string;
+    };
+    edges: EvidenceEdge[];
+};
+export declare function proofForSection(index: EvidenceIndex, sectionId: string): EvidenceNode[];
+export declare function imagesForSection(index: EvidenceIndex, sectionId: string): EvidenceNode[];
+export declare function sectionsAffectedByDecision(index: EvidenceIndex, decisionId: string): EvidenceNode[];
+/** A storyboard answer is an intent; this flags answers without source-backed facts. */
+export declare function visitorQuestionsWithoutProof(index: EvidenceIndex): {
+    sectionId: string;
+    questionId: string;
+    question: string;
+}[];

package/bin/types/src/agent/creative-objective.d.ts

@@ -0,0 +1,33 @@
+import type { GraphNode } from "./graph.ts";
+import { type CompleteStageOptions } from "./lifecycle.ts";
+import type { JevConfig } from "./jev/types.ts";
+import type { JevClient } from "./jev/client.ts";
+export type CreativeObjectiveReceipt = {
+    preparationId: string;
+    node: GraphNode;
+    completed?: boolean;
+    acceptedHash?: string;
+};
+export declare function creativePacketCoverageFailures(root: string, nodeId: string): string[];
+/** Completion is established by a lifecycle receipt, never by the shape of files alone. */
+export declare function runCreativeObjective(opts: {
+    root: string;
+    kernel: string;
+    node: GraphNode;
+    prompt: string;
+    pendingPath?: string;
+    retry?: boolean;
+    beforePrepare?: () => void;
+    evaluate: () => {
+        failures: string[];
+    };
+    agentUsage?: CompleteStageOptions["agentUsage"];
+    usageReceiptPath?: string;
+    jevConfig?: JevConfig;
+    jevClient?: JevClient;
+    buildPacket?: () => Promise<string>;
+}): Promise<{
+    paused: boolean;
+    failures: string[];
+    preparationId?: string;
+}>;

package/bin/types/src/agent/creative-profile.d.ts

@@ -0,0 +1,81 @@
+import { type CreativeRevisionPlan } from "./creative-contract.ts";
+import { type JevAggregatedSpend } from "./jev/budget.ts";
+import type { JevTransport } from "./jev/types.ts";
+import type { TrustedPilotContext } from "./jev/calibration.ts";
+export type CreativePhase = "shared" | "planning" | "rendering" | "study_review" | "representative" | "selection" | "revision" | "expansion" | "final_review" | "complete" | "blocked";
+export type CreativeRun = {
+    schemaVersion: 1;
+    id: string;
+    phase: CreativePhase;
+    createdAt: string;
+    kernelHash: string;
+    inputHash: string;
+    parentSourceHash: string;
+    finalSourceHash?: string;
+    child?: string;
+    candidateId?: string;
+    candidateRevision?: string;
+    identityHash?: string;
+    expansionStarted?: boolean;
+    studyOrder: string[];
+    tried: string[];
+    spentIterations: number;
+    observedIterations?: Record<string, number>;
+    spentDurationMs?: number;
+    observedDurationMs?: Record<string, number>;
+    candidateCeilings?: Record<string, number>;
+    candidateOutcomes?: Record<string, {
+        status: "qualified" | "rejected";
+        reason: string;
+    }>;
+    limits: {
+        iterations: number;
+        durationMs: number;
+        tokens: number | null;
+    };
+    orchestratorVersion?: 2;
+    studyAssetsHash?: string;
+    reviewRound?: number;
+    finalReviewRound?: number;
+    revisionCount?: number;
+    challengeCount?: number;
+    qualified?: Record<string, {
+        root: string;
+        revision: string;
+    }>;
+    revision?: {
+        round: number;
+        beforeRevision: string;
+        plan: CreativeRevisionPlan;
+        returnTo?: "expansion";
+    };
+    spentTokens?: number;
+    observedTokens?: Record<string, number>;
+    hasUnknownUsage?: boolean;
+    renderDurationMs?: number;
+    jevBaseline?: JevAggregatedSpend;
+    jevSpend?: JevAggregatedSpend;
+    jevFallback?: string;
+    error?: string;
+    blockedFromPhase?: CreativePhase;
+    blockKind?: "tool" | "creative" | "budget";
+};
+export declare function createCreativeRun(root: string, kernel: string, argv: string[]): CreativeRun;
+export declare function creativeRunStatus(root: string, id?: string): CreativeRun | undefined;
+export declare function promoteCreativeRun(root: string, id: string): {
+    backup: string;
+    promotedSourceHash: string;
+};
+/** A read-only view; receipt totals are recomputed without altering the run manifest. */
+export declare function creativeRunStatusSnapshot(root: string, id?: string): Record<string, unknown> | undefined;
+export declare function assertCreativeBudget(run: CreativeRun, reserveIterations?: number): void;
+export declare function runCreativeProfile(root: string, kernel: string, argv: string[], opts?: {
+    jevFetch?: JevTransport;
+    pilotContext?: TrustedPilotContext;
+}): Promise<{
+    run: CreativeRun;
+    paused: boolean;
+    exitCode: number;
+    previewUrl?: string;
+    summary: string;
+}>;

package/bin/types/src/agent/creative-prompts.d.ts

@@ -0,0 +1,7 @@
+/** Design reasoning is staged inside the same active agent, without extra model calls. */
+export declare const CREATIVE_PLANNING_METHOD = "\nCreative exploration method:\n1. Identify the business tension: what the visitor needs to understand, believe or accomplish, what currently prevents it, and what this business can genuinely prove. Turn that into objective -> visitor task -> supported evidence -> experience hypothesis -> observable outcome. When proof is missing, design honestly around the gap.\n2. Start each concept from a different organizing idea grounded in that tension. Possibilities include an artifact-led explanation, guided decision, editorial narrative, spatial/product exploration or service process. These are prompts for invention, not templates or required styles. Explain why the idea belongs to this business.\n3. Make the concepts differ in information hierarchy, narrative and composition before choosing colors. Typography, imagery, crop, spacing, motion and interaction should reinforce each concept. A palette swap or a renamed split hero is insufficient. In sparse-media cases, expressive typography, diagrams of supported processes and useful content can supply character; invented customer proof cannot.\n4. Sketch both the homepage and one consequential interior at once. Use plausible final-length copy derived from approved facts and real assets. Show a primary action, a proof moment and a mobile treatment. Make the interior develop the idea instead of repeating the homepage hero.\n5. Ask the counterfactual: if the logo and business name changed, would the site still fit almost any competitor? Identify the business-specific content, composition or interaction that prevents this. Avoid visual novelty that hides navigation, reduces legibility or obstructs the visitor task.\n6. Before submitting, compare the concepts by central idea, visitor journey, proof structure, composition, imagery and mobile behavior. Check the actual studies for those differences. Preserve the alternatives for review; do not silently converge them to one preferred template.\nKeep exploration bounded. Build two inexpensive studies by default; use a third only for a materially different unresolved hypothesis. The production candidate is developed after pixel-based comparison.\n";
+export declare const CREATIVE_CRITIQUE_METHOD = "\nUse these reasoning passes sequentially in this active session; they are roles, not additional agents:\n- Visitor: attempt the brief's actual tasks from the rendered pages. Locate the offer, differentiation, relevant proof and next step. Note where effort, ambiguity or unnecessary interaction gets in the way.\n- Art director: inspect hierarchy, type, image treatment, rhythm, density, transitions, spatial relationships and interior coherence at phone and desktop widths. Identify what makes the result specific and memorable. Do not equate added decoration with creativity.\n- Skeptic: challenge the strongest conclusion. Identify unsupported claims, weak proof, a plausible stronger alternative, compromised mobile behavior or a repeated template pattern. A technical pass does not establish creative quality.\n- Editor: select the one to three highest-impact findings. For each, distinguish visible observation from causal hypothesis and expected improvement. Locate the page, viewport, state and section; cite the actual render ID. A screenshot supports visible claims, not unperformed interactions or conversion lift.\nEvaluate business fit, distinctive idea, visual craft, task clarity, responsive behavior and factual credibility separately. Do not average away a blocking defect. Do not invent human preference labels or precise performance scores.\nPrefer a focused joint revision when the central idea is promising but copy, media and composition do not yet work together. Retire a disproven organizing idea. Request a challenger only when the uncertainty is material enough to justify its production cost. Select a qualified result when further exploration has low expected value, then preserve its strongest identity choices during expansion.\nReview prior findings and revision results before proposing another change. Explain whether the previous acceptance observations were achieved and avoid repeating an ineffective intervention. Budget pressure limits exploration; it cannot convert a known blocker into a pass.\n";
+export declare const CREATIVE_REVISION_METHOD = "\nCreative revision method:\n- Start from each located finding, the attempted fix history, and its observable acceptance condition. Preserve the selected concept's strongest identity decisions.\n- Change copy, media placement and composition together where they depend on one another. Name the affected routes and source files. Shared styles or components require review across all routes.\n- Re-render and check the actual outcome; a source edit or passing technical check alone does not establish visual improvement. Keep unresolved risks explicit.\n";
+export declare const CREATIVE_FINAL_AUDIT_METHOD = "\nFinal creative audit method:\n- Inspect the full rendered site at phone and desktop widths, including consequential interiors. Check identity, visual craft, factual credibility, responsive behavior and every declared visitor task separately.\n- Attempt supported actions. Distinguish an observed usable CTA from an unverified backend integration or an unmeasured conversion result.\n- Locate consequential blockers with current render evidence. Preserve strengths during a focused repair and repeat final whole-site verification.\n";
+/** One authoritative method per creative role, shared by ordinary and efficiency packets. */
+export declare function creativeMethod(role: "plan" | "study-review" | "decision" | "revision" | "final-review"): string;

package/bin/types/src/agent/creative-render-bindings.d.ts

@@ -0,0 +1,13 @@
+export type RenderBinding = {
+    id: string;
+    path: string;
+    viewport?: number;
+    route?: string;
+    state?: string;
+    subjectHash?: string;
+    receiptPath?: string;
+    current: boolean;
+    reason?: string;
+};
+/** Bind every declared visual check to both its screenshot bytes and the source revision it depicts. */
+export declare function creativeRenderBindings(root: string, runId: string, role: "study-review" | "decision" | "final-review" | "revision", child?: string, candidateId?: string, expectedRoutes?: string[]): RenderBinding[];

package/bin/types/src/agent/creative-revision.d.ts

@@ -0,0 +1,33 @@
+import { type GraphNode } from "./graph.ts";
+import type { CreativeRevisionPlan } from "./creative-contract.ts";
+import type { CreativeEfficiencyPolicy } from "./creative-efficiency.ts";
+import type { JevConfig } from "./jev/types.ts";
+import type { JevClient } from "./jev/client.ts";
+import type { TrustedPilotContext } from "./jev/calibration.ts";
+export declare const CREATIVE_REVISION_WRITES: string[];
+export declare function creativeRevisionNode(runId: string, round: number, refs: string[]): GraphNode;
+/** A joint revision owns the authored contracts; fresh critic/browser gates still own acceptance. */
+export declare function runCreativeRevision(opts: {
+    root: string;
+    kernel: string;
+    runId: string;
+    round: number;
+    beforeRevision: string;
+    plan: CreativeRevisionPlan;
+    retry?: boolean;
+    beforePrepare?: () => void;
+    usageReceiptPath?: string;
+    evidenceRoot?: string;
+    creativeRoot?: string;
+    findings?: unknown[];
+    efficiency?: {
+        policy: CreativeEfficiencyPolicy;
+        config: JevConfig;
+        client?: JevClient;
+        pilotContext?: TrustedPilotContext;
+    };
+}): Promise<{
+    paused: boolean;
+    failures: string[];
+    preparationId?: string;
+}>;

package/bin/types/src/agent/creative-skills.d.ts

@@ -0,0 +1,25 @@
+export type CreativeSkill = {
+    id: string;
+    version: number;
+    purpose: string;
+    prerequisites: string[];
+    related: string[];
+    applicability: string[];
+    requiredInputs: string[];
+    outputContract: string;
+    tools: string[];
+    validation: string;
+    contraindications: string[];
+    expansionHandle: string;
+};
+export declare const CREATIVE_SKILLS: CreativeSkill[];
+export declare function validateCreativeSkills(skills: CreativeSkill[]): string[];
+export declare function selectedCreativeSkills(ids: string[], root: string, kernel?: string): {
+    descriptions: CreativeSkill[];
+    expansions: {
+        id: string;
+        hash: string;
+        text: string;
+        provenance: string;
+    }[];
+};