0sec-cli 0.15.0 → 0.17.0

package/chunks/chunk-UJ4IK5PO.js

@@ -0,0 +1,2010 @@
+#!/usr/bin/env node
+import { createRequire as __0secCreateRequire } from "node:module";
+const require = __0secCreateRequire(import.meta.url);
+import {
+  analyzeFindingForKnownMarkers,
+  detectKnownMarkers,
+  extractFileRefs,
+  redactSensitiveHeaders,
+  require_dist
+} from "./chunk-UM3ZNQIM.js";
+import {
+  __toESM
+} from "./chunk-IR537GON.js";
+
+// packages/core/dist/disclose/screenshots.js
+import { execFileSync } from "node:child_process";
+import { writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+var DEFAULT_OPTS = {
+  binary: "freeze",
+  theme: "dracula",
+  width: 1200,
+  fontSize: 14,
+  background: "#0f1117"
+};
+function slugify(input, max = 40) {
+  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, max);
+}
+function isFreezeAvailable(binary = DEFAULT_OPTS.binary) {
+  try {
+    execFileSync(process.platform === "win32" ? "where" : "which", [binary], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function composeExploitSession(finding) {
+  const lines = [];
+  lines.push(`$ # PoC for: ${finding.title}`);
+  lines.push(`$ # Category: ${finding.category} | severity: ${finding.severity}`);
+  lines.push("");
+  const request = finding.evidence?.request?.trim();
+  const response = finding.evidence?.response?.trim();
+  if (request) {
+    const requestLines = redactSensitiveHeaders(request).split("\n");
+    lines.push(`$ ${requestLines[0]}`);
+    for (const line of requestLines.slice(1)) {
+      lines.push(`  ${line}`);
+    }
+    lines.push("");
+  }
+  if (response) {
+    lines.push(redactSensitiveHeaders(response));
+  }
+  const analysis = finding.evidence?.analysis?.trim();
+  if (analysis) {
+    lines.push("");
+    lines.push("# Agent analysis:");
+    for (const line of analysis.split("\n")) {
+      lines.push(`# ${line}`);
+    }
+  }
+  return lines.join("\n");
+}
+function composeStepSession(finding, step, index, total, result) {
+  const lines = [];
+  lines.push(`$ # PoC step ${index + 1}/${total} \u2014 ${step.kind}: ${step.summary}`);
+  lines.push(`$ # Finding: ${finding.title}`);
+  lines.push("");
+  switch (step.action.type) {
+    case "shell": {
+      const cmdLines = step.action.cmd.split("\n");
+      lines.push(`$ ${cmdLines[0]}`);
+      for (const l of cmdLines.slice(1))
+        lines.push(`  ${l}`);
+      break;
+    }
+    case "http": {
+      lines.push(`$ ${step.action.method.toUpperCase()} ${step.action.url}`);
+      if (step.action.headers) {
+        for (const [k, v] of Object.entries(step.action.headers)) {
+          const headerLine = redactSensitiveHeaders(`${k}: ${v}`);
+          lines.push(`  ${headerLine}`);
+        }
+      }
+      if (step.action.body) {
+        lines.push("");
+        const redactedBody = redactSensitiveHeaders(step.action.body);
+        for (const l of redactedBody.split("\n"))
+          lines.push(`  ${l}`);
+      }
+      break;
+    }
+    case "docker": {
+      lines.push(`$ docker run --rm ${step.action.args.join(" ")} ${step.action.image}`);
+      break;
+    }
+    case "note": {
+      lines.push(`$ # (note) ${step.action.text}`);
+      break;
+    }
+  }
+  if (result) {
+    lines.push("");
+    if (result.observedExit !== void 0) {
+      lines.push(`# exit=${result.observedExit}`);
+    }
+    if (result.observedStatus !== void 0) {
+      lines.push(`# http-status=${result.observedStatus}`);
+    }
+    if (result.observedStdout && result.observedStdout.trim().length > 0) {
+      for (const l of redactSensitiveHeaders(result.observedStdout).split("\n"))
+        lines.push(l);
+    }
+    if (result.observedResponseBody && result.observedResponseBody.trim().length > 0) {
+      for (const l of redactSensitiveHeaders(result.observedResponseBody).split("\n"))
+        lines.push(l);
+    }
+    if (result.observedStderr && result.observedStderr.trim().length > 0) {
+      lines.push("");
+      for (const l of redactSensitiveHeaders(result.observedStderr).split("\n"))
+        lines.push(`# stderr: ${l}`);
+    }
+    lines.push("");
+    lines.push(`# verdict: ${result.kind}${result.error ? ` (${result.error})` : ""}`);
+  } else {
+    if (step.expect) {
+      lines.push("");
+      lines.push(`# expected: ${describeExpect(step.expect)}`);
+    }
+  }
+  return lines.join("\n");
+}
+function describeExpect(expect) {
+  switch (expect.type) {
+    case "exit-zero":
+      return "exit-zero";
+    case "http-status": {
+      const s = Array.isArray(expect.status) ? expect.status.join(",") : expect.status;
+      return `http-status \u2208 {${s}}`;
+    }
+    case "body-contains":
+      return `body contains "${expect.text}"`;
+    case "body-matches":
+      return `body matches /${expect.pattern}/`;
+    case "file-exists":
+      return `file exists at ${expect.path}`;
+  }
+}
+function freezeSessionToPng(sessionFile, pngPath, opts) {
+  try {
+    execFileSync(opts.binary, [
+      sessionFile,
+      "--language",
+      "bash",
+      "--theme",
+      opts.theme,
+      "--window",
+      "--padding",
+      "20,30",
+      "--margin",
+      "10",
+      "--background",
+      opts.background,
+      "--font.size",
+      String(opts.fontSize),
+      "--width",
+      String(opts.width),
+      "-o",
+      pngPath
+    ], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function relativiseFrom(pngPath, markdownDir) {
+  if (!markdownDir)
+    return pngPath;
+  if (pngPath.startsWith(markdownDir))
+    return "." + pngPath.slice(markdownDir.length);
+  return pngPath;
+}
+function renderExploitScreenshot(finding, options) {
+  const opts = { ...DEFAULT_OPTS, ...options };
+  const available = options.available ?? isFreezeAvailable(opts.binary);
+  if (options.pocSteps !== void 0) {
+    if (!available || options.pocSteps.length === 0)
+      return [];
+    mkdirSync(opts.outputDir, { recursive: true });
+    const baseSlug = slugify(`${finding.severity}-${finding.id.slice(0, 8)}-${finding.title}`);
+    const frames = [];
+    for (let i = 0; i < options.pocSteps.length; i++) {
+      const step = options.pocSteps[i];
+      const result = options.stepResults?.[step.id];
+      const stepSlug = `${baseSlug}-step-${i + 1}-${slugify(step.id, 30)}`;
+      const sessionText2 = composeStepSession(finding, step, i, options.pocSteps.length, result);
+      const sessionFile2 = join(opts.outputDir, `${stepSlug}.session.txt`);
+      const pngPath2 = join(opts.outputDir, `${stepSlug}.png`);
+      writeFileSync(sessionFile2, sessionText2, "utf8");
+      const ok2 = freezeSessionToPng(sessionFile2, pngPath2, opts);
+      if (!ok2)
+        continue;
+      frames.push({
+        alt: `exploit-${stepSlug}`,
+        path: pngPath2,
+        relativePath: relativiseFrom(pngPath2, options.markdownDir),
+        caption: `${i + 1}. ${step.summary}`,
+        sessionText: sessionText2,
+        stepId: step.id,
+        frame: i + 1
+      });
+    }
+    return frames;
+  }
+  if (!available)
+    return null;
+  mkdirSync(opts.outputDir, { recursive: true });
+  const slug = slugify(`${finding.severity}-${finding.id.slice(0, 8)}-${finding.title}`);
+  const sessionText = composeExploitSession(finding);
+  const sessionFile = join(opts.outputDir, `${slug}.session.txt`);
+  const pngPath = join(opts.outputDir, `${slug}.png`);
+  writeFileSync(sessionFile, sessionText, "utf8");
+  const ok = freezeSessionToPng(sessionFile, pngPath, opts);
+  if (!ok)
+    return null;
+  return {
+    alt: `exploit-${slug}`,
+    path: pngPath,
+    relativePath: relativiseFrom(pngPath, options.markdownDir),
+    caption: finding.title,
+    sessionText
+  };
+}
+
+// packages/core/dist/disclose/sibling-fix.js
+import { existsSync, readFileSync } from "node:fs";
+import { resolve, join as join2, extname } from "node:path";
+var SIBLING_CUES = [
+  { pattern: /\bthe\s+right\s+gate\s+is\b/i, weight: 0.95, label: "the right gate is" },
+  { pattern: /\bcorrect\s+pattern\b/i, weight: 0.9, label: "correct pattern" },
+  { pattern: /\buses?\s+the\s+correct\b/i, weight: 0.9, label: "uses the correct" },
+  { pattern: /\bproperly\s+checks?\b/i, weight: 0.85, label: "properly checks" },
+  { pattern: /\bsafely\s+handles?\b/i, weight: 0.85, label: "safely handles" },
+  { pattern: /\bgated\s+on\b/i, weight: 0.8, label: "gated on" },
+  { pattern: /\bsibling\b/i, weight: 0.8, label: "sibling" },
+  { pattern: /\bcorrectly\s+(?:gated|checks?|handles?|validates?)\b/i, weight: 0.85, label: "correctly gated/checks/handles" },
+  { pattern: /\bsafe\s+(?:handler|sibling|version)\b/i, weight: 0.8, label: "safe handler/sibling/version" },
+  { pattern: /\bright\s+(?:check|guard|gate)\b/i, weight: 0.8, label: "right check/guard/gate" }
+];
+var VULNERABLE_CUES = [
+  /\bgates?\s+on\s+\w+\s+instead\s+of\b/i,
+  /\bvulnerable\s+at\b/i,
+  /\bwhere\s+the\s+\w+\s+(?:happens|occurs)\b/i,
+  /\bmissing\s+\w+/i,
+  /\bbug\s+is\s+at\b/i,
+  /\binstead\s+of\s+\w+/i
+];
+var LANGUAGE_BY_EXT = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".py": "python",
+  ".rs": "rust",
+  ".go": "go",
+  ".rb": "ruby",
+  ".java": "java",
+  ".kt": "kotlin",
+  ".swift": "swift",
+  ".c": "c",
+  ".h": "c",
+  ".cc": "cpp",
+  ".cpp": "cpp",
+  ".php": "php",
+  ".sh": "bash",
+  ".sql": "sql"
+};
+function languageFor(filePath) {
+  return LANGUAGE_BY_EXT[extname(filePath).toLowerCase()] ?? "";
+}
+function buildHaystack(finding) {
+  return [
+    finding.description,
+    finding.evidence?.analysis,
+    finding.evidence?.request,
+    finding.evidence?.response
+  ].filter((s) => typeof s === "string" && s.length > 0).join("\n\n");
+}
+function sentenceAround(haystack, refToken) {
+  const idx = haystack.indexOf(refToken);
+  if (idx === -1)
+    return "";
+  let start = idx;
+  while (start > 0) {
+    const c = haystack[start - 1];
+    if (c === "." || c === "!" || c === "?" || c === "\n")
+      break;
+    start--;
+  }
+  let end = idx + refToken.length;
+  while (end < haystack.length) {
+    const c = haystack[end];
+    if (c === "." || c === "!" || c === "?" || c === "\n")
+      break;
+    end++;
+  }
+  return haystack.slice(start, end + 1);
+}
+function classifyRef(haystack, ref) {
+  const token = `${ref.file}${ref.line !== void 0 ? `:${ref.line}` : ""}`;
+  const window = sentenceAround(haystack, token);
+  let siblingHit;
+  for (const cue of SIBLING_CUES) {
+    if (cue.pattern.test(window)) {
+      if (!siblingHit || cue.weight > siblingHit.weight) {
+        siblingHit = { weight: cue.weight, label: cue.label };
+      }
+    }
+  }
+  const vulnerableHit = VULNERABLE_CUES.some((p) => p.test(window));
+  return { ref, siblingHit, vulnerableHit };
+}
+function readSnippet(repoPath, ref, linesOfContext) {
+  if (ref.line === void 0)
+    return null;
+  const abs = join2(repoPath, ref.file);
+  if (!existsSync(abs))
+    return null;
+  let raw;
+  try {
+    raw = readFileSync(abs, "utf8");
+  } catch {
+    return null;
+  }
+  const lines = raw.split("\n");
+  if (ref.line < 1 || ref.line > lines.length)
+    return null;
+  const start = Math.max(0, ref.line - 1 - linesOfContext);
+  const end = Math.min(lines.length, ref.line + linesOfContext);
+  return lines.slice(start, end).join("\n");
+}
+var CONFIDENCE_FLOOR = 0.6;
+function extractSiblingFix(finding, options) {
+  if (!options.repoPath)
+    return null;
+  const repoPath = resolve(options.repoPath);
+  if (!existsSync(repoPath))
+    return null;
+  const linesOfContext = options.linesOfContext ?? 5;
+  const refs = extractFileRefs(finding);
+  if (refs.length === 0)
+    return null;
+  const haystack = buildHaystack(finding);
+  const classified = refs.map((ref) => classifyRef(haystack, ref));
+  let best = null;
+  for (const c of classified) {
+    if (!c.siblingHit)
+      continue;
+    const base = c.siblingHit.weight;
+    const confidence = c.vulnerableHit ? base * 0.5 : base;
+    const rationale = c.vulnerableHit ? `Matched sibling cue "${c.siblingHit.label}" in surrounding prose, but also matched a vulnerable-ref cue \u2014 confidence halved.` : `Matched sibling cue "${c.siblingHit.label}" in the sentence containing the ref.`;
+    if (!best || confidence > best.confidence) {
+      best = { c, confidence, rationale };
+    }
+  }
+  if (!best || best.confidence < CONFIDENCE_FLOOR)
+    return null;
+  const snippet = readSnippet(repoPath, best.c.ref, linesOfContext);
+  if (snippet === null)
+    return null;
+  return {
+    fileRef: best.c.ref,
+    snippet,
+    language: languageFor(best.c.ref.file),
+    confidence: best.confidence,
+    rationale: best.rationale
+  };
+}
+
+// packages/core/dist/disclose/poc-runtime.js
+import { spawn } from "node:child_process";
+var MAX_CAPTURE_BYTES = 1024 * 1024;
+var DEFAULT_STEP_TIMEOUT_MS = 3e4;
+var PERSONA_HEADER = "X-0sec-Persona";
+var TRUNCATION_MARKER = "\n\u2026[truncated at 1MiB]";
+var DEFAULT_RPS_PER_HOST = 2;
+var MAX_REDIRECT_HOPS = 5;
+var hostBuckets = /* @__PURE__ */ new Map();
+function getOrInitBucket(host, rps) {
+  let bucket = hostBuckets.get(host);
+  if (!bucket) {
+    bucket = {
+      tokens: rps,
+      // full bucket on first use
+      refillRatePerMs: rps / 1e3,
+      capacity: rps,
+      lastRefill: Date.now(),
+      retryUntil: 0
+    };
+    hostBuckets.set(host, bucket);
+  }
+  return bucket;
+}
+function refill(bucket) {
+  const now = Date.now();
+  const elapsed = now - bucket.lastRefill;
+  if (elapsed > 0) {
+    bucket.tokens = Math.min(bucket.capacity, bucket.tokens + elapsed * bucket.refillRatePerMs);
+    bucket.lastRefill = now;
+  }
+}
+async function acquireHostToken(host, rps) {
+  const bucket = getOrInitBucket(host, rps);
+  while (Date.now() < bucket.retryUntil) {
+    const waitMs = bucket.retryUntil - Date.now();
+    await sleep(Math.min(waitMs, 1e3));
+  }
+  while (true) {
+    refill(bucket);
+    if (bucket.tokens >= 1) {
+      bucket.tokens -= 1;
+      return;
+    }
+    const tokensNeeded = 1 - bucket.tokens;
+    const waitMs = Math.max(1, Math.ceil(tokensNeeded / bucket.refillRatePerMs));
+    await sleep(waitMs);
+  }
+}
+function markHostRateLimited(host, retryAfterHeader) {
+  const bucket = hostBuckets.get(host);
+  if (!bucket)
+    return;
+  const parsed = retryAfterHeader ? parseInt(retryAfterHeader, 10) : NaN;
+  const retryAfterMs = Number.isFinite(parsed) && parsed > 0 ? parsed * 1e3 : 0;
+  bucket.retryUntil = Date.now() + Math.max(retryAfterMs, 6e4);
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function normalizeHostForMatch(value) {
+  const trimmed = value.trim().toLowerCase();
+  if (trimmed.startsWith("[")) {
+    const end = trimmed.indexOf("]");
+    return end === -1 ? trimmed : trimmed.slice(1, end);
+  }
+  if ((trimmed.match(/:/g) ?? []).length >= 2)
+    return trimmed;
+  return trimmed.replace(/:\d+$/, "");
+}
+function hostMatchesAllowlist(host, allowlist) {
+  if (!allowlist || allowlist.length === 0)
+    return true;
+  const target = normalizeHostForMatch(host);
+  for (const raw of allowlist) {
+    const pattern = normalizeHostForMatch(raw);
+    if (!pattern)
+      continue;
+    if (pattern.startsWith("*.")) {
+      const suffix = pattern.slice(1);
+      if (target.endsWith(suffix) && target.length > suffix.length)
+        return true;
+    } else if (target === pattern) {
+      return true;
+    }
+  }
+  return false;
+}
+function scopeRequiredResult(step, target, start) {
+  if (target.scopeAllowlist && target.scopeAllowlist.length > 0)
+    return void 0;
+  return {
+    stepId: step.id,
+    kind: "errored",
+    durationMs: Date.now() - start,
+    error: "PoC reverify requires a non-empty scope allowlist"
+  };
+}
+function extractUrlsFromShellCommand(cmd) {
+  const matches = cmd.match(/https?:\/\/[^\s'"]+/g);
+  return matches ?? [];
+}
+function dockerRegistryHost(image) {
+  const separator = image.indexOf("/");
+  if (separator === -1)
+    return void 0;
+  const firstSegment = image.slice(0, separator);
+  return firstSegment.includes(".") || firstSegment.includes(":") || firstSegment === "localhost" ? firstSegment : void 0;
+}
+var deps = { spawn, fetch: globalThis.fetch };
+function setRuntimeDeps(overrides) {
+  const previous = deps;
+  deps = { ...previous, ...overrides };
+  return () => {
+    deps = previous;
+  };
+}
+async function executePocSteps(finding, target) {
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const steps = [];
+  const graph = finding.pocSteps ?? [];
+  for (const step of graph) {
+    const result = await executeStep(step, target);
+    steps.push(result);
+    if (result.kind === "errored" && step.kind !== "verify") {
+      for (let i = graph.indexOf(step) + 1; i < graph.length; i++) {
+        steps.push({
+          stepId: graph[i].id,
+          kind: "skipped",
+          durationMs: 0,
+          error: "skipped: an earlier step errored"
+        });
+      }
+      break;
+    }
+  }
+  const endedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    findingId: finding.id,
+    startedAt,
+    endedAt,
+    steps,
+    overallVerdict: aggregateVerdict(graph, steps)
+  };
+}
+async function executeStep(step, target) {
+  const start = Date.now();
+  if (target.allowProcessActions === false && (step.action.type === "shell" || step.action.type === "docker")) {
+    return {
+      stepId: step.id,
+      kind: "errored",
+      durationMs: Date.now() - start,
+      error: `PoC ${step.action.type} actions require an isolated execution environment`
+    };
+  }
+  try {
+    switch (step.action.type) {
+      case "shell":
+        return await runShellStep(step, step.action, target, start);
+      case "http":
+        return await runHttpStep(step, step.action, target, start);
+      case "docker":
+        return await runDockerStep(step, step.action, target, start);
+      case "note":
+        return {
+          stepId: step.id,
+          kind: "skipped",
+          durationMs: Date.now() - start
+        };
+      default: {
+        const _exhaustive = step.action;
+        return {
+          stepId: step.id,
+          kind: "errored",
+          durationMs: Date.now() - start,
+          error: `unknown action type: ${JSON.stringify(_exhaustive)}`
+        };
+      }
+    }
+  } catch (err) {
+    return {
+      stepId: step.id,
+      kind: "errored",
+      durationMs: Date.now() - start,
+      error: errMessage(err)
+    };
+  }
+}
+async function runShellStep(step, action, target, start) {
+  const scopeError = scopeRequiredResult(step, target, start);
+  if (scopeError)
+    return scopeError;
+  if (target.scopeAllowlist && target.scopeAllowlist.length > 0) {
+    for (const u of extractUrlsFromShellCommand(action.cmd)) {
+      let host;
+      try {
+        host = new URL(u).host;
+      } catch {
+        continue;
+      }
+      if (!hostMatchesAllowlist(host, target.scopeAllowlist)) {
+        return {
+          stepId: step.id,
+          kind: "errored",
+          durationMs: Date.now() - start,
+          error: `out-of-scope url in shell cmd: ${u} (allowlist: ${target.scopeAllowlist.join(", ")})`
+        };
+      }
+    }
+  }
+  const env = { ...process.env, ...target.env ?? {} };
+  const cwd = action.cwd ?? target.cwd;
+  const timeoutMs = target.timeoutMs ?? DEFAULT_STEP_TIMEOUT_MS;
+  const spawned = await spawnAndCapture("/bin/sh", ["-c", action.cmd], { env, cwd, timeoutMs });
+  return finaliseProcessStep(step, spawned, start);
+}
+async function runDockerStep(step, action, target, start) {
+  const scopeError = scopeRequiredResult(step, target, start);
+  if (scopeError)
+    return scopeError;
+  const registryHost = dockerRegistryHost(action.image);
+  if (registryHost && !hostMatchesAllowlist(registryHost, target.scopeAllowlist)) {
+    return {
+      stepId: step.id,
+      kind: "errored",
+      durationMs: Date.now() - start,
+      error: `out-of-scope docker registry: ${registryHost} (allowlist: ${target.scopeAllowlist.join(", ")})`
+    };
+  }
+  if (target.scopeAllowlist && target.scopeAllowlist.length > 0) {
+    const dockerTokens = [action.image, ...action.args].join(" ");
+    for (const u of extractUrlsFromShellCommand(dockerTokens)) {
+      let host;
+      try {
+        host = new URL(u).host;
+      } catch {
+        continue;
+      }
+      if (!hostMatchesAllowlist(host, target.scopeAllowlist)) {
+        return {
+          stepId: step.id,
+          kind: "errored",
+          durationMs: Date.now() - start,
+          error: `out-of-scope url in docker action: ${u} (allowlist: ${target.scopeAllowlist.join(", ")})`
+        };
+      }
+    }
+  }
+  const env = { ...process.env, ...target.env ?? {} };
+  const cwd = target.cwd;
+  const timeoutMs = target.timeoutMs ?? DEFAULT_STEP_TIMEOUT_MS;
+  const spawned = await spawnAndCapture("docker", ["run", "--rm", ...action.args, action.image], { env, cwd, timeoutMs });
+  return finaliseProcessStep(step, spawned, start);
+}
+async function runHttpStep(step, action, target, start) {
+  const scopeError = scopeRequiredResult(step, target, start);
+  if (scopeError)
+    return scopeError;
+  const url = resolveUrl(action.url, target.baseUrl);
+  if (!url) {
+    return {
+      stepId: step.id,
+      kind: "errored",
+      durationMs: Date.now() - start,
+      error: `http step has a relative url (${action.url}) but no target.baseUrl was provided`
+    };
+  }
+  let host;
+  try {
+    host = new URL(url).host;
+  } catch {
+    return {
+      stepId: step.id,
+      kind: "errored",
+      durationMs: Date.now() - start,
+      error: `http step url is not a valid URL: ${url}`
+    };
+  }
+  if (!hostMatchesAllowlist(host, target.scopeAllowlist)) {
+    return {
+      stepId: step.id,
+      kind: "errored",
+      durationMs: Date.now() - start,
+      error: `out-of-scope host: ${host} (allowlist: ${target.scopeAllowlist.join(", ")})`
+    };
+  }
+  const rps = target.rpsPerHost ?? DEFAULT_RPS_PER_HOST;
+  await acquireHostToken(host, rps);
+  const headers = mergePersonaHeaders(action.headers ?? {}, target);
+  const timeoutMs = target.timeoutMs ?? DEFAULT_STEP_TIMEOUT_MS;
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), timeoutMs);
+  let finalResponse;
+  let body = "";
+  let currentUrl = url;
+  let redirectCount = 0;
+  try {
+    while (true) {
+      finalResponse = await deps.fetch(currentUrl, {
+        method: action.method,
+        headers,
+        body: action.body,
+        signal: ac.signal,
+        redirect: "manual"
+      });
+      const status = finalResponse.status;
+      const isRedirect = [301, 302, 303, 307, 308].includes(status);
+      if (!isRedirect) {
+        body = await readBodyCapped(finalResponse);
+        if (status === 429) {
+          const retryAfter = finalResponse.headers.get("retry-after");
+          markHostRateLimited(host, retryAfter);
+        }
+        break;
+      }
+      redirectCount++;
+      if (redirectCount > MAX_REDIRECT_HOPS) {
+        try {
+          finalResponse.body?.cancel();
+        } catch {
+        }
+        clearTimeout(timer);
+        return {
+          stepId: step.id,
+          kind: "errored",
+          durationMs: Date.now() - start,
+          error: `too many redirects (exceeded ${MAX_REDIRECT_HOPS} hops)`
+        };
+      }
+      const location = finalResponse.headers.get("location");
+      if (!location) {
+        body = await readBodyCapped(finalResponse);
+        break;
+      }
+      const nextUrlStr = new URL(location, currentUrl).toString();
+      const nextHost = new URL(nextUrlStr).host;
+      if (!hostMatchesAllowlist(nextHost, target.scopeAllowlist)) {
+        try {
+          finalResponse.body?.cancel();
+        } catch {
+        }
+        clearTimeout(timer);
+        return {
+          stepId: step.id,
+          kind: "errored",
+          durationMs: Date.now() - start,
+          error: `redirect to out-of-scope host: ${nextHost} (allowlist: ${target.scopeAllowlist.join(", ")})`
+        };
+      }
+      try {
+        finalResponse.body?.cancel();
+      } catch {
+      }
+      currentUrl = nextUrlStr;
+    }
+  } catch (err) {
+    clearTimeout(timer);
+    const aborted = ac.signal.aborted;
+    return {
+      stepId: step.id,
+      kind: "errored",
+      durationMs: Date.now() - start,
+      error: aborted ? `timeout after ${timeoutMs}ms` : errMessage(err)
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+  const verdict = evaluateExpect(step.expect, {
+    status: finalResponse.status,
+    body
+  });
+  return {
+    stepId: step.id,
+    kind: verdict.kind,
+    observedStatus: finalResponse.status,
+    observedResponseBody: body,
+    durationMs: Date.now() - start,
+    ...verdict.error ? { error: verdict.error } : {}
+  };
+}
+function resolveUrl(stepUrl, baseUrl) {
+  try {
+    new URL(stepUrl);
+    return stepUrl;
+  } catch {
+  }
+  if (!baseUrl)
+    return null;
+  try {
+    return new URL(stepUrl, baseUrl).toString();
+  } catch {
+    return null;
+  }
+}
+function mergePersonaHeaders(stepHeaders, target) {
+  const merged = {};
+  let personaName;
+  for (const [k, v] of Object.entries(stepHeaders)) {
+    if (k.toLowerCase() === PERSONA_HEADER.toLowerCase()) {
+      personaName = v;
+      continue;
+    }
+    merged[k] = v;
+  }
+  if (!personaName)
+    return merged;
+  const persona = target.personas?.[personaName];
+  if (!persona)
+    return merged;
+  if (persona.headers) {
+    for (const [k, v] of Object.entries(persona.headers)) {
+      if (!(k in merged))
+        merged[k] = v;
+    }
+  }
+  if (persona.cookies && !("cookie" in lowerKeys(merged))) {
+    merged["Cookie"] = persona.cookies;
+  }
+  return merged;
+}
+function lowerKeys(obj) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj))
+    out[k.toLowerCase()] = v;
+  return out;
+}
+async function readBodyCapped(response) {
+  if (!response.body)
+    return "";
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder("utf-8", { fatal: false });
+  let captured = "";
+  let truncated = false;
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done)
+      break;
+    if (value) {
+      const chunk = decoder.decode(value, { stream: true });
+      if (captured.length + chunk.length > MAX_CAPTURE_BYTES) {
+        captured += chunk.slice(0, MAX_CAPTURE_BYTES - captured.length);
+        truncated = true;
+        try {
+          await reader.cancel();
+        } catch {
+        }
+        break;
+      }
+      captured += chunk;
+    }
+  }
+  return truncated ? captured + TRUNCATION_MARKER : captured;
+}
+function spawnAndCapture(cmd, args, opts) {
+  return new Promise((resolveP) => {
+    let child;
+    try {
+      child = deps.spawn(cmd, args, {
+        env: opts.env,
+        cwd: opts.cwd,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (err) {
+      resolveP({
+        exitCode: null,
+        stdout: "",
+        stderr: "",
+        timedOut: false,
+        error: errMessage(err)
+      });
+      return;
+    }
+    let stdout = "";
+    let stderr = "";
+    let stdoutTruncated = false;
+    let stderrTruncated = false;
+    let timedOut = false;
+    let settled = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+    }, opts.timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      const s = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      if (stdout.length + s.length > MAX_CAPTURE_BYTES) {
+        if (!stdoutTruncated) {
+          stdout += s.slice(0, MAX_CAPTURE_BYTES - stdout.length);
+          stdoutTruncated = true;
+        }
+        return;
+      }
+      stdout += s;
+    });
+    child.stderr?.on("data", (chunk) => {
+      const s = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      if (stderr.length + s.length > MAX_CAPTURE_BYTES) {
+        if (!stderrTruncated) {
+          stderr += s.slice(0, MAX_CAPTURE_BYTES - stderr.length);
+          stderrTruncated = true;
+        }
+        return;
+      }
+      stderr += s;
+    });
+    const settle = (exit, errorMsg) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolveP({
+        exitCode: exit,
+        stdout: stdoutTruncated ? stdout + TRUNCATION_MARKER : stdout,
+        stderr: stderrTruncated ? stderr + TRUNCATION_MARKER : stderr,
+        timedOut,
+        error: errorMsg
+      });
+    };
+    child.on("error", (err) => {
+      settle(null, errMessage(err));
+    });
+    child.on("close", (code) => {
+      settle(code);
+    });
+  });
+}
+function finaliseProcessStep(step, spawned, start) {
+  const durationMs = Date.now() - start;
+  if (spawned.timedOut) {
+    return {
+      stepId: step.id,
+      kind: "errored",
+      observedStdout: spawned.stdout,
+      observedStderr: spawned.stderr,
+      durationMs,
+      error: `timeout after ${durationMs}ms`
+    };
+  }
+  if (spawned.error && spawned.exitCode === null) {
+    return {
+      stepId: step.id,
+      kind: "errored",
+      observedStdout: spawned.stdout,
+      observedStderr: spawned.stderr,
+      durationMs,
+      error: spawned.error
+    };
+  }
+  const verdict = evaluateExpect(step.expect, {
+    exitCode: spawned.exitCode,
+    stdout: spawned.stdout
+  });
+  const result = {
+    stepId: step.id,
+    kind: verdict.kind,
+    observedStdout: spawned.stdout,
+    observedStderr: spawned.stderr,
+    durationMs
+  };
+  if (spawned.exitCode !== null)
+    result.observedExit = spawned.exitCode;
+  if (verdict.error)
+    result.error = verdict.error;
+  return result;
+}
+function evaluateExpect(expect, obs) {
+  if (!expect) {
+    return { kind: "passed" };
+  }
+  switch (expect.type) {
+    case "exit-zero": {
+      if (obs.exitCode === 0)
+        return { kind: "passed" };
+      return {
+        kind: "failed",
+        error: `expected exit-zero, got exitCode=${String(obs.exitCode ?? "unknown")}`
+      };
+    }
+    case "http-status": {
+      const wanted = Array.isArray(expect.status) ? expect.status : [expect.status];
+      if (typeof obs.status === "number" && wanted.includes(obs.status)) {
+        return { kind: "passed" };
+      }
+      return {
+        kind: "failed",
+        error: `expected http-status in [${wanted.join(",")}], got ${String(obs.status ?? "no-response")}`
+      };
+    }
+    case "body-contains": {
+      const haystack = obs.body ?? obs.stdout ?? "";
+      if (haystack.includes(expect.text))
+        return { kind: "passed" };
+      return {
+        kind: "failed",
+        error: `expected body-contains '${expect.text}', not found in observed output`
+      };
+    }
+    case "body-matches": {
+      const haystack = obs.body ?? obs.stdout ?? "";
+      let re;
+      try {
+        re = new RegExp(expect.pattern);
+      } catch (err) {
+        return { kind: "errored", error: `invalid regex: ${errMessage(err)}` };
+      }
+      if (re.test(haystack))
+        return { kind: "passed" };
+      return {
+        kind: "failed",
+        error: `expected body-matches /${expect.pattern}/, no match in observed output`
+      };
+    }
+    case "file-exists": {
+      return {
+        kind: "errored",
+        error: "file-exists predicate cannot be evaluated against a network target; rewrite as a shell action with `[ -e <path> ]`"
+      };
+    }
+    default: {
+      const _exhaustive = expect;
+      return {
+        kind: "errored",
+        error: `unknown expect type: ${JSON.stringify(_exhaustive)}`
+      };
+    }
+  }
+}
+function aggregateVerdict(graph, steps) {
+  if (graph.length === 0) {
+    return "could_not_run";
+  }
+  const byId = new Map(steps.map((s) => [s.stepId, s]));
+  let reachedExploitOrVerify = false;
+  for (const step of graph) {
+    const result = byId.get(step.id);
+    if (!result)
+      continue;
+    if (step.kind === "exploit" || step.kind === "verify") {
+      reachedExploitOrVerify = true;
+    }
+    if (result.kind === "errored" && (step.kind === "setup" || step.kind === "auth" || step.kind === "prerequisite")) {
+      return "could_not_run";
+    }
+  }
+  const verifySteps = graph.filter((s) => s.kind === "verify");
+  if (verifySteps.length > 0) {
+    let anyFailed = false;
+    let anyErrored = false;
+    let allPassed = true;
+    for (const v of verifySteps) {
+      const result = byId.get(v.id);
+      if (!result || result.kind === "skipped") {
+        allPassed = false;
+        anyErrored = true;
+        continue;
+      }
+      if (result.kind === "failed") {
+        anyFailed = true;
+        allPassed = false;
+      } else if (result.kind === "errored") {
+        anyErrored = true;
+        allPassed = false;
+      }
+    }
+    if (allPassed)
+      return "exploit_still_works";
+    if (anyFailed)
+      return "exploit_broken";
+    if (anyErrored)
+      return "could_not_run";
+  }
+  const exploitSteps = graph.filter((s) => s.kind === "exploit");
+  if (exploitSteps.length > 0) {
+    let anyFailed = false;
+    let anyErrored = false;
+    let allPassed = true;
+    for (const e of exploitSteps) {
+      const result = byId.get(e.id);
+      if (!result || result.kind === "skipped") {
+        allPassed = false;
+        anyErrored = true;
+        continue;
+      }
+      if (result.kind === "failed") {
+        anyFailed = true;
+        allPassed = false;
+      } else if (result.kind === "errored") {
+        anyErrored = true;
+        allPassed = false;
+      }
+    }
+    if (allPassed)
+      return "exploit_still_works";
+    if (anyFailed)
+      return "exploit_broken";
+    if (anyErrored)
+      return "could_not_run";
+  }
+  return reachedExploitOrVerify ? "exploit_still_works" : "could_not_run";
+}
+function errMessage(err) {
+  if (err instanceof Error)
+    return err.message;
+  if (typeof err === "string")
+    return err;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+
+// packages/core/dist/disclose/bundle.js
+function decideFilingState(inputs) {
+  const { patchStatus, behaviouralReport, dropFixed, keepUnrun, emptyPoc } = inputs;
+  if (emptyPoc) {
+    return { filingState: "drop", dropReason: "unverified-poc: empty PoC" };
+  }
+  if (patchStatus && dropFixed && (patchStatus.status === "fixed" || patchStatus.status === "file-removed")) {
+    return { filingState: "drop", dropReason: `canary status=${patchStatus.status}` };
+  }
+  if (behaviouralReport?.overallVerdict === "exploit_broken") {
+    return { filingState: "drop", dropReason: "behavioural reverify: exploit_broken" };
+  }
+  if (behaviouralReport?.overallVerdict === "could_not_run") {
+    if (keepUnrun)
+      return { filingState: "needs-review" };
+    return { filingState: "drop", dropReason: "unverified-poc: behavioural reverify could_not_run" };
+  }
+  return { filingState: "keep" };
+}
+function dropSlug(entry) {
+  return entry.patchStatus ?? entry.behaviouralVerdict ?? "dropped";
+}
+function droppedFilename(entry) {
+  return `${entry.finding.id.slice(0, 8)}-${entry.finding.severity}-${dropSlug(entry)}.md`;
+}
+function formatDroppedReason(args) {
+  const { finding, scanId, patchStatus, behaviouralReport, reason } = args;
+  const lines = [];
+  lines.push(`# Dropped: ${finding.title}`);
+  lines.push("");
+  lines.push(`- **Reason:** ${reason}`);
+  lines.push(`- **Scan:** \`${scanId}\``);
+  lines.push(`- **Finding id:** \`${finding.id}\``);
+  if (patchStatus) {
+    lines.push(`- **Canary status:** ${patchStatus.status}`);
+    lines.push(`- **Canary ref:** \`${patchStatus.ref}\``);
+  }
+  if (behaviouralReport) {
+    lines.push(`- **Behavioural verdict:** ${behaviouralReport.overallVerdict}`);
+    lines.push(`- **Last-known-good execution:** see \`${finding.id.slice(0, 8)}.execution.json\``);
+  }
+  lines.push("");
+  if (patchStatus) {
+    lines.push("## Canary notes", "");
+    for (const n of patchStatus.notes)
+      lines.push(`- ${n}`);
+    lines.push("", "## Refs checked", "");
+    for (const r of patchStatus.refsChecked) {
+      lines.push(`- \`${r.file}${r.line ? `:${r.line}` : ""}\``);
+    }
+    lines.push("");
+  }
+  if (behaviouralReport) {
+    lines.push("## Behavioural step verdicts", "");
+    for (const s of behaviouralReport.steps) {
+      lines.push(`- \`${s.stepId}\` \u2192 ${s.kind}${s.error ? ` (${s.error})` : ""}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function findingProvenanceHashes(finding) {
+  const HEX64 = /^[0-9a-f]{64}$/i;
+  const seen = /* @__PURE__ */ new Set();
+  for (const art of finding.verification_result?.evidence_artifacts ?? []) {
+    if (art.sha256 && HEX64.test(art.sha256))
+      seen.add(art.sha256.toLowerCase());
+  }
+  for (const envelope of finding.researchEvidence ?? []) {
+    for (const art of envelope.artifacts ?? []) {
+      if (art.sha256 && HEX64.test(art.sha256))
+        seen.add(art.sha256.toLowerCase());
+    }
+  }
+  return [...seen].sort();
+}
+function assembleBundleIndex(entries, options) {
+  const { scanIds } = options;
+  const generatedAt = options.generatedAt ?? /* @__PURE__ */ new Date();
+  const drafts = entries.filter((e) => e.filingState !== "drop");
+  const dropped = entries.filter((e) => e.filingState === "drop");
+  const scanLabel = scanIds.length === 1 ? `\`${scanIds[0]}\`` : `\`${scanIds.join("`, `")}\` (${scanIds.length} scans)`;
+  const truncateTitle = (t, max = 64) => t.length > max ? t.slice(0, max - 1) + "\u2026" : t;
+  const truncateReason = (r, max = 48) => !r ? "\u2014" : r.length > max ? r.slice(0, max - 1) + "\u2026" : r;
+  const escapePipe = (s) => s.replace(/\|/g, "\\|");
+  const formatProvenance = (e) => {
+    const hashes = findingProvenanceHashes(e.finding);
+    if (hashes.length === 0)
+      return "\u2014";
+    const first = `\`${hashes[0].slice(0, 12)}\u2026\``;
+    return hashes.length === 1 ? first : `${first} +${hashes.length - 1}`;
+  };
+  const redactTitle = (e) => escapePipe(truncateTitle(redactSensitiveHeaders(e.finding.title)));
+  const redactReason = (e) => escapePipe(truncateReason(e.dropReason ? redactSensitiveHeaders(e.dropReason) : void 0));
+  if (entries.length === 0) {
+    return [
+      "# Disclosure batch",
+      "",
+      `- Scan: ${scanLabel}`,
+      "- Drafts: 0",
+      `- Generated: ${generatedAt.toISOString()}`,
+      "",
+      "_No findings matched the current filters. Pass `--severity-floor low` or `--scan <id>` to widen the selection._",
+      ""
+    ].join("\n");
+  }
+  const lines = [];
+  lines.push("# Disclosure batch", "");
+  lines.push(`- Scan: ${scanLabel}`);
+  lines.push(`- Drafts: ${drafts.length}`);
+  if (dropped.length > 0)
+    lines.push(`- Dropped: ${dropped.length} (see \`_dropped/\`)`);
+  lines.push(`- Generated: ${generatedAt.toISOString()}`, "");
+  lines.push("## Filing order", "", "| finding-id | severity | title | gate-status | behavioural | filing-state | provenance |", "|---|---|---|---|---|---|---|");
+  for (const e of drafts) {
+    const id = e.finding.id.slice(0, 8);
+    const titleCell = `[${redactTitle(e)}](./${e.filename})`;
+    lines.push(`| \`${id}\` | ${e.finding.severity} | ${titleCell} | ${e.patchStatus ?? "\u2014"} | ${e.behaviouralVerdict ?? "\u2014"} | ${e.filingState} | ${formatProvenance(e)} |`);
+  }
+  if (dropped.length > 0) {
+    lines.push("", "## Dropped", "", "| finding-id | severity | title | gate-status | behavioural | reason | provenance |", "|---|---|---|---|---|---|---|");
+    for (const e of dropped) {
+      const id = e.finding.id.slice(0, 8);
+      const titleCell = `[${redactTitle(e)}](./_dropped/${droppedFilename(e)})`;
+      lines.push(`| \`${id}\` | ${e.finding.severity} | ${titleCell} | ${e.patchStatus ?? "\u2014"} | ${e.behaviouralVerdict ?? "\u2014"} | ${redactReason(e)} | ${formatProvenance(e)} |`);
+    }
+  }
+  lines.push("", "## Before filing each advisory", "", "1. Re-read the draft \u2014 the PoC and Patch Status sections are auto-populated from the scan but you should sanity-check against the current upstream HEAD.", "2. Verify the CVSS vector suggested by 0sec is still appropriate for your deployment model.", "3. Attach or replace screenshots in the PoC section as needed.", "4. File at https://github.com/<owner>/<repo>/security/advisories/new", "");
+  return lines.join("\n");
+}
+
+// packages/core/dist/disclose/writeup.js
+var import_yaml = __toESM(require_dist(), 1);
+var PUBLISHABLE_STATUSES = /* @__PURE__ */ new Set([
+  "published-cve",
+  "patched-no-cve",
+  "wontfix",
+  "maintainer-rejected"
+]);
+var EmbargoedFindingError = class extends Error {
+  status;
+  constructor(status) {
+    super(`Finding status "${status}" is not operator-cleared for a writeup. Pass allowEmbargoed:true to stage an internal draft, or wait for a terminal status (${[...PUBLISHABLE_STATUSES].join(", ")}).`);
+    this.name = "EmbargoedFindingError";
+    this.status = status;
+  }
+};
+var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+function parseDisclosure(raw) {
+  const m = FRONTMATTER_RE.exec(raw);
+  if (!m) {
+    return { frontmatter: {}, body: raw.trim() };
+  }
+  let frontmatter = {};
+  try {
+    const parsed = (0, import_yaml.parse)(m[1]);
+    if (parsed && typeof parsed === "object") {
+      frontmatter = parsed;
+    }
+  } catch {
+    frontmatter = {};
+  }
+  const body = raw.slice(m[0].length).trim();
+  return { frontmatter, body };
+}
+var EMAIL_RE = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g;
+var PUBLIC_SECURITY_LOCALPARTS = /* @__PURE__ */ new Set([
+  "security",
+  "secalert",
+  "psirt",
+  "abuse",
+  "cve",
+  "oss-security",
+  "support",
+  "info"
+]);
+function redactPii(text) {
+  if (!text)
+    return text;
+  return text.replace(EMAIL_RE, (addr) => {
+    const localPart = addr.slice(0, addr.indexOf("@")).toLowerCase();
+    if (PUBLIC_SECURITY_LOCALPARTS.has(localPart))
+      return addr;
+    return "<REDACTED-EMAIL>";
+  });
+}
+function sanitizeWriteup(text) {
+  return redactPii(redactSensitiveHeaders(text));
+}
+var HEADING_ALIASES = {
+  summary: "Summary",
+  analysis: "Summary",
+  "attack vector": "How we found it",
+  reproduction: "How we found it",
+  poc: "How we found it",
+  "proof of concept": "How we found it",
+  "end-to-end chain": "How we found it",
+  timeline: "Timeline",
+  "recommended fix": "Remediation",
+  "suggested fix": "Remediation",
+  "recommended remediation": "Remediation",
+  remediation: "Remediation"
+};
+var SECTION_ORDER = [
+  "Summary",
+  "How we found it",
+  "Timeline",
+  "Remediation"
+];
+function extractSections(body) {
+  const sections = {
+    Summary: [],
+    "How we found it": [],
+    Timeline: [],
+    Remediation: []
+  };
+  const headingRe = /^#{2,}\s+(.+?)\s*$/gm;
+  const matches = [...body.matchAll(headingRe)];
+  for (let i = 0; i < matches.length; i++) {
+    const headingText = matches[i][1].replace(/`[^`]*`/g, "").replace(/[*_]/g, "").trim().toLowerCase();
+    const canonical = HEADING_ALIASES[headingText];
+    if (!canonical)
+      continue;
+    const start = matches[i].index + matches[i][0].length;
+    const end = i + 1 < matches.length ? matches[i + 1].index : body.length;
+    const content = body.slice(start, end).trim();
+    if (content)
+      sections[canonical].push(content);
+  }
+  return sections;
+}
+function slugify2(value, max = 80) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, max);
+}
+function titleFor(fm, body) {
+  const h1 = /^#\s+(.+?)\s*$/m.exec(body);
+  if (h1)
+    return h1[1].trim();
+  const pkg = fm.package ?? "the target";
+  const cls = fm.vuln_class ? ` ${fm.vuln_class.replace(/-/g, " ")}` : "";
+  return `${pkg}${cls}`;
+}
+function generateWriteup(parsed, opts = {}) {
+  const { frontmatter: fm, body } = parsed;
+  const status = (fm.status ?? "unknown").trim();
+  const cleared = PUBLISHABLE_STATUSES.has(status);
+  if (!cleared && !opts.allowEmbargoed) {
+    throw new EmbargoedFindingError(status);
+  }
+  const title = titleFor(fm, body);
+  const sections = extractSections(body);
+  const generatedAt = opts.generatedAt ?? /* @__PURE__ */ new Date();
+  const dateStamp = generatedAt.toISOString().slice(0, 10);
+  const sectionsPresent = SECTION_ORDER.filter((s) => sections[s].length > 0);
+  const out = [];
+  out.push(`# How we hacked ${title}`, "");
+  out.push("> DRAFT \u2014 sanitised writeup generated from a disclosure record. Operator review required before publication; embargo rules in `disclosure/AGENTS.md` still apply.", "");
+  const meta = [];
+  if (fm.package)
+    meta.push(`**Target:** \`${fm.package}\``);
+  if (fm.vuln_class)
+    meta.push(`**Class:** ${fm.vuln_class}`);
+  if (fm.severity_estimate)
+    meta.push(`**Severity:** ${fm.severity_estimate}`);
+  if (fm.cve_id)
+    meta.push(`**CVE:** ${fm.cve_id}`);
+  else if (fm.ghsa_id)
+    meta.push(`**Advisory:** ${fm.ghsa_id}`);
+  meta.push(`**Status:** ${status}`);
+  if (meta.length)
+    out.push(meta.join(" \xB7 "), "");
+  if (!cleared) {
+    out.push(`> \u26A0\uFE0F This finding is **not yet in a public/terminal status** (\`${status}\`). Emitted under the embargo override as an internal draft only \u2014 do not publish.`, "");
+  }
+  for (const section of SECTION_ORDER) {
+    const parts = sections[section];
+    if (parts.length === 0)
+      continue;
+    out.push(`## ${section}`, "");
+    out.push(sanitizeWriteup(parts.join("\n\n")), "");
+  }
+  out.push("## Credits", "");
+  out.push("Found by 0sec's automated security-research tooling ([0sec.ai](https://0sec.ai)).", "");
+  const slug = slugify2(fm.short_name ? `${fm.package ?? ""}-${fm.short_name}` : title);
+  const filename = `${slug || "writeup"}-${dateStamp}.md`;
+  return {
+    filename,
+    markdown: out.join("\n").replace(/\n{3,}/g, "\n\n"),
+    sectionsPresent,
+    embargoed: !cleared
+  };
+}
+
+// packages/core/dist/disclose/tracking.js
+var DISCLOSURE_STATUSES = [
+  "draft",
+  "sent",
+  "acknowledged",
+  "accepted",
+  "cve_assigned",
+  "published",
+  "rejected",
+  "not_applicable",
+  "duplicate",
+  "withdrawn"
+];
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "published",
+  "rejected",
+  "not_applicable",
+  "duplicate",
+  "withdrawn"
+]);
+var PUBLIC_STATUSES = /* @__PURE__ */ new Set([
+  "published"
+]);
+var FORWARD_EDGES = {
+  draft: ["sent"],
+  sent: ["acknowledged", "accepted", "cve_assigned"],
+  acknowledged: ["accepted", "cve_assigned"],
+  accepted: ["cve_assigned", "published"],
+  cve_assigned: ["published"],
+  published: [],
+  rejected: [],
+  not_applicable: [],
+  duplicate: [],
+  withdrawn: []
+};
+var OFFRAMPS = [
+  "rejected",
+  "not_applicable",
+  "duplicate",
+  "withdrawn"
+];
+function allowedNextStatuses(from) {
+  if (TERMINAL_STATUSES.has(from))
+    return [];
+  const forward = FORWARD_EDGES[from] ?? [];
+  const next = new Set(forward);
+  for (const off of OFFRAMPS)
+    next.add(off);
+  next.delete(from);
+  return DISCLOSURE_STATUSES.filter((s) => next.has(s));
+}
+function canTransition(from, to) {
+  return allowedNextStatuses(from).includes(to);
+}
+var IllegalTransitionError = class extends Error {
+  from;
+  to;
+  constructor(from, to) {
+    const allowed = allowedNextStatuses(from);
+    super(`Illegal disclosure transition ${from} \u2192 ${to}. ` + (allowed.length ? `Allowed from "${from}": ${allowed.join(", ")}.` : `"${from}" is terminal \u2014 no further transitions.`));
+    this.name = "IllegalTransitionError";
+    this.from = from;
+    this.to = to;
+  }
+};
+function createDisclosureRecord(findingId, opts = {}) {
+  const at = opts.at ?? (/* @__PURE__ */ new Date()).toISOString();
+  const actor = opts.actor ?? "operator";
+  return {
+    findingId,
+    status: "draft",
+    timeline: [
+      {
+        fromStatus: null,
+        toStatus: "draft",
+        actor,
+        at,
+        message: opts.message ?? "Disclosure record opened (draft)."
+      }
+    ]
+  };
+}
+function transition(record, input) {
+  const from = record.status;
+  const to = input.to;
+  if (!canTransition(from, to)) {
+    throw new IllegalTransitionError(from, to);
+  }
+  const at = input.at ?? (/* @__PURE__ */ new Date()).toISOString();
+  const actor = input.actor ?? "operator";
+  const next = {
+    ...record,
+    status: to,
+    timeline: [
+      ...record.timeline,
+      { fromStatus: from, toStatus: to, actor, at, message: input.message }
+    ]
+  };
+  if (to === "sent") {
+    if (input.disclosedTo)
+      next.disclosedTo = input.disclosedTo;
+    next.disclosedAt = record.disclosedAt ?? at;
+  }
+  if (to === "cve_assigned" && input.cveId) {
+    next.cveId = input.cveId;
+  }
+  return next;
+}
+function isPubliclyDisclosed(record) {
+  return PUBLIC_STATUSES.has(record.status);
+}
+
+// packages/core/dist/triage/can-auto-suppress.js
+var PROTECTED_SEVERITIES = /* @__PURE__ */ new Set([
+  "critical",
+  "high"
+]);
+var HIGH_IMPACT_CATEGORIES = /* @__PURE__ */ new Set([
+  // Remote code / command / code execution
+  "command-injection",
+  "code-injection",
+  // Injection into the data store
+  "sql-injection",
+  // Unsafe deserialization is a classic RCE primitive
+  "unsafe-deserialization",
+  // Server-side request forgery (pivot / internal network reach)
+  "ssrf",
+  // Arbitrary file read/write
+  "path-traversal",
+  // Memory corruption / binary / kernel classes
+  "heap-overflow",
+  "out-of-bounds-read",
+  "out-of-bounds-write",
+  "use-after-free",
+  "stack-buffer-overflow",
+  "integer-overflow",
+  "type-confusion",
+  "double-free",
+  "format-string",
+  "uninitialized-memory",
+  "race-condition",
+  "toctou",
+  // Supply-chain compromise (known-vulnerable / malicious package)
+  "known-vulnerable-package",
+  "supply-chain",
+  // Prototype-pollution gadget → auth bypass / RCE when chained. We actively
+  // disclose these (e.g. the jsonwebtoken verify() gadget), so they must never
+  // be auto-dropped on a score alone.
+  "prototype-pollution",
+  // Cryptographic misuse — hardcoded keys/IVs, JWT alg-confusion (alg=none /
+  // HS-vs-RS), and predictable RNG for secrets are direct key-leak / auth-bypass
+  // primitives, so the class is protected from score-only auto-drop.
+  "crypto-misuse",
+  // AI-system adversarial classes — the core 0sec "adversarial reliability"
+  // thesis (authorization-boundary break, unsafe tool use, data exfiltration,
+  // prompt hijack). A missed one of these is a disclosure-grade loss.
+  "prompt-injection",
+  "data-exfiltration",
+  "tool-misuse"
+]);
+function canAutoSuppressDetailed(finding) {
+  if (PROTECTED_SEVERITIES.has(finding.severity)) {
+    return {
+      canSuppress: false,
+      guard: "high_severity",
+      reason: `severity=${finding.severity} is disclosure-grade; routed to verification instead of auto-drop`
+    };
+  }
+  if (HIGH_IMPACT_CATEGORIES.has(finding.category)) {
+    return {
+      canSuppress: false,
+      guard: "high_impact_class",
+      reason: `category=${finding.category} is a high-impact class; routed to verification instead of auto-drop`
+    };
+  }
+  return {
+    canSuppress: true,
+    reason: `severity=${finding.severity}, category=${finding.category} eligible for score/heuristic auto-suppression`
+  };
+}
+
+// packages/core/dist/triage/verify-verdict.js
+var REPRODUCING_LAYERS = /* @__PURE__ */ new Set(["poc_gen", "pov_gate", "oracle"]);
+function evidenceKindForFinding(finding) {
+  const hasPocSteps = Array.isArray(finding.pocSteps) && finding.pocSteps.length > 0;
+  const reproduced = hasPocSteps && (finding.layerVerdicts ?? []).some((v) => v.verdict === "pass" && REPRODUCING_LAYERS.has(v.layer));
+  return reproduced ? "reproduced-poc" : "source-only";
+}
+function outcomeOf(verdict) {
+  return typeof verdict === "string" ? verdict : verdict.verdict;
+}
+function isDisclosureWorthy(finding, verdict) {
+  if (outcomeOf(verdict) !== "rejected") {
+    return {
+      keep: true,
+      reason: `verdict=${outcomeOf(verdict)}: not a rejection \u2014 finding kept`
+    };
+  }
+  const guard = canAutoSuppressDetailed(finding);
+  if (guard.canSuppress) {
+    return { keep: false, reason: guard.reason };
+  }
+  return { keep: true, guard: guard.guard, reason: guard.reason };
+}
+
+// packages/core/dist/disclose/evidence-pack.js
+var UnreproducedFindingError = class extends Error {
+  findingId;
+  constructor(findingId) {
+    super(`Finding ${findingId} has no reproduced PoC (evidenceKind !== "reproduced-poc"). Refusing to assemble a vendor-notification draft. Pass allowUnreproduced:true to stage an internal draft for review anyway.`);
+    this.name = "UnreproducedFindingError";
+    this.findingId = findingId;
+  }
+};
+function impactForSeverity(severity) {
+  switch (severity) {
+    case "critical":
+      return "Critical \u2014 full compromise / unauthenticated remote impact is plausible.";
+    case "high":
+      return "High \u2014 significant confidentiality, integrity, or availability impact.";
+    case "medium":
+      return "Medium \u2014 meaningful impact, typically conditioned on access or configuration.";
+    case "low":
+      return "Low \u2014 limited impact or requires substantial preconditions.";
+    default:
+      return "Informational.";
+  }
+}
+function impactLine(finding) {
+  const base = impactForSeverity(finding.severity);
+  const a = finding.impactAssessment;
+  if (!a)
+    return base;
+  const gain = {
+    rce: "remote code execution",
+    "lpe-to-root": "local privilege escalation to root/SYSTEM",
+    "info-leak": "information disclosure",
+    "dos-crash": "denial of service (crash)"
+  };
+  const reach = {
+    "remote-unauth": "remotely, unauthenticated",
+    "proximity-rf": "from RF/physical proximity",
+    "local-unpriv": "by an unprivileged local user",
+    "local-priv": "by a privileged local user",
+    "needs-hardware": "with specific/attacker-supplied hardware",
+    "needs-host-migration": "if the victim mounts an attacker-supplied artifact"
+  };
+  const detail = `Attacker gains ${gain[a.weaponizability] ?? a.weaponizability}, exploitable ${reach[a.reachability_tier] ?? a.reachability_tier}.`;
+  return `${base} ${detail}`;
+}
+function renderReproStep(step, index) {
+  const n = index + 1;
+  const a = step.action;
+  let detail;
+  switch (a.type) {
+    case "shell":
+      detail = "```sh\n" + a.cmd + "\n```";
+      break;
+    case "http": {
+      const headerLines = a.headers ? Object.entries(a.headers).map(([k, v]) => `${k}: ${v}`) : [];
+      const reqBlock = [
+        `${a.method} ${a.url}`,
+        ...headerLines,
+        ...a.body ? ["", a.body] : []
+      ].join("\n");
+      detail = "```http\n" + reqBlock + "\n```";
+      break;
+    }
+    case "docker":
+      detail = `\`\`\`sh
+docker run ${a.image} ${a.args.join(" ")}
+\`\`\``;
+      break;
+    case "note":
+      detail = a.text;
+      break;
+    default:
+      detail = "";
+  }
+  const head = `${n}. **${step.summary}** _(${step.kind})_`;
+  return detail ? `${head}
+
+${detail}` : head;
+}
+function assembleEvidencePack(finding, opts = {}) {
+  const reproduced = evidenceKindForFinding(finding) === "reproduced-poc";
+  if (!reproduced && !opts.allowUnreproduced) {
+    throw new UnreproducedFindingError(finding.id);
+  }
+  const redact = (s) => redactSensitiveHeaders(s);
+  const where = (() => {
+    const parts = [];
+    if (opts.target)
+      parts.push(`\`${opts.target}\``);
+    if (opts.affectedRef)
+      parts.push(`(ref \`${opts.affectedRef}\`)`);
+    if (parts.length === 0) {
+      return "_Affected component/version: to be filled in by the operator before sending._";
+    }
+    return parts.join(" ");
+  })();
+  const reproSteps = (finding.pocSteps ?? []).map((step, i) => redact(renderReproStep(step, i)));
+  const remediation = (() => {
+    const r = finding.remediation;
+    if (!r)
+      return void 0;
+    const parts = [];
+    if (r.summary)
+      parts.push(r.summary);
+    if (r.steps?.length) {
+      parts.push(r.steps.map((s, i) => `${i + 1}. ${s}`).join("\n"));
+    }
+    return parts.length ? redact(parts.join("\n\n")) : void 0;
+  })();
+  let markerWarnings;
+  if (opts.sourceEvidence !== void 0) {
+    markerWarnings = detectKnownMarkers(opts.sourceEvidence, opts.sourceEvidencePath);
+  }
+  const findingMarkers = analyzeFindingForKnownMarkers(finding);
+  if (findingMarkers.hasKnownMarker) {
+    markerWarnings = markerWarnings ? {
+      hasKnownMarker: true,
+      markers: [...markerWarnings.markers, ...findingMarkers.markers]
+    } : findingMarkers;
+  }
+  return {
+    findingId: finding.id,
+    title: finding.title,
+    severity: finding.severity,
+    what: redact(finding.description.trim()),
+    where,
+    impact: impactLine(finding),
+    reproSteps,
+    remediation,
+    reproduced,
+    markerWarnings
+  };
+}
+function renderVendorNotificationMarkdown(draft) {
+  const out = [];
+  out.push(`# Vulnerability report: ${draft.title}`, "");
+  out.push("> **DRAFT \u2014 NOT SENT.** Auto-assembled vendor-notification draft. An operator must review, fill in any `to be filled in` fields, and send it manually. Nothing here is transmitted to a vendor by 0sec. Embargo rules in `disclosure/AGENTS.md` apply.", "");
+  if (!draft.reproduced) {
+    out.push("> \u26A0\uFE0F This finding's PoC did **not** reproduce in an isolated env (`evidenceKind !== reproduced-poc`). Staged as an internal draft only \u2014 do not send to a vendor without a working PoC.", "");
+  }
+  if (draft.markerWarnings?.hasKnownMarker) {
+    out.push("> **[WARN] Known-marker signal (#674).** The supplied source evidence contains explicit TODO / FIXME / XXX markers or documented-limitation phrasing. This is a courtesy operator-review warning, not a verdict. Review the Known markers section before deciding whether to file.", "");
+  }
+  out.push(`**Severity (estimate):** ${draft.severity}`, "");
+  out.push("## What", "", draft.what, "");
+  out.push("## Where", "", draft.where, "");
+  out.push("## Impact", "", draft.impact, "");
+  out.push("## Reproduction", "");
+  if (draft.reproSteps.length > 0) {
+    out.push(draft.reproSteps.join("\n\n"), "");
+  } else {
+    out.push("_No structured PoC steps on this finding \u2014 attach a reproduction before sending._", "");
+  }
+  if (draft.remediation) {
+    out.push("## Suggested remediation", "", draft.remediation, "");
+  }
+  if (draft.markerWarnings?.hasKnownMarker) {
+    out.push("## Known markers (courtesy / operator review)", "");
+    out.push("_The source evidence contains the following explicit markers. This is a conservative regex match: review each item before deciding whether the finding is worth filing._", "");
+    for (const marker of draft.markerWarnings.markers) {
+      out.push(`- **\`${marker.marker}\`**`);
+      if (marker.sourcePath) {
+        out.push(`  - Source: \`${marker.sourcePath}\``);
+      }
+      if (marker.lineNumber) {
+        out.push(`  - Line ${marker.lineNumber}: \`${marker.line}\``);
+      } else {
+        out.push(`  - \`${marker.line}\``);
+      }
+      if (marker.context) {
+        out.push(`  - Context:
+\`\`\`
+${marker.context}
+\`\`\``);
+      }
+      out.push("");
+    }
+  }
+  return out.join("\n").replace(/\n{3,}/g, "\n\n");
+}
+
+// packages/core/dist/disclose/reproducibility-manifest.js
+import { createHash } from "node:crypto";
+var UnverifiedFindingError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UnverifiedFindingError";
+  }
+};
+var IncompleteEvidenceError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "IncompleteEvidenceError";
+  }
+};
+var MANIFEST_VERSION = 1;
+var HASH_ALGORITHM = "sha256";
+var VERIFIED_STATUSES = {
+  verified: true,
+  confirmed: true
+};
+var SENSITIVE_USERINFO = /([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)[^@\n]+@/gi;
+var SENSITIVE_QUERY_VALUE = /([?&](?:access_token|api[_-]?key|authorization|auth|cookie|session|token|bearer|jwt|refresh_token|client_secret|client_id|password|passwd|secret)=)[^&#\s]*/gi;
+var STANDALONE_CREDENTIAL = /(^|[\s,;:.-])((?:access_token|api[_-]?key|authorization|auth|cookie|session|token|bearer|jwt|refresh_token|client_secret|client_id|password|passwd|secret)=)[^\s,;:)\]"'`]*(?![\w-])/gi;
+function redactManifestValue(value) {
+  return redactPii(redactSensitiveHeaders(value).replace(SENSITIVE_USERINFO, "$1[REDACTED-USER]@").replace(SENSITIVE_QUERY_VALUE, "$1[REDACTED]").replace(STANDALONE_CREDENTIAL, "$1$2[REDACTED]"));
+}
+function redactAndHash(value) {
+  if (!value)
+    return null;
+  return createHash(HASH_ALGORITHM).update(redactManifestValue(value), "utf8").digest("hex");
+}
+function canonicalJson(value) {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value);
+  if (Array.isArray(value))
+    return `[${value.map(canonicalJson).join(",")}]`;
+  const record = value;
+  return `{${Object.keys(record).sort().filter((key) => record[key] !== void 0).map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+}
+function collectEnvironmentFingerprint() {
+  return {
+    platform: process.platform,
+    arch: process.arch,
+    nodeVersion: process.version
+  };
+}
+function extractTarget(finding) {
+  const url = finding.evidence?.request?.match(/^(?:GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(\S+)/)?.[1] ?? finding.evidence?.request?.match(/^\S+/)?.[0];
+  if (url)
+    return redactManifestValue(url);
+  if (finding.title)
+    return redactManifestValue(finding.title);
+  return "unknown";
+}
+function computeHarnessRevision(finding) {
+  if (!finding.pocSteps || finding.pocSteps.length === 0)
+    return null;
+  const redactedSteps = finding.pocSteps.map((step) => {
+    const action = step.action ? { ...step.action } : step.action;
+    if (action && "cmd" in action && typeof action.cmd === "string") {
+      action.cmd = redactManifestValue(action.cmd);
+    }
+    if (action && "body" in action && typeof action.body === "string") {
+      action.body = redactManifestValue(action.body);
+    }
+    return { ...step, action };
+  });
+  return createHash(HASH_ALGORITHM).update(canonicalJson(redactedSteps), "utf8").digest("hex");
+}
+function assembleReproducibilityManifest(finding, opts = {}) {
+  const redactionsApplied = [];
+  if (!VERIFIED_STATUSES[finding.status]) {
+    throw new UnverifiedFindingError(`Cannot assemble reproducibility manifest for finding ${finding.id}: status is "${finding.status}", expected "verified" or "confirmed".`);
+  }
+  redactionsApplied.push("verified-status-gate");
+  const pocExec = finding.pocExecution;
+  const layerVerdicts = finding.layerVerdicts ?? [];
+  const replayResult = finding.verification_result;
+  const pocSuccessful = pocExec?.overallVerdict === "exploit_still_works";
+  const replaySuccessful = replayResult?.status === "reproduced" || replayResult?.oast_confirmed === true;
+  if (!pocSuccessful && !replaySuccessful) {
+    throw new IncompleteEvidenceError(`Cannot assemble reproducibility manifest for finding ${finding.id}: no successful verified PoV. PoC verdict was ${pocExec?.overallVerdict ?? "absent"} and replay status was ${replayResult?.status ?? "absent"}. A reproduced PoC or verified replay is required.`);
+  }
+  const pocVerdict = pocExec?.overallVerdict ?? null;
+  const passedLayerCount = layerVerdicts.filter((verdict) => verdict.verdict === "pass").length;
+  const verifiedAt = pocExec?.startedAt ?? replayResult?.completed_at ?? null;
+  const replayVerdict = replayResult?.status ?? null;
+  if (pocSuccessful)
+    redactionsApplied.push("poc-verified-impact");
+  if (replaySuccessful)
+    redactionsApplied.push("replay-verified-impact");
+  const target = opts.targetIdentifier ? redactManifestValue(opts.targetIdentifier) : extractTarget(finding);
+  const modelConfig = opts.modelConfig ? redactManifestValue(opts.modelConfig) : null;
+  const toolVersion = opts.toolVersion ?? process.env["0SEC_VERSION"] ?? "unknown";
+  const timestamp = opts.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+  const sanitizedTitle = redactManifestValue(finding.title);
+  const evidenceReq = finding.evidence?.request ?? null;
+  const evidenceRes = finding.evidence?.response ?? null;
+  const evidenceHashes = {
+    requestHash: redactAndHash(evidenceReq),
+    responseHash: redactAndHash(evidenceRes)
+  };
+  const harnessRevision = computeHarnessRevision(finding);
+  const sanitizedGeneratedAt = redactManifestValue(timestamp);
+  const sanitizedFindingId = redactManifestValue(finding.id);
+  const sanitizedSeverity = redactManifestValue(finding.severity);
+  const sanitizedCategory = redactManifestValue(finding.category);
+  const sanitizedStatus = redactManifestValue(finding.status);
+  const sanitizedToolVersion = redactManifestValue(toolVersion);
+  const sanitizedPocVerdict = pocVerdict ? redactManifestValue(pocVerdict) : null;
+  const sanitizedReplayVerdict = replayVerdict ? redactManifestValue(replayVerdict) : null;
+  const sanitizedVerifiedAt = verifiedAt ? redactManifestValue(verifiedAt) : null;
+  redactionsApplied.push("redact-sensitive-headers");
+  redactionsApplied.push("redact-pii");
+  redactionsApplied.push("redact-all-text-fields");
+  redactionsApplied.push("strip-url-userinfo");
+  return {
+    manifestVersion: MANIFEST_VERSION,
+    generatedAt: sanitizedGeneratedAt,
+    findingId: sanitizedFindingId,
+    findingTitle: sanitizedTitle,
+    findingSeverity: sanitizedSeverity,
+    findingCategory: sanitizedCategory,
+    findingStatus: sanitizedStatus,
+    targetIdentifier: target,
+    toolVersion: sanitizedToolVersion,
+    harnessRevision,
+    modelConfig,
+    environmentFingerprint: collectEnvironmentFingerprint(),
+    evidenceHashes,
+    verification: {
+      pocVerdict: sanitizedPocVerdict,
+      layerVerdictCount: layerVerdicts.length,
+      passedLayerCount,
+      replayVerdict: sanitizedReplayVerdict,
+      verifiedAt: sanitizedVerifiedAt
+    },
+    redactionsApplied
+  };
+}
+function renderReproducibilityManifest(manifest) {
+  const lines = [];
+  const add = (key, val) => {
+    lines.push(`  ${key.padEnd(28)} ${val ?? "\u2014"}`);
+  };
+  lines.push("\u2500".repeat(72));
+  lines.push("  REPRODUCIBILITY MANIFEST  (v" + manifest.manifestVersion + ")");
+  lines.push("\u2500".repeat(72));
+  lines.push("");
+  add("Generated", manifest.generatedAt);
+  add("Finding ID", manifest.findingId);
+  add("Title", manifest.findingTitle);
+  add("Severity", manifest.findingSeverity);
+  add("Category", manifest.findingCategory);
+  add("Status", manifest.findingStatus);
+  lines.push("");
+  lines.push("  Target");
+  lines.push("  " + "\u2500".repeat(66));
+  add("Identifier", manifest.targetIdentifier);
+  lines.push("");
+  lines.push("  Environment");
+  lines.push("  " + "\u2500".repeat(66));
+  add("Tool version", manifest.toolVersion);
+  add("Platform", manifest.environmentFingerprint.platform);
+  add("Architecture", manifest.environmentFingerprint.arch);
+  add("Node.js", manifest.environmentFingerprint.nodeVersion);
+  add("Model config", manifest.modelConfig ?? "\u2014");
+  lines.push("");
+  lines.push("  Evidence");
+  lines.push("  " + "\u2500".repeat(66));
+  add("Request (SHA-256)", manifest.evidenceHashes.requestHash ?? "\u2014");
+  add("Response (SHA-256)", manifest.evidenceHashes.responseHash ?? "\u2014");
+  add("Harness revision", manifest.harnessRevision ?? "\u2014");
+  lines.push("");
+  lines.push("  Verification");
+  lines.push("  " + "\u2500".repeat(66));
+  add("PoC verdict", manifest.verification.pocVerdict ?? "\u2014");
+  add("Layer verdicts", `${manifest.verification.passedLayerCount}/${manifest.verification.layerVerdictCount} pass`);
+  add("Replay verdict", manifest.verification.replayVerdict ?? "\u2014");
+  add("Verified at", manifest.verification.verifiedAt ?? "\u2014");
+  lines.push("");
+  lines.push("  Redactions applied");
+  lines.push("  " + "\u2500".repeat(66));
+  for (const r of manifest.redactionsApplied) {
+    lines.push(`    \u2022 ${r}`);
+  }
+  lines.push("");
+  lines.push("\u2500".repeat(72));
+  lines.push("  MANIFEST \u2014 FOR HUMAN REVIEW ONLY. NOT A DISCLOSURE ARTIFACT.");
+  lines.push("\u2500".repeat(72));
+  return lines.join("\n");
+}
+
+export {
+  isFreezeAvailable,
+  composeExploitSession,
+  composeStepSession,
+  renderExploitScreenshot,
+  extractSiblingFix,
+  MAX_CAPTURE_BYTES,
+  DEFAULT_STEP_TIMEOUT_MS,
+  setRuntimeDeps,
+  executePocSteps,
+  decideFilingState,
+  dropSlug,
+  droppedFilename,
+  formatDroppedReason,
+  assembleBundleIndex,
+  PUBLISHABLE_STATUSES,
+  EmbargoedFindingError,
+  parseDisclosure,
+  redactPii,
+  sanitizeWriteup,
+  extractSections,
+  generateWriteup,
+  DISCLOSURE_STATUSES,
+  TERMINAL_STATUSES,
+  PUBLIC_STATUSES,
+  allowedNextStatuses,
+  canTransition,
+  IllegalTransitionError,
+  createDisclosureRecord,
+  transition,
+  isPubliclyDisclosed,
+  canAutoSuppressDetailed,
+  evidenceKindForFinding,
+  isDisclosureWorthy,
+  UnreproducedFindingError,
+  assembleEvidencePack,
+  renderVendorNotificationMarkdown,
+  UnverifiedFindingError,
+  IncompleteEvidenceError,
+  assembleReproducibilityManifest,
+  renderReproducibilityManifest
+};