@gafj/gafj 0.1.1

package/core/text.js

@@ -0,0 +1,98 @@
+"use strict";
+
+/**
+ * Text helpers shared by provenance and the validators. Pure.
+ */
+
+const { words, metricKey } = require("./scoring");
+
+const NUMBER_WORDS = { one: 1, two: 2, three: 3, four: 4, five: 5, six: 6, seven: 7, eight: 8, nine: 9, ten: 10, eleven: 11, twelve: 12, dozen: 12 };
+const COUNT_NOUNS = "person|people|members?|staff|clients?|employees?|products?|repositories|repository|aircraft|countries|country|teams?|managers?|stores?|locations?|sites?|vendors?|carriers?|reports?|cases|returns|orders?|records?|tests?|lines";
+
+function norm(s) {
+  return String(s || "").toLowerCase().replace(/[^a-z0-9%$+.]+/g, " ").replace(/\s+/g, " ").trim();
+}
+
+function sentences(text) {
+  return String(text || "").split(/\r?\n|(?<=[.;:!?])\s+(?=[A-Z"(\[])/).map((s) => s.trim()).filter((s) => s.length > 0);
+}
+
+/** Phone numbers, emails, urls, zip codes, and calendar years are identifiers, not metrics. */
+function stripIdentifiers(text) {
+  return String(text || "")
+    .replace(/\b\d{3}[-. ]\d{3}[-. ]\d{4}\b/g, " ")
+    .replace(/[\w.+-]+@[\w-]+\.[\w.]+/g, " ")
+    .replace(/\b(?:https?:\/\/|www\.)\S+|\b[\w-]+\.(?:com|net|org|io|dev)\b(?:\/\S*)?/gi, " ")
+    .replace(/\b(?:FY|CY|Q[1-4]\s?)?(?:19|20)\d{2}\b/gi, " ")
+    .replace(/(?<![\d,$.])\b\d{5}(?:-\d{4})?\b(?!,\d|[\d%]|\s*(?:%|percent|K\b|M\b))/g, " "); // bare five digit numbers are zip codes
+}
+
+/**
+ * Every figure in a prose field: money, percents, counts with a noun, N+ forms,
+ * durations, and number words with a noun. Returns [{ text, key, kind }].
+ */
+function extractFigures(text) {
+  const src = stripIdentifiers(text);
+  const out = [];
+  const seen = new Set();
+  const push = (t, kind) => {
+    const clean = t.replace(/\s+/g, " ").trim();
+    const k = clean + "|" + kind;
+    if (seen.has(k)) return;
+    seen.add(k);
+    out.push({ text: clean, key: figureKey(clean), kind });
+  };
+  const re = new RegExp(
+    "\\$?\\s?\\d[\\d,]*(?:\\.\\d+)?\\s?[MK]?%?\\s*(?:to|-)\\s*\\$?\\d[\\d,]*(?:\\.\\d+)?\\s?[MK]?%?(?=\\W|$)" +
+    "|\\$\\s?\\d[\\d,]*(?:\\.\\d+)?\\s?[MK]?\\+?(?:\\s*(?:/|per)\\s*(?:month|year|yr|mo))?" +
+    "|\\d[\\d,]*(?:\\.\\d+)?\\s?(?:%|percent)\\+?" +
+    "|\\d[\\d,]*(?:\\.\\d+)?\\s+plus\\b(?!\\s*(?:years?|months?|weeks?|days?|yrs?)\\b)" +
+    "|\\b\\d+\\+(?!\\s*(?:years?|months?|weeks?|days?|yrs?)\\b)\\s*(?:" + COUNT_NOUNS + ")?" +
+    "|\\b\\d[\\d,]{2,}(?:\\.\\d+)?\\+?\\b" +
+    "|\\b(?:team of|staff of|group of)\\s+\\d{1,3}\\b" +
+    "|\\b\\d{1,3}\\s*(?:" + COUNT_NOUNS + ")\\b" +
+    "|\\b(?:" + Object.keys(NUMBER_WORDS).join("|") + ")\\s+(?:live\\s+)?(?:" + COUNT_NOUNS + ")\\b" +
+    "|\\b\\d[\\d,]*(?:\\.\\d+)?\\s*(?:\\+|plus\\s*)?\\s*(?:years?|months?|weeks?|days?|yrs?)\\b",
+    "gi");
+  let m;
+  while ((m = re.exec(src))) {
+    const t = m[0];
+    const kind = /\b(?:years?|months?|weeks?|days?|yrs?)\b/i.test(t) && !/\d\s*%/.test(t) ? "duration" : "metric";
+    push(t, kind);
+  }
+  return out;
+}
+
+/** "$430,000" and "$430K" share a key; "five products" keys as "5"; ranges key on the first figure. */
+function figureKey(text) {
+  const t = String(text).toLowerCase().replace(/\s*percent\b/, "%").replace(/\s+plus\b/, "+");
+  const wordMatch = t.match(/^(one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|dozen)\b/);
+  if (wordMatch) return String(NUMBER_WORDS[wordMatch[1]]);
+  const range = t.match(/^\$?\s?(\d[\d,]*(?:\.\d+)?\s?[mk]?)\s?%?\s*(?:to|-)\s*/);
+  if (range) return metricKey((t.startsWith("$") ? "$" : "") + range[1] + (/%/.test(t) ? "%" : ""));
+  const teamOf = t.match(/\b(?:team of|staff of|group of)\s+(\d+)/);
+  if (teamOf) return teamOf[1];
+  // key on the first number token only, so a trailing noun never reads as a K/M scale
+  const first = t.match(/\$?\s?\d[\d,]*(?:\.\d+)?\s?(?:[mk]\b)?\s?%?/);
+  return metricKey(first ? first[0] : t);
+}
+
+function stems(text) {
+  return new Set(words(text));
+}
+
+function overlap(a, b) {
+  let n = 0;
+  for (const x of a) if (b.has(x)) n++;
+  return n;
+}
+
+function capitalizedRuns(sentence) {
+  const out = [];
+  const re = /\b([A-Z][a-zA-Z&.']+(?:\s+[A-Z][a-zA-Z&.']+)+)\b/g;
+  let m;
+  while ((m = re.exec(sentence))) out.push(m[1]);
+  return out;
+}
+
+module.exports = { norm, sentences, stripIdentifiers, extractFigures, figureKey, stems, overlap, capitalizedRuns, NUMBER_WORDS };

package/core/tracker_map.js

@@ -0,0 +1,94 @@
+"use strict";
+
+/**
+ * Maps one row of the xlsx tracker to store shapes. Pure. The tracker's
+ * status column is authoritative; the fill color is a cross-check that
+ * produces a warning when they disagree. Interview rounds, people, and
+ * communications the tracker only holds as prose come from a rounds
+ * manifest (store/import_tracker.js), never from parsing notes.
+ */
+
+const HEADERS = {
+  company: /^company$/i, title: /^role\s*\/\s*title$|^title$|^role$/i, location: /^location$/i,
+  applied: /^date applied$/i, source: /^source$/i, contact: /^contact name$/i, email: /^contact email$/i,
+  status: /^status$/i, follow_up: /^follow-?up date$/i, interview: /^interview date$/i, offer: /^offer/i,
+  notes: /^notes$/i, resume: /^tailored resume$/i, stage: /^stage$/i, fit: /^fit score$/i,
+};
+
+const STATUS = { applied: "applied", "to apply": "to_apply", maybe: "to_apply", pass: "pass", rejected: "rejected",
+  closed: "closed", offer: "offer", withdrawn: "closed" };
+
+const FILL_STATUS = { BDD7EE: "applied", C6EFCE: "to_apply", FFC7CE: "closed_or_pass" };
+
+/** Column letter -> field name from the header row. */
+function mapHeaders(headerCells) {
+  const map = {};
+  for (const [col, text] of Object.entries(headerCells)) {
+    for (const [field, re] of Object.entries(HEADERS)) if (re.test(String(text).trim())) map[field] = col;
+  }
+  return map;
+}
+
+function excelSerialToIso(n) {
+  const ms = Math.round((Number(n) - 25569) * 86400 * 1000);
+  return new Date(ms).toISOString().slice(0, 10);
+}
+
+function toIsoDate(v) {
+  if (v == null || v === "") return null;
+  if (v instanceof Date) return v.toISOString().slice(0, 10);
+  if (typeof v === "number") return excelSerialToIso(v);
+  const s = String(v).trim();
+  if (/^\d{4}-\d{2}-\d{2}/.test(s)) return s.slice(0, 10);
+  if (/^\d{5}$/.test(s)) return excelSerialToIso(Number(s));
+  const m = s.match(/^(\d{1,2})\/(\d{1,2})\/(\d{4})/);
+  if (m) return `${m[3]}-${m[1].padStart(2, "0")}-${m[2].padStart(2, "0")}`;
+  return null;
+}
+
+function fillColor(argb) {
+  if (!argb) return null;
+  return String(argb).toUpperCase().slice(-6);
+}
+
+/** @param {{cells: Record<string,string>, fill?: string}} row  @param {Record<string,string>} cols */
+function mapRow(row, cols) {
+  const c = (f) => (cols[f] ? row.cells[cols[f]] : undefined);
+  const company = String(c("company") || "").trim();
+  const title = String(c("title") || "").trim();
+  if (!company || !title) return null;
+  const rawStatus = String(c("status") || "").trim().toLowerCase();
+  const status = STATUS[rawStatus] || "to_apply";
+  const fill = FILL_STATUS[fillColor(row.fill)] || null;
+  const warnings = [];
+  if (fill && fill !== status && !(fill === "closed_or_pass" && ["pass", "rejected", "closed"].includes(status))) {
+    warnings.push(`status "${rawStatus}" disagrees with fill ${row.fill}`);
+  }
+  const fitRaw = c("fit");
+  const fit = fitRaw == null || fitRaw === "" ? null : Number(fitRaw);
+  return {
+    company, title,
+    location: c("location") || null,
+    applied_at: toIsoDate(c("applied")),
+    source_url: /^https?:/i.test(String(c("source") || "")) ? String(c("source")).split(/\s|\|/)[0] : null,
+    source_text: c("source") || null,
+    contact: c("contact") || null,
+    email: c("email") || null,
+    status,
+    follow_up: c("follow_up") || null,
+    interview_date: toIsoDate(c("interview")),
+    offer: c("offer") || null,
+    notes: c("notes") || "",
+    resume_file: c("resume") || null,
+    stage: c("stage") || "",
+    fit: Number.isFinite(fit) ? Math.round(fit * 10) / 10 : null,
+    warnings,
+  };
+}
+
+/** Natural key for idempotent import: company, title, applied date. */
+function naturalKey(r) {
+  return [r.company.toLowerCase(), r.title.toLowerCase(), r.applied_at || ""].join("|");
+}
+
+module.exports = { mapHeaders, mapRow, naturalKey, toIsoDate, excelSerialToIso, STATUS, FILL_STATUS };

package/core/ulid.js

@@ -0,0 +1,38 @@
+"use strict";
+
+/**
+ * ULID: 48 bits of millisecond time plus 80 random bits, Crockford base32,
+ * 26 characters, lexically sortable by creation time. Time is a parameter so
+ * core stays clock-free; callers in store pass Date.now().
+ */
+
+const crypto = require("crypto");
+const ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+
+function encodeTime(ms) {
+  let out = "";
+  let t = ms;
+  for (let i = 0; i < 10; i++) {
+    out = ALPHABET[t % 32] + out;
+    t = Math.floor(t / 32);
+  }
+  return out;
+}
+
+function encodeRandom() {
+  const bytes = crypto.randomBytes(16);
+  let out = "";
+  for (let i = 0; i < 16; i++) out += ALPHABET[bytes[i] & 31];
+  return out;
+}
+
+function ulid(nowMs) {
+  if (!Number.isInteger(nowMs) || nowMs < 0) throw new Error("ulid needs a millisecond timestamp");
+  return encodeTime(nowMs) + encodeRandom();
+}
+
+function isUlid(s) {
+  return typeof s === "string" && /^[0-9A-HJKMNP-TV-Z]{26}$/.test(s);
+}
+
+module.exports = { ulid, isUlid };

package/core/validators/highlight_body_match.js

@@ -0,0 +1,49 @@
+"use strict";
+
+/**
+ * Ledger rule 2, the F2 gate, with the semantics the shipped scoring.js
+ * enforces: every figure claimed in Career Highlights must appear in a body
+ * bullet by metric key, or the body must carry a different figure from the
+ * same record ("inside 60 days" in a highlight and "within the first two
+ * months" in the body are one claim in two units; F2 catches missing
+ * evidence, not unit choice). Resume kind only. In ingest mode highlights and
+ * bullets come from ctx.resume; in lint mode from the text by section.
+ */
+
+const { extractFigures } = require("../text");
+
+function sections(text) {
+  const t = String(text);
+  const hi = t.search(/career\s+highlights/i);
+  const rest = hi === -1 ? -1 : t.slice(hi + 17).search(/\b(experience|logistics\s*&?\s*operations\s+experience|process\s+improvement)\b/i);
+  if (hi === -1 || rest === -1) return null;
+  const body = hi + 17 + rest;
+  return { highlights: [t.slice(hi, body)], bullets: [t.slice(body)] };
+}
+
+function recordKeys(r) {
+  const keys = new Set();
+  for (const m of r.metrics_json || []) for (const k of m.keys || [m.key]) keys.add(k);
+  for (const f of extractFigures((r.summary || "") + " " + (r.wordings_json || []).map((w) => w.text).join(" "))) keys.add(f.key);
+  return keys;
+}
+
+function run(fields, ctx) {
+  if (ctx.kind !== "resume") return [];
+  const parts = ctx.resume || sections(fields.map((f) => f.value).join("\n"));
+  if (!parts) return [];
+  const bodyKeys = new Set(extractFigures(parts.bullets.join("\n")).map((f) => f.key));
+  const records = [...(ctx.slice || new Map()).values()].map((r) => recordKeys(r));
+  const sameEvidence = (key) => records.some((keys) => keys.has(key) && [...keys].some((k) => k !== key && bodyKeys.has(k)));
+  const out = [];
+  parts.highlights.forEach((h, i) => {
+    for (const fig of extractFigures(h)) {
+      if (fig.kind === "duration" && !bodyKeys.has(fig.key) && sameEvidence(fig.key)) continue;
+      if (bodyKeys.has(fig.key) || sameEvidence(fig.key)) continue;
+      out.push({ path: `careerHighlights[${i}]`, span: fig.text, hint: "highlight figure has no supporting body bullet; restore the bullet or drop the claim" });
+    }
+  });
+  return out;
+}
+
+module.exports = { name: "highlight_body_match", kind: "integrity", run, sections };

package/core/validators/index.js

@@ -0,0 +1,43 @@
+"use strict";
+
+/**
+ * The failure ledger as functions. runAll takes the schema walk of a
+ * content object (or a single prose field in lint mode) and a context, and
+ * returns blocks and warnings. Severity of style rules is per kind from the
+ * house rules; integrity rules always block. Pure.
+ *
+ * ctx: { kind, mode: "ingest" | "lint", slice, records, application, universe, house, resume?: { highlights[], bullets[] } }
+ */
+
+const { severity } = require("../house_rules");
+
+const RULES = [
+  require("./no_dashes"),
+  require("./no_derived_tenure"),
+  require("./metric_pairing"),
+  require("./verb_ladder"),
+  require("./highlight_body_match"),
+  require("./style_config"),
+  require("./no_confabulated_history"),
+];
+
+function runAll(fields, ctx) {
+  const blocks = [];
+  const warnings = [];
+  for (const rule of RULES) {
+    const findings = rule.run(fields, ctx) || [];
+    for (const f of findings) {
+      const sev = f.severity || severity(ctx.house, rule.name, ctx.kind);
+      if (sev === "off") continue;
+      (sev === "block" ? blocks : warnings).push({ rule: rule.name, ...f, severity: undefined });
+    }
+  }
+  return { blocks, warnings };
+}
+
+/** Lint mode: one prose field from plain text, no claims, no provenance. */
+function lintFields(text) {
+  return [{ path: "$.text", value: String(text || ""), class: "prose", claims: null, claimed: false }];
+}
+
+module.exports = { runAll, lintFields, RULES };

package/core/validators/metric_pairing.js

@@ -0,0 +1,52 @@
+"use strict";
+
+/**
+ * Ledger rule 4: every figure in prose must be a confirmed metric on a
+ * record in scope, paired with its recorded outcome. In ingest mode the
+ * scope is the field's cited records and a metric claim with that value
+ * must exist; in lint mode the scope is the whole slice. Durations are left
+ * to no_derived_tenure. Identifier fields are never scanned.
+ */
+
+const { extractFigures, norm, stems, overlap } = require("../text");
+const { citedRecords } = require("../provenance");
+
+function metricsOf(record, ctx) {
+  return (record.metrics_json || []).filter((m) => m.review_state === "confirmed" || (ctx && ctx.include_review));
+}
+
+function keysOf(m) {
+  const { figureKey } = require("../text");
+  return new Set([m.key, figureKey(m.value), ...(m.keys || []), ...(m.aliases || []).map(figureKey)]);
+}
+
+function run(fields, ctx) {
+  const out = [];
+  for (const f of fields) {
+    if (f.class !== "prose") continue;
+    const figures = extractFigures(f.value).filter((x) => x.kind === "metric");
+    if (!figures.length) continue;
+    const scope = ctx.mode === "lint" || !f.claims ? [...ctx.slice.values()] : [...citedRecords(f, ctx.slice).values()];
+    const sentenceStems = stems(f.value);
+    for (const fig of figures) {
+      const hits = [];
+      for (const r of scope) for (const m of metricsOf(r, ctx)) if (keysOf(m).has(fig.key)) hits.push({ r, m });
+      if (!hits.length) {
+        out.push({ path: f.path, span: fig.text, hint: ctx.mode === "lint"
+          ? "figure is not a confirmed metric on any record"
+          : "figure is not a confirmed metric on a cited record" });
+        continue;
+      }
+      if (ctx.mode !== "lint" && f.claims) {
+        const claimed = f.claims.some((c) => c.kind === "metric" && hits.some((h) => keysOf({ key: h.m.key, value: c.value, aliases: [] }).has(fig.key) && h.r.id === c.source_id));
+        if (!claimed) { out.push({ path: f.path, span: fig.text, hint: "figure has no metric claim naming its record and outcome" }); continue; }
+      }
+      // outcome pairing: the sentence must share a stem with the recorded outcome or title of some hit
+      const paired = hits.some((h) => overlap(sentenceStems, stems((h.m.outcome || "") + " " + h.r.title)) >= 1);
+      if (!paired) out.push({ path: f.path, span: fig.text, hint: `figure is recorded against "${hits[0].m.outcome}"; this sentence does not mention that outcome` });
+    }
+  }
+  return out;
+}
+
+module.exports = { name: "metric_pairing", kind: "integrity", run, _norm: norm };

package/core/validators/no_confabulated_history.js

@@ -0,0 +1,63 @@
+"use strict";
+
+/**
+ * Ledger rules 3, 11, 12: the record is the memory. Applies to prep,
+ * onepager, deep_answers, and email. Two universes come from ctx: this
+ * application's (rounds, formats, people, documents, company) and the
+ * candidate's full one (every company across applications, aliases).
+ *
+ *  - a sentence with a history cue needs a history claim (ingest) or a
+ *    resolvable round or format word (lint), else unsupported_history_claim
+ *  - a company from another application blocks as cross_application_reference
+ *  - a capitalized run in a history sentence that is in neither universe
+ *    blocks as unknown_entity
+ *  - completed homework needs a practice or cheatsheet document of this
+ *    application, else unverified_homework
+ */
+
+const { sentences, capitalizedRuns, norm } = require("../text");
+
+const KINDS = new Set(["prep", "onepager", "deep_answers", "email"]);
+const HISTORY_CUE = /\b(?:as (?:we|you) discussed|last round|previous round|prior round|in (?:the )?(?:r\d|round \d)|the (?:recruiter )?screen|what landed|you (?:told|mentioned|said)|(?:he|she|they) (?:said|asked|engaged|liked|probed)|when we (?:spoke|talked))\b/i;
+const HOMEWORK_CUE = /\b(?:you (?:are|were) drilled|you drilled|we (?:drilled|built|prepared|practiced)|you (?:debugged|practiced|rehearsed)|the practice workbook|this weekend you)\b/i;
+
+function wordIn(text, phrase) {
+  return new RegExp(`(?<![A-Za-z])${phrase.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![A-Za-z])`, "i").test(text);
+}
+
+function run(fields, ctx) {
+  if (!KINDS.has(ctx.kind)) return [];
+  const u = ctx.universe || {};
+  const thisApp = ctx.application || {};
+  const otherCompanies = (u.other_companies || []).flatMap((c) => [c, ...(u.aliases && u.aliases[c] || []), ...(c.split(/\s+/)[0].length >= 4 ? [c.split(/\s+/)[0]] : [])]);
+  const known = new Set([...(u.known_entities || []), ...(thisApp.people || []), ...(thisApp.company ? [thisApp.company] : [])].map((s) => norm(s)));
+  const roundWords = new Set([...(thisApp.rounds || []).map((r) => r.toLowerCase()), ...(thisApp.formats || []).map((f) => f.toLowerCase())]);
+  const out = [];
+  for (const f of fields) {
+    if (f.class !== "prose") continue;
+    for (const s of sentences(f.value)) {
+      for (const c of otherCompanies) {
+        if (wordIn(s, c)) out.push({ path: f.path, span: s.slice(0, 80), hint: `cross_application_reference: "${c}" belongs to another application` });
+      }
+      const hasCue = HISTORY_CUE.test(s);
+      if (hasCue) {
+        const ok = ctx.mode === "lint" || !f.claims
+          ? [...roundWords].some((w) => new RegExp(`\\b${w}\\b`, "i").test(s)) || /\b(?:screen|recruiter)\b/i.test(s) && (thisApp.formats || []).includes("screen")
+          : (f.claims || []).some((c) => c.kind === "history" || c.kind === "quote");
+        if (!ok) out.push({ path: f.path, span: s.slice(0, 80), hint: "unsupported_history_claim: no history claim or round of this application" });
+        for (const run of capitalizedRuns(s)) {
+          const n = norm(run);
+          if (known.has(n) || [...known].some((k) => k.includes(n) || n.includes(k))) continue;
+          if (/^(?:the|this|that|monday|tuesday|wednesday|thursday|friday|excel|teams|zoom|google|microsoft)\b/i.test(run)) continue;
+          out.push({ path: f.path, span: run, hint: "unknown_entity in a history sentence" });
+        }
+      }
+      if (HOMEWORK_CUE.test(s) && !(thisApp.document_kinds || []).some((k) => ["practice", "cheatsheet"].includes(k))) {
+        out.push({ path: f.path, span: s.slice(0, 80), hint: "unverified_homework: no practice or cheatsheet document exists for this application" });
+      }
+    }
+  }
+  return out;
+}
+
+module.exports = { name: "no_confabulated_history", kind: "integrity", run };

package/core/validators/no_dashes.js

@@ -0,0 +1,31 @@
+"use strict";
+
+/** Ledger rule 6: no dashes in outbound prose, including the email subject line. */
+
+const DASHES = /[‒-―−]/g;
+const SPACED_HYPHEN = /\s-\s|\s-(?=\S)|(?<=\S)-\s/g;
+const COMPOUND = /(?<=[A-Za-z])-(?=[A-Za-z])/g;
+const PHONE = /\b\d{3}-\d{3}-\d{4}\b/g;
+
+function run(fields, ctx) {
+  const allow = new Set((ctx.house && ctx.house.hyphen_allow || []).map((s) => s.toLowerCase()));
+  const out = [];
+  for (const f of fields) {
+    if (f.class !== "prose") continue;
+    const text = f.value.replace(PHONE, (m) => " ".repeat(m.length));
+    for (const m of text.matchAll(DASHES)) out.push({ path: f.path, span: snippet(text, m.index), hint: "use a comma, colon, or a new sentence" });
+    for (const m of text.matchAll(SPACED_HYPHEN)) out.push({ path: f.path, span: snippet(text, m.index), hint: "hyphen used as punctuation" });
+    for (const m of text.matchAll(COMPOUND)) {
+      const word = text.slice(text.lastIndexOf(" ", m.index) + 1, (text.indexOf(" ", m.index) + 1 || text.length + 1) - 1);
+      if (allow.has(word.toLowerCase())) continue;
+      out.push({ path: f.path, span: word, hint: "write the compound open or add it to hyphen_allow" });
+    }
+  }
+  return out;
+}
+
+function snippet(text, i) {
+  return text.slice(Math.max(0, i - 12), i + 12).trim();
+}
+
+module.exports = { name: "no_dashes", kind: "style", run };

package/core/validators/no_derived_tenure.js

@@ -0,0 +1,60 @@
+"use strict";
+
+/**
+ * Ledger rules 1 and 9: no derived tenure arithmetic. A tenure phrase passes
+ * only as a confirmed tenure claim on a record in scope; a duration passes
+ * when it is a confirmed duration claim or metric on a record in scope.
+ * quoted_source fields are exempt (a requirement echo is not a claim).
+ */
+
+const { norm } = require("../text");
+const { citedRecords } = require("../provenance");
+
+const NUM = "(?:\\d+(?:\\+|\\s*plus)?|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|fifteen|twenty)";
+const TENURE = new RegExp(`\\b(?:(?:over|nearly|almost|more than|about|roughly)\\s+)?(?:a\\s+decade|two\\s+decades|${NUM}\\s*\\+?\\s*(?:years?|yrs?)(?:\\s+of)?(?:\\s+(?:experience|tenure|sales|selling|career|leading|in\\b))?)`, "gi");
+const DURATION = new RegExp(`\\b(?:(?:over|in|within|nearly|almost|about|roughly|under|the\\s+first)\\s+)?(?:the\\s+first\\s+)?${NUM}\\s*(?:years?|months?|weeks?|days?)\\b`, "gi");
+
+function scopeRecords(f, ctx) {
+  if (ctx.mode === "lint" || !f.claims) return [...ctx.slice.values()];
+  return [...citedRecords(f, ctx.slice).values()];
+}
+
+const WORDS = { one: "1", two: "2", three: "3", four: "4", five: "5", six: "6", seven: "7", eight: "8", nine: "9", ten: "10", eleven: "11", twelve: "12" };
+const digitsForWords = (s) => s.replace(/\b(one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve)\b/g, (m) => WORDS[m]);
+
+function confirmedPhrase(records, phrase) {
+  const p = digitsForWords(norm(phrase)).replace(/^(over|in|within|nearly|almost|about|roughly|under|the first)\s+/, "").replace(/\s*plus\b/, "+").replace(/\s*\+\s*/, "+ ");
+  // a confirmed claim may be the fuller wording the candidate chose ("7+ years in fulfillment"); the regex match is its head
+  const head = (t) => digitsForWords(norm(t)).replace(/^(over|in|within|nearly|almost|about|roughly|under|the first)\s+/, "").replace(/\s*plus\b/, "+").replace(/\s*\+\s*/, "+ ");
+  return records.some((r) =>
+    (r.verbatim_claims_json || []).some((c) => c.review_state === "confirmed" && (head(c.text) === p || head(c.text).startsWith(p + " ") || head(c.text).startsWith(p)))
+    || (r.metrics_json || []).some((m) => m.review_state === "confirmed" && digitsForWords(norm(m.value)) === p));
+}
+
+function run(fields, ctx) {
+  const out = [];
+  for (const f of fields) {
+    if (f.class !== "prose") continue;
+    const records = scopeRecords(f, ctx);
+    const seen = new Set();
+    for (const re of [TENURE, DURATION]) {
+      re.lastIndex = 0;
+      let m;
+      while ((m = re.exec(f.value))) {
+        const phrase = m[0].replace(/\s+/g, " ").trim();
+        if (seen.has(phrase.toLowerCase())) continue;
+        seen.add(phrase.toLowerCase());
+        if (/\bsince\s+(?:19|20)\d{2}/i.test(f.value.slice(Math.max(0, m.index - 20), m.index + phrase.length + 20)) && re === DURATION) continue;
+        if (confirmedPhrase(records, phrase)) continue;
+        const claimed = (f.claims || []).some((c) => c.kind === "tenure" && (norm(c.value) === norm(phrase) || norm(c.value).startsWith(norm(phrase))) && norm(f.value).includes(norm(c.value)));
+        if (claimed) continue;
+        out.push({ path: f.path, span: phrase, hint: re === TENURE
+          ? "tenure must be a confirmed verbatim claim; anchor to a recorded figure or let the dates speak"
+          : "a duration must be a confirmed duration claim or metric on a cited record" });
+      }
+    }
+  }
+  return out;
+}
+
+module.exports = { name: "no_derived_tenure", kind: "integrity", run };

package/core/validators/style_config.js

@@ -0,0 +1,18 @@
+"use strict";
+
+/** House vocabulary (ecommerce, N+, %, P&L), per candidate, prose fields only. */
+
+function run(fields, ctx) {
+  const rules = (ctx.house && ctx.house.vocabulary) || [];
+  const out = [];
+  for (const f of fields) {
+    if (f.class !== "prose") continue;
+    for (const r of rules) {
+      const re = new RegExp(r.pattern, (r.flags || "") + "g");
+      for (const m of f.value.matchAll(re)) out.push({ path: f.path, span: m[0], hint: r.message });
+    }
+  }
+  return out;
+}
+
+module.exports = { name: "style_config", kind: "style", run };

package/core/validators/verb_ladder.js

@@ -0,0 +1,51 @@
+"use strict";
+
+/**
+ * Ledger rule 5: ownership verbs never promote. Ownership claims are checked
+ * against the cited record's confirmed verbs; a record with only review
+ * state verbs supports tier 1 at most. Prose defense: a tier-3 lead verb in
+ * a sentence whose cited records carry no confirmed tier-3 verb blocks. Weak
+ * and unlisted verbs are ignored. A subject with no overlap against the
+ * record is a warning, never a block.
+ */
+
+const { sentences, stems, overlap, norm } = require("../text");
+const { tier, leadVerb } = require("../verbs");
+const { citedRecords } = require("../provenance");
+
+function maxTier(record) {
+  const confirmed = (record.verbs_json || []).filter((v) => v.review_state === "confirmed");
+  return confirmed.length ? Math.max(...confirmed.map((v) => v.tier || tier(v.verb))) : 1;
+}
+
+function run(fields, ctx) {
+  const out = [];
+  for (const f of fields) {
+    if (f.class !== "prose") continue;
+    const scope = ctx.mode === "lint" || !f.claims ? null : citedRecords(f, ctx.slice);
+    for (const c of f.claims || []) {
+      if (c.kind !== "ownership") continue;
+      const r = ctx.slice.get(c.source_id);
+      if (!r) continue; // provenance already blocked it
+      const t = tier(c.verb);
+      if (t > maxTier(r)) out.push({ path: f.path, span: c.verb, hint: `"${c.verb}" is tier ${t}; ${r.id} supports tier ${maxTier(r)} on confirmed verbs` });
+      if (c.subject && overlap(stems(c.subject), stems(r.title + " " + (r.summary || ""))) === 0) {
+        out.push({ path: f.path, span: c.subject, hint: `subject has no overlap with ${r.id}; confirm it is this record`, severity: "warn" });
+      }
+    }
+    for (const s of sentences(f.value)) {
+      const v = leadVerb(s);
+      if (!v || tier(v) < 3) continue;
+      if (ctx.mode === "lint" || !f.claims) {
+        const ok = [...ctx.slice.values()].some((r) => maxTier(r) >= 3 && (r.verbs_json || []).some((x) => x.verb === v && x.review_state === "confirmed")
+          && (overlap(stems(s), stems(r.title)) >= 2 || (r.metrics_json || []).some((m) => m.review_state === "confirmed" && norm(s).replace(/\s+/g, "").includes(norm(m.value).replace(/\s+/g, "")))));
+        if (!ok) out.push({ path: f.path, span: s.slice(0, 80), hint: `"${v}" is a tier 3 ownership verb; no record in scope confirms it for this sentence` });
+      } else if (![...scope.values()].some((r) => maxTier(r) >= 3)) {
+        out.push({ path: f.path, span: s.slice(0, 80), hint: `"${v}" is a tier 3 ownership verb; no cited record carries a confirmed tier 3 verb` });
+      }
+    }
+  }
+  return out;
+}
+
+module.exports = { name: "verb_ladder", kind: "integrity", run };

package/core/verbs.js

@@ -0,0 +1,43 @@
+"use strict";
+
+/**
+ * The ownership verb ladder (ledger rule 5). Tier 3 claims ownership, tier 2
+ * claims management, tier 1 claims participation. Verbs not on the ladder
+ * (reduced, recovered, cut, improved) describe outcomes, not ownership, and
+ * validator 4 ignores them: inflation is the risk, deflation is not.
+ */
+
+const LADDER = {
+  led: 3, built: 3, created: 3, owned: 3, founded: 3, launched: 3, ran: 3, directed: 3,
+  managed: 2, drove: 2, delivered: 2, designed: 2, implemented: 2, grew: 2, established: 2, developed: 2, scaled: 2,
+  contributed: 1, supported: 1, assisted: 1, participated: 1, helped: 1,
+};
+
+const SYNONYM = { lead: "led", leading: "led", build: "built", building: "built", create: "created", own: "owned",
+  launch: "launched", run: "ran", manage: "managed", drive: "drove",
+  deliver: "delivered", implement: "implemented", grow: "grew", establish: "established", develop: "developed",
+  scale: "scaled", contribute: "contributed", support: "supported", assist: "assisted", participate: "participated",
+  help: "helped" };
+
+function canonical(word) {
+  const w = String(word || "").toLowerCase();
+  return LADDER[w] ? w : SYNONYM[w] || null;
+}
+
+function tier(word) {
+  const c = canonical(word);
+  return c ? LADDER[c] : 0;
+}
+
+/**
+ * The ownership verb a wording claims: its first ladder verb in past tense
+ * form, if any. Base forms are not accepted here: "direct team of 6" and
+ * "found by auditing" are not ownership claims.
+ */
+function leadVerb(text) {
+  const tokens = String(text || "").toLowerCase().match(/[a-z]+/g) || [];
+  for (const t of tokens.slice(0, 3)) if (LADDER[t]) return t;
+  return null;
+}
+
+module.exports = { LADDER, canonical, tier, leadVerb };