sneakoscope 3.1.0 → 3.1.2

package/dist/core/loops/loop-worker-runtime.js

@@ -0,0 +1,281 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runNativeAgentOrchestrator } from '../agents/agent-orchestrator.js';
+import { ensureDir, nowIso, readJson, runProcess, writeJsonAtomic } from '../fsx.js';
+import { loopNodeRoot } from './loop-artifacts.js';
+import { computeLoopConcurrencyBudget, loopWorkerBudgetFor } from './loop-concurrency-budget.js';
+import { decideLoopFixturePolicy, writeLoopFixturePolicyDecision } from './loop-fixture-policy.js';
+import { buildLoopCheckerPrompt, buildLoopMakerPrompt } from './loop-worker-prompts.js';
+export async function runLoopMakerWorkers(input) {
+    return runLoopWorkers({ ...input, phase: 'maker' });
+}
+export async function runLoopCheckerWorkers(input) {
+    return runLoopWorkers({ ...input, phase: 'checker', noMutation: true });
+}
+async function runLoopWorkers(input) {
+    if (shouldUseFixture(input))
+        return runLoopWorkerFixture(input);
+    return runLoopWorkerNative(input);
+}
+// `noMutation` used to force fixture mode here, which silently turned EVERY
+// checker run into a deterministic fixture (checkers always pass
+// noMutation: true for read-only semantics) — real model verification never
+// happened. Fixture mode is now an explicit, separate test-only signal.
+function shouldUseFixture(input) {
+    const requested = input.fixture === true || process.env.SKS_LOOP_RUNTIME_FIXTURE === '1';
+    if (!requested)
+        return false;
+    const decision = decideLoopFixturePolicy({
+        root: input.root,
+        missionId: input.plan.mission_id,
+        mode: 'worker',
+        requested
+    });
+    void writeLoopFixturePolicyDecision(input.root, input.plan.mission_id, decision).catch(() => undefined);
+    if (!decision.allowed) {
+        throw new Error(`loop_fixture_runtime_forbidden:${decision.reason}:${decision.blockers.join(',')}`);
+    }
+    return true;
+}
+async function runLoopWorkerNative(input) {
+    const prompt = input.phase === 'maker'
+        ? buildLoopMakerPrompt({ plan: input.plan, node: input.node, worktreePath: input.worktree?.path || null })
+        : buildLoopCheckerPrompt({ plan: input.plan, node: input.node, makerArtifacts: input.makerArtifacts || [] });
+    const workerCount = effectiveLoopWorkerCount(input);
+    const workGraph = buildLoopNarutoWorkGraph(input, workerCount);
+    // Root-cause-1 fix: keep the ORCHESTRATOR root on the MAIN repo (input.root), not the
+    // loop worktree. All zellij/right-column/slot-telemetry state derives from the orchestrator
+    // root, so anchoring it on input.root makes the SLOTS snapshot land under
+    // <main repo>/.sneakoscope/missions/<missionId>/... where the main session's anchor + slot
+    // renderer panes watch it (previously it landed under the worktree and went permanently stale).
+    // The loop worktree is still where workers cwd + write: it is threaded through the per-worker
+    // `worktree` opt below, which launchWorker reads as ctx.opts.worktree -> workerCwd.
+    const insideZellij = Boolean(process.env.SKS_ZELLIJ_SESSION_NAME || process.env.ZELLIJ);
+    const visiblePaneCap = Math.min(resolveLoopVisiblePaneCap(workerCount), Math.max(1, workerCount));
+    const zellijPlacementOpts = insideZellij ? {
+        workerPlacement: 'zellij-pane',
+        ...(process.env.SKS_ZELLIJ_SESSION_NAME ? { zellijSessionName: process.env.SKS_ZELLIJ_SESSION_NAME } : {}),
+        zellijVisiblePaneCap: visiblePaneCap
+    } : {};
+    const orchestrator = await runNativeAgentOrchestrator({
+        root: input.root,
+        missionId: input.plan.mission_id,
+        prompt,
+        route: '$Naruto',
+        backend: 'codex-sdk',
+        readonly: input.phase === 'checker',
+        workspaceWrite: input.phase === 'maker',
+        desiredWorkItemCount: workGraph.total_work_items,
+        minimumWorkItems: 1,
+        maxAgentCount: Math.max(1, workerCount),
+        targetActiveSlots: Math.max(1, workerCount),
+        visualLaneCount: visiblePaneCap,
+        narutoMode: true,
+        narutoWorkGraph: workGraph,
+        ...zellijPlacementOpts,
+        env: {
+            SKS_LOOP_ID: input.node.loop_id,
+            SKS_LOOP_PHASE: input.phase,
+            SKS_LOOP_MAIN_ROOT: input.root,
+            SKS_LOOP_WORKER_BUDGET: String(workerCount)
+        },
+        ...(input.worktree?.path ? {
+            worktree: {
+                id: input.worktree.id || `loop-${input.node.loop_id}-${input.phase}`,
+                path: input.worktree.path,
+                branch: input.worktree.branch || 'unknown',
+                main_repo_root: input.root
+            }
+        } : {}),
+        gitWorktreePolicy: input.worktree?.path ? {
+            mode: 'patch-envelope-only',
+            required: false,
+            main_repo_root: input.root,
+            worktree_root: input.worktree.path,
+            fallback_reason: null
+        } : null
+    });
+    return normalizeNativeResult(input, orchestrator);
+}
+async function normalizeNativeResult(input, result) {
+    const artifacts = collectArtifactPaths(result);
+    const changedFiles = stringArray(result?.changed_files || result?.proof?.changed_files || result?.results?.flatMap?.((row) => row?.changed_files || []));
+    const blockers = [
+        ...(result?.ok === true ? [] : ['loop_worker_native_orchestrator_not_ok']),
+        ...stringArray(result?.blockers || result?.proof?.blockers)
+    ];
+    const proofPath = path.join(loopNodeRoot(input.root, input.plan.mission_id, input.node.loop_id), input.phase, 'worker-runtime-result.json');
+    const normalized = {
+        schema: 'sks.loop-worker-run-result.v1',
+        ok: blockers.length === 0,
+        mission_id: input.plan.mission_id,
+        loop_id: input.node.loop_id,
+        phase: input.phase,
+        worker_count: effectiveLoopWorkerCount(input),
+        backend: 'native-agent-orchestrator',
+        artifacts,
+        patch_candidates: input.phase === 'maker' ? artifacts.filter((artifact) => artifact.includes('patch')) : [],
+        checker_findings: input.phase === 'checker' ? artifacts.filter((artifact) => artifact.includes('checker') || artifact.includes('finding')) : [],
+        changed_files: changedFiles,
+        blockers: [...new Set(blockers)],
+        runtime_proof_path: proofPath,
+        worker_ids: stringArray(result?.results?.map?.((row) => row?.agent_id || row?.id)),
+        session_ids: stringArray(result?.results?.map?.((row) => row?.session_id))
+    };
+    await writeJsonAtomic(proofPath, { ...normalized, native_result_summary: summarizeNativeResult(result), generated_at: nowIso() });
+    return normalized;
+}
+async function runLoopWorkerFixture(input) {
+    const fixturePolicy = decideLoopFixturePolicy({
+        root: input.root,
+        missionId: input.plan.mission_id,
+        mode: 'worker',
+        requested: true
+    });
+    const dir = path.join(loopNodeRoot(input.root, input.plan.mission_id, input.node.loop_id), input.phase);
+    await ensureDir(dir);
+    const resultPath = path.join(dir, 'worker-runtime-result.json');
+    const childInputPath = path.join(dir, 'worker-fixture-intake.json');
+    await writeJsonAtomic(childInputPath, {
+        schema: 'sks.loop-worker-fixture-intake.v1',
+        root: input.root,
+        mission_id: input.plan.mission_id,
+        loop_id: input.node.loop_id,
+        phase: input.phase,
+        worker_count: input.phase === 'maker' ? input.node.maker.worker_count : input.node.checker.worker_count,
+        result_path: resultPath,
+        owner_scope: input.node.owner_scope,
+        maker_artifacts: input.makerArtifacts || []
+    });
+    const child = await runProcess(process.execPath, [fixtureChildEntrypoint(), childInputPath], {
+        cwd: input.root,
+        timeoutMs: input.timeoutMs || 30000,
+        maxOutputBytes: 64 * 1024
+    });
+    const result = await readJson(resultPath, null);
+    if (!result) {
+        return {
+            schema: 'sks.loop-worker-run-result.v1',
+            ok: false,
+            mission_id: input.plan.mission_id,
+            loop_id: input.node.loop_id,
+            phase: input.phase,
+            worker_count: 0,
+            backend: 'deterministic-fixture',
+            artifacts: [],
+            patch_candidates: [],
+            checker_findings: [],
+            changed_files: [],
+            blockers: [`loop_worker_fixture_child_missing_result:${child.code}`],
+            runtime_proof_path: resultPath,
+            worker_ids: [],
+            session_ids: [],
+            fixture_policy: fixturePolicy,
+            fixture_allowed_reason: fixturePolicy.allowed ? fixturePolicy.reason : null
+        };
+    }
+    return {
+        ...result,
+        ok: result.ok && child.code === 0,
+        blockers: [
+            ...result.blockers,
+            ...(child.code === 0 ? [] : [`loop_worker_fixture_child_exit:${child.code}`])
+        ],
+        fixture_policy: fixturePolicy,
+        fixture_allowed_reason: fixturePolicy.allowed ? fixturePolicy.reason : null
+    };
+}
+function buildLoopNarutoWorkGraph(input, workerCount) {
+    const workItems = Array.from({ length: Math.max(1, workerCount) }, (_, index) => {
+        const id = `${input.node.loop_id}-${input.phase}-${index + 1}`;
+        const writeAllowed = input.phase === 'maker';
+        return {
+            id,
+            kind: writeAllowed ? 'code_modification' : 'verification',
+            title: `${input.phase} worker ${index + 1} for ${input.node.loop_id}`,
+            target_paths: [...input.node.owner_scope.files, ...input.node.owner_scope.directories],
+            readonly_paths: input.phase === 'checker' ? [...input.node.owner_scope.files, ...input.node.owner_scope.directories] : [],
+            write_paths: writeAllowed ? [...input.node.owner_scope.files, ...input.node.owner_scope.directories] : [],
+            required_role: input.phase,
+            write_allowed: writeAllowed,
+            verification_required: input.phase === 'checker',
+            dependencies: [],
+            can_run_in_parallel_with: [],
+            conflicts_with: [],
+            estimated_cost: { tokens: 8000, latency_ms: 30000, cpu_weight: 1, memory_mb: 512, gpu_weight: 0 },
+            lease_requirements: input.node.owner_scope.files.map((file) => ({ path: file, kind: writeAllowed ? 'write' : 'read' })),
+            acceptance: { requires_patch_envelope: writeAllowed, requires_verification: !writeAllowed, requires_gpt_final: input.node.risk.requires_gpt_final },
+            owner: input.node.loop_id,
+            allocation_reason: 'loop-worker-runtime',
+            allocation_score: 1,
+            allocation_hints: null,
+            lane: input.phase,
+            worktree: {
+                mode: input.worktree?.path ? 'patch-envelope-only' : 'git-worktree',
+                required: input.node.worktree.required,
+                allocation_required: false
+            }
+        };
+    });
+    return {
+        schema: 'sks.naruto-work-graph.v1',
+        route: '$Naruto',
+        requested_clones: workerCount,
+        total_work_items: workItems.length,
+        readonly: input.phase === 'checker',
+        write_capable: input.phase === 'maker',
+        work_items: workItems,
+        active_waves: [{ wave_id: `${input.node.loop_id}-${input.phase}`, work_item_ids: workItems.map((item) => item.id), write_paths: workItems.flatMap((item) => item.write_paths), conflict_count: 0 }],
+        mixed_work_kinds: [...new Set(workItems.map((item) => item.kind))],
+        write_allowed_count: workItems.filter((item) => item.write_allowed).length,
+        worktree_policy: {
+            mode: input.worktree?.path ? 'patch-envelope-only' : 'git-worktree',
+            required: input.node.worktree.required,
+            main_repo_root: input.root,
+            worktree_root: null,
+            fallback_reason: input.worktree?.path ? 'loop_worktree_already_allocated' : null
+        },
+        blockers: [],
+        ok: true
+    };
+}
+function collectArtifactPaths(result) {
+    return stringArray([
+        result?.ledger_root,
+        result?.proof?.artifact,
+        ...(Array.isArray(result?.results) ? result.results.flatMap((row) => row?.artifacts || row?.patch_queue_refs || []) : [])
+    ]);
+}
+function summarizeNativeResult(result) {
+    return {
+        ok: result?.ok === true,
+        status: result?.status || null,
+        mission_id: result?.mission_id || null,
+        backend: result?.backend || null,
+        result_count: Array.isArray(result?.results) ? result.results.length : 0,
+        blockers: stringArray(result?.blockers || result?.proof?.blockers).slice(0, 20)
+    };
+}
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return [...new Set(value.flat().map((item) => String(item || '').trim()).filter(Boolean))];
+}
+// Visible pane cap for loop workers: defaults to min(4, workers) so the right
+// column stays readable; SKS_ZELLIJ_VISIBLE_PANE_CAP overrides for tall
+// terminals (overflow workers run headless and stay visible in SLOTS rows).
+function resolveLoopVisiblePaneCap(workerCount) {
+    const fromEnv = Number(process.env.SKS_ZELLIJ_VISIBLE_PANE_CAP || 0);
+    if (Number.isFinite(fromEnv) && fromEnv >= 1)
+        return Math.floor(fromEnv);
+    return Math.min(4, Math.max(1, workerCount));
+}
+function fixtureChildEntrypoint() {
+    return fileURLToPath(new URL('../../scripts/loop-worker-fixture-child.js', import.meta.url));
+}
+function effectiveLoopWorkerCount(input) {
+    const requested = input.phase === 'maker' ? input.node.maker.worker_count : input.node.checker.worker_count;
+    const budget = computeLoopConcurrencyBudget({ plan: input.plan });
+    return loopWorkerBudgetFor(budget, input.node.loop_id, input.phase, requested);
+}
+//# sourceMappingURL=loop-worker-runtime.js.map

