@openprose/reactor 0.1.0-rc.1

package/dist/cost/index.d.ts

@@ -0,0 +1,49 @@
+import type { ReceiptEventCauseV0, ReceiptRecheckKindV0, ReceiptV0 } from "../receipt";
+export declare const ALLOWED_SURPRISE_CAUSES_V0: readonly ["real-input", "forecast-recheck", "escalation"];
+export type CostRelationshipV0 = "surprise-attribution-complete" | "flat-spend-under-static";
+export type CostEvaluationIssueCodeV0 = "receipt-not-object" | "core-not-object" | "core-event-cause-invalid" | "cost-not-object" | "tokens-not-object" | "tokens-invalid" | "surprise-cause-missing" | "surprise-cause-invalid" | "surprise-cause-multiple" | "surprise-cause-mismatch" | "bootstrap-receipt-count-invalid" | "world-profile-not-static" | "token-bearing-evidence-missing" | "post-bootstrap-fresh-spend";
+export interface CostEvaluationIssueV0 {
+    readonly path: string;
+    readonly code: CostEvaluationIssueCodeV0;
+    readonly message: string;
+    readonly observed: unknown;
+}
+export interface ReceiptCostObservationV0 {
+    readonly path: string;
+    readonly token_bearing: boolean;
+    readonly fresh: number;
+    readonly reused: number;
+    readonly surprise_cause: ReceiptEventCauseV0;
+    readonly recheck_kind: ReceiptRecheckKindV0 | null;
+    readonly content_hash: string | null;
+}
+export interface ReceiptSurpriseAttributionCheckV0 {
+    readonly ok: boolean;
+    readonly issues: readonly CostEvaluationIssueV0[];
+    readonly observation: ReceiptCostObservationV0 | null;
+}
+export interface CostRelationshipEvaluationV0 {
+    readonly ok: boolean;
+    readonly relationship: CostRelationshipV0;
+    readonly summary: string;
+    readonly issues: readonly CostEvaluationIssueV0[];
+    readonly checked: {
+        readonly receipts: number;
+        readonly token_bearing_receipts: number;
+        readonly post_bootstrap_token_bearing_receipts: number;
+        readonly plan_age_audit_floor_receipts: number;
+    };
+}
+export interface FlatSpendUnderStaticInputV0 {
+    readonly receipts: readonly unknown[];
+    readonly bootstrap_receipt_count?: number;
+    readonly world_profile?: string;
+}
+export declare function isAllowedSurpriseCauseV0(value: unknown): value is ReceiptEventCauseV0;
+export declare function isTokenBearingReceiptV0(receipt: Pick<ReceiptV0, "cost">): boolean;
+export declare function validateReceiptSurpriseAttributionV0(receipt: unknown, path?: string): ReceiptSurpriseAttributionCheckV0;
+export declare const validateReceiptSurpriseCauseV0: typeof validateReceiptSurpriseAttributionV0;
+export declare function evaluateSurpriseAttributionCompleteV0(receipts: readonly unknown[]): CostRelationshipEvaluationV0;
+export declare function evaluateFlatSpendUnderStaticV0(input: FlatSpendUnderStaticInputV0): CostRelationshipEvaluationV0;
+export declare function isPlanAgeAuditObservationV0(observation: Pick<ReceiptCostObservationV0, "surprise_cause" | "recheck_kind">): boolean;
+//# sourceMappingURL=index.d.ts.map

