murmur8 4.0.1 → 4.2.0

package/.blueprint/agents/TEAM_MANIFESTO.md

@@ -18,7 +18,7 @@ This is our shared manifesto — for every agent and the human. Read it before y
 
 ## We build things that matter
 
-We are not here to generate output. We are here to build a product that makes a real impact on the people or agents who use it. Every line of code, every test, every story should serve that purpose. If it doesn't make things better for the user, we ask why we're doing it. We enjoy building
+We are not here to generate output. We are here to build a product that makes a real impact on the people or agents who use it. Every line of code, every test, every story should serve that purpose. If it doesn't make things better for the user, we ask why we're doing it. We enjoy building great things. We don't just make slop! 
 
 ## We take pride in beautiful code
 

package/.blueprint/features/feature_export-history/FEATURE_SPEC.md

@@ -0,0 +1,215 @@
+# Feature Specification — Export Pipeline History
+
+## 1. Feature Intent
+
+**Why this feature exists.**
+
+Users need to extract pipeline history data for analysis, reporting, and integration with external tools. The existing `history` and `insights` commands provide on-demand viewing, but teams often require:
+
+- **Spreadsheet analysis** — CSV export for pivot tables, charts, and ad-hoc queries
+- **Custom dashboards** — JSON export for ingestion into monitoring tools or team portals
+- **Filtered exports** — Ability to slice data by date range, status, or specific features
+
+This feature supports the system purpose of **observability** (System Spec Section 8) by making pipeline execution data portable and actionable beyond the CLI.
+
+---
+
+## 2. Scope
+
+### In Scope
+
+- New `export` subcommand under `murmur8 history`
+- Export formats: CSV and JSON
+- Filtering options: `--since`, `--until`, `--status`, `--feature`
+- Output to stdout (default) or file via `--output`
+
+### Out of Scope
+
+- Export of queue state (`.claude/implement-queue.json`) — separate concern
+- Scheduled/automated exports — users can integrate via shell scripts
+- Direct integration with external services (Slack, email, dashboards)
+- Aggregated statistics export — `--stats` output remains display-only
+
+---
+
+## 3. Actors Involved
+
+### Human User
+
+- **Can:** Export history data in CSV or JSON format, apply filters, redirect to file
+- **Cannot:** Export queue state or insights aggregations through this command
+
+---
+
+## 4. Behaviour Overview
+
+**Happy Path:**
+
+1. User runs `murmur8 history export --format=csv`
+2. System reads `.claude/pipeline-history.json`
+3. System converts entries to CSV format
+4. System outputs to stdout
+
+**With Filters:**
+
+1. User runs `murmur8 history export --format=json --since=2024-01-01 --status=failed`
+2. System reads history, filters by date and status
+3. System outputs filtered JSON to stdout
+
+**To File:**
+
+1. User runs `murmur8 history export --format=csv --output=report.csv`
+2. System writes CSV to specified file
+3. System prints confirmation message
+
+**Edge Cases:**
+
+- Empty history: Output empty array/CSV header with no data rows
+- Corrupted history file: Warn and exit with non-zero status
+- No matches for filters: Output empty result (not an error)
+- Invalid date format: Error with usage hint
+
+---
+
+## 5. State & Lifecycle Interactions
+
+This feature is **state-reading only**. It does not modify pipeline state.
+
+- **Reads:** `.claude/pipeline-history.json`
+- **Does not modify:** Any state files or artifacts
+
+---
+
+## 6. Rules & Decision Logic
+
+### Format Selection Rule
+
+| `--format` value | Output |
+|------------------|--------|
+| `csv` (default) | Comma-separated values with header row |
+| `json` | Pretty-printed JSON array |
+
+### Date Filtering Rules
+
+- `--since=YYYY-MM-DD`: Include entries where `completedAt >= since`
+- `--until=YYYY-MM-DD`: Include entries where `completedAt <= until`
+- Both can be combined for a range
+- Dates are interpreted as start of day (00:00:00) in local timezone
+
+### Status Filtering Rule
+
+- `--status=success|failed|paused`: Include only entries with matching status
+- Multiple values not supported in v1 (e.g., no `--status=success,failed`)
+
+### Feature Filtering Rule
+
+- `--feature=<slug>`: Include only entries matching the feature slug
+- Exact match (not substring)
+
+### Output Destination Rule
+
+- No `--output`: Write to stdout
+- `--output=<path>`: Write to file, creating parent directories if needed
+
+---
+
+## 7. Dependencies
+
+### System Components
+
+- `src/history.js` — Existing `readHistoryFile()` function for reading history
+- `src/theme.js` — Optional colorization for confirmation messages
+
+### Data Format
+
+Relies on existing history entry structure:
+
+```javascript
+{
+  slug: string,
+  status: 'success' | 'failed' | 'paused',
+  startedAt: ISO8601,
+  completedAt: ISO8601,
+  totalDurationMs: number,
+  stages: { [stage]: { durationMs, feedback? } },
+  failedStage?: string,
+  pausedAfter?: string
+}
+```
+
+---
+
+## 8. Non-Functional Considerations
+
+### Performance
+
+- History files are typically small (<1MB). No streaming required for v1.
+- If performance becomes an issue with large histories, consider streaming JSON output.
+
+### Error Handling
+
+- Invalid date format: Exit with code 1, print usage hint
+- Missing history file: Treat as empty (not an error)
+- Corrupted history file: Exit with code 1, suggest `history clear`
+- File write error: Exit with code 1 with descriptive message
+
+---
+
+## 9. Assumptions & Open Questions
+
+### Assumptions
+
+- History file structure is stable (no migration needed)
+- Users have write permissions for `--output` destination
+- Date parsing uses native JavaScript Date (ISO 8601 format expected)
+
+### Open Questions
+
+- **Q:** Should we support `--limit` to cap exported rows?
+  - **A:** Defer to v2. Users can pipe to `head` for now.
+- **Q:** Should CSV include nested stage data?
+  - **A:** v1 exports top-level fields only. Stage details available in JSON.
+
+---
+
+## 10. Impact on System Specification
+
+This feature **reinforces** existing system assumptions:
+
+- Aligns with observability cross-cutting concern (System Spec Section 8)
+- Builds on existing history module without modifying its behavior
+- Does not introduce new state, lifecycle, or invariant changes
+
+No system spec changes required.
+
+---
+
+## 11. Handover to BA (Cass)
+
+### Story Themes
+
+1. **Basic Export** — Export history to CSV or JSON format
+2. **Date Filtering** — Filter exports by date range
+3. **Status Filtering** — Filter exports by pipeline status
+4. **Feature Filtering** — Filter exports by feature slug
+5. **File Output** — Write exports to a file instead of stdout
+
+### Expected Story Boundaries
+
+- Each filter type should be a separate story for independent testing
+- File output can be combined with basic export
+- Error handling can be implicit in each story's acceptance criteria
+
+### Areas Needing Careful Story Framing
+
+- CSV field ordering and escaping rules (commas, quotes in slugs)
+- Empty result behavior (should still output valid CSV/JSON structure)
+- Date parsing edge cases (timezone handling, invalid formats)
+
+---
+
+## 12. Change Log (Feature-Level)
+
+| Date | Change | Reason | Raised By |
+|------|--------|--------|-----------|
+| 2026-03-03 | Initial feature specification | Implement export-history from backlog | Alex |

