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

package/bin/types/src/agent/jev/review.d.ts

@@ -0,0 +1,37 @@
+import type { JevClient } from "./client.ts";
+import type { GroundingPreflightSummary, JevConfig } from "./types.ts";
+import { type CodeQuoteCheck } from "./policy.ts";
+export declare function normalizeWhitespace(text: string): string;
+/** Code-level check to verify that a declared quote exists verbatim in the cited source file. */
+export declare function verifyQuoteInSource(root: string, sourcePath: string, excerpt: string): CodeQuoteCheck;
+/**
+ * Builds question set for shared-state grounding batch with explicit path references.
+ * Explicitly rejects missing evidence keys without falling back to ev_0.
+ */
+export declare function buildGroundingBatchQuestions(batch: {
+    claims: Array<{
+        id: string;
+        statement?: string;
+        claim?: string;
+        evidenceIds?: string[];
+        evidence?: string[];
+    }>;
+    evidence: Array<{
+        id: string;
+        excerpt?: string;
+        hash?: string;
+        sources?: any[];
+    }> | Record<string, any>;
+}): Record<string, any>;
+/** Executes semantic grounding preflight checks for review nodes. */
+export declare function runSemanticGroundingPreflight(opts: {
+    root: string;
+    client: JevClient;
+    nodeId: string;
+    signal?: AbortSignal;
+    preparationId?: string;
+    inputHash?: string;
+    jevConfig?: JevConfig;
+}): Promise<GroundingPreflightSummary>;
+/** Formats the preflight summary block for insertion into critic prompts. */
+export declare function formatPreflightSummary(summary: GroundingPreflightSummary): string;

package/bin/types/src/agent/jev/security.d.ts

@@ -0,0 +1,28 @@
+export interface PathConfinementResult {
+    safe: boolean;
+    resolvedPath: string;
+    reason?: string;
+}
+/**
+ * Validates that candidatePath resolves strictly within the canonical root directory.
+ * - Prevents sibling-directory escapes (e.g. /workspace/site-extra from /workspace/site).
+ * - Resolves symlinks on both root and target to prevent symlink traversal outside root.
+ * - Uses separator-aware relative distance checks.
+ */
+export declare function isPathConfined(root: string, candidatePath: string): PathConfinementResult;
+export interface VisualProvenanceResult {
+    valid: boolean;
+    reason?: string;
+}
+/**
+ * Validates that a visual record (screenshot) has plausible provenance.
+ * Checks existence, mtime within preparation lease window, and environment match.
+ * If provenance is unavailable, returns { valid: false, reason: "provenance_unavailable" }.
+ */
+export declare function validateVisualProvenance(opts: {
+    screenshotPath: string;
+    expectedEnvironment?: string;
+    preparationId: string;
+    leaseStartMs?: number;
+    leaseEndMs?: number;
+}): VisualProvenanceResult;

package/bin/types/src/agent/jev/semantic-lifecycle.d.ts

@@ -0,0 +1,19 @@
+import type { JevClient } from "./client.ts";
+import type { JevCapabilityConfig } from "./types.ts";
+import { type SemanticReceipt } from "./semantic-tasks.ts";
+export declare function runLifecycleSemanticTasks(input: {
+    root: string;
+    stage: string;
+    preparationId: string;
+    capabilities: JevCapabilityConfig;
+    model: string;
+    client?: JevClient;
+    signal?: AbortSignal;
+    lessonCandidates?: Array<{
+        id: string;
+        reason: string;
+    }>;
+}): Promise<{
+    receipts: SemanticReceipt[];
+    advisory: string;
+}>;

package/bin/types/src/agent/jev/semantic-tasks.d.ts