package/dist/core/loops/loop-worktree-runtime.js

@@ -0,0 +1,92 @@
+import path from 'node:path';
+import { exists, nowIso, writeJsonAtomic } from '../fsx.js';
+import { allocateWorkerWorktree } from '../git/git-worktree-manager.js';
+import { gitOutputLine, runGitCommand } from '../git/git-worktree-runner.js';
+import { loopNodeRoot } from './loop-artifacts.js';
+export async function allocateLoopWorktree(input) {
+    const blockers = [];
+    let worktreeId = null;
+    let worktreePath = null;
+    let branch = null;
+    let baseRef = null;
+    if (input.node.worktree.required && !input.noMutation) {
+        const gitPresent = await exists(path.join(input.root, '.git'));
+        if (!gitPresent) {
+            blockers.push('loop_worktree_required_but_git_missing');
+        }
+        else {
+            const allocation = await allocateWorkerWorktree({
+                repoRoot: input.root,
+                missionId: input.plan.mission_id,
+                workerId: input.node.loop_id,
+                slotId: input.node.loop_id,
+                generationIndex: 1,
+                branchPrefix: input.node.worktree.branch_prefix
+            }).catch((err) => ({ ok: false, blockers: [`loop_worktree_allocate_exception:${err instanceof Error ? err.message : String(err)}`] }));
+            if (allocation.ok) {
+                worktreeId = allocation.worker_id || input.node.loop_id;
+                worktreePath = allocation.worktree_path || null;
+                branch = allocation.branch || null;
+                baseRef = allocation.base_ref || null;
+            }
+            else {
+                blockers.push(...stringArray(allocation.blockers));
+            }
+        }
+    }
+    const record = {
+        schema: 'sks.loop-worktree.v1',
+        loop_id: input.node.loop_id,
+        worktree_id: worktreeId,
+        path: worktreePath,
+        branch,
+        base_ref: baseRef,
+        allocated_at: nowIso(),
+        cleanup_policy: input.node.worktree.cleanup,
+        blockers
+    };
+    await writeJsonAtomic(path.join(loopNodeRoot(input.root, input.plan.mission_id, input.node.loop_id), 'worktree.json'), record);
+    return record;
+}
+export async function computeLoopDiff(input) {
+    const cwd = input.worktreePath || input.root;
+    const blockers = [];
+    const names = await runGitCommand(cwd, ['diff', '--name-only', 'HEAD'], { timeoutMs: 30000 }).catch(() => null);
+    const stat = await runGitCommand(cwd, ['diff', '--stat', 'HEAD'], { timeoutMs: 30000 }).catch(() => null);
+    const diff = await runGitCommand(cwd, ['diff', '--binary', '--full-index', 'HEAD'], { timeoutMs: 60000 }).catch(() => null);
+    if (!names?.ok)
+        blockers.push('loop_git_diff_name_only_failed');
+    if (!diff?.ok)
+        blockers.push('loop_git_diff_failed');
+    const changedFiles = [...new Set((names?.stdout || '').split(/\r?\n/).map((line) => line.trim()).filter(Boolean))];
+    blockers.push(...enforceLoopOwnerScope(changedFiles, input.ownerScope));
+    return {
+        changed_files: changedFiles,
+        patch_bytes: Buffer.byteLength(diff?.stdout || ''),
+        diff_stat: stat ? gitOutputLine(stat) || stat.stdout.slice(-4000) : '',
+        blockers: [...new Set(blockers)]
+    };
+}
+export function enforceLoopOwnerScope(changedFiles, ownerScope) {
+    const blockers = [];
+    for (const file of changedFiles) {
+        if (!isInOwnerScope(file, ownerScope))
+            blockers.push(`loop_owner_scope_violation:${file}`);
+    }
+    return blockers;
+}
+function isInOwnerScope(file, ownerScope) {
+    const normalized = normalizePath(file);
+    if (ownerScope.files.map(normalizePath).includes(normalized))
+        return true;
+    return ownerScope.directories.map(normalizePath).some((dir) => normalized === dir || normalized.startsWith(`${dir}/`));
+}
+function normalizePath(value) {
+    return String(value || '').replace(/\\/g, '/').replace(/^\.\/+/, '');
+}
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map((item) => String(item || '').trim()).filter(Boolean);
+}
+//# sourceMappingURL=loop-worktree-runtime.js.map

