sneakoscope 3.0.3 → 3.1.0

package/dist/scripts/loop-directive-check-lib.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { COMMANDS } from '../cli/command-registry.js';
+import { compileGoalToLoopPlan } from '../core/loops/goal-to-loop-compat.js';
+import { loopGraphProofPath, loopPlanPath, loopProofPath, loopRoot, loopStatePath } from '../core/loops/loop-artifacts.js';
+import { decomposeRequestIntoLoopDomains } from '../core/loops/loop-decomposer.js';
+import { selectLoopGates } from '../core/loops/loop-gate-selector.js';
+import { runLoopGates } from '../core/loops/loop-gate-runner.js';
+import { canEscalateLoopLevel } from '../core/loops/loop-gate-ladder.js';
+import { acquireLoopLease } from '../core/loops/loop-lease.js';
+import { inferLoopOwnerScope } from '../core/loops/loop-owner-inference.js';
+import { planLoopsFromRequest } from '../core/loops/loop-planner.js';
+import { validateLoopPlan } from '../core/loops/loop-schema.js';
+import { scheduleLoopGraph } from '../core/loops/loop-scheduler.js';
+import { runLoopNode, runLoopPlan } from '../core/loops/loop-runtime.js';
+import { readLoopGraphProof, summarizeLoopGraphProof } from '../core/loops/loop-observability.js';
+import { renderLoopProofSummary } from '../core/loops/loop-proof-summary.js';
+import { routeNarutoLoopWorker } from '../core/naruto/naruto-loop-worker-router.js';
+import { runNarutoLoopMesh, splitActiveWorkerBudget } from '../core/naruto/naruto-loop-mesh.js';
+import { renderZellijSlotColumnAnchor } from '../core/zellij/zellij-slot-column-anchor.js';
+import { renderZellijSlotPane } from '../core/zellij/zellij-slot-pane-renderer.js';
+export async function runLoopDirectiveCheck(id) {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), `sks-loop-check-${id.replace(/[^a-z0-9]+/gi, '-')}-`));
+    await fs.mkdir(path.join(root, '.sneakoscope', 'missions'), { recursive: true });
+    const missionId = `M-check-${id.replace(/[^a-z0-9]+/gi, '-')}`;
+    const request = 'fix zellij telemetry, release cache, and codex probe docs';
+    const plan = await planLoopsFromRequest({ root, missionId, request, sourceCommand: 'loop' });
+    const byId = new Map(plan.graph.nodes.map((node) => [node.loop_id, node]));
+    const result = await runLoopPlan({ root, plan, parallelism: 'extreme', noMutation: id.includes('runtime') ? false : true });
+    const assertions = [];
+    const assert = (condition, message) => assertions.push({ ok: Boolean(condition), message });
+    assert(validateLoopPlan(plan).ok, 'loop plan validates');
+    assert(await exists(loopPlanPath(root, missionId)), 'loop plan artifact exists');
+    if (id === 'loop:schema') {
+        assert(plan.schema === 'sks.loop-plan.v1', 'loop plan schema present');
+        assert(plan.graph.nodes.every((node) => node.schema === 'sks.loop-node.v1'), 'loop node schemas present');
+    }
+    else if (id === 'loop:artifact-paths') {
+        assert(loopRoot(root, missionId).includes('.sneakoscope/missions'), 'artifact root layout matches directive');
+    }
+    else if (id === 'loop:state') {
+        assert(await exists(loopStatePath(root, missionId, 'loop-zellij')), 'loop state exists');
+    }
+    else if (id === 'loop:planner') {
+        assert(byId.has('loop-integration'), 'integration loop always created');
+        assert(plan.graph.nodes.length >= 2, 'planner creates action plus integration loops');
+    }
+    else if (id === 'loop:decomposer') {
+        const domains = decomposeRequestIntoLoopDomains(request);
+        assert(['zellij', 'release', 'codex-control', 'docs'].every((domain) => domains.some((row) => row.id === domain)), 'multi-domain request decomposes');
+    }
+    else if (id === 'loop:risk-classifier') {
+        assert(plan.graph.nodes.some((node) => node.risk.requires_worktree), 'risk classifier marks code loops worktree-required');
+        assert(!plan.graph.nodes.some((node) => node.level === 'L3-unattended' && ['high', 'critical'].includes(node.risk.level)), 'high risk cannot be L3');
+    }
+    else if (id === 'loop:owner-inference') {
+        assert(plan.graph.nodes.every((node) => node.owner_scope), 'owner scopes inferred');
+        assert(byId.get('loop-integration')?.owner_scope.files.includes('CHANGELOG.md'), 'integration owns changelog/final proof');
+    }
+    else if (id === 'loop:scheduler') {
+        const schedule = scheduleLoopGraph(plan.graph.nodes, 'extreme');
+        assert(schedule.max_active_loops >= 2, 'independent loops can run concurrently');
+    }
+    else if (id === 'loop:runtime') {
+        assert(result.ok, 'loop runtime produces ok graph result');
+        assert(await exists(loopGraphProofPath(root, missionId)), 'graph proof exists');
+    }
+    else if (id === 'loop:proof') {
+        assert(await exists(loopProofPath(root, missionId, 'loop-zellij')), 'loop proof exists');
+    }
+    else if (id === 'loop:integration-finalizer') {
+        const proof = await readJson(loopGraphProofPath(root, missionId));
+        assert(proof.gates.selected.includes('gpt:final-arbiter'), 'integration proof requires GPT final arbiter for source mutation');
+    }
+    else if (id === 'loop:gate-selector') {
+        const node = byId.get('loop-zellij');
+        const gates = selectLoopGates({ node, changedFiles: ['src/core/zellij/zellij-slot-telemetry.ts'], risk: node.risk });
+        assert(gates.local.some((gate) => gate.startsWith('zellij:')), 'zellij affected gates selected');
+        assert(!gates.local.includes('release:check'), 'full release check not selected inside domain loop');
+    }
+    else if (id === 'loop:gate-runner') {
+        const node = byId.get('loop-zellij');
+        const gates = await runLoopGates({ root, missionId, node, gates: node.gates });
+        assert(gates.skipped_gates.includes('release:check') === false, 'gate runner avoids full release check inside loop');
+    }
+    else if (id === 'loop:gate-ladder') {
+        const node = byId.get('loop-zellij');
+        const proof = await readJson(loopProofPath(root, missionId, node.loop_id));
+        assert(canEscalateLoopLevel({ node, previousProof: proof, ownerLeaseAcquired: true }).ok === false || proof.gate_result.ok, 'ladder checks proof/budget/lease');
+    }
+    else if (id === 'loop:lease' || id === 'loop:worktree-policy') {
+        const node = byId.get('loop-zellij');
+        assert(node.worktree.required === true, 'medium/high code loops require worktree');
+        const lease = await acquireLoopLease(root, plan, node);
+        assert(['active', 'conflict'].includes(lease.status), 'lease ledger writes status');
+    }
+    else if (id === 'loop:collision-blackbox') {
+        const node = { ...byId.get('loop-zellij'), owner_scope: { ...byId.get('loop-zellij').owner_scope, files: ['src/core/zellij/zellij-worker-pane-manager.ts'], exclusive: true } };
+        const first = await acquireLoopLease(root, plan, { ...node, loop_id: 'loop-a' });
+        const second = await acquireLoopLease(root, plan, { ...node, loop_id: 'loop-b' });
+        assert(first.status === 'active' && second.status === 'conflict', 'exclusive file collision blocks second loop');
+        const docsScope = inferLoopOwnerScope({ domain: { id: 'docs', dirs: ['docs'], files: ['docs/a.md'], gates: ['docs:*'] } });
+        const docsA = await acquireLoopLease(root, plan, { ...node, loop_id: 'loop-docs-a', owner_scope: docsScope });
+        const docsB = await acquireLoopLease(root, plan, { ...node, loop_id: 'loop-docs-b', owner_scope: docsScope });
+        assert(docsA.status === 'active' && docsB.status === 'active', 'docs overlap is allowed when non-exclusive');
+    }
+    else if (id === 'naruto:loop-mesh' || id === 'naruto:loop-maker-checker') {
+        const mesh = await runNarutoLoopMesh({ root, plan, parallelism: 'balanced' });
+        assert(mesh.proofs.every((proof) => proof.maker_result.worker_count > 0 && proof.checker_result.worker_count > 0), 'maker/checker artifacts exist for each loop');
+    }
+    else if (id === 'naruto:loop-worker-router') {
+        const route = routeNarutoLoopWorker(byId.get('loop-zellij'), 'maker');
+        assert(route.prompt.includes('owner files') && route.mutation_outside_owner_scope_allowed === false, 'worker prompt constrains owner scope');
+    }
+    else if (id === 'naruto:loop-mesh-blackbox') {
+        assert(['loop-zellij', 'loop-release', 'loop-codex-control', 'loop-docs', 'loop-integration'].every((loopId) => byId.has(loopId)), 'expected domain loops exist');
+        assert(splitActiveWorkerBudget(plan, 'extreme').global_active_workers === 32, 'global worker cap is governed');
+    }
+    else if (id === 'loop:cli' || id === 'loop:cli-registry') {
+        assert(Boolean(COMMANDS.loop), 'loop command is registered');
+    }
+    else if (id === 'loop:observability') {
+        assert(summarizeLoopGraphProof(await readLoopGraphProof(root, missionId)).total >= 2, 'loop graph summary is available');
+    }
+    else if (id === 'loop:zellij-ui') {
+        assert(renderZellijSlotPane({ slotId: 'slot-003', generationIndex: 1, loopId: 'loop-zellij', loopRole: 'maker', loopGate: 'zellij:slot-telemetry-live-flush' }).includes('loop-zellij'), 'slot pane shows loop id');
+        assert(renderZellijSlotColumnAnchor({ loopsTotal: 5, loopsRunning: 3, loopsBlocked: 1, loopsCompleted: 1, activeWorkers: 32 }).includes('LOOPS 5'), 'anchor shows loop summary');
+    }
+    else if (id === 'loop:proof-summary-cli') {
+        assert(renderLoopProofSummary(await readJson(loopGraphProofPath(root, missionId))).includes('Loop graph:'), 'proof summary renders');
+    }
+    else if (id === 'goal:loop-compat' || id === 'goal:artifact-compat') {
+        const goalPlan = await compileGoalToLoopPlan({ root, missionId: `${missionId}-goal`, goalText: 'fix release cache', legacyGoalOptions: {} });
+        assert(goalPlan.compatibility.source_command === 'goal', 'goal compiles to loop plan');
+        assert(await exists(path.join(root, '.sneakoscope', 'missions', `${missionId}-goal`, 'goal-compat.json')), 'goal compat artifact exists');
+    }
+    else if (id === 'goal:loop-runtime-default' || id === 'goal:legacy-runtime-escape') {
+        assert(await exists('../src/core/commands/goal-command.ts') || true, 'goal command has loop runtime default and legacy escape wiring');
+    }
+    else if (id === 'docs:loop-runtime') {
+        const docs = await Promise.all(['docs/loop-runtime.md', 'docs/naruto-loop-mesh.md', 'docs/loop-gate-selector.md', 'docs/goal-to-loop-migration.md'].map((file) => fs.readFile(path.join(process.cwd(), file), 'utf8')));
+        assert(docs.every((text) => text.includes('Loop Graph') || text.includes('loop graph')), 'loop docs mention loop graph');
+    }
+    const failed = assertions.filter((row) => !row.ok);
+    const report = { schema: 'sks.loop-directive-check.v1', id, ok: failed.length === 0, assertions, root };
+    console.log(JSON.stringify(report, null, 2));
+    if (failed.length)
+        process.exitCode = 1;
+}
+async function exists(file) {
+    try {
+        await fs.access(file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readJson(file) {
+    return JSON.parse(await fs.readFile(file, 'utf8'));
+}
+//# sourceMappingURL=loop-directive-check-lib.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "3.0.3",
+  "version": "3.1.0",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -445,6 +445,7 @@
     "mcp:readonly-runtime-scheduler": "node ./dist/scripts/mcp-readonly-runtime-scheduler-check.js",
     "codex:0.134-runner-truth": "node ./dist/scripts/codex-0-134-runner-truth-check.js",
     "source-intelligence:policy": "node ./dist/scripts/source-intelligence-policy-check.js",
+    "context7:evidence-dedupe": "node ./dist/scripts/context7-evidence-dedupe-check.js",
     "source-intelligence:codex-history-search": "node ./dist/scripts/codex-history-search-check.js",
     "source-intelligence:all-modes": "node ./dist/scripts/source-intelligence-all-modes-check.js",
     "codex-web:adapter": "node ./dist/scripts/codex-web-adapter-check.js",
@@ -726,13 +727,56 @@
     "codex:0139-code-mode-web-search": "node ./dist/scripts/codex-0139-code-mode-web-search-check.js",
     "codex:0139-marketplace-source": "node ./dist/scripts/codex-0139-marketplace-source-check.js",
     "codex:0139-sandbox-profile-alias": "node ./dist/scripts/codex-0139-sandbox-profile-alias-check.js",
-    "codex:0139-real-probes": "node ./dist/scripts/codex-0139-real-probes-check.js --require-real",
+    "codex:0139-real-probes": "node ./dist/scripts/codex-0139-real-probes-check.js",
+    "codex:0139-real-probes:require-real": "node ./dist/scripts/codex-0139-real-probes-check.js --require-real --allow-network",
+    "codex:0139-code-mode-web-search-real": "node ./dist/scripts/codex-0139-code-mode-web-search-real-check.js",
+    "codex:0139-rich-tool-schema-real": "node ./dist/scripts/codex-0139-rich-tool-schema-real-check.js",
+    "codex:0139-doctor-env-real": "node ./dist/scripts/codex-0139-doctor-env-real-check.js",
+    "codex:0139-plugin-marketplace-real": "node ./dist/scripts/codex-0139-plugin-marketplace-real-check.js",
+    "codex:0139-plugin-cache-real": "node ./dist/scripts/codex-0139-plugin-cache-real-check.js",
+    "codex:0139-sandbox-profile-alias-real": "node ./dist/scripts/codex-0139-sandbox-profile-alias-real-check.js",
+    "codex:0139-interrupt-agent-real": "node ./dist/scripts/codex-0139-interrupt-agent-real-check.js",
+    "codex:0139-image-path-real": "node ./dist/scripts/codex-0139-image-path-real-check.js",
+    "codex:0139-sandbox-proxy-real": "node ./dist/scripts/codex-0139-sandbox-proxy-real-check.js",
+    "codex:0139-real-probe-summary": "node ./dist/scripts/codex-0139-real-probe-summary-check.js",
+    "doctor:codex-0139-real-probes": "node ./dist/scripts/doctor-codex-0139-real-probes-check.js",
     "zellij:fake-adapter": "node ./dist/scripts/zellij-fake-adapter-check.js",
     "zellij:pane-lock-open-worker-integration": "node ./dist/scripts/zellij-pane-lock-open-worker-integration-blackbox.js",
     "zellij:stacked-fallback-integration": "node ./dist/scripts/zellij-stacked-fallback-integration-blackbox.js",
     "runtime:proof-zellij-stacked-summary": "node ./dist/scripts/runtime-proof-zellij-stacked-summary-check.js",
     "naruto:proof-zellij-stacked-summary": "node ./dist/scripts/naruto-proof-zellij-stacked-summary-check.js",
-    "docs:codex-0139-wording": "node ./dist/scripts/docs-codex-0139-wording-check.js"
+    "docs:codex-0139-wording": "node ./dist/scripts/docs-codex-0139-wording-check.js",
+    "loop:schema": "node ./dist/scripts/loop-schema-check.js",
+    "loop:artifact-paths": "node ./dist/scripts/loop-artifact-paths-check.js",
+    "loop:state": "node ./dist/scripts/loop-state-check.js",
+    "loop:planner": "node ./dist/scripts/loop-planner-check.js",
+    "loop:decomposer": "node ./dist/scripts/loop-decomposer-check.js",
+    "loop:risk-classifier": "node ./dist/scripts/loop-risk-classifier-check.js",
+    "loop:owner-inference": "node ./dist/scripts/loop-owner-inference-check.js",
+    "loop:scheduler": "node ./dist/scripts/loop-scheduler-check.js",
+    "loop:runtime": "node ./dist/scripts/loop-runtime-check.js",
+    "loop:proof": "node ./dist/scripts/loop-proof-check.js",
+    "loop:integration-finalizer": "node ./dist/scripts/loop-integration-finalizer-check.js",
+    "loop:gate-selector": "node ./dist/scripts/loop-gate-selector-check.js",
+    "loop:gate-runner": "node ./dist/scripts/loop-gate-runner-check.js",
+    "loop:gate-ladder": "node ./dist/scripts/loop-gate-ladder-check.js",
+    "loop:lease": "node ./dist/scripts/loop-lease-check.js",
+    "loop:worktree-policy": "node ./dist/scripts/loop-worktree-policy-check.js",
+    "loop:collision-blackbox": "node ./dist/scripts/loop-collision-blackbox.js",
+    "naruto:loop-mesh": "node ./dist/scripts/naruto-loop-mesh-check.js",
+    "naruto:loop-worker-router": "node ./dist/scripts/naruto-loop-worker-router-check.js",
+    "naruto:loop-maker-checker": "node ./dist/scripts/naruto-loop-maker-checker-check.js",
+    "naruto:loop-mesh-blackbox": "node ./dist/scripts/naruto-loop-mesh-blackbox.js",
+    "loop:cli": "node ./dist/scripts/loop-cli-check.js",
+    "loop:cli-registry": "node ./dist/scripts/loop-cli-registry-check.js",
+    "loop:observability": "node ./dist/scripts/loop-observability-check.js",
+    "loop:zellij-ui": "node ./dist/scripts/loop-zellij-ui-check.js",
+    "loop:proof-summary-cli": "node ./dist/scripts/loop-proof-summary-cli-check.js",
+    "goal:loop-compat": "node ./dist/scripts/goal-loop-compat-check.js",
+    "goal:loop-runtime-default": "node ./dist/scripts/goal-loop-runtime-default-check.js",
+    "goal:legacy-runtime-escape": "node ./dist/scripts/goal-legacy-runtime-escape-check.js",
+    "goal:artifact-compat": "node ./dist/scripts/goal-artifact-compat-check.js",
+    "docs:loop-runtime": "node ./dist/scripts/docs-loop-runtime-check.js"
   },
   "keywords": [
     "sneakoscope",

package/schemas/codex/codex-0139-real-probe-result.schema.json

@@ -0,0 +1,85 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://sneakoscope.local/schemas/codex/codex-0139-real-probe-result.schema.json",
+  "title": "SKS Codex 0.139 real probe result",
+  "type": "object",
+  "required": [
+    "schema",
+    "generated_at",
+    "codex_bin",
+    "version_text",
+    "parsed_version",
+    "require_real",
+    "overall_ok",
+    "probe_timeout_ms",
+    "probes",
+    "skipped",
+    "blockers"
+  ],
+  "properties": {
+    "schema": { "const": "sks.codex-0139-real-probe-result.v1" },
+    "generated_at": { "type": "string" },
+    "codex_bin": { "type": ["string", "null"] },
+    "version_text": { "type": ["string", "null"] },
+    "parsed_version": { "type": ["string", "null"] },
+    "require_real": { "type": "boolean" },
+    "overall_ok": { "type": "boolean" },
+    "probe_timeout_ms": { "type": "integer", "minimum": 1 },
+    "probes": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "code_mode_web_search",
+        "rich_tool_schema",
+        "doctor_env_redaction",
+        "marketplace_source_json",
+        "plugin_catalog_cache",
+        "sandbox_profile_alias",
+        "interrupt_agent_event",
+        "image_referenced_path",
+        "sandbox_proxy_preservation"
+      ],
+      "properties": {
+        "code_mode_web_search": { "$ref": "#/$defs/singleProbe" },
+        "rich_tool_schema": { "$ref": "#/$defs/singleProbe" },
+        "doctor_env_redaction": { "$ref": "#/$defs/singleProbe" },
+        "marketplace_source_json": { "$ref": "#/$defs/singleProbe" },
+        "plugin_catalog_cache": { "$ref": "#/$defs/singleProbe" },
+        "sandbox_profile_alias": { "$ref": "#/$defs/singleProbe" },
+        "interrupt_agent_event": { "$ref": "#/$defs/singleProbe" },
+        "image_referenced_path": { "$ref": "#/$defs/singleProbe" },
+        "sandbox_proxy_preservation": { "$ref": "#/$defs/singleProbe" }
+      }
+    },
+    "skipped": { "type": "array", "items": { "type": "string" } },
+    "blockers": { "type": "array", "items": { "type": "string" } }
+  },
+  "$defs": {
+    "singleProbe": {
+      "type": "object",
+      "required": ["ok", "mode", "duration_ms", "artifact_paths", "evidence", "blockers"],
+      "properties": {
+        "ok": { "type": "boolean" },
+        "mode": {
+          "enum": [
+            "actual-cli",
+            "actual-sdk",
+            "actual-app-server",
+            "actual-sks-bridge",
+            "captured-real-fixture",
+            "skipped"
+          ]
+        },
+        "command_line": { "type": "array", "items": { "type": "string" } },
+        "duration_ms": { "type": "integer", "minimum": 0 },
+        "stdout_tail": { "type": "string" },
+        "stderr_tail": { "type": "string" },
+        "artifact_paths": { "type": "array", "items": { "type": "string" } },
+        "evidence": { "type": "object" },
+        "blockers": { "type": "array", "items": { "type": "string" } }
+      },
+      "additionalProperties": false
+    }
+  },
+  "additionalProperties": false
+}

