@gafj/gafj 0.1.1

package/core/rules/rubric.md

@@ -0,0 +1,120 @@
+# Requirement scoring rubric (Update Spec Part K)
+
+You have called a scoring tool. The server has already done the deterministic
+half: it scanned the posting, ranked the knowledge base against it, and ran the
+mechanical gates. What remains is judgement, and it is yours. Follow this
+rubric exactly.
+
+**This output is a diagnostic, not a deliverable.** See "Output handling".
+
+---
+
+## Pass 1 — Requirement extraction and weighting
+
+Produce 5 to 8 categories. More than 8 means you are splitting too finely.
+
+| Field | Rule |
+| --- | --- |
+| `category` | A short label in the POSTING's own language, e.g. "3PL and Outsourced Logistics Vendor Management". Never map onto a fixed taxonomy. Categories differ per posting. |
+| `weight` | 1 to 10, inferred from the employer's emphasis: minimum versus preferred qualifications, repetition, position in the responsibilities list, and whether the opening paragraph names it. |
+| `jd_evidence` | The verbatim posting lines that produced the category. **Required.** A category with no quoted source text is invalid; delete it. |
+| `is_hard_gate` | True when phrased as required, must have, a named credential, or a years of experience minimum. The tool returns candidate hard gate lines; confirm each. |
+
+**The single most important constraint in Part K: weight from the employer's
+emphasis, never from what the candidate happens to be good at.** A scorer that weights
+toward the candidate's strengths is worthless. If you notice yourself raising a
+weight because the evidence is strong, you have already failed.
+
+The tool reports whether the G1 AI triggers fired. If they did, AI capability is
+a real category and the entry placement rule changes; do not treat it as
+incidental.
+
+## Pass 1b — Evidence ranking
+
+The tool returns a ranked shortlist per category with a provisional
+`evidence_strength`. Read the accomplishments before accepting it. Downgrade
+anything whose match is vocabulary rather than substance. Mark a category
+`Absent` when nothing in the knowledge base genuinely speaks to it, and say so
+plainly rather than stretching an adjacent bullet to cover it.
+
+This ranking feeds Career Highlights selection. It converts highlight choice
+from recall into evidence ranking, which is what stops a leadership requirement
+being answered with no leadership bullet on the page.
+
+## Pass 2 — Score the finished resume
+
+| Field | Rule |
+| --- | --- |
+| `score` | 1 to 10 for how well THE RESUME evidences the category. Not how well the candidate does. |
+| `rationale` | Two or three sentences citing specific resume content. Quote it. |
+| `missing_evidence` | Knowledge base material that would have scored higher and was not selected. The tool computes a candidate list. |
+
+### The pre-send gate is enforced, not yours to apply
+
+Pass your scores to `score_resume` as `scores`, an array of
+`{category, weight, score}`. The server computes the weighted average to one
+decimal and returns a `PRE-SEND GATE` section carrying `gate`, `overall`, and
+`blocking`. You do not compute the overall and you do not decide the verdict.
+
+`gate` is **BLOCKED** when either of these is true:
+
+- any category with `weight >= 8` scores below 7, or
+- any mechanical finding has severity `blocker` — decided with or without
+  `scores`, because a Career Highlight claiming a metric no body bullet supports
+  is not sendable at any score.
+
+BLOCKED means the document is not sendable and must be regenerated. It is a
+verdict on the resume, not advice about it, and there is no threshold of overall
+score that overrides it. When the gate blocks, the tool says so in the first
+line of its output, ahead of this rubric; act on that line before reading
+anything else. Fix every blocking item, regenerate, and score again.
+
+Omitting `scores` does not make a weak resume sendable. It only means the
+weighted half of the gate was never checked, so no PASS is reported.
+
+## Gap classification
+
+| Class | Meaning | Action |
+| --- | --- | --- |
+| Fixable by wording | The evidence exists; the resume did not surface it, or used different vocabulary | Regenerate with corrected wording |
+| Fixable by KB | The candidate likely has this but it is not in the knowledge base | Ask the candidate to confirm, then add it |
+| Genuine gap | He does not have it | Feed to the cover letter's gap naming paragraph. Never hide it |
+
+Worked examples from the 2026-08-11 Meta scoring: "formal OKR framework
+governance is light versus KPI driven cost management" is fixable by wording,
+because the record says KPI throughout and the posting says OKR. "No explicit
+Sarbanes Oxley experience" is a genuine gap with internal controls work as a
+legitimate transferable proxy.
+
+## Guarding against self-grading
+
+If this generator scores its own output against its own rubric, it will flatter
+itself. Four mitigations, all required:
+
+1. The rubric comes from the posting verbatim. Every category carries
+   `jd_evidence`.
+2. Score the document, not the person. The question is "does this resume prove
+   it", never "can the candidate do it".
+3. **Absence is scoreable.** If the resume does not contain the evidence, the
+   score is low even when the knowledge base does contain it. That divergence
+   is exactly what `missing_evidence` exists to surface. Resist the pull to
+   score what you know rather than what is on the page.
+4. Calibrate against an independent tool periodically. CandidateMatch scored the
+   round 5 Meta resume 8.8 out of 10 on 2026-08-11. That is the benchmark. If
+   this scorer rates the same resume and posting meaningfully higher, the rubric
+   has drifted and the scores are worth nothing until it is re-anchored.
+
+## Output handling
+
+Render to the working session only. Do not write a shareable file, and never
+auto-generate a candidate facing "match report".
+
+A candidate authored match report is self assessment, and its gap section is a
+pre-drafted rejection rationale sitting in a forwardable file with the candidate's name
+on it. The same document sent by a recruiter is a third party assessment and
+carries real weight. Identical artifact, opposite effect, depending on sender.
+
+The one sanctioned export is arming a recruiter already advocating for him, and
+it requires him to say so per instance. When `export_for_recruiter` is set, the
+tool omits the gap list; present what remains as a requirement to evidence map,
+not as an automated score.