@@ -0,0 +1,89 @@
+export declare const SEMANTIC_TASKS: readonly ["rank-lessons", "unanswered-questions", "fact-copy-contradiction", "cta-fit", "unexplained-repetition", "direction-continuity"];
+export type SemanticTask = (typeof SEMANTIC_TASKS)[number];
+export type SemanticReceipt = {
+    task: SemanticTask;
+    candidateId?: string;
+    rank?: number;
+    confidence?: number;
+    mode: "off" | "shadow" | "assist";
+    state: "off" | "ok" | "unknown" | "unavailable" | "malformed";
+    citedEvidence: string[];
+    answer: string;
+    latencyMs: number;
+    calls: number;
+    cacheHits: number;
+    tokenUsage: {
+        input?: number;
+        output?: number;
+    } | "unavailable";
+    fallback: string | null;
+    cacheKey: string;
+    cannotWaive: true;
+    followUps: 0;
+};
+export type SemanticCache = Map<string, {
+    text: string;
+    tokenUsage?: {
+        input?: number;
+        output?: number;
+    };
+}>;
+export declare function semanticCacheKey(input: {
+    task: SemanticTask;
+    model: string;
+    content: unknown;
+    knowledgeRelease: string;
+    policyId: string;
+}): string;
+export declare function interpretSemanticText(text: string, allowedEvidence: string[]): {
+    state: "ok" | "unknown" | "malformed";
+    citedEvidence: string[];
+    answer: string;
+};
+export declare function runSemanticTask(input: {
+    task: SemanticTask;
+    mode: "off" | "shadow" | "assist";
+    model: string;
+    content: unknown;
+    knowledgeRelease: string;
+    policyId: string;
+    evidenceIds: string[];
+    cache: SemanticCache;
+    unavailableReason?: string;
+    invoke?: () => Promise<{
+        text: string;
+        latencyMs: number;
+        cached?: boolean;
+        tokenUsage?: {
+            input?: number;
+            output?: number;
+        };
+    } | {
+        error: string;
+        latencyMs?: number;
+    }>;
+}): Promise<SemanticReceipt>;
+/** A semantic suggestion cannot change a confirmed serious failure into a pass. */
+export declare function applySemanticAdvice(finding: {
+    status: string;
+    severity: string;
+}, advice: {
+    status?: string;
+}): {
+    status: string;
+    waived: false;
+    ignored: boolean;
+};
+export declare function semanticAssistNote(capabilities: {
+    lessonRanking?: string;
+    visitorQuestionCheck?: string;
+    factContradictionCheck?: string;
+    ctaFitCheck?: string;
+    repetitionExplanationCheck?: string;
+    directionContinuityCheck?: string;
+}): string;
+export declare function assistanceSavedEffort(input: {
+    calls: number;
+    cacheHits: number;
+    extraRepairs: number | null;
+}): "saved" | "extra-repair" | "unknown";

package/bin/types/src/agent/jev/service-registry.d.ts

