cloving 1.0.1 → 1.2.0

package/dist/src/authority/reconciliation.js

@@ -1,5 +1,6 @@
+import { isTicketStatus } from "../ticket-status.js";
 import { gateContinuation } from "./gate-reduction.js";
-import { isBlockedReason } from "../workflow-contracts.js";
+import { isBlockedReason, isPromotionId } from "../workflow-contracts.js";
 import { continues } from "./gates.js";
 import { startOperation } from "./reduction.js";
 import { terminal, } from "./transitions.js";
@@ -110,11 +111,26 @@ function moved(kind, observed) {
 }
 function completionOutcome(world) {
     const { outcome, outcomeReason } = world;
-    if (outcome !== "handoff_requested" && outcome !== "blocked")
+    if (outcome === "blocked")
+        return {
+            outcome,
+            ...(isBlockedReason(outcomeReason) ? { outcomeReason } : {}),
+        };
+    if (outcome !== "handoff_requested")
         return {};
-    if (outcome !== "blocked" || !isBlockedReason(outcomeReason))
-        return { outcome };
-    return { outcome, outcomeReason };
+    return {
+        outcome,
+        ...(isBlockedReason(outcomeReason) ? { outcomeReason } : {}),
+        ...(isPromotionId(world.promotionId)
+            ? { promotionId: world.promotionId }
+            : {}),
+        ...(world.issueUpdate === "failed"
+            ? { issueUpdate: world.issueUpdate }
+            : {}),
+        ...(isTicketStatus(world.ticketStatus)
+            ? { ticketStatus: world.ticketStatus }
+            : {}),
+    };
 }
 function noted(observed, evidence) {
     const { run, world, reason } = observed;

package/dist/src/authority/transitions.d.ts

@@ -40,7 +40,7 @@ export interface AuthorityEvent {
     readonly payload: Readonly<Record<string, string>>;
 }
 export declare const numberFields: readonly ["expectedRevision", "generation", "attempt", "limit", "effectLimit", "units", "recoveryLimit", "leaseGeneration", "sourceGeneration", "capacity"];
-export declare const textFields: readonly ["workflow", "submission", "input", "resolver", "gateId", "gateKind", "subject", "prompt", "expiresAt", "decision", "answer", "condition", "reason", "evidence", "retryAt", "operationId", "receipt", "capabilities", "capability", "method", "target", "payload", "inputDigest", "resource", "transport", "source", "worker", "outcome", "outcomeReason", "result"];
+export declare const textFields: readonly ["parentRunId", "chainId", "workflow", "submission", "input", "resolver", "gateId", "gateKind", "subject", "prompt", "expiresAt", "decision", "answer", "condition", "reason", "evidence", "retryAt", "operationId", "receipt", "capabilities", "capability", "method", "target", "payload", "inputDigest", "resource", "transport", "source", "worker", "outcome", "outcomeReason", "promotionId", "ticketStatus", "issueUpdate", "result"];
 export type NumberField = (typeof numberFields)[number];
 export type TextField = (typeof textFields)[number];
 export type AuthorityCommand = {

package/dist/src/authority/transitions.js

@@ -31,6 +31,8 @@ export const numberFields = [
     "capacity",
 ];
 export const textFields = [
+    "parentRunId",
+    "chainId",
     "workflow",
     "submission",
     "input",
@@ -60,6 +62,9 @@ export const textFields = [
     "worker",
     "outcome",
     "outcomeReason",
+    "promotionId",
+    "ticketStatus",
+    "issueUpdate",
     "result",
 ];
 export const terminal = [

package/dist/src/broker/actor/authority-queries.d.ts

@@ -1,6 +1,7 @@
 import type { Database } from "solid-objects";
 import type { AuthorityCommand, AuthorityEvent } from "../../authority/transitions.ts";
 import { type SqlConnection } from "../../storage/domain-rows.ts";
+import { type RunLinks, type RunOrigins } from "../../authority/handoff-chain.ts";
 export interface CommandRecord {
     readonly commandId: string;
     readonly sequence: number;
@@ -28,6 +29,7 @@ export interface Sequences {
 export interface CompletionCursor {
     readonly runId: string;
     readonly atOrBefore: number;
+    readonly terminal?: boolean;
 }
 export interface AuthorityQueries {
     readonly document: (digest: string) => Promise<string | undefined>;
@@ -36,6 +38,8 @@ export interface AuthorityQueries {
     readonly latestCompletion: (cursor: CompletionCursor) => Promise<PublishedEvent | undefined>;
     readonly sequences: () => Promise<Sequences>;
     readonly workflowIds: () => Promise<Readonly<Record<string, string>>>;
+    readonly runOrigins: () => Promise<RunOrigins>;
+    readonly runLinks: () => Promise<Readonly<Record<string, RunLinks>>>;
 }
 export type Read = <Value>(query: (connection: SqlConnection) => Promise<Value>) => Promise<Value>;
 export declare function guardedRead(access: {

package/dist/src/broker/actor/authority-queries.js

@@ -1,8 +1,19 @@
 import { parseCommand } from "../../authority/commands.js";
 import { documentBody } from "../../storage/decision-rows.js";
-import { integer, latestSequence, text, } from "../../storage/domain-rows.js";
+import { integer, optionalText, latestSequence, text, } from "../../storage/domain-rows.js";
 import { storedEvents } from "../authority-restore.js";
 import { documentDigest } from "../decision-restore.js";
+import { runLinks, } from "../../authority/handoff-chain.js";
+async function runOrigins(connection, cursor) {
+    const rows = await connection.all("SELECT run_id, json_extract(payload, '$.parentRunId') AS parent_run_id, coalesce(json_extract(payload, '$.chainId'), run_id) AS chain_id FROM events WHERE type = 'run.created' AND sequence > ? AND sequence <= ? ORDER BY sequence", [cursor.after, cursor.through]);
+    return Object.fromEntries(rows.map((row) => [
+        text(row, "run_id"),
+        {
+            parentRunId: optionalText(row, "parent_run_id"),
+            chainId: text(row, "chain_id"),
+        },
+    ]));
+}
 async function receipt(connection, commandId) {
     const row = await connection.get("SELECT c.request, c.sequence, e.run_id, e.recorded_at FROM commands c JOIN events e ON e.sequence = c.sequence WHERE c.command_id = ?", [commandId]);
     if (row === undefined)
@@ -51,7 +62,10 @@ function publishedEvents(rows) {
     }));
 }
 async function latestCompletion(connection, cursor) {
-    const row = await connection.get("SELECT sequence, type, run_id, command_id, recorded_at, payload FROM events WHERE run_id = ? AND type = 'run.completed' AND sequence <= ? ORDER BY sequence DESC LIMIT 1", [cursor.runId, cursor.atOrBefore]);
+    const types = cursor.terminal === true
+        ? "type IN ('run.completed', 'run.failed', 'run.cancelled')"
+        : "type = 'run.completed'";
+    const row = await connection.get(`SELECT sequence, type, run_id, command_id, recorded_at, payload FROM events WHERE run_id = ? AND ${types} AND sequence <= ? ORDER BY sequence DESC LIMIT 1`, [cursor.runId, cursor.atOrBefore]);
     return row === undefined ? undefined : publishedEvents([row])[0];
 }
 async function sequences(connection) {
@@ -66,6 +80,28 @@ async function workflowIds(connection) {
     const rows = await connection.all("SELECT d.run_id, json_extract(s.body, '$.workflowId') AS workflow_id FROM run_details d JOIN documents s ON s.digest = d.submission WHERE json_valid(s.body) AND json_type(s.body, '$.workflowId') = 'text'");
     return Object.fromEntries(rows.map((row) => [text(row, "run_id"), text(row, "workflow_id")]));
 }
+function cachedOrigins(read) {
+    let sequence = 0;
+    let origins = {};
+    let pending = Promise.resolve();
+    return () => {
+        const result = pending.then(() => read(async (connection) => {
+            const through = await latestSequence(connection);
+            if (through === sequence)
+                return origins;
+            const added = await runOrigins(connection, {
+                after: sequence,
+                through,
+            });
+            if (Object.keys(added).length > 0)
+                origins = { ...origins, ...added };
+            sequence = through;
+            return origins;
+        }));
+        pending = result.then(() => undefined, () => undefined);
+        return result;
+    };
+}
 export function guardedRead(access) {
     const { reader, ready } = access;
     return async (query) => {
@@ -74,6 +110,17 @@ export function guardedRead(access) {
     };
 }
 export function authorityQueries(read) {
+    const origins = cachedOrigins(read);
+    let linkedOrigins;
+    let links = {};
+    const currentLinks = async () => {
+        const current = await origins();
+        if (current !== linkedOrigins) {
+            links = runLinks(current);
+            linkedOrigins = current;
+        }
+        return links;
+    };
     return {
         document: (digest) => read((connection) => documentBody(connection, digest)),
         receipt: (commandId) => read((connection) => receipt(connection, commandId)),
@@ -81,5 +128,7 @@ export function authorityQueries(read) {
         latestCompletion: (cursor) => read((connection) => latestCompletion(connection, cursor)),
         sequences: () => read(sequences),
         workflowIds: () => read(workflowIds),
+        runOrigins: origins,
+        runLinks: currentLinks,
     };
 }

package/dist/src/broker/actor/authority-session.d.ts

@@ -1,5 +1,6 @@
 import type { Database, JsonObject } from "solid-objects";
 import { type AuthorityEvent, type EffectIntent } from "../../authority/reducer.ts";
+import { type ProjectionSnapshot } from "../../storage/decision-snapshots.ts";
 import type { AdmissionResult, ExecutionManifest } from "../../workflow-admission.ts";
 import { type StoredState } from "../authority-restore.ts";
 import { type SequenceChanges, type SequenceListener } from "./authority-changes.ts";
@@ -63,3 +64,4 @@ export interface SessionParts {
     readonly subscribe: (listener: SequenceListener) => () => void;
 }
 export declare function authoritySession(parts: SessionParts): Authority;
+export declare function operationRecords(snapshot: Pick<ProjectionSnapshot, "outbox" | "deliveries">): readonly OperationRecord[];

package/dist/src/broker/actor/authority-session.js

@@ -221,16 +221,15 @@ async function healthyReceipt(session, value) {
     await refreshed(session);
     return receipt;
 }
-function operationRecords(snapshot) {
+export function operationRecords(snapshot) {
+    const deliveries = Map.groupBy(snapshot.deliveries, (row) => row.operationId);
     return snapshot.outbox.map((row) => ({
         operationId: row.operationId,
         kind: intentKind(row.kind),
         runId: row.runId,
         createdSequence: row.createdSequence,
         releasedSequence: row.releasedSequence,
-        deliveries: snapshot.deliveries
-            .filter((delivery) => delivery.operationId === row.operationId)
-            .map(({ effectId, outcome, receipt, purpose, epoch }) => ({
+        deliveries: (deliveries.get(row.operationId) ?? []).map(({ effectId, outcome, receipt, purpose, epoch }) => ({
             effectId,
             outcome,
             receipt,

package/dist/src/broker/actor/delivery-intents.d.ts

@@ -51,6 +51,7 @@ export interface Delivery {
         readonly worker?: string;
     } | AdapterOutcome>;
     readonly reconcile: (intent: DeliveryIntent, signal: AbortSignal) => Promise<AdapterOutcome>;
+    readonly retry?: Delivery["reconcile"];
     readonly stop?: (intent: DeliveryIntent, signal: AbortSignal) => Promise<AdapterOutcome>;
 }
 export type AvailableManifest = (pinned: ExecutionManifest) => ExecutionManifest | undefined;

package/dist/src/broker/actor/effect-delivery.js

@@ -69,9 +69,16 @@ function decided(parts, attempt) {
     }), {
         intent: { ...intent, computedDigest: effectInputDigest(intent) },
         now,
+        ...(attempt.mode === undefined ? {} : { mode: attempt.mode }),
     }));
 }
 const withheld = { kind: "withheld" };
+async function retryEffect(parts, attempt) {
+    const retry = await decided(parts, { ...attempt, mode: "retry" });
+    return retry === "send"
+        ? called(parts, { intent: attempt.intent, name: "retry" })
+        : attempt.known;
+}
 function unsent(decision) {
     return decision === "stale" ? withheld : { kind: decision };
 }
@@ -83,6 +90,8 @@ async function attempted(parts, attempt) {
     if (intent.purpose === "stop")
         return stopRequested(parts, intent);
     const known = await called(parts, { intent, name: "reconcile" });
+    if (known.kind === "unknown" && parts.delivery.retry !== undefined)
+        return retryEffect(parts, { ...attempt, known });
     if (known.kind !== "absent" || intent.purpose === "reconcile")
         return known;
     if (first !== "send")

package/dist/src/broker/authority-admission.js

@@ -1,5 +1,5 @@
 import { parseCommand } from "../authority/commands.js";
-import { readExecutionManifest, resumePinned } from "../execution-pin.js";
+import { executionCapabilities, readExecutionManifest, resumePinned, } from "../execution-pin.js";
 import { effectInputDigest } from "./effect-restore.js";
 import { workflowPin } from "./workflow-pin.js";
 const admissible = { kind: "admissible", definitions: new Map() };
@@ -15,7 +15,7 @@ const admission = (command, context) => {
     const pin = workflowPin(stored);
     if (command.workflow !== pin)
         return { kind: "rejected", reason: "workflow-pin-mismatch" };
-    const capabilities = JSON.stringify([...stored.capabilities].sort());
+    const capabilities = executionCapabilities(stored);
     if ((command.capabilities ?? capabilities) !== capabilities)
         return { kind: "rejected", reason: "capability-pin-mismatch" };
     return { kind: "admissible", definitions: new Map([[pin, stored]]) };
@@ -40,9 +40,17 @@ const effectRequest = (command, context) => {
         target: String(command.target),
         payload: String(command.payload),
     });
-    return computed === command.inputDigest
-        ? unpinned(command, context)
-        : { kind: "rejected", reason: "input-digest-mismatch" };
+    if (computed !== command.inputDigest)
+        return { kind: "rejected", reason: "input-digest-mismatch" };
+    if (command.capability !== "handoff")
+        return unpinned(command, context);
+    const pin = context.state.runs[command.runId]?.workflow ?? "";
+    const declaration = context.definitions.get(pin);
+    if (!declaration?.handoffs?.includes(String(command.target)))
+        return { kind: "rejected", reason: "handoff-not-declared" };
+    if (command.units !== 1 || command.method !== "run")
+        return { kind: "rejected", reason: "invalid-handoff-request" };
+    return unpinned(command, context);
 };
 const rules = {
     "request-effect": effectRequest,

package/dist/src/chats/analysis-batches.d.ts

@@ -0,0 +1,42 @@
+import type { AnalysisResult } from "./analysis-contract.ts";
+import { type AnalysisSnapshot } from "./analysis-input.ts";
+import { type AnalysisBatchContext } from "./analysis-prompt.ts";
+export interface AnalysisBatchPosition {
+    readonly nextRecordIndex: number;
+    readonly completedBatchCount: number;
+    readonly previousResult: AnalysisResult | null;
+}
+export interface AnalysisBatch {
+    readonly kind: "batch";
+    readonly batchIndex: number;
+    readonly firstRecordIndex: number;
+    readonly nextRecordIndex: number;
+    readonly totalRecords: number;
+    readonly snapshot: AnalysisSnapshot;
+    readonly prompt: string;
+    readonly launchBytes: number;
+    readonly adapterDocument: string;
+    readonly context: AnalysisBatchContext;
+}
+export type AnalysisBatchPreparation = AnalysisBatch | {
+    readonly kind: "refused";
+    readonly code: "analysis-input-refused" | "analysis-too-large" | "analysis-batch-limit";
+};
+export declare const analysisCaptureBytes = 52428800;
+export declare function analysisBatchData(batch: AnalysisBatch, capture: {
+    readonly digest: string;
+    readonly snapshot?: AnalysisSnapshot;
+}): {
+    snapshot: AnalysisSnapshot;
+    context?: never;
+    batch?: never;
+} | {
+    snapshot: AnalysisSnapshot;
+    context: AnalysisBatchContext;
+    batch: {
+        batchIndex: number;
+        nextRecordIndex: number;
+        capturedDigest: string;
+    };
+};
+export declare function prepareAnalysisBatch(snapshot: AnalysisSnapshot, position: AnalysisBatchPosition): AnalysisBatchPreparation;

package/dist/src/chats/analysis-batches.js

@@ -0,0 +1,97 @@
+import { analysisDocumentBytes, analysisEvidence, isAnalysisSnapshot, validAnalysisImportId, } from "./analysis-input.js";
+import { analysisLaunchBytes, analysisPrompt, } from "./analysis-prompt.js";
+export const analysisCaptureBytes = 52_428_800;
+export function analysisBatchData(batch, capture) {
+    if (batch.batchIndex === 0 && batch.nextRecordIndex === batch.totalRecords)
+        return { snapshot: capture.snapshot ?? batch.snapshot };
+    return {
+        snapshot: batch.snapshot,
+        context: batch.context,
+        batch: {
+            batchIndex: batch.batchIndex,
+            nextRecordIndex: batch.nextRecordIndex,
+            capturedDigest: capture.digest,
+        },
+    };
+}
+export function prepareAnalysisBatch(snapshot, position) {
+    if (!isAnalysisSnapshot(snapshot) ||
+        !validAnalysisImportId(snapshot.importId))
+        return { kind: "refused", code: "analysis-input-refused" };
+    if (Buffer.byteLength(snapshot.corpus) > analysisCaptureBytes ||
+        [snapshot.redaction, snapshot.structure].some((text) => Buffer.byteLength(text) > analysisDocumentBytes))
+        return { kind: "refused", code: "analysis-too-large" };
+    try {
+        return preparedBatch(snapshot, position);
+    }
+    catch {
+        return { kind: "refused", code: "analysis-input-refused" };
+    }
+}
+function preparedBatch(snapshot, position) {
+    const lines = snapshot.corpus.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+    if (![position.nextRecordIndex, position.completedBatchCount].every(Number.isSafeInteger) ||
+        position.nextRecordIndex < 0 ||
+        position.nextRecordIndex >= lines.length ||
+        position.completedBatchCount < 0 ||
+        position.completedBatchCount > 4)
+        return { kind: "refused", code: "analysis-input-refused" };
+    if (position.completedBatchCount === 4)
+        return { kind: "refused", code: "analysis-batch-limit" };
+    const structure = analysisEvidence(snapshot).structure;
+    let longest = {
+        kind: "refused",
+        code: "analysis-too-large",
+    };
+    for (let end = position.nextRecordIndex + 1; end <= lines.length; end++) {
+        const batch = batchOf(snapshot, { lines, position, end, structure });
+        if (Math.max(batch.launchBytes, Buffer.byteLength(batch.adapterDocument)) >
+            analysisDocumentBytes)
+            break;
+        longest = batch;
+    }
+    return longest;
+}
+function batchOf(snapshot, input) {
+    const { position, lines, end } = input;
+    const batchSnapshot = {
+        ...snapshot,
+        corpus: lines.slice(position.nextRecordIndex, end).join(""),
+        structure: projectedStructure(snapshot.importId, input),
+    };
+    const context = {
+        batchIndex: position.completedBatchCount,
+        firstRecordIndex: position.nextRecordIndex,
+        previousResult: position.previousResult,
+    };
+    const prompt = analysisPrompt(batchSnapshot, context);
+    return {
+        kind: "batch",
+        batchIndex: context.batchIndex,
+        firstRecordIndex: context.firstRecordIndex,
+        nextRecordIndex: end,
+        totalRecords: lines.length,
+        snapshot: batchSnapshot,
+        prompt,
+        launchBytes: analysisLaunchBytes(prompt),
+        adapterDocument: JSON.stringify({ snapshot: batchSnapshot, context }),
+        context,
+    };
+}
+function projectedStructure(importId, input) {
+    const { structure, position, end } = input;
+    return JSON.stringify({
+        schemaVersion: 1,
+        importId,
+        historyCompleteness: structure.historyCompleteness,
+        occurrences: structure.occurrences.slice(position.nextRecordIndex, end),
+        conflictGroups: structure.conflictGroups
+            .map((group) => ({
+            uuid: group.uuid,
+            variants: group.variants
+                .map((variant) => variant.filter((reference) => reference.recordIndex < end))
+                .filter((variant) => variant.length > 0),
+        }))
+            .filter((group) => group.variants.length > 0),
+    });
+}

package/dist/src/chats/analysis-checkpoint.d.ts

@@ -0,0 +1,29 @@
+import type { AnalysisResult } from "./analysis-contract.ts";
+export interface AnalysisCheckpoint {
+    readonly schemaVersion: 1;
+    readonly runId: string;
+    readonly importId: string;
+    readonly capturedDigest: string;
+    readonly batchIndex: number | null;
+    readonly status: "partial" | "complete";
+    readonly result: AnalysisResult | null;
+    readonly total: number;
+    readonly covered: number;
+    readonly uncovered: number;
+    readonly completedBatchCount: number;
+    readonly nextRecordIndex: number;
+}
+export interface AnalysisCheckpointCapture {
+    readonly runId: string;
+    readonly importId: string;
+    readonly digest: string;
+    readonly totalRecords: number;
+}
+export declare function initialAnalysisCheckpoint(capture: AnalysisCheckpointCapture): AnalysisCheckpoint;
+export declare function batchAnalysisCheckpoint(capture: AnalysisCheckpointCapture, position: {
+    readonly batchIndex: number;
+    readonly nextRecordIndex: number;
+    readonly result: AnalysisResult;
+}): AnalysisCheckpoint & {
+    readonly result: AnalysisResult;
+};

package/dist/src/chats/analysis-checkpoint.js

@@ -0,0 +1,31 @@
+export function initialAnalysisCheckpoint(capture) {
+    return {
+        schemaVersion: 1,
+        runId: capture.runId,
+        importId: capture.importId,
+        capturedDigest: capture.digest,
+        batchIndex: null,
+        status: "partial",
+        result: null,
+        total: capture.totalRecords,
+        covered: 0,
+        uncovered: capture.totalRecords,
+        completedBatchCount: 0,
+        nextRecordIndex: 0,
+    };
+}
+export function batchAnalysisCheckpoint(capture, position) {
+    return {
+        ...initialAnalysisCheckpoint(capture),
+        batchIndex: position.batchIndex,
+        status: position.nextRecordIndex === capture.totalRecords &&
+            position.result.openQuestion === undefined
+            ? "complete"
+            : "partial",
+        result: position.result,
+        covered: position.nextRecordIndex,
+        uncovered: capture.totalRecords - position.nextRecordIndex,
+        completedBatchCount: position.batchIndex + 1,
+        nextRecordIndex: position.nextRecordIndex,
+    };
+}

package/dist/src/chats/analysis-contract.d.ts

@@ -0,0 +1,80 @@
+import type { MessageRecord } from "./normalize.ts";
+import type { ImportStructure, OccurrenceReference } from "./structure.ts";
+export declare const analysisCodes: readonly ["not-plain-data", "unknown-version", "invalid-shape", "unknown-kind", "unknown-decision-type", "invalid-question", "question-without-conflict", "missing-source", "unknown-source", "copy-only", "insufficient-repetition", "invalid-loop-limit", "gate-on-non-gate", "authority-field"];
+export type AnalysisCode = (typeof analysisCodes)[number];
+export type ClaimKind = "explicit-human-instruction" | "observed-repetition" | "assistant-claim" | "exception" | "rejected-approach" | "uncertain-inference";
+export type StageActivity = "work" | "routine-repair" | "accidental-interruption" | "tool-imposed-confirmation";
+export type DecisionType = "design-decision" | "configured-action-approval" | "factual-input";
+export interface AnalysisItem {
+    readonly id: string;
+    readonly description: string;
+}
+export interface AnalysisClaim extends AnalysisItem {
+    readonly kind: ClaimKind;
+    readonly sourceRefs: readonly OccurrenceReference[];
+    readonly counterevidenceRefs: readonly OccurrenceReference[];
+}
+export interface AnalysisStage extends AnalysisClaim {
+    readonly activity: StageActivity;
+}
+export interface AnalysisGate extends AnalysisClaim {
+    readonly stageId: string;
+    readonly type: DecisionType;
+}
+export interface AnalysisLoop extends AnalysisClaim {
+    readonly stageIds: readonly string[];
+    readonly maxIterations: number;
+    readonly exitCondition: string;
+    readonly exhaustedStoppingConditionId: string;
+}
+export interface AnalysisBranch extends AnalysisItem {
+    readonly sourceStageId: string;
+    readonly condition: string;
+    readonly targetStageId: string;
+}
+export interface AnalysisNonGate extends AnalysisItem {
+    readonly stageId: string;
+    readonly reason: Exclude<StageActivity, "work">;
+}
+export interface AnalysisProcess {
+    readonly id: string;
+    readonly name: string;
+    readonly scope: string;
+    readonly inputs: readonly AnalysisItem[];
+    readonly stages: readonly AnalysisStage[];
+    readonly branches: readonly AnalysisBranch[];
+    readonly loops: readonly AnalysisLoop[];
+    readonly artifacts: readonly AnalysisItem[];
+    readonly stoppingConditions: readonly AnalysisItem[];
+    readonly gates: readonly AnalysisGate[];
+    readonly nonGates: readonly AnalysisNonGate[];
+}
+export interface AnalysisCandidate {
+    readonly schemaVersion: 1;
+    readonly process: AnalysisProcess;
+    readonly openQuestion?: AnalysisQuestion;
+}
+export interface AnalysisQuestion {
+    readonly claimId: string;
+    readonly description: string;
+    readonly sourceRefs: readonly OccurrenceReference[];
+    readonly choices: readonly AnalysisItem[];
+}
+export interface AnalysisEvidence {
+    readonly records: readonly MessageRecord[];
+    readonly structure: ImportStructure;
+}
+export interface AnalysisResult extends AnalysisCandidate {
+    readonly limitations: {
+        readonly historyCompleteness: "unknown";
+        readonly independentObservations: "not-established";
+        readonly conflictGroups: ImportStructure["conflictGroups"];
+    };
+}
+export type AnalysisValidation = {
+    readonly accepted: true;
+    readonly result: AnalysisResult;
+} | {
+    readonly accepted: false;
+    readonly codes: readonly AnalysisCode[];
+};

package/dist/src/chats/analysis-contract.js

@@ -0,0 +1,16 @@
+export const analysisCodes = [
+    "not-plain-data",
+    "unknown-version",
+    "invalid-shape",
+    "unknown-kind",
+    "unknown-decision-type",
+    "invalid-question",
+    "question-without-conflict",
+    "missing-source",
+    "unknown-source",
+    "copy-only",
+    "insufficient-repetition",
+    "invalid-loop-limit",
+    "gate-on-non-gate",
+    "authority-field",
+];

package/dist/src/chats/analysis-data.d.ts

@@ -0,0 +1,3 @@
+import type { AnalysisCode } from "./analysis-contract.ts";
+export declare function forbiddenAnalysisField(key: string): boolean;
+export declare function inspectAnalysisData(value: unknown): readonly AnalysisCode[];