package/core/schema.sql

@@ -0,0 +1,342 @@
+-- GAF-J schema, version 1. Plan section K.
+-- Enums are CHECK constraints. Rules that must survive a UI bug are triggers.
+-- IDs are ULIDs. Timestamps are ISO 8601 UTC strings stamped by the server.
+-- PRAGMAs are set by store/db.js in the documented order, not here.
+
+CREATE TABLE candidate (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  contact_json TEXT NOT NULL DEFAULT '{}',
+  style_config_json TEXT NOT NULL DEFAULT '{}',
+  company_aliases_json TEXT NOT NULL DEFAULT '{}',
+  kb_revision INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL
+);
+
+CREATE TABLE accomplishment (
+  id TEXT PRIMARY KEY,
+  candidate_id TEXT NOT NULL REFERENCES candidate(id),
+  title TEXT NOT NULL,
+  company TEXT NOT NULL,
+  role TEXT NOT NULL,
+  date_start TEXT,
+  date_end TEXT,
+  summary TEXT,
+  metrics_json TEXT NOT NULL DEFAULT '[]',
+  verbatim_claims_json TEXT NOT NULL DEFAULT '[]',
+  verbs_json TEXT NOT NULL DEFAULT '[]',
+  subjects_json TEXT NOT NULL DEFAULT '[]',
+  wordings_json TEXT NOT NULL DEFAULT '[]',
+  tags_json TEXT NOT NULL DEFAULT '[]',
+  strength_score INTEGER,
+  source TEXT NOT NULL CHECK (source IN ('import', 'confirmed_pending')),
+  confirmed_at TEXT NOT NULL
+);
+CREATE INDEX accomplishment_candidate ON accomplishment(candidate_id);
+
+CREATE TABLE onboarding_batch (
+  id TEXT PRIMARY KEY,
+  candidate_id TEXT NOT NULL REFERENCES candidate(id),
+  status TEXT NOT NULL CHECK (status IN ('open', 'review', 'completed', 'abandoned')),
+  created_at TEXT NOT NULL,
+  completed_at TEXT
+);
+
+CREATE TABLE source_document (
+  id TEXT PRIMARY KEY,
+  candidate_id TEXT NOT NULL REFERENCES candidate(id),
+  batch_id TEXT NOT NULL REFERENCES onboarding_batch(id),
+  filename TEXT NOT NULL,
+  kind TEXT NOT NULL CHECK (kind IN ('docx', 'pdf', 'md', 'txt')),
+  file_hash TEXT NOT NULL,
+  text_hash TEXT NOT NULL,
+  extractor TEXT NOT NULL,
+  extractor_version TEXT NOT NULL,
+  text TEXT NOT NULL CHECK (length(text) <= 1048576),
+  uploaded_at TEXT NOT NULL,
+  UNIQUE (candidate_id, file_hash)
+);
+CREATE TRIGGER batch_source_cap BEFORE INSERT ON source_document
+  WHEN (SELECT count(*) FROM source_document WHERE batch_id = NEW.batch_id) >= 20
+  BEGIN SELECT RAISE(ABORT, 'batch holds 20 sources; open another'); END;
+
+CREATE TABLE posting (
+  id TEXT PRIMARY KEY,
+  candidate_id TEXT NOT NULL REFERENCES candidate(id),
+  company TEXT NOT NULL,
+  title TEXT NOT NULL,
+  raw_text TEXT NOT NULL CHECK (length(raw_text) BETWEEN 1 AND 262144),
+  content_hash TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('proposed', 'accepted', 'archived')),
+  source_url TEXT,
+  comp_text TEXT,
+  location TEXT,
+  captured_at TEXT NOT NULL,
+  taken_down_at TEXT,
+  UNIQUE (candidate_id, company, title, content_hash)
+);
+CREATE INDEX posting_candidate ON posting(candidate_id, captured_at DESC);
+CREATE TRIGGER posting_raw_immutable BEFORE UPDATE OF raw_text, content_hash ON posting
+  BEGIN SELECT RAISE(ABORT, 'posting text is the permanent record'); END;
+
+CREATE TABLE kb_gap (
+  id TEXT PRIMARY KEY,
+  candidate_id TEXT NOT NULL REFERENCES candidate(id),
+  posting_id TEXT NOT NULL REFERENCES posting(id),
+  requirement_text TEXT NOT NULL,
+  question TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  resolved_at TEXT
+);
+
+CREATE TABLE pending_accomplishment (
+  id TEXT PRIMARY KEY,
+  candidate_id TEXT NOT NULL REFERENCES candidate(id),
+  draft_json TEXT NOT NULL,
+  source TEXT NOT NULL CHECK (source IN ('gap_answer', 'manual', 'proposal', 'onboarding')),
+  batch_id TEXT REFERENCES onboarding_batch(id),
+  source_document_id TEXT REFERENCES source_document(id),
+  ai_attempt_id TEXT REFERENCES ai_attempt(id),
+  dedup_group_id TEXT,
+  gap_id TEXT REFERENCES kb_gap(id),
+  proposed_at TEXT NOT NULL,
+  CHECK (source <> 'onboarding' OR (batch_id IS NOT NULL AND source_document_id IS NOT NULL))
+);
+CREATE TRIGGER pending_cap_campaign BEFORE INSERT ON pending_accomplishment
+  WHEN NEW.source <> 'onboarding'
+   AND (SELECT count(*) FROM pending_accomplishment
+        WHERE candidate_id = NEW.candidate_id AND source <> 'onboarding') >= 20
+  BEGIN SELECT RAISE(ABORT, 'pending queue is full; confirm or dismiss first'); END;
+CREATE TRIGGER pending_cap_source BEFORE INSERT ON pending_accomplishment
+  WHEN NEW.source = 'onboarding'
+   AND (SELECT count(*) FROM pending_accomplishment WHERE source_document_id = NEW.source_document_id) >= 40
+  BEGIN SELECT RAISE(ABORT, '40 proposals per source; review before proposing more'); END;
+CREATE TRIGGER pending_cap_batch BEFORE INSERT ON pending_accomplishment
+  WHEN NEW.source = 'onboarding'
+   AND (SELECT count(*) FROM pending_accomplishment WHERE batch_id = NEW.batch_id) >= 250
+  BEGIN SELECT RAISE(ABORT, '250 proposals per batch'); END;
+
+CREATE TABLE scoring (
+  id TEXT PRIMARY KEY,
+  posting_id TEXT NOT NULL REFERENCES posting(id),
+  categories_json TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('proposed', 'frozen')),
+  fit_score REAL CHECK (fit_score IS NULL OR fit_score BETWEEN 0 AND 10),
+  verdict TEXT CHECK (verdict IS NULL OR verdict IN ('pursue', 'pass')),
+  verdict_reason TEXT,
+  engine_version TEXT NOT NULL,
+  rubric_version TEXT NOT NULL,
+  kb_revision INTEGER NOT NULL,
+  scoring_evidence_hash TEXT,
+  supersedes_id TEXT REFERENCES scoring(id),
+  scored_at TEXT NOT NULL,
+  CHECK ((status = 'proposed' AND fit_score IS NULL AND verdict IS NULL)
+      OR (status = 'frozen' AND fit_score IS NOT NULL AND verdict IS NOT NULL AND scoring_evidence_hash IS NOT NULL))
+);
+
+CREATE TABLE application (
+  id TEXT PRIMARY KEY,
+  posting_id TEXT NOT NULL UNIQUE REFERENCES posting(id),
+  status TEXT NOT NULL CHECK (status IN ('to_apply', 'applied', 'pass', 'rejected', 'closed', 'offer')),
+  applied_at TEXT,
+  scoring_id TEXT REFERENCES scoring(id),
+  decision_expected_at TEXT,
+  resume_doc_id TEXT REFERENCES document(id),
+  cover_doc_id TEXT REFERENCES document(id),
+  comp_floor_ok INTEGER NOT NULL DEFAULT 0,
+  notes TEXT NOT NULL DEFAULT ''
+);
+-- An application may only reference an accepted posting, a frozen score for that posting,
+-- and passed documents of the right kind for that posting. Checked on insert and update.
+CREATE TRIGGER application_posting_insert BEFORE INSERT ON application
+  WHEN (SELECT status FROM posting WHERE id = NEW.posting_id) IS NOT 'accepted'
+  BEGIN SELECT RAISE(ABORT, 'applications require an accepted posting'); END;
+CREATE TRIGGER application_posting_update BEFORE UPDATE OF posting_id ON application
+  WHEN (SELECT status FROM posting WHERE id = NEW.posting_id) IS NOT 'accepted'
+  BEGIN SELECT RAISE(ABORT, 'applications require an accepted posting'); END;
+CREATE TRIGGER application_scoring_insert BEFORE INSERT ON application
+  WHEN NEW.scoring_id IS NOT NULL AND NOT EXISTS (
+    SELECT 1 FROM scoring s WHERE s.id = NEW.scoring_id AND s.status = 'frozen' AND s.posting_id = NEW.posting_id)
+  BEGIN SELECT RAISE(ABORT, 'scoring_id must be a frozen score for this posting'); END;
+CREATE TRIGGER application_scoring_update BEFORE UPDATE OF scoring_id, posting_id ON application
+  WHEN NEW.scoring_id IS NOT NULL AND NOT EXISTS (
+    SELECT 1 FROM scoring s WHERE s.id = NEW.scoring_id AND s.status = 'frozen' AND s.posting_id = NEW.posting_id)
+  BEGIN SELECT RAISE(ABORT, 'scoring_id must be a frozen score for this posting'); END;
+CREATE TRIGGER application_resume_insert BEFORE INSERT ON application
+  WHEN NEW.resume_doc_id IS NOT NULL AND NOT EXISTS (
+    SELECT 1 FROM document d WHERE d.id = NEW.resume_doc_id AND d.kind = 'resume' AND d.status = 'passed' AND d.posting_id = NEW.posting_id)
+  BEGIN SELECT RAISE(ABORT, 'resume_doc_id must be a passed resume for this posting'); END;
+CREATE TRIGGER application_resume_update BEFORE UPDATE OF resume_doc_id, posting_id ON application
+  WHEN NEW.resume_doc_id IS NOT NULL AND NOT EXISTS (
+    SELECT 1 FROM document d WHERE d.id = NEW.resume_doc_id AND d.kind = 'resume' AND d.status = 'passed' AND d.posting_id = NEW.posting_id)
+  BEGIN SELECT RAISE(ABORT, 'resume_doc_id must be a passed resume for this posting'); END;
+CREATE TRIGGER application_cover_insert BEFORE INSERT ON application
+  WHEN NEW.cover_doc_id IS NOT NULL AND NOT EXISTS (
+    SELECT 1 FROM document d WHERE d.id = NEW.cover_doc_id AND d.kind = 'cover' AND d.status = 'passed' AND d.posting_id = NEW.posting_id)
+  BEGIN SELECT RAISE(ABORT, 'cover_doc_id must be a passed cover letter for this posting'); END;
+CREATE TRIGGER application_cover_update BEFORE UPDATE OF cover_doc_id, posting_id ON application
+  WHEN NEW.cover_doc_id IS NOT NULL AND NOT EXISTS (
+    SELECT 1 FROM document d WHERE d.id = NEW.cover_doc_id AND d.kind = 'cover' AND d.status = 'passed' AND d.posting_id = NEW.posting_id)
+  BEGIN SELECT RAISE(ABORT, 'cover_doc_id must be a passed cover letter for this posting'); END;
+
+CREATE TABLE person (
+  id TEXT PRIMARY KEY,
+  candidate_id TEXT NOT NULL REFERENCES candidate(id),
+  name TEXT NOT NULL,
+  title TEXT,
+  org TEXT,
+  intel_text TEXT,
+  links_json TEXT NOT NULL DEFAULT '[]',
+  first_seen_at TEXT NOT NULL,
+  merged_into_id TEXT REFERENCES person(id)
+);
+CREATE TABLE application_person (
+  application_id TEXT NOT NULL REFERENCES application(id),
+  person_id TEXT NOT NULL REFERENCES person(id),
+  role TEXT NOT NULL CHECK (role IN ('interviewer', 'recruiter', 'referral', 'other')),
+  PRIMARY KEY (application_id, person_id, role)
+);
+
+CREATE TABLE interview (
+  id TEXT PRIMARY KEY,
+  application_id TEXT NOT NULL REFERENCES application(id),
+  round_label TEXT NOT NULL,
+  scheduled_at TEXT NOT NULL,
+  tz TEXT NOT NULL,
+  format TEXT NOT NULL CHECK (format IN ('screen', 'hm', 'panel', 'technical', 'onsite')),
+  status TEXT NOT NULL DEFAULT 'scheduled' CHECK (status IN ('scheduled', 'completed', 'cancelled', 'superseded')),
+  completed_at TEXT,
+  invite_received_at TEXT,
+  supersedes_id TEXT REFERENCES interview(id),
+  pinned_ids_json TEXT NOT NULL DEFAULT '[]',
+  outcome TEXT NOT NULL DEFAULT 'pending' CHECK (outcome IN ('pending', 'advanced', 'rejected', 'ghosted')),
+  debrief_text TEXT CHECK (debrief_text IS NULL OR length(debrief_text) <= 65536),
+  debrief_captured_at TEXT
+);
+CREATE INDEX interview_app ON interview(application_id, scheduled_at);
+CREATE UNIQUE INDEX interview_one_scheduled ON interview(application_id, round_label) WHERE status = 'scheduled';
+CREATE TABLE interview_person (
+  interview_id TEXT NOT NULL REFERENCES interview(id),
+  person_id TEXT NOT NULL REFERENCES person(id),
+  PRIMARY KEY (interview_id, person_id)
+);
+
+CREATE TABLE document (
+  id TEXT PRIMARY KEY,
+  candidate_id TEXT NOT NULL REFERENCES candidate(id),
+  kind TEXT NOT NULL CHECK (kind IN ('resume', 'cover', 'prep', 'onepager', 'deep_answers', 'practice', 'cheatsheet', 'email')),
+  posting_id TEXT REFERENCES posting(id),
+  application_id TEXT REFERENCES application(id),
+  interview_id TEXT REFERENCES interview(id),
+  content_json TEXT NOT NULL,
+  provenance_json TEXT NOT NULL,
+  gate_result_json TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('passed', 'blocked')),
+  warnings_json TEXT NOT NULL DEFAULT '[]',
+  route TEXT NOT NULL CHECK (route IN ('mcp', 'paste', 'byo_key', 'credits', 'manual')),
+  rules_version TEXT NOT NULL,
+  schema_version TEXT NOT NULL,
+  ai_attempt_id TEXT REFERENCES ai_attempt(id),
+  rendered_rel_path TEXT,
+  created_at TEXT NOT NULL,
+  CHECK ((kind IN ('resume', 'cover') AND posting_id IS NOT NULL AND application_id IS NULL AND interview_id IS NULL)
+      OR (kind IN ('prep', 'onepager', 'deep_answers', 'practice', 'cheatsheet') AND interview_id IS NOT NULL AND posting_id IS NULL AND application_id IS NULL)
+      OR (kind = 'email' AND application_id IS NOT NULL AND posting_id IS NULL))
+);
+CREATE INDEX document_interview ON document(interview_id, kind, created_at DESC);
+CREATE INDEX document_posting ON document(posting_id, kind, created_at DESC);
+CREATE TRIGGER document_email_interview BEFORE INSERT ON document
+  WHEN NEW.kind = 'email' AND NEW.interview_id IS NOT NULL
+   AND (SELECT application_id FROM interview WHERE id = NEW.interview_id) IS NOT NEW.application_id
+  BEGIN SELECT RAISE(ABORT, 'interview belongs to another application'); END;
+CREATE TRIGGER document_immutable BEFORE UPDATE OF
+    candidate_id, kind, posting_id, application_id, interview_id, content_json, provenance_json,
+    gate_result_json, status, warnings_json, route, rules_version, schema_version, ai_attempt_id, created_at
+  ON document
+  BEGIN SELECT RAISE(ABORT, 'documents are versions; only rendered_rel_path may change'); END;
+
+CREATE TABLE communication (
+  id TEXT PRIMARY KEY,
+  application_id TEXT NOT NULL REFERENCES application(id),
+  interview_id TEXT REFERENCES interview(id),
+  kind TEXT NOT NULL CHECK (kind IN ('thankyou', 'nudge', 'negotiation', 'other')),
+  document_id TEXT REFERENCES document(id),
+  to_addr TEXT,
+  sent_at TEXT NOT NULL,
+  sent_body_text TEXT
+);
+CREATE TRIGGER communication_interview_insert BEFORE INSERT ON communication
+  WHEN NEW.interview_id IS NOT NULL
+   AND (SELECT application_id FROM interview WHERE id = NEW.interview_id) IS NOT NEW.application_id
+  BEGIN SELECT RAISE(ABORT, 'interview belongs to another application'); END;
+CREATE TRIGGER communication_interview_update BEFORE UPDATE OF interview_id, application_id ON communication
+  WHEN NEW.interview_id IS NOT NULL
+   AND (SELECT application_id FROM interview WHERE id = NEW.interview_id) IS NOT NEW.application_id
+  BEGIN SELECT RAISE(ABORT, 'interview belongs to another application'); END;
+CREATE TRIGGER communication_doc_insert BEFORE INSERT ON communication
+  WHEN NEW.document_id IS NOT NULL AND NOT EXISTS (
+    SELECT 1 FROM document d WHERE d.id = NEW.document_id AND d.kind = 'email' AND d.status = 'passed'
+      AND d.application_id = NEW.application_id
+      AND (d.interview_id IS NULL OR d.interview_id IS NEW.interview_id))
+  BEGIN SELECT RAISE(ABORT, 'draft must be a passed email for this application and interview'); END;
+CREATE TRIGGER communication_doc_update BEFORE UPDATE OF document_id, application_id, interview_id ON communication
+  WHEN NEW.document_id IS NOT NULL AND NOT EXISTS (
+    SELECT 1 FROM document d WHERE d.id = NEW.document_id AND d.kind = 'email' AND d.status = 'passed'
+      AND d.application_id = NEW.application_id
+      AND (d.interview_id IS NULL OR d.interview_id IS NEW.interview_id))
+  BEGIN SELECT RAISE(ABORT, 'draft must be a passed email for this application and interview'); END;
+
+CREATE TABLE event_log (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  candidate_id TEXT NOT NULL REFERENCES candidate(id),
+  entity TEXT NOT NULL,
+  entity_id TEXT NOT NULL,
+  event TEXT NOT NULL,
+  actor_type TEXT NOT NULL CHECK (actor_type IN ('ui', 'cli', 'mcp', 'bridge', 'import', 'system')),
+  actor_ref TEXT,
+  payload_json TEXT NOT NULL DEFAULT '{}',
+  prior_json TEXT,
+  at TEXT NOT NULL
+);
+CREATE TRIGGER event_log_no_update BEFORE UPDATE ON event_log BEGIN SELECT RAISE(ABORT, 'append only'); END;
+CREATE TRIGGER event_log_no_delete BEFORE DELETE ON event_log BEGIN SELECT RAISE(ABORT, 'append only'); END;
+
+CREATE TABLE ai_run (
+  id TEXT PRIMARY KEY,
+  candidate_id TEXT NOT NULL REFERENCES candidate(id),
+  route TEXT NOT NULL CHECK (route IN ('mcp', 'paste', 'byo_key', 'credits', 'manual')),
+  operation TEXT NOT NULL CHECK (operation IN ('resume', 'cover', 'prep', 'onepager', 'deep_answers', 'followup', 'practice', 'categories', 'extract', 'style', 'dedup')),
+  interview_id TEXT REFERENCES interview(id),
+  posting_id TEXT REFERENCES posting(id),
+  source_document_id TEXT REFERENCES source_document(id),
+  onboarding_batch_id TEXT REFERENCES onboarding_batch(id),
+  rules_version TEXT NOT NULL,
+  schema_version TEXT NOT NULL,
+  packet_version TEXT NOT NULL,
+  kb_revision INTEGER NOT NULL,
+  packet_hash TEXT NOT NULL,
+  kb_ids_json TEXT NOT NULL,
+  started_at TEXT NOT NULL,
+  finished_at TEXT,
+  final_result TEXT NOT NULL DEFAULT 'pending' CHECK (final_result IN ('pending', 'passed', 'blocked', 'error', 'abandoned')),
+  CHECK ((operation IN ('resume', 'cover', 'categories') AND posting_id IS NOT NULL)
+      OR (operation IN ('prep', 'onepager', 'deep_answers', 'followup', 'practice') AND interview_id IS NOT NULL)
+      OR (operation IN ('extract', 'style') AND source_document_id IS NOT NULL)
+      OR (operation = 'dedup' AND onboarding_batch_id IS NOT NULL))
+);
+CREATE TABLE ai_attempt (
+  id TEXT PRIMARY KEY,
+  ai_run_id TEXT NOT NULL REFERENCES ai_run(id),
+  attempt_no INTEGER NOT NULL CHECK (attempt_no BETWEEN 1 AND 3),
+  provider TEXT,
+  model TEXT,
+  tokens_in INTEGER,
+  tokens_out INTEGER,
+  latency_ms INTEGER,
+  output_hash TEXT,
+  result TEXT NOT NULL CHECK (result IN ('passed', 'blocked', 'error')),
+  error_code TEXT,
+  started_at TEXT NOT NULL,
+  finished_at TEXT,
+  UNIQUE (ai_run_id, attempt_no)
+);

