blitzstrike 2.4.29 → 2.4.30

package/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to Blitz Strike are documented here.
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/).
 
+## [2.4.30] — 2026-09-14
+
+### Added — Proof-Obligation Engine (structure by construction)
+
+- New `src/obligations.ts`: append-only obligation ledger — every hypothesis
+  is an OPEN proof debt that must be discharged (verified/refuted/blocked).
+- New tools: `next_obligation` (single-decision loop: return the top open
+  obligation + the exact test), `discharge_obligation` (verified/refuted/
+  blocked), `obligations` (ledger + deterministic `complete` gate).
+- `engagement_track` (pending) now auto-creates an obligation; `generate_report`
+  is GATED — it warns while open proof debt remains.
+- System prompt: the LLM drives the engagement as a single-decision loop; it
+  holds no plan in its head — the ledger is the single source of truth.
+
 ## [2.4.29] — 2026-09-14
 
 ### Added — Enterprise compliance mapping (CWE -> frameworks)

package/dist/index.js

@@ -15493,9 +15493,9 @@ async function checkMcpServers() {
 var init_mcp_status = () => {};
 
 // src/sync.ts
-import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync7, readFileSync as readFileSync19, readdirSync as readdirSync7, statSync as statSync4, rmSync as rmSync4 } from "node:fs";
-import { join as join18 } from "node:path";
-import { homedir as homedir9 } from "node:os";
+import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync8, readFileSync as readFileSync20, readdirSync as readdirSync7, statSync as statSync4, rmSync as rmSync4 } from "node:fs";
+import { join as join19 } from "node:path";
+import { homedir as homedir10 } from "node:os";
 import { fileURLToPath as fileURLToPath9 } from "node:url";
 import { spawnSync as spawnSync4 } from "node:child_process";
 function dirExists(p) {
@@ -15511,7 +15511,7 @@ function countFiles(dir) {
     const walk = (d) => {
       for (const e of readdirSync7(d, { withFileTypes: true })) {
         if (e.isDirectory())
-          walk(join18(d, e.name));
+          walk(join19(d, e.name));
         else
           n++;
       }
@@ -15524,9 +15524,9 @@ function countFiles(dir) {
 }
 function syncData() {
   if (!dirExists(DATA_ROOT2))
-    mkdirSync8(DATA_ROOT2, { recursive: true });
-  const payloadsPath = join18(DATA_ROOT2, "payloads");
-  const templatesPath = join18(DATA_ROOT2, "templates");
+    mkdirSync9(DATA_ROOT2, { recursive: true });
+  const payloadsPath = join19(DATA_ROOT2, "payloads");
+  const templatesPath = join19(DATA_ROOT2, "templates");
   const hasPayloads = dirExists(payloadsPath) && countFiles(payloadsPath) > 0;
   const hasTemplates = dirExists(templatesPath) && countFiles(templatesPath) > 0;
   if (hasPayloads && hasTemplates) {
@@ -15536,8 +15536,8 @@ function syncData() {
       data_root: DATA_ROOT2
     };
   }
-  const localPayloads = join18(ROOT7, "payloads");
-  const localTemplates = join18(ROOT7, "templates");
+  const localPayloads = join19(ROOT7, "payloads");
+  const localTemplates = join19(ROOT7, "templates");
   let payloadsSynced = false;
   let templatesSynced = false;
   if (!hasPayloads && dirExists(localPayloads)) {
@@ -15550,7 +15550,7 @@ function syncData() {
   }
   const gitOk = spawnSync4("git", ["--version"]).status === 0;
   if (gitOk && (!dirExists(payloadsPath) || countFiles(payloadsPath) === 0 || !dirExists(templatesPath) || countFiles(templatesPath) === 0)) {
-    const tmp = join18(DATA_ROOT2, ".tmp-clone");
+    const tmp = join19(DATA_ROOT2, ".tmp-clone");
     if (dirExists(tmp))
       rmSync4(tmp, { recursive: true, force: true });
     const r = spawnSync4("git", ["clone", "--depth", "1", "--filter=blob:none", "--sparse", GITHUB_REPO, tmp], { timeout: 120000 });
@@ -15558,11 +15558,11 @@ function syncData() {
       const sparse = spawnSync4("git", ["-C", tmp, "sparse-checkout", "set", "payloads", "templates"], { timeout: 120000 });
       if (sparse.status === 0) {
         if (!dirExists(payloadsPath) || countFiles(payloadsPath) === 0) {
-          copyDir(join18(tmp, "payloads"), payloadsPath);
+          copyDir(join19(tmp, "payloads"), payloadsPath);
           payloadsSynced = true;
         }
         if (!dirExists(templatesPath) || countFiles(templatesPath) === 0) {
-          copyDir(join18(tmp, "templates"), templatesPath);
+          copyDir(join19(tmp, "templates"), templatesPath);
           templatesSynced = true;
         }
       }
@@ -15582,20 +15582,20 @@ function copyDir(src, dst) {
   }
 }
 function manualCopy(src, dst) {
-  mkdirSync8(dst, { recursive: true });
+  mkdirSync9(dst, { recursive: true });
   for (const e of readdirSync7(src, { withFileTypes: true })) {
-    const s = join18(src, e.name);
-    const d = join18(dst, e.name);
+    const s = join19(src, e.name);
+    const d = join19(dst, e.name);
     if (e.isDirectory())
       manualCopy(s, d);
     else
-      writeFileSync7(d, readFileSync19(s));
+      writeFileSync8(d, readFileSync20(s));
   }
 }
 var ROOT7, DATA_ROOT2, GITHUB_REPO = "https://github.com/shinthink/blitzstrike.git";
 var init_sync = __esm(() => {
-  ROOT7 = join18(fileURLToPath9(new URL(".", import.meta.url)), "..");
-  DATA_ROOT2 = process.env.BLITZSTRIKE_DATA ?? join18(homedir9(), ".blitzstrike", "data");
+  ROOT7 = join19(fileURLToPath9(new URL(".", import.meta.url)), "..");
+  DATA_ROOT2 = process.env.BLITZSTRIKE_DATA ?? join19(homedir10(), ".blitzstrike", "data");
 });
 
 // src/update.ts
@@ -15640,15 +15640,15 @@ var init_update = __esm(() => {
 });
 
 // src/release.ts
-import { readFileSync as readFileSync21, existsSync as existsSync11 } from "node:fs";
-import { join as join19 } from "node:path";
+import { readFileSync as readFileSync22, existsSync as existsSync12 } from "node:fs";
+import { join as join20 } from "node:path";
 import { fileURLToPath as fileURLToPath10 } from "node:url";
 import { execSync as execSync2 } from "node:child_process";
 function validateRelease() {
   const checks = [];
   checks.push({ name: "package.json version", ok: true, detail: VERSION });
   try {
-    const changelog = readFileSync21(join19(ROOT8, "CHANGELOG.md"), "utf8");
+    const changelog = readFileSync22(join20(ROOT8, "CHANGELOG.md"), "utf8");
     const m = changelog.match(/^##\s+\[([0-9]+\.[0-9]+\.[0-9]+)\]/m);
     const changelogVersion = m?.[1] ?? null;
     checks.push({
@@ -15680,22 +15680,22 @@ function validateRelease() {
   return { version: VERSION, checks, consistent: checks.filter((c) => !c.soft).every((c) => c.ok) };
 }
 function lockfilePresent() {
-  return existsSync11(join19(ROOT8, "package-lock.json")) || existsSync11(join19(ROOT8, "bun.lock")) || existsSync11(join19(ROOT8, "bun.lockb"));
+  return existsSync12(join20(ROOT8, "package-lock.json")) || existsSync12(join20(ROOT8, "bun.lock")) || existsSync12(join20(ROOT8, "bun.lockb"));
 }
 var ROOT8;
 var init_release = __esm(() => {
   init_version();
-  ROOT8 = join19(fileURLToPath10(new URL(".", import.meta.url)), "..");
+  ROOT8 = join20(fileURLToPath10(new URL(".", import.meta.url)), "..");
 });
 
 // src/dependency.ts
-import { readFileSync as readFileSync22 } from "node:fs";
-import { join as join20 } from "node:path";
+import { readFileSync as readFileSync23 } from "node:fs";
+import { join as join21 } from "node:path";
 import { fileURLToPath as fileURLToPath11 } from "node:url";
 function checkDependencies() {
   let pkg = {};
   try {
-    pkg = JSON.parse(readFileSync22(join20(ROOT9, "package.json"), "utf8"));
+    pkg = JSON.parse(readFileSync23(join21(ROOT9, "package.json"), "utf8"));
   } catch {
     return { install_scripts: [], git_dependencies: [], total_dependencies: 0, safe: false };
   }
@@ -15718,13 +15718,13 @@ function checkDependencies() {
 }
 var ROOT9;
 var init_dependency = __esm(() => {
-  ROOT9 = join20(fileURLToPath11(new URL(".", import.meta.url)), "..");
+  ROOT9 = join21(fileURLToPath11(new URL(".", import.meta.url)), "..");
 });
 
 // src/cli.ts
-import { readFileSync as readFileSync23, existsSync as existsSync12, writeFileSync as writeFileSync8, mkdirSync as mkdirSync9 } from "node:fs";
-import { join as join21, dirname as dirname2 } from "node:path";
-import { homedir as homedir10 } from "node:os";
+import { readFileSync as readFileSync24, existsSync as existsSync13, writeFileSync as writeFileSync9, mkdirSync as mkdirSync10 } from "node:fs";
+import { join as join22, dirname as dirname2 } from "node:path";
+import { homedir as homedir11 } from "node:os";
 import { fileURLToPath as fileURLToPath12 } from "node:url";
 import { spawnSync as spawnSync5 } from "node:child_process";
 function which(cmd) {
@@ -15768,7 +15768,7 @@ async function runDoctor() {
     detail: h1 ? `X-HackerOne-Research: ${h1}` : "H1_USERNAME not set",
     fix: h1 ? undefined : "export H1_USERNAME=<your-hackerone-username> (adds X-HackerOne-Research to outbound requests)"
   });
-  const dataOk = existsSync12(join21(ROOT10, "chains.json")) && existsSync12(join21(ROOT10, "tools-catalog.json"));
+  const dataOk = existsSync13(join22(ROOT10, "chains.json")) && existsSync13(join22(ROOT10, "tools-catalog.json"));
   issues.push({
     name: "Data layers (chains + tools-catalog)",
     status: dataOk ? "ok" : "fail",
@@ -15819,21 +15819,21 @@ BlitzStrike — ${verdict}`);
 function resolveCommand() {
   if (which("blitzstrike"))
     return { command: "blitzstrike", args: ["serve", "--mcp"] };
-  const src = join21(ROOT10, "src", "index.ts");
-  if (which("bun") && existsSync12(src))
+  const src = join22(ROOT10, "src", "index.ts");
+  if (which("bun") && existsSync13(src))
     return { command: "bun", args: ["run", src, "serve", "--mcp"] };
   if (which("npx"))
     return { command: "npx", args: ["-y", "blitzstrike", "serve", "--mcp"] };
   if (which("bunx"))
     return { command: "bunx", args: ["blitzstrike", "serve", "--mcp"] };
-  const dist = join21(ROOT10, "dist", "index.js");
-  if (existsSync12(dist))
+  const dist = join22(ROOT10, "dist", "index.js");
+  if (existsSync13(dist))
     return { command: "bun", args: [dist, "serve", "--mcp"] };
   return { command: "npx", args: ["-y", "blitzstrike", "serve", "--mcp"] };
 }
 function readJson(p) {
   try {
-    return JSON.parse(readFileSync23(p, "utf8"));
+    return JSON.parse(readFileSync24(p, "utf8"));
   } catch {
     return null;
   }
@@ -15841,51 +15841,51 @@ function readJson(p) {
 function jsonMcpServersWrite(p) {
   return (command, args) => {
     const dir = dirname2(p);
-    if (!existsSync12(dir))
-      mkdirSync9(dir, { recursive: true });
+    if (!existsSync13(dir))
+      mkdirSync10(dir, { recursive: true });
     const existing = readJson(p) ?? {};
     existing.mcpServers = {
       ...existing.mcpServers ?? {},
       blitzstrike: { command, args }
     };
-    writeFileSync8(p, JSON.stringify(existing, null, 2));
+    writeFileSync9(p, JSON.stringify(existing, null, 2));
   };
 }
 function opencodeWrite(p) {
   return (command, args) => {
     const dir = dirname2(p);
-    if (!existsSync12(dir))
-      mkdirSync9(dir, { recursive: true });
+    if (!existsSync13(dir))
+      mkdirSync10(dir, { recursive: true });
     const existing = readJson(p) ?? {};
     existing.mcp = {
       ...existing.mcp ?? {},
       blitzstrike: { type: "local", command: [command, ...args], enabled: true }
     };
-    writeFileSync8(p, JSON.stringify(existing, null, 2));
+    writeFileSync9(p, JSON.stringify(existing, null, 2));
     copyOpenCodeAgents();
   };
 }
 function copyOpenCodeAgents() {
-  const srcDir = join21(ROOT10, "opencode-agents");
-  const dstDir = join21(homedir10(), ".config", "opencode", "agents");
-  if (!existsSync12(srcDir))
+  const srcDir = join22(ROOT10, "opencode-agents");
+  const dstDir = join22(homedir11(), ".config", "opencode", "agents");
+  if (!existsSync13(srcDir))
     return;
-  if (!existsSync12(dstDir))
-    mkdirSync9(dstDir, { recursive: true });
+  if (!existsSync13(dstDir))
+    mkdirSync10(dstDir, { recursive: true });
   for (const f of ["Blitz Strike.md", "Blitz.md", "Eagle Eye.md", "Strike.md"]) {
-    const src = join21(srcDir, f);
-    const dst = join21(dstDir, f);
-    if (existsSync12(src)) {
-      writeFileSync8(dst, readFileSync23(src, "utf8"));
+    const src = join22(srcDir, f);
+    const dst = join22(dstDir, f);
+    if (existsSync13(src)) {
+      writeFileSync9(dst, readFileSync24(src, "utf8"));
     }
   }
 }
 function codexWrite(p) {
   return (command, args) => {
     const dir = dirname2(p);
-    if (!existsSync12(dir))
-      mkdirSync9(dir, { recursive: true });
-    let existing = existsSync12(p) ? readFileSync23(p, "utf8") : "";
+    if (!existsSync13(dir))
+      mkdirSync10(dir, { recursive: true });
+    let existing = existsSync13(p) ? readFileSync24(p, "utf8") : "";
     if (!existing.trimEnd().endsWith(`
 `))
       existing += `
@@ -15896,15 +15896,15 @@ function codexWrite(p) {
 command = "${command}"
 args = ${JSON.stringify(args)}
 `;
-    writeFileSync8(p, existing);
+    writeFileSync9(p, existing);
   };
 }
 function hermesWrite(p) {
   return (command, args) => {
     const dir = dirname2(p);
-    if (!existsSync12(dir))
-      mkdirSync9(dir, { recursive: true });
-    let existing = existsSync12(p) ? readFileSync23(p, "utf8") : "";
+    if (!existsSync13(dir))
+      mkdirSync10(dir, { recursive: true });
+    let existing = existsSync13(p) ? readFileSync24(p, "utf8") : "";
     existing = existing.replace(/^  blitzstrike:\n(?:    .*\n?)*/m, "");
     if (!existing.trimEnd().endsWith(`
 `))
@@ -15925,80 +15925,80 @@ mcp_servers:
     args: ${JSON.stringify(args)}
 `;
     }
-    writeFileSync8(p, existing);
+    writeFileSync9(p, existing);
   };
 }
 function detectAgents() {
-  const home = homedir10();
+  const home = homedir11();
   const agents = [];
-  const claudeJson = join21(home, ".claude.json");
+  const claudeJson = join22(home, ".claude.json");
   agents.push({
     name: "Claude Code",
     detectPath: claudeJson,
-    installed: () => existsSync12(claudeJson) || which("claude"),
+    installed: () => existsSync13(claudeJson) || which("claude"),
     write: jsonMcpServersWrite(claudeJson)
   });
-  const claudeDesktop = join21(home, ".config", "Claude", "claude_desktop_config.json");
+  const claudeDesktop = join22(home, ".config", "Claude", "claude_desktop_config.json");
   agents.push({
     name: "Claude Desktop",
     detectPath: claudeDesktop,
-    installed: () => existsSync12(claudeDesktop),
+    installed: () => existsSync13(claudeDesktop),
     write: jsonMcpServersWrite(claudeDesktop)
   });
-  const cursor = join21(home, ".cursor", "mcp.json");
+  const cursor = join22(home, ".cursor", "mcp.json");
   agents.push({
     name: "Cursor",
     detectPath: cursor,
-    installed: () => existsSync12(join21(home, ".cursor")) || which("cursor"),
+    installed: () => existsSync13(join22(home, ".cursor")) || which("cursor"),
     write: jsonMcpServersWrite(cursor)
   });
-  const opencode = join21(home, ".config", "opencode", "opencode.jsonc");
+  const opencode = join22(home, ".config", "opencode", "opencode.jsonc");
   agents.push({
     name: "OpenCode",
     detectPath: opencode,
-    installed: () => existsSync12(join21(home, ".config", "opencode")) || which("opencode"),
+    installed: () => existsSync13(join22(home, ".config", "opencode")) || which("opencode"),
     write: opencodeWrite(opencode)
   });
-  const codex = join21(home, ".codex", "config.toml");
+  const codex = join22(home, ".codex", "config.toml");
   agents.push({
     name: "Codex",
     detectPath: codex,
-    installed: () => existsSync12(join21(home, ".codex")) || which("codex"),
+    installed: () => existsSync13(join22(home, ".codex")) || which("codex"),
     write: codexWrite(codex)
   });
-  const hermes = join21(home, ".hermes", "config.yaml");
+  const hermes = join22(home, ".hermes", "config.yaml");
   agents.push({
     name: "Hermes",
     detectPath: hermes,
-    installed: () => existsSync12(join21(home, ".hermes")) || which("hermes"),
+    installed: () => existsSync13(join22(home, ".hermes")) || which("hermes"),
     write: hermesWrite(hermes)
   });
-  const gemini = join21(home, ".gemini", "settings.json");
+  const gemini = join22(home, ".gemini", "settings.json");
   agents.push({
     name: "Gemini CLI",
     detectPath: gemini,
-    installed: () => existsSync12(join21(home, ".gemini")) || which("gemini"),
+    installed: () => existsSync13(join22(home, ".gemini")) || which("gemini"),
     write: jsonMcpServersWrite(gemini)
   });
-  const windsurf = join21(home, ".codeium", "windsurf", "mcp_config.json");
+  const windsurf = join22(home, ".codeium", "windsurf", "mcp_config.json");
   agents.push({
     name: "Windsurf",
     detectPath: windsurf,
-    installed: () => existsSync12(join21(home, ".codeium")) || which("windsurf"),
+    installed: () => existsSync13(join22(home, ".codeium")) || which("windsurf"),
     write: jsonMcpServersWrite(windsurf)
   });
-  const copilot = join21(home, ".copilot", "mcp.json");
+  const copilot = join22(home, ".copilot", "mcp.json");
   agents.push({
     name: "Copilot",
     detectPath: copilot,
-    installed: () => existsSync12(join21(home, ".copilot")),
+    installed: () => existsSync13(join22(home, ".copilot")),
     write: jsonMcpServersWrite(copilot)
   });
-  const cline = join21(home, ".cline", "mcp_settings.json");
+  const cline = join22(home, ".cline", "mcp_settings.json");
   agents.push({
     name: "Cline",
     detectPath: cline,
-    installed: () => existsSync12(join21(home, ".cline")),
+    installed: () => existsSync13(join22(home, ".cline")),
     write: jsonMcpServersWrite(cline)
   });
   return agents;
@@ -16116,7 +16116,7 @@ var init_cli = __esm(() => {
   init_release();
   init_dependency();
   init_mcp_status();
-  ROOT10 = join21(fileURLToPath12(new URL(".", import.meta.url)), "..");
+  ROOT10 = join22(fileURLToPath12(new URL(".", import.meta.url)), "..");
 });
 
 // node_modules/zod/v3/helpers/util.js
@@ -30754,7 +30754,7 @@ class StdioServerTransport {
 
 // src/server.ts
 init_scanner();
-import { readFileSync as readFileSync20 } from "node:fs";
+import { readFileSync as readFileSync21 } from "node:fs";
 
 // src/recon.ts
 var TIMEOUT_MS = 25000;
@@ -56578,17 +56578,133 @@ function runBenchmark() {
   };
 }
 
+// src/obligations.ts
+import { readFileSync as readFileSync18, appendFileSync as appendFileSync4, mkdirSync as mkdirSync8, existsSync as existsSync10, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join17 } from "node:path";
+import { createHash as createHash6 } from "node:crypto";
+import { homedir as homedir9 } from "node:os";
+var HOME_DIR4 = process.env.BLITZSTRIKE_HOME ?? join17(homedir9(), ".blitzstrike");
+var OBLIGATION_PATH = join17(HOME_DIR4, "obligations.jsonl");
+function ensureDir3() {
+  if (!existsSync10(HOME_DIR4))
+    mkdirSync8(HOME_DIR4, { recursive: true });
+}
+function shortId2(claim) {
+  return `obl-${createHash6("sha256").update(`${claim}\x00${Date.now()}`).digest("hex").slice(0, 12)}`;
+}
+function loadObligations() {
+  if (!existsSync10(OBLIGATION_PATH))
+    return [];
+  try {
+    const out = [];
+    for (const line of readFileSync18(OBLIGATION_PATH, "utf8").split(`
+`)) {
+      const t = line.trim();
+      if (!t)
+        continue;
+      try {
+        out.push(JSON.parse(t));
+      } catch {}
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+function append3(o) {
+  ensureDir3();
+  appendFileSync4(OBLIGATION_PATH, JSON.stringify(o) + `
+`);
+}
+function rewrite(entries) {
+  ensureDir3();
+  writeFileSync7(OBLIGATION_PATH, entries.map((e) => JSON.stringify(e)).join(`
+`) + (entries.length ? `
+` : ""));
+}
+function createObligation(input) {
+  const o = {
+    id: shortId2(input.claim),
+    claim: input.claim.trim(),
+    status: "open",
+    next_action: input.next_action ?? "Verify live (strike_verify marker + negative control) or read-verify (verify_file_read), then strike_resolve.",
+    evidence_required: input.evidence_required ?? "marker reflected + negative control inert (SHA-256-tagged evidence)",
+    correlation_id: input.correlation_id,
+    created: new Date().toISOString()
+  };
+  append3(o);
+  return o;
+}
+function listObligations() {
+  const all = loadObligations();
+  const open = all.filter((o) => o.status === "open");
+  return {
+    total: all.length,
+    open: open.length,
+    verified: all.filter((o) => o.status === "verified").length,
+    refuted: all.filter((o) => o.status === "refuted").length,
+    blocked: all.filter((o) => o.status === "blocked").length,
+    done: all.length - open.length,
+    complete: open.length === 0,
+    open_obligations: open.map((o) => ({ id: o.id, claim: o.claim, next_action: o.next_action, evidence_required: o.evidence_required, correlation_id: o.correlation_id, created: o.created }))
+  };
+}
+function nextObligation() {
+  const open = loadObligations().filter((o) => o.status === "open");
+  if (open.length === 0) {
+    return { done: true, note: "No open proof obligations — every hypothesis is verified/refuted/blocked. Proceed to generate_report." };
+  }
+  const next = open[0];
+  return {
+    done: false,
+    remaining: open.length,
+    obligation: {
+      id: next.id,
+      claim: next.claim,
+      next_action: next.next_action,
+      evidence_required: next.evidence_required,
+      correlation_id: next.correlation_id
+    },
+    instruction: `Discharge this obligation: ${next.next_action}. Evidence required: ${next.evidence_required}. Then discharge_obligation(id, status=verified|refuted|blocked).`
+  };
+}
+function dischargeObligation(input) {
+  const all = loadObligations();
+  const target = input.id ? all.find((o) => o.id === input.id) : input.correlation_id ? all.find((o) => o.correlation_id === input.correlation_id && o.status === "open") : undefined;
+  if (!target) {
+    return { discharged: false, error: "obligation not found", id: input.id, correlation_id: input.correlation_id };
+  }
+  if (target.status !== "open") {
+    return { discharged: false, duplicate: true, id: target.id, note: `already ${target.status}` };
+  }
+  target.status = input.status;
+  target.discharged = new Date().toISOString();
+  rewrite(all);
+  const remaining = all.filter((o) => o.status === "open").length;
+  return {
+    discharged: true,
+    id: target.id,
+    claim: target.claim,
+    status: target.status,
+    remaining_open: remaining,
+    ...remaining === 0 ? { hint: "All proof obligations discharged — proceed to generate_report." } : {}
+  };
+}
+function openCount() {
+  return loadObligations().filter((o) => o.status === "open").length;
+}
+
 // src/enterprise-benchmark.ts
-import { existsSync as existsSync10, readFileSync as readFileSync18, readdirSync as readdirSync6, statSync as statSync3 } from "node:fs";
-import { join as join17, resolve } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync19, readdirSync as readdirSync6, statSync as statSync3 } from "node:fs";
+import { join as join18, resolve } from "node:path";
 var ROOT6 = resolve(process.cwd(), "bench", "enterprise");
 var ENTERPRISE_FIXTURES = [
-  { id: "php-laravel", dir: join17(ROOT6, "php-laravel"), expected_vulns: 4 },
-  { id: "js-express", dir: join17(ROOT6, "js-express"), expected_vulns: 2 },
-  { id: "py-django", dir: join17(ROOT6, "py-django"), expected_vulns: 2 },
-  { id: "java-spring", dir: join17(ROOT6, "java-spring"), expected_vulns: 2 },
-  { id: "wp-batch-route", dir: join17(ROOT6, "wp-batch-route"), expected_vulns: 1 },
-  { id: "php-complex", dir: join17(ROOT6, "php-complex"), expected_vulns: 4 }
+  { id: "php-laravel", dir: join18(ROOT6, "php-laravel"), expected_vulns: 4 },
+  { id: "js-express", dir: join18(ROOT6, "js-express"), expected_vulns: 2 },
+  { id: "py-django", dir: join18(ROOT6, "py-django"), expected_vulns: 2 },
+  { id: "java-spring", dir: join18(ROOT6, "java-spring"), expected_vulns: 2 },
+  { id: "wp-batch-route", dir: join18(ROOT6, "wp-batch-route"), expected_vulns: 1 },
+  { id: "php-complex", dir: join18(ROOT6, "php-complex"), expected_vulns: 4 }
 ];
 function sourceFiles(root) {
   const out = [];
@@ -56600,7 +56716,7 @@ function sourceFiles(root) {
       return;
     }
     for (const e of entries) {
-      const p = join17(dir, e);
+      const p = join18(dir, e);
       let st;
       try {
         st = statSync3(p);
@@ -56621,7 +56737,7 @@ function detectFixture(dir) {
   for (const f of sourceFiles(dir)) {
     let code;
     try {
-      code = readFileSync18(f, "utf8");
+      code = readFileSync19(f, "utf8");
     } catch {
       continue;
     }
@@ -56639,7 +56755,7 @@ function detectFixture(dir) {
 function runEnterpriseBenchmark() {
   const fixtures = [];
   for (const fx of ENTERPRISE_FIXTURES) {
-    if (!existsSync10(fx.dir)) {
+    if (!existsSync11(fx.dir)) {
       fixtures.push({ id: fx.id, available: false, detected: 0, expected: fx.expected_vulns, recall: 0 });
       continue;
     }
@@ -56810,7 +56926,7 @@ function createServer() {
   }, {
     instructions: "Blitz Strike — deterministic security-audit toolbelt. You reason; its tools do the deterministic work (scan, taint, verify, evidence).\\n\\n" + "FIRST ACTION (when the user says test / scan / audit / engagement / pentest <URL or path>):\\n" + "- Call run_engagement(target) — or run_autonomous(target) to also get escalation paths. ONE call runs the whole engagement (recon -> sweep -> checks -> report).\\n" + "- NEVER do manual live_recon / blitz_scan first, and never fall back to manual probing. Manual tools are ONLY for follow-up AFTER run_engagement, or when the user names a specific sub-step.\\n\\n" + "RULES (never violate):\\n" + `- A hit is a HYPOTHESIS; live verification (marker + negative control) is the verdict. Never report unverified.
 ` + `- run_engagement / run_autonomous return status DETECTED (NOT "complete") — that is the signal to VERIFY. After detection you MUST strike_verify (or verify_file_read for CWE-22, drive_devtools for DOM/JS precision) on each finding, then generate_report. Detection without verification is NOT a deliverable.
-` + "- scope_check is intel-only, never gates. No scope = proceed (repo disclaimer carries responsibility). No authorization gate — hunt the target you are given.\\n" + "- strike_verify + live checks AUTO-attempt WAF bypass. Don't report 'needs bypass' without re-probing.\\n" + "- NEVER ask 'should I continue?' / 'say the word' / 'want me to pursue' / 'next?' — that is a hard violation. Execute the full chain autonomously until COMPLETE. COMPLETE means every lead verified/blocked AND every reachable chain step executed or blocked (no deferred escalations). Pause only: destructive/DoS consent, external block (OTP/cred), or genuine COMPLETE.\\n" + "- One hard stop: malicious/third-party infra ('find the actor') -> static + takedown only.\\n" + "- FINDING LIFECYCLE (stateful — never loop stateless tools): advance findings via finding_create -> strike_verify -> strike_resolve. finding_transition now takes a FULL finding JSON + target status and RETURNS the updated finding (pass the object, never a status string); a bad move returns 'illegal transition' + the legal next states. confidence_score is DETERMINISTIC (same factors -> same score) — call it ONCE, never retry; it changes nothing. SELF-HARDENING: when a finding is verified false_positive, call capture_false_positive(code, language, detector, note) with the triggering code so the detector gets more precise every engagement.\\n\\n" + "CHAIN DECISIONS (a confirmed finding is the START, not the end):\\n" + "- For each confirmed finding, enumerate follow-ups with list_chains + chain_links: ESCALATE (what it becomes), CHAIN (compose with other findings), BYPASS, PIVOT (new surface now reachable).\\n" + "- Ask the chain-aware question: 'I found X -> what can I NOW read / do / access?' e.g. SQLi -> query the DB for credentials AND for the Werkzeug console PIN / secrets / source; LFI -> read configs, keys, PIN inputs; cred dump -> crack offline -> authenticate -> privileged actions.\\n" + "- Every follow-up is a HYPOTHESIS — verify each before it enters the report. Don't stop at 'found SQLi'; follow where the chain leads.\\n" + "- EXECUTE follow-ups NOW, not as 'next phase': any leaked source/error -> scan_leaked_source(text) to enumerate sinks (eval/exec/SECRET_KEY/creds) then exploit each; dumped hashes -> crack_hash(hash) now; hidden-content IDOR -> test the direct route. A 'next chain' you write is a TODO — run it, never leave it as a recommendation.\\n\\n" + "- DOCTRINE — 'if you can continue, why not? if possible, why not try?': a chain step you CAN execute is one you MUST execute. A PREREQUISITE is a chain step, NOT a separate engagement — e.g. a CORS->session-theft chain needing 'a foothold on any subdomain (XSS / dangling-DNS takeover)' means CHECK for it NOW: resolve every allowlisted subdomain and test each for dangling delegation (NXDOMAIN, unclaimed S3/bucket, dangling SaaS CNAME) + probe for XSS — do NOT write 'dangling-DNS audit is the next engagement'. Declaring COMPLETE while a reachable chain step is deferred is a violation.\\n\\n" + `DELIVERABLE + PERSISTENCE (recon is INPUT, not output):
+` + "- scope_check is intel-only, never gates. No scope = proceed (repo disclaimer carries responsibility). No authorization gate — hunt the target you are given.\\n" + "- strike_verify + live checks AUTO-attempt WAF bypass. Don't report 'needs bypass' without re-probing.\\n" + "- NEVER ask 'should I continue?' / 'say the word' / 'want me to pursue' / 'next?' — that is a hard violation. Execute the full chain autonomously until COMPLETE. COMPLETE means every lead verified/blocked AND every reachable chain step executed or blocked (no deferred escalations). Pause only: destructive/DoS consent, external block (OTP/cred), or genuine COMPLETE.\\n" + "- One hard stop: malicious/third-party infra ('find the actor') -> static + takedown only.\\n" + "- FINDING LIFECYCLE (stateful — never loop stateless tools): advance findings via finding_create -> strike_verify -> strike_resolve. finding_transition now takes a FULL finding JSON + target status and RETURNS the updated finding (pass the object, never a status string); a bad move returns 'illegal transition' + the legal next states. confidence_score is DETERMINISTIC (same factors -> same score) — call it ONCE, never retry; it changes nothing. SELF-HARDENING: when a finding is verified false_positive, call capture_false_positive(code, language, detector, note) with the triggering code so the detector gets more precise every engagement. PROOF-OBLIGATION LOOP (the structure, not a prompt): every pending hypothesis is an OPEN obligation. Drive the engagement as a single-decision loop — next_obligation() -> run the ONE test it names -> discharge_obligation(id, status=verified|refuted|blocked). COMPLETE is gated on zero open obligations (obligations().complete); generate_report warns while any remain. You hold NO plan in your head — the ledger is the single source of truth for what work remains.\\n\\n" + "CHAIN DECISIONS (a confirmed finding is the START, not the end):\\n" + "- For each confirmed finding, enumerate follow-ups with list_chains + chain_links: ESCALATE (what it becomes), CHAIN (compose with other findings), BYPASS, PIVOT (new surface now reachable).\\n" + "- Ask the chain-aware question: 'I found X -> what can I NOW read / do / access?' e.g. SQLi -> query the DB for credentials AND for the Werkzeug console PIN / secrets / source; LFI -> read configs, keys, PIN inputs; cred dump -> crack offline -> authenticate -> privileged actions.\\n" + "- Every follow-up is a HYPOTHESIS — verify each before it enters the report. Don't stop at 'found SQLi'; follow where the chain leads.\\n" + "- EXECUTE follow-ups NOW, not as 'next phase': any leaked source/error -> scan_leaked_source(text) to enumerate sinks (eval/exec/SECRET_KEY/creds) then exploit each; dumped hashes -> crack_hash(hash) now; hidden-content IDOR -> test the direct route. A 'next chain' you write is a TODO — run it, never leave it as a recommendation.\\n\\n" + "- DOCTRINE — 'if you can continue, why not? if possible, why not try?': a chain step you CAN execute is one you MUST execute. A PREREQUISITE is a chain step, NOT a separate engagement — e.g. a CORS->session-theft chain needing 'a foothold on any subdomain (XSS / dangling-DNS takeover)' means CHECK for it NOW: resolve every allowlisted subdomain and test each for dangling delegation (NXDOMAIN, unclaimed S3/bucket, dangling SaaS CNAME) + probe for XSS — do NOT write 'dangling-DNS audit is the next engagement'. Declaring COMPLETE while a reachable chain step is deferred is a violation.\\n\\n" + `DELIVERABLE + PERSISTENCE (recon is INPUT, not output):
 ` + `- The deliverable is a HackerOne-grade FINDING report via generate_report, NEVER a hand-written recon/surface map. Recon is input; confirmed findings are the output.
 ` + `- After recon, VERIFY every lead before it enters the report: strike_verify (marker + negative control) for HTTP, browser_validate for DOM/JS. A lead is a HYPOTHESIS until verified.
 ` + `- A hard block (Cloudflare/WAF/IP-block/captcha) is NOT the end: mark the finding blocked + note the required vantage (residential / authorized / correct-SNI / --resolve direct-to-origin), then CONTINUE to the next lead (origin bypass, non-prod cluster, mobile APK, subdomain).
@@ -57640,7 +57756,37 @@ ${statusLine}` : statusLine },
       status: _enum(["pending", "confirmed", "rejected"]).optional().describe("Defaults to pending.")
     }
   }, async ({ sink, status }) => {
-    return { content: [{ type: "text", text: JSON.stringify(trackHypothesis(sink, status)) }] };
+    const tracked = trackHypothesis(sink, status);
+    if ((status ?? "pending") === "pending") {
+      createObligation({ claim: sink, correlation_id: String(tracked?.id ?? "") });
+    }
+    return { content: [{ type: "text", text: JSON.stringify(tracked) }] };
+  });
+  server.registerTool("next_obligation", {
+    title: "Get the next open proof obligation",
+    description: "PROOF-OBLIGATION (single-decision loop): return the top OPEN hypothesis that still needs verification + the exact deterministic test to discharge it. The LLM asks, executes that one test, then calls discharge_obligation. Never plan from scratch — the ledger is the single source of truth for what work remains.",
+    inputSchema: {}
+  }, async () => {
+    return { content: [{ type: "text", text: JSON.stringify(nextObligation()) }] };
+  });
+  server.registerTool("discharge_obligation", {
+    title: "Discharge a proof obligation",
+    description: "PROOF-OBLIGATION: mark an open obligation as verified (evidence-backed), refuted (false positive), or blocked. Pass the obligation id (from next_obligation) OR a correlation_id. verified means you ran strike_verify and the marker reflected + negative control inert. When the last obligation is discharged the engagement is COMPLETE.",
+    inputSchema: {
+      id: string2().optional().describe("Obligation id (from next_obligation / obligations)"),
+      correlation_id: string2().optional().describe("Correlation id (a finding/hypothesis id)"),
+      status: _enum(["verified", "refuted", "blocked"]).describe("Outcome of the verification"),
+      note: string2().optional().describe("Short note (e.g. evidence reference)")
+    }
+  }, async ({ id, correlation_id, status, note }) => {
+    return { content: [{ type: "text", text: JSON.stringify(dischargeObligation({ id, correlation_id, status, note })) }] };
+  });
+  server.registerTool("obligations", {
+    title: "List all proof obligations",
+    description: "PROOF-OBLIGATION: list the obligation ledger — open/verified/refuted/blocked counts + the open obligations. The `complete` flag is the deterministic gate: an engagement is NOT complete while open > 0.",
+    inputSchema: {}
+  }, async () => {
+    return { content: [{ type: "text", text: JSON.stringify(listObligations()) }] };
   });
   server.registerTool("engagement_status", {
     title: "Engagement status + termination check",
@@ -58014,7 +58160,7 @@ ${statusLine}` : statusLine },
     description: "Route confusion (separate class from source→sink taint): detect attacker-controlled dispatch (call_user_func/forward/dispatch), dynamic method calls ($obj->$m()), dynamic include (LFI), batch/proxy forwarding without per-route auth re-check, and route matching without path normalization.",
     inputSchema: { path: string2().describe("Source file path (PHP)") }
   }, async ({ path }) => {
-    const code = readFileSync20(path, "utf8");
+    const code = readFileSync21(path, "utf8");
     const findings = detectRouteConfusion(code, path);
     return {
       content: [{
@@ -58028,7 +58174,7 @@ ${statusLine}` : statusLine },
     description: "Complex-bug detection beyond taint: deserialization→POP gadget chain (unserialize + magic method), type juggling (loose ==/!= vs hash/secret), mass assignment (extract/parse_str without a safe flag), prototype pollution (unsafe merge of request data), CRLF/header injection (user input into a header), path confusion (user input into a file path without canonicalization), SSRF (user-controlled URL with no host allowlist), XXE (user XML parsed without disabling entities), and SSTI (user input into a template render with no sandbox).",
     inputSchema: { path: string2().describe("Source file path") }
   }, async ({ path }) => {
-    const code = readFileSync20(path, "utf8");
+    const code = readFileSync21(path, "utf8");
     const findings = detectComplexBugs(code, path);
     return {
       content: [{
@@ -58095,7 +58241,7 @@ ${statusLine}` : statusLine },
     let lang = language;
     if (path && !code) {
       try {
-        src = readFileSync20(path, "utf8");
+        src = readFileSync21(path, "utf8");
       } catch {
         return { content: [{ type: "text", text: JSON.stringify({ error: `cannot read ${path}` }) }] };
       }
@@ -58288,9 +58434,14 @@ ${statusLine}` : statusLine },
     const opts = { title, scope, version: VERSION };
     const out = fmt === "json" ? reportJson(list, opts) : reportMarkdown(list, opts);
     const saved = saveReport(out, { title, scope, version: VERSION, format: fmt });
+    const open = openCount();
+    const gate = open > 0 ? `
+
+⚠ PROOF-OBLIGATION GATE: ${open} open obligation(s) remain unverified. Discharge them (next_obligation -> strike_verify -> discharge_obligation) before declaring the engagement complete.
+` : "";
     return { content: [{ type: "text", text: `Report saved to: ${saved.path}
 
-${out}` }] };
+${out}${gate}` }] };
   });
   server.registerTool("run_benchmark", {
     title: "Run the benchmark suite",
@@ -58331,15 +58482,15 @@ async function serve() {
 
 // src/index.ts
 init_cli();
-import { readFileSync as readFileSync24, existsSync as existsSync13 } from "node:fs";
-import { join as join22 } from "node:path";
+import { readFileSync as readFileSync25, existsSync as existsSync14 } from "node:fs";
+import { join as join23 } from "node:path";
 import { fileURLToPath as fileURLToPath13 } from "node:url";
-var ROOT11 = join22(fileURLToPath13(new URL(".", import.meta.url)), "..");
+var ROOT11 = join23(fileURLToPath13(new URL(".", import.meta.url)), "..");
 function readVersion() {
   try {
-    const p = join22(ROOT11, "package.json");
-    if (existsSync13(p))
-      return JSON.parse(readFileSync24(p, "utf8")).version ?? "1.0.0";
+    const p = join23(ROOT11, "package.json");
+    if (existsSync14(p))
+      return JSON.parse(readFileSync25(p, "utf8")).version ?? "1.0.0";
   } catch {}
   return "1.0.0";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blitzstrike",
-  "version": "2.4.29",
+  "version": "2.4.30",
   "description": "Blitz Strike — a universal MCP security-audit toolbelt. BLITZ sweeps the attack surface, EAGLE-EYE traces source-to-sink, STRIKE verifies live. 57 attack chains, 130-tool catalog, intelligence data layer. One server, every agent.",
   "type": "module",
   "bin": {