package/.blueprint/features/feature_export-history/IMPLEMENTATION_PLAN.md

@@ -0,0 +1,48 @@
+# Implementation Plan — Export Pipeline History
+
+## Summary
+
+Add `exportHistory()` function to `src/history.js` that reads pipeline history, applies optional filters (date range, status, feature slug), and outputs CSV or JSON. Wire `history export` subcommand in CLI to invoke this function with parsed flags.
+
+## Files to Create/Modify
+
+| Path | Action | Purpose |
+|------|--------|---------|
+| `src/history.js` | Modify | Add `exportHistory()` function with filtering, CSV/JSON formatting, file output |
+| `bin/cli.js` | Modify | Add `export` subcommand to `history` handler, parse new flags |
+
+## Implementation Steps
+
+1. **Add date validation helper** in `src/history.js` — validate YYYY-MM-DD format, return Date or null
+
+2. **Add CSV formatter** in `src/history.js` — convert entry array to CSV string with header row (slug, status, startedAt, completedAt, totalDurationMs, failedStage, pausedAfter), escape commas/quotes in values
+
+3. **Add JSON formatter** in `src/history.js` — pretty-print array with 2-space indent
+
+4. **Implement `exportHistory(options)` function** in `src/history.js`:
+   - Read history via `readHistoryFile()`
+   - Return `{ exitCode: 1, error: '...' }` if corrupted
+   - Apply filters: `since`, `until`, `status`, `feature` (all optional)
+   - Validate date formats and status values, return error if invalid
+   - Format output as CSV (default) or JSON based on `options.format`
+   - If `options.output`: write to file (create parent dirs), return `{ message: '...' }`
+   - Otherwise return `{ output: '...' }` for stdout
+
+5. **Export `exportHistory`** from `src/history.js` module.exports
+
+6. **Add export subcommand handling** in `bin/cli.js`:
+   - In `history` command handler, check if `subArg === 'export'`
+   - Parse flags: `--format=csv|json`, `--since=YYYY-MM-DD`, `--until=YYYY-MM-DD`, `--status=success|failed|paused`, `--feature=<slug>`, `--output=<path>`
+   - Call `exportHistory()` with options object
+   - Print `result.output` to stdout or `result.message` for file confirmation
+   - Exit with `result.exitCode` if error
+
+7. **Update help text** in `showHelp()` to document `history export` and its flags
+
+8. **Run tests** — `node --test test/feature_export-history.test.js`
+
+## Risks/Questions
+
+- CSV escaping edge case: slugs containing commas or quotes need proper RFC 4180 escaping (wrap in quotes, double internal quotes)
+- Date filtering uses `completedAt` per spec; entries without `completedAt` should be excluded from date filters
+- Empty/missing history file treated as empty array (not an error per spec)