package/core/schemas/categories.js

@@ -0,0 +1,16 @@
+"use strict";
+const { str, arr, obj } = require("./lang");
+
+/**
+ * Proposed scoring categories, Part K. Every jd_evidence line must be a
+ * verbatim substring of the posting text or the proposal is rejected.
+ * Weights come from the employer's emphasis, never the candidate's strengths.
+ */
+module.exports = obj({
+  categories: arr(obj({
+    category: str("prose", { max: 80 }),
+    weight: { t: "number", min: 1, max: 10 },
+    jd_evidence: arr(str("quoted_source", { max: 400 }), 1, 6),
+    is_hard_gate: { t: "boolean" },
+  }), 5, 8),
+}, ["categories"]);

package/core/schemas/cover.js

@@ -0,0 +1,10 @@
+"use strict";
+const { str, claimed, arr, obj } = require("./lang");
+
+/** Cover letter. A requirement the letter restates goes in quoted_source, never prose. */
+module.exports = obj({
+  greeting: str("prose", { max: 80 }),
+  paragraphs: arr(claimed(900), 2, 5),
+  requirement_echoes: arr(str("quoted_source", { max: 300 }), 0, 6),
+  closing: str("prose", { max: 200 }),
+}, ["greeting", "paragraphs", "closing"]);