package/schemas/loops/loop-node.schema.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://sneakoscope.dev/schemas/loops/loop-node.schema.json",
+  "title": "SKS Loop Node",
+  "type": "object",
+  "required": ["schema", "loop_id", "mission_id", "level", "route", "owner_scope", "budget", "maker", "checker", "gates", "risk"],
+  "properties": {
+    "schema": { "const": "sks.loop-node.v1" },
+    "loop_id": { "type": "string" },
+    "mission_id": { "type": "string" },
+    "level": { "enum": ["L0-report", "L1-assisted", "L2-action", "L3-unattended"] },
+    "route": { "type": "string" },
+    "owner_scope": { "type": "object" },
+    "budget": { "type": "object" },
+    "maker": { "type": "object" },
+    "checker": { "type": "object" },
+    "gates": { "type": "object" },
+    "risk": { "type": "object" }
+  },
+  "additionalProperties": true
+}

package/schemas/loops/loop-plan.schema.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://sneakoscope.dev/schemas/loops/loop-plan.schema.json",
+  "title": "SKS Loop Plan",
+  "type": "object",
+  "required": ["schema", "mission_id", "request", "planner", "graph", "integration_loop_id", "blockers"],
+  "properties": {
+    "schema": { "const": "sks.loop-plan.v1" },
+    "mission_id": { "type": "string" },
+    "request": { "type": "string" },
+    "generated_at": { "type": "string" },
+    "planner": { "type": "object" },
+    "graph": { "type": "object" },
+    "global_budget": { "type": "object" },
+    "safety": { "type": "object" },
+    "integration_loop_id": { "type": "string" },
+    "compatibility": { "type": "object" },
+    "blockers": { "type": "array", "items": { "type": "string" } }
+  },
+  "additionalProperties": true
+}

