@forwardimpact/basecamp 2.3.1 → 2.4.0

package/README.md

@@ -165,6 +165,25 @@ vi ~/.fit/basecamp/scheduler.json
 { "type": "once", "runAt": "2025-02-12T10:00:00Z" }
 ```
 
+## Updating
+
+When you upgrade Basecamp (install a new `.pkg`), the installer automatically
+runs `--update` on all configured knowledge bases. This pushes the latest
+`CLAUDE.md`, skills, and agents into each KB without touching your data.
+
+You can also run it manually at any time:
+
+```bash
+# Update all configured knowledge bases
+/Applications/Basecamp.app/Contents/MacOS/fit-basecamp --update
+
+# Update a specific knowledge base
+/Applications/Basecamp.app/Contents/MacOS/fit-basecamp --update ~/Documents/Personal
+```
+
+The update merges `.claude/settings.json` non-destructively — new entries are
+added but your existing permissions are preserved.
+
 ## CLI Reference
 
 ```
@@ -172,6 +191,7 @@ fit-basecamp                     Run due tasks once and exit
 fit-basecamp --daemon            Run continuously (poll every 60s)
 fit-basecamp --run <task>        Run a specific task immediately
 fit-basecamp --init <path>       Initialize a new knowledge base
+fit-basecamp --update [path]     Update KB skills, agents, and CLAUDE.md
 fit-basecamp --status            Show knowledge bases and task status
 fit-basecamp --validate          Validate agents and skills exist
 fit-basecamp --help              Show this help

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forwardimpact/basecamp",
-  "version": "2.3.1",
+  "version": "2.4.0",
   "description": "Claude Code-native personal knowledge system with autonomous agents",
   "license": "Apache-2.0",
   "repository": {
@@ -28,5 +28,8 @@
   ],
   "engines": {
     "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "xlsx": "^0.18.5"
   }
 }

package/template/.claude/skills/workday-requisition/SKILL.md

