@forwardimpact/outpost 3.12.0 → 3.13.0

package/templates/.claude/skills/req-bundle/scripts/split-bundle.mjs

@@ -0,0 +1,377 @@
+#!/usr/bin/env node
+/**
+ * Split a Workday CV-bundle PDF into per-candidate CV.pdf files.
+ *
+ * Workday's "bundle" export concatenates every candidate's attachments (CV,
+ * cover letter, certificates) into one PDF with NO per-candidate separator page.
+ * The only reliable delimiter is the PDF outline (bookmarks): exactly one flat,
+ * depth-0 bookmark per candidate whose destination is that candidate's first
+ * page. Candidate i occupies pages [bookmark(i), bookmark(i+1) - 1]; the last
+ * candidate runs to the end of the file. Everything before the first bookmark is
+ * the front-matter Table of Contents and is skipped.
+ *
+ * This script reads the outline (pdfjs-dist), matches each bookmark title to a
+ * canonical candidate name from the parsed Workday roster (so folder names agree
+ * with req-workday), extracts the page range losslessly (pdf-lib), and writes it
+ * to 2-Confidential/Candidates/{Clean Name}/CV.pdf.
+ *
+ * It ALWAYS emits a JSON manifest describing every mapping and never overwrites
+ * an existing CV.pdf. With --dry-run it computes the manifest without touching
+ * disk. Multi-part bundles (`..._1_of_4.pdf` … `_4_of_4.pdf`) are self-contained:
+ * pass all parts as positional arguments; each part is processed independently.
+ *
+ * The roster is the stdout JSON of req-workday/scripts/parse-workday.mjs
+ * ({ requisition, candidates: [{ name, cleanName, ... }] }) — the single source
+ * of truth for candidate names, so this script needs no XLSX parser of its own.
+ *
+ * Requires (bun install): pdfjs-dist, pdf-lib.
+ *
+ * Usage:
+ *   node split-bundle.mjs <bundle.pdf> [<bundle2.pdf> ...] \
+ *       --roster <roster.json> \
+ *       --candidates-dir <2-Confidential/Candidates> \
+ *       --manifest <out.json> \
+ *       [--dry-run]
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
+
+let PDFDocument, pdfjs;
+try {
+  ({ PDFDocument } = await import("pdf-lib"));
+  pdfjs = await import("pdfjs-dist/legacy/build/pdf.mjs");
+} catch {
+  console.error(
+    "Error: pdfjs-dist and/or pdf-lib not found. Install them first:\n  bun install pdfjs-dist pdf-lib",
+  );
+  process.exit(1);
+}
+
+// --- CLI parsing --------------------------------------------------------------
+
+if (
+  process.argv.includes("-h") ||
+  process.argv.includes("--help") ||
+  process.argv.length < 3
+) {
+  console.log(`split-bundle — split a Workday CV bundle into per-candidate CV.pdf by PDF bookmarks
+
+Usage:
+  node split-bundle.mjs <bundle.pdf> [<bundle2.pdf> ...] --roster <roster.json> \\
+       --candidates-dir <dir> --manifest <out.json> [--dry-run]
+
+  <roster.json> is the stdout of req-workday/scripts/parse-workday.mjs.`);
+  process.exit(process.argv.length < 3 ? 1 : 0);
+}
+
+function optValue(name) {
+  const i = process.argv.indexOf(name);
+  return i >= 0 && i + 1 < process.argv.length
+    ? process.argv[i + 1]
+    : undefined;
+}
+
+const dryRun = process.argv.includes("--dry-run");
+const rosterPath = optValue("--roster");
+const candidatesDir = optValue("--candidates-dir");
+const manifestPath = optValue("--manifest");
+const FLAGS_WITH_VALUE = new Set([
+  "--roster",
+  "--candidates-dir",
+  "--manifest",
+]);
+const bundles = process.argv.slice(2).filter((a, i, arr) => {
+  if (a.startsWith("--")) return false;
+  const prev = arr[i - 1];
+  return !(prev && FLAGS_WITH_VALUE.has(prev)); // drop values consumed by flags
+});
+
+if (!candidatesDir || !manifestPath || bundles.length === 0) {
+  console.error(
+    "Error: need <bundle.pdf...>, --candidates-dir, and --manifest.",
+  );
+  process.exit(1);
+}
+
+// --- Name normalization & matching -------------------------------------------
+
+const SUFFIX_RE = /\b(internal|referral|prior worker|external|contractor)\b/gi;
+const PAREN_RE = /\([^)]*\)/g;
+
+/** Fold a display name to a comparable key: no parentheticals, no diacritics,
+ * lowercase alphanumerics only, whitespace collapsed. */
+function normalize(name) {
+  let s = name || "";
+  s = s.replace(PAREN_RE, " ").replace(SUFFIX_RE, " ");
+  s = s.normalize("NFKD").replace(/\p{M}/gu, ""); // strip combining accents
+  s = s.toLowerCase().replace(/[^a-z0-9\s]/g, " ");
+  return s.replace(/\s+/g, " ").trim();
+}
+
+/** Make a bookmark title safe as a directory name (used only when unmatched). */
+function sanitizeFolder(title) {
+  const s = (title || "").replace(/[/\\]/g, "-").replace(/\s+/g, " ").trim();
+  return s || "UNKNOWN";
+}
+
+class Roster {
+  constructor(candidates) {
+    this.byExact = new Map(); // normalized name -> canonical cleanName
+    this.byTokens = new Map(); // sorted-token key -> canonical cleanName
+    this.all = []; // [{ key, clean }]
+    for (const c of candidates) {
+      const clean = (c.cleanName || c.name || "").trim();
+      if (!clean) continue;
+      const key = normalize(clean);
+      if (!key) continue;
+      if (!this.byExact.has(key)) this.byExact.set(key, clean);
+      const tkey = key.split(" ").sort().join(" ");
+      if (!this.byTokens.has(tkey)) this.byTokens.set(tkey, clean);
+      this.all.push({ key, clean });
+    }
+  }
+
+  /** Return { clean, method } — conservative: exact key, then token-set equality. */
+  match(title) {
+    const key = normalize(title);
+    if (!key) return { clean: null, method: "unmatched" };
+    if (this.byExact.has(key))
+      return { clean: this.byExact.get(key), method: "exact" };
+    const tkey = key.split(" ").sort().join(" ");
+    if (this.byTokens.has(tkey))
+      return { clean: this.byTokens.get(tkey), method: "token-set" };
+    return { clean: null, method: "unmatched" };
+  }
+
+  /** Nearest roster names by shared-token count — helps a human resolve a miss. */
+  hints(title, limit = 3) {
+    const tokens = new Set(normalize(title).split(" ").filter(Boolean));
+    const scored = [];
+    for (const { key, clean } of this.all) {
+      const shared = key.split(" ").filter((t) => tokens.has(t)).length;
+      if (shared) scored.push({ shared, clean });
+    }
+    scored.sort(
+      (a, b) => b.shared - a.shared || a.clean.localeCompare(b.clean),
+    );
+    const out = [];
+    for (const { clean } of scored) {
+      if (!out.includes(clean)) out.push(clean);
+      if (out.length >= limit) break;
+    }
+    return out;
+  }
+}
+
+// --- PDF outline handling -----------------------------------------------------
+
+/** Return [{ title, page }] (0-based page index) for every outline destination,
+ * in document order. pdfjs resolves both named and explicit destinations. */
+async function readOutline(doc) {
+  const outline = (await doc.getOutline()) || [];
+  const items = [];
+
+  async function pageIndex(dest) {
+    const explicit =
+      typeof dest === "string" ? await doc.getDestination(dest) : dest;
+    if (!Array.isArray(explicit) || !explicit[0]) return null;
+    try {
+      return await doc.getPageIndex(explicit[0]);
+    } catch {
+      return null;
+    }
+  }
+
+  // Flatten defensively (Workday bundles are flat, depth-0).
+  const stack = [...outline];
+  while (stack.length) {
+    const node = stack.shift();
+    const page = await pageIndex(node.dest);
+    if (node.title != null && page != null)
+      items.push({ title: String(node.title), page });
+    if (Array.isArray(node.items) && node.items.length)
+      stack.unshift(...node.items);
+  }
+  items.sort((a, b) => a.page - b.page);
+  return items;
+}
+
+function partLabel(path) {
+  const m = basename(path).match(/_(\d+)_of_(\d+)\b/);
+  return m ? `${m[1]}/${m[2]}` : null;
+}
+
+// --- Main ---------------------------------------------------------------------
+
+let requisition = {};
+let rosterCandidates = [];
+if (rosterPath && existsSync(rosterPath)) {
+  const data = JSON.parse(readFileSync(rosterPath, "utf8"));
+  rosterCandidates = data.candidates || [];
+  requisition = data.requisition || {};
+}
+const roster = new Roster(rosterCandidates);
+
+const entries = [];
+const matchedClean = new Set(); // normalized cleanNames that got a bookmark
+const folderWritten = new Map(); // folder -> count (within this run, for collisions)
+
+for (const bundle of bundles) {
+  // pdfjs detaches the ArrayBuffer it's handed, so give each library its own copy.
+  const doc = await pdfjs.getDocument({
+    data: new Uint8Array(readFileSync(bundle)),
+    useSystemFonts: true,
+    verbosity: 0,
+  }).promise;
+  const outline = await readOutline(doc);
+  const part = partLabel(bundle);
+
+  if (outline.length === 0) {
+    entries.push({
+      bundle,
+      part,
+      status: "no-outline",
+      note: "No PDF bookmarks found — cannot split this file by candidate.",
+    });
+    continue;
+  }
+
+  // pdf-lib source (only loaded when we actually extract).
+  let src = null;
+  let total = 0;
+  if (!dryRun) {
+    src = await PDFDocument.load(new Uint8Array(readFileSync(bundle)));
+    total = src.getPageCount();
+  } else {
+    total = doc.numPages;
+  }
+
+  for (let i = 0; i < outline.length; i++) {
+    const start = outline[i].page;
+    const end = i + 1 < outline.length ? outline[i + 1].page - 1 : total - 1;
+    const title = outline[i].title;
+    const { clean, method } = roster.match(title);
+    const matched = clean != null;
+    let folder, status, hints;
+    if (matched) {
+      matchedClean.add(normalize(clean));
+      folder = clean;
+      status = "matched";
+      hints = [];
+    } else {
+      folder = sanitizeFolder(title);
+      status = "unmatched";
+      hints = roster.hints(title);
+    }
+
+    const destDir = join(candidatesDir, folder);
+    const cvPath = join(destDir, "CV.pdf");
+    const seen = folderWritten.get(folder) || 0;
+    const existingCv = existsSync(cvPath);
+    let outName;
+    if (seen > 0) {
+      outName = `CV-dup-${seen + 1}.pdf`;
+      if (matched) status = "collision";
+    } else if (existingCv) {
+      outName = "CV-workday.pdf";
+      if (matched) status = "existing-cv";
+    } else {
+      outName = "CV.pdf";
+    }
+    folderWritten.set(folder, seen + 1);
+    const outPath = join(destDir, outName);
+
+    let action = dryRun ? "would-write" : "pending";
+    if (!dryRun) {
+      try {
+        mkdirSync(destDir, { recursive: true });
+        const out = await PDFDocument.create();
+        const idxs = [];
+        for (let p = start; p <= end; p++) idxs.push(p);
+        const copied = await out.copyPages(src, idxs);
+        for (const pg of copied) out.addPage(pg);
+        writeFileSync(outPath, await out.save());
+        action = "wrote";
+      } catch (exc) {
+        action = `error: ${exc.message || exc}`;
+      }
+    }
+
+    entries.push({
+      bundle,
+      part,
+      order: i + 1,
+      title,
+      page_start: start + 1, // 1-based for humans
+      page_end: end + 1,
+      page_count: end - start + 1,
+      matched,
+      match_method: method,
+      clean_name: clean || "",
+      folder,
+      status,
+      out_path: outPath,
+      action,
+      hints,
+    });
+  }
+}
+
+const rosterUnmatched = [
+  ...new Set(
+    rosterCandidates
+      .map((c) => c.cleanName || c.name)
+      .filter((n) => n && !matchedClean.has(normalize(n))),
+  ),
+].sort();
+
+const bookmarkEntries = entries.filter((e) => "title" in e);
+const summary = {
+  bundles: bundles.length,
+  bookmarks_total: bookmarkEntries.length,
+  matched: bookmarkEntries.filter((e) => e.matched).length,
+  unmatched_bookmarks: bookmarkEntries.filter((e) => !e.matched).length,
+  collisions: bookmarkEntries.filter((e) => e.status === "collision").length,
+  existing_cv: bookmarkEntries.filter((e) => e.status === "existing-cv").length,
+  roster_total: rosterCandidates.length,
+  roster_unmatched: rosterUnmatched.length,
+};
+
+const manifest = {
+  generated_from: bundles,
+  requisition,
+  candidates_dir: candidatesDir,
+  dry_run: dryRun,
+  summary,
+  entries,
+  roster_unmatched_names: rosterUnmatched,
+};
+writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+
+// Human summary to stdout.
+const mode = dryRun ? "DRY RUN — nothing written" : "COMMIT";
+console.log(
+  `[${mode}] ${requisition.id || "?"} ${requisition.title || ""}`.trimEnd(),
+);
+console.log(`  bundles:            ${summary.bundles}`);
+console.log(`  bookmarks:          ${summary.bookmarks_total}`);
+console.log(`  matched → roster:   ${summary.matched}`);
+console.log(`  unmatched bookmark: ${summary.unmatched_bookmarks}`);
+console.log(`  collisions (dupes): ${summary.collisions}`);
+console.log(`  existing CV.pdf:    ${summary.existing_cv}`);
+console.log(
+  `  roster w/o bookmark:${summary.roster_unmatched} (of ${summary.roster_total})`,
+);
+console.log(`  manifest:           ${manifestPath}`);
+if (summary.unmatched_bookmarks) {
+  console.log("  ⚠ unmatched bookmarks (resolve in the manifest):");
+  for (const e of bookmarkEntries) {
+    if (!e.matched) {
+      const hint = e.hints.length ? `  ~ ${e.hints.join(", ")}` : "";
+      console.log(
+        `      - "${e.title}" (p${e.page_start}-${e.page_end})${hint}`,
+      );
+    }
+  }
+}

