@forwardimpact/outpost 3.0.3

package/templates/.claude/skills/req-workday/scripts/parse-workday.mjs

@@ -0,0 +1,313 @@
+#!/usr/bin/env bun
+/**
+ * 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:
+ *   bun scripts/parse-workday.mjs <path-to-xlsx>
+ *   bun scripts/parse-workday.mjs <path-to-xlsx> --summary
+ *   bun scripts/parse-workday.mjs -h|--help
+ *
+ * Requires: bun install read-excel-file
+ */
+
+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:
+  bun scripts/parse-workday.mjs <path-to-xlsx>            Full JSON output
+  bun scripts/parse-workday.mjs <path-to-xlsx> --summary  Name + status only
+  bun scripts/parse-workday.mjs -h|--help                 Show this help
+
+Output (JSON):
+  { requisition: { id, title, ... }, candidates: [ { name, ... }, ... ] }
+
+Requires: bun install read-excel-file`);
+  process.exit(process.argv.length < 3 ? 1 : 0);
+}
+
+let readXlsxFile;
+try {
+  readXlsxFile = (await import("read-excel-file/node")).default;
+} catch {
+  console.error(
+    "Error: read-excel-file package not found. Install it first:\n  bun install read-excel-file",
+  );
+  process.exit(1);
+}
+
+const filePath = process.argv[2];
+const summaryMode = process.argv.includes("--summary");
+
+/** Read a sheet by number (1-indexed) or name, returning rows as arrays of strings. */
+async function readSheet(file, sheet) {
+  const rows = await readXlsxFile(file, { sheet });
+  // Normalise null cells to empty strings to match previous behaviour
+  return rows.map((row) => row.map((cell) => (cell == null ? "" : cell)));
+}
+
+// Get sheet names to find the candidates sheet
+const sheets = await readXlsxFile(filePath, { getSheets: true });
+const sheetNames = sheets.map((s) => s.name);
+
+// --- Sheet 1: Requisition metadata ---
+
+const sheet1Rows = await readSheet(filePath, 1);
+
+/** 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"] || "",
+};
+
+// --- Candidates sheet ---
+
+// Find the candidates sheet. Workday exports vary:
+//   - Old format: 3+ sheets, candidates on a sheet named "Candidates" or Sheet3
+//   - New format: 2 sheets, candidates on Sheet2
+const candSheetName =
+  sheetNames.find((n) => n.toLowerCase() === "candidates") ||
+  sheetNames[Math.min(2, sheetNames.length - 1)];
+const candRows = await readSheet(filePath, candSheetName);
+
+// Find the header row dynamically — look for a row containing "Stage"
+// Old format: row 3 (index 2). New format: row 8 (index 7).
+let HEADER_ROW = 2;
+for (let i = 0; i < Math.min(15, candRows.length); i++) {
+  if (candRows[i].some((c) => String(c).trim().toLowerCase() === "stage")) {
+    HEADER_ROW = i;
+    break;
+  }
+}
+const DATA_START = HEADER_ROW + 1;
+
+// --- Build header-driven column index map ---
+// Column layout varies between Workday exports (extra columns like "Jobs Applied to"
+// or "Referred by" shift indices). Map by header name to be resilient.
+
+const headerRow = candRows[HEADER_ROW] || [];
+const colMap = {};
+const HEADER_ALIASES = {
+  "job application": "name", // second "Job Application" column (index 1) has candidate name
+  stage: "stage",
+  "step / disposition": "step",
+  "awaiting me": "awaitingMe",
+  "awaiting action": "awaitingAction",
+  resume: "resumeFile",
+  "date applied": "dateApplied",
+  "current job title": "currentTitle",
+  "current company": "currentCompany",
+  source: "source",
+  "referred by": "referredBy",
+  "availability date": "availabilityDate",
+  "visa requirement": "visaRequirement",
+  "eligible to work": "eligibleToWork",
+  relocation: "relocation",
+  "salary expectations": "salaryExpectations",
+  "non-compete": "nonCompete",
+  "candidate location": "location",
+  phone: "phone",
+  email: "email",
+  "total years experience": "totalYearsExperience",
+  "all job titles": "allJobTitles",
+  companies: "companies",
+  degrees: "degrees",
+  "fields of study": "fieldsOfStudy",
+  language: "language",
+  "resume text": "resumeText",
+};
+
+// Skip columns we don't need (e.g. "Jobs Applied to", "Create Candidate Home Account URL")
+for (let i = 0; i < headerRow.length; i++) {
+  const hdr = String(headerRow[i]).trim().toLowerCase();
+  const field = HEADER_ALIASES[hdr];
+  if (field) {
+    // "Job Application" appears twice (cols A and B) — always take the latest
+    // occurrence so we end up with the second one (index 1) which has the name
+    colMap[field] = i;
+  }
+}
+
+// Fallback: if "name" wasn't mapped, use index 0 (new format) or 1 (old format)
+if (colMap.name === undefined) colMap.name = 1;
+// In new format there's only one "Job Application" column (index 0) — the
+// "always take latest" logic already handles this correctly.
+
+/** Get a cell value by field name, with fallback to empty string. */
+function col(row, field) {
+  const idx = colMap[field];
+  if (idx === undefined) return "";
+  return row[idx] ?? "";
+}
+
+/**
+ * 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(col(row, "name") || "").trim();
+  const stage = String(col(row, "stage") || "").trim();
+
+  // Skip empty rows; stop at stage-summary rows (name present but no stage)
+  if (!rawName) continue;
+  if (!stage) break;
+
+  const { cleanName, internalExternal: nameIE } = parseName(rawName);
+  const source = String(col(row, "source") || "").trim();
+
+  candidates.push({
+    name: rawName,
+    cleanName,
+    stage,
+    step: String(col(row, "step") || "").trim(),
+    awaitingMe: String(col(row, "awaitingMe") || "").trim(),
+    awaitingAction: String(col(row, "awaitingAction") || "").trim(),
+    resumeFile: String(col(row, "resumeFile") || "").trim(),
+    dateApplied: fmtDate(col(row, "dateApplied")),
+    currentTitle: String(col(row, "currentTitle") || "").trim(),
+    currentCompany: String(col(row, "currentCompany") || "").trim(),
+    source,
+    referredBy: String(col(row, "referredBy") || "").trim(),
+    availabilityDate: fmtDate(col(row, "availabilityDate")),
+    visaRequirement: String(col(row, "visaRequirement") || "").trim(),
+    eligibleToWork: String(col(row, "eligibleToWork") || "").trim(),
+    relocation: String(col(row, "relocation") || "").trim(),
+    salaryExpectations: String(col(row, "salaryExpectations") || "").trim(),
+    nonCompete: String(col(row, "nonCompete") || "").trim(),
+    location: String(col(row, "location") || "").trim(),
+    phone: String(col(row, "phone") || "").trim(),
+    email: String(col(row, "email") || "").trim(),
+    totalYearsExperience: String(col(row, "totalYearsExperience") || "").trim(),
+    allJobTitles: multiline(col(row, "allJobTitles")),
+    companies: multiline(col(row, "companies")),
+    degrees: multiline(col(row, "degrees")),
+    fieldsOfStudy: multiline(col(row, "fieldsOfStudy")),
+    language: multiline(col(row, "language")),
+    resumeText: String(col(row, "resumeText") || "").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/templates/.claude/skills/send-chat/SKILL.md

@@ -0,0 +1,170 @@
+---
+name: send-chat
+description: Send messages to people via chat platforms (e.g. Microsoft Teams, Slack) using browser automation. Resolves people by name using the knowledge graph, drafts messages for approval, and sends via the web app. Use when the user asks to message, ping, or chat with someone.
+compatibility:
+  requires:
+    - browser-automation
+---
+
+# Send Chat
+
+Send chat messages to people using browser automation against a web-based chat
+platform (Microsoft Teams, Slack, or similar). Resolves recipients by name from
+the knowledge graph so the user can say "message Sarah about the standup"
+without needing exact display names.
+
+## Trigger
+
+Run when the user asks to:
+
+- Send a message on Teams / Slack / chat
+- Ping / chat / DM someone
+- Follow up with someone via chat
+- Send a message about a topic
+
+## Prerequisites
+
+- Chat platform web app open and authenticated in the browser
+- Browser automation available (e.g. Chrome MCP, Playwright)
+- Knowledge base populated with people notes
+
+## Critical: Always Look Up Context First
+
+**BEFORE messaging anyone, you MUST look up the person in the knowledge base.**
+
+When the user mentions ANY person:
+
+1. **STOP** — Do not open the chat platform yet
+2. **SEARCH** — Look them up: `rg -l "{name}" knowledge/People/`
+3. **READ** — Read their note to understand context, role, recent interactions
+4. **UNDERSTAND** — Know who they are, what you've been working on together
+5. **THEN PROCEED** — Only now compose the message and use browser automation
+
+This context is essential for:
+
+- Finding the right person if the name is ambiguous
+- Drafting an appropriate message if the user gave a loose prompt
+- Knowing the person's role and relationship for tone
+
+## Resolving People
+
+The user will refer to people by first name, last name, or nickname. Resolve to
+a full name using the knowledge graph:
+
+```bash
+# Find person by partial name
+rg -l -i "{name}" knowledge/People/
+
+# If ambiguous, read candidates to disambiguate
+cat "knowledge/People/{Candidate}.md"
+```
+
+**If ambiguous** (multiple matches), ask the user which person they mean — list
+the matches with roles/orgs to help them pick.
+
+**If no match**, tell the user you don't have this person in the knowledge base
+and ask for their full name as it appears in the chat platform.
+
+## Composing the Message
+
+**Every message MUST be drafted as a text file first.** This ensures the user
+can review and edit the exact message before it's sent.
+
+### Draft Workflow
+
+1. **Compose the message** based on context and user intent.
+2. **Write it to a draft file** at `drafts/chat-{recipient-slug}-{date}.md`
+   - `{recipient-slug}` = lowercase, hyphenated full name (e.g. `sarah-chen`)
+   - `{date}` = ISO date (e.g. `2026-02-19`)
+3. **Show the user the draft** — display the file path and contents.
+4. **Wait for approval** — the user may edit the file or ask for changes.
+5. **Only after approval**, proceed to send.
+
+**Draft file format:**
+
+```markdown
+To: {Full Name}
+Via: {Platform name}
+Date: {YYYY-MM-DD}
+
+---
+
+{message body}
+```
+
+The message body (everything below the `---` separator) is what gets pasted into
+the chat.
+
+**Message guidelines:**
+
+- Match the user's usual tone — casual for peers, professional for leadership
+- Keep it concise — chat is informal, not email
+- Reference specific context naturally (project names, recent decisions)
+- If the user provides exact wording, use it verbatim
+- If the user said "ping {name}" without detail, ask what they want to say
+- Draft one message based on context — don't offer multiple options
+- **Keep messages on a single line with no formatting.** No line breaks, no
+  markdown. Use inline separators (e.g. `•`, `—`) to keep structure. Multi-line
+  formatting is unreliable via browser automation.
+
+## Browser Automation Flow
+
+Once the user has approved the draft, send it as a **single submission** — paste
+the entire message at once rather than typing line by line.
+
+### Step 1: Identify the Chat Platform
+
+Check which platform is available:
+
+- Look for an open tab matching the configured chat URL
+- If no tab is open, ask the user which platform to use and navigate to it
+
+### Step 2: Open a Chat with the Recipient
+
+1. Use the platform's search or "New chat" feature
+2. Type the recipient's full name
+3. Wait for search results to populate (take a screenshot to verify)
+4. Click the correct person from the results
+
+If the person doesn't appear in search, inform the user — they may not be in the
+same organization.
+
+### Step 3: Send the Approved Message
+
+1. Read the approved draft file to get the message body (below the `---`)
+2. Click the message compose box
+3. Paste the entire message as a single submission
+4. Press Enter or click Send
+5. Take a screenshot to confirm the message was sent
+
+### Step 4: Update Knowledge Graph (Optional)
+
+If the message is substantive (not just "hey" or "thanks"), note the interaction
+on the person's knowledge note:
+
+```markdown
+- {YYYY-MM-DD}: Messaged on {Platform} re: {topic}
+```
+
+## Error Handling
+
+- **Platform not loaded / auth required:** Tell the user to sign in first, then
+  retry
+- **Person not found in search:** Report back — they may be external or using a
+  different display name. Ask the user for the exact name
+- **Chat already open:** If a chat with this person is already visible, use it
+  directly
+- **UI not as expected:** Take a screenshot and describe what you see. Don't
+  click blindly
+
+## Constraints
+
+- **Always confirm before sending.** Never send a message without explicit user
+  approval — this is a hard requirement
+- **One message at a time.** Don't batch-send to multiple people without
+  confirming each one
+- **No file attachments.** This skill handles text messages only
+- **No group chats.** Targets 1:1 chats only
+- **No message deletion or editing.** Once sent, it's sent
+- **Respect ethics rules.** Never send messages that contain personal judgments,
+  gossip, or sensitive information per the knowledge base ethics policy

package/templates/.claude/skills/sync-apple-calendar/SKILL.md

@@ -0,0 +1,145 @@
+---
+name: sync-apple-calendar
+description: Sync calendar events from the macOS Calendar app's local SQLite database into ~/.cache/fit/outpost/apple_calendar/ as JSON files. Use on a schedule or when the user asks to sync their calendar. Requires macOS with Calendar app configured and Full Disk Access granted.
+compatibility: Requires macOS with Apple Calendar configured and Full Disk Access granted to the terminal
+---
+
+# Sync Apple Calendar
+
+Sync calendar events from the macOS Calendar app's local SQLite database into
+`~/.cache/fit/outpost/apple_calendar/` as JSON files. This is an automated data
+pipeline skill — it ingests raw calendar data that other skills (like
+`extract-entities` and `meeting-prep`) consume downstream.
+
+## Trigger
+
+Run this skill on a schedule (every 5 minutes) or when the user asks to sync
+their calendar.
+
+## Prerequisites
+
+- macOS with the built-in Calendar app configured
+- Full Disk Access granted to the terminal (System Settings → Privacy & Security
+  → Full Disk Access)
+
+## Inputs
+
+- `~/Library/Group Containers/group.com.apple.calendar/Calendar.sqlitedb` —
+  Apple Calendar SQLite database (Sonoma+/macOS 14+)
+- `~/Library/Calendars/Calendar.sqlitedb` — fallback path for older macOS
+
+## Outputs
+
+- `~/.cache/fit/outpost/apple_calendar/{event_id}.json` — one JSON file per
+  event (14-day sliding window)
+
+---
+
+## Implementation
+
+Run the sync as a single Node.js script with embedded SQLite. This avoids N+1
+process invocations (one per event for attendees) and handles all data
+transformation in one pass:
+
+    node scripts/sync.mjs [--days N]
+
+- `--days N` — how many days back to sync (default: 30)
+
+The script:
+
+1. Finds the Calendar database (Sonoma+ path first, then fallback)
+2. Queries all events in a sliding window (`--days` past / 14 days future) with
+   a single SQL query
+3. Batch-fetches all attendees for those events in one query
+4. Writes one JSON file per event to `~/.cache/fit/outpost/apple_calendar/`
+5. Cleans up JSON files for events now outside the window
+6. Reports summary (events synced, files cleaned up)
+
+## Database Schema
+
+See [references/SCHEMA.md](references/SCHEMA.md) for the complete Apple Calendar
+SQLite schema including table structures, column names, and important caveats
+(e.g., Identity uses `address` not `email`, Participant has no `display_name`).
+
+## Output Format
+
+Each `{event_id}.json` file:
+
+```json
+{
+  "id": "apple_cal_123",
+  "summary": "Meeting with Sarah Chen",
+  "start": { "dateTime": "2025-02-12T15:00:00+01:00", "timeZone": "Europe/Paris" },
+  "end": { "dateTime": "2025-02-12T16:00:00+01:00", "timeZone": "Europe/Paris" },
+  "allDay": false,
+  "location": "Zoom",
+  "description": "Discuss Q2 roadmap",
+  "conferenceUrl": null,
+  "calendar": "Calendar",
+  "organizer": { "email": "sarah@acme.com", "name": "Chen, Sarah" },
+  "attendees": [
+    {
+      "email": "sarah@acme.com",
+      "name": "Chen, Sarah",
+      "status": "accepted",
+      "role": "required",
+      "self": false
+    }
+  ]
+}
+```
+
+## Error Handling
+
+- Database not found → Calendar not configured, report and stop
+- Permission denied → Full Disk Access not granted, report and stop
+- Database locked → wait 2 seconds, retry once
+- Skip events with no summary (likely cancelled or placeholder)
+
+## Querying Events
+
+After syncing, use the query script to filter events by date or time window.
+**Agents should use this script instead of writing bespoke calendar parsers.**
+
+    node scripts/query.mjs [options]
+
+### Time filters (combinable)
+
+| Flag                            | Description                                               |
+| ------------------------------- | --------------------------------------------------------- |
+| `--today`                       | Events starting today (default if no filter given)        |
+| `--tomorrow`                    | Events starting tomorrow                                  |
+| `--upcoming 2h`                 | Events starting within interval (e.g., `2h`, `30m`, `1d`) |
+| `--date 2026-03-09`             | Events on a specific date                                 |
+| `--range 2026-03-09 2026-03-11` | Events between two dates (inclusive)                      |
+
+### Output options
+
+| Flag                | Description                                     |
+| ------------------- | ----------------------------------------------- |
+| `--json`            | Output as JSON array (default: formatted table) |
+| `--include-all-day` | Include all-day events (excluded by default)    |
+| `--no-attendees`    | Omit attendee names from output                 |
+
+### Examples
+
+```bash
+# Concierge: get today + tomorrow for triage
+node scripts/query.mjs --today --tomorrow
+
+# Meeting-prep: get upcoming meetings in next 2 hours as JSON
+node scripts/query.mjs --upcoming 2h --json
+
+# Chief-of-staff: get this week's events
+node scripts/query.mjs --range 2026-03-09 2026-03-13
+
+# Quick count check
+node scripts/query.mjs --today --json | node -e "process.stdin.on('data',d=>console.log(JSON.parse(d).length+' events today'))"
+```
+
+## Constraints
+
+- Open database read-only (`readOnly: true`)
+- This sync is stateless — always queries the current sliding window
+- All-day events may have null end times — use start date as end date
+- All-day events have timezone `_float` — omit timezone from output