@askexenow/exe-os 0.9.372 → 0.9.374

package/dist/chunk-4YNA3CM6.js

@@ -0,0 +1,872 @@
+// src/lib/verification-evidence.ts
+import { execFileSync } from "child_process";
+
+// src/shared/attribution.ts
+var ok = { ok: true, code: "ok", message: "attributed" };
+function deny(code, message) {
+  return { ok: false, code, message };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function str(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+var PLACEHOLDER_IDENTITIES = /* @__PURE__ */ new Set([
+  "me",
+  "self",
+  "myself",
+  "i",
+  "agent",
+  "the agent",
+  "an agent",
+  "assistant",
+  "ai",
+  "an ai",
+  "the ai",
+  "bot",
+  "chatbot",
+  "llm",
+  "model",
+  "admin",
+  "administrator",
+  "support",
+  "askexe",
+  "exe-os",
+  "system",
+  "automated",
+  "auto",
+  "user",
+  "someone",
+  "somebody",
+  "team",
+  "staff",
+  "n/a",
+  "na",
+  "none",
+  "null",
+  "unknown",
+  "tbd",
+  "todo",
+  "test",
+  "testing",
+  "claude",
+  "gpt",
+  "openai",
+  "anthropic"
+]);
+function isPlaceholderIdentity(name) {
+  return PLACEHOLDER_IDENTITIES.has(name.trim().toLowerCase());
+}
+var UNRESOLVED_IDENTITIES = /* @__PURE__ */ new Set(["default"]);
+function isUnresolvedIdentity(name) {
+  return UNRESOLVED_IDENTITIES.has(name.trim().toLowerCase());
+}
+var MODEL_FAMILIES = [
+  "claude",
+  "gpt",
+  "o1",
+  "o3",
+  "o4",
+  "codex",
+  "gemini",
+  "glm",
+  "minimax",
+  "qwen",
+  "llama",
+  "mistral",
+  "mixtral",
+  "deepseek",
+  "grok",
+  "kimi",
+  "command",
+  "phi",
+  "nova",
+  "sonar"
+];
+var MODEL_SHAPE = /^[a-z][a-z0-9]*(?:[-._][a-z0-9]+)*$/i;
+var HAS_VERSION = /\d/;
+function assessModel(raw) {
+  const model = str(raw).toLowerCase();
+  if (!model) {
+    return deny("attribution_model_missing", "attribution requires the model that produced this record");
+  }
+  if (isPlaceholderIdentity(model)) {
+    return deny(
+      "attribution_model_placeholder",
+      `"${model}" names a vendor or a category, not a model. Give the model id, e.g. claude-opus-5, gpt-5.5, glm-5.2`
+    );
+  }
+  if (!MODEL_SHAPE.test(model)) {
+    return deny("attribution_model_unrecognised", `"${model}" is not a model id`);
+  }
+  const family = MODEL_FAMILIES.find((f) => model === f || model.startsWith(`${f}-`) || model.startsWith(`${f}.`));
+  if (!family) {
+    return deny(
+      "attribution_model_unrecognised",
+      `"${model}" does not name a known model family (${MODEL_FAMILIES.slice(0, 6).join(", ")}, \u2026). If this is a new family, add it to MODEL_FAMILIES rather than weakening the check`
+    );
+  }
+  if (!HAS_VERSION.test(model)) {
+    return deny(
+      "attribution_model_unrecognised",
+      `"${model}" names a family but not a version \u2014 "claude" is not a model, "claude-opus-5" is`
+    );
+  }
+  return ok;
+}
+var FUTURE_SKEW_MS = 5 * 60 * 1e3;
+function assessObservedAt(raw, now) {
+  const text = str(raw);
+  if (!text) {
+    return deny(
+      "attribution_observed_at_missing",
+      "attribution requires observed_at: when the behaviour or evidence was ACTUALLY SEEN, which is not necessarily now"
+    );
+  }
+  const ms = Date.parse(text);
+  if (!Number.isFinite(ms)) {
+    return deny("attribution_observed_at_invalid", `observed_at "${text}" is not a parseable timestamp`);
+  }
+  if (ms > now + FUTURE_SKEW_MS) {
+    return deny("attribution_observed_at_in_future", "observed_at is in the future \u2014 nothing was observed then");
+  }
+  return ok;
+}
+var HEX_SHA = /^[0-9a-f]{7,64}$/i;
+function assessAttribution(raw, purpose, context = {}) {
+  if (raw === void 0 || raw === null || raw === "") {
+    return deny(
+      "attribution_missing",
+      `this ${purpose} requires attribution: which agent produced it, with which model, and when the evidence was observed`
+    );
+  }
+  let attribution = raw;
+  if (typeof raw === "string") {
+    try {
+      attribution = JSON.parse(raw);
+    } catch {
+      return deny("attribution_malformed", "attribution must be valid JSON");
+    }
+  }
+  if (!isRecord(attribution)) {
+    return deny("attribution_malformed", "attribution must be an object");
+  }
+  const agent = str(attribution.agent);
+  if (!agent) {
+    return deny("attribution_agent_missing", "attribution requires the agent identity that produced this record");
+  }
+  if (isPlaceholderIdentity(agent)) {
+    return deny(
+      "attribution_agent_placeholder",
+      `"${agent}" is a role, not an identity. Records attributed to "admin" are exactly why past verdicts cannot be traced to anyone \u2014 name the actual agent`
+    );
+  }
+  if (purpose === "verdict" && isUnresolvedIdentity(agent)) {
+    return deny(
+      "attribution_agent_placeholder",
+      `"${agent}" is the identity resolver's fallback, not an agent \u2014 it is what a call from the launchd daemon carries when there is no active-agent marker, no tmux session and no AGENT_ID. A verdict signed with it is signed by nobody. Pass the real employee name of whoever made this call`
+    );
+  }
+  const modelResult = assessModel(attribution.model);
+  if (!modelResult.ok) return modelResult;
+  const now = context.now ?? Date.now();
+  const observedResult = assessObservedAt(attribution.observed_at, now);
+  if (!observedResult.ok) return observedResult;
+  if (purpose === "verdict") {
+    const ref = str(attribution.evidence_ref);
+    if (!ref) {
+      return deny(
+        "attribution_evidence_ref_missing",
+        "a verdict requires evidence_ref: the commit you actually read the evidence at. main moves several times a day, so a verdict against an unnamed ref cannot be checked or reproduced"
+      );
+    }
+    if (!HEX_SHA.test(ref)) {
+      return deny("attribution_evidence_ref_invalid", `evidence_ref "${ref}" is not a commit sha`);
+    }
+  }
+  const second = attribution.second_opinion;
+  if (second !== void 0 && second !== null && second !== "") {
+    if (!isRecord(second)) {
+      return deny("second_opinion_malformed", "second_opinion must be an object with model and verdict");
+    }
+    const secondModel = assessModel(second.model);
+    if (!secondModel.ok) {
+      return deny("second_opinion_malformed", `second_opinion model: ${secondModel.message}`);
+    }
+    const verdict = str(second.verdict);
+    if (verdict !== "confirmed" && verdict !== "refuted") {
+      return deny("second_opinion_malformed", "second_opinion.verdict must be 'confirmed' or 'refuted'");
+    }
+    if (str(second.model).toLowerCase() === str(attribution.model).toLowerCase()) {
+      return deny(
+        "second_opinion_same_model",
+        "second_opinion.model must differ from the model that produced the record \u2014 a model confirming itself is not an adversarial review"
+      );
+    }
+    if (verdict === "refuted") {
+      return deny(
+        "second_opinion_refuted",
+        "the second opinion REFUTED this verdict \u2014 resolve the disagreement before recording it, or record the refutation as a note instead"
+      );
+    }
+  }
+  return ok;
+}
+
+// src/shared/verification-artifact.ts
+var VERIFIER_BACKED_DISPOSITIONS = /* @__PURE__ */ new Set(["not_a_defect", "superseded"]);
+var MIN_DISPOSITION_REASON_CHARS = 40;
+var MIN_WONTFIX_REASON_CHARS = 120;
+var MIN_COVERAGE_EVIDENCE_CHARS = 20;
+var ok2 = { ok: true, code: "ok", message: "verified" };
+function deny2(code, message) {
+  return { ok: false, code, message };
+}
+var HEX_SHA2 = /^[0-9a-f]{7,64}$/i;
+var MIN_OBSERVATION_CHARS = 40;
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function str2(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function isSubstantiveCommit(substance) {
+  if (!isRecord2(substance)) return false;
+  const added = num(substance.added);
+  const deleted = num(substance.deleted);
+  const substantive = num(substance.substantive_added);
+  const sourceFiles = num(substance.source_files);
+  if (added === null || deleted === null || substantive === null || sourceFiles === null) return false;
+  if (added < 0 || deleted < 0 || substantive < 0 || sourceFiles < 0) return false;
+  if (substantive > added) return false;
+  if (sourceFiles < 1) return false;
+  if (substantive < 1 && deleted < 1) return false;
+  return true;
+}
+function isSubstantiveTestFix(substance) {
+  if (!isRecord2(substance)) return false;
+  const added = num(substance.added);
+  const deleted = num(substance.deleted);
+  const testFiles = num(substance.test_files);
+  const testSubstantive = num(substance.test_substantive_added);
+  if (added === null || deleted === null || testFiles === null || testSubstantive === null) return false;
+  if (added < 0 || deleted < 0 || testFiles < 0 || testSubstantive < 0) return false;
+  if (testSubstantive > added) return false;
+  if (testFiles < 1) return false;
+  if (testSubstantive < 1 && deleted < 1) return false;
+  return true;
+}
+var VERDICT_ONLY_OBSERVATION = /^(?:it(?:'s| is)? |the bug (?:is|was) |this (?:is|was) )?(?:fixed|resolved|working|done|good|ok|verified|closed)\b/i;
+var HEDGED_OBSERVATION = /\b(?:looks?|look|seems?|appears?)\s+(?:to\s+be\s+)?(?:fine|good|ok|okay|right|healthy|correct|normal)\b|\ball\s+(?:good|fine|clear)\b|\bno\s+issues\b|\bseems?\s+fine\b/i;
+function assessObservation(raw) {
+  const observation = str2(raw).replace(/\s+/g, " ");
+  if (observation.length < MIN_OBSERVATION_CHARS) {
+    return deny2(
+      "manual_observation_too_thin",
+      "verification requires an observation describing the defect's absence"
+    );
+  }
+  if (VERDICT_ONLY_OBSERVATION.test(observation) || HEDGED_OBSERVATION.test(observation)) {
+    return deny2(
+      "observation_not_absence",
+      "the observation must report what was OBSERVED that shows the defect is absent \u2014 a verdict ('it is fixed') or a hedge ('looks fine') is not an observation"
+    );
+  }
+  return ok2;
+}
+function assessVerifier(raw, context) {
+  const verifier = str2(raw);
+  if (!verifier) {
+    return deny2("manual_verifier_missing", "this close requires a named verifier");
+  }
+  if (isPlaceholderIdentity(verifier)) {
+    return deny2(
+      "manual_verifier_placeholder",
+      `"${verifier}" is a role, not an identity. Records attested by "admin" are exactly why past verdicts cannot be traced to anyone \u2014 name the actual person or employee`
+    );
+  }
+  const authors = (context.authorIdentities ?? []).map((a) => str2(a).toLowerCase()).filter(Boolean);
+  if (authors.includes(verifier.toLowerCase())) {
+    return deny2(
+      "manual_verifier_is_author",
+      "verification must be attested by someone other than the record's author or assignee"
+    );
+  }
+  return ok2;
+}
+function parseTimestamp(raw) {
+  const text = str2(raw);
+  if (!text) return null;
+  const ms = Date.parse(text);
+  return Number.isFinite(ms) ? ms : null;
+}
+function assessProbes(raw, claimType) {
+  if (!Array.isArray(raw) || raw.length === 0) {
+    return deny2(
+      "ops_probe_missing",
+      "ops_transcript requires at least one probe: the verbatim command, its verbatim output, the host it ran against, and when it ran"
+    );
+  }
+  const timestamps = [];
+  for (let i = 0; i < raw.length; i += 1) {
+    const probe = raw[i];
+    const where = `probe ${i + 1}`;
+    if (!isRecord2(probe)) {
+      return deny2("ops_probe_malformed", `${where} is not an object`);
+    }
+    if (!str2(probe.command)) {
+      return deny2("ops_probe_malformed", `${where} has no command \u2014 record the command verbatim, as typed`);
+    }
+    if (!str2(probe.output)) {
+      return deny2(
+        "ops_probe_malformed",
+        `${where} has no command output \u2014 paste the output verbatim; a probe with nothing to show is a summary, not evidence`
+      );
+    }
+    if (!str2(probe.host)) {
+      return deny2("ops_probe_malformed", `${where} does not name the host or system it ran against`);
+    }
+    const ts = parseTimestamp(probe.ran_at);
+    if (ts === null) {
+      return deny2("ops_probe_malformed", `${where} has no valid ran_at timestamp`);
+    }
+    timestamps.push(ts);
+  }
+  if (claimType === "ongoing_state") {
+    const distinct = new Set(timestamps);
+    if (raw.length < 2 || distinct.size < 2) {
+      return deny2(
+        "ops_claim_needs_multiple_probes",
+        "a claim about ONGOING state needs at least two probes taken at two distinct times \u2014 one sample cannot evidence a continuing condition"
+      );
+    }
+  }
+  return ok2;
+}
+function assessVerificationArtifact(raw, context = {}) {
+  if (raw === void 0 || raw === null || raw === "") {
+    return deny2("artifact_missing", "closing requires a verification artifact showing the defect is absent");
+  }
+  let artifact = raw;
+  if (typeof raw === "string") {
+    try {
+      artifact = JSON.parse(raw);
+    } catch {
+      return deny2("artifact_malformed", "verification artifact must be valid JSON");
+    }
+  }
+  if (!isRecord2(artifact)) {
+    return deny2("artifact_malformed", "verification artifact must be an object");
+  }
+  const kind = str2(artifact.kind);
+  if (kind !== "regression_test" && kind !== "manual" && kind !== "ops_transcript") {
+    return deny2("artifact_unknown_kind", "verification artifact kind must be regression_test, manual or ops_transcript");
+  }
+  if (kind === "ops_transcript") {
+    return assessOpsTranscript(artifact, context);
+  }
+  const declaredLayer = str2(artifact.defect_layer) || "production";
+  if (declaredLayer !== "production" && declaredLayer !== "test_harness") {
+    return deny2("artifact_malformed", "defect_layer must be production or test_harness");
+  }
+  if (declaredLayer === "test_harness") {
+    if (!isSubstantiveTestFix(artifact.substance)) {
+      return deny2(
+        "test_fix_not_substantive",
+        "defect_layer=test_harness was declared, but the fix commit changes no executable test/harness code (comment-only, whitespace-only or docs-only diffs are not fixes at any layer)"
+      );
+    }
+    if (!str2(artifact.test_id)) {
+      return deny2(
+        "test_fix_missing_assertion",
+        "defect_layer=test_harness requires test_id \u2014 name the test whose behaviour is the evidence"
+      );
+    }
+    if (str2(artifact.reverted_result) !== "fail") {
+      return deny2(
+        "test_fix_missing_assertion",
+        "defect_layer=test_harness requires reverted_result='fail' \u2014 the observed result of re-running the named test with the fix reverted. A test-only diff that does not go red when removed evidences nothing"
+      );
+    }
+  } else if (!isSubstantiveCommit(artifact.substance)) {
+    return deny2(
+      "commit_not_substantive",
+      "the fix commit changes no executable production source (comment-only, whitespace-only, or test-only diffs are not fixes). If the DEFECT ITSELF is in the test/harness layer, declare defect_layer='test_harness' and supply test_id and reverted_result"
+    );
+  }
+  if (kind === "regression_test") {
+    const testId = str2(artifact.test_id);
+    const fixCommit = str2(artifact.fix_commit);
+    const parentCommit = str2(artifact.parent_commit);
+    if (!testId || !HEX_SHA2.test(fixCommit) || !HEX_SHA2.test(parentCommit)) {
+      return deny2("artifact_malformed", "regression_test requires test_id, fix_commit and parent_commit");
+    }
+    if (fixCommit.toLowerCase() === parentCommit.toLowerCase()) {
+      return deny2("parent_equals_fix", "parent_commit must be the commit BEFORE the fix");
+    }
+    if (str2(artifact.parent_result) !== "fail") {
+      return deny2(
+        "test_did_not_fail_at_parent",
+        "the named test must FAIL at the parent commit \u2014 a test that already passed does not detect the defect"
+      );
+    }
+    if (str2(artifact.fix_result) !== "pass") {
+      return deny2("test_did_not_pass_at_fix", "the named test must PASS at the fix commit");
+    }
+    return ok2;
+  }
+  const verifierResult = assessVerifier(artifact.verifier, context);
+  if (!verifierResult.ok) return verifierResult;
+  if (!str2(artifact.method)) {
+    return deny2("artifact_malformed", "manual verification requires a method");
+  }
+  const observationResult = assessObservation(artifact.observation);
+  if (!observationResult.ok) return observationResult;
+  if (!HEX_SHA2.test(str2(artifact.fix_commit))) {
+    return deny2("artifact_malformed", "manual verification requires a fix_commit");
+  }
+  return ok2;
+}
+function assessOpsTranscript(artifact, context) {
+  const verifierResult = assessVerifier(artifact.verifier, context);
+  if (!verifierResult.ok) return verifierResult;
+  const claimType = str2(artifact.claim_type);
+  if (claimType !== "point_in_time" && claimType !== "ongoing_state") {
+    return deny2(
+      "artifact_malformed",
+      "ops_transcript requires claim_type: 'point_in_time' for a fact true when observed, 'ongoing_state' for a claim that a condition holds"
+    );
+  }
+  const probeResult = assessProbes(artifact.probes, claimType);
+  if (!probeResult.ok) return probeResult;
+  const observationResult = assessObservation(artifact.observation);
+  if (!observationResult.ok) return observationResult;
+  const fixCommit = str2(artifact.fix_commit);
+  if (fixCommit && !HEX_SHA2.test(fixCommit)) {
+    return deny2("artifact_malformed", "ops_transcript fix_commit, when supplied, must be a commit sha");
+  }
+  return ok2;
+}
+function assessDisposition(disposition, input) {
+  const reason = str2(input.disposition_reason).replace(/\s+/g, " ");
+  if (!reason) {
+    return deny2(
+      "disposition_reason_missing",
+      `closing as ${disposition} requires disposition_reason \u2014 state why this record has nothing to fix`
+    );
+  }
+  if (reason.length < MIN_DISPOSITION_REASON_CHARS) {
+    return deny2(
+      "disposition_reason_too_thin",
+      `closing as ${disposition} requires a reason that explains the call, not a label`
+    );
+  }
+  if (VERDICT_ONLY_OBSERVATION.test(reason) || HEDGED_OBSERVATION.test(reason)) {
+    return deny2(
+      "observation_not_absence",
+      "the disposition reason must explain what makes this a non-defect \u2014 a verdict or a hedge is not a reason"
+    );
+  }
+  if (disposition === "wontfix" && reason.length < MIN_WONTFIX_REASON_CHARS) {
+    return deny2(
+      "wontfix_reason_omits_live_behaviour",
+      "closing as wontfix requires the reason to describe the LIVE BEHAVIOUR the user will still hit, not only the decision to decline. One honest sentence naming what stays broken is enough \u2014 but it has to be there, because this record is about to stop being read"
+    );
+  }
+  if (disposition === "superseded") {
+    if (!str2(input.superseded_by)) {
+      return deny2(
+        "superseded_by_missing",
+        "closing as superseded requires superseded_by \u2014 name the record that replaces this one, so the claim is checkable"
+      );
+    }
+    const coverage = assessSupersedingCoverage(input);
+    if (!coverage.ok) return coverage;
+  }
+  if (VERIFIER_BACKED_DISPOSITIONS.has(disposition)) {
+    const verifierResult = assessVerifier(input.disposition_verifier, input.context ?? {});
+    if (!verifierResult.ok) return verifierResult;
+  }
+  return ok2;
+}
+function assessSupersedingCoverage(input) {
+  const declared = parseSymptomIds(input.symptoms);
+  if (declared.length === 0) {
+    return deny2(
+      "superseded_symptoms_not_enumerated",
+      "closing as superseded requires the record's symptoms to be enumerated, so coverage by the superseding record can be checked one by one. An unenumerated record cannot be shown to be fully covered"
+    );
+  }
+  const entries = parseCoverageEntries(input.superseded_coverage);
+  const thin = entries.filter(
+    (e) => declared.includes(e.id) && e.evidence.length < MIN_COVERAGE_EVIDENCE_CHARS
+  );
+  if (thin.length > 0) {
+    return deny2(
+      "superseded_coverage_evidence_missing",
+      `${thin.length} symptom(s) are listed as covered with no evidence naming WHERE ${str2(input.superseded_by)} covers them: ${thin.map((e) => e.id).join(", ")}`
+    );
+  }
+  const covered = new Set(entries.map((e) => e.id));
+  const survivors = declared.filter((id) => !covered.has(id));
+  if (survivors.length > 0) {
+    return deny2(
+      "superseded_coverage_incomplete",
+      `${survivors.length} of ${declared.length} symptoms are NOT covered by ${str2(input.superseded_by)}: ${survivors.join(", ")}. Partial coverage supersedes nothing \u2014 keep this record open with those symptoms as its remaining scope, or supply coverage evidence for each`
+    );
+  }
+  return ok2;
+}
+function parseCoverageEntries(raw) {
+  let value = raw;
+  if (typeof raw === "string") {
+    if (!raw.trim()) return [];
+    try {
+      value = JSON.parse(raw);
+    } catch {
+      return [];
+    }
+  }
+  if (!Array.isArray(value)) return [];
+  const entries = [];
+  for (const entry of value) {
+    if (!isRecord2(entry)) continue;
+    const id = str2(entry.id);
+    if (!id) continue;
+    entries.push({ id, evidence: str2(entry.evidence) });
+  }
+  return entries;
+}
+function parseSymptomIds(raw) {
+  let value = raw;
+  if (typeof raw === "string") {
+    if (!raw.trim()) return [];
+    try {
+      value = JSON.parse(raw);
+    } catch {
+      return [];
+    }
+  }
+  if (!Array.isArray(value)) return [];
+  const ids = [];
+  for (const entry of value) {
+    if (typeof entry === "string" && entry.trim()) ids.push(entry.trim());
+    else if (isRecord2(entry) && str2(entry.id)) ids.push(str2(entry.id));
+  }
+  return ids;
+}
+
+// src/lib/verification-evidence.ts
+var TEST_PATH = /(?:^|\/)(?:tests?|__tests__|__mocks__|e2e|fixtures)\//i;
+var TEST_FILE = /\.(?:test|spec)\.[cm]?[jt]sx?$/i;
+var NON_SOURCE_FILE = /\.(?:md|mdx|txt|rst|adoc|snap|lock)$/i;
+var COMMENT_LINE = /^(?:\/\/|\/\*|\*\/|\*(?!\/)|#|--|<!--|-->)/;
+function isTestPath(path) {
+  return TEST_PATH.test(path) || TEST_FILE.test(path);
+}
+function isNonSourcePath(path) {
+  return NON_SOURCE_FILE.test(path);
+}
+function isCommentOrBlank(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return true;
+  return COMMENT_LINE.test(trimmed);
+}
+function measureUnifiedDiff(diff) {
+  let added = 0;
+  let deleted = 0;
+  let substantiveAdded = 0;
+  let testSubstantiveAdded = 0;
+  const sourceFiles = /* @__PURE__ */ new Set();
+  const testFiles = /* @__PURE__ */ new Set();
+  let currentPath = "";
+  let currentIsSource = false;
+  let currentIsTest = false;
+  for (const line of diff.split(/\r?\n/)) {
+    if (line.startsWith("+++ ")) {
+      const path = line.slice(4).replace(/^b\//, "").trim();
+      currentPath = path === "/dev/null" ? "" : path;
+      const isDocs = Boolean(currentPath) && isNonSourcePath(currentPath);
+      currentIsSource = Boolean(currentPath) && !isTestPath(currentPath) && !isDocs;
+      currentIsTest = Boolean(currentPath) && isTestPath(currentPath) && !isDocs;
+      continue;
+    }
+    if (line.startsWith("--- ") || line.startsWith("diff ") || line.startsWith("index ") || line.startsWith("@@")) {
+      continue;
+    }
+    if (line.startsWith("+")) {
+      added += 1;
+      const content = line.slice(1);
+      if (currentIsSource) {
+        if (!isCommentOrBlank(content)) {
+          substantiveAdded += 1;
+          sourceFiles.add(currentPath);
+        }
+      } else if (currentIsTest) {
+        if (!isCommentOrBlank(content)) {
+          testSubstantiveAdded += 1;
+          testFiles.add(currentPath);
+        }
+      }
+    } else if (line.startsWith("-")) {
+      deleted += 1;
+      const content = line.slice(1);
+      if (currentIsSource) {
+        if (!isCommentOrBlank(content)) sourceFiles.add(currentPath);
+      } else if (currentIsTest) {
+        if (!isCommentOrBlank(content)) testFiles.add(currentPath);
+      }
+    }
+  }
+  return {
+    added,
+    deleted,
+    substantive_added: substantiveAdded,
+    source_files: sourceFiles.size,
+    test_files: testFiles.size,
+    test_substantive_added: testSubstantiveAdded
+  };
+}
+function measureCommitSubstance(sha, cwd) {
+  if (!/^[0-9a-f]{7,64}$/i.test(sha)) return null;
+  try {
+    const diff = execFileSync(
+      "git",
+      ["show", "--format=", "--unified=0", "--no-color", sha],
+      { cwd, encoding: "utf8", timeout: 15e3, maxBuffer: 32 * 1024 * 1024 }
+    );
+    return measureUnifiedDiff(diff);
+  } catch {
+    return null;
+  }
+}
+function resolveParentCommit(sha, cwd) {
+  if (!/^[0-9a-f]{7,64}$/i.test(sha)) return null;
+  try {
+    const out = execFileSync("git", ["rev-parse", `${sha}^`], {
+      cwd,
+      encoding: "utf8",
+      timeout: 1e4
+    });
+    const parent = out.trim();
+    return /^[0-9a-f]{7,64}$/i.test(parent) ? parent : null;
+  } catch {
+    return null;
+  }
+}
+function fail(code, message) {
+  return { ok: false, code, message };
+}
+var PLACEHOLDER_VERIFIERS = /* @__PURE__ */ new Set([
+  "me",
+  "self",
+  "myself",
+  "i",
+  "agent",
+  "the agent",
+  "assistant",
+  "ai",
+  "bot",
+  "n/a",
+  "na",
+  "none",
+  "unknown",
+  "tbd",
+  "todo",
+  "system",
+  "automated",
+  "auto",
+  "claude",
+  "user",
+  "test",
+  "someone",
+  "team"
+]);
+var LOW_CONTENT_OBSERVATION = /^(?:it(?:'s| is)? |the bug (?:is|was) |this (?:is|was) )?(?:fixed|resolved|working|done|good|ok|verified|closed)\b/i;
+function resolveCommit(sha, cwd) {
+  if (!/^[0-9a-f]{7,64}$/i.test(sha)) return null;
+  try {
+    const out = execFileSync("git", ["rev-parse", "--verify", `${sha}^{commit}`], {
+      cwd,
+      encoding: "utf8",
+      timeout: 1e4
+    }).trim();
+    return /^[0-9a-f]{40}$/i.test(out) ? out : null;
+  } catch {
+    return null;
+  }
+}
+function checkVerifierName(raw) {
+  const verifier = (raw ?? "").trim();
+  if (!verifier) {
+    return { ok: false, result: fail("manual_verifier_missing", "verification requires a named verifier") };
+  }
+  if (PLACEHOLDER_VERIFIERS.has(verifier.toLowerCase())) {
+    return {
+      ok: false,
+      result: fail(
+        "manual_verifier_placeholder",
+        `"${verifier}" is not an identity. Name the person or employee who confirmed the defect is gone.`
+      )
+    };
+  }
+  return { ok: true, verifier };
+}
+function buildOpsTranscript(request, context) {
+  const verifierCheck = checkVerifierName(request.verifier);
+  if (!verifierCheck.ok) return verifierCheck.result;
+  const claimType = (request.claim_type ?? "").trim();
+  if (claimType !== "point_in_time" && claimType !== "ongoing_state") {
+    return fail(
+      "artifact_malformed",
+      "ops_transcript requires claim_type: 'point_in_time' for a fact true when observed, 'ongoing_state' for a claim that a condition holds (needs 2+ probes at distinct times)"
+    );
+  }
+  const probes = Array.isArray(request.probes) ? request.probes : [];
+  if (probes.length === 0) {
+    return fail(
+      "ops_probe_missing",
+      "ops_transcript requires at least one probe: {command, output, host, ran_at}, all verbatim"
+    );
+  }
+  const observation = (request.observation ?? "").replace(/\s+/g, " ").trim();
+  if (LOW_CONTENT_OBSERVATION.test(observation)) {
+    return fail(
+      "manual_observation_too_thin",
+      "the observation must describe what the output SHOWS that makes the defect absent \u2014 not that the bug is 'fixed'"
+    );
+  }
+  const artifact = {
+    kind: "ops_transcript",
+    verifier: verifierCheck.verifier,
+    claim_type: claimType,
+    probes: probes.map((p) => ({
+      command: (p?.command ?? "").trim(),
+      output: (p?.output ?? "").trim(),
+      host: (p?.host ?? "").trim(),
+      ran_at: (p?.ran_at ?? "").trim()
+    })),
+    observation,
+    ...request.fix_commit?.trim() ? { fix_commit: request.fix_commit.trim() } : {}
+  };
+  const assessed = assessVerificationArtifact(artifact, context);
+  if (!assessed.ok) return fail(assessed.code, assessed.message);
+  return {
+    ok: true,
+    artifact,
+    substance: { added: 0, deleted: 0, substantive_added: 0, source_files: 0 }
+  };
+}
+function buildVerificationArtifact(request, context = {}) {
+  if (request.kind === "ops_transcript") {
+    return buildOpsTranscript(request, context);
+  }
+  const declaredLayer = (request.defect_layer ?? "").trim() || "production";
+  if (declaredLayer !== "production" && declaredLayer !== "test_harness") {
+    return fail("artifact_malformed", "defect_layer must be production or test_harness");
+  }
+  const defectLayer = declaredLayer;
+  let revertedResult;
+  if (defectLayer === "test_harness") {
+    const observed = (request.reverted_result ?? "").trim();
+    if (observed !== "fail" && observed !== "pass" && observed !== "error") {
+      return fail(
+        "test_fix_missing_assertion",
+        "defect_layer=test_harness requires reverted_result: the result you OBSERVED re-running the named test with the fix reverted. It must be 'fail' \u2014 a test-only diff that does not go red when removed evidences nothing."
+      );
+    }
+    revertedResult = observed;
+  }
+  const repo = request.repo_path;
+  if (!repo || !repo.trim()) {
+    return fail("repo_path_missing", "repo_path is required: the fix commit must be measured in the repository that contains it");
+  }
+  const fixCommit = resolveCommit(request.fix_commit ?? "", repo);
+  if (!fixCommit) {
+    return fail(
+      "fix_commit_unresolvable",
+      `fix_commit ${request.fix_commit} is not a commit in ${repo} \u2014 verification evidence cannot be measured, and will not be guessed`
+    );
+  }
+  const substance = measureCommitSubstance(fixCommit, repo);
+  if (!substance) {
+    return fail("commit_not_measurable", `git could not diff ${fixCommit} in ${repo}`);
+  }
+  let artifact;
+  if (request.kind === "regression_test") {
+    const parentCommit = resolveParentCommit(fixCommit, repo);
+    if (!parentCommit) {
+      return fail(
+        "parent_commit_unresolvable",
+        `could not resolve the first parent of ${fixCommit} \u2014 a regression_test artifact needs the tree WITHOUT the fix`
+      );
+    }
+    const testId = (request.test_id ?? "").trim();
+    if (!testId) return fail("artifact_malformed", "regression_test requires test_id (e.g. 'tests/foo.test.ts::rejects empty scope')");
+    const parentResult = (request.parent_result ?? "").trim();
+    const fixResult = (request.fix_result ?? "").trim();
+    if (parentResult !== "fail" && parentResult !== "pass" && parentResult !== "error") {
+      return fail("artifact_malformed", "parent_result must be the result you OBSERVED running the test at the parent commit: fail, pass or error");
+    }
+    if (fixResult !== "fail" && fixResult !== "pass" && fixResult !== "error") {
+      return fail("artifact_malformed", "fix_result must be the result you OBSERVED running the test at the fix commit: fail, pass or error");
+    }
+    const regression = {
+      kind: "regression_test",
+      test_id: testId,
+      fix_commit: fixCommit,
+      parent_commit: parentCommit,
+      parent_result: parentResult,
+      fix_result: fixResult,
+      substance,
+      ...defectLayer === "test_harness" ? { defect_layer: defectLayer, reverted_result: revertedResult } : {}
+    };
+    artifact = regression;
+  } else if (request.kind === "manual") {
+    const verifierCheck = checkVerifierName(request.verifier);
+    if (!verifierCheck.ok) return verifierCheck.result;
+    const verifier = verifierCheck.verifier;
+    const method = (request.method ?? "").trim();
+    if (!method) return fail("artifact_malformed", "manual verification requires a method someone else could repeat");
+    const observation = (request.observation ?? "").replace(/\s+/g, " ").trim();
+    if (LOW_CONTENT_OBSERVATION.test(observation)) {
+      return fail(
+        "manual_observation_too_thin",
+        "the observation must describe what you saw that shows the DEFECT IS ABSENT \u2014 not that the bug is 'fixed'"
+      );
+    }
+    if (observation.toLowerCase() === method.toLowerCase()) {
+      return fail("manual_observation_too_thin", "the observation must say what you saw, not repeat the method");
+    }
+    const manual = {
+      kind: "manual",
+      verifier,
+      method,
+      observation,
+      fix_commit: fixCommit,
+      substance,
+      ...defectLayer === "test_harness" ? { defect_layer: defectLayer, test_id: (request.test_id ?? "").trim(), reverted_result: revertedResult } : {}
+    };
+    artifact = manual;
+  } else {
+    return fail("artifact_unknown_kind", "verification kind must be regression_test, manual or ops_transcript");
+  }
+  const assessed = assessVerificationArtifact(artifact, context);
+  if (!assessed.ok) return fail(assessed.code, assessed.message);
+  return { ok: true, artifact, substance };
+}
+
+export {
+  isPlaceholderIdentity,
+  isUnresolvedIdentity,
+  assessAttribution,
+  isSubstantiveCommit,
+  assessVerificationArtifact,
+  assessDisposition,
+  measureCommitSubstance,
+  buildVerificationArtifact
+};