@@ -0,0 +1,98 @@
+export interface JevTaskRegistration {
+    taskId: string;
+    taskType: "grounding" | "cta_consistency" | "coverage" | "custom";
+    lifecycleCaller: string[];
+    inputSchema: string;
+    outputConsumer: string;
+    fallback: string;
+    testId: string;
+    description: string;
+    /** Whether this task can authorize delegated ownership. Always false for uncalibrated tasks. */
+    delegationEligible?: boolean;
+}
+export interface TaskExecutionRecord {
+    preparationId: string;
+    nodeId: string;
+    taskId: string;
+    taskType: "grounding" | "cta_consistency" | "coverage" | "custom";
+    inputHash: string;
+    status: "completed" | "cached" | "no_candidates" | "unavailable" | "partial";
+    timestamp: string;
+    receiptIds?: string[];
+    judgmentIds?: string[];
+    evaluatedCount?: number;
+    cachedCount?: number;
+    failureReason?: string;
+    priorPreparationId?: string;
+    cacheKey?: string;
+}
+/**
+ * Preparation-time task manifest. Saved before any inference runs.
+ * Binds expected model, question semantics, and claim/evidence identity to a specific preparation.
+ * verifyTaskExecution must match receipts and judgments against this manifest.
+ *
+ * Missing manifest → fail closed. Inference without a matching manifest is not verified.
+ */
+export interface JevTaskManifest {
+    schemaVersion: 1;
+    preparationId: string;
+    nodeId: string;
+    taskId: string;
+    taskType: string;
+    /** Model that was active when the manifest was created. Receipts must match. */
+    expectedModel: string;
+    /** Canonical hash of the question semantics (instructions + criteria). Judgments must match. */
+    questionSemanticsHash: string;
+    /** Ordered list of claim IDs included in this inference run. */
+    claimIds: string[];
+    /** Ordered list of evidence IDs included in this inference run. */
+    evidenceIds: string[];
+    /** Hash of each claim's normalized text at manifest creation time. */
+    claimHashes: Record<string, string>;
+    /** Hash of each evidence item's normalized excerpt at manifest creation time. */
+    evidenceHashes: Record<string, string>;
+    /** SHA-256 hashes of each batch-state payload, for state-binding verification. */
+    batchStateHashes: string[];
+    /** Question map keys generated for this run. Receipt answers must match this set. */
+    questionIds?: string[];
+    /** Subject / review-input hash at manifest creation. */
+    subjectHash?: string;
+    createdAt: string;
+}
+/** Registers a Jev task with the system. Throws if taskId is already registered. */
+export declare function registerTask(task: JevTaskRegistration): void;
+/** Looks up a registered Jev task by taskId. Returns undefined if not found. */
+export declare function getTask(taskId: string): JevTaskRegistration | undefined;
+/** Checks whether a Jev task is registered. */
+export declare function isTaskRegistered(taskId: string): boolean;
+/** Returns all currently registered Jev tasks. */
+export declare function allTasks(): JevTaskRegistration[];
+/** Returns all tasks associated with a given lifecycle caller node. */
+export declare function getTasksForCaller(nodeId: string): JevTaskRegistration[];
+/** Clears the registry (useful in test teardown). */
+export declare function clearRegistry(): void;
+/** Writes a durable task execution outcome bound to preparation identity and input hash. */
+export declare function recordTaskExecution(root: string, record: TaskExecutionRecord): void;
+export declare function saveTaskManifest(root: string, manifest: JevTaskManifest): void;
+/**
+ * Loads a task manifest for a specific preparation and taskId.
+ * Returns undefined if no manifest exists (fail-closed: caller must treat missing as unverified).
+ */
+export declare function loadTaskManifest(root: string, preparationId: string, taskId: string): JevTaskManifest | undefined;
+/** Loads a task execution record for a specific preparation and taskId or taskType. */
+export declare function loadTaskExecution(root: string, preparationId: string, taskIdOrType: string): TaskExecutionRecord | undefined;
+/**
+ * Strictly verifies that a registered task executed for the current preparation,
+ * disallowing stale/unrelated receipts, empty ledgers, or mismatched task/input identities.
+ * Preserves critic fallback on unavailable inference.
+ */
+export declare function verifyTaskExecution(root: string, prepId: string, nodeId: string, task: JevTaskRegistration, expectedInputHash?: string, options?: {
+    expectedModel?: string;
+    expectedQuestionSemantics?: string;
+    expectedSubjectHash?: string;
+}): {
+    ok: boolean;
+    reason?: string;
+};
+/** Resets registry to default built-in task registrations. */
+export declare function initDefaultRegistry(): void;

package/bin/types/src/agent/jev/state.d.ts