package/dist/cost/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cost/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,oBAAoB,EACpB,SAAS,EACV,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,0BAA0B,2DAIa,CAAC;AAErD,MAAM,MAAM,kBAAkB,GAC1B,+BAA+B,GAC/B,yBAAyB,CAAC;AAE9B,MAAM,MAAM,yBAAyB,GACjC,oBAAoB,GACpB,iBAAiB,GACjB,0BAA0B,GAC1B,iBAAiB,GACjB,mBAAmB,GACnB,gBAAgB,GAChB,wBAAwB,GACxB,wBAAwB,GACxB,yBAAyB,GACzB,yBAAyB,GACzB,iCAAiC,GACjC,0BAA0B,GAC1B,gCAAgC,GAChC,4BAA4B,CAAC;AAEjC,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,yBAAyB,CAAC;IACzC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,cAAc,EAAE,mBAAmB,CAAC;IAC7C,QAAQ,CAAC,YAAY,EAAE,oBAAoB,GAAG,IAAI,CAAC;IACnD,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CACtC;AAED,MAAM,WAAW,iCAAiC;IAChD,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAClD,QAAQ,CAAC,WAAW,EAAE,wBAAwB,GAAG,IAAI,CAAC;CACvD;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,YAAY,EAAE,kBAAkB,CAAC;IAC1C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAClD,QAAQ,CAAC,OAAO,EAAE;QAChB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;QACxC,QAAQ,CAAC,qCAAqC,EAAE,MAAM,CAAC;QACvD,QAAQ,CAAC,6BAA6B,EAAE,MAAM,CAAC;KAChD,CAAC;CACH;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAC;IACtC,QAAQ,CAAC,uBAAuB,CAAC,EAAE,MAAM,CAAC;IAC1C,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACjC;AAUD,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,mBAAmB,CAK9B;AAED,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,GAC/B,OAAO,CAET;AAED,wBAAgB,oCAAoC,CAClD,OAAO,EAAE,OAAO,EAChB,IAAI,SAAY,GACf,iCAAiC,CAqEnC;AAED,eAAO,MAAM,8BAA8B,6CACL,CAAC;AAEvC,wBAAgB,qCAAqC,CACnD,QAAQ,EAAE,SAAS,OAAO,EAAE,GAC3B,4BAA4B,CAkC9B;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,2BAA2B,GACjC,4BAA4B,CA4F9B;AAED,wBAAgB,2BAA2B,CACzC,WAAW,EAAE,IAAI,CACf,wBAAwB,EACxB,gBAAgB,GAAG,cAAc,CAClC,GACA,OAAO,CAKT"}