package/core/schemas/deep_answers.js

@@ -0,0 +1,16 @@
+"use strict";
+const { str, claimed, arr, obj } = require("./lang");
+
+/**
+ * Spoken-word scripts, Codification 3.3. Anything only the candidate lived
+ * is the literal token [YOURS]; a placeholder is never delivered and is
+ * excluded from provenance.
+ */
+module.exports = obj({
+  answers: arr(obj({
+    question: str("prose", { max: 200 }),
+    seconds: { t: "number", min: 30, max: 150 },
+    script: claimed(1800),
+    skeleton_only: { t: "boolean" },
+  }, ["question", "script"]), 3, 12),
+}, ["answers"]);

package/core/schemas/discover.js

@@ -0,0 +1,19 @@
+"use strict";
+const { str, arr, obj } = require("./lang");
+
+/**
+ * Discovery (plan section U, the shakedown): questions the AI asks about the
+ * confirmed records, each tied to one record id from the slice. The store
+ * rejects a question whose id is not in the packet. Nothing here is a claim;
+ * the answer is the candidate's, written on the knowledge base screen, and
+ * lands pending against that record.
+ */
+module.exports = obj({
+  questions: arr(obj({
+    accomplishment_id: str("identifier", { max: 80 }),
+    kind: str("identifier", { enum: ["metric", "scope", "context", "story", "tenure", "skill"] }),
+    question: str("prose", { max: 400 }),
+    why: str("prose", { max: 240 }),
+  }, ["accomplishment_id", "kind", "question"]), 1, 12),
+  notes: str("prose", { max: 600 }),
+}, ["questions"]);