@@ -0,0 +1,104 @@
+export interface GroundingStatePayload {
+    task: "grounding";
+    claimId: string;
+    claim: string;
+    evidenceId?: string;
+    sourceFile?: string;
+    excerpt: string;
+}
+export declare function buildGroundingState(item: {
+    claimId: string;
+    claim: string;
+    evidenceId?: string;
+    sourceFile?: string;
+    excerpt: string;
+}): GroundingStatePayload;
+export interface RoutingStatePayload {
+    task: "routing";
+    instruction: string;
+    currentPages?: string[];
+    preservedDecisions?: string[];
+}
+export declare function buildRoutingState(instruction: string, options?: {
+    pages?: string[];
+    preserved?: string[];
+}): RoutingStatePayload;
+export interface CtaStatePayload {
+    task: "cta_consistency";
+    pagePath: string;
+    sectionId: string;
+    plannedCta: string;
+    storyboardAction?: {
+        label: string;
+        destination: string;
+        behavior: string;
+    } | null;
+}
+export declare function buildCtaState(opts: {
+    pagePath: string;
+    sectionId: string;
+    plannedCta: string;
+    storyboardAction?: {
+        label: string;
+        destination: string;
+        behavior: string;
+    } | null;
+}): CtaStatePayload;
+export interface EvidenceSourceLocation {
+    source: string;
+    span?: string | [number, number];
+    alias?: string;
+    evidenceId?: string;
+    sourceFile?: string;
+}
+export interface SharedEvidenceItem {
+    id: string;
+    source: string;
+    hash: string;
+    excerpt: string;
+    sources?: EvidenceSourceLocation[];
+}
+export interface SharedClaimItem {
+    id: string;
+    claim: string;
+}
+export interface SharedGroundingStatePayload {
+    task: "grounding_batch";
+    claims: Record<string, SharedClaimItem>;
+    evidence: Record<string, SharedEvidenceItem>;
+    metadata?: Record<string, unknown>;
+}
+export interface GroundingBatchCandidate {
+    claimId?: string;
+    claim?: string;
+    evidenceId?: string;
+    sourceFile?: string;
+    source?: string;
+    excerpt: string;
+    span?: string | [number, number];
+    alias?: string;
+}
+/** Compute SHA-256 hash of string for collision-free evidence identity. */
+export declare function sha256Hex(str: string): string;
+/** Retained for backward-compatibility, now backed by SHA-256 to prevent collisions. */
+export declare function simpleHash(str: string): string;
+/**
+ * Builds shared-state batch deduplicating excerpts by collision-free SHA-256 content hash.
+ * Questions reference explicit state paths rather than embedding duplicate text.
+ * Preserves every source alias and span when identical text appears across multiple sources.
+ */
+export declare function buildSharedGroundingBatch(candidates: GroundingBatchCandidate[]): {
+    state: SharedGroundingStatePayload;
+    evidenceKeyByHash: Map<string, string>;
+    evidence: SharedEvidenceItem[];
+};
+/**
+ * Recomputes SHA-256 from actual overflow file bytes.
+ * Prevents manipulation of evidence text while keeping JSON keys intact.
+ */
+export declare function rehashOverflowContent(overflowPath: string): string;
+/**
+ * Extends a shared grounding batch state with preparation identity.
+ * Binds the batch to a specific preparation context.
+ */
+export declare function bindBatchToPreparation(state: SharedGroundingStatePayload, preparationId: string, nodeId: string): SharedGroundingStatePayload;

package/bin/types/src/agent/jev/types.d.ts

