tor-to-proposal 2.0.0

package/bin/profile.mjs

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+// profile: the one-time consultant profile -> ~/.tor-to-proposal/profile.json
+// Every value here is USER-SUPPLIED. The profile is the canonical "user input"
+// trace source downstream tools cite; nothing in it is ever invented or defaulted
+// silently. Plug-and-play: `npx tor-to-proposal init` runs the wizard once, and
+// every future bid inherits these facts instead of re-asking for them.
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import readline from 'node:readline/promises';
+import { fail, parseArgs, helpText } from './lib.mjs';
+
+const HELP = helpText('profile', [
+  'One-time consultant profile, stored at ~/.tor-to-proposal/profile.json.',
+  '',
+  '  init                 interactive wizard (terminal prompts; blank = keep current)',
+  '  set key=value ...    set fields (dotted keys). Values parse as JSON when valid:',
+  '                         profile set identity.name="Ayesha Khan" rates.defaults.base=400 cv.masterPath=~/cv/master.md',
+  '  get [key]            print the whole profile (or one dotted field) as JSON',
+  '  path                 print the profile file path',
+  '  erase                delete the profile',
+  '',
+  'Fields:',
+  '  identity.{name, credentials, title, email, phone, location, nationality, languages[]}',
+  '  rates.floor.{annualIncome, billableDays, costLoading}      # your floor-math inputs',
+  '  rates.defaults.{base, basis, currency, loading, contingency} # re-confirmed per bid',
+  '  cv.masterPath                                              # your master CV',
+]);
+
+const FILE = path.join(os.homedir(), '.tor-to-proposal', 'profile.json');
+
+const NUMERIC = {
+  'rates.floor.annualIncome': { min: 0, max: 1e9, label: 'annual income need' },
+  'rates.floor.billableDays': { min: 0, max: 365, label: 'billable days per year' },
+  'rates.floor.costLoading': { min: 0, max: 2, label: 'cost loading (0–2, e.g. 0.25)' },
+  'rates.defaults.base': { min: 0, max: 1e7, label: 'base rate' },
+  'rates.defaults.loading': { min: 0, max: 2, label: 'loading (0–2)' },
+  'rates.defaults.contingency': { min: 0, max: 1, label: 'contingency (0–1)' },
+};
+const BASIS = ['hour', 'day', 'week', 'month'];
+
+export function loadProfile() {
+  try {
+    return JSON.parse(fs.readFileSync(FILE, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function emptyProfile() {
+  const now = new Date().toISOString();
+  return {
+    version: 1,
+    identity: { name: null, credentials: null, title: null, email: null, phone: null, location: null, nationality: null, languages: [] },
+    rates: { floor: { annualIncome: null, billableDays: null, costLoading: null }, defaults: { base: null, basis: 'day', currency: 'USD', loading: null, contingency: null } },
+    cv: { masterPath: null },
+    meta: { createdAt: now, updatedAt: now },
+  };
+}
+
+function getDeep(obj, dotted) {
+  return dotted.split('.').reduce((o, k) => (o == null ? undefined : o[k]), obj);
+}
+
+function setDeep(obj, dotted, value) {
+  const keys = dotted.split('.');
+  let o = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    if (typeof o[keys[i]] !== 'object' || o[keys[i]] === null) o[keys[i]] = {};
+    o = o[keys[i]];
+  }
+  o[keys[keys.length - 1]] = value;
+}
+
+function coerceAndValidate(dotted, raw) {
+  let v;
+  try { v = JSON.parse(raw); } catch { v = raw; }
+  if (v === '' || v === 'null' || v === null) v = null;
+  if (NUMERIC[dotted]) {
+    if (v === null) return null;
+    const n = Number(v);
+    if (!Number.isFinite(n)) fail(`${dotted} must be a number (got: ${JSON.stringify(raw)})`, 2);
+    const { min, max, label } = NUMERIC[dotted];
+    if (n < min || n > max) fail(`${dotted} (${label}) must be between ${min} and ${max}`, 2);
+    return n;
+  }
+  if (dotted === 'rates.defaults.basis' && v !== null && !BASIS.includes(String(v).toLowerCase())) {
+    fail(`rates.defaults.basis must be one of ${BASIS.join('|')}`, 2);
+  }
+  if (dotted === 'cv.masterPath' && v !== null) {
+    const p = String(v).replace(/^~(?=\/|$)/, os.homedir());
+    if (!fs.existsSync(p)) fail(`cv.masterPath does not exist: ${p} (set it to your master CV file)`, 2);
+    return p;
+  }
+  if (dotted === 'identity.languages' && v !== null && !Array.isArray(v)) {
+    v = String(v).split(/[,;]\s*/).map((s) => s.trim()).filter(Boolean);
+  }
+  return v;
+}
+
+function save(profile) {
+  profile.meta = { ...(profile.meta || {}), updatedAt: new Date().toISOString() };
+  fs.mkdirSync(path.dirname(FILE), { recursive: true });
+  fs.writeFileSync(FILE, JSON.stringify(profile, null, 2));
+  process.stderr.write(`written: ${FILE}\n`);
+}
+
+// ---------- interactive wizard ----------
+async function wizard() {
+  const current = loadProfile() || emptyProfile();
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const ask = async (label, existing, hint = '') => {
+    const tail = hint ? ` (${hint})` : '';
+    const cur = existing === null || existing === undefined || (Array.isArray(existing) && !existing.length) ? '' : String(Array.isArray(existing) ? existing.join(', ') : existing);
+    const a = (await rl.question(`${label}${tail} [${cur}]: `)).trim();
+    return a === '' ? existing : a;
+  };
+  const id = current.identity;
+  id.name = await ask('Full name (exactly as on your CV)', id.name);
+  id.credentials = await ask('Credentials after your name (e.g. "PhD, PMP")', id.credentials);
+  id.title = await ask('Professional title (e.g. "M&E Consultant")', id.title);
+  id.email = await ask('Email', id.email);
+  id.phone = await ask('Phone (international format)', id.phone);
+  id.location = await ask('City, country', id.location);
+  id.nationality = await ask('Nationality (some ToRs require it)', id.nationality);
+  id.languages = await ask('Working languages (comma-separated)', id.languages);
+  const cv = await ask('Path to your master CV file', current.cv.masterPath);
+  if (cv !== current.cv.masterPath) {
+    const p = String(cv).replace(/^~(?=\/|$)/, os.homedir());
+    if (!fs.existsSync(p)) process.stderr.write(`  ! file not found (${p}) — stored anyway; fix with: profile set cv.masterPath=...\n`);
+    current.cv.masterPath = p;
+  }
+  const fl = current.rates.floor;
+  const asNum = (v) => (v === null || v === undefined || v === '' ? null : Number(v));
+  let a = await ask('Minimum annual income you need (your floor math)', fl.annualIncome, 'e.g. 60000');
+  fl.annualIncome = a === fl.annualIncome ? fl.annualIncome : asNum(a);
+  a = await ask('Realistic billable days per year', fl.billableDays, 'e.g. 180');
+  fl.billableDays = a === fl.billableDays ? fl.billableDays : asNum(a);
+  a = await ask('Cost loading (overheads on top of your net)', fl.costLoading, 'e.g. 0.25');
+  fl.costLoading = a === fl.costLoading ? fl.costLoading : asNum(a);
+  const d = current.rates.defaults;
+  a = await ask('Default currency', d.currency || 'USD');
+  d.currency = String(a).toUpperCase();
+  a = await ask('Typical base rate (optional — you confirm it per bid)', d.base, 'e.g. 400');
+  d.base = a === d.base ? d.base : asNum(a);
+  a = await ask('Typical loading', d.loading, 'e.g. 0.25');
+  d.loading = a === d.loading ? d.loading : asNum(a);
+  rl.close();
+  save(current);
+  process.stdout.write(
+    `\nProfile saved: ${FILE}\n\nNext: drop a ToR + your CV into a folder and tell your AI assistant:\n  "Run a bid pack on <folder>"\n` +
+      'Your saved numbers will be offered for one-keystroke confirmation — never used without it.\n'
+  );
+}
+
+// ---------- dispatch (guarded so other tools can import loadProfile) ----------
+import { pathToFileURL } from 'node:url';
+const isMain = process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href;
+
+const args = parseArgs(process.argv.slice(2));
+const cmd = args._[0];
+
+async function main() {
+if (args.__help || !cmd) {
+  process.stdout.write(HELP);
+  process.exit(args.__help ? 0 : 1);
+}
+
+if (cmd === 'init') {
+  await wizard();
+} else if (cmd === 'set') {
+  if (!args._.slice(1).length) fail('nothing to set. Example: profile set identity.name="A. Khan" rates.defaults.base=400', 2);
+  const profile = loadProfile() || emptyProfile();
+  for (const kv of args._.slice(1)) {
+    const eq = kv.indexOf('=');
+    if (eq <= 0) fail(`expected key=value, got "${kv}"`, 2);
+    const key = kv.slice(0, eq).trim();
+    if (key === 'meta' || key.startsWith('meta.') || key === 'version') fail(`"${key}" is managed by the tool`, 2);
+    setDeep(profile, key, coerceAndValidate(key, kv.slice(eq + 1)));
+    process.stderr.write(`set ${key}\n`);
+  }
+  save(profile);
+} else if (cmd === 'get') {
+  const profile = loadProfile();
+  if (!profile) fail(`no profile at ${FILE} — run: tor-to-proposal init`, 2);
+  if (args._[1]) {
+    const v = getDeep(profile, args._[1]);
+    if (v === undefined) fail(`unknown key: ${args._[1]}`, 2);
+    process.stdout.write(JSON.stringify(v, null, 2) + '\n');
+  } else process.stdout.write(JSON.stringify(profile, null, 2) + '\n');
+} else if (cmd === 'path') {
+  process.stdout.write(FILE + '\n');
+} else if (cmd === 'erase') {
+  if (fs.existsSync(FILE)) { fs.rmSync(FILE); process.stderr.write(`erased: ${FILE}\n`); }
+  else process.stderr.write('no profile to erase\n');
+} else {
+  fail(`unknown command: ${cmd} (init | set | get | path | erase)`, 2);
+}
+}
+
+if (isMain) await main();

package/bin/render.mjs

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+// render: minimal pure-JS markdown -> PDF emitter (the fallback tier).
+// The agent's own document tooling produces the presentation PDFs; this exists so
+// a bid pack can ALWAYS be completed and verified, even with no document skill
+// present. Text layout only: headings, bullets, tables (Courier), wrapping,
+// page numbers, WinAnsi text. Deterministic: same input -> same bytes.
+import fs from 'node:fs';
+import path from 'node:path';
+import { fail, parseArgs, readText, writeOut, helpText } from './lib.mjs';
+
+const HELP = helpText('render', [
+  'Usage: node bin/render.mjs <input.md> --out output.pdf [--footer "text"]',
+  '',
+  'Fallback renderer: clean, plain, submittable. For a designed PDF, let your AI',
+  'assistant render it with its document tooling instead — package.mjs verifies',
+  'whichever PDF it finds, whichever tool produced it.',
+]);
+
+// ---------- cp1252 (WinAnsi) encoding ----------
+const SPECIAL = { 0x20ac: 0x80, 0x201a: 0x82, 0x0192: 0x83, 0x201e: 0x84, 0x2026: 0x85, 0x2020: 0x86, 0x2021: 0x87, 0x02c6: 0x88, 0x2030: 0x89, 0x0160: 0x8a, 0x2039: 0x8b, 0x0152: 0x8c, 0x017d: 0x8e, 0x2018: 0x91, 0x2019: 0x92, 0x201c: 0x93, 0x201d: 0x94, 0x2022: 0x95, 0x2013: 0x96, 0x2014: 0x97, 0x02dc: 0x98, 0x2122: 0x99, 0x0161: 0x9a, 0x203a: 0x9b, 0x0153: 0x9c, 0x017e: 0x9e, 0x0178: 0x9f };
+function cp1252Buffer(s) {
+  const out = [];
+  for (const ch of String(s)) {
+    const c = ch.codePointAt(0);
+    if (c < 0x100 && !(c >= 0x7f && c <= 0x9f)) out.push(c);
+    else if (SPECIAL[c] !== undefined) out.push(SPECIAL[c]);
+    else out.push(0x3f); // ?
+  }
+  return Buffer.from(out, 'latin1');
+}
+
+// ---------- markdown -> layout tokens ----------
+const stripInline = (s) => String(s).replace(/\*\*([^*]+)\*\*/g, '$1').replace(/\*([^*]+)\*/g, '$1').replace(/`([^`]+)`/g, '$1').replace(/\s+/g, ' ').trim();
+
+function tokenize(md) {
+  const lines = md.split('\n');
+  const tokens = [];
+  let table = null;
+  const flushTable = () => { if (table && table.rows.length) tokens.push({ type: 'table', rows: table.rows }); table = null; };
+  for (const raw of lines) {
+    const line = raw.replace(/\s+$/, '');
+    if (/^\s*\|.*\|?\s*$/.test(line)) {
+      if (/^\s*\|?[\s:|-]+\|?\s*$/.test(line)) continue; // separator row
+      const cells = line.trim().replace(/^\||\|$/g, '').split('|').map((c) => stripInline(c));
+      table = table || { rows: [] };
+      table.rows.push(cells);
+      continue;
+    }
+    flushTable();
+    if (!line.trim()) { tokens.push({ type: 'gap' }); continue; }
+    let m = line.match(/^(#{1,3})\s+(.*)$/);
+    if (m) { tokens.push({ type: 'h' + m[1].length, text: stripInline(m[2]) }); continue; }
+    if (/^\s*(?:[-*_]\s*){3,}$/.test(line)) { tokens.push({ type: 'gap' }); continue; }
+    m = line.match(/^(\s*)(?:[-*•·‣–]|\d{1,2}[.)])\s+(.*)$/);
+    if (m) { tokens.push({ type: 'bullet', indent: m[1].length, text: stripInline(m[2]) }); continue; }
+    if (/^\*\*[^*]+\*\*$/.test(line.trim())) { tokens.push({ type: 'bold', text: stripInline(line) }); continue; }
+    tokens.push({ type: 'text', text: stripInline(line) });
+  }
+  flushTable();
+  return tokens;
+}
+
+// ---------- layout ----------
+const PAGE_W = 595, PAGE_H = 842, MARGIN = 56, TOP = 778, BOTTOM = 56;
+const FONTS = {
+  F1: { base: 'Helvetica', factor: 0.5 },
+  F2: { base: 'Helvetica-Bold', factor: 0.53 },
+  F3: { base: 'Courier', factor: 0.6 },
+};
+
+function wrapText(text, maxChars) {
+  const words = String(text).split(/\s+/).filter(Boolean);
+  if (!words.length) return [''];
+  const lines = [];
+  let cur = '';
+  for (let w of words) {
+    while (w.length > maxChars) { // hard-break overlong tokens (URLs)
+      const take = maxChars - (cur ? cur.length + 1 : 0);
+      if (take <= 0) { break; }
+      cur = cur ? cur + ' ' + w.slice(0, take) : w.slice(0, take);
+      lines.push(cur); cur = ''; w = w.slice(take);
+    }
+    const next = cur ? cur + ' ' + w : w;
+    if (next.length > maxChars && cur) { lines.push(cur); cur = w; } else cur = next;
+  }
+  if (cur) lines.push(cur);
+  return lines;
+}
+
+function layout(tokens) {
+  const pages = [];
+  let cur = [];
+  let y = TOP;
+  const newPage = () => { pages.push(cur); cur = []; y = TOP; };
+  const put = (text, font, size, lead, x, wrapAt) => {
+    for (const line of wrapText(text, wrapAt)) {
+      if (y - lead < BOTTOM) newPage();
+      cur.push({ x, y, font, size, text: line });
+      y -= lead;
+    }
+  };
+  for (const t of tokens) {
+    if (t.type === 'gap') { y -= 6; continue; }
+    if (t.type === 'h1') { y -= 8; put(t.text, 'F2', 14, 18, MARGIN, 64); y -= 2; continue; }
+    if (t.type === 'h2') { y -= 6; put(t.text, 'F2', 12, 16, MARGIN, 74); continue; }
+    if (t.type === 'h3') { y -= 4; put(t.text, 'F2', 10.5, 14, MARGIN, 85); continue; }
+    if (t.type === 'bold') { put(t.text, 'F2', 10, 14, MARGIN, 88); continue; }
+    if (t.type === 'bullet') {
+      const first = '• ' + t.text;
+      const lines = wrapText(first, 92);
+      lines.forEach((line, i) => put(line, 'F1', 10, 14, i === 0 ? MARGIN + 2 : MARGIN + 14, 92));
+      continue;
+    }
+    if (t.type === 'table') {
+      const rows = t.rows;
+      const nCol = Math.max(...rows.map((r) => r.length));
+      const budget = 96;
+      const widths = Array.from({ length: nCol }, (_, c) => Math.max(4, ...rows.map((r) => (r[c] || '').length)));
+      let total = widths.reduce((a, b) => a + b, 0) + nCol * 3;
+      if (total > budget) widths.forEach((_, i) => (widths[i] = Math.max(5, Math.floor((widths[i] / total) * budget))));
+      total = widths.reduce((a, b) => a + b, 0) + nCol * 3;
+      const renderRow = (r) => ' ' + Array.from({ length: nCol }, (_, c) => {
+        const w = widths[c];
+        const cell = (r[c] || '');
+        return cell.length > w ? cell.slice(0, w - 1) + '…' : cell.padEnd(w);
+      }).join(' | ');
+      y -= 4;
+      rows.forEach((r, i) => {
+        put(renderRow(r), 'F3', 8, 10.5, MARGIN, 110);
+        if (i === 0) put('-'.repeat(Math.min(total, 96)), 'F3', 8, 10.5, MARGIN, 110);
+      });
+      y -= 4;
+      continue;
+    }
+    put(t.text, 'F1', 10, 14, MARGIN, 92);
+  }
+  pages.push(cur);
+  return pages.filter((p, i) => p.length || i === 0);
+}
+
+// ---------- PDF assembly ----------
+function buildPdf(pages, title, footerText) {
+  const esc = (s) => String(s).replace(/\\/g, '\\\\').replace(/\(/g, '\\(').replace(/\)/g, '\\)');
+  const obj = (body) => Buffer.concat([Buffer.from(body, 'latin1')]);
+  const P = pages.length;
+  const pageObjs = pages.map((_, i) => 6 + i);
+  const contentObjs = pages.map((_, i) => 6 + P + i);
+  const infoNum = 6 + 2 * P;
+
+  const contents = pages.map((lines, i) => {
+    const parts = lines.map((l) => `BT /${l.font} ${l.size} Tf 1 0 0 1 ${l.x.toFixed(1)} ${l.y.toFixed(1)} Tm (${esc(l.text)}) Tj ET`);
+    const label = footerText ? `${footerText}  —  Page ${i + 1} of ${P}` : `Page ${i + 1} of ${P}`;
+    parts.push(`BT /F1 8 Tf 1 0 0 1 ${(PAGE_W / 2 - label.length * 2).toFixed(1)} 36 Tm (${esc(label)}) Tj ET`);
+    const stream = cp1252Buffer(parts.join('\n'));
+    return Buffer.concat([Buffer.from(`<< /Length ${stream.length} >>\nstream\n`, 'latin1'), stream, Buffer.from('\nendstream', 'latin1')]);
+  });
+
+  const bodies = [];
+  bodies[1] = obj('<< /Type /Catalog /Pages 2 0 R >>');
+  bodies[2] = obj(`<< /Type /Pages /Kids [${pageObjs.map((n) => `${n} 0 R`).join(' ')}] /Count ${P} >>`);
+  bodies[3] = obj('<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>');
+  bodies[4] = obj('<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding >>');
+  bodies[5] = obj('<< /Type /Font /Subtype /Type1 /BaseFont /Courier /Encoding /WinAnsiEncoding >>');
+  pages.forEach((_, i) => {
+    bodies[pageObjs[i]] = obj(`<< /Type /Page /Parent 2 0 R /MediaBox [0 0 ${PAGE_W} ${PAGE_H}] /Resources << /Font << /F1 3 0 R /F2 4 0 R /F3 5 0 R >> >> /Contents ${contentObjs[i]} 0 R >>`);
+    bodies[contentObjs[i]] = contents[i];
+  });
+  bodies[infoNum] = obj(`<< /Title (${esc(title || 'Proposal')}) /Producer (tor-to-proposal render) >>`);
+
+  const chunks = [Buffer.from('%PDF-1.4\n', 'latin1')];
+  const offsets = new Array(infoNum + 1).fill(0);
+  for (let n = 1; n <= infoNum; n++) {
+    if (!bodies[n]) continue;
+    offsets[n] = Buffer.concat(chunks).length;
+    chunks.push(Buffer.concat([Buffer.from(`${n} 0 obj\n`, 'latin1'), bodies[n], Buffer.from('\nendobj\n', 'latin1')]));
+  }
+  const xrefPos = Buffer.concat(chunks).length;
+  let xref = `xref\n0 ${infoNum + 1}\n0000000000 65535 f \n`;
+  for (let n = 1; n <= infoNum; n++) xref += `${String(offsets[n]).padStart(10, '0')} 00000 n \n`;
+  chunks.push(Buffer.from(xref + `trailer\n<< /Size ${infoNum + 1} /Root 1 0 R /Info ${infoNum} 0 R >>\nstartxref\n${xrefPos}\n%%EOF\n`, 'latin1'));
+  return Buffer.concat(chunks);
+}
+
+// ---------- CLI ----------
+const args = parseArgs(process.argv.slice(2));
+if (args.__help || !args._[0] || !args.out) {
+  process.stdout.write(HELP);
+  process.exit(args.__help ? 0 : 1);
+}
+const md = readText(args._[0], 'markdown input');
+const tokens = tokenize(md);
+if (!tokens.length) fail('input is empty — nothing to render', 2);
+const pages = layout(tokens);
+const title = (tokens.find((t) => t.type === 'h1') || {}).text || path0(args._[0]);
+function path0(p) { return String(p).split(/[\\/]/).pop(); }
+const pdf = buildPdf(pages, title, args.footer ? String(args.footer) : null);
+fs.mkdirSync(path.dirname(path.resolve(args.out)), { recursive: true });
+fs.writeFileSync(args.out, pdf);
+process.stderr.write(`written: ${args.out} (${pages.length} page${pages.length > 1 ? 's' : ''}, ${pdf.length} bytes, fallback renderer)\n`);

package/bin/simulator.mjs

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+// simulator: reverse-score a drafted technical response against the ToR's published
+// evaluation grid. Coverage arithmetic only — at-risk points = weight × (missing
+// sub-elements ÷ total). This is NOT a prediction of evaluator behavior (stated in report).
+import fs from 'node:fs';
+import { fail, parseArgs, readText, writeOut, helpText, mdTable } from './lib.mjs';
+
+const HELP = helpText('simulator', [
+  'Usage: node bin/simulator.mjs --extract out/tor-extract.json --response response.md',
+  '            [--sub-elements sub-elements.json] [--out simulator-report.md]',
+  '',
+  '--sub-elements (optional): {"criterion label": ["sub-element 1", "..."], ...}',
+  '  Agent-extracted from the ToR — verbatim wording, with the ToR page noted.',
+  '',
+  'Keyword-coverage check per sub-element; at-risk pts = weight × missing/total.',
+]);
+
+const STOP = new Set(['the', 'and', 'with', 'for', 'from', 'that', 'this', 'will', 'shall', 'including', 'based', 'using', 'which', 'their', 'other', 'others', 'must', 'have', 'been', 'into', 'such', 'than', 'then', 'when', 'where', 'while', 'about', 'under', 'over', 'within', 'should', 'would', 'could', 'these', 'those', 'applicant', 'bidder']);
+
+const args = parseArgs(process.argv.slice(2));
+if (args.__help || !args.extract || !args.response) {
+  process.stdout.write(HELP);
+  process.exit(args.__help ? 0 : 1);
+}
+const extract = JSON.parse(readText(args.extract, '--extract'));
+const response = readText(args.response, '--response');
+const responseLc = response.toLowerCase();
+const subMap = args['sub-elements'] ? JSON.parse(readText(args['sub-elements'], '--sub-elements')) : {};
+
+const criteria = extract.evaluation?.criteria ?? [];
+if (!criteria.length) fail('tor-extract.json has no evaluation criteria — re-run extract (or supply via --json per SKILL.md step 1)', 2);
+
+function keywords(text) {
+  return [...new Set(text.toLowerCase().match(/[a-z][a-z-]{3,}/g) ?? [])].filter((w) => !STOP.has(w)).slice(0, 8);
+}
+function coveredBy(el) {
+  const kws = keywords(el);
+  if (!kws.length) return { covered: true, hits: [], kws };
+  const hits = kws.filter((k) => new RegExp(`(^|[^a-z])${k}([^a-z]|$)`, 'i').test(responseLc));
+  return { covered: hits.length >= Math.max(1, Math.ceil(kws.length * 0.4)), hits, kws };
+}
+
+const rows = [];
+let totalAtRisk = 0;
+for (const c of criteria) {
+  const subs = subMap[c.label] ?? [c.label]; // no sub-map -> the criterion itself is the unit
+  const detail = subs.map((s) => ({ sub: s, ...coveredBy(s) }));
+  const missing = detail.filter((d) => !d.covered);
+  const atRisk = (c.weight * missing.length) / subs.length;
+  totalAtRisk += atRisk;
+  rows.push({
+    label: c.label, weight: c.weight, page: c.page ?? null, subs, missing: missing.map((m) => m.sub),
+    coveredN: subs.length - missing.length, atRisk: Math.round(atRisk * 100) / 100,
+  });
+}
+rows.sort((a, b) => b.atRisk - a.atRisk);
+const totalWeight = criteria.reduce((s, c) => s + c.weight, 0);
+
+const table = mdTable(
+  ['Criterion', 'Wt', 'Sub-elems covered', 'At-risk pts', 'Missing (add these)'],
+  rows.map((r) => [`${r.label}${r.page ? ` (p.${r.page})` : ''}`, String(r.weight), `${r.coveredN}/${r.subs.length}`, r.atRisk ? `**${r.atRisk.toFixed(2)}**` : '0', r.missing.length ? r.missing.map((m) => `“${m}”`).join('; ') : '—'])
+);
+const priorities = rows.filter((r) => r.atRisk > 0).map((r, i) => `${i + 1}. ${r.label} — recover up to ${r.atRisk.toFixed(2)} pts: add ${r.missing.join('; ')}.`);
+
+const report = `# Simulator report — coverage vs published grid\n\n**At-risk points: ${totalAtRisk.toFixed(2)} of ${totalWeight}** (sum of weights × missing share)\n\n${table}\n\n## Rewrite priorities (highest recoverable points first)\n${priorities.length ? priorities.join('\n') : 'None — every criterion covered at keyword level. Still get a human read.'}\n\n## Method (no false precision)\nPer sub-element, up to 8 distinctive keywords are extracted from the ToR wording and checked\nagainst your response; “covered” = ≥40% of keywords present. At-risk pts = weight × (missing ÷\ntotal sub-elements). This is coverage arithmetic on the published grid — NOT a prediction of\nhow evaluators will score you. Missing sub-element wording is verbatim ToR language: answer it\nin their words.\n`;
+writeOut(args.out || 'simulator-report.md', report);
+process.stderr.write(`simulator: at-risk ${totalAtRisk.toFixed(2)} / ${totalWeight} pts across ${criteria.length} criteria\n`);

package/bin/template-filler.mjs

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+// template-filler: fills the CLIENT'S OWN forms. docx placeholders + xlsx labeled
+// cells. Never alters template structure; never overwrites a formula; every write
+// is traced in fill-report.md. CLIENT-TEMPLATE-WINS is enforced here, mechanically.
+import fs from 'node:fs';
+import path from 'node:path';
+import { fail, parseArgs, readText, writeOut, helpText, loadDep } from './lib.mjs';
+
+const HELP = helpText('template-filler', [
+  'Commands (docx: {{placeholders}} in the client template; xlsx: row labels):',
+  '  map   --template form.docx|form.xlsx --data data.json',
+  '  fill  --template form.docx|form.xlsx --data data.json --out filled.docx|filled.xlsx',
+  '  check --template form.docx|form.xlsx --data data.json        # exit 1 if any [FILL] left',
+  '',
+  'data.json: flat map, e.g. {"daily_rate": 468.75, "Daily Fee": 468.75}.',
+  'docx values replace {{key}}; xlsx values fill the first empty cell right of a',
+  'matching row label. Formulas are never touched. fill-report.md traces every write.',
+]);
+
+const args = parseArgs(process.argv.slice(2));
+const cmd = args._[0];
+if (args.__help || !cmd || !args.template) {
+  process.stdout.write(HELP);
+  process.exit(args.__help ? 0 : 1);
+}
+const template = args.template;
+if (!fs.existsSync(template)) fail(`template not found: ${template}`, 2);
+const ext = (template.split('.').pop() || '').toLowerCase();
+const data = cmd === 'map' && !args.data ? {} : JSON.parse(readText(args.data, '--data (flat label->value map, e.g. from pricing.json rates)'));
+const writes = [];
+let unmapped = [];
+
+const xmlEscape = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+
+// ---------------- docx ----------------
+async function docxEntries() {
+  const AdmZip = await loadDep('adm-zip');
+  const zip = new AdmZip(fs.readFileSync(template));
+  return { zip, files: zip.getEntries().filter((e) => /word\/(document|header\d*|footer\d*)\.xml$/.test(e.entryName)) };
+}
+
+async function docxMap() {
+  const { zip, files } = await docxEntries();
+  const found = new Set();
+  const split = [];
+  for (const e of files) {
+    const xml = zip.readAsText(e);
+    for (const m of xml.matchAll(/\{\{\s*([\w.-]+)\s*\}\}/g)) found.add(m[1]);
+    for (const m of xml.matchAll(/\{\{[^}]{0,80}?<[^>]+>[^}]{0,80}?\}\}/g)) split.push(`${e.entryName}: ${m[0].slice(0, 60)}…`);
+  }
+  return { placeholders: [...found], split, files };
+}
+
+async function docxFill(out) {
+  const { zip, files } = await docxEntries();
+  const remaining = new Set();
+  for (const e of files) {
+    let xml = zip.readAsText(e);
+    xml = xml.replace(/\{\{\s*([\w.-]+)\s*\}\}/g, (whole, key) => {
+      if (key in data) {
+        writes.push({ file: out, place: `${e.entryName} {{${key}}}`, value: data[key], trace: `data.json["${key}"]` });
+        return xmlEscape(data[key]);
+      }
+      remaining.add(key);
+      return whole;
+    });
+    zip.updateFile(e.entryName, Buffer.from(xml, 'utf8'));
+  }
+  zip.writeZip(out);
+  unmapped = [...remaining];
+}
+
+// ---------------- xlsx ----------------
+async function loadWb() {
+  const mod = await loadDep('exceljs');
+  const ExcelJS = mod.default ?? mod;
+  const wb = new ExcelJS.Workbook();
+  await wb.xlsx.readFile(template);
+  return { ExcelJS, wb };
+}
+async function xlsxMap() {
+  const { wb } = await loadWb();
+  const labels = [];
+  wb.eachSheet((ws) => {
+    for (let r = 1; r <= Math.min(ws.rowCount || 0, 300); r++) {
+      const labelCell = ws.getRow(r).getCell(1);
+      const label = labelCell.value;
+      if (typeof label !== 'string' || !label.trim()) continue;
+      // candidate: label row with at least one empty non-label cell to the right
+      for (let c = 2; c <= 12; c++) {
+        const cell = ws.getRow(r).getCell(c);
+        if (cell.value === null || cell.value === '' || cell.value === undefined) {
+          labels.push({ sheet: ws.name, label: label.trim(), cell: cell.address });
+          break;
+        }
+        if (cell.formula || typeof cell.value === 'object') break; // hit data/formula zone — not a fill row
+      }
+    }
+  });
+  return labels;
+}
+async function xlsxFill(out) {
+  const { wb } = await loadWb();
+  const labels = await xlsxMap();
+  const left = new Set(labels.map((l) => l.label));
+  for (const l of labels) {
+    if (!(l.label in data)) continue;
+    left.delete(l.label);
+    const cell = wb.getWorksheet(l.sheet).getCell(l.cell);
+    if (cell.formula) { fail(`refusing to overwrite formula at ${l.sheet}!${l.cell} (client's formula stays)`, 2); }
+    const v = data[l.label];
+    cell.value = typeof v === 'number' ? v : String(v);
+    writes.push({ file: out, place: `${l.sheet}!${l.cell} (label "${l.label}")`, value: v, trace: `data.json["${l.label}"]` });
+  }
+  unmapped = [...left];
+  await wb.xlsx.writeFile(out);
+}
+
+// ---------------- run ----------------
+if (ext === 'docx') {
+  if (cmd === 'map') {
+    const { placeholders, split } = await docxMap();
+    process.stdout.write(`Placeholders in ${template}:\n` + (placeholders.map((p) => `  {{${p}}}${p in data ? '' : '  -> needs data key'}`).join('\n') || '  (none)') + '\n' + (split.length ? `\nSPLIT placeholders (Word broke them across formatting runs — fix in Word by retyping them as plain text, then re-run):\n` + split.map((s) => '  ' + s).join('\n') + '\n' : ''));
+  } else if (cmd === 'fill' || cmd === 'check') {
+    const out = cmd === 'fill' ? args.out || 'filled.docx' : null;
+    if (cmd === 'fill') {
+      if (!out) fail('--out required for fill', 2);
+      await docxFill(out);
+    } else {
+      const { placeholders } = await docxMap();
+      unmapped = placeholders.filter((p) => !(p in data));
+    }
+  } else fail(`unknown command: ${cmd}`, 2);
+} else if (ext === 'xlsx' || ext === 'xlsm') {
+  if (cmd === 'map') {
+    const labels = await xlsxMap();
+    process.stdout.write(`Fillable labeled cells in ${template}:\n` + (labels.map((l) => `  "${l.label}" -> ${l.sheet}!${l.cell}${l.label in data ? '' : '  -> needs data key'}`).join('\n') || '  (none)') + '\n');
+  } else if (cmd === 'fill') {
+    if (!args.out) fail('--out required for fill', 2);
+    await xlsxFill(args.out);
+  } else if (cmd === 'check') {
+    const labels = await xlsxMap();
+    unmapped = labels.filter((l) => !(l.label in data)).map((l) => l.label);
+  } else fail(`unknown command: ${cmd}`, 2);
+} else {
+  fail(`unsupported template type: .${ext} (docx/xlsx only — for PDF forms, request the editable original from the client)`, 2);
+}
+
+if (cmd !== 'map') {
+  const report = `# Fill report — ${template}\n\n## Writes (${writes.length})\n` +
+    (writes.length ? `| Where | Value | Trace |\n| --- | --- | --- |\n` + writes.map((w) => `| ${w.place} | ${w.value} | ${w.trace} |`).join('\n') : '(none)') +
+    `\n\n## Unmapped ([FILL] required)\n` + (unmapped.length ? unmapped.map((u) => `- **${u}** — supply in data.json or fill by hand`).join('\n') : 'none — all mapped') +
+    `\n\nClient template structure untouched; formulas never overwritten.\n`;
+  writeOut(args.report || 'fill-report.md', report);
+  process.stderr.write(`${cmd}: ${writes.length} writes, ${unmapped.length} unmapped\n`);
+  if (cmd === 'check' && unmapped.length) {
+    process.stderr.write(`CHECK FAILED: ${unmapped.length} field(s) still need values ([FILL] list above)\n`);
+    process.exit(1);
+  }
+}