0sec-cli 0.22.1 → 0.23.0

package/chunks/chunk-AAA4PRWK.js

@@ -0,0 +1,990 @@
+#!/usr/bin/env node
+import { createRequire as __0CreateRequire } from "node:module";
+const require = __0CreateRequire(import.meta.url);
+import {
+  isAdmittedSmolvmWorkbench
+} from "./chunk-NI6QYQSK.js";
+import {
+  isScopeEnforcementEnabled
+} from "./chunk-ITES7BCY.js";
+import {
+  external_exports
+} from "./chunk-VIT5ALXF.js";
+
+// packages/core/dist/bench/improvement-promotion.js
+import { createHash } from "node:crypto";
+var DEFAULT_IMPROVEMENT_PROMOTION_POLICY = Object.freeze({
+  minimumCases: 10,
+  minimumDevelopmentLift: 0.05,
+  minimumHeldOutLift: 0.03,
+  maximumNegativeControlFpDelta: 0.02,
+  maximumCostMultiplier: 1.5
+});
+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().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+}
+function digest(value) {
+  return `sha256:${createHash("sha256").update(canonicalJson(value)).digest("hex")}`;
+}
+function isSha256(value) {
+  return /^sha256:[a-f0-9]{64}$/i.test(value);
+}
+function metricSampleIsSufficient(result, minimumCases) {
+  return result.development.champion.cases >= minimumCases && result.development.challenger.cases >= minimumCases && result.heldOut.champion.cases >= minimumCases && result.heldOut.challenger.cases >= minimumCases && result.negativeControls.champion.cases >= minimumCases && result.negativeControls.challenger.cases >= minimumCases;
+}
+function resultRatesAreFinite(result) {
+  return [
+    result.development.champion.successRate,
+    result.development.challenger.successRate,
+    result.heldOut.champion.successRate,
+    result.heldOut.challenger.successRate,
+    result.negativeControls.champion.falsePositiveRate,
+    result.negativeControls.challenger.falsePositiveRate
+  ].every((value) => Number.isFinite(value) && value >= 0 && value <= 1);
+}
+function makeDecision(candidateId, status, checks) {
+  const unsigned = {
+    schemaVersion: 1,
+    candidateId,
+    status,
+    checks
+  };
+  return {
+    ...unsigned,
+    decisionDigest: digest(unsigned)
+  };
+}
+function evaluateImprovementPromotion(candidate, policy = DEFAULT_IMPROVEMENT_PROMOTION_POLICY) {
+  const result = candidate.result;
+  const checks = [];
+  checks.push({
+    id: "candidate_identity",
+    passed: candidate.candidateId.length > 0 && candidate.candidateId === result.candidateId,
+    detail: "candidate id must be non-empty and match the sealed research result"
+  });
+  checks.push({
+    id: "artifact_digests",
+    passed: isSha256(candidate.baseArtifactDigest) && isSha256(candidate.candidateArtifactDigest) && candidate.baseArtifactDigest !== candidate.candidateArtifactDigest,
+    detail: "base and candidate artifacts must be distinct sha256 digests"
+  });
+  checks.push({
+    id: "ci",
+    passed: result.ciPassed,
+    detail: "candidate evaluation must carry a passing CI attestation"
+  });
+  checks.push({
+    id: "evaluator_stability",
+    passed: isSha256(result.evaluatorDigestBefore) && result.evaluatorDigestBefore === result.evaluatorDigestAfter,
+    detail: "the evaluator digest must remain stable across the candidate evaluation"
+  });
+  const provenance = result.provenance;
+  checks.push({
+    id: "comparison_compatibility",
+    passed: provenance === void 0 || provenance.compatibilityStatus === "compatible" && Boolean(provenance.resolvedModel) && Boolean(provenance.provider) && provenance.evaluatorDigest === result.evaluatorDigestBefore && provenance.development.digest === result.developmentCorpusDigest && provenance.heldOut.digest === result.heldOutCorpusDigest && provenance.negativeControl.digest === result.negativeControlCorpusDigest,
+    detail: provenance === void 0 ? "legacy result has no comparison provenance; explicit provenance enables longitudinal gating" : provenance.compatibilityStatus === "compatible" ? "comparison provenance is compatible" : "comparison provenance is incompatible or unresolved"
+  });
+  checks.push({
+    id: "holdout_exposure",
+    passed: result.campaignGate === void 0 || result.campaignGate.allowed,
+    detail: result.campaignGate?.reason ?? "holdout exposure and durable campaign accounting permit promotion"
+  });
+  checks.push({
+    id: "evidence",
+    passed: result.evidenceRefs.length > 0,
+    detail: "candidate evaluation must retain at least one evidence reference"
+  });
+  checks.push({
+    id: "sample_size",
+    passed: resultRatesAreFinite(result) && metricSampleIsSufficient(result, policy.minimumCases),
+    detail: `every sealed lane must contain at least ${policy.minimumCases} finite observations`
+  });
+  const developmentLift = result.development.challenger.successRate - result.development.champion.successRate;
+  checks.push({
+    id: "development_lift",
+    passed: developmentLift >= policy.minimumDevelopmentLift,
+    detail: `development success lift ${developmentLift.toFixed(4)} must be at least ${policy.minimumDevelopmentLift.toFixed(4)}`
+  });
+  const heldOutLift = result.heldOut.challenger.successRate - result.heldOut.champion.successRate;
+  checks.push({
+    id: "held_out_lift",
+    passed: heldOutLift >= policy.minimumHeldOutLift,
+    detail: `held-out success lift ${heldOutLift.toFixed(4)} must be at least ${policy.minimumHeldOutLift.toFixed(4)}`
+  });
+  const fpDelta = result.negativeControls.challenger.falsePositiveRate - result.negativeControls.champion.falsePositiveRate;
+  checks.push({
+    id: "negative_control_precision",
+    passed: fpDelta <= policy.maximumNegativeControlFpDelta,
+    detail: `negative-control FP delta ${fpDelta.toFixed(4)} must not exceed ${policy.maximumNegativeControlFpDelta.toFixed(4)}`
+  });
+  const championCost = result.heldOut.champion.costPerSuccessUsd;
+  const challengerCost = result.heldOut.challenger.costPerSuccessUsd;
+  const zeroSuccessBaseline = championCost === null && result.heldOut.champion.successRate === 0 && result.heldOut.champion.inconclusiveRate === 0;
+  const costPasses = challengerCost !== null && Number.isFinite(challengerCost) && challengerCost >= 0 && (zeroSuccessBaseline || championCost !== null && Number.isFinite(championCost) && championCost >= 0 && challengerCost <= championCost * policy.maximumCostMultiplier);
+  checks.push({
+    id: "cost_discipline",
+    passed: costPasses,
+    detail: `held-out challenger cost must be finite and nonnegative; at most ${policy.maximumCostMultiplier.toFixed(2)}x champion cost unless the fully observed champion has zero successes`
+  });
+  if (checks.some((check) => !check.passed)) {
+    return makeDecision(candidate.candidateId, "rejected", checks);
+  }
+  return makeDecision(candidate.candidateId, candidate.kind === "source" ? "requires_human_approval" : "eligible_for_canary", checks);
+}
+function appendImprovementLedgerEntry(entries, event) {
+  const verification = verifyImprovementLedger(entries);
+  if (!verification.valid)
+    throw new Error(`cannot append to invalid improvement ledger: ${verification.reason}`);
+  if (!isSha256(event.payloadDigest))
+    throw new Error("ledger payloadDigest must be a sha256 digest");
+  const previousDigest = entries.length === 0 ? null : entries[entries.length - 1].entryDigest;
+  const unsigned = {
+    schemaVersion: 1,
+    sequence: entries.length,
+    occurredAt: event.occurredAt,
+    type: event.type,
+    candidateId: event.candidateId,
+    payloadDigest: event.payloadDigest,
+    previousDigest
+  };
+  return {
+    ...unsigned,
+    entryDigest: digest(unsigned)
+  };
+}
+function verifyImprovementLedger(entries) {
+  let previousDigest = null;
+  for (const [sequence, entry] of entries.entries()) {
+    if (entry.sequence !== sequence)
+      return { valid: false, reason: `unexpected sequence at ${sequence}` };
+    if (entry.previousDigest !== previousDigest)
+      return { valid: false, reason: `broken predecessor at ${sequence}` };
+    if (!isSha256(entry.payloadDigest))
+      return { valid: false, reason: `invalid payload digest at ${sequence}` };
+    const unsigned = {
+      schemaVersion: entry.schemaVersion,
+      sequence: entry.sequence,
+      occurredAt: entry.occurredAt,
+      type: entry.type,
+      candidateId: entry.candidateId,
+      payloadDigest: entry.payloadDigest,
+      previousDigest: entry.previousDigest
+    };
+    if (entry.entryDigest !== digest(unsigned))
+      return { valid: false, reason: `invalid entry digest at ${sequence}` };
+    previousDigest = entry.entryDigest;
+  }
+  return { valid: true };
+}
+
+// packages/core/dist/improvement/config.js
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, resolve, sep } from "node:path";
+var relativePath = external_exports.string().min(1).max(512).refine((value) => !isAbsolute(value) && !value.includes("\\") && !value.includes("\0") && value !== "." && value.split("/").every((part) => part !== ".." && part !== "" && part !== "."), "must be a normalized relative file or directory path (not the entire workspace)");
+var argv = external_exports.array(external_exports.string().max(8192).refine((value) => !value.includes("\0"))).min(1).max(128).refine((value) => value[0].length > 0, "executable must not be empty");
+var finitePositive = external_exports.number().finite().positive();
+var schema = external_exports.object({
+  schemaVersion: external_exports.literal(1),
+  sourceRoot: external_exports.string().min(1),
+  storePath: external_exports.string().min(1),
+  image: external_exports.string().min(1).max(512).regex(/^[a-zA-Z0-9][a-zA-Z0-9_./:@-]*$/),
+  backend: external_exports.enum(["docker", "smolvm"]).optional(),
+  imageArchive: external_exports.string().min(1).max(4096).refine((value) => !value.includes("\0")).optional(),
+  sourcePaths: external_exports.array(relativePath).min(1).max(256),
+  editablePaths: external_exports.array(relativePath).min(1).max(256),
+  kind: external_exports.enum(["source", "skill", "router", "lens"]).default("source"),
+  command: argv,
+  buildCommand: argv.optional(),
+  cases: external_exports.array(external_exports.object({
+    id: external_exports.string().min(1).max(128),
+    lane: external_exports.enum(["development", "held-out", "negative-control"]),
+    input: external_exports.unknown(),
+    expected: external_exports.unknown()
+  }).strict()).min(3).max(1e3),
+  repeats: external_exports.number().int().min(2).max(20).default(3),
+  maxIterations: external_exports.number().int().min(1).max(100).default(3),
+  maxModelTurns: external_exports.number().int().min(1).max(64).default(12),
+  maxModelCostUsd: finitePositive.max(1e3).default(5),
+  maxEvaluationCostUsd: finitePositive.max(1e3).default(5),
+  computeUsdPerSecond: finitePositive.max(10),
+  timeoutMs: external_exports.number().int().min(100).max(6e5).default(6e4),
+  memoryMb: external_exports.number().int().min(32).max(16384).default(1024),
+  cpus: finitePositive.max(16).default(1),
+  maxOutputBytes: external_exports.number().int().min(256).max(16 * 1024 * 1024).default(64 * 1024),
+  maxSourceBytes: external_exports.number().int().min(1024).max(512 * 1024 * 1024).default(64 * 1024 * 1024),
+  maxChangedBytes: external_exports.number().int().min(128).max(4 * 1024 * 1024).default(256 * 1024),
+  model: external_exports.string().min(1).optional(),
+  objective: external_exports.string().min(1).max(16e3),
+  allowModelSourceAccess: external_exports.boolean().default(false),
+  autoPromote: external_exports.boolean().default(false),
+  canaryTrials: external_exports.number().int().min(1).max(20).default(2),
+  promotionPolicy: external_exports.object({
+    minimumCases: external_exports.number().int().min(3).max(1e3).default(DEFAULT_IMPROVEMENT_PROMOTION_POLICY.minimumCases),
+    minimumDevelopmentLift: finitePositive.max(1).default(DEFAULT_IMPROVEMENT_PROMOTION_POLICY.minimumDevelopmentLift),
+    minimumHeldOutLift: finitePositive.max(1).default(DEFAULT_IMPROVEMENT_PROMOTION_POLICY.minimumHeldOutLift),
+    maximumNegativeControlFpDelta: external_exports.literal(0).default(0),
+    maximumCostMultiplier: finitePositive.max(10).default(DEFAULT_IMPROVEMENT_PROMOTION_POLICY.maximumCostMultiplier)
+  }).strict().default({}),
+  safety: external_exports.object({
+    enabled: external_exports.boolean().default(false),
+    holdoutExposureLimit: external_exports.number().int().min(1).max(1e6)
+  }).strict().optional(),
+  maxAlternativeParents: external_exports.number().int().min(0).max(10).optional()
+}).strict();
+function canonicalEvolutionJson(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return JSON.stringify(value);
+  if (typeof value === "number" && Number.isFinite(value))
+    return JSON.stringify(value);
+  if (Array.isArray(value))
+    return `[${Array.from(value, canonicalEvolutionJson).join(",")}]`;
+  if (typeof value === "object" && value !== null && Object.getPrototypeOf(value) === Object.prototype) {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalEvolutionJson(value[key])}`).join(",")}}`;
+  }
+  throw new Error("evolution cases must contain finite JSON values only");
+}
+function parseEvolutionConfig(raw, baseDir = process.cwd()) {
+  const parsed = schema.parse(raw);
+  const admitted = isAdmittedSmolvmWorkbench();
+  if (admitted) {
+    if (parsed.imageArchive)
+      throw new Error("Admitted workbench images must use the host-approved catalog, not guest archive paths");
+    parsed.backend = "smolvm";
+  }
+  if (parsed.backend === "smolvm") {
+    if (!parsed.imageArchive && !admitted)
+      throw new Error("smolvm requires a local imageArchive");
+    if (!Number.isInteger(parsed.cpus))
+      throw new Error("smolvm cpus must be an integer");
+    if (parsed.imageArchive)
+      parsed.imageArchive = resolve(baseDir, parsed.imageArchive);
+  } else if (parsed.imageArchive !== void 0) {
+    throw new Error("imageArchive is only valid with backend smolvm");
+  }
+  if (parsed.cases.length * parsed.repeats * 4 * parsed.maxOutputBytes > 64 * 1024 * 1024) {
+    throw new Error("evaluation stream retention exceeds 64 MiB; reduce cases, repeats or maxOutputBytes");
+  }
+  const seenIds = /* @__PURE__ */ new Set();
+  const inputs = /* @__PURE__ */ new Map();
+  for (const entry of parsed.cases) {
+    if (seenIds.has(entry.id))
+      throw new Error(`duplicate evolution case id: ${entry.id}`);
+    seenIds.add(entry.id);
+    const input = canonicalEvolutionJson(entry.input);
+    canonicalEvolutionJson(entry.expected);
+    if (inputs.has(input))
+      throw new Error(`duplicate evaluation input: ${entry.id}; cases and lanes must be independent`);
+    inputs.set(input, entry.lane);
+  }
+  for (const lane of ["development", "held-out", "negative-control"]) {
+    if (parsed.cases.filter((entry) => entry.lane === lane).length < parsed.promotionPolicy.minimumCases) {
+      throw new Error(`${lane} requires at least ${parsed.promotionPolicy.minimumCases} distinct cases`);
+    }
+  }
+  for (const edit of parsed.editablePaths) {
+    if (!parsed.sourcePaths.some((source) => edit === source || edit.startsWith(`${source}/`))) {
+      throw new Error(`editable path ${edit} is not inside a selected source path`);
+    }
+  }
+  const sourceRoot = resolve(baseDir, parsed.sourceRoot === "~" ? homedir() : parsed.sourceRoot.startsWith("~/") ? resolve(homedir(), parsed.sourceRoot.slice(2)) : parsed.sourceRoot);
+  const storePath = resolve(baseDir, parsed.storePath === "~" ? homedir() : parsed.storePath.startsWith("~/") ? resolve(homedir(), parsed.storePath.slice(2)) : parsed.storePath);
+  if (sourceRoot === storePath)
+    throw new Error("evolution store cannot be the source workspace");
+  for (const selected of parsed.sourcePaths) {
+    const source = resolve(sourceRoot, selected);
+    if (storePath === source || storePath.startsWith(`${source}/`) || source.startsWith(`${storePath}/`)) {
+      throw new Error("evolution store and selected source paths must not overlap");
+    }
+  }
+  return JSON.parse(JSON.stringify({ ...parsed, sourceRoot, storePath }));
+}
+function loadEvolutionConfigFile(path) {
+  const absPath = resolve(path);
+  if (!existsSync(absPath))
+    throw new Error(`config file not found: ${absPath}`);
+  const configFile = realpathSync(absPath);
+  const raw = JSON.parse(readFileSync(absPath, "utf8"));
+  const config = parseEvolutionConfig(raw, resolve(path, ".."));
+  for (const source of config.sourcePaths) {
+    const sourcePath = resolve(config.sourceRoot, source);
+    const selected = existsSync(sourcePath) ? realpathSync(sourcePath) : sourcePath;
+    if (configFile === selected || configFile.startsWith(`${selected}${sep}`)) {
+      throw new Error("evolution config contains private answers and must be outside selected source paths");
+    }
+  }
+  return config;
+}
+
+// packages/core/dist/verification-spec/spec.js
+import { execFile } from "node:child_process";
+import { promises as fs } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve as resolve2, isAbsolute as isAbsolute2, normalize, sep as sep2 } from "node:path";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var MAX_GIT_DIFF_BYTES = 1e6;
+var GIT_CHECK_TIMEOUT_MS = 5e3;
+var FULL_GIT_OBJECT_ID_RE = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i;
+var MAX_PATTERN_LENGTH = 512;
+var MAX_FILE_BYTES = 1e6;
+function resolveRepoPath(repoRoot, file) {
+  if (typeof file !== "string" || file.length === 0)
+    return null;
+  if (isAbsolute2(file))
+    return null;
+  const root = resolve2(repoRoot);
+  const candidate = resolve2(root, file);
+  const normalized = normalize(candidate);
+  if (normalized !== root && !normalized.startsWith(root + sep2)) {
+    return null;
+  }
+  return normalized;
+}
+async function checkRepoBoundary(repoRoot, absPath) {
+  try {
+    await fs.lstat(absPath);
+  } catch {
+    return "missing";
+  }
+  try {
+    const [realRoot, realTarget] = await Promise.all([
+      fs.realpath(repoRoot),
+      fs.realpath(absPath)
+    ]);
+    if (realTarget === realRoot || realTarget.startsWith(realRoot + sep2)) {
+      return "inside";
+    }
+    return "outside";
+  } catch {
+    return "outside";
+  }
+}
+function safeRegex(pattern, flags) {
+  if (typeof pattern !== "string")
+    return null;
+  if (pattern.length > MAX_PATTERN_LENGTH)
+    return null;
+  try {
+    return new RegExp(pattern, flags);
+  } catch {
+    return null;
+  }
+}
+async function readFileSafe(absPath) {
+  try {
+    const stat = await fs.stat(absPath);
+    if (!stat.isFile())
+      return null;
+    if (stat.size > MAX_FILE_BYTES)
+      return null;
+    return await fs.readFile(absPath, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function evaluateGitDiffApplies(predicate, repoRoot) {
+  if (predicate.diff.trim().length === 0) {
+    return { predicate, passed: false, reason: "git diff is empty" };
+  }
+  if (Buffer.byteLength(predicate.diff, "utf8") > MAX_GIT_DIFF_BYTES) {
+    return {
+      predicate,
+      passed: false,
+      reason: `git diff exceeds ${MAX_GIT_DIFF_BYTES} bytes`
+    };
+  }
+  if (!FULL_GIT_OBJECT_ID_RE.test(predicate.baseCommit)) {
+    return { predicate, passed: false, reason: "invalid git base commit" };
+  }
+  let head;
+  try {
+    const result = await execFileAsync("git", ["rev-parse", "--verify", "HEAD"], {
+      cwd: repoRoot,
+      timeout: GIT_CHECK_TIMEOUT_MS,
+      maxBuffer: 4096
+    });
+    head = result.stdout.trim();
+  } catch {
+    return {
+      predicate,
+      passed: false,
+      reason: "git repository HEAD unavailable"
+    };
+  }
+  if (head.toLowerCase() !== predicate.baseCommit.toLowerCase()) {
+    return {
+      predicate,
+      passed: false,
+      reason: "git HEAD does not match diff base commit"
+    };
+  }
+  let tempDir;
+  try {
+    tempDir = await fs.mkdtemp(join(tmpdir(), "0-verify-diff-"));
+    const patchPath = join(tempDir, "evidence.patch");
+    await fs.writeFile(patchPath, predicate.diff, { encoding: "utf8", mode: 384 });
+    await execFileAsync("git", ["apply", "--check", "--whitespace=nowarn", "--", patchPath], {
+      cwd: repoRoot,
+      timeout: GIT_CHECK_TIMEOUT_MS,
+      maxBuffer: 65536
+    });
+    return {
+      predicate,
+      passed: true,
+      reason: "git diff applies cleanly"
+    };
+  } catch {
+    return {
+      predicate,
+      passed: false,
+      reason: "git diff does not apply cleanly"
+    };
+  } finally {
+    if (tempDir) {
+      try {
+        await fs.rm(tempDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+}
+async function evaluateOne(predicate, repoRoot) {
+  switch (predicate.kind) {
+    case "file-exists": {
+      const abs = resolveRepoPath(repoRoot, predicate.file);
+      if (!abs) {
+        return {
+          predicate,
+          passed: false,
+          reason: `path escapes repo root or is invalid: ${predicate.file}`
+        };
+      }
+      const outcome = await checkRepoBoundary(repoRoot, abs);
+      if (outcome === "outside") {
+        return {
+          predicate,
+          passed: false,
+          reason: `path resolves outside repo root: ${predicate.file}`
+        };
+      }
+      const ok = outcome === "inside";
+      return {
+        predicate,
+        passed: ok,
+        reason: ok ? "file exists" : `file not found: ${predicate.file}`
+      };
+    }
+    case "file-contains": {
+      const abs = resolveRepoPath(repoRoot, predicate.file);
+      if (!abs) {
+        return {
+          predicate,
+          passed: false,
+          reason: `path escapes repo root or is invalid: ${predicate.file}`
+        };
+      }
+      const outcome = await checkRepoBoundary(repoRoot, abs);
+      if (outcome === "outside") {
+        return {
+          predicate,
+          passed: false,
+          reason: `path resolves outside repo root: ${predicate.file}`
+        };
+      }
+      if (outcome === "missing") {
+        return {
+          predicate,
+          passed: false,
+          reason: `file not found or unreadable: ${predicate.file}`
+        };
+      }
+      const content = await readFileSafe(abs);
+      if (content === null) {
+        return {
+          predicate,
+          passed: false,
+          reason: `file not found or unreadable: ${predicate.file}`
+        };
+      }
+      const re = safeRegex(predicate.pattern, predicate.flags);
+      if (!re) {
+        return {
+          predicate,
+          passed: false,
+          reason: `invalid regex: /${predicate.pattern}/${predicate.flags ?? ""}`
+        };
+      }
+      const matched = re.test(content);
+      return {
+        predicate,
+        passed: matched,
+        reason: matched ? `pattern matched in ${predicate.file}` : `pattern not found in ${predicate.file}`
+      };
+    }
+    case "file-missing-pattern": {
+      const abs = resolveRepoPath(repoRoot, predicate.file);
+      if (!abs) {
+        return {
+          predicate,
+          passed: false,
+          reason: `path escapes repo root or is invalid: ${predicate.file}`
+        };
+      }
+      const outcome = await checkRepoBoundary(repoRoot, abs);
+      if (outcome === "outside") {
+        return {
+          predicate,
+          passed: false,
+          reason: `path resolves outside repo root: ${predicate.file}`
+        };
+      }
+      if (outcome === "missing") {
+        return {
+          predicate,
+          passed: false,
+          reason: `file not found or unreadable: ${predicate.file}`
+        };
+      }
+      const content = await readFileSafe(abs);
+      if (content === null) {
+        return {
+          predicate,
+          passed: false,
+          reason: `file not found or unreadable: ${predicate.file}`
+        };
+      }
+      const re = safeRegex(predicate.pattern, predicate.flags);
+      if (!re) {
+        return {
+          predicate,
+          passed: false,
+          reason: `invalid regex: /${predicate.pattern}/${predicate.flags ?? ""}`
+        };
+      }
+      const matched = re.test(content);
+      return {
+        predicate,
+        passed: !matched,
+        reason: matched ? `pattern unexpectedly present in ${predicate.file}` : `pattern absent in ${predicate.file}`
+      };
+    }
+    case "git-diff-applies":
+      return evaluateGitDiffApplies(predicate, repoRoot);
+    case "ast-shape": {
+      return {
+        predicate,
+        passed: false,
+        reason: "ast-shape predicates are not yet implemented in the OSS verifier"
+      };
+    }
+    default: {
+      const _exhaustive = predicate;
+      void _exhaustive;
+      return {
+        predicate,
+        passed: false,
+        reason: "unknown predicate kind"
+      };
+    }
+  }
+}
+async function evaluateVerificationSpec(spec, repoRoot) {
+  const results = [];
+  for (const predicate of spec.code) {
+    results.push(await evaluateOne(predicate, repoRoot));
+  }
+  const failedPredicates = results.filter((r) => !r.passed);
+  const hasVulnerabilityPredicate = spec.code.some((predicate) => predicate.kind !== "git-diff-applies");
+  if (!hasVulnerabilityPredicate && !spec.behavior) {
+    return {
+      passed: false,
+      failedPredicates,
+      reason: spec.code.length === 0 ? "no predicates" : "no vulnerability predicates"
+    };
+  }
+  const codePassed = failedPredicates.length === 0 && hasVulnerabilityPredicate;
+  if (spec.behavior) {
+    return {
+      passed: codePassed,
+      failedPredicates,
+      reason: "behavior eval not yet supported"
+    };
+  }
+  return {
+    passed: codePassed,
+    failedPredicates
+  };
+}
+
+// packages/core/dist/improvement/artifacts.js
+import { randomUUID } from "node:crypto";
+import { closeSync, constants, fchmodSync, fstatSync, fsyncSync, linkSync, lstatSync, mkdirSync, openSync, readFileSync as readFileSync2, realpathSync as realpathSync2, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute as isAbsolute3, join as join2, parse, resolve as resolve3, sep as sep3 } from "node:path";
+var MAX_ARTIFACT_BYTES = 128 * 1024 * 1024;
+function hasCode(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+function resolveEvolutionDirectoryPath(path) {
+  const requested = resolve3(path);
+  const root = parse(requested).root;
+  let cursor = root;
+  const components = requested.slice(root.length).split(sep3).filter(Boolean);
+  for (let index = 0; index < components.length; index++) {
+    cursor = join2(cursor, components[index]);
+    let stat;
+    try {
+      stat = lstatSync(cursor);
+    } catch (error) {
+      if (!hasCode(error, "ENOENT"))
+        throw error;
+      return join2(cursor, ...components.slice(index + 1));
+    }
+    if (stat.isSymbolicLink()) {
+      const trustedTarget = process.platform === "darwin" ? { "/tmp": "/private/tmp", "/var": "/private/var", "/etc": "/private/etc" }[cursor] : void 0;
+      if (!trustedTarget || stat.uid !== 0 || realpathSync2(cursor) !== trustedTarget || index === components.length - 1) {
+        throw new Error(`unsafe evolution directory: ${cursor}`);
+      }
+      cursor = trustedTarget;
+    } else if (!stat.isDirectory()) {
+      throw new Error(`unsafe evolution directory: ${cursor}`);
+    }
+  }
+  return cursor;
+}
+function inspectDirectories(path, create) {
+  if (!isAbsolute3(path))
+    throw new Error("evolution storage paths must be absolute");
+  const absolute = resolveEvolutionDirectoryPath(path);
+  const root = parse(absolute).root;
+  let cursor = root;
+  for (const component of absolute.slice(root.length).split(sep3).filter(Boolean)) {
+    cursor = join2(cursor, component);
+    if (create) {
+      try {
+        mkdirSync(cursor, { mode: 448 });
+      } catch (error) {
+        if (!hasCode(error, "EEXIST"))
+          throw error;
+      }
+    }
+    const stat = lstatSync(cursor);
+    if (!stat.isDirectory() || stat.isSymbolicLink())
+      throw new Error(`unsafe evolution directory: ${cursor}`);
+  }
+  const leaf = lstatSync(absolute);
+  if (typeof process.getuid === "function" && leaf.uid !== process.getuid() || (leaf.mode & 63) !== 0) {
+    throw new Error(`evolution storage directory must be owner-only: ${absolute}`);
+  }
+  return absolute;
+}
+function ensureEvolutionDirectory(path) {
+  return inspectDirectories(path, true);
+}
+function readEvolutionArtifact(path) {
+  inspectDirectories(dirname(path), false);
+  const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const stat = fstatSync(fd);
+    if (!stat.isFile() || stat.size > MAX_ARTIFACT_BYTES || (stat.mode & 63) !== 0 || typeof process.getuid === "function" && stat.uid !== process.getuid()) {
+      throw new Error(`unsafe evolution artifact: ${path}`);
+    }
+    const value = JSON.parse(readFileSync2(fd, "utf8"));
+    canonicalEvolutionJson(value);
+    return value;
+  } finally {
+    closeSync(fd);
+  }
+}
+function publishEvolutionArtifact(path, value) {
+  const content = canonicalEvolutionJson(value);
+  if (Buffer.byteLength(content) > MAX_ARTIFACT_BYTES)
+    throw new Error("evolution artifact exceeds retention limit");
+  const directory = ensureEvolutionDirectory(dirname(path));
+  const temporary = join2(directory, `.artifact-${randomUUID()}.tmp`);
+  const fd = openSync(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
+  try {
+    try {
+      writeFileSync(fd, content, "utf8");
+      fchmodSync(fd, 256);
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    try {
+      linkSync(temporary, path);
+    } catch (error) {
+      if (!hasCode(error, "EEXIST"))
+        throw error;
+      if (canonicalEvolutionJson(readEvolutionArtifact(path)) !== content) {
+        throw new Error(`immutable evolution artifact collision: ${path}`);
+      }
+    }
+    const directoryFd = openSync(directory, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+    try {
+      fsyncSync(directoryFd);
+    } finally {
+      closeSync(directoryFd);
+    }
+  } finally {
+    unlinkSync(temporary);
+  }
+}
+
+// packages/core/dist/agent/apply-patch.js
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+var BEGIN = "*** Begin Patch";
+var END = "*** End Patch";
+function parsePatch(input) {
+  const text = input.replace(/\r\n/g, "\n");
+  const lines = text.split("\n");
+  if (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  if (lines.length === 0 || lines[0].trim() !== BEGIN) {
+    throw new Error(`apply_patch: envelope must start with "${BEGIN}" (got: ${lines[0] ?? "<empty>"})`);
+  }
+  if (lines[lines.length - 1].trim() !== END) {
+    throw new Error(`apply_patch: envelope must end with "${END}"`);
+  }
+  const body = lines.slice(1, -1);
+  const ops = [];
+  let i = 0;
+  while (i < body.length) {
+    const line = body[i];
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      i += 1;
+      continue;
+    }
+    const addMatch = /^\*\*\* Add File: (.+)$/.exec(trimmed);
+    const replaceMatch = /^\*\*\* Replace File: (.+)$/.exec(trimmed);
+    const updateMatch = /^\*\*\* Update File: (.+)$/.exec(trimmed);
+    const deleteMatch = /^\*\*\* Delete File: (.+)$/.exec(trimmed);
+    if (addMatch || replaceMatch) {
+      const path = (addMatch?.[1] ?? replaceMatch[1]).trim();
+      const overwrite = replaceMatch !== null;
+      i += 1;
+      const contentLines = [];
+      while (i < body.length && !isOpHeader(body[i])) {
+        const ln = body[i];
+        if (ln.length === 0) {
+          contentLines.push("");
+        } else if (ln[0] === "+") {
+          contentLines.push(ln.slice(1));
+        } else {
+          throw new Error(`apply_patch: Add/Replace body lines must start with "+" (got: ${JSON.stringify(ln)})`);
+        }
+        i += 1;
+      }
+      ops.push({
+        kind: "add",
+        path,
+        contents: contentLines.join("\n"),
+        overwrite
+      });
+      continue;
+    }
+    if (deleteMatch) {
+      ops.push({ kind: "delete", path: deleteMatch[1].trim() });
+      i += 1;
+      continue;
+    }
+    if (updateMatch) {
+      const path = updateMatch[1].trim();
+      i += 1;
+      const hunks = [];
+      while (i < body.length && !isOpHeader(body[i])) {
+        const hunkLine = body[i];
+        if (!hunkLine.startsWith("@@")) {
+          throw new Error(`apply_patch: Update File body must begin with "@@ <anchor>" hunk header (got: ${JSON.stringify(hunkLine)})`);
+        }
+        const anchor = hunkLine.slice(2).trim();
+        i += 1;
+        const hunkBody = [];
+        while (i < body.length && !isOpHeader(body[i]) && !body[i].startsWith("@@")) {
+          const ln = body[i];
+          if (ln === "") {
+            hunkBody.push({ kind: "context", text: "" });
+          } else if (ln[0] === " ") {
+            hunkBody.push({ kind: "context", text: ln.slice(1) });
+          } else if (ln[0] === "+") {
+            hunkBody.push({ kind: "add", text: ln.slice(1) });
+          } else if (ln[0] === "-") {
+            hunkBody.push({ kind: "del", text: ln.slice(1) });
+          } else {
+            throw new Error(`apply_patch: Update hunk body lines must start with " ", "+", or "-" (got: ${JSON.stringify(ln)})`);
+          }
+          i += 1;
+        }
+        hunks.push({ anchor, body: hunkBody });
+      }
+      if (hunks.length === 0) {
+        throw new Error(`apply_patch: "Update File: ${path}" requires at least one "@@" hunk`);
+      }
+      ops.push({ kind: "update", path, hunks });
+      continue;
+    }
+    throw new Error(`apply_patch: unknown directive (got: ${JSON.stringify(trimmed)})`);
+  }
+  if (ops.length === 0) {
+    throw new Error("apply_patch: envelope contains no operations");
+  }
+  return ops;
+}
+function isOpHeader(line) {
+  return line.startsWith("*** Add File:") || line.startsWith("*** Replace File:") || line.startsWith("*** Update File:") || line.startsWith("*** Delete File:");
+}
+function applyPatchOps(ops, pathResolver) {
+  const applied = [];
+  for (const op of ops) {
+    const abs = pathResolver(op.path);
+    if (op.kind === "add") {
+      if (!op.overwrite && existsSync2(abs)) {
+        throw new Error(`apply_patch: Add File "${op.path}" failed \u2014 file already exists. Use "*** Replace File: ${op.path}" to overwrite.`);
+      }
+      mkdirSync2(dirname2(abs), { recursive: true });
+      writeFileSync2(abs, op.contents, "utf-8");
+      applied.push({ kind: "add", path: op.path });
+      continue;
+    }
+    if (op.kind === "delete") {
+      if (!existsSync2(abs)) {
+        throw new Error(`apply_patch: Delete File "${op.path}" failed \u2014 file does not exist`);
+      }
+      unlinkSync2(abs);
+      applied.push({ kind: "delete", path: op.path });
+      continue;
+    }
+    if (!existsSync2(abs)) {
+      throw new Error(`apply_patch: Update File "${op.path}" failed \u2014 file does not exist`);
+    }
+    const original = readFileSync3(abs, "utf-8");
+    const updated = applyUpdateHunks(original, op.path, op.hunks);
+    writeFileSync2(abs, updated, "utf-8");
+    applied.push({ kind: "update", path: op.path });
+  }
+  return { applied };
+}
+function applyUpdateHunks(source, logicalPath, hunks) {
+  const hadTrailingNewline = source.endsWith("\n");
+  const sourceBody = hadTrailingNewline ? source.slice(0, -1) : source;
+  let lines = sourceBody.split("\n");
+  for (const hunk of hunks) {
+    const anchorIdx = locateAnchor(lines, hunk.anchor, logicalPath);
+    const { newLines, consumed } = applyOneHunk(lines, anchorIdx, hunk, logicalPath);
+    lines = [
+      ...lines.slice(0, anchorIdx),
+      ...newLines,
+      ...lines.slice(anchorIdx + consumed)
+    ];
+  }
+  return lines.join("\n") + (hadTrailingNewline ? "\n" : "");
+}
+function locateAnchor(lines, anchor, logicalPath) {
+  if (anchor === "") {
+    return 0;
+  }
+  const matches = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes(anchor)) {
+      matches.push(i);
+    }
+  }
+  if (matches.length === 0) {
+    throw new Error(`apply_patch: anchor "${anchor}" not found in ${logicalPath}; refine the @@ anchor to a line that exists in the file`);
+  }
+  if (matches.length > 1) {
+    throw new Error(`apply_patch: context "${anchor}" matches ${matches.length} locations in ${logicalPath}; refine the @@ anchor to be unique`);
+  }
+  return matches[0];
+}
+function applyOneHunk(lines, anchorIdx, hunk, logicalPath) {
+  const newLines = [];
+  let cursor = anchorIdx;
+  for (const entry of hunk.body) {
+    if (entry.kind === "context") {
+      const observed = lines[cursor];
+      if (observed === void 0 || observed !== entry.text) {
+        throw new Error(`apply_patch: context mismatch in ${logicalPath} at line ${cursor + 1}: expected ${JSON.stringify(entry.text)}, got ${JSON.stringify(observed ?? "<eof>")}`);
+      }
+      newLines.push(entry.text);
+      cursor += 1;
+      continue;
+    }
+    if (entry.kind === "del") {
+      const observed = lines[cursor];
+      if (observed === void 0 || observed !== entry.text) {
+        throw new Error(`apply_patch: removed line mismatch in ${logicalPath} at line ${cursor + 1}: expected ${JSON.stringify(entry.text)}, got ${JSON.stringify(observed ?? "<eof>")}`);
+      }
+      cursor += 1;
+      continue;
+    }
+    newLines.push(entry.text);
+  }
+  return { newLines, consumed: cursor - anchorIdx };
+}
+
+// packages/core/dist/agent/tools/scope-path.js
+import { lstatSync as lstatSync2, realpathSync as realpathSync3 } from "node:fs";
+import { basename, dirname as dirname3, isAbsolute as isAbsolute4, resolve as resolve4, sep as sep4 } from "node:path";
+function pathEntryExists(path) {
+  try {
+    lstatSync2(path);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return false;
+    throw error;
+  }
+}
+function canonicalizePath(path) {
+  const missingSegments = [];
+  let existingPath = path;
+  while (!pathEntryExists(existingPath)) {
+    const parent = dirname3(existingPath);
+    if (parent === existingPath) {
+      throw new Error(`Path does not have an existing parent: ${path}`);
+    }
+    missingSegments.unshift(basename(existingPath));
+    existingPath = parent;
+  }
+  return resolve4(realpathSync3(existingPath), ...missingSegments);
+}
+function isScopedPath(scopePath, inputPath) {
+  const root = realpathSync3(scopePath);
+  const logicalCandidate = isAbsolute4(inputPath) ? resolve4(inputPath) : resolve4(root, inputPath);
+  const candidate = canonicalizePath(logicalCandidate);
+  return candidate === root || candidate.startsWith(root + sep4);
+}
+function resolveScopedPath(scopePath, inputPath) {
+  if (isScopeEnforcementEnabled() && (!scopePath || !isScopedPath(scopePath, inputPath))) {
+    throw new Error(`Path escapes the allowed scope: ${inputPath}`);
+  }
+  const root = scopePath ? realpathSync3(scopePath) : process.cwd();
+  const logicalCandidate = isAbsolute4(inputPath) ? resolve4(inputPath) : resolve4(root, inputPath);
+  return canonicalizePath(logicalCandidate);
+}
+
+export {
+  DEFAULT_IMPROVEMENT_PROMOTION_POLICY,
+  evaluateImprovementPromotion,
+  appendImprovementLedgerEntry,
+  verifyImprovementLedger,
+  canonicalEvolutionJson,
+  parseEvolutionConfig,
+  loadEvolutionConfigFile,
+  resolveEvolutionDirectoryPath,
+  ensureEvolutionDirectory,
+  readEvolutionArtifact,
+  publishEvolutionArtifact,
+  evaluateVerificationSpec,
+  parsePatch,
+  applyPatchOps,
+  resolveScopedPath
+};