martin-loop 0.1.4 → 1.3.0

package/dist/vendor/core/index.js

@@ -5,12 +5,15 @@ import { evaluateChangeApprovalLeash, evaluateFilesystemLeash, evaluateSecretLea
 import { buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations } from "./grounding.js";
 import { captureRollbackBoundary, restoreRollbackBoundary } from "./rollback.js";
 import { compilePromptPacket } from "./compiler.js";
-import { makeLedgerEvent } from "./persistence/index.js";
+import { makeLedgerEvent, resolveRunsRoot, runDir } from "./persistence/index.js";
+import { runContextIntegrityPrecheck } from "./context-integrity.js";
 export { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, nextPolicyPhase, policyPhaseToLifecycleState, scorePatchDecision, selectRecoveryRecipe, evaluateVerificationLeash, evaluateFilesystemLeash, evaluateChangeApprovalLeash, evaluateSecretLeash, resolveExecutionProfile, redactSecretsFromText, buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations, captureRollbackBoundary, restoreRollbackBoundary };
+// ─── Context Integrity Pre-gate ──────────────────────────────────────────────
+export { runContextIntegrityPrecheck } from "./context-integrity.js";
 // ─── Prompt packet compiler ──────────────────────────────────────────────────
 export { compilePromptPacket } from "./compiler.js";
 // ─── Persistence (RunStore, LedgerEvent, FileRunStore) ──────────────────────
-export { createFileRunStore, makeLedgerEvent, resolveRunsRoot } from "./persistence/index.js";
+export { createFileRunStore, makeLedgerEvent, readAllLoopRecords, readLatestLoopRecord, readLatestLoopRecordFromFile, readLoopRecordsFromFile, resolveRunsRoot } from "./persistence/index.js";
 export { compileAndPersistContext } from "./persistence/index.js";
 /**
  * Admission gate — must pass before any attempt is executed.
@@ -126,6 +129,7 @@ export async function runMartin(input) {
             runId: loop.loopId,
             payload: { workspaceId: input.workspaceId, projectId: input.projectId }
         }));
+        await persistLoopRecordIfSupported(input.store, loop);
     }
     const DEFAULT_FALLBACK_MODELS = [
         "claude-haiku-4-5",
@@ -136,6 +140,7 @@ export async function runMartin(input) {
     let currentAdapterIndex = 0;
     let currentAdapter = adapterChain[currentAdapterIndex] ?? input.adapter;
     let useCompressedContext = false;
+    const isVerifyOnly = input.task.mutationMode === "verify_only";
     const executionProfile = resolveExecutionProfile({
         executionProfile: input.task.executionProfile,
         allowedNetworkDomains: input.task.allowedNetworkDomains
@@ -153,7 +158,8 @@ export async function runMartin(input) {
             shouldExit: true,
             lifecycleState: "human_escalation",
             status: "exited",
-            reason
+            reason,
+            ...classifySafetyLeashExit(leashDecision, "verifier")
         };
         if (input.store) {
             await input.store.appendLedger(loop.loopId, makeLedgerEvent({
@@ -169,15 +175,13 @@ export async function runMartin(input) {
             await input.store.appendLedger(loop.loopId, makeLedgerEvent({
                 kind: "run.exited",
                 runId: loop.loopId,
-                payload: {
-                    lifecycleState: leashExitDecision.lifecycleState,
-                    status: leashExitDecision.status,
-                    reason: leashExitDecision.reason
-                }
+                payload: createRunExitPayload(leashExitDecision)
             }));
         }
+        const finalizedLoop = finalizeLoop(loop, leashExitDecision, now(), idFactory);
+        await persistLoopRecordIfSupported(input.store, finalizedLoop);
         return {
-            loop: finalizeLoop(loop, leashExitDecision, now(), idFactory),
+            loop: finalizedLoop,
             decision: leashExitDecision
         };
     }
@@ -193,7 +197,8 @@ export async function runMartin(input) {
             shouldExit: true,
             lifecycleState: "human_escalation",
             status: "exited",
-            reason: secretDecision.reason ?? "Safety leash blocked secret-like values in the runtime context."
+            reason: secretDecision.reason ?? "Safety leash blocked secret-like values in the runtime context.",
+            ...classifySafetyLeashExit(secretDecision, "secret")
         };
         if (input.store) {
             await input.store.appendLedger(loop.loopId, makeLedgerEvent({
@@ -208,15 +213,13 @@ export async function runMartin(input) {
             await input.store.appendLedger(loop.loopId, makeLedgerEvent({
                 kind: "run.exited",
                 runId: loop.loopId,
-                payload: {
-                    lifecycleState: secretExitDecision.lifecycleState,
-                    status: secretExitDecision.status,
-                    reason: secretExitDecision.reason
-                }
+                payload: createRunExitPayload(secretExitDecision)
             }));
         }
+        const finalizedLoop = finalizeLoop(loop, secretExitDecision, now(), idFactory);
+        await persistLoopRecordIfSupported(input.store, finalizedLoop);
         return {
-            loop: finalizeLoop(loop, secretExitDecision, now(), idFactory),
+            loop: finalizedLoop,
             decision: secretExitDecision
         };
     }
@@ -254,20 +257,52 @@ export async function runMartin(input) {
                 await input.store.appendLedger(loop.loopId, makeLedgerEvent({
                     kind: "run.exited",
                     runId: loop.loopId,
-                    payload: {
-                        lifecycleState: preflightExitDecision.lifecycleState,
-                        status: preflightExitDecision.status,
-                        reason: preflightExitDecision.reason
-                    }
+                    payload: createRunExitPayload(preflightExitDecision)
                 }));
             }
+            const finalizedLoop = finalizeLoop(loop, preflightExitDecision, now(), idFactory);
+            await persistLoopRecordIfSupported(input.store, finalizedLoop);
             return {
-                loop: finalizeLoop(loop, preflightExitDecision, now(), idFactory),
+                loop: finalizedLoop,
                 decision: preflightExitDecision
             };
         }
         // GATHER → ADMIT: run admission control before executing
         currentPhase = "ADMIT";
+        // T05: Context Integrity Pre-gate — blocks authority inversion / injection before reasoning
+        const contextPrecheck = await runContextIntegrityPrecheck(loop.loopId, loop.attempts.length + 1, runDir(resolveRunsRoot(), loop.loopId), {
+            userPrompt: distilled.focus,
+            history: loop.attempts.map(a => a.summary).join("\n")
+        });
+        if (contextPrecheck.verdict === "context_poisoning_block") {
+            currentPhase = "ABORT";
+            const poisoningExitDecision = {
+                shouldExit: true,
+                lifecycleState: "human_escalation",
+                status: "exited",
+                reason: "Context Integrity Pre-gate: context poisoning attempt detected.",
+                failureClass: "safety_leash_blocked",
+                safetySurface: "context_integrity",
+                reasonCode: "context_poisoning_blocked"
+            };
+            if (input.store) {
+                await input.store.appendLedger(loop.loopId, makeLedgerEvent({
+                    kind: "safety.violations_found",
+                    runId: loop.loopId,
+                    payload: {
+                        verdict: contextPrecheck.verdict,
+                        signals: contextPrecheck.detectedSignals,
+                        source: "context_integrity_pregate"
+                    }
+                }));
+            }
+            const finalizedLoop = finalizeLoop(loop, poisoningExitDecision, now(), idFactory);
+            await persistLoopRecordIfSupported(input.store, finalizedLoop);
+            return {
+                loop: finalizedLoop,
+                decision: poisoningExitDecision
+            };
+        }
         const admissionDecision = evaluateAttemptPolicy({
             request: {
                 loopId: loop.loopId,
@@ -315,15 +350,13 @@ export async function runMartin(input) {
                 await input.store.appendLedger(loop.loopId, makeLedgerEvent({
                     kind: "run.exited",
                     runId: loop.loopId,
-                    payload: {
-                        lifecycleState: exitDecision.lifecycleState,
-                        status: exitDecision.status,
-                        reason: exitDecision.reason
-                    }
+                    payload: createRunExitPayload(exitDecision)
                 }));
             }
+            const finalizedLoop = finalizeLoop(loop, exitDecision, now(), idFactory);
+            await persistLoopRecordIfSupported(input.store, finalizedLoop);
             return {
-                loop: finalizeLoop(loop, exitDecision, now(), idFactory),
+                loop: finalizedLoop,
                 decision: exitDecision
             };
         }
@@ -361,6 +394,7 @@ export async function runMartin(input) {
                 objective: loop.task.objective,
                 verificationPlan: loop.task.verificationPlan,
                 ...(loop.task.verificationStack ? { verificationStack: loop.task.verificationStack } : {}),
+                ...(loop.task.mutationMode ? { mutationMode: loop.task.mutationMode } : {}),
                 ...(loop.task.repoRoot ? { repoRoot: loop.task.repoRoot } : {}),
                 ...(loop.task.allowedPaths ? { allowedPaths: loop.task.allowedPaths } : {}),
                 ...(loop.task.deniedPaths ? { deniedPaths: loop.task.deniedPaths } : {}),
@@ -539,6 +573,92 @@ export async function runMartin(input) {
         // returned a non-empty list. A repoRoot alone is insufficient — git may fail (e.g. not
         // a git repo) and silently return [], which would falsely trigger no_code_change.
         const changedFileEvidenceAvailable = result.execution?.changedFiles !== undefined || changedFiles.length > 0;
+        if (isVerifyOnly && changedFiles.length > 0) {
+            const patchDecision = evaluatePatchDecision({
+                verificationPassed: result.verification.passed,
+                previousVerifierScore,
+                verifierScore: result.verification.passed ? 1 : 0,
+                scopeViolationCount: changedFiles.length,
+                changedFileCount: changedFiles.length,
+                diffNovelty: 1,
+                diffStats: result.execution?.diffStats,
+                costUsd: getUsageUsd(result.usage),
+                summary: result.summary
+            });
+            const verifyOnlyExitDecision = {
+                shouldExit: true,
+                lifecycleState: "human_escalation",
+                status: "exited",
+                reason: "Verify-only mode forbids file changes.",
+                failureClass: "safety_leash_blocked",
+                safetySurface: "filesystem",
+                reasonCode: "verify_only_write_attempt"
+            };
+            const rollbackOutcome = await restoreRollbackBoundary({
+                repoRoot: request.context.repoRoot,
+                boundary: rollbackBoundary,
+                restoredAt: attemptCompletedAt,
+                decision: patchDecision.decision
+            });
+            if (input.store) {
+                const verifyOnlyViolation = {
+                    kind: "path_not_allowed",
+                    message: `Verify-only mode forbids changed files: ${changedFiles.join(", ")}`,
+                    file: changedFiles[0]
+                };
+                await input.store.writeAttemptArtifacts(loop.loopId, currentAttemptIndex, {
+                    compiledContext,
+                    leash: createLeashArtifact({
+                        surface: "filesystem",
+                        reason: verifyOnlyExitDecision.reason,
+                        violations: [verifyOnlyViolation]
+                    }, currentAttemptIndex),
+                    patchScore: patchDecision.score,
+                    patchDecision: toPatchDecisionArtifact(patchDecision),
+                    ...(rollbackBoundary ? { rollbackBoundary } : {}),
+                    ...(rollbackOutcome ? { rollbackOutcome } : {})
+                });
+                await input.store.appendLedger(loop.loopId, makeLedgerEvent({
+                    kind: "safety.violations_found",
+                    runId: loop.loopId,
+                    attemptIndex: currentAttemptIndex,
+                    payload: {
+                        surface: "filesystem",
+                        blocked: true,
+                        attemptIndex: currentAttemptIndex,
+                        violations: [
+                            {
+                                kind: "path_not_allowed",
+                                message: verifyOnlyExitDecision.reason,
+                                files: changedFiles
+                            }
+                        ]
+                    }
+                }));
+                await input.store.appendLedger(loop.loopId, makeLedgerEvent({
+                    kind: "attempt.discarded",
+                    runId: loop.loopId,
+                    attemptIndex: currentAttemptIndex,
+                    payload: {
+                        decision: patchDecision.decision,
+                        reason: patchDecision.summary,
+                        reasonCodes: patchDecision.reasonCodes,
+                        score: patchDecision.score.score
+                    }
+                }));
+                await input.store.appendLedger(loop.loopId, makeLedgerEvent({
+                    kind: "run.exited",
+                    runId: loop.loopId,
+                    payload: createRunExitPayload(verifyOnlyExitDecision)
+                }));
+            }
+            const finalizedLoop = finalizeLoop(loop, verifyOnlyExitDecision, now(), idFactory);
+            await persistLoopRecordIfSupported(input.store, finalizedLoop);
+            return {
+                loop: finalizedLoop,
+                decision: verifyOnlyExitDecision
+            };
+        }
         const filesystemDecision = evaluateFilesystemLeash({
             repoRoot: request.context.repoRoot,
             changedFiles,
@@ -561,7 +681,8 @@ export async function runMartin(input) {
                 shouldExit: true,
                 lifecycleState: "human_escalation",
                 status: "exited",
-                reason: filesystemDecision.reason ?? "Safety leash blocked filesystem changes."
+                reason: filesystemDecision.reason ?? "Safety leash blocked filesystem changes.",
+                ...classifySafetyLeashExit(filesystemDecision, "filesystem")
             };
             const rollbackOutcome = await restoreRollbackBoundary({
                 repoRoot: request.context.repoRoot,
@@ -603,15 +724,13 @@ export async function runMartin(input) {
                 await input.store.appendLedger(loop.loopId, makeLedgerEvent({
                     kind: "run.exited",
                     runId: loop.loopId,
-                    payload: {
-                        lifecycleState: filesystemExitDecision.lifecycleState,
-                        status: filesystemExitDecision.status,
-                        reason: filesystemExitDecision.reason
-                    }
+                    payload: createRunExitPayload(filesystemExitDecision)
                 }));
             }
+            const finalizedLoop = finalizeLoop(loop, filesystemExitDecision, now(), idFactory);
+            await persistLoopRecordIfSupported(input.store, finalizedLoop);
             return {
-                loop: finalizeLoop(loop, filesystemExitDecision, now(), idFactory),
+                loop: finalizedLoop,
                 decision: filesystemExitDecision
             };
         }
@@ -638,7 +757,8 @@ export async function runMartin(input) {
                 lifecycleState: "human_escalation",
                 status: "exited",
                 reason: changeApprovalDecision.reason ??
-                    "Safety leash blocked dependency or migration changes that require approval."
+                    "Safety leash blocked dependency or migration changes that require approval.",
+                ...classifySafetyLeashExit(changeApprovalDecision, "dependency")
             };
             const rollbackOutcome = await restoreRollbackBoundary({
                 repoRoot: request.context.repoRoot,
@@ -681,15 +801,13 @@ export async function runMartin(input) {
                 await input.store.appendLedger(loop.loopId, makeLedgerEvent({
                     kind: "run.exited",
                     runId: loop.loopId,
-                    payload: {
-                        lifecycleState: approvalExitDecision.lifecycleState,
-                        status: approvalExitDecision.status,
-                        reason: approvalExitDecision.reason
-                    }
+                    payload: createRunExitPayload(approvalExitDecision)
                 }));
             }
+            const finalizedLoop = finalizeLoop(loop, approvalExitDecision, now(), idFactory);
+            await persistLoopRecordIfSupported(input.store, finalizedLoop);
             return {
-                loop: finalizeLoop(loop, approvalExitDecision, now(), idFactory),
+                loop: finalizedLoop,
                 decision: approvalExitDecision
             };
         }
@@ -728,8 +846,8 @@ export async function runMartin(input) {
                 previousVerifierScore,
                 verifierScore: result.verification.passed ? 1 : 0,
                 groundingViolationCount: groundingScanResult?.violations.length ?? 0,
-                changedFileCount: changedFileEvidenceAvailable ? changedFiles.length : undefined,
-                diffNovelty: changedFileEvidenceAvailable ? (changedFiles.length > 0 ? 1 : 0) : undefined,
+                changedFileCount: !isVerifyOnly && changedFileEvidenceAvailable ? changedFiles.length : undefined,
+                diffNovelty: !isVerifyOnly && changedFileEvidenceAvailable ? (changedFiles.length > 0 ? 1 : 0) : undefined,
                 diffStats: result.execution?.diffStats,
                 costUsd: getUsageUsd(result.usage),
                 summary: result.summary
@@ -822,15 +940,13 @@ export async function runMartin(input) {
                 await input.store.appendLedger(loop.loopId, makeLedgerEvent({
                     kind: "run.exited",
                     runId: loop.loopId,
-                    payload: {
-                        lifecycleState: patchExitDecision.lifecycleState,
-                        status: patchExitDecision.status,
-                        reason: patchExitDecision.reason
-                    }
+                    payload: createRunExitPayload(patchExitDecision)
                 }));
             }
+            const finalizedLoop = finalizeLoop(loop, patchExitDecision, now(), idFactory);
+            await persistLoopRecordIfSupported(input.store, finalizedLoop);
             return {
-                loop: finalizeLoop(loop, patchExitDecision, now(), idFactory),
+                loop: finalizedLoop,
                 decision: patchExitDecision
             };
         }
@@ -870,15 +986,13 @@ export async function runMartin(input) {
                 await input.store.appendLedger(loop.loopId, makeLedgerEvent({
                     kind: "run.exited",
                     runId: loop.loopId,
-                    payload: {
-                        lifecycleState: decision.lifecycleState,
-                        status: decision.status,
-                        reason: decision.reason
-                    }
+                    payload: createRunExitPayload(decision)
                 }));
             }
+            const finalizedLoop = finalizeLoop(loop, decision, now(), idFactory);
+            await persistLoopRecordIfSupported(input.store, finalizedLoop);
             return {
-                loop: finalizeLoop(loop, decision, now(), idFactory),
+                loop: finalizedLoop,
                 decision
             };
         }
@@ -893,23 +1007,64 @@ export async function runMartin(input) {
         await input.store.appendLedger(loop.loopId, makeLedgerEvent({
             kind: "run.exited",
             runId: loop.loopId,
-            payload: {
-                lifecycleState: decision.lifecycleState,
-                status: decision.status,
-                reason: decision.reason
-            }
+            payload: createRunExitPayload(decision)
         }));
     }
+    const finalizedLoop = finalizeLoop(loop, decision, now(), idFactory);
+    await persistLoopRecordIfSupported(input.store, finalizedLoop);
     return {
-        loop: finalizeLoop(loop, decision, now(), idFactory),
+        loop: finalizedLoop,
         decision
     };
 }
+function createRunExitPayload(decision) {
+    return {
+        lifecycleState: decision.lifecycleState,
+        status: decision.status,
+        reason: decision.reason,
+        ...(decision.failureClass ? { failureClass: decision.failureClass } : {}),
+        ...(decision.safetySurface ? { safetySurface: decision.safetySurface } : {}),
+        ...(decision.reasonCode ? { reasonCode: decision.reasonCode } : {})
+    };
+}
+function classifySafetyLeashExit(decision, safetySurface = decision.surface) {
+    return {
+        failureClass: "safety_leash_blocked",
+        safetySurface,
+        reasonCode: safetyLeashReasonCode(decision, safetySurface)
+    };
+}
+function safetyLeashReasonCode(decision, safetySurface) {
+    const kind = decision.violations[0]?.kind;
+    switch (kind) {
+        case "command_blocked":
+            return safetySurface === "verifier" ? "destructive_verifier_command" : "command_blocked";
+        case "network_blocked":
+            return safetySurface === "verifier" ? "verifier_network_blocked" : "network_access_blocked";
+        case "secret_value":
+            return "secret_context_value";
+        case "path_denied":
+        case "protected_path":
+            return "protected_surface_write";
+        case "path_not_allowed":
+            return "surface_write_not_allowed";
+        case "path_outside_repo":
+            return "outside_repo_write";
+        case "dependency_approval_required":
+            return "dependency_approval_required";
+        case "migration_approval_required":
+            return "migration_approval_required";
+        case "config_change_approval_required":
+            return "config_change_approval_required";
+        default:
+            return `${safetySurface}_safety_block`;
+    }
+}
 function finalizeLoop(loop, decision, timestamp, idFactory) {
     const finalized = appendLoopEvent(loop, {
         type: "run.completed",
         lifecycleState: decision.lifecycleState,
-        payload: { status: decision.status, reason: decision.reason }
+        payload: createRunExitPayload(decision)
     }, { now: timestamp, idFactory });
     return {
         ...finalized,
@@ -918,6 +1073,9 @@ function finalizeLoop(loop, decision, timestamp, idFactory) {
         updatedAt: timestamp
     };
 }
+async function persistLoopRecordIfSupported(store, loop) {
+    await store?.writeLoopRecord?.(loop.loopId, loop);
+}
 function getAdapterTransport(adapter) {
     return adapter.metadata.transport ?? (adapter.kind === "agent-cli" ? "cli" : "http");
 }
@@ -934,7 +1092,7 @@ function getUsageProvenance(usage) {
     return "actual";
 }
 function resolveChangedFiles(result, repoRoot) {
-    if (result.execution?.changedFiles?.length) {
+    if (result.execution?.changedFiles !== undefined) {
         return result.execution.changedFiles;
     }
     if (!repoRoot) {

package/dist/vendor/core/learning/bayesian-update.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Applies a single-step Bayesian update to a prior probability.
+ *
+ * Formula: posterior = (prior * likelihood) / normalizing_constant
+ *
+ * The normalizing constant ensures the result stays in [0, 1]:
+ *   Z = prior * likelihood + (1 - prior) * (1 - likelihood)
+ *
+ * This is the standard Beta-Bernoulli update for binary outcomes.
+ * - likelihood > 0.5 → positive evidence → posterior increases
+ * - likelihood < 0.5 → negative evidence → posterior decreases
+ * - likelihood = 0.5 → no information → posterior unchanged
+ *
+ * @param prior     Current prior probability (0.0 – 1.0)
+ * @param likelihood Likelihood of observation given the hypothesis (0.0 – 1.0)
+ * @returns Updated posterior probability (0.0 – 1.0)
+ */
+export declare function updatePriorBayesian(prior: number, likelihood: number): number;
+/**
+ * Applies a Bayesian update to a PriorSet's individual symbol priors
+ * using confidence deltas from the hypothesis ledger.
+ *
+ * confidenceDelta > 0 → validated evidence → likelihood = 0.5 + delta/2
+ * confidenceDelta < 0 → invalidated evidence → likelihood = 0.5 + delta/2
+ *
+ * @param priors     Symbol → prior probability map
+ * @param symbol     The specific symbol to update
+ * @param confidenceDelta  From hypothesis ledger (−1.0 to +1.0)
+ * @returns New priors map with updated value for symbol
+ */
+export declare function updateSymbolPrior(priors: Record<string, number>, symbol: string, confidenceDelta: number): Record<string, number>;

package/dist/vendor/core/learning/bayesian-update.js

@@ -0,0 +1,60 @@
+// ─── Bayesian Update ─────────────────────────────────────────────────────────
+/**
+ * Applies a single-step Bayesian update to a prior probability.
+ *
+ * Formula: posterior = (prior * likelihood) / normalizing_constant
+ *
+ * The normalizing constant ensures the result stays in [0, 1]:
+ *   Z = prior * likelihood + (1 - prior) * (1 - likelihood)
+ *
+ * This is the standard Beta-Bernoulli update for binary outcomes.
+ * - likelihood > 0.5 → positive evidence → posterior increases
+ * - likelihood < 0.5 → negative evidence → posterior decreases
+ * - likelihood = 0.5 → no information → posterior unchanged
+ *
+ * @param prior     Current prior probability (0.0 – 1.0)
+ * @param likelihood Likelihood of observation given the hypothesis (0.0 – 1.0)
+ * @returns Updated posterior probability (0.0 – 1.0)
+ */
+export function updatePriorBayesian(prior, likelihood) {
+    if (prior < 0 || prior > 1)
+        throw new Error(`prior must be in [0, 1], got ${prior}`);
+    if (likelihood < 0 || likelihood > 1)
+        throw new Error(`likelihood must be in [0, 1], got ${likelihood}`);
+    // P(H|E) = P(E|H) * P(H) / P(E)
+    // P(E) = P(E|H)*P(H) + P(E|¬H)*P(¬H)
+    const pEgivenH = likelihood;
+    const pEgivenNotH = 1 - likelihood;
+    const pH = prior;
+    const pNotH = 1 - prior;
+    const pE = pEgivenH * pH + pEgivenNotH * pNotH;
+    // Avoid division by zero (shouldn't happen with valid inputs)
+    if (pE === 0)
+        return prior;
+    return (pEgivenH * pH) / pE;
+}
+/**
+ * Applies a Bayesian update to a PriorSet's individual symbol priors
+ * using confidence deltas from the hypothesis ledger.
+ *
+ * confidenceDelta > 0 → validated evidence → likelihood = 0.5 + delta/2
+ * confidenceDelta < 0 → invalidated evidence → likelihood = 0.5 + delta/2
+ *
+ * @param priors     Symbol → prior probability map
+ * @param symbol     The specific symbol to update
+ * @param confidenceDelta  From hypothesis ledger (−1.0 to +1.0)
+ * @returns New priors map with updated value for symbol
+ */
+export function updateSymbolPrior(priors, symbol, confidenceDelta) {
+    const currentPrior = priors[symbol] ?? 0.5;
+    // Map confidenceDelta (−1..+1) to likelihood (0..1)
+    // delta=+1.0 → likelihood=1.0 (strong positive evidence)
+    // delta=0.0  → likelihood=0.5 (no information)
+    // delta=−1.0 → likelihood=0.0 (strong negative evidence)
+    const likelihood = Math.max(0, Math.min(1, 0.5 + confidenceDelta / 2));
+    return {
+        ...priors,
+        [symbol]: updatePriorBayesian(currentPrior, likelihood)
+    };
+}
+//# sourceMappingURL=bayesian-update.js.map

package/dist/vendor/core/learning/prior-sets.d.ts

@@ -0,0 +1,42 @@
+export type PromotionGate = "development" | "backtest" | "shadow" | "live";
+export interface PriorSet {
+    priorSetId: string;
+    taskClass: string;
+    version: number;
+    confidence: number;
+    priors: Record<string, number>;
+    lastUpdatedAt: string;
+    promotionGate: PromotionGate;
+    sampleCount: number;
+}
+export interface PriorStore {
+    priorSets: PriorSet[];
+}
+export interface CreatePriorSetInput {
+    priorSetId: string;
+    taskClass: string;
+    priors: Record<string, number>;
+}
+export declare function createPriorSet(input: CreatePriorSetInput): PriorSet;
+export declare function loadPriorStore(storeDir: string): Promise<PriorStore>;
+export declare function savePriorStore(store: PriorStore, storeDir: string): Promise<void>;
+/**
+ * Promotes a PriorSet to the next gate in the sequence.
+ * Gates must advance sequentially: development → backtest → shadow → live.
+ * Throws if the target gate is not the immediate next gate.
+ */
+export declare function promotePriorSet(priorSetId: string, targetGate: PromotionGate, storeDir: string): Promise<PriorSet>;
+/**
+ * Rolls back a PriorSet to the previous gate.
+ * Rollback is always available from any gate above development.
+ * Throws if already at development.
+ */
+export declare function rollbackPriorSet(priorSetId: string, storeDir: string): Promise<PriorSet>;
+/**
+ * Returns all PriorSets from the store.
+ */
+export declare function listPriorSets(storeDir: string): Promise<PriorSet[]>;
+/**
+ * Returns a single PriorSet by ID, or null if not found.
+ */
+export declare function getPriorSet(priorSetId: string, storeDir: string): Promise<PriorSet | null>;