@grainulation/wheat 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aid Idrizovic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,136 @@
+# wheat
+
+**You're about to mass-migrate 200 microservices. Slow down.**
+
+The migration will take months. It will cost real money. And right now, the decision to move is based on a Slack thread, a blog post, and a gut feeling from someone who left the company.
+
+Wheat exists because the most expensive engineering decisions are made with the least structured evidence. Not because people are careless -- because there's no tool that makes structured investigation feel natural.
+
+## The idea
+
+Wheat is a research sprint framework. You point it at a question -- "Should we migrate to Postgres?", "Is this architecture going to scale?", "Which vendor should we pick?" -- and it helps you build an evidence base before you commit.
+
+Every finding becomes a typed, evidence-graded claim. A constraint from your VP is different from a benchmark you ran, and wheat tracks the difference. When two findings contradict each other, the compiler catches it. When you try to ship a recommendation backed by nothing but blog posts, it warns you.
+
+The process is intentionally slow. You gather evidence from multiple sources. You grade how much you trust each piece. You challenge your own assumptions. Then -- and only then -- you compile it into a recommendation you can defend.
+
+If that sounds like a lot of work: it is. That's the point. The work happens before you commit a team to six months of migration, not after.
+
+## See it in 30 seconds
+
+```bash
+npx @grainulation/wheat quickstart
+```
+
+Creates a demo sprint with pre-seeded claims, an intentional conflict, compiles everything, and opens a dashboard. You'll see the compiler flag the conflict and block output until it's resolved.
+
+## Start a real sprint
+
+```bash
+npx @grainulation/wheat init
+```
+
+Wheat asks a few questions -- what you're investigating, who needs the answer, what constraints exist. Then it sets up the sprint in your repo:
+
+```
+claims.json          # Your evidence database
+CLAUDE.md            # AI assistant configuration
+.claude/commands/    # 17 research slash commands
+output/              # Where compiled artifacts land
+```
+
+Open Claude Code and start investigating:
+
+```
+/research "Postgres migration risks"
+/prototype                              # build something testable
+/challenge r003                         # stress-test a finding
+/blind-spot                             # what are we missing?
+/brief                                  # compile the decision document
+```
+
+## How it works
+
+Wheat uses a claim-based system inspired by compiler design:
+
+```
+You investigate  -->  Claims accumulate  -->  Compiler validates  -->  Artifacts compile
+   /research          claims.json            wheat compile            /brief, /present
+   /prototype         (typed, graded)        (7-pass pipeline)        (backed by evidence)
+   /challenge
+```
+
+**Claim types:** constraint, factual, estimate, risk, recommendation, feedback
+
+**Evidence tiers:** stated -> web -> documented -> tested -> production
+
+The compiler catches conflicts, warns about weak evidence, and blocks output when issues exist. You cannot ship a brief built on unresolved contradictions.
+
+## Works in any repo
+
+Wheat doesn't care what language you use. It runs via npx and stores sprint data in your repo. Your Scala project, your Python monorepo, your Flutter app -- wheat works the same everywhere.
+
+```bash
+# In a Scala repo
+npx @grainulation/wheat init
+
+# In a Python repo
+npx @grainulation/wheat init
+
+# Compiles anywhere Node 18+ is available
+npx @grainulation/wheat compile --summary
+```
+
+No dependencies are added to your project. No `node_modules` pollution. Wheat is a tool you run, not a library you import.
+
+## Guard rails
+
+Wheat installs two guard mechanisms:
+
+1. **Git pre-commit hook** -- prevents committing broken `claims.json`
+2. **Claude Code guard hook** -- prevents generating output artifacts from stale or blocked compilations
+
+Both are optional and can be removed. But they exist because the most dangerous moment in a research sprint is when you skip the process.
+
+## Commands
+
+| Command | What it does |
+|---------|-------------|
+| `/init` | Bootstrap a new research sprint |
+| `/research <topic>` | Deep dive on a topic, creates claims |
+| `/prototype` | Build something testable |
+| `/challenge <id>` | Adversarial stress-test of a claim |
+| `/witness <id> <url>` | External corroboration |
+| `/blind-spot` | Find gaps in your investigation |
+| `/status` | Sprint dashboard |
+| `/brief` | Compile the decision document |
+| `/present` | Generate a stakeholder presentation |
+| `/feedback` | Incorporate stakeholder input |
+| `/resolve` | Adjudicate conflicts between claims |
+| `/replay` | Time-travel through sprint history |
+| `/calibrate` | Score predictions against actual outcomes |
+| `/handoff` | Package sprint for knowledge transfer |
+| `/merge <path>` | Combine findings across sprints |
+| `/connect <type>` | Link external tools (Jira, docs, etc.) |
+
+## Documentation
+
+- **[Concepts](docs/concepts.md)** -- claims, phases, evidence tiers, the compiler
+- **[Commands](docs/commands.md)** -- every slash command with usage examples
+- **[FAQ](docs/faq.md)** -- setup, data, usage, and troubleshooting
+
+## Platform support
+
+Wheat runs on macOS, Linux, and Windows. All path handling uses `path.join`/`path.sep` internally, and git commands are invoked via `execFileSync` (no shell). The pre-commit hook requires Git Bash on Windows (bundled with Git for Windows).
+
+On Windows, use `npx @grainulation/wheat` directly -- Node 18+ is the only requirement.
+
+## Contributing
+
+We'd love your help. See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+Good first issues are labeled [`good first issue`](https://github.com/grainulation/wheat/labels/good%20first%20issue).
+
+## License
+
+MIT