@@ -0,0 +1,190 @@
+import type { ChoiceCriteria, ChoiceQuestion, ChoiceResponse, NoulQuestion, NoulResponse, Question, Questions, ScoreCriteria, ScoreQuestion, ScoreResponse, SystemOneRequest, SystemOneResult, Usage } from "@typesafe-ai/sdk";
+export type { ChoiceCriteria, ChoiceQuestion, ChoiceResponse, NoulQuestion, NoulResponse, Question, Questions, ScoreCriteria, ScoreQuestion, ScoreResponse, SystemOneRequest, SystemOneResult, Usage, };
+export type JevMode = "off" | "shadow" | "assist";
+/**
+ * Experimental work-ownership setting. Orthogonal to global mode and per-capability mode.
+ *
+ * - "agent"     (default): Agent owns the full workload. No Jev-delegated obligation removal.
+ *   Use for baseline/additive tests. Backward-compatible with all existing behavior.
+ * - "delegated" (experimental/uncalibrated): Machine-covered routine obligations may be removed
+ *   from the agent prompt only when ALL of the following hold:
+ *     1. Global mode is "assist".
+ *     2. The specific capability is "assist".
+ *     3. The calibration gate for the task is eligible === true.
+ *     4. The task contract, coverage, risk policy, and applicability all allow it.
+ *   Effective "off" or "shadow" cannot delegate. "assist" alone does not authorize delegation
+ *   unless all conditions above are met.
+ *
+ * Initially all tasks are uncalibrated; no live delegation is granted. Mark this setting
+ * as experimental in any UI or docs — it is not currently supported production syntax.
+ */
+export type JevWorkOwnership = "agent" | "delegated";
+/**
+ * Per-task calibration gate. All tasks default to eligible=false (uncalibrated).
+ * Delegation is blocked until a task-specific gate is manually set to eligible=true
+ * in an isolated pilot context with verified measurements.
+ */
+export interface JevCalibrationGate {
+    taskId: string;
+    /** Default false — delegation disabled until measurements justify enabling. */
+    eligible: boolean;
+    gateVersion?: string;
+    /** If true, only permitted inside an explicitly named pilot context. */
+    pilotOnly?: boolean;
+    notes?: string;
+}
+/**
+ * Per-task applicability descriptor. Prevents inapplicable tasks from running
+ * (e.g. no booking questions when the site has no booking functionality).
+ */
+export interface JevTaskApplicability {
+    taskId: string;
+    /** Whether the subject matter required by this task exists on the site. */
+    subjectExists: boolean;
+    riskLevel: "low" | "medium" | "high";
+    /** All policy conditions that must be satisfied for delegation. */
+    delegationRequires: string[];
+}
+export interface JevConfidenceThresholds {
+    routing: number;
+    grounding: number;
+}
+export interface JevCacheConfig {
+    enabled: boolean;
+    dir: string;
+}
+export interface JevBudgetConfig {
+    maxCalls?: number;
+    maxInputTokens?: number;
+    maxOutputTokens?: number;
+    maxCostUsd?: number;
+}
+export interface JevCapabilityConfig {
+    mediaClassification?: JevMode;
+    mediaSelection?: JevMode;
+    mediaSetReview?: JevMode;
+    mediaProvenance?: JevMode;
+    grounding: JevMode;
+    sourceSelection: JevMode;
+    retrievalRanking: JevMode;
+    consistency: JevMode;
+    repairAssistance: JevMode;
+    preferenceScoring: JevMode;
+    claimStrengthening?: JevMode;
+    ctaFidelity?: JevMode;
+    crossStageContinuity?: JevMode;
+    coverageCheck?: JevMode;
+    creativeScoring?: JevMode;
+    /** Phase 2: rank library blocks after copy-review / changed pages. Off in the matched quality profile. */
+    componentSelection?: JevMode;
+    /** Advisory storyboard repetition check. Off unless the design-assist preset or an explicit capability enables it. */
+    compositionCheck?: JevMode;
+    /** Rank eligible lessons. Cannot drop mandatory requirements. */
+    lessonRanking?: JevMode;
+    visitorQuestionCheck?: JevMode;
+    factContradictionCheck?: JevMode;
+    ctaFitCheck?: JevMode;
+    repetitionExplanationCheck?: JevMode;
+    directionContinuityCheck?: JevMode;
+}
+export interface JevTelemetryConfig {
+    enabled: boolean;
+    receiptDir: string;
+}
+/**
+ * Pilot budget limits for isolated experiments.
+ * Default ceiling: 100 transport attempts, 200,000 estimated input tokens.
+ * Preflight estimates may conservatively reserve budget; actual usage reconciles.
+ * Stop Jev and restore agent obligations at the ceiling.
+ */
+export interface JevPilotBudget {
+    maxTransportAttempts: number;
+    maxInputTokens: number;
+}
+export interface JevConfig {
+    mode: JevMode;
+    model: string;
+    endpoint?: string;
+    timeoutMs: number;
+    taskDeadlineMs: number;
+    maxConcurrency: number;
+    maxRetries: number;
+    confidenceThresholds: JevConfidenceThresholds;
+    compactPackets: boolean;
+    cache?: JevCacheConfig;
+    budget?: JevBudgetConfig;
+    capabilities?: Partial<JevCapabilityConfig>;
+    telemetry?: JevTelemetryConfig;
+    /**
+     * Experimental work-ownership setting. Default "agent".
+     * See JevWorkOwnership for full semantics and constraints.
+     */
+    workOwnership?: JevWorkOwnership;
+    /**
+     * Pilot budget ceiling. Applied only when explicitly running a pilot.
+     * Default: 100 transport attempts, 200,000 input tokens.
+     */
+    pilotBudget?: JevPilotBudget;
+    /**
+     * Per-task calibration gates from site config. Diagnostic only.
+     * `eligible: true` here NEVER authorizes delegation. Kernel calibration artifacts do.
+     */
+    calibrationGates?: JevCalibrationGate[];
+    /**
+     * Per-task applicability descriptors. Controls whether a task runs at all
+     * given the site's actual content.
+     */
+    taskApplicability?: JevTaskApplicability[];
+}
+export type GroundingVerdict = "verified" | "contradicted" | "insufficient_evidence" | "quote_not_found" | "missing_source" | "fabricated" | "superseded";
+/** Six-state evidence model. Maps from the existing 4-state claim status on read. */
+export type EvidenceStatus = "supported" | "contradicted" | "insufficient" | "conflict" | "unavailable" | "superseded";
+export interface GroundingCheckItem {
+    id: string;
+    claim: string;
+    evidenceId?: string;
+    sourceFile?: string;
+    excerpt?: string;
+    verdict: GroundingVerdict;
+    confidence?: number;
+    relation?: "supports" | "contradicts" | "says_nothing" | "consistent" | "contradictory" | "unaddressed";
+    autoAccepted: boolean;
+    notes?: string;
+}
+export interface GroundingPreflightSummary {
+    nodeId: string;
+    totalChecked: number;
+    verifiedCount: number;
+    flaggedCount: number;
+    items: GroundingCheckItem[];
+    preflightReceiptPath?: string;
+}
+export interface JevReceipt {
+    schemaVersion: 1;
+    receiptId: string;
+    taskType: "grounding" | "routing" | "cta_consistency" | "custom";
+    nodeId?: string;
+    model: string;
+    policyVersion: string;
+    questionVersion: string;
+    subjectHash?: string;
+    evidenceHash?: string;
+    stateHash: string;
+    durationMs: number;
+    createdAt: string;
+    status: "ok" | "uncertain" | "unavailable" | "malformed" | "budget_limited" | "canceled";
+    cached: boolean;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        /** True when the SDK omitted usage; spend must use estimatedInputTokens, never treat as zero. */
+        unknown?: boolean;
+    };
+    retries: number;
+    /** Actual HTTP/SDK attempts for this receipt. 0 means no network (cache or reservation denial). */
+    transportAttempts?: number;
+    estimatedInputTokens?: number;
+    answers: Record<string, unknown>;
+    fallbackReason?: string;
+}
+export type JevTransport = (input: string, init?: RequestInit) => Promise<Response>;