package/.blueprint/features/feature_export-history/story-basic-export.md

@@ -0,0 +1,48 @@
+# Story — Basic Export
+
+## User story
+
+As a developer, I want to export pipeline history to CSV or JSON format so that I can analyze execution data in spreadsheets or integrate with external tools.
+
+---
+
+## Acceptance criteria
+
+**AC-1 — Default CSV export to stdout**
+- Given the history file contains one or more entries,
+- When I run `murmur8 history export`,
+- Then the output is written to stdout in CSV format with a header row.
+
+**AC-2 — Explicit CSV format selection**
+- Given the history file contains entries,
+- When I run `murmur8 history export --format=csv`,
+- Then the output is CSV format with columns: slug, status, startedAt, completedAt, totalDurationMs, failedStage, pausedAfter.
+
+**AC-3 — JSON format selection**
+- Given the history file contains entries,
+- When I run `murmur8 history export --format=json`,
+- Then the output is a pretty-printed JSON array containing all history entries with their full structure.
+
+**AC-4 — Empty history produces valid structure**
+- Given the history file is empty or does not exist,
+- When I run `murmur8 history export --format=csv`,
+- Then the output is a CSV header row with no data rows.
+
+**AC-5 — Empty history produces valid JSON**
+- Given the history file is empty or does not exist,
+- When I run `murmur8 history export --format=json`,
+- Then the output is an empty JSON array `[]`.
+
+**AC-6 — Corrupted history file handling**
+- Given the history file contains invalid JSON,
+- When I run `murmur8 history export`,
+- Then the command exits with code 1 and displays an error message suggesting `history clear`.
+
+---
+
+## Out of scope
+
+- Exporting nested stage data in CSV (available in JSON only)
+- Streaming output for large files
+- Custom column selection
+- Export of queue state or insights aggregations