package/bin/wheat.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+/**
+ * wheat — CLI entrypoint for the Wheat research sprint framework
+ *
+ * Usage:
+ *   wheat init                    Bootstrap a new sprint (conversational)
+ *   wheat init --question "..."   Quick mode (skip conversation)
+ *   wheat init --headless         Non-interactive mode (requires all flags)
+ *   wheat compile [--summary|--check|--gate]   Run the Bran compiler
+ *   wheat guard                   Run the PreToolUse guard hook
+ *   wheat status                  Quick sprint status
+ *   wheat stats                   Local sprint statistics (no phone-home)
+ *   wheat update                  Update slash commands in .claude/commands/
+ *   wheat mcp                     Start MCP server
+ *
+ * All operations resolve paths relative to --dir or process.cwd().
+ * The package ships framework code; sprint data stays in YOUR repo.
+ *
+ * Zero npm dependencies.
+ */
+
+import path from 'path';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { track as trackInstall, maybePrompt as installPrompt } from '../lib/install-prompt.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const VERSION = JSON.parse(readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8')).version;
+
+// ─── Parse arguments ─────────────────────────────────────────────────────────
+
+const verbose = process.argv.includes('--verbose');
+function vlog(...a) {
+  if (!verbose) return;
+  const ts = new Date().toISOString();
+  process.stderr.write(`[${ts}] wheat: ${a.join(' ')}\n`);
+}
+export { vlog, verbose };
+
+const args = process.argv.slice(2);
+const subcommand = args[0];
+
+vlog('startup', `subcommand=${subcommand || '(none)'}`, `cwd=${process.cwd()}`);
+
+// Extract --dir or --root flag (applies to all subcommands)
+let targetDir = process.cwd();
+const dirIdx = args.indexOf('--dir') !== -1 ? args.indexOf('--dir') : args.indexOf('--root');
+if (dirIdx !== -1 && args[dirIdx + 1]) {
+  targetDir = path.resolve(args[dirIdx + 1]);
+  args.splice(dirIdx, 2);
+}
+
+// Pass remaining args (minus subcommand) to subcommand handlers
+const subArgs = args.slice(1);
+
+// ─── Help / Version ──────────────────────────────────────────────────────────
+
+if (!subcommand || subcommand === '--help' || subcommand === '-h') {
+  console.log(`wheat v${VERSION} — Research-driven development framework
+
+Usage:
+  wheat <command> [options]
+
+Commands:
+  init       Bootstrap a new research sprint in this repo
+  quickstart Zero-to-dashboard demo sprint (under 90 seconds)
+  compile    Run the Bran compiler on claims.json
+  serve      Start the sprint dashboard UI
+  connect    Connect to external tools (e.g. wheat connect farmer)
+  disconnect Remove external tool hooks (e.g. wheat disconnect farmer)
+  guard      PreToolUse guard hook (used by Claude Code)
+  status     Quick sprint status check
+  stats      Local sprint statistics (no phone-home)
+  update     Copy/update slash commands to .claude/commands/
+  mcp        Start MCP server
+
+Global options:
+  --dir <path>   Target directory (default: current directory)
+  --json         Output as JSON (machine-readable)
+  --verbose      Enable verbose logging to stderr
+  --version      Show version
+  --help         Show this help
+
+Examples:
+  npx @grainulation/wheat quickstart
+  npx @grainulation/wheat init
+  npx @grainulation/wheat compile --summary
+  npx @grainulation/wheat init --question "Should we migrate to Postgres?"
+
+Documentation: https://github.com/grainulation/wheat`);
+  process.exit(0);
+}
+
+if (subcommand === '--version' || subcommand === '-v') {
+  console.log(`wheat v${VERSION}`);
+  process.exit(0);
+}
+
+// ─── Install prompt tracking ─────────────────────────────────────────────────
+// Track npx usage and maybe suggest installing. Both calls are sync, <5ms,
+// and fail silently. Only fires for real subcommands (not --help/--version).
+
+trackInstall(subcommand);
+installPrompt(subcommand);
+
+// ─── Dispatch ────────────────────────────────────────────────────────────────
+
+const commands = {
+  init:       '../lib/init.js',
+  quickstart: '../lib/quickstart.js',
+  compile:    '../lib/compiler.js',
+  guard:   '../lib/guard.js',
+  status:  '../lib/status.js',
+  stats:   '../lib/stats.js',
+  update:  '../lib/update.js',
+  serve:   '../lib/server.js',
+  mcp:     '../lib/serve-mcp.js',
+};
+
+// ─── wheat migrate (not yet implemented) ────────────────────────────────────
+if (subcommand === 'migrate') {
+  console.error('wheat migrate is not yet available');
+  process.exit(1);
+}
+
+
+// Handle "wheat connect <target>" as a compound subcommand
+if (subcommand === 'connect') {
+  const target = subArgs[0];
+  if (!target || target === '--help' || target === '-h') {
+    console.log(`wheat connect — Link external tools
+
+Usage:
+  wheat connect farmer [options]   Connect Farmer permission dashboard
+
+Run "wheat connect farmer --help" for options.`);
+    process.exit(0);
+  }
+  if (target === 'farmer') {
+    const connectModule = await import(new URL('../lib/connect.js', import.meta.url).href);
+    await connectModule.run(targetDir, subArgs.slice(1)).catch(err => {
+      console.error(`\nwheat connect farmer failed:`, err.message);
+      if (process.env.WHEAT_DEBUG) console.error(err.stack);
+      process.exit(1);
+    });
+    process.exit(0);
+  }
+  console.error(`wheat: unknown connect target: ${target}\nAvailable: farmer`);
+  process.exit(1);
+}
+
+// Handle "wheat disconnect <target>" as a compound subcommand
+if (subcommand === 'disconnect') {
+  const target = subArgs[0];
+  if (!target || target === '--help' || target === '-h') {
+    console.log(`wheat disconnect — Remove external tool hooks
+
+Usage:
+  wheat disconnect farmer [options]   Remove Farmer hooks from settings
+
+Run "wheat disconnect farmer --help" for options.`);
+    process.exit(0);
+  }
+  if (target === 'farmer') {
+    const disconnectModule = await import(new URL('../lib/disconnect.js', import.meta.url).href);
+    await disconnectModule.run(targetDir, subArgs.slice(1)).catch(err => {
+      console.error(`\nwheat disconnect farmer failed:`, err.message);
+      if (process.env.WHEAT_DEBUG) console.error(err.stack);
+      process.exit(1);
+    });
+    process.exit(0);
+  }
+  console.error(`wheat: unknown disconnect target: ${target}\nAvailable: farmer`);
+  process.exit(1);
+}
+
+if (!commands[subcommand]) {
+  console.error(`wheat: unknown command: ${subcommand}\n`);
+  console.error('Run "wheat --help" for available commands.');
+  process.exit(1);
+}
+
+// Load and run the subcommand module
+vlog('dispatch', `loading module for "${subcommand}"`);
+const modulePath = new URL(commands[subcommand], import.meta.url).href;
+const handler = await import(modulePath);
+handler.run(targetDir, subArgs).catch(err => {
+  console.error(`\nwheat ${subcommand} failed:`, err.message);
+  if (process.env.WHEAT_DEBUG) console.error(err.stack);
+  process.exit(1);
+});