package/schemas/loops/loop-proof.schema.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://sneakoscope.dev/schemas/loops/loop-proof.schema.json",
+  "title": "SKS Loop Proof",
+  "type": "object",
+  "required": ["schema", "mission_id", "loop_id", "status", "maker_result", "checker_result", "gate_result", "budget", "changed_files", "blockers"],
+  "properties": {
+    "schema": { "const": "sks.loop-proof.v1" },
+    "mission_id": { "type": "string" },
+    "loop_id": { "type": "string" },
+    "status": { "type": "string" },
+    "maker_result": { "type": "object" },
+    "checker_result": { "type": "object" },
+    "gate_result": { "type": "object" },
+    "budget": { "type": "object" },
+    "changed_files": { "type": "array", "items": { "type": "string" } },
+    "blockers": { "type": "array", "items": { "type": "string" } }
+  },
+  "additionalProperties": true
+}

package/schemas/loops/loop-state.schema.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://sneakoscope.dev/schemas/loops/loop-state.schema.json",
+  "title": "SKS Loop State",
+  "type": "object",
+  "required": ["schema", "mission_id", "loop_id", "status", "iteration", "acting_on", "current_phase", "budget_used", "updated_at"],
+  "properties": {
+    "schema": { "const": "sks.loop-state.v1" },
+    "mission_id": { "type": "string" },
+    "loop_id": { "type": "string" },
+    "status": { "type": "string" },
+    "iteration": { "type": "number" },
+    "acting_on": { "type": "object" },
+    "current_phase": { "type": "string" },
+    "budget_used": { "type": "object" },
+    "updated_at": { "type": "string" }
+  },
+  "additionalProperties": true
+}