package/core/schemas/extract.js

@@ -0,0 +1,32 @@
+"use strict";
+const { str, arr, obj } = require("./lang");
+
+/**
+ * Onboarding extraction (plan section U): accomplishments proposed from
+ * one source document. Every factual atom is an excerpt: the value plus
+ * the [start, end) span of the source text that contains it, checked by
+ * propose_from_source. Prose (summary) may paraphrase; atoms may not.
+ * No claims here: this never crosses the document ledger.
+ */
+const ATOM = obj({ value: str("quoted_source", { max: 300 }), start: { t: "number", min: 0 }, end: { t: "number", min: 0 } });
+const METRIC = obj({ value: str("quoted_source", { max: 80 }), start: { t: "number", min: 0 }, end: { t: "number", min: 0 }, outcome: str("prose", { max: 160 }) }, ["value", "start", "end"]);
+
+module.exports = obj({
+  accomplishments: arr(obj({
+    title: str("prose", { max: 200 }),
+    company: ATOM,
+    role: ATOM,
+    dates: ATOM,
+    summary: str("prose", { max: 1200 }),
+    metrics: arr(METRIC, 0, 12),
+    verbs: arr(ATOM, 0, 8),
+    wordings: arr(ATOM, 1, 6),
+    scope: ATOM,
+    tags: arr(str("identifier", { max: 40 }), 0, 8),
+  }, ["title", "company", "role", "wordings"]), 1, 40),
+  style_observed: obj({
+    dashes: str("identifier", { enum: ["none", "hyphens", "em_dashes", "mixed"] }),
+    ecommerce_spelling: str("identifier", { max: 20 }),
+    percent_style: str("identifier", { enum: ["symbol", "word", "mixed"] }),
+  }, []),
+}, ["accomplishments"]);