package/compiler/detect-sprints.js

@@ -0,0 +1,319 @@
+#!/usr/bin/env node
+/**
+ * detect-sprints.js — Git-based sprint detection without config pointer
+ *
+ * Scans the repo for sprint indicators (claims.json files) and determines
+ * which sprint is "active" using filesystem + git heuristics:
+ *
+ *   1. Find all claims.json files (root + examples/ subdirs)
+ *   2. Read meta.phase — "archived" sprints are inactive
+ *   3. Query git log for most recent commit touching each claims.json
+ *   4. Rank by: non-archived > most recent git activity > most recent initiated date
+ *
+ * Returns a list of sprints with status (active/archived/example).
+ * Works without any config file — pure filesystem + git.
+ *
+ * Based on stakeholder feedback f001: config should not duplicate
+ * git-derivable state. Supersedes r020/r025 (config-based currentSprint).
+ *
+ * Usage:
+ *   node detect-sprints.js              # Human-readable output
+ *   node detect-sprints.js --json       # Machine-readable JSON
+ *   node detect-sprints.js --active     # Print only the active sprint path
+ *
+ * Zero npm dependencies (Node built-in only).
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { execFileSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+let ROOT = __dirname;
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+/** Safely parse JSON from a file path; returns null on failure. */
+function loadJSON(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get the ISO timestamp of the most recent git commit touching a file.
+ * Returns null if file is untracked or git is unavailable.
+ */
+function lastGitCommitDate(filePath) {
+  try {
+    const result = execFileSync('git', [
+      'log', '-1', '--format=%aI', '--', filePath
+    ], { cwd: ROOT, timeout: 5000, stdio: ['ignore', 'pipe', 'pipe'] });
+    const dateStr = result.toString().trim();
+    return dateStr || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Count git commits touching a file (proxy for activity level).
+ */
+function gitCommitCount(filePath) {
+  try {
+    const result = execFileSync('git', [
+      'rev-list', '--count', 'HEAD', '--', filePath
+    ], { cwd: ROOT, timeout: 5000, stdio: ['ignore', 'pipe', 'pipe'] });
+    return parseInt(result.toString().trim(), 10) || 0;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Derive a slug from the sprint's path or question.
+ * Root sprint gets slug from first few words of the question.
+ */
+function deriveName(sprintPath, meta) {
+  if (sprintPath !== '.') {
+    // examples/remote-farmer-sprint -> remote-farmer-sprint
+    return path.basename(sprintPath);
+  }
+  // Root sprint: derive from question
+  if (meta?.question) {
+    return meta.question
+      .toLowerCase()
+      .replace(/[^a-z0-9\s]/g, '')
+      .split(/\s+/)
+      .slice(0, 4)
+      .join('-');
+  }
+  return 'current';
+}
+
+// ─── Scanner ──────────────────────────────────────────────────────────────────
+
+/** Find all sprint roots (directories containing claims.json). */
+function findSprintRoots() {
+  const roots = [];
+
+  // 1. Root-level claims.json (current sprint)
+  const rootClaims = path.join(ROOT, 'claims.json');
+  if (fs.existsSync(rootClaims)) {
+    roots.push({ claimsPath: rootClaims, sprintPath: '.' });
+  }
+
+  // 2. Scan known subdirectories for sprint claims.json files
+  //    Root claims.json should NOT prevent scanning subdirs
+  const scanDirs = ['examples', 'sprints', 'archive'];
+  for (const dirName of scanDirs) {
+    const dir = path.join(ROOT, dirName);
+    if (!fs.existsSync(dir)) continue;
+    try {
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (!entry.isDirectory()) continue;
+        const claimsPath = path.join(dir, entry.name, 'claims.json');
+        if (fs.existsSync(claimsPath)) {
+          roots.push({
+            claimsPath,
+            sprintPath: path.join(dirName, entry.name),
+          });
+        }
+      }
+    } catch { /* skip if unreadable */ }
+  }
+
+  return roots;
+}
+
+// ─── Sprint Analysis ──────────────────────────────────────────────────────────
+
+/**
+ * Analyze a single sprint root and return structured info.
+ * @param {{ claimsPath: string, sprintPath: string }} root
+ * @returns {object} Sprint descriptor
+ */
+function analyzeSprint(root) {
+  const claims = loadJSON(root.claimsPath);
+  if (!claims) return null;
+
+  const meta = claims.meta || {};
+  const claimsList = claims.claims || [];
+
+  // Git activity signals
+  const lastCommit = lastGitCommitDate(root.claimsPath);
+  const commitCount = gitCommitCount(root.claimsPath);
+
+  // Phase-based status inference
+  const phase = meta.phase || 'unknown';
+  const isArchived = phase === 'archived' || phase === 'complete';
+  const isExample = root.sprintPath.startsWith('examples' + path.sep) || root.sprintPath.startsWith('examples/');
+
+  // Compute status
+  let status;
+  if (isArchived) {
+    status = 'archived';
+  } else if (isExample) {
+    status = 'example';
+  } else {
+    status = 'candidate'; // will be resolved to 'active' below
+  }
+
+  return {
+    name: deriveName(root.sprintPath, meta),
+    path: root.sprintPath,
+    question: meta.question || '',
+    phase,
+    initiated: meta.initiated || null,
+    last_git_activity: lastCommit,
+    git_commit_count: commitCount,
+    claims_count: claimsList.length,
+    active_claims: claimsList.filter(c => c.status === 'active').length,
+    status,
+  };
+}
+
+/**
+ * Detect all sprints and determine which is active.
+ *
+ * Heuristic ranking (highest to lowest priority):
+ *   1. Non-archived, non-example sprints (root-level candidates)
+ *   2. Most recent git commit touching claims.json
+ *   3. Most recent meta.initiated date
+ *   4. Highest claim count (tiebreaker)
+ *
+ * @returns {{ active: object|null, sprints: object[] }}
+ */
+export function detectSprints(rootDir) {
+  if (rootDir) ROOT = rootDir;
+  const roots = findSprintRoots();
+  const sprints = roots.map(analyzeSprint).filter(Boolean);
+
+  // Separate candidates from archived/examples
+  const candidates = sprints.filter(s => s.status === 'candidate');
+  const others = sprints.filter(s => s.status !== 'candidate');
+
+  // Rank candidates by git activity, then initiated date, then claim count
+  candidates.sort((a, b) => {
+    // Most recent git activity first
+    const dateA = a.last_git_activity ? new Date(a.last_git_activity).getTime() : 0;
+    const dateB = b.last_git_activity ? new Date(b.last_git_activity).getTime() : 0;
+    if (dateB !== dateA) return dateB - dateA;
+
+    // Most recent initiated date
+    const initA = a.initiated ? new Date(a.initiated).getTime() : 0;
+    const initB = b.initiated ? new Date(b.initiated).getTime() : 0;
+    if (initB !== initA) return initB - initA;
+
+    // More claims = more active
+    return b.claims_count - a.claims_count;
+  });
+
+  // Top candidate is active
+  let active = null;
+  if (candidates.length > 0) {
+    candidates[0].status = 'active';
+    active = candidates[0];
+  }
+
+  // If no root candidate, check examples — the one with most recent git activity
+  if (!active && others.length > 0) {
+    const nonArchived = others.filter(s => s.status !== 'archived');
+    if (nonArchived.length > 0) {
+      nonArchived.sort((a, b) => {
+        const dateA = a.last_git_activity ? new Date(a.last_git_activity).getTime() : 0;
+        const dateB = b.last_git_activity ? new Date(b.last_git_activity).getTime() : 0;
+        return dateB - dateA;
+      });
+      nonArchived[0].status = 'active';
+      active = nonArchived[0];
+    }
+  }
+
+  // Combine and sort: active first, then by last_git_activity
+  const allSprints = [...candidates, ...others].sort((a, b) => {
+    if (a.status === 'active' && b.status !== 'active') return -1;
+    if (b.status === 'active' && a.status !== 'active') return 1;
+    const dateA = a.last_git_activity ? new Date(a.last_git_activity).getTime() : 0;
+    const dateB = b.last_git_activity ? new Date(b.last_git_activity).getTime() : 0;
+    return dateB - dateA;
+  });
+
+  return { active, sprints: allSprints };
+}
+
+export { findSprintRoots, analyzeSprint };
+
+// ─── CLI (only when run directly, not when imported) ──────────────────────────
+
+const isMain = process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.argv[1]);
+
+if (isMain) {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`detect-sprints.js — Git-based sprint detection (no config required)
+
+Usage:
+  node detect-sprints.js              Human-readable sprint list
+  node detect-sprints.js --json       Machine-readable JSON output
+  node detect-sprints.js --active     Print only the active sprint path
+
+Detects sprints from claims.json files in the repo. Determines the active
+sprint using git commit history and metadata — no config pointer needed.
+Based on f001: config should not duplicate git-derivable state.`);
+    process.exit(0);
+  }
+
+  const rootIdx = args.indexOf('--root');
+  const rootArg = (rootIdx !== -1 && args[rootIdx + 1]) ? path.resolve(args[rootIdx + 1]) : undefined;
+
+  const t0 = performance.now();
+  const result = detectSprints(rootArg);
+  const elapsed = (performance.now() - t0).toFixed(1);
+
+  if (args.includes('--json')) {
+    console.log(JSON.stringify(result, null, 2));
+    process.exit(0);
+  }
+
+  if (args.includes('--active')) {
+    if (result.active) {
+      console.log(result.active.path);
+    } else {
+      console.error('No active sprint detected.');
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+
+  // Human-readable output
+  console.log(`Sprint Detection (${elapsed}ms)`);
+  console.log('='.repeat(50));
+  console.log(`Found ${result.sprints.length} sprint(s)\n`);
+
+  for (const sprint of result.sprints) {
+    const icon = sprint.status === 'active' ? '>>>' : '   ';
+    const statusTag = sprint.status.toUpperCase().padEnd(8);
+    console.log(`${icon} [${statusTag}] ${sprint.name}`);
+    console.log(`    Path:     ${sprint.path}`);
+    console.log(`    Phase:    ${sprint.phase}`);
+    console.log(`    Claims:   ${sprint.claims_count} total, ${sprint.active_claims} active`);
+    console.log(`    Initiated: ${sprint.initiated || 'unknown'}`);
+    console.log(`    Last git:  ${sprint.last_git_activity || 'untracked'}`);
+    console.log(`    Commits:   ${sprint.git_commit_count}`);
+    console.log(`    Question:  ${sprint.question.slice(0, 80)}${sprint.question.length > 80 ? '...' : ''}`);
+    console.log();
+  }
+
+  if (result.active) {
+    console.log(`Active sprint: ${result.active.path} (${result.active.name})`);
+  } else {
+    console.log('No active sprint detected.');
+  }
+}