package/dist/cost/index.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateReceiptSurpriseCauseV0 = exports.ALLOWED_SURPRISE_CAUSES_V0 = void 0;
+exports.isAllowedSurpriseCauseV0 = isAllowedSurpriseCauseV0;
+exports.isTokenBearingReceiptV0 = isTokenBearingReceiptV0;
+exports.validateReceiptSurpriseAttributionV0 = validateReceiptSurpriseAttributionV0;
+exports.evaluateSurpriseAttributionCompleteV0 = evaluateSurpriseAttributionCompleteV0;
+exports.evaluateFlatSpendUnderStaticV0 = evaluateFlatSpendUnderStaticV0;
+exports.isPlanAgeAuditObservationV0 = isPlanAgeAuditObservationV0;
+exports.ALLOWED_SURPRISE_CAUSES_V0 = Object.freeze([
+    "real-input",
+    "forecast-recheck",
+    "escalation",
+]);
+const ALLOWED_SURPRISE_CAUSE_SET = new Set(exports.ALLOWED_SURPRISE_CAUSES_V0);
+const ALLOWED_RECHECK_KIND_SET = new Set([
+    "evidence-age",
+    "plan-age",
+]);
+function isAllowedSurpriseCauseV0(value) {
+    return (typeof value === "string" &&
+        ALLOWED_SURPRISE_CAUSE_SET.has(value));
+}
+function isTokenBearingReceiptV0(receipt) {
+    return receipt.cost.tokens.fresh + receipt.cost.tokens.reused > 0;
+}
+function validateReceiptSurpriseAttributionV0(receipt, path = "receipt") {
+    const issues = [];
+    if (!isRecord(receipt)) {
+        return {
+            ok: false,
+            issues: [
+                issue(path, "receipt-not-object", "receipt must be an object before cost attribution can be evaluated", receipt),
+            ],
+            observation: null,
+        };
+    }
+    const cost = readRecord(receipt, "cost", path, "cost-not-object", issues);
+    const core = readRecord(receipt, "core", path, "core-not-object", issues);
+    if (cost === undefined || core === undefined) {
+        return { ok: false, issues: Object.freeze([...issues]), observation: null };
+    }
+    const tokenSpend = readTokenSpend(cost, `${path}.cost`, issues);
+    const coreEventCause = readCoreEventCause(core, `${path}.core`, issues);
+    const surpriseCause = readExactlyOneSurpriseCause(cost, `${path}.cost`, issues);
+    if (surpriseCause !== undefined &&
+        coreEventCause !== undefined &&
+        surpriseCause !== coreEventCause) {
+        issues.push(issue(`${path}.cost.surprise_cause`, "surprise-cause-mismatch", "cost.surprise_cause must match receipt core.event_cause", { surprise_cause: surpriseCause, event_cause: coreEventCause }));
+    }
+    const recheckKind = readRecheckKind(core, `${path}.core`);
+    if (tokenSpend === undefined ||
+        surpriseCause === undefined ||
+        coreEventCause === undefined) {
+        return { ok: false, issues: Object.freeze([...issues]), observation: null };
+    }
+    const observation = {
+        path: `${path}.cost`,
+        token_bearing: tokenSpend.fresh + tokenSpend.reused > 0,
+        fresh: tokenSpend.fresh,
+        reused: tokenSpend.reused,
+        surprise_cause: surpriseCause,
+        recheck_kind: recheckKind,
+        content_hash: typeof receipt["content_hash"] === "string" ? receipt["content_hash"] : null,
+    };
+    return {
+        ok: issues.length === 0,
+        issues: Object.freeze([...issues]),
+        observation,
+    };
+}
+exports.validateReceiptSurpriseCauseV0 = validateReceiptSurpriseAttributionV0;
+function evaluateSurpriseAttributionCompleteV0(receipts) {
+    const checks = receipts.map((receipt, index) => validateReceiptSurpriseAttributionV0(receipt, `receipts[${index}]`));
+    const observations = checks.flatMap((check) => check.observation === null ? [] : [check.observation]);
+    const tokenBearing = observations.filter((observation) => observation.token_bearing);
+    const issues = checks.flatMap((check) => check.issues);
+    if (tokenBearing.length === 0) {
+        issues.push(issue("receipts", "token-bearing-evidence-missing", "surprise attribution needs at least one token-bearing receipt", { receipts: receipts.length }));
+    }
+    return relationshipResult("surprise-attribution-complete", issues.length === 0
+        ? "all token-bearing receipts name exactly one allowed surprise cause"
+        : "one or more token-bearing receipts failed surprise attribution", receipts.length, tokenBearing.length, 0, 0, issues);
+}
+function evaluateFlatSpendUnderStaticV0(input) {
+    const issues = [];
+    const bootstrapReceiptCount = input.bootstrap_receipt_count ?? 1;
+    if (!Number.isSafeInteger(bootstrapReceiptCount) ||
+        bootstrapReceiptCount < 0) {
+        issues.push(issue("bootstrap_receipt_count", "bootstrap-receipt-count-invalid", "bootstrap_receipt_count must be a non-negative safe integer", bootstrapReceiptCount));
+    }
+    if (input.world_profile !== undefined &&
+        input.world_profile !== "static") {
+        issues.push(issue("world_profile", "world-profile-not-static", "flat-spend-under-static only applies to static world runs", input.world_profile));
+    }
+    const checks = input.receipts.map((receipt, index) => validateReceiptSurpriseAttributionV0(receipt, `receipts[${index}]`));
+    issues.push(...checks.flatMap((check) => check.issues));
+    const observations = checks.flatMap((check) => check.observation === null ? [] : [check.observation]);
+    const tokenBearing = observations.filter((observation) => observation.token_bearing);
+    const safeBootstrapReceiptCount = Number.isSafeInteger(bootstrapReceiptCount) && bootstrapReceiptCount >= 0
+        ? bootstrapReceiptCount
+        : 0;
+    const postBootstrap = tokenBearing.slice(safeBootstrapReceiptCount);
+    if (tokenBearing.length === 0) {
+        issues.push(issue("receipts", "token-bearing-evidence-missing", "flat-spend-under-static needs token-bearing receipt evidence", { receipts: input.receipts.length }));
+    }
+    for (const observation of postBootstrap) {
+        if (observation.fresh === 0 || isPlanAgeAuditObservationV0(observation)) {
+            continue;
+        }
+        issues.push(issue(`${observation.path}.tokens.fresh`, "post-bootstrap-fresh-spend", "post-bootstrap static-world fresh spend must stay flat except plan-age audit receipts", {
+            fresh: observation.fresh,
+            reused: observation.reused,
+            surprise_cause: observation.surprise_cause,
+            recheck_kind: observation.recheck_kind,
+            content_hash: observation.content_hash,
+        }));
+    }
+    return relationshipResult("flat-spend-under-static", issues.length === 0
+        ? "static-world post-bootstrap fresh spend stayed flat apart from the plan-age audit floor"
+        : "static-world post-bootstrap fresh spend increased outside the plan-age audit floor", input.receipts.length, tokenBearing.length, postBootstrap.length, postBootstrap.filter(isPlanAgeAuditObservationV0).length, issues);
+}
+function isPlanAgeAuditObservationV0(observation) {
+    return (observation.surprise_cause === "forecast-recheck" &&
+        observation.recheck_kind === "plan-age");
+}
+function relationshipResult(relationship, summary, receiptCount, tokenBearingReceiptCount, postBootstrapTokenBearingReceiptCount, planAgeAuditFloorReceiptCount, issues) {
+    return {
+        ok: issues.length === 0,
+        relationship,
+        summary,
+        issues: Object.freeze([...issues]),
+        checked: {
+            receipts: receiptCount,
+            token_bearing_receipts: tokenBearingReceiptCount,
+            post_bootstrap_token_bearing_receipts: postBootstrapTokenBearingReceiptCount,
+            plan_age_audit_floor_receipts: planAgeAuditFloorReceiptCount,
+        },
+    };
+}
+function readRecord(record, key, path, code, issues) {
+    const value = record[key];
+    if (!isRecord(value)) {
+        issues.push(issue(`${path}.${key}`, code, `${path}.${key} must be an object`, value));
+        return undefined;
+    }
+    return value;
+}
+function readTokenSpend(cost, path, issues) {
+    const tokens = cost["tokens"];
+    if (!isRecord(tokens)) {
+        issues.push(issue(`${path}.tokens`, "tokens-not-object", "cost.tokens must carry fresh and reused token counts", tokens));
+        return undefined;
+    }
+    const fresh = tokens["fresh"];
+    const reused = tokens["reused"];
+    if (!isNonNegativeSafeInteger(fresh) || !isNonNegativeSafeInteger(reused)) {
+        issues.push(issue(`${path}.tokens`, "tokens-invalid", "cost.tokens.fresh and cost.tokens.reused must be non-negative safe integers", { fresh, reused }));
+        return undefined;
+    }
+    return { fresh, reused };
+}
+function readCoreEventCause(core, path, issues) {
+    const eventCause = core["event_cause"];
+    if (!isAllowedSurpriseCauseV0(eventCause)) {
+        issues.push(issue(`${path}.event_cause`, "core-event-cause-invalid", "core.event_cause must be one of the allowed surprise causes", eventCause));
+        return undefined;
+    }
+    return eventCause;
+}
+function readExactlyOneSurpriseCause(cost, path, issues) {
+    if (!Object.hasOwn(cost, "surprise_cause")) {
+        issues.push(issue(`${path}.surprise_cause`, "surprise-cause-missing", "cost.surprise_cause is required for receipt v0 cost attribution", null));
+        return undefined;
+    }
+    const surpriseCause = cost["surprise_cause"];
+    if (Array.isArray(surpriseCause) || Object.hasOwn(cost, "surprise_causes")) {
+        issues.push(issue(`${path}.surprise_cause`, "surprise-cause-multiple", "receipt v0 cost attribution must name exactly one surprise cause", {
+            surprise_cause: surpriseCause,
+            surprise_causes: cost["surprise_causes"] ?? null,
+        }));
+        return undefined;
+    }
+    if (!isAllowedSurpriseCauseV0(surpriseCause)) {
+        issues.push(issue(`${path}.surprise_cause`, "surprise-cause-invalid", "cost.surprise_cause must be one of real-input, forecast-recheck, escalation", surpriseCause));
+        return undefined;
+    }
+    return surpriseCause;
+}
+function readRecheckKind(core, path) {
+    const recheckKind = core["recheck_kind"];
+    if (typeof recheckKind === "string" &&
+        ALLOWED_RECHECK_KIND_SET.has(recheckKind)) {
+        return recheckKind;
+    }
+    return null;
+}
+function issue(path, code, message, observed) {
+    return { path, code, message, observed };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonNegativeSafeInteger(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}

package/dist/evidence-plan/index.d.ts

@@ -0,0 +1,57 @@
+import { type ContentHashV0, type ReceiptV0 } from "../receipt";
+export type EvidenceSourceKind = "adapter" | "forecast" | "dependency";
+export type EvidenceReceiptOrder = "unordered" | "declared";
+export type DeepRoamTrigger = "confidence-escalation" | "stakes-escalation" | "forecast-evidence-age" | "forecast-plan-age" | "no-anchor-forced-deep" | "degraded-calibration";
+export interface CompiledEvidenceSource {
+    readonly id: string;
+    readonly kind: EvidenceSourceKind;
+    readonly required: boolean;
+    readonly receipt_order?: EvidenceReceiptOrder;
+}
+export interface CompiledEvidencePlan {
+    readonly responsibility_id: string;
+    readonly contract_revision: ContentHashV0;
+    readonly policy_artifact_namespace: string;
+    readonly policy_artifact_revision: string;
+    readonly plan_revision: string;
+    readonly as_of: string;
+    readonly evidence_order: EvidenceReceiptOrder;
+    readonly sources: readonly CompiledEvidenceSource[];
+}
+export interface EvidenceReceiptRef {
+    readonly source_id: string;
+    readonly receipt_hash: ContentHashV0;
+}
+export type EvidenceSourceCollector = (source: CompiledEvidenceSource) => ReceiptV0 | undefined;
+export type ShallowEvidencePlanResult = {
+    readonly outcome: "ready";
+    readonly consulted_source_ids: readonly string[];
+    readonly evidence_receipts: readonly EvidenceReceiptRef[];
+    readonly canonical_evidence_receipts: readonly EvidenceReceiptRef[];
+} | {
+    readonly outcome: "fail-safe";
+    readonly consulted_source_ids: readonly string[];
+    readonly reason: string;
+    readonly receipt: ReceiptV0;
+};
+export interface DeepRoamDiscovery {
+    readonly source_id: string;
+    readonly kind: EvidenceSourceKind;
+    readonly receipt_hash?: ContentHashV0;
+}
+export type DeepRoamReconciliation = {
+    readonly outcome: "plan-confirmed";
+    readonly trigger: DeepRoamTrigger;
+    readonly confirmed_source_ids: readonly string[];
+} | {
+    readonly outcome: "force-recompile";
+    readonly trigger: DeepRoamTrigger;
+    readonly discovered_source_ids: readonly string[];
+    readonly discovered_receipt_hashes: readonly ContentHashV0[];
+    readonly reason: string;
+};
+export declare function executeShallowEvidencePlan(plan: CompiledEvidencePlan, collectors: Readonly<Record<string, EvidenceSourceCollector>>): ShallowEvidencePlanResult;
+export declare function reconcileDeepRoam(plan: CompiledEvidencePlan, trigger: DeepRoamTrigger, discoveries: readonly DeepRoamDiscovery[]): DeepRoamReconciliation;
+export declare function canonicalizeEvidenceReceiptRefsForPlan(plan: Pick<CompiledEvidencePlan, "evidence_order">, refs: readonly EvidenceReceiptRef[]): readonly EvidenceReceiptRef[];
+export declare function validateCompiledEvidencePlan(plan: CompiledEvidencePlan): readonly string[];
+//# sourceMappingURL=index.d.ts.map

package/dist/evidence-plan/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/evidence-plan/index.ts"],"names":[],"mappings":"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"}

package/dist/evidence-plan/index.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeShallowEvidencePlan = executeShallowEvidencePlan;
+exports.reconcileDeepRoam = reconcileDeepRoam;
+exports.canonicalizeEvidenceReceiptRefsForPlan = canonicalizeEvidenceReceiptRefsForPlan;
+exports.validateCompiledEvidencePlan = validateCompiledEvidencePlan;
+const kernel_1 = require("../kernel");
+const receipt_1 = require("../receipt");
+function executeShallowEvidencePlan(plan, collectors) {
+    const validation = validateCompiledEvidencePlan(plan);
+    if (validation.length > 0) {
+        return failSafe(plan, [], validation.join("; "));
+    }
+    const consultedSourceIds = [];
+    const evidenceReceipts = [];
+    for (const source of plan.sources) {
+        consultedSourceIds.push(source.id);
+        const collector = collectors[source.id];
+        if (collector === undefined) {
+            if (!source.required) {
+                continue;
+            }
+            return failSafe(plan, consultedSourceIds, `planned source ${source.id} has no collector`);
+        }
+        const receipt = collector(source);
+        if (receipt === undefined) {
+            if (!source.required) {
+                continue;
+            }
+            return failSafe(plan, consultedSourceIds, `planned source ${source.id} produced no receipt`);
+        }
+        const verification = (0, receipt_1.verifyReceiptV0)(receipt);
+        if (!verification.ok) {
+            return failSafe(plan, consultedSourceIds, `planned source ${source.id} produced an unverifiable receipt`);
+        }
+        evidenceReceipts.push({
+            source_id: source.id,
+            receipt_hash: verification.content_hash,
+        });
+    }
+    const canonicalEvidenceReceipts = canonicalizeEvidenceReceiptRefsForPlan(plan, evidenceReceipts);
+    return {
+        outcome: "ready",
+        consulted_source_ids: consultedSourceIds,
+        evidence_receipts: evidenceReceipts,
+        canonical_evidence_receipts: canonicalEvidenceReceipts,
+    };
+}
+function reconcileDeepRoam(plan, trigger, discoveries) {
+    const plannedSourceIds = new Set(plan.sources.map((source) => source.id));
+    const discovered = discoveries.filter((discovery) => !plannedSourceIds.has(discovery.source_id));
+    if (discovered.length === 0) {
+        return {
+            outcome: "plan-confirmed",
+            trigger,
+            confirmed_source_ids: plan.sources.map((source) => source.id),
+        };
+    }
+    return {
+        outcome: "force-recompile",
+        trigger,
+        discovered_source_ids: discovered.map((discovery) => discovery.source_id),
+        discovered_receipt_hashes: discovered.flatMap((discovery) => discovery.receipt_hash === undefined ? [] : [discovery.receipt_hash]),
+        reason: "deep roaming discovered evidence outside the compiled plan",
+    };
+}
+function canonicalizeEvidenceReceiptRefsForPlan(plan, refs) {
+    const seen = new Set();
+    for (const ref of refs) {
+        if (seen.has(ref.receipt_hash)) {
+            throw new Error(`duplicate evidence receipt ref ${ref.receipt_hash}`);
+        }
+        seen.add(ref.receipt_hash);
+    }
+    if (plan.evidence_order === "declared") {
+        return [...refs];
+    }
+    return [...refs].sort((left, right) => left.receipt_hash.localeCompare(right.receipt_hash));
+}
+function validateCompiledEvidencePlan(plan) {
+    const errors = [];
+    if (plan.responsibility_id.length === 0) {
+        errors.push("plan.responsibility_id must be non-empty");
+    }
+    if (!isContentHash(plan.contract_revision)) {
+        errors.push("plan.contract_revision must be a sha256 content address");
+    }
+    if (plan.policy_artifact_namespace.length === 0) {
+        errors.push("plan.policy_artifact_namespace must be non-empty");
+    }
+    if (plan.policy_artifact_revision.length === 0) {
+        errors.push("plan.policy_artifact_revision must be non-empty");
+    }
+    if (plan.plan_revision.length === 0) {
+        errors.push("plan.plan_revision must be non-empty");
+    }
+    if (!isReplayableInstant(plan.as_of)) {
+        errors.push("plan.as_of must be a replayable ISO instant");
+    }
+    if (plan.evidence_order !== "unordered" && plan.evidence_order !== "declared") {
+        errors.push("plan.evidence_order is malformed");
+    }
+    const seenSourceIds = new Set();
+    for (const source of plan.sources) {
+        if (source.id.length === 0) {
+            errors.push("source.id must be non-empty");
+        }
+        if (seenSourceIds.has(source.id)) {
+            errors.push(`source ${source.id} is duplicated`);
+        }
+        seenSourceIds.add(source.id);
+        if (source.kind !== "adapter" &&
+            source.kind !== "forecast" &&
+            source.kind !== "dependency") {
+            errors.push(`source ${source.id} has malformed kind`);
+        }
+        if (typeof source.required !== "boolean") {
+            errors.push(`source ${source.id} required flag is malformed`);
+        }
+        if (source.receipt_order !== undefined &&
+            source.receipt_order !== "unordered" &&
+            source.receipt_order !== "declared") {
+            errors.push(`source ${source.id} receipt_order is malformed`);
+        }
+    }
+    return errors;
+}
+function failSafe(plan, consultedSourceIds, reason) {
+    return {
+        outcome: "fail-safe",
+        consulted_source_ids: consultedSourceIds,
+        reason,
+        receipt: (0, kernel_1.createKernelSafetyReceipt)({
+            responsibility_id: plan.responsibility_id,
+            contract_revision: plan.contract_revision,
+            memo_key: `evidence-plan-fail-safe:${plan.policy_artifact_namespace}:${plan.plan_revision}`,
+            evidence_input_ids: [failSafeEvidenceInputId(plan, consultedSourceIds, reason)],
+            as_of: plan.as_of,
+            reason,
+            fix_target: "policy-artifact",
+            interrupt_cause: "needs-judgment",
+            event_cause: "escalation",
+        }),
+    };
+}
+function failSafeEvidenceInputId(plan, consultedSourceIds, reason) {
+    return (0, receipt_1.hashCanonicalReceiptV0)((0, receipt_1.canonicalizeForReceiptV0)({
+        schema: "openprose.evidence-plan.fail-safe-input",
+        v: 0,
+        contract_revision: plan.contract_revision,
+        policy_artifact_namespace: plan.policy_artifact_namespace,
+        policy_artifact_revision: plan.policy_artifact_revision,
+        plan_revision: plan.plan_revision,
+        consulted_source_ids: consultedSourceIds,
+        reason,
+        as_of: plan.as_of,
+    }));
+}
+function isContentHash(value) {
+    return /^sha256:[a-f0-9]{64}$/.test(value);
+}
+function isReplayableInstant(value) {
+    return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/.test(value);
+}

package/dist/forecast/index.d.ts

@@ -0,0 +1,39 @@
+import { type ContentHashV0, type ReceiptRecheckKindV0, type ReceiptV0 } from "../receipt";
+export interface ForecastScheduleStateV0 {
+    readonly responsibility_id: string;
+    readonly contract_revision: ContentHashV0;
+    readonly memo_key: string;
+    readonly evidence_input_ids: readonly ContentHashV0[];
+    readonly next_evidence_recheck: string;
+    readonly next_plan_recheck: string;
+}
+export interface ForecastScheduleInputV0 {
+    readonly as_of: string;
+    readonly schedule: ForecastScheduleStateV0;
+    readonly real_input_observed: boolean;
+}
+export type ForecastScheduleResultV0 = {
+    readonly outcome: "sleep";
+    readonly next_due_at: string;
+    readonly token_bearing_receipts: readonly ReceiptV0[];
+    readonly due_rechecks: readonly ReceiptRecheckKindV0[];
+} | {
+    readonly outcome: "manufacture-recheck";
+    readonly next_due_at?: string;
+    readonly receipts: readonly ReceiptV0[];
+    readonly token_bearing_receipts: readonly ReceiptV0[];
+    readonly due_rechecks: readonly ReceiptRecheckKindV0[];
+    readonly reason: "forecast-clock-crossed" | "adversarial-silent";
+};
+export declare function evaluateForecastScheduleV0(input: ForecastScheduleInputV0): ForecastScheduleResultV0;
+export interface ForecastRecheckReceiptInputV0 {
+    readonly responsibility_id: string;
+    readonly contract_revision: ContentHashV0;
+    readonly memo_key: string;
+    readonly evidence_input_ids: readonly ContentHashV0[];
+    readonly as_of: string;
+    readonly recheck_kind: ReceiptRecheckKindV0;
+}
+export declare function createForecastRecheckReceiptV0(input: ForecastRecheckReceiptInputV0): ReceiptV0;
+export declare function tokenBearingReceipts(receipts: readonly ReceiptV0[]): readonly ReceiptV0[];
+//# sourceMappingURL=index.d.ts.map

package/dist/forecast/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/forecast/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,SAAS,EAGf,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,iBAAiB,EAAE,aAAa,CAAC;IAC1C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,kBAAkB,EAAE,SAAS,aAAa,EAAE,CAAC;IACtD,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAC;IACvC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;CACpC;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,uBAAuB,CAAC;IAC3C,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;CACvC;AAED,MAAM,MAAM,wBAAwB,GAChC;IACE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,sBAAsB,EAAE,SAAS,SAAS,EAAE,CAAC;IACtD,QAAQ,CAAC,YAAY,EAAE,SAAS,oBAAoB,EAAE,CAAC;CACxD,GACD;IACE,QAAQ,CAAC,OAAO,EAAE,qBAAqB,CAAC;IACxC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,SAAS,SAAS,EAAE,CAAC;IACxC,QAAQ,CAAC,sBAAsB,EAAE,SAAS,SAAS,EAAE,CAAC;IACtD,QAAQ,CAAC,YAAY,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACvD,QAAQ,CAAC,MAAM,EAAE,wBAAwB,GAAG,oBAAoB,CAAC;CAClE,CAAC;AAEN,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,uBAAuB,GAC7B,wBAAwB,CAqC1B;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,iBAAiB,EAAE,aAAa,CAAC;IAC1C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,kBAAkB,EAAE,SAAS,aAAa,EAAE,CAAC;IACtD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,YAAY,EAAE,oBAAoB,CAAC;CAC7C;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,6BAA6B,GACnC,SAAS,CA+CX;AAED,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,SAAS,SAAS,EAAE,GAC7B,SAAS,SAAS,EAAE,CAItB"}

package/dist/forecast/index.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateForecastScheduleV0 = evaluateForecastScheduleV0;
+exports.createForecastRecheckReceiptV0 = createForecastRecheckReceiptV0;
+exports.tokenBearingReceipts = tokenBearingReceipts;
+const receipt_1 = require("../receipt");
+function evaluateForecastScheduleV0(input) {
+    const asOfMs = parseInstantMs(input.as_of, "as_of");
+    const dueRechecks = dueRecheckKinds(input.schedule, asOfMs);
+    if (dueRechecks.length === 0) {
+        return {
+            outcome: "sleep",
+            next_due_at: earliestInstant([
+                input.schedule.next_evidence_recheck,
+                input.schedule.next_plan_recheck,
+            ]),
+            token_bearing_receipts: [],
+            due_rechecks: [],
+        };
+    }
+    const receipts = dueRechecks.map((recheckKind) => createForecastRecheckReceiptV0({
+        responsibility_id: input.schedule.responsibility_id,
+        contract_revision: input.schedule.contract_revision,
+        memo_key: input.schedule.memo_key,
+        evidence_input_ids: input.schedule.evidence_input_ids,
+        as_of: input.as_of,
+        recheck_kind: recheckKind,
+    }));
+    const nextDueAt = nextDueAfter(input.schedule, dueRechecks);
+    return {
+        outcome: "manufacture-recheck",
+        ...(nextDueAt === undefined ? {} : { next_due_at: nextDueAt }),
+        receipts,
+        token_bearing_receipts: tokenBearingReceipts(receipts),
+        due_rechecks: dueRechecks,
+        reason: input.real_input_observed ? "forecast-clock-crossed" : "adversarial-silent",
+    };
+}
+function createForecastRecheckReceiptV0(input) {
+    return (0, receipt_1.createReceiptV0)({
+        core: {
+            responsibility_id: input.responsibility_id,
+            contract_revision: input.contract_revision,
+            event_cause: "forecast-recheck",
+            recheck_kind: input.recheck_kind,
+            memo_key: input.memo_key,
+            evidence_input_ids: input.evidence_input_ids,
+            as_of: input.as_of,
+            role: "judge",
+        },
+        sig: (0, receipt_1.createNullSignerReceiptSignatureV0)(),
+        verdict: {
+            status: "blocked",
+            confidence: {
+                value: 0,
+                derivation_method: "forecast-gated-synthetic-input",
+                calibration_grade: "none",
+                label_source: "forecast-clock",
+            },
+            blocked: {
+                reason: `forecast-${input.recheck_kind}-recheck-required`,
+                fix_target: "judge",
+                interrupt_cause: "needs-judgment",
+            },
+        },
+        freshness: {
+            as_of: input.as_of,
+            next_forecast_recheck: input.as_of,
+        },
+        composition: {
+            consumed_receipts: [],
+            cycle_checked: true,
+        },
+        cost: {
+            provider: "forecast",
+            model: "deterministic-scheduler",
+            role: "judge",
+            tags: ["forecast-recheck", input.recheck_kind],
+            responsibility_id: input.responsibility_id,
+            run_id: `forecast-${input.recheck_kind}-${input.as_of}`,
+            as_of: input.as_of,
+            tokens: { fresh: 0, reused: 0 },
+            surprise_cause: "forecast-recheck",
+        },
+    });
+}
+function tokenBearingReceipts(receipts) {
+    return receipts.filter((receipt) => receipt.cost.tokens.fresh + receipt.cost.tokens.reused > 0);
+}
+function dueRecheckKinds(schedule, asOfMs) {
+    const due = [];
+    if (parseInstantMs(schedule.next_evidence_recheck, "next_evidence_recheck") <= asOfMs) {
+        due.push("evidence-age");
+    }
+    if (parseInstantMs(schedule.next_plan_recheck, "next_plan_recheck") <= asOfMs) {
+        due.push("plan-age");
+    }
+    return due;
+}
+function earliestInstant(values) {
+    return [...values].sort((left, right) => parseInstantMs(left, left) - parseInstantMs(right, right))[0] ?? "";
+}
+function nextDueAfter(schedule, dueRechecks) {
+    const candidates = [];
+    if (!dueRechecks.includes("evidence-age")) {
+        candidates.push(schedule.next_evidence_recheck);
+    }
+    if (!dueRechecks.includes("plan-age")) {
+        candidates.push(schedule.next_plan_recheck);
+    }
+    return candidates.length === 0 ? undefined : earliestInstant(candidates);
+}
+function parseInstantMs(value, name) {
+    const parsed = Date.parse(value);
+    if (!Number.isFinite(parsed)) {
+        throw new Error(`${name} must be a replayable instant`);
+    }
+    return parsed;
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./receipt";
+export * from "./cost";
+export * from "./kernel";
+export * from "./evidence-plan";
+export * from "./memo";
+export * from "./forecast";
+export * from "./sdk";
+export * from "./reactor";
+export * from "./judge";
+export * from "./adapters";
+export * from "./policy";
+export * from "./composition";
+export * from "./projection";
+//# sourceMappingURL=index.d.ts.map