package/.blueprint/features/feature_export-history/story-date-filter.md

@@ -0,0 +1,42 @@
+# Story — Date Filtering
+
+## User story
+
+As a developer, I want to filter exported history by date range so that I can extract data for specific time periods for reporting or analysis.
+
+---
+
+## Acceptance criteria
+
+**AC-1 — Filter by since date**
+- Given the history file contains entries from multiple dates,
+- When I run `murmur8 history export --since=2024-01-15`,
+- Then only entries where `completedAt >= 2024-01-15T00:00:00` (local time) are included in the output.
+
+**AC-2 — Filter by until date**
+- Given the history file contains entries from multiple dates,
+- When I run `murmur8 history export --until=2024-01-20`,
+- Then only entries where `completedAt <= 2024-01-20T23:59:59` (local time) are included in the output.
+
+**AC-3 — Combined date range filter**
+- Given the history file contains entries from multiple dates,
+- When I run `murmur8 history export --since=2024-01-15 --until=2024-01-20`,
+- Then only entries within the inclusive date range are included in the output.
+
+**AC-4 — No matches returns empty result**
+- Given the history file contains entries but none within the specified range,
+- When I run `murmur8 history export --since=2099-01-01`,
+- Then the output is a valid empty structure (CSV header only or empty JSON array).
+
+**AC-5 — Invalid date format error**
+- Given an invalid date format is provided,
+- When I run `murmur8 history export --since=invalid-date`,
+- Then the command exits with code 1 and displays a usage hint showing the expected YYYY-MM-DD format.
+
+---
+
+## Out of scope
+
+- Time-of-day filtering (only date precision)
+- Timezone configuration (uses local timezone)
+- Relative date expressions (e.g., "last week")

package/.blueprint/features/feature_export-history/story-feature-filter.md

@@ -0,0 +1,42 @@
+# Story — Feature Filtering
+
+## User story
+
+As a developer, I want to filter exported history by feature slug so that I can extract execution data for a specific feature across all its runs.
+
+---
+
+## Acceptance criteria
+
+**AC-1 — Filter by exact feature slug**
+- Given the history file contains entries for multiple features,
+- When I run `murmur8 history export --feature=user-auth`,
+- Then only entries where `slug === 'user-auth'` are included in the output.
+
+**AC-2 — Exact match only**
+- Given the history file contains entries for "user-auth" and "user-auth-v2",
+- When I run `murmur8 history export --feature=user-auth`,
+- Then only entries with exact slug "user-auth" are included (not "user-auth-v2").
+
+**AC-3 — No matches returns empty result**
+- Given the history file contains entries but none matching the specified slug,
+- When I run `murmur8 history export --feature=nonexistent`,
+- Then the output is a valid empty structure (CSV header only or empty JSON array).
+
+**AC-4 — Combine with other filters**
+- Given the history file contains multiple entries for a feature with different statuses,
+- When I run `murmur8 history export --feature=user-auth --status=failed`,
+- Then only entries matching both the feature slug AND the status are included.
+
+**AC-5 — Case-sensitive matching**
+- Given the history file contains an entry with slug "User-Auth",
+- When I run `murmur8 history export --feature=user-auth`,
+- Then no entries are returned (matching is case-sensitive).
+
+---
+
+## Out of scope
+
+- Substring or pattern matching
+- Multiple feature slugs in a single filter
+- Case-insensitive matching option

package/.blueprint/features/feature_export-history/story-file-output.md

@@ -0,0 +1,48 @@
+# Story — File Output
+
+## User story
+
+As a developer, I want to write exported history directly to a file so that I can save reports without shell redirection and receive confirmation of the write.
+
+---
+
+## Acceptance criteria
+
+**AC-1 — Write to specified file**
+- Given the history file contains entries,
+- When I run `murmur8 history export --output=report.csv`,
+- Then the export is written to `report.csv` in the current directory.
+
+**AC-2 — Success confirmation message**
+- Given the export writes successfully,
+- When I run `murmur8 history export --output=report.csv`,
+- Then a confirmation message is displayed showing the file path and entry count.
+
+**AC-3 — Create parent directories**
+- Given the output path includes directories that do not exist,
+- When I run `murmur8 history export --output=reports/2024/january.csv`,
+- Then the parent directories are created and the file is written.
+
+**AC-4 — Combine with format option**
+- Given the history file contains entries,
+- When I run `murmur8 history export --format=json --output=report.json`,
+- Then the file contains JSON-formatted export data.
+
+**AC-5 — File write error handling**
+- Given the output path is not writable (e.g., permission denied),
+- When I run `murmur8 history export --output=/readonly/report.csv`,
+- Then the command exits with code 1 and displays a descriptive error message.
+
+**AC-6 — Overwrite existing file**
+- Given a file already exists at the output path,
+- When I run `murmur8 history export --output=existing.csv`,
+- Then the existing file is overwritten without prompting.
+
+---
+
+## Out of scope
+
+- Interactive overwrite confirmation
+- Append mode for existing files
+- Automatic file extension based on format
+- Output to multiple files

package/.blueprint/features/feature_export-history/story-status-filter.md

@@ -0,0 +1,42 @@
+# Story — Status Filtering
+
+## User story
+
+As a developer, I want to filter exported history by pipeline status so that I can analyze specific outcomes like failures or successful runs.
+
+---
+
+## Acceptance criteria
+
+**AC-1 — Filter by success status**
+- Given the history file contains entries with mixed statuses,
+- When I run `murmur8 history export --status=success`,
+- Then only entries with `status === 'success'` are included in the output.
+
+**AC-2 — Filter by failed status**
+- Given the history file contains entries with mixed statuses,
+- When I run `murmur8 history export --status=failed`,
+- Then only entries with `status === 'failed'` are included in the output.
+
+**AC-3 — Filter by paused status**
+- Given the history file contains entries with mixed statuses,
+- When I run `murmur8 history export --status=paused`,
+- Then only entries with `status === 'paused'` are included in the output.
+
+**AC-4 — No matches returns empty result**
+- Given the history file contains entries but none with the specified status,
+- When I run `murmur8 history export --status=failed`,
+- Then the output is a valid empty structure (CSV header only or empty JSON array).
+
+**AC-5 — Invalid status value error**
+- Given an invalid status value is provided,
+- When I run `murmur8 history export --status=unknown`,
+- Then the command exits with code 1 and displays an error listing valid status values: success, failed, paused.
+
+---
+
+## Out of scope
+
+- Multiple status values in a single filter (e.g., `--status=success,failed`)
+- Negation filters (e.g., exclude failed)
+- Custom status values

package/README.md

@@ -1,8 +1,8 @@
 # murmur8
 
-A multi-agent workflow framework for automated feature development. Like a murmuration of starlings — individual agents moving together as one, each responding to its neighbours to create something greater than the sum of its parts.
+A multi-agent workflow framework for automated feature development In Claude Code and Copilot CLI. Four specialised AI agents collaborate in sequence to take features from specification to implementation, with built-in feedback loops and self-improvement capabilities.
 
-Four specialized AI agents collaborate in sequence to take features from specification to implementation, with built-in feedback loops and self-improvement capabilities.
+Like a murmuration of starlings, individual agents move together as one, each responding to its neighbours to create something greater than the sum of its parts.
 
 ## Upgrading to v4.0
 
@@ -98,6 +98,13 @@ This updates `.blueprint/agents/`, `.blueprint/templates/`, `.blueprint/ways_of_
 | `npx murmur8 history --stats` | View aggregate statistics |
 | `npx murmur8 history --all` | View all runs |
 | `npx murmur8 history clear` | Clear history |
+| `npx murmur8 history export` | Export history as CSV (default) |
+| `npx murmur8 history export --format=json` | Export as JSON |
+| `npx murmur8 history export --since=YYYY-MM-DD` | Filter by start date |
+| `npx murmur8 history export --until=YYYY-MM-DD` | Filter by end date |
+| `npx murmur8 history export --status=<status>` | Filter by status (success/failed/paused) |
+| `npx murmur8 history export --feature=<slug>` | Filter by feature slug |
+| `npx murmur8 history export --output=<path>` | Write to file instead of stdout |
 | `npx murmur8 insights` | Analyze patterns and get recommendations |
 | `npx murmur8 insights --feedback` | View feedback correlation analysis |
 | `npx murmur8 insights --bottlenecks` | View bottleneck analysis |
@@ -363,6 +370,30 @@ $ npx murmur8 insights
 - Avg duration: 14 min → 11 min (improving)
 ```
 
+## Multi-CLI Support (v4.1)
+
+The `/implement-feature` skill works with both **Claude Code** and **GitHub Copilot CLI**. During initialization, murmur8 installs the skill to both locations:
+
+| CLI | Location |
+|-----|----------|
+| Claude Code | `.claude/commands/implement-feature.md` |
+| Copilot CLI | `.github/skills/implement-feature/SKILL.md` |
+
+The Copilot CLI location is a symlink to the Claude Code master, ensuring both tools use identical skill definitions.
+
+### Usage
+
+```bash
+# Initialize (installs skill for both CLIs)
+npx murmur8 init
+
+# Then use either CLI:
+/implement-feature user-auth    # Works in Claude Code
+/implement-feature user-auth    # Works in Copilot CLI
+```
+
+Both CLIs execute the same pipeline: Alex → Cass → Nigel → Codey. The skill uses each CLI's native agent/task mechanism.
+
 ## Token Efficiency (v2.7)
 
 Version 2.7 introduces several optimizations to reduce token usage:

package/bin/cli.js

@@ -4,7 +4,7 @@ const { init } = require('../src/init');
 const { update } = require('../src/update');
 const { displayQueue, resetQueue } = require('../src/orchestrator');
 const { validate, formatOutput } = require('../src/validate');