package/templates/.claude/skills/req-decide/SKILL.md

@@ -9,8 +9,11 @@ description: >
 
 # Hiring Decision
 
+Write tier: `2-Confidential`
+Frontmatter: candidate (stamps `status`, `updated`)
+
 Synthesize all available evidence for a candidate into a final hiring
-recommendation. This is the culmination of the hiring pipeline — every prior
+recommendation. This is the culmination of the hiring pipeline. Every prior
 assessment feeds in.
 
 This is **Stage 3** of the three-stage pipeline:
@@ -29,41 +32,46 @@ This is **Stage 3** of the three-stage pipeline:
 ## Prerequisites
 
 - `fit-pathway` CLI installed.
-- `Knowledge/Candidates/{Name}/screening.md` exists.
-- At least one `Knowledge/Candidates/{Name}/interview-*.md`.
-- `Knowledge/Candidates/{Name}/brief.md` exists.
+- `2-Confidential/Candidates/{Name}/screening.md` exists.
+- At least one `2-Confidential/Candidates/{Name}/interview-*.md`.
+- `2-Confidential/Candidates/{Name}/brief.md` exists.
 
 ## Inputs
 
-- All artifacts in `Knowledge/Candidates/{Name}/`.
+- All artifacts in `2-Confidential/Candidates/{Name}/`.
 - Standard data via `fit-pathway`.