package/core/schemas/followup.js

@@ -0,0 +1,10 @@
+"use strict";
+const { str, claimed, obj } = require("./lang");
+
+/** Thank-you, nudge, negotiation. Subject and body are outbound prose; dashes block by default. */
+module.exports = obj({
+  kind: str("identifier", { enum: ["thankyou", "nudge", "negotiation", "other"] }),
+  subject: str("prose", { max: 120 }),
+  body: claimed(2200),
+  open_loop_closed: str("prose", { max: 200 }),
+}, ["kind", "subject", "body"]);

package/core/schemas/index.js

@@ -0,0 +1,32 @@
+"use strict";
+
+/**
+ * A small schema language for model output. Every string field carries a
+ * class (prose, identifier, quoted_source, url, email); a claim-bearing
+ * field is an object { text, claims[] }. The same schema validates model
+ * output, drives the walk the validators consume, and renders to JSON
+ * Schema for the packet. No date field exists in any output schema, and no
+ * field can carry the comp floor; a test walks every schema for both.
+ */
+
+const lang = require("./lang");
+
+const SCHEMAS = {
+  resume: require("./resume"),
+  cover: require("./cover"),
+  prep: require("./prep"),
+  onepager: require("./onepager"),
+  deep_answers: require("./deep_answers"),
+  followup: require("./followup"),
+  practice: require("./practice"),
+  categories: require("./categories"),
+  extract: require("./extract"),
+  discover: require("./discover"),
+};
+
+const SCHEMA_VERSION = "1";
+
+/** Document kind for a schema key. followup lands as an email document; categories is a proposal. */
+const KIND_OF = { resume: "resume", cover: "cover", prep: "prep", onepager: "onepager", deep_answers: "deep_answers", followup: "email", practice: "practice" };
+
+module.exports = { ...lang, SCHEMAS, SCHEMA_VERSION, KIND_OF };