tor-to-proposal 2.1.6 → 2.2.2

package/README.md

@@ -21,7 +21,40 @@ dates, names or client facts. In a domain where one invented fact means
 disqualification (and vendor blacklisting), that is the feature, not a
 limitation.
 
-## Install — one command, once
+## Choose your door
+
+### Door 1 — "I use Claude / ChatGPT / Gemini" (for consultants, not coders)
+
+You never learn the CLI. You talk to your AI; the AI runs the machinery; you
+answer plain questions and paste one brief into the chat per document. One-time
+setup (about five minutes, a couple of copy-paste commands):
+
+**Claude Code users:**
+```bash
+npx skills add ahaomar/tor-to-proposal
+```
+
+**Claude Desktop / other MCP apps** — add the MCP server (see the
+[Technical Guide](docs/TECHNICAL-GUIDE.md) for per-app JSON/config):
+```bash
+claude mcp add tor-to-proposal -- npx -y tor-to-proposal mcp-server
+```
+
+**Any AI chat (no setup at all):** run `npx tor-to-proposal bid-pack start
+--tor tor.pdf --cv cv.pdf --dir mybid/` once with help from the
+[User Guide](docs/USER-GUIDE.md), then copy `out/brief-cover-letter.md` and
+`out/brief-technical-proposal.md` — complete, ready-to-paste prompts — into
+Claude/ChatGPT/Gemini, save the replies into the bid folder, and let the tool
+audit the result. The AI writes; the tool refuses to let it lie.
+
+Then, in your AI, just say: *"Run a bid pack on this folder"* and answer the
+questions it asks you — one at a time, in plain language.
+
+**Never sure what to type?** The full copy-paste conversation script — every
+sentence to say at every stage of a bid — is in
+[docs/CONVERSATION-SCRIPT.md](docs/CONVERSATION-SCRIPT.md).
+
+### Door 2 — "I live in the terminal" (for technical users)
 
 ```bash
 npx tor-to-proposal init
@@ -30,12 +63,9 @@ npx tor-to-proposal init
 That sets up your consultant profile (name, credentials, rates, master CV) at
 `.tor-to-proposal/profile.json` in the **current folder** (the legacy
 `~/.tor-to-proposal/profile.json` is still read if no local profile exists).
-Then use it with any AI assistant (Claude
-Desktop / Claude Code / Codex / ChatGPT) via the MCP server at
-`mcp/server.mjs`, or install the agent skill:
 
 ```bash
-npx skills add ahaomar/tor-to-proposal   # agent users
+npx skills add ahaomar/tor-to-proposal   # install as an agent skill
 ```
 
 Local-first: no network calls carry your documents. The only optional outbound

package/SKILL.md

@@ -101,6 +101,15 @@ Repeat until `0 still open`.
 
 ### Phase 3 — Draft all four documents (you draft, tools gate)
 
+**Non-technical users:** the tool writes ready-to-paste AI briefs at
+`out/brief-cover-letter.md` and `out/brief-technical-proposal.md` after
+`start` and `apply` — each is a self-contained prompt (ToR facts with page
+tags, compliance rows, verified CV evidence, structure, honesty rules). The
+user pastes one into any AI chat, saves the reply as `cover-letter.md` /
+`technical-proposal.md` in `<bid-dir>/`, and the tool audits it. The brief is
+the canonical drafting path for laymen; the manual route below is for agents
+drafting directly.
+
 Write drafts to `<bid-dir>/` as `cover-letter.md`, `technical-proposal.md`
 (`cv-tailored.md` already exists from Phase 1; edit it only with master-CV
 material or user evidence answers).

package/bin/bid-pack.mjs

@@ -202,6 +202,115 @@ function renderPreviews() {
   }
 }
 
+// ---------------- AI briefs ----------------
+// The tool never drafts the cover letter or technical proposal (honesty rule:
+// prose about the user's career must come from the user or their assistant).
+// These briefs make that step concrete: a self-contained prompt the user
+// pastes into ANY AI, containing the ToR facts, requirements, verified CV
+// evidence, the required structure, and the honesty rules. The tool audits
+// the result afterward either way.
+function writeBriefs() {
+  const extractPath = inDir('tor-extract.json');
+  if (!extractPath) return;
+  const extract = JSON.parse(fs.readFileSync(extractPath, 'utf8'));
+  const profile = loadProfile();
+  const context = writeContext();
+  const id = profile?.identity || {};
+  const consultant = `${id.name || '[YOUR NAME]'}${id.credentials ? `, ${id.credentials}` : ''}`;
+  const v = (x) => (x && x.value ? `${x.value}${x.page ? ` (p.${x.page})` : ''}` : 'not stated in the ToR text');
+  const tailoredPath = inDir('cv-tailored.md');
+  const tailored = tailoredPath ? fs.readFileSync(tailoredPath, 'utf8') : '';
+  const matrixPath = inDir('compliance-matrix.md');
+  const matrix = matrixPath ? fs.readFileSync(matrixPath, 'utf8').split('\n').filter((l) => l.trim().startsWith('|') && !/^\|\s*[-:\s|]+\|/.test(l) && !/requirement/i.test(l.split('|')[1] ?? '')).join('\n') : '';
+  const deliverables = (extract.deliverables || []).map((d, i) => `${i + 1}. ${d.value || JSON.stringify(d)}${d.page ? ` (p.${d.page})` : ''}`).join('\n') || '(see compliance matrix below)';
+
+  const shared = `# RULES the drafted document MUST obey (the tool audits every line afterward)
+1. NO superlatives — never write: leading, world-class, renowned, premier, cutting-edge, state-of-the-art, best-in-class, unparalleled, top-tier, foremost, "exceptional expertise", "vast experience". Show evidence instead.
+2. Every fact about the assignment needs a page tag like (p.2). Every fact about the consultant's experience must come ONLY from the VERIFIED EVIDENCE section below — if it is not there, do not write it.
+3. If a required fact is missing, write [FILL: what is missing] instead of inventing it.
+4. Use the client's own vocabulary and terms exactly as they appear in the ToR.
+5. Output ONLY the finished document in markdown. No commentary, no explanation.
+`;
+
+  // ---- cover letter brief ----
+  const cl = `# AI BRIEF — Cover Letter (copy this ENTIRE file into Claude, ChatGPT, Gemini, or any AI)
+
+You are drafting a one-page cover letter for a consultant bidding on the assignment below.
+Consultant: ${consultant}${id.email ? ` | ${id.email}` : ''}${id.phone ? ` | ${id.phone}` : ''}${id.location ? ` | ${id.location}` : ''}
+
+# ASSIGNMENT FACTS (from the ToR — cite these page tags as given)
+- Title: ${v(extract.title)}
+- Reference: ${v(extract.referenceNumber)}
+- Client: ${v(extract.client)}
+- Duration: ${v(extract.duration)}
+- Duty station: ${v(extract.dutyStation)}
+- Submission deadline: ${v(extract.deadline)}${!extract.deadline ? ' — the letter should say the deadline will be confirmed with the client' : ''}
+- Deliverables and dates:
+${deliverables}
+
+# REQUIREMENTS TO ADDRESS (verbatim from the compliance matrix)
+${matrix || '(run bid-pack start first to generate the compliance matrix)'}
+
+# VERIFIED EVIDENCE (the consultant's master CV, already tailored to this ToR — the ONLY experience facts you may use)
+${tailored ? tailored.slice(0, 6000) : '(no CV provided — ask the user for their master CV; do not invent experience)'}
+
+# DECLARED FACTS (the consultant confirmed these; use them verbatim)
+- Availability: ${context.availabilityDate || '[FILL: ask the consultant]'}
+- Proposal validity: ${context.validity || '[FILL: e.g. 90 days from submission]'}
+- Tax treatment: ${context.taxes || '[FILL: ask the consultant]'}
+- Reimbursables: ${context.reimbursables || '[FILL: ask the consultant]'}
+
+${shared}
+# REQUIRED STRUCTURE
+Dear [client committee],
+RE: [exact assignment title] — Reference: [exact ref] (p.X)
+[1 short paragraph: understanding of the assignment, facts only, page-tagged]
+[3–4 short blocks, each: a verbatim requirement (p.X) + matching evidence from VERIFIED EVIDENCE]
+[Compliance paragraph: validity, GCC acceptance, tax, reimbursables]
+[Availability + contact line]
+Sincerely,
+${consultant}
+Keep it under 550 words.
+`;
+
+  // ---- technical proposal brief ----
+  const tp = `# AI BRIEF — Technical Proposal (copy this ENTIRE file into Claude, ChatGPT, Gemini, or any AI)
+
+You are drafting a technical proposal for the same consultant and assignment as the cover letter brief.
+Consultant: ${consultant}
+
+# ASSIGNMENT FACTS (from the ToR — cite these page tags as given)
+- Title: ${v(extract.title)}
+- Reference: ${v(extract.referenceNumber)}
+- Duration: ${v(extract.duration)}
+- Deliverables and dates:
+${deliverables}
+
+# REQUIREMENTS (verbatim from the compliance matrix — cover EVERY row)
+${matrix || '(run bid-pack start first to generate the compliance matrix)'}
+
+# VERIFIED EVIDENCE (master CV — the ONLY experience facts you may use)
+${tailored ? tailored.slice(0, 6000) : '(no CV provided — ask the user for their master CV; do not invent experience)'}
+
+# DECLARED FACTS
+- Availability: ${context.availabilityDate || '[FILL: ask the consultant]'}
+- Validity: ${context.validity || '[FILL]'}
+- Tax: ${context.taxes || '[FILL]'}; Reimbursables: ${context.reimbursables || '[FILL]'}
+
+${shared}
+# REQUIRED STRUCTURE
+# Technical Response — [assignment title] ([reference])
+One section PER DELIVERABLE above (keep the client's own numbering, titles, and dates).
+Each section: Approach (what will be done and why it fits the ToR) -> Steps (numbered) ->
+Quality control (how correctness is checked) -> Relevant experience (ONLY from VERIFIED EVIDENCE).
+End with a short Payment terms section referencing the ToR payment schedule (p.X).
+`;
+
+  writeOut(path.join(outDir, 'brief-cover-letter.md'), cl);
+  writeOut(path.join(outDir, 'brief-technical-proposal.md'), tp);
+  process.stderr.write(`AI briefs written: out/brief-cover-letter.md, out/brief-technical-proposal.md — paste one into any AI chat, save the reply as cover-letter.md / technical-proposal.md in ${dir}\n`);
+}
+
 // ---------------- context ----------------
 function writeContext() {
   const extractPath = inDir('tor-extract.json');
@@ -240,6 +349,21 @@ function start() {
   const torAbs = path.resolve(String(args.tor));
   if (!fs.existsSync(torAbs)) fail(`--tor not found: ${torAbs}`, 2);
 
+  process.stdout.write(
+    `# Inputs checklist — what this bid needs from you\n\n` +
+      `HAVE NOW (verified before anything runs):\n` +
+      `  [x] ToR document — ${path.basename(torAbs)}\n` +
+      `  ${args.cv ? `[x] Master CV — ${path.basename(String(args.cv))}` : `[ ] Master CV — NOT provided (add --cv <file>; the tailored CV and CV gap report will be skipped without it)`}\n\n` +
+      `PRODUCED BY THE TOOL (automatic): bid screen, compliance matrix, CV gap report,\n` +
+      `  tailored CV, pricing, financial proposal, final PDFs + zip.\n\n` +
+      `PRODUCED BY YOU + YOUR AI ASSISTANT (the tool drafts nothing in your name, then\n` +
+      `  verifies every line — this is the honesty rule):\n` +
+      `  [ ] Cover letter — paste out/brief-cover-letter.md into any AI chat, save the reply as cover-letter.md\n` +
+      `  [ ] Technical proposal — paste out/brief-technical-proposal.md, save the reply as technical-proposal.md\n` +
+      `  [ ] Your answers to the bid questions — via: bid-pack ask --dir ${dir}\n\n` +
+      `You will see this exact checklist again at pack time; nothing can be packaged while a box is open.\n\n`
+  );
+
   // 0. ToR -> page-tagged text
   run('pdf-extract.mjs', [torAbs, '--out', path.join(outDir, 'tor.txt'), '--signals', path.join(outDir, 'tor-signals.json')], { fatal: true, label: 'pdf-extract (ToR)' });
   state.steps.torExtract = { status: 'done' };
@@ -273,6 +397,7 @@ function start() {
   state.steps.questions = { status: 'done', open: q.openCount };
   writeState(state);
   renderPreviews();
+  writeBriefs();
 
   // report
   const extract = JSON.parse(fs.readFileSync(path.join(outDir, 'tor-extract.json'), 'utf8'));
@@ -401,6 +526,7 @@ function apply() {
   state.steps.pricing = { status: inDir('pricing.json') ? 'done' : 'awaiting-user-numbers' };
   writeState(state);
   renderPreviews();
+  writeBriefs();
 
   process.stdout.write(
     `# Apply (round ${round}): ${applied} answer(s) recorded, ${fresh.openCount} still open\n\n` +

package/bin/package.mjs

@@ -130,7 +130,7 @@ const verifyMd = (file, key) => {
 
 for (const doc of DOCS) {
   const a = inv[doc.key];
-  if (!a) { checks.push([doc.name, 'MISSING', '—', `produce ${doc.key}.(pdf|docx|xlsx|md) in ${dir} or ${dir}/out`]); hard++; continue; }
+  if (!a) { checks.push([doc.name, 'MISSING', '—', (doc.key === 'cover-letter' || doc.key === 'technical-proposal') ? `paste out/brief-${doc.key}.md into any AI chat, save the reply as ${doc.key}.md in ${dir} or ${dir}/out` : `produce ${doc.key}.(pdf|docx|xlsx|md) in ${dir} or ${dir}/out`]); hard++; continue; }
   let v;
   try {
     v = a.ext === 'pdf' ? await verifyPdf(a.path, doc.key) : a.ext === 'docx' ? await verifyDocx(a.path, doc.key) : a.ext === 'xlsx' ? await verifyXlsx(a.path, doc.key) : verifyMd(a.path, doc.key);

package/docs/CONVERSATION-SCRIPT.md

@@ -0,0 +1,145 @@
+# The conversation script — what to say, step by step
+
+For consultants using Door 1: you live in Claude, ChatGPT, or Gemini, and the
+tool does the verification underneath. This page gives you the **exact
+sentences to type** at every stage of a bid, what you should see back, and
+what to do next. Replace anything in `⟨angle brackets⟩` with your own values.
+
+If a step doesn't behave as described, jump to the [trouble table](#if-something-doesnt-work)
+at the bottom.
+
+---
+
+## Step 0 — One-time setup (5 minutes, once ever)
+
+**Claude Code** (terminal AI) — paste in Terminal:
+```bash
+npx skills add ahaomar/tor-to-proposal
+```
+
+**Claude Desktop / other MCP apps** — paste in Terminal:
+```bash
+claude mcp add tor-to-proposal -- npx -y tor-to-proposal mcp-server
+```
+(or add the JSON from the Prompt Guide to Claude Desktop's config file).
+
+**Then, in your AI chat, say:**
+> List the tor-to-proposal tools you have.
+
+**You should see:** a list of around twenty tools with names like
+`bid_pack_start`, `pricing_model`, `cv_tailor`.
+**If not:** see [USER-GUIDE §7](USER-GUIDE.md) — or skip setup entirely and use
+the zero-setup path in Step 5.
+
+## Step 1 — Your consultant profile (once ever)
+
+> Set up my consultant profile. My name is ⟨Ayesha Khan, PhD⟩, email
+> ⟨ayesha@example.com⟩, my minimum acceptable income is ⟨60000⟩ per year
+> across about ⟨180⟩ billable days, my typical base rate is ⟨400⟩ per day in
+> ⟨USD⟩, and my master CV is at ⟨/Users/me/Documents/cv-master.pdf⟩.
+
+**You should see:** the tool saving `profile.json` (in the current folder) and
+a summary. Your AI will offer these numbers for one-word confirmation on every
+future bid — they are never used without your "yes".
+
+## Step 2 — Start a bid
+
+Put the ToR (PDF or Word) and your master CV in one folder, then say:
+
+> I want to bid on a new assignment. The ToR is ⟨tor.pdf⟩ and my CV is
+> ⟨cv.pdf⟩, both in this folder. Run a bid pack.
+
+**You should see:** a bid screen (title, client, deadline, duration, how you'll
+be scored, red flags) and a set of open questions.
+
+## Step 3 — Go / no-go (your decision, always)
+
+> Show me the bid screen and explain it in plain words. What are the red
+> flags, and is anything unusual?
+
+**You decide:** continue or stop. Nothing is drafted until you say go.
+
+## Step 4 — Answer the questions
+
+> Ask me the open questions one at a time in plain language, then apply my
+> answers. Never suggest a number — ask me for mine.
+
+**You should see:** one question at a time, each with a "how to answer" hint.
+Pricing runs only after you confirm numbers. Answering one round can reveal a
+few more questions when a document is generated for the first time — that is
+normal and converges.
+
+*(Claude Code users can alternatively run `npx tor-to-proposal bid-pack ask --dir .`
+in the Terminal — the wizard asks the same questions.)*
+
+## Step 5 — The drafts (briefs: paste one into any AI)
+
+The tool never writes about your career in your name. Instead it writes a
+**brief** — a complete prompt containing the ToR facts, the requirements, and
+your verified CV evidence.
+
+**With Claude Code or an MCP file-writing assistant, say:**
+> Read out/brief-cover-letter.md and draft my cover letter from it. Follow the
+> brief's rules exactly, save the result as cover-letter.md in the bid folder,
+> then run the cover-letter lint and fix everything you can fix yourself.
+
+> Now do the same with out/brief-technical-proposal.md → technical-proposal.md.
+
+**Zero-setup variant (any AI chat, nothing installed):** open
+`out/brief-cover-letter.md` in any text editor, copy the whole file, paste it
+into Claude/ChatGPT/Gemini, save the reply as `cover-letter.md` in the bid
+folder. Same for the technical brief. The tool audits whatever you save.
+
+## Step 6 — The verification loop
+
+> Lint my cover letter and technical proposal. Fix every problem you can fix
+> yourself, and list anything only I can supply (facts, decisions, missing
+> ToR details) as plain questions.
+
+**You should see:** PASS on both lints, or a short list of remaining items.
+Repeat until the lists are empty. `[FILL]` markers mean "a real fact goes
+here — yours"; the pack refuses to build while any remain.
+
+## Step 7 — Build the submission pack
+
+> Run the final pack. Tell me exactly where the PDFs and the zip are, and
+> whether the audit passed.
+
+**You should see:** `PACK READY`, the audit line **PASS**, and the locations:
+`pack/` (four verified documents + submission checklist + calendar file) and
+`⟨ref⟩-bid-pack.zip`.
+
+## Step 8 — Pre-submit checklist (before you upload anything)
+
+> What must I still confirm with the client before submitting? List anything
+> not verified from the ToR: deadline, submission channel, clarifications, and
+> any date conflicts (for example my availability vs their deliverable dates).
+
+**You should see:** a short, honest list. Typical items: a deadline the ToR
+text didn't state, the submission channel, and evaluation weights that don't
+sum. Send these to the client BEFORE their clarification cutoff.
+
+## Step 9 — Submit, then record the outcome
+
+Submit the zip through the confirmed channel, in their time zone. When the
+client announces the decision:
+
+> The result came out: ⟨won / lost⟩ at ⟨the fee⟩. Save a one-paragraph outcome
+> note (assignment, ref, fee, result, what I quoted) in the bid folder so I
+> keep a record of my pricing history.
+
+---
+
+## If something doesn't work
+
+| Symptom | First thing to say to your AI |
+| --- | --- |
+| Tool list is empty after setup | "Reconnect the tor-to-proposal MCP server and list your tools again." (Check the Prompt Guide's config for your app.) |
+| "OCR required" / scanned PDF error | "The PDF seems scanned. Tell me how to OCR it, then retry." |
+| A question you can't answer | "Mark it [FILL] and move on — I'll come back to it." |
+| The pack says FAIL or MISSING | "Show me the pack report and explain each failed line in plain words, with the exact next action." |
+| Your AI invents a number or fact | "That has no source. Mark it [FILL] and ask me instead." |
+
+Everything in this script maps to the commands documented in the
+[Technical Guide](TECHNICAL-GUIDE.md); the plain-language background is in the
+[User Guide](USER-GUIDE.md).

package/docs/PROMPT-GUIDE.md

@@ -9,6 +9,10 @@ The working pattern is always the same:
 the tools enforce the honesty rules.** When you see `[FILL]`, that's a
 question addressed to you.
 
+**New to this? Start with the [Conversation Script](CONVERSATION-SCRIPT.md)** —
+the exact sentences to type at every stage of a bid, in order. This guide is
+the deeper prompt library behind it.
+
 ---
 
 ## 1. Setup per assistant (one-time)
@@ -82,10 +86,14 @@ I am bidding on a consultancy. Run the full tor-to-proposal bid pack
 
 Rules for you:
 - Start with bid_pack_start, then show me the bid screen — I decide go/no-go.
-- Then put EVERY question from out/questions.md to me in ONE message. I answer
-  once; write my answers to answers.json and run bid_pack_apply. Repeat until
-  zero open. Never invent an answer, never ask questions one by one.
-- Drafts get linted/simulated/audited with the tools; fix and loop until they pass.
+- Then ask me the open questions ONE AT A TIME in plain language (each has a
+  "how to answer" hint in questions.md). I answer in words; write my answers
+  to answers.json and run bid_pack_apply. Repeat until zero open — new
+  questions can appear when a document is first rendered; that is normal.
+  Never invent an answer and never suggest a number.
+- Drafts come from the AI briefs: draft from out/brief-cover-letter.md and
+  out/brief-technical-proposal.md, then lint/simulate/audit with the tools;
+  fix and loop until they pass.
 - Finish with the four PDFs rendered per references/render-specs.md and
   bid_pack_pack. Deliver pack/ + submission-checklist.md. Nothing is "done"
   while pack exits non-zero.
@@ -142,21 +150,23 @@ show every formula. Finally position my rate against the cited band.
 
 **Cover letter:**
 ```text
-Draft a one-page cover letter per assets/templates.md: verbatim title + ref +
-deadline block, 2-sentence understanding from Background/Objectives only, fit
-section quoting 3–5 JD requirements (p.X) with my CV evidence — mark [FILL]
-where I haven't given you evidence yet — compliance declarations, availability
-per the ToR start date. Then lint it with cover_letter_lint and fix everything
-it flags. No superlatives.
+Draft my cover letter from the brief: read out/brief-cover-letter.md and
+follow it exactly — it already contains the ToR facts, the compliance rows,
+my verified CV evidence, the required structure, and the honesty rules.
+Save the result as cover-letter.md in the bid folder, then lint it with
+cover_letter_lint and fix everything it flags. Where the brief says [FILL],
+ask me for the fact instead of inventing it. No superlatives.
 ```
 
 **Technical response + self-score:**
 ```text
-Draft the technical response: one section per scored criterion, highest weight
-first, in the client's vocabulary, every deliverable addressed. Extract the
-sub-elements of each criterion verbatim into sub-elements.json, then run
-simulate and give me the at-risk points. Loop with me: rewrite the weakest
-criterion, re-simulate, until at-risk ≈ 0.
+Draft my technical proposal from the brief: read out/brief-technical-proposal.md
+and follow it exactly — one section per deliverable/criterion, in the client's
+vocabulary, experience facts only from the brief's VERIFIED EVIDENCE section.
+Save it as technical-proposal.md, then extract the sub-elements of each
+criterion verbatim into sub-elements.json, run simulate, and give me the
+at-risk points. Loop with me: rewrite the weakest criterion, re-simulate,
+until at-risk ≈ 0.
 ```
 
 **Their forms:**

package/docs/USER-GUIDE.md

@@ -44,13 +44,25 @@ Gather these into one folder on your computer (e.g. `Documents/bids/UNDP-2026-04
 | 3 | Your **money numbers** | Your minimum acceptable yearly income, your monthly costs (for pricing) |
 | 4 | Your **calendar** | So you can honestly answer "can I start when they need me?" |
 
+**Who produces what — important:** the tool prepares, verifies, and packages. It deliberately does not write two documents for you:
+
+| Document | Who produces it |
+| --- | --- |
+| Bid screen, CV gap report, tailored CV, financial proposal, pricing | **The tool** — fully automatic |
+| **Cover letter** and **technical proposal** | **You + your AI assistant** draft them (the tool gives you the template in `assets/templates.md`, the ToR extract, and your tailored CV; the tool then lints and audits every line) |
+| Answers to the bid questions (price, dates, facts) | **You** — via the `bid-pack ask` wizard |
+
+A submission can never be packaged while anything is missing — the `pack` gate will list exactly what is absent.
+
 ---
 
 ## 3. How you use it (one conversation)
 
 You talk to Claude (or ChatGPT, Codex, or similar) in normal English. The AI
 runs everything and explains the results. You never see a command line unless
-you want to.
+you want to. (Not sure what to say at each step? The
+[Conversation Script](CONVERSATION-SCRIPT.md) gives you the exact sentences,
+in order.)
 
 **One-time setup (5 minutes):** install once with a single command and connect
 your AI assistant (exact keystrokes in §4). Then say things like:
@@ -152,10 +164,17 @@ a green ✔ MATCH table and red **"GAP — do not claim"** lines. Those GAP line
 must not appear anywhere in your bid, no matter how tempting — the tool
 enforces it.
 
-**Step 4 — The drafts.** A one-page cover letter and a technical response with
-**one section per scoring criterion**, quoting the ToR with page numbers.
-Places it can't fill honestly appear as `[FILL]` — answer them and the drafts
-are re-checked automatically.
+**Step 4 — The drafts (paste a brief into your AI).** The tool never writes a
+cover letter or technical proposal in your name — a document about YOUR career
+must come from YOUR facts. Instead it writes two **AI briefs** for you:
+`out/brief-cover-letter.md` and `out/brief-technical-proposal.md`. Each brief
+is a complete, ready-to-paste prompt containing the ToR facts with page
+numbers, every requirement, your verified CV evidence, the required structure,
+and the honesty rules. **Copy the whole file, paste it into Claude/ChatGPT/
+Gemini, save the reply as `cover-letter.md` / `technical-proposal.md` in your
+bid folder.** The tool then lints and audits every line of what the AI wrote —
+superlatives, invented facts, and untraceable claims are rejected with the
+exact line number.
 
 **Step 5 — The self-score.** The tool scores your draft against their grid:
 *"Criterion 3 (25 pts): 2 of 3 sub-elements covered; missing: sustainability

package/mcp/server.mjs

@@ -322,7 +322,7 @@ function handle(msg) {
     return {
       protocolVersion: typeof params?.protocolVersion === 'string' ? params.protocolVersion : '2024-11-05',
       capabilities: { tools: {} },
-      serverInfo: { name: 'tor-to-proposal', version: '2.1.6' },
+      serverInfo: { name: 'tor-to-proposal', version: '2.2.2' },
     };
   }
   if (typeof method === 'string' && method.startsWith('notifications/')) return undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tor-to-proposal",
-  "version": "2.1.6",
+  "version": "2.2.2",
   "description": "The bid tool that refuses to lie. ToR + CV in -> verified bid pack out: cover letter, tailored CV, technical response, financial proposal, submission checklist. Deterministic CLI + agent skill for UN / NGO / government consultants.",
   "type": "module",
   "bin": {