@@ -0,0 +1,341 @@
+---
+name: workday-requisition
+description: >
+  Import candidates from a Workday requisition export (.xlsx) into
+  knowledge/Candidates/. Parses requisition metadata and candidate data,
+  creates candidate briefs and CV.md files from resume text, and integrates
+  with the existing track-candidates pipeline. Use when the user provides a
+  Workday export file or asks to import candidates from an XLSX requisition
+  export.
+---
+
+# Workday Requisition Import
+
+Import candidates from a Workday requisition export (`.xlsx`) into
+`knowledge/Candidates/`. Extracts requisition metadata and candidate profiles,
+creates standardized candidate briefs and `CV.md` files from the embedded resume
+text, and integrates with the existing `track-candidates` pipeline format.
+
+## Trigger
+
+Run this skill:
+
+- When the user provides a Workday requisition export file (`.xlsx`)
+- When the user asks to import candidates from Workday or an XLSX export
+- When the user mentions a requisition ID and asks to process the export
+
+## Prerequisites
+
+- A Workday requisition export file (`.xlsx`) accessible on the filesystem
+  (typically in `~/Downloads/`)
+- The `xlsx` npm package installed in the KB root:
+  ```bash
+  npm install xlsx
+  ```
+- User identity configured in `USER.md`
+
+## Inputs
+
+- Path to the `.xlsx` file (e.g.
+  `~/Downloads/4951493_Principal_Software_Engineer_–_Forward_Deployed_(Open).xlsx`)
+
+## Outputs
+
+- `knowledge/Candidates/{Full Name}/brief.md` — candidate profile note
+- `knowledge/Candidates/{Full Name}/CV.md` — resume text rendered as markdown
+- Updated existing candidate briefs if candidate already exists
+
+---
+
+## Workday Export Format
+
+The Workday requisition export contains multiple sheets. This skill uses:
+
+### Sheet 1 — Requisition Metadata
+
+Key-value pairs, one per row:
+
+| Row | Field                 | Example                                |
+| --- | --------------------- | -------------------------------------- |
+| 1   | Title header          | `4951493 Principal Software Engineer…` |
+| 2   | Recruiting Start Date | `02/10/2026`                           |
+| 3   | Target Hire Date      | `02/10/2026`                           |
+| 4   | Primary Location      | `USA - NY - Headquarters`              |
+| 5   | Hiring Manager Title  | `Hiring Manager`                       |
+| 6   | Hiring Manager        | Name                                   |
+| 7   | Recruiter Title       | `Recruiter`                            |
+| 8   | Recruiter             | Name                                   |
+
+### Sheet 3 — Candidates
+
+Row 3 contains column headers. Data rows start at row 4. After the last
+candidate, stage-summary rows appear (these are not candidates).
+
+| Column | Field                  | Maps to brief field…     |
+| ------ | ---------------------- | ------------------------ |
+| B      | Candidate name         | `# {Name}`               |
+| C      | Stage                  | Status derivation        |
+| D      | Step / Disposition     | Status derivation        |
+| G      | Resume filename        | Reference only (no file) |
+| H      | Date Applied           | **First seen**           |
+| I      | Current Job Title      | **Current title**, Title |
+| J      | Current Company        | **Current title** suffix |
+| K      | Source                 | **Source**               |
+| L      | Referred by            | **Source** suffix        |
+| N      | Availability Date      | **Availability**         |
+| O      | Visa Requirement       | Notes                    |
+| P      | Eligible to Work       | Notes                    |
+| Q      | Relocation             | Notes                    |
+| R      | Salary Expectations    | **Rate**                 |
+| S      | Non-Compete            | Notes                    |
+| T      | Candidate Location     | **Location**             |
+| U      | Phone                  | **Phone**                |
+| V      | Email                  | **Email**                |
+| W      | Total Years Experience | Summary context          |
+| X      | All Job Titles         | Work History context     |
+| Y      | Companies              | Work History context     |
+| Z      | Degrees                | Education                |
+| AA     | Fields of Study        | Education                |
+| AB     | Language               | **English** / Language   |
+| AC     | Resume Text            | `CV.md` content          |
+
+#### Name Annotations
+
+Names may include parenthetical annotations:
+
+- `(Prior Worker)` → Internal/External = `External (Prior Worker)`
+- `(Internal)` → Internal/External = `Internal`
+- No annotation + source contains "Internal" → `Internal`
+- Otherwise → `External`
+
+## Before Starting
+
+1. Read `USER.md` to get the user's name, email, and domain.
+2. Confirm the XLSX file path with the user (or use the provided path).
+3. Ensure the `xlsx` package is installed:
+   ```bash
+   npm list xlsx 2>/dev/null || npm install xlsx
+   ```
+
+## Step 1: Parse the Export
+
+Run the parse script to extract structured data:
+
+```bash
+node .claude/skills/workday-requisition/scripts/parse-workday.mjs "<path-to-xlsx>" --summary
+```
+
+This prints a summary of the requisition and all candidates. Review the output
+to confirm the file parsed correctly and note the total candidate count.
+
+For the full JSON output (used in subsequent steps):
+
+```bash
+node .claude/skills/workday-requisition/scripts/parse-workday.mjs "<path-to-xlsx>"
+```
+
+The full output is a JSON object with:
+
+- `requisition` — metadata (id, title, location, hiringManager, recruiter)
+- `candidates` — array of candidate objects with all extracted fields
+
+## Step 2: Build Candidate Index
+
+Scan existing candidate notes to avoid duplicates:
+
+```bash
+ls -d knowledge/Candidates/*/ 2>/dev/null
+```
+
+For each existing candidate, check if they match any imported candidate by name.
+Use fuzzy matching — the Workday name may differ slightly from an existing note
+(e.g. middle names, accents, spelling variations).
+
+## Step 3: Determine Pipeline Status
+
+Map Workday stage and step/disposition to the `track-candidates` pipeline
+status:
+
+| Workday Step / Disposition   | Pipeline Status    |
+| ---------------------------- | ------------------ |
+| `Considered`                 | `new`              |
+| `Manager Resume Screen`      | `screening`        |
+| `Assessment`                 | `screening`        |
+| `Interview` / `Phone Screen` | `first-interview`  |
+| `Second Interview`           | `second-interview` |
+| `Reference Check`            | `second-interview` |
+| `Offer`                      | `offer`            |
+| `Employment Agreement`       | `offer`            |
+| `Background Check`           | `hired`            |
+| `Ready for Hire`             | `hired`            |
+| `Rejected` / `Declined`      | `rejected`         |
+
+If the step is identical to the stage (e.g. both "Considered"), default to
+`new`.
+
+## Step 4: Create CV.md from Resume Text
+
+For each candidate with resume text, create
+`knowledge/Candidates/{Clean Name}/CV.md`:
+
+```markdown
+# {Clean Name} — Resume
+
+> Extracted from Workday requisition export {Req ID} on {today's date}.
+> Original file: {Resume filename from column G}
+
+---
+
+{Resume text from column AC, preserving original formatting}
+```
+
+**Formatting rules for resume text:**
+
+- Preserve paragraph breaks (double newlines)
+- Convert ALL-CAPS section headers to `## Heading` format
+- Preserve bullet points and lists
+- Clean up excessive whitespace but keep structure
+- Do not rewrite or summarize — reproduce faithfully
+
+If a candidate has no resume text, skip the CV.md file.
+
+## Step 5: Write Candidate Brief
+
+### For NEW candidates
+
+Create the candidate directory and brief:
+
+```bash
+mkdir -p "knowledge/Candidates/{Clean Name}"
+```
+
+Then create `knowledge/Candidates/{Clean Name}/brief.md` using the
+`track-candidates` format:
+
+```markdown
+# {Clean Name}
+
+## Info
+**Title:** {Current Job Title or "—"}
+**Rate:** {Salary Expectations or "—"}
+**Availability:** {Availability Date or "—"}
+**English:** {Language field or "—"}
+**Location:** {Candidate Location or "—"}
+**Gender:** —
+**Source:** {Source} {via Referred by, if present}
+**Status:** {pipeline status from Step 3}
+**First seen:** {Date Applied, YYYY-MM-DD}
+**Last activity:** {Date Applied, YYYY-MM-DD}
+**Req:** {Req ID} — {Req Title}
+**Internal/External:** {Internal / External / External (Prior Worker)}
+**Current title:** {Current Job Title at Current Company}
+**Email:** {Email or "—"}
+**Phone:** {Phone or "—"}
+
+## Summary
+{2-3 sentences based on resume text: role focus, years of experience, key
+strengths. If no resume text, use Current Job Title + Total Years Experience.}
+
+## CV
+- [CV.md](./CV.md)
+
+## Connected to
+- {Referred by person, if present}
+
+## Pipeline
+- **{Date Applied}**: Applied via {Source}
+
+## Skills
+{Extract key technical skills from resume text — use framework IDs where
+possible via `npx fit-pathway skill --list`}
+
+## Education
+{Degrees and Fields of Study from the export columns}
+
+## Work History
+{All Job Titles and Companies from the export columns, formatted as a list}
+
+## Notes
+{Include any noteworthy fields here:}
+{- Visa requirement (if present)}
+{- Eligible to work (if present)}
+{- Relocation willingness (if present)}
+{- Non-compete status (if present)}
+{- Total years of experience}
+```
+
+**Extra fields** (after Last activity, in order): Req, Internal/External,
+Current title, Email, Phone, LinkedIn — include only when available. Follow the
+order defined in the `track-candidates` skill.
+
+### For EXISTING candidates
+
+Read `knowledge/Candidates/{Name}/brief.md`, then apply targeted edits:
+
+- Add or update **Req** field with this requisition's ID
+- Update **Status** if the Workday stage is more advanced
+- Update **Last activity** date if this application is more recent
+- Add a new **Pipeline** entry:
+  `**{Date Applied}**: Applied to {Req ID} — {Req Title} via {Source}`
+- Update any missing fields (Email, Phone, Location) from the export
+- Do NOT overwrite existing richer data with sparser Workday data
+
+**Use precise edits — don't rewrite the entire file.**
+
+## Step 6: Process in Batches
+
+Workday exports can contain many candidates. Process in batches of **10
+candidates per run** to stay within context limits.
+
+For each batch:
+
+1. Parse the JSON output (or re-run the parse script)
+2. Process 10 candidates: create/update brief + CV.md
+3. Report progress: `Processed {N}/{Total} candidates`
+
+If the export has more than 10 candidates, tell the user how many remain and
+offer to continue.
+
+## Step 7: Capture Key Insights
+
+After processing all candidates, review the batch for strategic observations and
+add them to `knowledge/Candidates/Insights.md`:
+
+- Candidates who stand out as strong matches
+- Candidates better suited for a different role
+- Notable patterns (source quality, experience distribution, skill gaps)
+
+Follow the `track-candidates` Insights format: one bullet per insight under
+`## Placement Notes` with `[[Candidates/Name/brief|Name]]` links.
+
+## Step 8: Tag Skills with Framework IDs
+
+When resume text mentions technical skills, map them to the engineering
+framework:
+
+```bash
+npx fit-pathway skill --list
+```
+
+Use framework skill IDs in the **Skills** section of each brief. If a candidate
+has a CV.md, flag them for the `analyze-cv` skill for a full framework-aligned
+assessment.
+
+## Quality Checklist
+
+- [ ] XLSX parsed correctly — verify candidate count matches summary
+- [ ] Requisition metadata extracted (ID, title, hiring manager, recruiter)
+- [ ] Each candidate has a directory under `knowledge/Candidates/{Clean Name}/`
+- [ ] CV.md created for every candidate with resume text
+- [ ] CV.md faithfully reproduces resume text (no rewriting or summarizing)
+- [ ] Brief follows `track-candidates` format exactly
+- [ ] Info fields in standard order (Title → Rate → Availability → English →
+      Location → Gender → Source → Status → First seen → Last activity → extras)
+- [ ] Pipeline status correctly mapped from Workday stage/step
+- [ ] Internal/External correctly derived from name annotations and source
+- [ ] Name annotations stripped from directory names and headings
+- [ ] Existing candidates updated (not duplicated) with precise edits
+- [ ] Skills tagged using framework skill IDs where possible
+- [ ] Gender field set to `—` (Workday exports don't include gender signals)
+- [ ] Insights.md updated with strategic observations
+- [ ] No duplicate candidate directories created

package/template/.claude/skills/workday-requisition/scripts/parse-workday.mjs

@@ -0,0 +1,243 @@
+#!/usr/bin/env node
+/**
+ * Parse a Workday requisition export (.xlsx) and output structured JSON.
+ *
+ * Reads Sheet1 for requisition metadata and the "Candidates" sheet for
+ * candidate data. Outputs a JSON object to stdout with:
+ *   - requisition: { id, title, startDate, targetHireDate, location,
+ *                     hiringManager, recruiter }
+ *   - candidates:  [ { name, cleanName, stage, step, resumeFile, dateApplied,
+ *                       currentTitle, currentCompany, source, referredBy,
+ *                       availabilityDate, visaRequirement, eligibleToWork,
+ *                       relocation, salaryExpectations, nonCompete, location,
+ *                       phone, email, totalYearsExperience, allJobTitles,
+ *                       companies, degrees, fieldsOfStudy, language,
+ *                       resumeText, internalExternal } ]
+ *
+ * Usage:
+ *   node scripts/parse-workday.mjs <path-to-xlsx>
+ *   node scripts/parse-workday.mjs <path-to-xlsx> --summary
+ *   node scripts/parse-workday.mjs -h|--help
+ *
+ * Requires: npm install xlsx
+ */
+
+import { readFileSync } from "node:fs";
+
+if (
+  process.argv.includes("-h") ||
+  process.argv.includes("--help") ||
+  process.argv.length < 3
+) {
+  console.log(`parse-workday — extract candidates from a Workday requisition export
+
+Usage:
+  node scripts/parse-workday.mjs <path-to-xlsx>            Full JSON output
+  node scripts/parse-workday.mjs <path-to-xlsx> --summary  Name + status only
+  node scripts/parse-workday.mjs -h|--help                 Show this help
+
+Output (JSON):
+  { requisition: { id, title, ... }, candidates: [ { name, ... }, ... ] }
+
+Requires: npm install xlsx`);
+  process.exit(process.argv.length < 3 ? 1 : 0);
+}
+
+let XLSX;
+try {
+  XLSX = await import("xlsx");
+} catch {
+  console.error(
+    "Error: xlsx package not found. Install it first:\n  npm install xlsx",
+  );
+  process.exit(1);
+}
+
+const filePath = process.argv[2];
+const summaryMode = process.argv.includes("--summary");
+
+const data = readFileSync(filePath);
+const wb = XLSX.read(data, { type: "buffer", cellDates: true });
+
+// --- Sheet 1: Requisition metadata ---
+
+const ws1 = wb.Sheets[wb.SheetNames[0]];
+const sheet1Rows = XLSX.utils.sheet_to_json(ws1, { header: 1, defval: "" });
+
+/** Extract the requisition ID and title from the header row. */
+function parseReqHeader(headerText) {
+  // Format: "4951493 Principal Software Engineer – Forward Deployed: 4951493 ..."
+  const text = String(headerText).split(":")[0].trim();
+  const match = text.match(/^(\d+)\s+(.+)$/);
+  if (match) return { id: match[1], title: match[2] };
+  return { id: "", title: text };
+}
+
+/** Build a key-value map from Sheet1 rows (column A = label, column B = value). */
+function buildReqMetadata(rows) {
+  const meta = {};
+  for (const row of rows) {
+    const key = String(row[0] || "").trim();
+    const val = String(row[1] || "").trim();
+    if (key && val) meta[key] = val;
+  }
+  return meta;
+}
+
+const reqHeader = parseReqHeader(sheet1Rows[0]?.[0] || "");
+const reqMeta = buildReqMetadata(sheet1Rows.slice(1));
+
+/** Clean a metadata date string (e.g. "02/10/2026 - 22 days ago" → "2026-02-10"). */
+function cleanMetaDate(val) {
+  if (!val) return "";
+  const clean = val.replace(/\s*-\s*\d+\s+days?\s+ago$/i, "").trim();
+  // Convert MM/DD/YYYY → YYYY-MM-DD
+  const match = clean.match(/^(\d{2})\/(\d{2})\/(\d{4})$/);
+  if (match) return `${match[3]}-${match[1]}-${match[2]}`;
+  return clean;
+}
+
+const requisition = {
+  id: reqHeader.id,
+  title: reqHeader.title,
+  startDate: cleanMetaDate(reqMeta["Recruiting Start Date"]),
+  targetHireDate: cleanMetaDate(reqMeta["Target Hire Date"]),
+  location: reqMeta["Primary Location"] || "",
+  hiringManager: reqMeta["Hiring Manager"] || "",
+  recruiter: reqMeta["Recruiter"] || "",
+};
+
+// --- Sheet 3: Candidates ---
+
+// Find the "Candidates" sheet (usually index 2, but search by name to be safe)
+const candSheetName =
+  wb.SheetNames.find((n) => n.toLowerCase() === "candidates") ||
+  wb.SheetNames[2];
+const ws3 = wb.Sheets[candSheetName];
+const candRows = XLSX.utils.sheet_to_json(ws3, { header: 1, defval: "" });
+
+// Row 3 (index 2) has column headers. Data starts at row 4 (index 3).
+// Stage summary rows start when column A has a non-empty value that looks like
+// a label or number — detect by checking if column C (Stage) is empty and
+// column A has a value.
+const DATA_START = 3;
+
+/**
+ * Clean a candidate name by stripping annotations like (Prior Worker),
+ * (Internal), etc. Returns { cleanName, internalExternal }.
+ */
+function parseName(raw) {
+  const name = String(raw).trim();
+  if (!name) return { cleanName: "", internalExternal: "" };
+
+  const match = name.match(/^(.+?)\s*\(([^)]+)\)\s*$/);
+  if (match) {
+    const annotation = match[2].trim();
+    let ie = "";
+    if (/prior\s*worker/i.test(annotation)) ie = "External (Prior Worker)";
+    else if (/internal/i.test(annotation)) ie = "Internal";
+    else ie = annotation;
+    return { cleanName: match[1].trim(), internalExternal: ie };
+  }
+  return { cleanName: name, internalExternal: "" };
+}
+
+/** Detect source-based internal/external when name annotation is absent. */
+function inferInternalExternal(source, nameAnnotation) {
+  if (nameAnnotation) return nameAnnotation;
+  if (/internal/i.test(source)) return "Internal";
+  return "External";
+}
+
+/** Format a date value (may be Date object or string). */
+function fmtDate(val) {
+  if (!val) return "";
+  if (val instanceof Date) {
+    // Use local date parts to avoid UTC offset shifting the day
+    const y = val.getFullYear();
+    const m = String(val.getMonth() + 1).padStart(2, "0");
+    const d = String(val.getDate()).padStart(2, "0");
+    return `${y}-${m}-${d}`;
+  }
+  const s = String(val).trim();
+  // Strip trailing " 00:00:00" and relative text like " - 22 days ago"
+  return s
+    .replace(/\s+\d{2}:\d{2}:\d{2}$/, "")
+    .replace(/\s*-\s*\d+\s+days?\s+ago$/i, "");
+}
+
+/** Normalise multiline cell values into clean lists. */
+function multiline(val) {
+  if (!val) return "";
+  return String(val)
+    .split("\n")
+    .map((l) => l.trim())
+    .filter(Boolean)
+    .join(", ");
+}
+
+const candidates = [];
+
+for (let i = DATA_START; i < candRows.length; i++) {
+  const row = candRows[i];
+  const rawName = String(row[1] || "").trim(); // Column B (index 1)
+  const stage = String(row[2] || "").trim(); // Column C (index 2)
+
+  // Stop at stage-summary rows: column A has a value, column C (stage) is empty
+  if (!rawName || (!stage && String(row[0] || "").trim())) break;
+  if (!rawName) continue;
+
+  const { cleanName, internalExternal: nameIE } = parseName(rawName);
+  const source = String(row[10] || "").trim();
+
+  candidates.push({
+    name: rawName,
+    cleanName,
+    stage,
+    step: String(row[3] || "").trim(),
+    awaitingMe: String(row[4] || "").trim(),
+    awaitingAction: String(row[5] || "").trim(),
+    resumeFile: String(row[6] || "").trim(),
+    dateApplied: fmtDate(row[7]),
+    currentTitle: String(row[8] || "").trim(),
+    currentCompany: String(row[9] || "").trim(),
+    source,
+    referredBy: String(row[11] || "").trim(),
+    availabilityDate: fmtDate(row[13]),
+    visaRequirement: String(row[14] || "").trim(),
+    eligibleToWork: String(row[15] || "").trim(),
+    relocation: String(row[16] || "").trim(),
+    salaryExpectations: String(row[17] || "").trim(),
+    nonCompete: String(row[18] || "").trim(),
+    location: String(row[19] || "").trim(),
+    phone: String(row[20] || "").trim(),
+    email: String(row[21] || "").trim(),
+    totalYearsExperience: String(row[22] || "").trim(),
+    allJobTitles: multiline(row[23]),
+    companies: multiline(row[24]),
+    degrees: multiline(row[25]),
+    fieldsOfStudy: multiline(row[26]),
+    language: multiline(row[27]),
+    resumeText: String(row[28] || "").trim(),
+    internalExternal: inferInternalExternal(source, nameIE),
+  });
+}
+
+// --- Output ---
+
+if (summaryMode) {
+  console.log(`Requisition: ${requisition.id} — ${requisition.title}`);
+  console.log(`Location: ${requisition.location}`);
+  console.log(`Hiring Manager: ${requisition.hiringManager}`);
+  console.log(`Recruiter: ${requisition.recruiter}`);
+  console.log(`Candidates: ${candidates.length}`);
+  console.log();
+  for (const c of candidates) {
+    const resume = c.resumeText ? "has resume" : "no resume";
+    console.log(
+      `  ${c.cleanName} — ${c.step || c.stage} (${c.internalExternal}, ${resume})`,
+    );
+  }
+} else {
+  console.log(JSON.stringify({ requisition, candidates }, null, 2));
+}