package/dist/core/naruto/naruto-finalizer.js

@@ -5,14 +5,19 @@ export function evaluateNarutoFinalizer(input = {}) {
     const blockers = [
         ...(gptFinalRequired && !gptFinalAccepted ? ['naruto_local_worker_output_needs_gpt_final_arbiter'] : [])
     ];
+    const finalStatus = blockers.length ? 'blocked' : input.applyPatches === true ? 'accepted' : 'draft';
+    const applyFinalized = finalStatus === 'accepted';
     return {
         schema: 'sks.naruto-finalizer.v1',
         local_participated: localParticipated,
         gpt_final_required: gptFinalRequired,
-        final_status: blockers.length ? 'blocked' : input.applyPatches === true ? 'accepted' : 'draft',
+        final_status: finalStatus,
         final_patch_source: gptFinalRequired ? 'gpt_final_arbiter' : 'deterministic_no_local',
         blockers,
-        ok: blockers.length === 0
+        run_ok: blockers.length === 0,
+        release_proof_allowed: applyFinalized,
+        apply_finalized: applyFinalized,
+        ok: applyFinalized
     };
 }
 //# sourceMappingURL=naruto-finalizer.js.map

package/dist/core/naruto/naruto-loop-mesh.js

@@ -1,17 +1,26 @@
 import { writeJsonAtomic } from '../fsx.js';
