@forwardimpact/outpost 3.0.3

package/templates/.claude/skills/candidate-report/scripts/render-pdf.mjs

@@ -0,0 +1,48 @@
+#!/usr/bin/env bun
+/**
+ * Render a candidate report HTML file to A4 PDF using Playwright.
+ *
+ * Usage: node scripts/render-pdf.mjs [input.html] [output.pdf]
+ *
+ * Defaults:
+ *   input  → /tmp/candidate-report.html
+ *   output → ~/Desktop/candidate-report.pdf
+ *
+ * Requires: bun install playwright && bunx playwright install chromium
+ */
+
+import { resolve, join } from "node:path";
+import { homedir } from "node:os";
+
+const HELP = `render-pdf — render candidate report HTML to A4 PDF via Playwright
+
+Usage: node scripts/render-pdf.mjs [input.html] [output.pdf] [-h|--help]
+
+Arguments:
+  input.html   HTML report file  (default: /tmp/candidate-report.html)
+  output.pdf   Output PDF path   (default: ~/Desktop/candidate-report.pdf)
+
+Requires: bun install playwright && bunx playwright install chromium`;
+
+if (process.argv.includes("-h") || process.argv.includes("--help")) {
+  console.log(HELP);
+  process.exit(0);
+}
+
+const positional = process.argv.slice(2).filter((a) => !a.startsWith("-"));
+const input = positional[0] || "/tmp/candidate-report.html";
+const output =
+  positional[1] || join(homedir(), "Desktop", "candidate-report.pdf");
+
+const { chromium } = await import("playwright");
+const browser = await chromium.launch();
+const page = await browser.newPage();
+await page.goto(`file://${resolve(input)}`, { waitUntil: "networkidle" });
+await page.pdf({
+  path: output,
+  format: "A4",
+  printBackground: true,
+  margin: { top: 0, right: 0, bottom: 0, left: 0 },
+});
+await browser.close();
+console.log(`Done: ${output}`);

package/templates/.claude/skills/deck-create/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: deck-create
+description: Generate PDF slide decks from user requests using Playwright to render HTML slides to PDF. Use when the user asks to create a presentation, slide deck, or pitch deck. Pulls context from the knowledge base for company info, project details, and people.
+compatibility: Requires Node.js installed. Playwright is installed on first use.
+---
+
+# Create Presentations
+
+Generate PDF slide decks from user requests. Uses Playwright to render HTML
+slides to PDF. Can pull context from the knowledge base for company info,
+project details, and people.
+
+## Trigger
+
+Run when the user asks to create a presentation, slide deck, or pitch deck.
+
+## Prerequisites
+
+- Node.js installed
+- Playwright will be installed on first use
+
+## Inputs
+
+- User's description of the presentation
+- `knowledge/` — optional context about company, product, team, projects
+
+## Outputs
+
+- `~/Desktop/presentation.pdf` — the generated PDF presentation
+
+---
+
+## Workflow
+
+1.  Check `knowledge/` for relevant context about the company, product, team,
+    etc.
+2.  Ensure Playwright is installed:
+    `bun install playwright && bunx playwright install chromium`
+3.  Create an HTML file at `/tmp/outpost-presentation.html` with slides
+    (1280x720px each)
+4.  Include the required CSS from [references/slide.css](references/slide.css)
+5.  Run the conversion script:
+
+        node scripts/convert-to-pdf.mjs
+
+6.  Tell the user: "Your presentation is ready at ~/Desktop/presentation.pdf"
+
+**Do NOT show HTML code to the user. Just create the PDF and deliver it.**
+
+The conversion script accepts optional arguments:
+
+    node scripts/convert-to-pdf.mjs [input.html] [output.pdf]
+
+Defaults: input = `/tmp/outpost-presentation.html`, output =
+`~/Desktop/presentation.pdf`
+
+## PDF Rendering Rules
+
+**These prevent rendering issues in PDF:**
+
+1. **No layered elements** — Style content elements directly, no separate
+   background elements
+2. **No box-shadow** — Use borders instead: `border: 1px solid #e5e7eb`
+3. **Bullets via CSS only** — Use `li::before` pseudo-elements
+4. **Content must fit** — Slides are 1280x720px with 60px padding. Safe area is
+   1160x600px. Use `overflow: hidden`
+5. **No footers or headers** — No fixed/absolute positioned footer/header
+   elements
+
+## Constraints
+
+- Always use the knowledge base for context when available
+- Output to `~/Desktop/presentation.pdf` unless user specifies otherwise
+- Keep slides clean and readable — max 5-6 bullet points per slide
+- Use consistent styling throughout

package/templates/.claude/skills/deck-create/references/slide.css

@@ -0,0 +1,35 @@
+/* Required CSS for HTML slide decks rendered to PDF via Playwright.
+ *
+ * Include this in the <style> block of /tmp/outpost-presentation.html.
+ * See scripts/convert-to-pdf.mjs for the rendering script.
+ *
+ * PDF rendering rules:
+ * - No layered elements — style content directly, no separate backgrounds
+ * - No box-shadow — use borders: border: 1px solid #e5e7eb
+ * - Bullets via CSS only — use li::before pseudo-elements
+ * - Content must fit — safe area is 1160x600px (1280x720 minus 60px padding)
+ * - No footers or headers — no fixed/absolute positioned elements
+ */
+
+@page {
+  size: 1280px 720px;
+  margin: 0;
+}
+
+html {
+  -webkit-print-color-adjust: exact !important;
+  print-color-adjust: exact !important;
+}
+
+.slide {
+  width: 1280px;
+  height: 720px;
+  padding: 60px;
+  overflow: hidden;
+  page-break-after: always;
+  page-break-inside: avoid;
+}
+
+.slide:last-child {
+  page-break-after: auto;
+}

package/templates/.claude/skills/deck-create/scripts/convert-to-pdf.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env bun
+/**
+ * Convert HTML slides to PDF using Playwright.
+ *
+ * Renders an HTML file containing slide markup (1280x720px per slide) into a
+ * PDF document. Each slide is sized to exactly 1280x720 pixels with background
+ * colours and images preserved. Defaults to reading from /tmp and writing to
+ * ~/Desktop when no arguments are given.
+ *
+ * Requires: bun install playwright && bunx playwright install chromium
+ */
+
+import { join } from "node:path";
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+
+const HELP = `convert-to-pdf — render HTML slides to PDF via Playwright
+
+Usage: bun scripts/convert-to-pdf.mjs [input.html] [output.pdf] [-h|--help]
+
+Arguments:
+  input.html   HTML slides file (default: /tmp/outpost-presentation.html)
+  output.pdf   Output PDF path (default: ~/Desktop/presentation.pdf)
+
+Requires: bun install playwright && bunx playwright install chromium`;
+
+if (process.argv.includes("-h") || process.argv.includes("--help")) {
+  console.log(HELP);
+  process.exit(0);
+}
+
+const positional = process.argv.slice(2).filter((a) => !a.startsWith("-"));
+const input = positional[0] || "/tmp/outpost-presentation.html";
+const output = positional[1] || join(homedir(), "Desktop", "presentation.pdf");
+
+const { chromium } = await import("playwright");
+const browser = await chromium.launch();
+const page = await browser.newPage();
+await page.goto(`file://${resolve(input)}`, { waitUntil: "networkidle" });
+await page.pdf({
+  path: output,
+  width: "1280px",
+  height: "720px",
+  printBackground: true,
+});
+await browser.close();
+console.log(`Done: ${output}`);

package/templates/.claude/skills/deck-summarize/SKILL.md

@@ -0,0 +1,139 @@
+---
+name: deck-summarize
+description: Synthesize PowerPoint decks into engineer-friendly markdown briefs covering Jobs-To-Be-Done, dependencies, and synthetic data needs. Use when the user asks to break down, summarize, or make sense of a slide deck (.pptx) for engineering work.
+compatibility: Node.js only — no external dependencies.
+---
+
+# Synthesize Deck
+
+Turn messy PowerPoint specification decks into clear, actionable markdown briefs
+that forward deployed engineers can build from. Strip business jargon and focus
+on what matters: what needs to be built, what blocks progress, what data is
+needed to start prototyping.
+
+## Trigger
+
+The user asks to summarize, synthesize, or break down a `.pptx` deck; make sense
+of a specification or proposal deck for engineering; create an engineering brief
+from a slide deck; or understand what a project deck is actually asking for.
+
+## Prerequisites
+
+- Node.js 18+.
+- Input files must be `.pptx`.
+
+## Inputs
+
+- One or more `.pptx` file paths.
+- Optional: focus areas the engineer cares about.
+
+## Outputs
+
+- One markdown file per deck (or one combined file for related decks) written to
+  `knowledge/Projects/{Project Name} - Engineering Brief.md`.
+
+<do_confirm_checklist goal="Verify the brief is engineer-actionable before
+delivering">
+
+- [ ] No invented requirements — every claim traces to the deck.
+- [ ] Plain language; no marketing jargon (no "synergize", "orchestrate",
+      "leverage", "intelligent \_\_\_ hub").
+- [ ] JTBDs describe the user's goal, not the proposed solution; one job per
+      statement; each includes the "so that".
+- [ ] Data dependencies table flags blockers (missing, locked, compliance).
+- [ ] Synthetic data needs name fields, ranges, edge cases, and volume.
+- [ ] Gaps and open questions list what an engineer would notice missing.
+- [ ] Brief is under 2,000 lines — a summary, not a transcription.
+- [ ] Knowledge base looked up for mentioned people, orgs, and projects.
+
+</do_confirm_checklist>
+
+Output template and the data dependencies table:
+[references/brief-template.md](references/brief-template.md).
+
+## Procedure
+
+### 1. Extract text
+
+```bash
+node .claude/skills/deck-summarize/scripts/extract-pptx.mjs "$FILE_PATH"
+```
+
+For multiple decks, pass all files at once. To save the extracted text:
+
+```bash
+node .claude/skills/deck-summarize/scripts/extract-pptx.mjs "$FILE_PATH" -o /tmp/deck_extract.txt
+```
+
+Read all extracted text before continuing.
+
+### 2. Identify the core problem
+
+Plain-language answers to: what process exists today; what's broken, slow, or
+painful; who suffers. Don't restate the deck's framing.
+
+### 3. Extract Jobs-To-Be-Done
+
+Format: `When [situation], I need to [action], so that [outcome].`
+
+Group by user role/persona. One job per statement. Use the user's goal, not the
+proposed solution. A job should still make sense if you discard the deck's
+solution. Don't restate the deck's feature list as jobs and don't reuse its
+jargon.
+
+### 4. Map dependencies
+
+**4a. Data** — fill the table in
+[references/brief-template.md](references/brief-template.md#data-dependencies-table).
+Flag blockers (missing, locked, unstructured, compliance).
+
+**4b. Systems & integrations** — every external system/API/platform: what the
+integration does, read-only vs read-write, API vs manual/scraping, access
+confirmed?
+
+**4c. People & approvals** — approvals, reviews, or co-creation needed before
+engineering can proceed. Flag long lead-time items (legal, compliance, vendor
+contracts).
+
+### 5. Define synthetic-data needs
+
+For each core feature/use case:
+
+- **Generate:** entity, key fields and types, realistic value ranges and
+  distributions, edge cases that matter, volume for meaningful testing.
+- **Simulate:** workflows and state transitions, time-series patterns,
+  multi-actor interactions, error/failure modes.
+- **Format:** prefer CSV/JSON; PII-shaped fake data only — never real PII;
+  include happy-path _and_ adversarial examples; consider ML training/eval data.
+
+### 6. Translate the proposed solution
+
+Describe the build in engineering terms: components, what each does in plain
+terms, how they connect, end-to-end data flow, AI/ML capabilities and what
+they're actually doing. Translate branded names — e.g. "Intelligent Intake Hub"
+→ "OCR + NLP pipeline that extracts structured fields from scanned enrollment
+forms"; "Copay Guardian" → "Anomaly detection on weekly claims data".
+
+### 7. Identify what's missing
+
+Call out: features without clear data sources; AI capabilities without a
+training-data strategy; assumed integrations; user workflows that skip edge
+cases; metrics promised without measurement infrastructure; timeline–scope
+mismatches.
+
+### 8. Assemble the brief
+
+Use the structure in
+[references/brief-template.md](references/brief-template.md). Save to
+`knowledge/Projects/{Project Name} - Engineering Brief.md`. For multiple related
+decks, write one combined brief with shared dependencies.
+
+### 9. Save and report
+
+Tell the user the file path and give a 3-sentence project summary.
+
+## Writing style
+
+Plain language, concrete over abstract, honest about uncertainty, opinionated
+when helpful (flag dependency or timeline risks), short sentences. Engineers
+scan, they don't read essays.

package/templates/.claude/skills/deck-summarize/references/brief-template.md

@@ -0,0 +1,85 @@
+# Engineering Brief Template
+
+Reference template for `deck-summarize` Step 8. Save the assembled brief to
+`knowledge/Projects/{Project Name} - Engineering Brief.md`.
+
+```markdown
+---
+project: {Project Name}
+source: {list of deck filenames}
+date_synthesized: {today's date}
+status: engineering-brief
+---
+
+# {Project Name} — Engineering Brief
+
+> One-paragraph plain-English summary of what this project is and why it
+> exists.
+
+## The Problem
+
+{Step 2 output — what's broken, who it affects, why it matters}
+
+## Jobs-To-Be-Done
+
+### {Persona 1}
+- When [situation], I need to [action], so that [outcome].
+- ...
+
+### {Persona 2}
+- ...
+
+## What They Want to Build
+
+{Step 6 output — solution in engineering terms, components, data flow}
+
+### System Architecture (Simplified)
+
+{Text-based diagram or description of how components connect}
+
+### AI/ML Components
+
+{What models/capabilities are needed, what they do, what data they need}
+
+## Dependencies
+
+### Data
+{Step 4a table}
+
+### Systems & Integrations
+{Step 4b list}
+
+### People & Approvals
+{Step 4c list}
+
+## Synthetic Data for Prototyping
+
+### {Feature/Use Case 1}
+{Step 5 output}
+
+### {Feature/Use Case 2}
+{Step 5 output}
+
+## Gaps & Open Questions
+
+{Step 7 output as a numbered list}
+
+## Phasing
+
+{Timeline and wave structure from the deck, with engineering commentary on
+what's realistic and what depends on what}
+
+## Key Metrics
+
+{What success looks like, translated into measurable engineering terms}
+```
+
+## Data dependencies table
+
+For Step 4a, fill in this table. Flag any data that doesn't seem to exist yet,
+is locked behind inaccessible systems, is unstructured and would need heavy
+preprocessing, or carries compliance/privacy constraints.
+
+| Data        | Where It Lives             | Format                             | Access                          | Blocker?       |
+| ----------- | -------------------------- | ---------------------------------- | ------------------------------- | -------------- |
+| _What data_ | _System/team that owns it_ | _Structured/unstructured/API/file_ | _Do we have it? Can we get it?_ | _Yes/No + why_ |

package/templates/.claude/skills/deck-summarize/scripts/extract-pptx.mjs

@@ -0,0 +1,210 @@
+#!/usr/bin/env bun
+/**
+ * Extract text from PowerPoint (.pptx) slides.
+ *
+ * PPTX files are ZIP archives containing XML. This script extracts all text
+ * from each slide and outputs it as structured markdown with slide headings.
+ * Handles multiple files and outputs to stdout or a file.
+ *
+ * Usage:
+ *   node scripts/extract-pptx.mjs <path-to-pptx>
+ *   node scripts/extract-pptx.mjs <path-to-pptx> -o /tmp/extract.txt
+ *   node scripts/extract-pptx.mjs file1.pptx file2.pptx
+ *   node scripts/extract-pptx.mjs -h|--help
+ *
+ * No external dependencies — uses Node.js built-in modules only.
+ */
+
+import { readFileSync, writeFileSync } from "node:fs";
+import { basename } from "node:path";
+
+const HELP = `extract-pptx — extract slide text from .pptx files
+
+Usage:
+  node scripts/extract-pptx.mjs <file.pptx> [file2.pptx ...]
+  node scripts/extract-pptx.mjs <file.pptx> -o <output.txt>
+  node scripts/extract-pptx.mjs -h|--help
+
+Options:
+  -o <path>   Write output to file instead of stdout
+  -h, --help  Show this help
+
+Output: Markdown-formatted text with ## Slide N headings per slide.
+Multiple files get # Deck: filename.pptx headings.`;
+
+if (
+  process.argv.includes("-h") ||
+  process.argv.includes("--help") ||
+  process.argv.length < 3
+) {
+  console.log(HELP);
+  process.exit(process.argv.length < 3 ? 1 : 0);
+}
+
+// --- Parse arguments ---
+
+const args = process.argv.slice(2);
+let outputPath = null;
+const files = [];
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === "-o" && i + 1 < args.length) {
+    outputPath = args[++i];
+  } else if (!args[i].startsWith("-")) {
+    files.push(args[i]);
+  }
+}
+
+if (files.length === 0) {
+  console.error("Error: no .pptx files provided");
+  process.exit(1);
+}
+
+// --- ZIP parsing (no dependencies) ---
+
+/**
+ * Parse a ZIP file's central directory to extract file entries.
+ * @param {Buffer} buf
+ * @returns {Array<{name: string, offset: number, compressedSize: number, compressionMethod: number}>}
+ */
+function parseZipEntries(buf) {
+  // Find End of Central Directory record (signature 0x06054b50)
+  let eocdOffset = -1;
+  for (let i = buf.length - 22; i >= 0; i--) {
+    if (
+      buf[i] === 0x50 &&
+      buf[i + 1] === 0x4b &&
+      buf[i + 2] === 0x05 &&
+      buf[i + 3] === 0x06
+    ) {
+      eocdOffset = i;
+      break;
+    }
+  }
+  if (eocdOffset === -1) throw new Error("Not a valid ZIP file");
+
+  const cdOffset = buf.readUInt32LE(eocdOffset + 16);
+  const cdEntries = buf.readUInt16LE(eocdOffset + 10);
+
+  const entries = [];
+  let pos = cdOffset;
+
+  for (let e = 0; e < cdEntries; e++) {
+    // Central directory file header signature: 0x02014b50
+    if (buf.readUInt32LE(pos) !== 0x02014b50) break;
+
+    const compressionMethod = buf.readUInt16LE(pos + 10);
+    const compressedSize = buf.readUInt32LE(pos + 20);
+    const nameLen = buf.readUInt16LE(pos + 28);
+    const extraLen = buf.readUInt16LE(pos + 30);
+    const commentLen = buf.readUInt16LE(pos + 32);
+    const localHeaderOffset = buf.readUInt32LE(pos + 42);
+    const name = buf.toString("utf8", pos + 46, pos + 46 + nameLen);
+
+    entries.push({
+      name,
+      offset: localHeaderOffset,
+      compressedSize,
+      compressionMethod,
+    });
+    pos += 46 + nameLen + extraLen + commentLen;
+  }
+
+  return entries;
+}
+
+const { inflateRawSync } = await import("node:zlib");
+
+/**
+ * Read the uncompressed content of a ZIP entry.
+ * @param {Buffer} buf
+ * @param {{offset: number, compressedSize: number, compressionMethod: number}} entry
+ * @returns {Buffer}
+ */
+function readEntry(buf, entry) {
+  const pos = entry.offset;
+  const nameLen = buf.readUInt16LE(pos + 26);
+  const extraLen = buf.readUInt16LE(pos + 28);
+  const dataStart = pos + 30 + nameLen + extraLen;
+  const raw = buf.subarray(dataStart, dataStart + entry.compressedSize);
+
+  if (entry.compressionMethod === 0) return raw;
+  if (entry.compressionMethod === 8) return inflateRawSync(raw);
+  throw new Error(
+    `Unsupported compression method ${entry.compressionMethod} for ${entry.name}`,
+  );
+}
+
+/**
+ * Extract all text content from slide XML using the DrawingML namespace.
+ * Matches <a:t>text</a:t> elements used by PowerPoint.
+ * @param {string} xml
+ * @returns {string[]}
+ */
+function extractTextFromXml(xml) {
+  const texts = [];
+  const re = /<a:t>([^<]*)<\/a:t>/g;
+  let match;
+  while ((match = re.exec(xml)) !== null) {
+    const text = match[1].trim();
+    if (text) texts.push(text);
+  }
+  return texts;
+}
+
+/**
+ * Extract slide text from a .pptx file.
+ * @param {string} filePath
+ * @returns {string} Markdown-formatted slide text
+ */
+function extractPptx(filePath) {
+  const buf = readFileSync(filePath);
+  const entries = parseZipEntries(buf);
+
+  // Find slide XML files and sort by slide number
+  const slideEntries = entries
+    .filter(
+      (e) => e.name.startsWith("ppt/slides/slide") && e.name.endsWith(".xml"),
+    )
+    .sort((a, b) => {
+      const numA = parseInt(a.name.match(/(\d+)/)?.[1] || "0", 10);
+      const numB = parseInt(b.name.match(/(\d+)/)?.[1] || "0", 10);
+      return numA - numB;
+    });
+
+  const lines = [];
+
+  for (const entry of slideEntries) {
+    const xml = readEntry(buf, entry).toString("utf8");
+    const texts = extractTextFromXml(xml);
+
+    if (texts.length > 0) {
+      const num = entry.name.match(/(\d+)/)?.[1] || "?";
+      lines.push(`## Slide ${num}`);
+      lines.push(texts.join("\n"));
+      lines.push("");
+    }
+  }
+
+  return lines.join("\n");
+}
+
+// --- Main ---
+
+const outputs = [];
+
+for (const file of files) {
+  if (files.length > 1) {
+    outputs.push(`# Deck: ${basename(file)}\n`);
+  }
+  outputs.push(extractPptx(file));
+}
+
+const result = outputs.join("\n");
+
+if (outputPath) {
+  writeFileSync(outputPath, result);
+  console.log(`Extracted ${files.length} deck(s) → ${outputPath}`);
+} else {
+  process.stdout.write(result);
+}