-- `Knowledge/Candidates/Insights.md` — cross-candidate context.
-- `Knowledge/Roles/*.md` — the candidate's requisition (positions, hiring
+- `2-Confidential/Candidates/Insights.md` — cross-candidate context.
+- `2-Confidential/Roles/*.md` — the candidate's requisition (positions, hiring
   manager, domain lead). Check the `**Status:**` field to distinguish active
   from historical reqs.
-- `Knowledge/Priorities/*.md` — strategic context.
-- Other active candidates at the same level — relative positioning.
+- `3-Team/Priorities/*.md` — strategic context.
+- Other active candidates at the same level — relative position.
 
 ## Outputs
 
-- `Knowledge/Candidates/{Name}/recommendation.md` — final recommendation.
-- Updated `Knowledge/Candidates/{Name}/brief.md` — status and link.
-- Updated `Knowledge/Candidates/Insights.md` — cross-candidate observations.
+- `2-Confidential/Candidates/{Name}/recommendation.md` — final recommendation.
+- Updated `2-Confidential/Candidates/{Name}/brief.md` — status, link, and
+  frontmatter `status` and `updated` stamped.
+- Updated `2-Confidential/Candidates/Insights.md` — cross-candidate
+  observations.
 
 <do_confirm_checklist goal="Verify the recommendation is grounded and
 audit-ready">
 
-- [ ] Every skill rating traces to a specific evidence source (stage + detail).
-- [ ] Evidence hierarchy respected — interview evidence outranks CV.
-- [ ] Level recommendation grounded in standard progression criteria.
-- [ ] Track recommendation cites interview evidence, not just CV.
-- [ ] Decision rules applied strictly; match % and gap counts verified.
-- [ ] Risk assessment is honest — concerns not minimised to justify a hire.
-- [ ] "Do not hire" written with the same rigour as "Hire" (GDPR Article 15:
-      candidate may request access).
-- [ ] Brief updated with `[Hiring Recommendation](./recommendation.md)` and a
-      final pipeline entry.
-- [ ] Recommendation could be shown to the candidate without embarrassment.
+- [ ] Trace every skill rating to a specific evidence source (stage + detail).
+- [ ] Respect the evidence hierarchy. Interview evidence outranks CV.
+- [ ] Ground the level recommendation in standard progression criteria.
+- [ ] Cite interview evidence for the track recommendation. A CV alone is not
+      enough.
+- [ ] Apply the decision rules strictly. Verify the match % and the gap counts.
+- [ ] Keep the risk assessment honest. Do not minimise a concern to justify a
+      hire.
+- [ ] Write "Do not hire" with the same rigour as "Hire" (GDPR Article 15 lets
+      the candidate request access).
+- [ ] Update the brief with `[Hiring Recommendation](./recommendation.md)` and
+      a final pipeline entry.
+- [ ] Write a recommendation you could show to the candidate without
+      embarrassment.
 
 </do_confirm_checklist>
 
@@ -72,7 +80,7 @@ audit-ready">
 ### 1. Gather all evidence
 
 ```bash
-ls Knowledge/Candidates/{Name}/
+ls 2-Confidential/Candidates/{Name}/
 ```
 
 Read in order: `brief.md`, `screening.md`, every `interview-*.md`, relevant
@@ -86,9 +94,10 @@ bunx fit-pathway job {discipline} {level} --track={track} --skills
 bunx fit-pathway progress {discipline} {level} --track={track}
 ```
 
-For each skill in the target job, pick the highest-fidelity evidence using the
-[evidence hierarchy](references/rubric.md#evidence-hierarchy). Record final
-rating, best evidence source, trajectory, confidence.
+For each skill in the target job, use the
+[evidence hierarchy](references/rubric.md#evidence-hierarchy) to pick the
+highest-fidelity evidence. Record final rating, best evidence source,
+trajectory, confidence.
 
 ### 3. Build the final behaviour profile
 
@@ -115,21 +124,20 @@ Apply the level-confirmation criteria in
 If `brief.md` carries a `Req`:
 
 ```bash
-ls Knowledge/Roles/ | grep "{req_number}"
-cat "Knowledge/Roles/{matching file}"
+ls 2-Confidential/Roles/ | grep "{req_number}"
+cat "2-Confidential/Roles/{matching file}"
 ```
 
 Check the `**Status:**` field. Capture remaining positions, hiring manager,
-domain lead, goal alignment, other
-candidates on the same req, and channel (hr / vendor). Frame the recommendation
-in terms of strategic impact.
+domain lead, goal alignment, other candidates on the same req, and channel
+(hr / vendor). Frame the recommendation in terms of strategic impact.
 
 ### 6. Assess against the active pipeline
 
 ```bash
-cat Knowledge/Candidates/Insights.md
+cat 2-Confidential/Candidates/Insights.md
 
-for dir in Knowledge/Candidates/*/; do
+for dir in 2-Confidential/Candidates/*/; do
   if [ -f "$dir/screening.md" ]; then
     head -5 "$dir/screening.md"
   fi
@@ -146,9 +154,10 @@ Apply the [decision rules](references/rubric.md#decision-rules) and run the
 
 ### 8. Write the recommendation
 
-Save to `Knowledge/Candidates/{Name}/recommendation.md` using the template in
-[references/template.md](references/template.md). Carry the **advisory-only**
-banner. Cite specific evidence in skill, behaviour, level, and track sections.
+Use the template in [references/template.md](references/template.md). Save to
+`2-Confidential/Candidates/{Name}/recommendation.md`. Carry the
+**advisory-only** banner. Cite specific evidence in skill, behaviour, level, and
+track sections.
 
 ### 9. Update brief and insights
 
@@ -157,9 +166,11 @@ Update `brief.md`:
 - Set `Status` to `recommended` or `not-recommended`.
 - Append `- [Hiring Recommendation](./recommendation.md)`.
 - Add the final pipeline entry with date and outcome.
+- Stamp the frontmatter: set `updated` to the decision date and `status` to
+  the closest registry value (agents select from `registry.yaml`).
 
-Update `Knowledge/Candidates/Insights.md` only when there's a cross-candidate
-observation worth keeping (strongest at level, sourcing channel pattern,
-level-adjustment implications).
+Update `2-Confidential/Candidates/Insights.md` only when a cross-candidate
+observation deserves a record (strongest at level, a pattern in the sourcing
+channel, level-adjustment implications).
 
-Use targeted Edit operations — never rewrite entire files.
+Use targeted Edit operations. Never rewrite entire files.

package/templates/.claude/skills/req-decide/references/rubric.md

@@ -13,8 +13,9 @@ applies and use it as the source of the final rating.
    answers.
 3. **Interviewer observation** — an interviewer noted strength or concern.
 4. **CV evidence with quantification** — concrete metrics, named projects.
-5. **CV evidence without quantification** — described but vague.
-6. **Not evidenced** — never surfaced across any stage.
+5. **CV evidence without quantification** — the CV describes it but stays
+   vague.
+6. **Not evidenced** — no stage surfaced it.
 
 For each skill record: **final rating**, **best evidence source**,
 **trajectory** (↑ / ↓ / —), **confidence** (High = demonstrated live; Medium =
@@ -22,9 +23,9 @@ discussed well; Low = CV only or thin).
 
 ## Behaviour evidence
 
-Same hierarchy. Behaviours assessed in interviews carry far more weight than CV
-signals. For each: **final maturity**, **best evidence** (specific moment or
-pattern), **consistency** (once vs. throughout).
+Same hierarchy. A behaviour that an interview assessed carries far more weight
+than a CV signal. For each: **final maturity**, **best evidence** (specific
+moment or pattern), **consistency** (once vs. throughout).
 
 ## Level confirmation criteria
 
@@ -41,7 +42,7 @@ pattern), **consistency** (once vs. throughout).
 | Recommendation             | Criteria                                                                                  |
 | -------------------------- | ----------------------------------------------------------------------------------------- |
 | **Hire**                   | ≥ 70 % Strong match at the final level, no unresolved core-skill gaps, strong behaviours  |
-| **Hire at adjusted level** | Strong candidate; evidence supports a different level than originally targeted            |
+| **Hire at adjusted level** | Strong candidate. The evidence supports a level other than the original target            |
 | **Do not hire**            | Unresolved core-skill gaps, behaviour concerns, or insufficient evidence after interviews |
 
 ### Hire criteria check
@@ -50,14 +51,14 @@ pattern), **consistency** (once vs. throughout).
 - No core skill gaps remain unresolved (core = top-tier skills for the
   discipline/track combo).
 - All agent-aligned standard behaviours at or above expected maturity.
-- Level confirmed by interview evidence (not just CV).
-- Track fit confirmed by interview evidence.
+- Interview evidence confirms the level. The CV alone does not.
+- Interview evidence confirms the track fit.
 - No red flags from any interview stage.
 
 ## Pipeline context (Step 5)
 
-This is **not** a ranking exercise — it provides context. Note:
+This is **not** a ranking exercise. It gives context. Note:
 
 - Whether this candidate fills a gap in the current pipeline.
 - Whether stronger candidates exist for the same role.
-- Whether this candidate is better suited to a different open position.
+- Whether a different open position suits this candidate better.

package/templates/.claude/skills/req-decide/references/template.md

@@ -1,7 +1,7 @@
 # Recommendation Template
 
-Reference template for `req-decide` Step 6. Save to
-`Knowledge/Candidates/{Name}/recommendation.md`.
+Reference template for `req-decide` Step 8. Save to
+`2-Confidential/Candidates/{Name}/recommendation.md`.
 
 ```markdown
 # Hiring Recommendation — {Full Name}