package/template/CLAUDE.md

@@ -81,13 +81,13 @@ This knowledge base is maintained by a team of agents, each defined in
 `.claude/agents/`. They are woken on a schedule by the Basecamp scheduler. Each
 wake, they observe KB state, decide the most valuable action, and execute.
 
-| Agent              | Domain                         | Schedule        | Skills                                                         |
-| ------------------ | ------------------------------ | --------------- | -------------------------------------------------------------- |
-| **postman**        | Email triage and drafts        | Every 5 min     | sync-apple-mail, draft-emails                                  |
-| **concierge**      | Meeting prep and transcripts   | Every 10 min    | sync-apple-calendar, meeting-prep, process-hyprnote            |
-| **librarian**      | Knowledge graph maintenance    | Every 15 min    | extract-entities, organize-files, manage-tasks                 |
-| **recruiter**      | Engineering recruitment        | Every 30 min    | track-candidates, analyze-cv, right-to-be-forgotten, fit-pathway, fit-map |
-| **chief-of-staff** | Daily briefings and priorities | 7am, Mon 7:30am | weekly-update _(Mon)_, _(reads all state for daily briefings)_ |
+| Agent              | Domain                         | Schedule        | Skills                                                                                         |
+| ------------------ | ------------------------------ | --------------- | ---------------------------------------------------------------------------------------------- |
+| **postman**        | Email triage and drafts        | Every 5 min     | sync-apple-mail, draft-emails                                                                  |
+| **concierge**      | Meeting prep and transcripts   | Every 10 min    | sync-apple-calendar, meeting-prep, process-hyprnote                                            |
+| **librarian**      | Knowledge graph maintenance    | Every 15 min    | extract-entities, organize-files, manage-tasks                                                 |
+| **recruiter**      | Engineering recruitment        | Every 30 min    | track-candidates, analyze-cv, workday-requisition, right-to-be-forgotten, fit-pathway, fit-map |
+| **chief-of-staff** | Daily briefings and priorities | 7am, Mon 7:30am | weekly-update _(Mon)_, _(reads all state for daily briefings)_                                 |
 
 Each agent writes a triage file to `~/.cache/fit/basecamp/state/` every wake
 cycle. The naming convention is `{agent}_triage.md`:
@@ -200,16 +200,17 @@ Available skills (grouped by function):
 
 **Knowledge graph** — build and maintain structured notes:
 
-| Skill              | Purpose                                  |
-| ------------------ | ---------------------------------------- |
-| `extract-entities` | Process synced data into knowledge notes |
-| `manage-tasks`     | Per-person task boards with lifecycle    |
-| `track-candidates` | Recruitment pipeline from email threads  |
-| `analyze-cv`       | CV assessment against career framework   |
-| `right-to-be-forgotten` | GDPR data erasure with audit trail  |
-| `weekly-update`    | Weekly priorities from tasks + calendar  |
-| `process-hyprnote` | Extract entities from Hyprnote sessions  |
-| `organize-files`   | Tidy Desktop/Downloads, chain to extract |
+| Skill                   | Purpose                                  |
+| ----------------------- | ---------------------------------------- |
+| `extract-entities`      | Process synced data into knowledge notes |
+| `manage-tasks`          | Per-person task boards with lifecycle    |
+| `track-candidates`      | Recruitment pipeline from email threads  |
+| `workday-requisition`   | Import candidates from Workday XLSX      |
+| `analyze-cv`            | CV assessment against career framework   |
+| `right-to-be-forgotten` | GDPR data erasure with audit trail       |
+| `weekly-update`         | Weekly priorities from tasks + calendar  |
+| `process-hyprnote`      | Extract entities from Hyprnote sessions  |
+| `organize-files`        | Tidy Desktop/Downloads, chain to extract |
 
 **Communication** — draft, send, and present: