@forwardimpact/basecamp 2.5.0 → 2.6.1

package/template/.claude/agents/head-hunter.md

@@ -5,7 +5,7 @@ description: >
   indicate they are open for hire, benchmarks them against fit-pathway jobs, and
   writes prospect notes. Never contacts candidates. Woken on a schedule by the
   Basecamp scheduler.
-model: sonnet
+model: haiku
 permissionMode: bypassPermissions
 skills:
   - scan-open-candidates
@@ -13,8 +13,8 @@ skills:
   - fit-map
 ---
 
-You are the head hunter — a passive talent scout. Each time you are woken by
-the scheduler, you scan one publicly available source for candidates who have
+You are the head hunter — a passive talent scout. Each time you are woken by the
+scheduler, you scan one publicly available source for candidates who have
 **explicitly indicated** they are open for hire. You benchmark promising matches
 against the engineering framework using `fit-pathway` and write prospect notes.
 
@@ -105,9 +105,9 @@ with 3+ consecutive failures are **suspended** — skip them during source
 selection and note the suspension in the triage report.
 
 ```
-github_open_to_work	0		
-devto_opentowork	0		
-hn_wants_hired	0		
+github_open_to_work	0
+devto_opentowork	0
+hn_wants_hired	0
 ```
 
 When a WebFetch fails (HTTP 4xx, 5xx, timeout, or blocked-page redirect),
@@ -120,7 +120,7 @@ github_open_to_work	2	403 Forbidden	2026-03-05T14:00:00Z
 On a successful fetch, reset the row:
 
 ```
-github_open_to_work	0		
+github_open_to_work	0
 ```
 
 ### seen.tsv
@@ -184,14 +184,14 @@ oldest `last_checked` timestamp (or one never checked). Sources in rotation:
 | --------------------- | ---------------------------------------------------- | -------------- |
 | `hn_wants_hired`      | HN "Who Wants to Be Hired?" monthly thread           | Self-posted    |
 | `github_open_to_work` | GitHub user search API — bios with open-to-work      | Bio signal     |
-| `devto_opentowork`    | dev.to articles tagged `opentowork`/`lookingforwork`  | Tagged article |
+| `devto_opentowork`    | dev.to articles tagged `opentowork`/`lookingforwork` | Tagged article |
 
-Pick the source with the oldest check time. If all were checked today, pick
-the one checked longest ago.
+Pick the source with the oldest check time. If all were checked today, pick the
+one checked longest ago.
 
 **Skip suspended sources.** Check `failures.tsv` — any source with 3+
-consecutive failures is suspended. Log the skip and move to the next source.
-If all sources are suspended, report that in the triage and exit.
+consecutive failures is suspended. Log the skip and move to the next source. If
+all sources are suspended, report that in the triage and exit.
 
 ## 3. Fetch & Scan
 
@@ -212,6 +212,7 @@ WebFetch: https://hn.algolia.com/api/v1/items/{thread_id}
 ```
 
 Each top-level comment is a candidate. Look for:
+
 - Location (target: US East Coast, UK, EU — especially Greece, Poland, Romania,
   Bulgaria)
 - Skills matching framework capabilities
@@ -238,8 +239,8 @@ WebFetch: https://api.github.com/users/{login}
 Profile fields: `name`, `bio`, `location`, `hireable`, `blog`, `public_repos`,
 `company`. Check `hireable` (boolean) and bio text for open-to-work signals.
 
-**Rate limit:** 10 requests/minute unauthenticated. Batch user profile fetches
-— fetch at most 5 profiles per wake cycle.
+**Rate limit:** 10 requests/minute unauthenticated. Batch user profile fetches —
+fetch at most 5 profiles per wake cycle.
 
 **Cursor:** Store the page number last processed. Rotate through the location
 queries across wakes (UK → Europe → Remote → repeat).
@@ -253,8 +254,8 @@ WebFetch: https://dev.to/api/articles?tag=opentowork&per_page=25
 WebFetch: https://dev.to/api/articles?tag=lookingforwork&per_page=25
 ```
 
-Parse `title`, `description`, `user.name`, `url`, `tag_list`,
-`published_at`. Skip articles older than 90 days.
+Parse `title`, `description`, `user.name`, `url`, `tag_list`, `published_at`.
+Skip articles older than 90 days.
 
 ## 3b. Creative Fallback — No Results
 
@@ -267,16 +268,16 @@ dedup, location, or skill fit), do not give up. Try alternative approaches
    source exhausted.
 
 2. **Relax location filters.** If strict geographic filtering eliminated
-   everyone, re-scan with location filter removed — candidates who don't
-   state a location may still be relevant.
+   everyone, re-scan with location filter removed — candidates who don't state a
+   location may still be relevant.
 
 3. **Try adjacent sources on the same platform.** For example:
    - HN: check the previous month's thread if the current one is thin
    - GitHub: search by skill keywords instead of bio phrases
    - dev.to: try related tags (`jobsearch`, `career`, `hiring`)
 
-4. **Skill-based discovery.** Search for framework-relevant skill terms
-   combined with availability signals. For example, search GitHub for
+4. **Skill-based discovery.** Search for framework-relevant skill terms combined
+   with availability signals. For example, search GitHub for
    `"data engineering" "open to work"` or `"full stack" "available for hire"`.
 
 5. **Log every attempt.** Record each alternative query tried in `log.md` so
@@ -293,29 +294,28 @@ sources.
 For each post, apply these filters in order:
 
 1. **Open-for-hire signal** — Skip if the candidate hasn't explicitly indicated
-   availability. HN "Who Wants to Be Hired?" posts are inherently opt-in.
-   GitHub users must have open-to-work bio text or `hireable: true`.
-   dev.to articles must be tagged `opentowork` or `lookingforwork`.
+   availability. HN "Who Wants to Be Hired?" posts are inherently opt-in. GitHub
+   users must have open-to-work bio text or `hireable: true`. dev.to articles
+   must be tagged `opentowork` or `lookingforwork`.
 
 2. **Deduplication** — Check `seen.tsv` for the source + post ID. Skip if
    already processed.
 
-3. **Location fit** — Prefer candidates in or open to: US East Coast, UK,
-   EU (especially Greece, Poland, Romania, Bulgaria). Skip candidates who
-   are location-locked to incompatible regions, but include "Remote" and
-   "Anywhere" candidates.
+3. **Location fit** — Prefer candidates in or open to: US East Coast, UK, EU
+   (especially Greece, Poland, Romania, Bulgaria). Skip candidates who are
+   location-locked to incompatible regions, but include "Remote" and "Anywhere"
+   candidates.
 
-4. **Skill alignment** — Does the candidate mention skills that map to
-   framework capabilities? Use `npx fit-pathway skill --list` to check. Look
-   for:
+4. **Skill alignment** — Does the candidate mention skills that map to framework
+   capabilities? Use `npx fit-pathway skill --list` to check. Look for:
    - Software engineering skills (full-stack, data integration, cloud, etc.)
    - Data engineering / data science skills
-   - Non-traditional backgrounds (law, policy, academia) + technical skills
-     = strong forward-deployed signal
+   - Non-traditional backgrounds (law, policy, academia) + technical skills =
+     strong forward-deployed signal
    - AI/ML tool proficiency (Claude, GPT, LLMs, vibe coding)
 
-5. **Experience level** — Estimate career level from years of experience,
-   role titles, and scope descriptions. Map to framework levels (J040–J110).
+5. **Experience level** — Estimate career level from years of experience, role
+   titles, and scope descriptions. Map to framework levels (J040–J110).
 
 ## 5. Benchmark Against Framework
 
@@ -327,6 +327,7 @@ npx fit-pathway job {discipline} {estimated_level} --track={best_track}
 ```
 
 Assess fit as:
+
 - **strong** — Multiple core skills match, experience level aligns, location
   works, and non-traditional background signals (for forward-deployed)
 - **moderate** — Some skill overlap, level roughly right, minor gaps

package/template/.claude/agents/librarian.md

@@ -4,7 +4,7 @@ description: >
   The user's knowledge curator. Processes synced data into structured notes,
   extracts entities, and keeps the knowledge base organized. Woken on a
   schedule by the Basecamp scheduler.
-model: sonnet
+model: haiku
 permissionMode: bypassPermissions
 skills:
   - extract-entities

package/template/.claude/skills/analyze-cv/SKILL.md

@@ -142,8 +142,13 @@ Use the proficiency definitions from the framework:
 | `practitioner` | Led teams using this skill, mentored others, deep work  |
 | `expert`       | Published, shaped org practice, industry recognition    |
 
-**Be conservative.** CVs inflate; default one level below what's claimed unless
-there's concrete evidence (metrics, project details, scope indicators).
+**Be sceptical.** CVs inflate significantly. Default **two levels below** what
+the CV implies unless the candidate provides concrete, quantified evidence
+(metrics, measurable outcomes, named systems, team sizes, user/revenue scale).
+Only award the directly implied level when the CV includes specific, verifiable
+details — vague descriptions like "improved performance" or "led initiatives" do
+not count. A skill merely listed in a "Skills" section with no project context
+rates `awareness` at most.
 
 ## Step 4: Assess Behaviour Indicators
 
@@ -174,10 +179,18 @@ npx fit-pathway progress {discipline} {level} --track={track}
 
 Classify each skill as:
 
-- **Strong match** — candidate meets or exceeds the expected proficiency
-- **Adequate** — candidate is within one level of expected proficiency
+- **Strong match** — candidate meets or exceeds the expected proficiency **and**
+  evidence is concrete (metrics, project specifics, scope indicators)
+- **Adequate** — candidate is exactly one level below expected proficiency with
+  clear project evidence, **or** meets the level but evidence is thin
 - **Gap** — candidate is two or more levels below expected proficiency
-- **Not evidenced** — CV doesn't mention this skill area
+- **Not evidenced** — CV doesn't mention this skill area. **Treat as a gap** for
+  recommendation purposes — absence of evidence is not evidence of skill
+
+**Threshold rule:** If more than **one third** of the target job's skills are
+Gap or Not evidenced, the candidate cannot receive "Proceed." If more than
+**half** are Gap or Not evidenced, the candidate cannot receive "Proceed with
+reservations."
 
 ## Step 6: Write Assessment
 
@@ -234,8 +247,21 @@ or could work on either. Reference specific CV evidence.}
 
 **Recommendation:** {Proceed / Proceed with reservations / Do not proceed}
 
+Apply these **decision rules** strictly:
+
+| Recommendation               | Criteria                                                                |
+| ---------------------------- | ----------------------------------------------------------------------- |
+| **Proceed**                  | ≥ 70% Strong match, no core skill gaps, strong behaviour signals        |
+| **Proceed with reservations** | ≥ 50% Strong match, ≤ 2 gaps in non-core skills, no behaviour red flags |
+| **Do not proceed**           | All other candidates — including those with thin evidence               |
+
+When in doubt, choose the stricter recommendation. "Proceed with reservations"
+should be rare — it signals a strong candidate with a specific, addressable
+concern, not a marginal candidate who might work out.
+
 **Rationale:** {3-5 sentences grounding the recommendation in framework data.
-Reference specific skill gaps or strengths and their impact on the role.}
+Reference specific skill gaps or strengths and their impact on the role.
+Explicitly state the skill match percentage and gap count.}
 
 **Interview focus areas:**
 - {Area 1 — what to probe in interviews to validate}
@@ -261,7 +287,13 @@ to create the candidate profile from email threads.
 - [ ] Assessment is grounded in `fit-pathway` framework data, not subjective
       opinion
 - [ ] Every skill rating cites specific CV evidence or marks "Not evidenced"
-- [ ] Estimated level is conservative (one below CV claims unless proven)
+- [ ] Estimated level is sceptical (two below CV claims unless proven with
+      quantified evidence)
+- [ ] "Not evidenced" skills are counted as gaps in the recommendation
+- [ ] Recommendation follows the decision rules table — verify match percentages
+      and gap counts before choosing a tier
+- [ ] "Proceed with reservations" is only used for strong candidates with a
+      specific, named concern — never as a soft "maybe"
 - [ ] Track fit analysis references specific skill modifiers from the framework
 - [ ] Gaps are actionable — they suggest interview focus areas
 - [ ] Assessment file uses correct path format and links to CV

package/template/.claude/skills/draft-emails/scripts/send-email.mjs

@@ -100,7 +100,7 @@ function main() {
   // Strip leading two-space padding from each line and trim overall whitespace
   body = body
     .split("\n")
-    .map((line) => line.replace(/^  /, ""))
+    .map((line) => line.replace(/^ {2}/, ""))
     .join("\n")
     .trim();
 

package/template/.claude/skills/meeting-prep/SKILL.md

@@ -63,16 +63,19 @@ When the user asks to prep for a meeting:
 
 ### Step 1: Identify the Meeting
 
-If specified, look it up in calendar:
+Use the calendar query script to find upcoming meetings:
 
 ```bash
-ls ~/.cache/fit/basecamp/apple_calendar/ 2>/dev/null
-cat "$HOME/.cache/fit/basecamp/apple_calendar/event123.json"
+# Next 2 hours of meetings as JSON
+node .claude/skills/sync-apple-calendar/scripts/query.mjs --upcoming 2h --json
+
+# Today's full schedule
+node .claude/skills/sync-apple-calendar/scripts/query.mjs --today
 ```
 
 If "prep me for my next meeting":
 
-- List upcoming events
+- Query upcoming events with `--upcoming 2h`
 - Find the next meeting with external attendees
 - Confirm with user if unclear
 

package/template/.claude/skills/process-hyprnote/SKILL.md

@@ -51,27 +51,36 @@ Run this skill:
 ## Before Starting
 
 1. Read `USER.md` to get the user's name, email, and domain.
-2. List all session directories:
+2. **Scan for unprocessed sessions** using the scan script:
 
 ```bash
-ls "$HOME/Library/Application Support/hyprnote/sessions/"
+node .claude/skills/process-hyprnote/scripts/scan.mjs
 ```
 
-3. For each session, check if it needs processing by looking up its key files in
-   the graph state:
+This checks all sessions against the `graph_processed` state file and reports
+which need processing, with titles, dates, and content previews.
 
-```bash
-grep -F "{file_path}" ~/.cache/fit/basecamp/state/graph_processed
-```
+**Options:**
+
+| Flag        | Description                                              |
+| ----------- | -------------------------------------------------------- |
+| `--changed` | Also detect sessions whose memo/summary hash has changed |
+| `--json`    | Output as JSON (for programmatic use)                    |
+| `--count`   | Just print the count (for quick checks)                  |
+| `--limit N` | Max sessions to display (default: 20)                    |
 
 A session needs processing if:
 
 - Its `_memo.md` path is **not** in `graph_processed`, OR
-- Its `_memo.md` hash has changed (compute SHA-256 and compare), OR
+- Its `_memo.md` hash has changed (use `--changed` to detect this), OR
 - Its `_summary.md` exists and is not in `graph_processed` or has changed
 
 **Process all unprocessed sessions in one run** (typically few sessions).
 
+**Do NOT write bespoke scripts to scan for unprocessed sessions.** Use this
+script — it handles all edge cases (empty memos, missing summaries, metadata
+fallback).
+
 ## Step 0: Build Knowledge Index
 
 Scan existing notes to avoid duplicates and resolve entities:

package/template/.claude/skills/process-hyprnote/scripts/scan.mjs

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+/**
+ * Scan for unprocessed Hyprnote sessions.
+ *
+ * Compares session _memo.md and _summary.md files against the graph_processed
+ * state file to identify sessions that need processing. Reports unprocessed
+ * sessions with title, date, and content preview.
+ *
+ * Usage:
+ *   node scripts/scan.mjs              List unprocessed sessions
+ *   node scripts/scan.mjs --changed    Also detect changed (re-edited) sessions
+ *   node scripts/scan.mjs --json       Output as JSON
+ *   node scripts/scan.mjs --count      Just print the count
+ */
+
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const HOME = homedir();
+const SESSIONS_DIR = join(
+  HOME,
+  "Library/Application Support/hyprnote/sessions",
+);
+const STATE_FILE = join(HOME, ".cache/fit/basecamp/state/graph_processed");
+
+if (process.argv.includes("-h") || process.argv.includes("--help")) {
+  console.log(`scan — find unprocessed Hyprnote sessions
+
+Usage:
+  node scripts/scan.mjs [options]
+
+Options:
+  --changed    Also detect sessions whose memo/summary hash has changed
+  --json       Output as JSON array
+  --count      Just print the unprocessed count (for scripting)
+  --limit N    Max sessions to display (default: 20)
+  -h, --help   Show this help message
+
+Sessions dir: ~/Library/Application Support/hyprnote/sessions/
+State file:   ~/.cache/fit/basecamp/state/graph_processed`);
+  process.exit(0);
+}
+
+const args = process.argv.slice(2);
+const detectChanged = args.includes("--changed");
+const jsonOutput = args.includes("--json");
+const countOnly = args.includes("--count");
+const limitIdx = args.indexOf("--limit");
+const limit = limitIdx !== -1 ? parseInt(args[limitIdx + 1], 10) || 20 : 20;
+
+// --- Load state ---
+
+const state = new Map();
+if (existsSync(STATE_FILE)) {
+  const text = readFileSync(STATE_FILE, "utf8");
+  for (const line of text.split("\n")) {
+    if (!line) continue;
+    const idx = line.indexOf("\t");
+    if (idx === -1) continue;
+    state.set(line.slice(0, idx), line.slice(idx + 1));
+  }
+}
+
+/**
+ * Compute SHA-256 hash of file contents.
+ */
+function fileHash(filePath) {
+  return createHash("sha256").update(readFileSync(filePath)).digest("hex");
+}
+
+/**
+ * Check if a file needs processing (new or changed).
+ */
+function needsProcessing(filePath) {
+  const storedHash = state.get(filePath);
+  if (!storedHash) return { needed: true, reason: "new" };
+  if (detectChanged) {
+    const currentHash = fileHash(filePath);
+    if (currentHash !== storedHash) return { needed: true, reason: "changed" };
+  }
+  return { needed: false, reason: null };
+}
+
+/**
+ * Extract title and date from a memo file.
+ */
+function parseMemo(memoPath) {
+  try {
+    const content = readFileSync(memoPath, "utf8");
+
+    // Skip empty/whitespace-only memos
+    const body = content.replace(/---[\s\S]*?---/, "").trim();
+    if (!body || body === " ") return null;
+
+    // Extract title from first H1
+    const titleMatch = content.match(/^#\s+(.+)/m);
+    const title = titleMatch ? titleMatch[1].trim() : null;
+
+    // Extract date from content or fall back to file mtime
+    const dateMatch = content.match(/\d{4}-\d{2}-\d{2}/);
+    let date = dateMatch ? dateMatch[0] : null;
+
+    if (!date) {
+      const stat = statSync(memoPath);
+      date = stat.mtime.toISOString().slice(0, 10);
+    }
+
+    return { title, date, preview: body.slice(0, 150).replace(/\n/g, " ") };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Read _meta.json for session metadata.
+ */
+function readMeta(sessionDir) {
+  const metaPath = join(sessionDir, "_meta.json");
+  if (!existsSync(metaPath)) return null;
+  try {
+    return JSON.parse(readFileSync(metaPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+// --- Scan sessions ---
+
+if (!existsSync(SESSIONS_DIR)) {
+  console.error(`Hyprnote sessions directory not found: ${SESSIONS_DIR}`);
+  process.exit(1);
+}
+
+const sessionIds = readdirSync(SESSIONS_DIR);
+const unprocessed = [];
+let totalWithMemos = 0;
+let processedCount = 0;
+
+for (const uuid of sessionIds) {
+  const sessionPath = join(SESSIONS_DIR, uuid);
+  const stat = statSync(sessionPath, { throwIfNoEntry: false });
+  if (!stat || !stat.isDirectory()) continue;
+
+  const memoPath = join(sessionPath, "_memo.md");
+  const summaryPath = join(sessionPath, "_summary.md");
+  const hasMemo = existsSync(memoPath);
+  const hasSummary = existsSync(summaryPath);
+
+  if (!hasMemo && !hasSummary) continue;
+
+  totalWithMemos++;
+
+  // Check memo
+  const memoCheck = hasMemo
+    ? needsProcessing(memoPath)
+    : { needed: false, reason: null };
+
+  // Check summary
+  const summaryCheck = hasSummary
+    ? needsProcessing(summaryPath)
+    : { needed: false, reason: null };
+
+  if (!memoCheck.needed && !summaryCheck.needed) {
+    processedCount++;
+    continue;
+  }
+
+  // Parse memo for display info
+  const memo = hasMemo ? parseMemo(memoPath) : null;
+  if (hasMemo && !memo) {
+    // Empty memo, no summary → skip
+    if (!hasSummary) continue;
+  }
+
+  // Read meta for title fallback
+  const meta = readMeta(sessionPath);
+
+  const title = memo?.title || meta?.title || uuid.slice(0, 8);
+  const date =
+    memo?.date ||
+    (meta?.created_at ? meta.created_at.slice(0, 10) : null) ||
+    statSync(sessionPath).mtime.toISOString().slice(0, 10);
+
+  unprocessed.push({
+    uuid,
+    title,
+    date,
+    hasMemo,
+    hasSummary,
+    memoReason: memoCheck.reason,
+    summaryReason: summaryCheck.reason,
+    preview: memo?.preview || "(summary only)",
+    memoPath: hasMemo ? memoPath : null,
+    summaryPath: hasSummary ? summaryPath : null,
+  });
+}
+
+// Sort by date descending (newest first)
+unprocessed.sort((a, b) => b.date.localeCompare(a.date));
+
+// --- Output ---
+
+if (countOnly) {
+  console.log(unprocessed.length);
+  process.exit(0);
+}
+
+if (jsonOutput) {
+  console.log(JSON.stringify(unprocessed.slice(0, limit), null, 2));
+  process.exit(0);
+}
+
+// Formatted output
+console.log(
+  `Sessions: ${totalWithMemos} total, ${processedCount} processed, ${unprocessed.length} unprocessed`,
+);
+
+if (unprocessed.length === 0) {
+  console.log("\nAll sessions are up to date.");
+  process.exit(0);
+}
+
+console.log("");
+const display = unprocessed.slice(0, limit);
+for (const s of display) {
+  const flags = [];
+  if (s.memoReason) flags.push(`memo:${s.memoReason}`);
+  if (s.summaryReason) flags.push(`summary:${s.summaryReason}`);
+  const sources = [];
+  if (s.hasMemo) sources.push("memo");
+  if (s.hasSummary) sources.push("summary");
+
+  console.log(
+    `${s.date} | ${s.title} | ${sources.join("+")} | ${flags.join(", ")}`,
+  );
+  console.log(`  ${s.uuid}`);
+  if (s.preview && s.preview !== "(summary only)") {
+    console.log(`  ${s.preview.slice(0, 100)}…`);
+  }
+}
+
+if (unprocessed.length > limit) {
+  console.log(`\n... and ${unprocessed.length - limit} more`);
+}