-const { displayHistory, showStats, clearHistory } = require('../src/history');
+const { displayHistory, showStats, clearHistory, exportHistory } = require('../src/history');
 const { displayInsights } = require('../src/insights');
 const { displayConfig, setConfigValue, resetConfig } = require('../src/retry');
 const {
@@ -87,6 +87,26 @@ const commands = {
       const flags = parseFlags(args);
       if (subArg === 'clear') {
         await clearHistory({ force: flags.force });
+      } else if (subArg === 'export') {
+        const exportOpts = {};
+        for (const arg of args) {
+          if (arg.startsWith('--format=')) exportOpts.format = arg.split('=')[1];
+          if (arg.startsWith('--since=')) exportOpts.since = arg.split('=')[1];
+          if (arg.startsWith('--until=')) exportOpts.until = arg.split('=')[1];
+          if (arg.startsWith('--status=')) exportOpts.status = arg.split('=')[1];
+          if (arg.startsWith('--feature=')) exportOpts.feature = arg.split('=')[1];
+          if (arg.startsWith('--output=')) exportOpts.output = arg.split('=')[1];
+        }
+        const result = await exportHistory(exportOpts);
+        if (result.exitCode) {
+          console.error(`Error: ${result.error}`);
+          process.exit(result.exitCode);
+        }
+        if (result.message) {
+          console.log(result.message);
+        } else if (result.output) {
+          console.log(result.output);
+        }
       } else if (flags.stats) {
         showStats();
       } else {
@@ -339,6 +359,13 @@ Commands:
   history --stats       View aggregate statistics
   history clear         Clear all pipeline history (with confirmation)
   history clear --force Clear all pipeline history (no confirmation)
+  history export        Export history as CSV (default) or JSON
+  history export --format=json  Export as JSON
+  history export --since=YYYY-MM-DD  Filter entries on or after date
+  history export --until=YYYY-MM-DD  Filter entries on or before date
+  history export --status=<status>   Filter by status (success|failed|paused)
+  history export --feature=<slug>    Filter by feature slug
+  history export --output=<path>     Write to file instead of stdout
   insights              Analyze pipeline for bottlenecks, failures, and trends
   insights --bottlenecks Show only bottleneck analysis
   insights --failures   Show only failure patterns

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "murmur8",
-  "version": "4.0.1",
+  "version": "4.2.0",
   "description": "Multi-agent workflow framework for automated feature development",
   "main": "src/index.js",
   "bin": {
@@ -15,6 +15,7 @@
     "ai",
     "automation",
     "claude",
+    "copilot",
     "feature-development"
   ],
   "author": "NewmanJustice",

package/src/history.js

@@ -100,6 +100,96 @@ function formatDuration(ms) {
   return `${minutes}m ${secs}s`;
 }
 
+function isValidDateFormat(dateStr) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(dateStr)) return false;
+  const date = new Date(dateStr);
+  return !isNaN(date.getTime());
+}
+
+function escapeCSVField(value) {
+  if (value === null || value === undefined) return '';
+  const str = String(value);
+  if (str.includes(',') || str.includes('"') || str.includes('\n')) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
+
+function formatCSV(entries) {
+  const headers = ['slug', 'status', 'startedAt', 'completedAt', 'totalDurationMs', 'failedStage', 'pausedAfter'];
+  const lines = [headers.join(',')];
+  for (const entry of entries) {
+    const row = headers.map(h => escapeCSVField(entry[h]));
+    lines.push(row.join(','));
+  }
+  return lines.join('\n');
+}
+
+function formatJSON(entries) {
+  return JSON.stringify(entries, null, 2);
+}
+
+async function exportHistory(options = {}) {
+  const { format = 'csv', since, until, status, feature, output } = options;
+
+  const history = readHistoryFile();
+
+  if (history.error === 'corrupted') {
+    return { exitCode: 1, error: "History file is corrupted. Run 'murmur8 history clear' to reset." };
+  }
+
+  if (since && !isValidDateFormat(since)) {
+    return { exitCode: 1, error: 'Invalid --since format. Use YYYY-MM-DD.' };
+  }
+
+  if (until && !isValidDateFormat(until)) {
+    return { exitCode: 1, error: 'Invalid --until format. Use YYYY-MM-DD.' };
+  }
+
+  const validStatuses = ['success', 'failed', 'paused'];
+  if (status && !validStatuses.includes(status)) {
+    return { exitCode: 1, error: `Invalid --status value. Use: success, failed, paused.` };
+  }
+
+  let filtered = history;
+
+  if (since) {
+    const sinceDate = new Date(since);
+    filtered = filtered.filter(e => e.completedAt && new Date(e.completedAt) >= sinceDate);
+  }
+
+  if (until) {
+    const untilDate = new Date(until);
+    untilDate.setDate(untilDate.getDate() + 1);
+    filtered = filtered.filter(e => e.completedAt && new Date(e.completedAt) < untilDate);
+  }
+
+  if (status) {
+    filtered = filtered.filter(e => e.status === status);
+  }
+
+  if (feature) {
+    filtered = filtered.filter(e => e.slug === feature);
+  }
+
+  const formatted = format === 'json' ? formatJSON(filtered) : formatCSV(filtered);
+
+  if (output) {
+    try {
+      const dir = path.dirname(output);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(output, formatted);
+      return { message: `Exported ${filtered.length} entries to ${output}` };
+    } catch (err) {
+      return { exitCode: 1, error: err.message };
+    }
+  }
+
+  return { output: formatted };
+}
+
 function formatDate(isoString) {
   const date = new Date(isoString);
   return date.toISOString().replace('T', ' ').slice(0, 19);
@@ -292,5 +382,6 @@ module.exports = {
   displayHistory,
   showStats,
   clearHistory,
-  formatDuration
+  formatDuration,
+  exportHistory
 };

package/src/init.js

@@ -41,7 +41,7 @@ function copyDir(src, dest) {
 function updateGitignore() {
   const gitignorePath = path.join(TARGET_DIR, '.gitignore');
   const entriesToAdd = [
-    '# agent-workflow',
+    '# murmur8',
     '.claude/implement-queue.json',
     '.claude/pipeline-history.json',
     '.claude/stack-config.json'
@@ -61,6 +61,40 @@ function updateGitignore() {
   }
 }
 
+/**
+ * Create symlink for Copilot CLI
+ * Links .github/skills/implement-feature/SKILL.md -> .claude/commands/implement-feature.md
+ */
+function createCopilotSymlink() {
+  const copilotSkillDir = path.join(TARGET_DIR, '.github', 'skills', 'implement-feature');
+  const copilotSkillPath = path.join(copilotSkillDir, 'SKILL.md');
+  const claudeSkillPath = path.join(TARGET_DIR, '.claude', 'commands', 'implement-feature.md');
+
+  // Relative path from .github/skills/implement-feature/ to .claude/commands/
+  const relativePath = path.relative(copilotSkillDir, claudeSkillPath);
+
+  // Create directory
+  fs.mkdirSync(copilotSkillDir, { recursive: true });
+
+  // Remove existing symlink or file
+  if (fs.existsSync(copilotSkillPath)) {
+    fs.unlinkSync(copilotSkillPath);
+  }
+
+  // Create symlink
+  try {
+    fs.symlinkSync(relativePath, copilotSkillPath);
+    console.log('Created Copilot CLI symlink at .github/skills/implement-feature/SKILL.md');
+    return true;
+  } catch (err) {
+    console.warn(`Warning: Could not create symlink: ${err.message}`);
+    // Fallback: copy the file instead
+    fs.copyFileSync(claudeSkillPath, copilotSkillPath);
+    console.log('Copied skill to .github/skills/implement-feature/SKILL.md (symlink failed)');
+    return false;
+  }
+}
+
 async function init() {
   const blueprintSrc = path.join(PACKAGE_ROOT, '.blueprint');
   const blueprintDest = path.join(TARGET_DIR, '.blueprint');
@@ -74,25 +108,27 @@ async function init() {
   if (fs.existsSync(blueprintDest)) {
     const answer = await prompt('.blueprint directory already exists. Overwrite? (y/N): ');
     if (answer !== 'y' && answer !== 'yes') {
-      console.log('Aborted. Use "agent-workflow update" to update existing installation.');
+      console.log('Aborted. Use "murmur8 update" to update existing installation.');
       return;
     }
     fs.rmSync(blueprintDest, { recursive: true });
   }
 
-  // Copy skill to .claude/commands/ for Claude Code discovery
+  // Copy skill to .claude/commands/ (master location)
   fs.mkdirSync(claudeCommandsDir, { recursive: true });
   if (fs.existsSync(skillCommandDest)) {
     const answer = await prompt('.claude/commands/implement-feature.md already exists. Overwrite? (y/N): ');
     if (answer !== 'y' && answer !== 'yes') {
-      console.log('Skipping skill command');
+      console.log('Skipping skill installation');
     } else {
       fs.copyFileSync(skillSrc, skillCommandDest);
       console.log('Copied skill to .claude/commands/implement-feature.md');
+      createCopilotSymlink();
     }
   } else {
     fs.copyFileSync(skillSrc, skillCommandDest);
     console.log('Copied skill to .claude/commands/implement-feature.md');
+    createCopilotSymlink();
   }
 
   // Copy .blueprint directory
@@ -132,7 +168,7 @@ murmur8 initialized successfully!
 Next steps:
 1. Review your tech stack with \`npx murmur8 stack-config\`
 2. Add business context documents to .business_context/
-3. Run /implement-feature in Claude Code to start your first feature
+3. Run /implement-feature in Claude Code or Copilot CLI to start your first feature
 `);
 }