package/bin/types/src/agent/jev/visible-assertions.d.ts

@@ -0,0 +1,84 @@
+export type EvidenceStatus = "resolved" | "missing" | "stale" | "conflicting" | "unrelated" | "none_cited";
+export interface ResolvedEvidence {
+    id: string;
+    excerpt: string;
+    source: string;
+    hash: string;
+    span?: [number, number];
+}
+export type AssertionMatchKind = "stable-id" | "section-element" | "bounded-semantic" | "unmatched" | "conflict";
+export interface SourceLocation {
+    file: string;
+    start: number;
+    end: number;
+}
+export interface VisibleAssertion {
+    id: string;
+    pagePath: string;
+    sectionId: string;
+    element: string;
+    text: string;
+    origin: "copy-plan" | "compiled-html";
+    sourceHash: string;
+    factIds: string[];
+    evidence: ResolvedEvidence[];
+    evidenceStatus: EvidenceStatus;
+    evidenceObligation?: string;
+    sourceLocation?: SourceLocation;
+    matchKind?: AssertionMatchKind;
+    plannedId?: string;
+    factIdsAttached?: boolean;
+}
+export interface CtaPair {
+    id: string;
+    label: string;
+    behavior: string;
+    behaviorKind: "planned" | "rendered" | "browser-observed";
+    location: string;
+    href?: string;
+    linkResolved?: boolean;
+    pagePath: string;
+}
+export interface AssertionDelta {
+    added: VisibleAssertion[];
+    dropped: VisibleAssertion[];
+    strengthened: Array<{
+        planned: VisibleAssertion;
+        rendered: VisibleAssertion;
+    }>;
+}
+export declare function resolveFactEvidence(root: string, factIds: string[]): {
+    evidence: ResolvedEvidence[];
+    status: EvidenceStatus;
+    obligation?: string;
+};
+export declare function extractPlannedAssertions(root: string): VisibleAssertion[];
+export declare function extractRenderedAssertions(root: string): VisibleAssertion[];
+export declare function extractAssertionsForNode(root: string, nodeId: string): VisibleAssertion[];
+export declare function tokenOverlap(a: string, b: string): number;
+export interface LineageResult {
+    linked: VisibleAssertion[];
+    unmatchedRendered: VisibleAssertion[];
+    unmatchedPlanned: VisibleAssertion[];
+    conflicts: VisibleAssertion[];
+    stale: VisibleAssertion[];
+    reusedHeadings: Array<{
+        text: string;
+        sections: string[];
+    }>;
+}
+export declare function currentCopySectionHashes(root: string): Map<string, string>;
+export declare function attachLineage(root: string, planned: VisibleAssertion[], rendered: VisibleAssertion[]): LineageResult;
+export declare function comparePlannedToRendered(planned: VisibleAssertion[], rendered: VisibleAssertion[]): AssertionDelta;
+export declare function extractPlannedCtas(root: string): CtaPair[];
+export declare function extractRenderedCtas(root: string): CtaPair[];
+export declare function extractCtasForNode(root: string, nodeId: string): CtaPair[];
+export declare function formatEvidenceForJev(assertion: VisibleAssertion): string | undefined;
+export declare function extractPhones(text: string): string[];
+export declare function authorizedPhones(root: string): Set<string>;
+export declare function unauthorizedContactFindings(root: string, assertions: VisibleAssertion[]): Array<{
+    id: string;
+    location: string;
+    phone: string;
+    text: string;
+}>;