+import { computeLoopConcurrencyBudget } from '../loops/loop-concurrency-budget.js';
 import { loopRoot } from '../loops/loop-artifacts.js';
 import { runLoopPlan } from '../loops/loop-runtime.js';
 import { routeNarutoLoopWorker } from './naruto-loop-worker-router.js';
 export async function runNarutoLoopMesh(input) {
     const routes = input.plan.graph.nodes.flatMap((node) => [routeNarutoLoopWorker(node, 'maker'), routeNarutoLoopWorker(node, 'checker')]);
     const activeWorkerBudget = splitActiveWorkerBudget(input.plan, input.parallelism);
+    const loopConcurrencyBudget = computeLoopConcurrencyBudget({ plan: input.plan, parallelism: input.parallelism });
     await writeJsonAtomic(`${loopRoot(input.root, input.plan.mission_id)}/naruto-loop-worker-routes.json`, {
         schema: 'sks.naruto-loop-worker-routes.v1',
         mission_id: input.plan.mission_id,
         active_worker_budget: activeWorkerBudget,
+        loop_concurrency_budget: loopConcurrencyBudget,
         routes
     });
-    return runLoopPlan({ root: input.root, plan: input.plan, parallelism: input.parallelism });
+    return runLoopPlan({
+        root: input.root,
+        plan: input.plan,
+        parallelism: input.parallelism,
+        ...(input.dryRun === undefined ? {} : { dryRun: input.dryRun }),
+        ...(input.noMutation === undefined ? {} : { noMutation: input.noMutation })
+    });
 }
 export function splitActiveWorkerBudget(plan, parallelism) {
     const cap = parallelism === 'safe' ? 8 : parallelism === 'extreme' ? 32 : 16;

package/dist/core/proof/auto-finalize.js

@@ -13,7 +13,7 @@ const AGENT_ARTIFACTS = [
     'agents/agent-task-board.json',
     'agents/agent-concurrency-policy.json'
 ];
-export async function maybeFinalizeRoute(root, { missionId, route, gateFile = null, gate = null, artifacts = [], claims = [], visualEvidence = null, visual = false, fixClaim = false, requireRelation = false, mock = false, statusHint = null, reason = null, command = null, dbEvidence = null, testEvidence = null, blockers = [], unverified = [], agents = undefined, allowActiveWrongnessPartial = false } = {}) {
+export async function maybeFinalizeRoute(root, { missionId, route, gateFile = null, gate = null, artifacts = [], claims = [], visualEvidence = null, visual = false, fixClaim = false, requireRelation = false, mock = false, statusHint = null, reason = null, command = null, dbEvidence = null, testEvidence = null, blockers = [], unverified = [], agents = undefined, allowActiveWrongnessPartial = false, failureAnalysis = null } = {}) {
     if (!missionId || !route) {
         return { ok: false, skipped: true, reason: 'mission_id_or_route_missing' };
     }
@@ -61,7 +61,8 @@ export async function maybeFinalizeRoute(root, { missionId, route, gateFile = nu
         requireRelation,
         visualClaim: visual,
         agents,
-        allowActiveWrongnessPartial
+        allowActiveWrongnessPartial,
+        failureAnalysis
     });
     return { ...proof, auto_finalized: true, gate_passed: passed, status_hint: finalStatus };
 }

package/dist/core/proof/proof-schema.js

@@ -38,6 +38,12 @@ export function emptyCompletionProof(overrides = {}) {
         claims: [],
         unverified: [],
         blockers: [],
+        failure_analysis: {
+            status: 'not_required',
+            root_cause: null,
+            corrective_action: null,
+            evidence: []
+        },
         next_human_actions: [],
         ...overrides
     };

package/dist/core/proof/proof-writer.js

@@ -76,10 +76,13 @@ export function renderProofMarkdown(proof = {}, validation = validateCompletionP
         `- Wrongness: ${proof.evidence?.wrongness?.active_count ?? 0} active (${proof.evidence?.wrongness?.high_severity_active ?? 0} high)`,
         `- Evidence router: ${proof.evidence?.evidence_router?.records ?? 0} record(s)`,
         `- Trust report: ${proof.evidence?.trust_report || 'not_recorded'}`,
-        '',
-        '## Unverified',
         ''
     ];
+    const failureAnalysis = proof.failure_analysis;
+    if (failureAnalysis && (failureAnalysis.status !== 'not_required' || failureAnalysis.root_cause || failureAnalysis.corrective_action)) {
+        lines.push('## Failure Analysis', '', `- Status: ${failureAnalysis.status || 'unknown'}`, `- Root cause: ${failureAnalysis.root_cause || 'not_recorded'}`, `- Corrective action: ${failureAnalysis.corrective_action || 'not_recorded'}`, `- Evidence: ${Array.isArray(failureAnalysis.evidence) ? failureAnalysis.evidence.length : failureAnalysis.evidence ? 1 : 0}`, '');
+    }
+    lines.push('## Unverified', '');
     const unverified = proof.unverified?.length ? proof.unverified : ['No unverified claims recorded.'];
     for (const item of unverified)
         lines.push(`- ${typeof item === 'string' ? item : JSON.stringify(item)}`);

package/dist/core/proof/root-cause-policy.js

@@ -0,0 +1,70 @@
+const PROBLEM_PATTERN = /\b(fallback|workaround|bypass|temporary|synthetic|stale|missing|failed|failure|error|blocked|not_ok|not ok|fixture_child_missing|native_agent_proof_false)\b/i;
+const COMPLETE_STATUSES = new Set(['complete', 'completed', 'corrected', 'resolved', 'fixed']);
+const BLOCKING_STATUSES = new Set(['blocked', 'failed', 'not_verified']);
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function asList(value) {
+    return Array.isArray(value) ? value : [];
+}
+function meaningfulString(value, minLength = 12) {
+    return typeof value === 'string' && value.trim().length >= minLength;
+}
+function hasEvidence(value) {
+    if (typeof value === 'string')
+        return value.trim().length >= 6;
+    if (Array.isArray(value))
+        return value.length > 0;
+    if (value && typeof value === 'object')
+        return Object.keys(value).length > 0;
+    return false;
+}
+export function rootCauseAnalysisRequired(proof = {}, validationIssues = []) {
+    const proofRecord = asRecord(proof);
+    if (!Object.keys(proofRecord).length)
+        return false;
+    const evidence = asRecord(proofRecord.evidence);
+    const agents = asRecord(evidence.agents);
+    const routeGate = asRecord(evidence.route_gate);
+    if (BLOCKING_STATUSES.has(String(proofRecord.status || '')))
+        return true;
+    if (asList(proofRecord.blockers).length > 0)
+        return true;
+    if (validationIssues.some((issue) => String(issue) !== 'root_cause_analysis_missing'))
+        return true;
+    const problemSurface = {
+        status: proofRecord.status,
+        unverified: proofRecord.unverified,
+        blockers: proofRecord.blockers,
+        claims: proofRecord.claims,
+        route_gate: routeGate,
+        agents: {
+            ok: agents.ok,
+            status: agents.status,
+            blockers: agents.blockers,
+            issues: agents.issues
+        },
+        wrongness: evidence.wrongness,
+        trust_report: evidence.trust_report
+    };
+    return PROBLEM_PATTERN.test(JSON.stringify(problemSurface));
+}
+export function rootCauseAnalysisComplete(proof = {}) {
+    const proofRecord = asRecord(proof);
+    const analysis = asRecord(proofRecord.failure_analysis || asRecord(proofRecord.evidence).root_cause_analysis);
+    if (!Object.keys(analysis).length)
+        return false;
+    const status = String(analysis.status || '').toLowerCase();
+    if (!COMPLETE_STATUSES.has(status))
+        return false;
+    const rootCause = analysis.root_cause ?? analysis.cause;
+    const correctiveAction = analysis.corrective_action ?? analysis.fix ?? analysis.correction;
+    const evidence = analysis.evidence ?? analysis.proof ?? analysis.references;
+    return meaningfulString(rootCause) && meaningfulString(correctiveAction) && hasEvidence(evidence);
+}
+export function rootCauseAnalysisIssue(proof = {}, validationIssues = []) {
+    if (!rootCauseAnalysisRequired(proof, validationIssues))
+        return null;
+    return rootCauseAnalysisComplete(proof) ? null : 'root_cause_analysis_missing';
+}
+//# sourceMappingURL=root-cause-policy.js.map

package/dist/core/proof/route-adapter.js

@@ -5,7 +5,7 @@ import { normalizeProofRoute, routeRequiresImageVoxelAnchors } from './route-pro
 import { linkProofClaimsToEvidence, proofEvidenceSummary } from '../evidence/evidence-proof-linker.js';
 import { writeTrustArtifactsForProof } from '../trust-kernel/trust-report.js';
 import { enforceRetention } from '../retention.js';
-export async function writeRouteCompletionProof(root, { missionId = null, route = null, status = 'verified_partial', gate = null, summary = {}, artifacts = [], evidence = {}, claims = [], unverified = [], blockers = [], nextHumanActions = [] } = {}) {
+export async function writeRouteCompletionProof(root, { missionId = null, route = null, status = 'verified_partial', gate = null, summary = {}, artifacts = [], evidence = {}, claims = [], unverified = [], blockers = [], failureAnalysis = null, nextHumanActions = [] } = {}) {
     const collected = await collectProofEvidence(root);
     const normalizedRoute = normalizeProofRoute(route);
     const mergedEvidence = {
@@ -36,6 +36,7 @@ export async function writeRouteCompletionProof(root, { missionId = null, route
         claims,
         unverified,
         blockers,
+        failure_analysis: normalizeFailureAnalysis(failureAnalysis || evidence.failure_analysis || evidence.root_cause_analysis),
         next_human_actions: nextHumanActions
     }, {
         command: {
@@ -68,6 +69,22 @@ export async function writeRouteCompletionProof(root, { missionId = null, route
     const retention = await runPostRouteRetention(root, missionId);
     return { ...enriched, trust, retention };
 }
+function normalizeFailureAnalysis(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return {
+            status: 'not_required',
+            root_cause: null,
+            corrective_action: null,
+            evidence: []
+        };
+    }
+    return {
+        status: value.status || 'complete',
+        root_cause: value.root_cause || value.cause || null,
+        corrective_action: value.corrective_action || value.fix || value.correction || null,
+        evidence: value.evidence || value.proof || value.references || []
+    };
+}
 function normalizeRouteProofStatus(status, { route, evidence, blockers, unverified }) {
     if (blockers?.length)
         return status === 'failed' ? 'failed' : 'blocked';