package/bin/types/src/agent/kernel-commands.d.ts

@@ -0,0 +1,2 @@
+export declare function kernelScriptCommand(kernel: string, scriptRel: string, bundledName?: string | undefined): string;
+export declare function preferBundledToolArgs(kernel: string, args: string[]): string[];

package/bin/types/src/agent/kit-runtime.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Mutable agent-kit paths that must never be inherited from the kernel into a
+ * fresh site, and must never be copied from the kernel over a site's own
+ * runtime during refresh.
+ */
+export declare const AGENT_RUNTIME_HISTORY_ENTRIES: readonly ["decisions", "runs", "run-history", "reviews", "screenshots", "preparations", "leases", "receipts", "design-runs", "CURRENT.md", "PREPARED.json", "preview-server.json", "RUN.lock", "result-manifest.json", ".mutation.lock", ".commit-journal.json", "quality-attempts.json", "media-revisions", "template-responses.json", "template-questions.json", "template-decisions.json", "template-inventory.json", "theme-selection.json", "template-input.json", "theme-awaiting.json"];
+/**
+ * Deletes kernel runtime history from a copied agent directory.
+ * Safe to call on a destination site after copying the static kit.
+ * Does not touch STATE.json, graph, refs, or site-authored config.
+ */
+export declare function stripAgentRuntimeHistory(agentDir: string): string[];

package/bin/types/src/agent/legacy-definitions/theme-art.d.ts

@@ -0,0 +1,5 @@
+export declare const photo: (id: string, caption: string, cls?: string) => string;
+export declare const object: (n: number, caption: string, cls?: string) => string;
+export declare const plant: string;
+export declare const planDrawing = "<svg viewBox=\"0 0 800 480\" role=\"img\" aria-label=\"Original schematic: reading room, joinery wall and window\"><g fill=\"none\" stroke=\"currentColor\"><path d=\"M80 50H720V430H80Z\" stroke-width=\"9\"/><path d=\"M80 350H150M230 350H720M510 50V350\" stroke-width=\"6\"/><path d=\"M150 350v-80a80 80 0 0 1 80 80M510 75H690V330H510M110 80H200V260H110\" stroke-width=\"2\"/><path d=\"M285 130H430V220H285Z M310 105V125 M405 105V125 M310 225V250 M405 225V250 M80 20H720 M80 12V28 M720 12V28\" stroke-width=\"2\"/><path d=\"M245 430H445\" stroke-width=\"13\"/></g><g fill=\"currentColor\" font-family=\"IBM Plex Mono,monospace\" font-size=\"17\"><text x=\"315\" y=\"185\">01</text><text x=\"580\" y=\"210\">02</text><text x=\"300\" y=\"400\">03</text><text x=\"240\" y=\"470\">SCHEMATIC / NOT TO SCALE</text></g></svg>";
+export declare const enquiry: (title?: string) => string;