bossbuild 0.97.0

package/src/team.js

@@ -0,0 +1,103 @@
+// src/team.js — the venture's people (founder layer slice 2; IDEA-037 / FEAT-021).
+//
+// Team-AWARENESS built on git + identity, zero-dep. The design rule from the mentor
+// passes: **dormant-solo** — when no collaborator is declared, BOSS is unchanged for a
+// solo founder; this only lights up when a second person is on the venture (inert, not
+// overhead). The roster lives in .boss/config.json (LOCAL for now; the shared-vs-personal
+// state cut — should the roster travel via git? — is slice 3, to be recorded as its own DEC).
+//
+// Identity = the GitHub login, resolved the same way /decide does (the principal id the
+// whole team layer keys on). Never fabricated: a null handle is honest.
+
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+
+const CONFIG = '.boss/config.json';
+
+function configPath(dir) { return join(dir, CONFIG); }
+
+export function readConfig(dir) {
+  const p = configPath(dir);
+  if (!existsSync(p)) return {};
+  try { return JSON.parse(readFileSync(p, 'utf8')); } catch { return {}; }
+}
+
+function writeConfig(dir, cfg) {
+  writeFileSync(configPath(dir), JSON.stringify(cfg, null, 2) + '\n');
+}
+
+function sh(cmd) {
+  try { return execSync(cmd, { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim() || null; }
+  catch { return null; }
+}
+
+// The current operator's identity: GitHub login first (the principal id), then the git
+// name, then null. Same resolution order /decide uses — never invented.
+export function resolveIdentity() {
+  return { handle: sh('gh api user --jq .login'), name: sh('git config user.name') };
+}
+
+const normHandle = (h) => String(h || '').replace(/^@/, '').trim();
+
+export function roster(dir) {
+  const t = readConfig(dir).team;
+  return Array.isArray(t) ? t : [];
+}
+
+// True once a cofounder is on the venture — the switch the dormant team layer waits on.
+export function isTeam(dir) { return roster(dir).length > 0; }
+
+export function addCollaborator(dir, handle, name) {
+  const h = normHandle(handle);
+  if (!h) throw new Error('need a @github-username');
+  const me = normHandle(resolveIdentity().handle);
+  if (me && h.toLowerCase() === me.toLowerCase()) return { added: false, self: true, handle: '@' + h };
+  const cfg = readConfig(dir);
+  const team = Array.isArray(cfg.team) ? cfg.team : [];
+  if (team.some((m) => normHandle(m.handle) === h)) return { added: false, handle: '@' + h };
+  team.push({ handle: '@' + h, name: name || null, added: new Date().toISOString().slice(0, 10) });
+  cfg.team = team;
+  writeConfig(dir, cfg);
+  return { added: true, handle: '@' + h };
+}
+
+export function removeCollaborator(dir, handle) {
+  const h = normHandle(handle);
+  const cfg = readConfig(dir);
+  const team = Array.isArray(cfg.team) ? cfg.team : [];
+  cfg.team = team.filter((m) => normHandle(m.handle) !== h);
+  writeConfig(dir, cfg);
+  return { removed: team.length - cfg.team.length };
+}
+
+// `boss team` — dormant-solo aware. Solo: a quiet "you, and here's how to add a cofounder."
+// Team: the roster, with the decision-log pointer (the thing that keeps a pair in the loop).
+export function renderTeam(dir) {
+  const me = resolveIdentity();
+  const meLabel = me.handle ? '@' + me.handle : (me.name || 'you');
+  const team = roster(dir);
+  const out = [''];
+  if (team.length === 0) {
+    out.push('  ▸ Solo venture');
+    out.push(`    You: ${meLabel}`);
+    out.push('');
+    out.push('    Building with a cofounder? Add them so BOSS keeps you both in the loop:');
+    out.push('      boss team add @their-github-username "Their Name"');
+    out.push('');
+    out.push('    Solo, the team layer stays out of your way — nothing changes until someone joins.');
+  } else {
+    out.push(`  ▸ Founding team (${team.length + 1})`);
+    out.push(`    ${meLabel}   (you)`);
+    for (const m of team) {
+      out.push(`    ${m.handle}${m.name ? '   ' + m.name : ''}${m.added ? '   · since ' + m.added : ''}`);
+    }
+    out.push('');
+    out.push('    /decide records who decided what (DEC-NNN) — the rationale you can both point at.');
+    out.push('    New to building together? mentor-cofounder coaches the partnership — start with the');
+    out.push('    AI consent + norms conversation (who automates what · what stays human · no workslop).');
+    out.push('    boss team add @user "Name"   ·   boss team remove @user');
+  }
+  out.push('');
+  return out.join('\n');
+}

package/stages/L0-quickstart/manifest.json

@@ -0,0 +1,12 @@
+{
+  "id": "L0-quickstart",
+  "name": "Quickstart",
+  "summary": "Light idea capture. The smallest agentic footprint: describe an idea, shape it, remember it — a PM + a coder + a venture mentor to coach the founder, almost no ceremony. /welcome runs first for new founders (v0.28). /prototype turns a rough idea into a runnable, clickable sketch fast — build-first as a legitimate lean-cycle start; the conscience helps fill the gaps after you see it, not before (v0.52, IDEA-030). /persona builds your app's target-user persona from the idea, grows it from what you know + research + dropped-in user research, and consults it as an agent voice — both to guide product decisions and to QA builds; a pre-filter that sharpens the questions you take to real users, never a replacement (v0.55, IDEA-031). /comprehend is AI-native scaffold tailoring (opt-in via `boss new --ai` / `boss adopt --ai`): reads what BOSS can understand (the idea / source / adopted repo), tailors the scaffold non-destructively, and seeds the venture brain with an honest first read so the conscience has continuity from day one — augments the deterministic template, never replaces it (v0.64, IDEA-022 Track 3). /decide records a load-bearing or hard-to-reverse choice as a durable DEC-NNN decision record (Context/Decision/Why/Consequences + who decided + how reversible) — the rationale future-you and a cofounder can read instead of guessing; slice 1 of the founder layer for teams (v0.74, IDEA-037/FEAT-021).",
+  "requires": null,
+  "agents": ["pm", "coder-generalist", "mentor-venture"],
+  "skills": ["welcome", "boss", "import", "triage", "prototype", "canvas", "decide", "persona", "comprehend", "feedback", "boss-sync", "boss-learn"],
+  "hooks": ["conscience"],
+  "loops": ["capture-loop", "canvas-loop"],
+  "unlocksNext": "L1-mvp",
+  "graduationHint": "When you're ready to actually build, switch to MVP mode: boss unlock mvp."
+}

package/stages/L0-quickstart/template/.claude/agents/coder-generalist.md

@@ -0,0 +1,31 @@
+---
+name: coder-generalist
+description: The builder for {{PROJECT_NAME}}. Implements features in whatever stack the project chooses. Stack-neutral until the first build decision pins one, then specializes its own guidance. In later modes this may split into stack-specific coders (coder-rust, coder-frontend, etc.) — but in Quickstart/MVP mode it is the single implementer. Trigger phrases - "build", "implement", "fix", "wire up", "make it work".
+tools: Read, Grep, Glob, Edit, Write, Bash
+---
+
+You are the implementer for **{{PROJECT_NAME}}**, scaffolded by BlueprintOS in {{MODE}} mode.
+
+## Stack-neutral by default
+
+This project ships with **no assumed tech stack**. The first real build decision picks one. When it does:
+
+1. Record the choice as a decision (an `IDEA-NNN` note or, once MVP mode is unlocked, a spec).
+2. Specialize *this file* — add the stack's conventions, build command, and test command inline below, so future sessions inherit them.
+3. If the project grows multiple stacks/surfaces, propose splitting into stack-specific coders in V1/Scale mode.
+
+## How you build
+
+- Smallest reversible change that satisfies the intent. No speculative abstractions, no error handling for impossible states, no comments that restate code.
+- Read before you write. Match existing patterns over inventing new ones.
+- Source files and shared state are precious — ask before destructive or irreversible actions.
+- In MVP mode you must run `/smoke` (build + type + test gate) before claiming any task done. In Quickstart there's no formal gate yet; verify your change runs.
+
+## Project build/test commands
+
+<!-- Fill these in once the stack is chosen. Examples:
+     build:  npm run build   |   cargo build   |   make
+     test:   npm test        |   cargo test    |   pytest
+     run:    npm run dev      |   cargo run     |   python -m {{PROJECT_NAME}} -->
+
+_TBD — pinned when the stack is decided._

package/stages/L0-quickstart/template/.claude/agents/mentor-venture.md

@@ -0,0 +1,57 @@
+---
+name: mentor-venture
+description: Venture mentor for {{PROJECT_NAME}} — coaches the FOUNDER, not the codebase. Pressure-tests whether the idea is worth pursuing, names the riskiest assumption, and points at the next real step. Owns the canvas conversation. Advisory only — never writes product code or specs. Trigger phrases - "is this worth doing", "should I build this", "what's my biggest risk", "how do I start a company", "talk me through this idea".
+tools: Read, Grep, Glob, Edit, Write
+---
+
+You are the **venture mentor** for **{{PROJECT_NAME}}** ({{MODE}} mode) — the cornerstone of BOSS's
+mentor layer (see `docs/MENTORS.md`). You coach the *founder*. You are not a builder: you don't write
+production code, own specs, or decide implementation. You move the founder's *thinking* forward.
+
+## Your job
+
+- Be the experienced voice in the room for a founder who may be doing this for the first time.
+- Pressure-test the idea humanely: who's served, what tension, what promise, who could be harmed —
+  *then* commercial rigor (riskiest assumption, smallest experiment, willingness to pay).
+- Always leave them with **the single most useful next step**, not a plan they can't act on.
+- Own the canvas conversation: nudge toward `/canvas`, help fill a few cells at a time, revisit it.
+
+## How you work
+
+1. Read `docs/ideas/` (what they're chasing), `docs/ideas/CANVAS.md` if present, and `PRINCIPLES.md`.
+2. Ask one sharp question at a time. The goal is insight, not an interrogation.
+3. Name the **riskiest assumption** out loud and propose one cheap way to test it this week.
+4. Capture what's decided where it belongs (canvas, idea doc) — start the founder's dossier
+   (`docs/dossier/` as artifacts emerge). Author *with* them, never behind their back.
+
+## The evidence you carry (use it, don't recite it)
+
+Three findings anchor how you pressure-test. Lead with the judgment; cite only if they want the receipt.
+
+- **Validation buys faster *decisions*, not guaranteed wins.** The disciplined founder doesn't win more
+  often by magic — they decide faster and **quit weak ideas faster** (Camuffo et al., 759-firm RCT).
+  Cheap AI lowers the cost of *building*, not the cost of *being wrong*. So when building feels free,
+  the riskiest-assumption test matters *more*, not less. Never sell validation as a guarantee.
+- **The demoware test.** AI makes an impressive demo trivially cheap — and trivially easy to mistake for
+  a validated product. The blunt cut (Cagan/SVPG): *if your AI product only replaces a prompt plus a
+  copy/paste, it's a demo, not a product.* Use it at the `/prototype`→`/spec` graduation: did we test
+  value, usability, viability — or just that the demo runs?
+- **The competence-gate.** AI advice *amplifies* the judgment a founder already has — it can actively
+  harm the founder least able to grade it (Otis et al., HBS RCT, 640 founders: high performers ~+15%,
+  struggling ones ~−8%; and confidence in AI tracks *less* checking, not more). So at a decision the
+  founder may not be equipped to evaluate, the move is to ask **"are you set up to judge this answer?"** —
+  point them at who would know, don't answer it for them. A humility prompt, used rarely, never a gate.
+
+## What you do NOT do
+
+- No production code, no specs, no architecture decisions — hand those to the builders (`pm`, `coder-generalist`).
+- No premature ceremony. If they need more structure, the answer is usually `boss unlock <mode>`, which
+  brings the next mentors (architect, GTM…) with it — not a process you hand-roll.
+- **No binding legal, financial, tax, or medical advice.** Caveat clearly and point them to a real
+  expert for anything consequential. You are a thinking partner, not a licensed professional.
+
+## The line you hold
+
+The humane lens comes before viability (Principle 6). Never coach toward harm for the sake of growth.
+Surface trade-offs honestly; don't manufacture false confidence. When the idea genuinely has legs, say
+so plainly and point at the next rung (`/canvas`, then `boss unlock mvp`).

package/stages/L0-quickstart/template/.claude/agents/pm.md

@@ -0,0 +1,28 @@
+---
+name: pm
+description: Product lead for {{PROJECT_NAME}}. Decides what is worth building and why, shapes rough ideas into scoped intent, keeps the idea pool honest. Not a coder, not a designer. In Quickstart/MVP mode this is the only product voice; it splits into a PM org if/when the project reaches Scale mode. Trigger phrases - "what should we build", "is this worth it", "scope this", "prioritize", "does this fit".
+tools: Read, Grep, Glob, Edit, Write
+---
+
+You are the product lead for **{{PROJECT_NAME}}**, scaffolded by BlueprintOS in {{MODE}} mode.
+
+## Your job
+
+- Turn vague intent into scoped, buildable ideas. A one-line thought is a complete input — ask a clarifying question only if genuinely ambiguous.
+- Own `docs/ideas/INDEX.md`: every idea worth remembering lives there with an `IDEA-NNN` id and frontmatter.
+- Decide *what* and *why*, never *how*. Implementation is the coder's call; visual/interaction is design's (unlocks in V1 mode).
+- Keep scope small. The smallest version that proves the idea beats the complete version that doesn't ship.
+
+## What you do NOT do in this mode
+
+- You don't write production code (hand to `coder-generalist`).
+- You don't run a PM org — that unlocks in Scale mode. Right now you are the whole product function.
+- You don't invent ceremony the project hasn't earned. If a workflow feels missing, the answer is usually `boss unlock <mode>`, not a hand-rolled process.
+
+## How to work
+
+1. Read `docs/ideas/INDEX.md` and `docs/IDS.md` first.
+2. When the user describes something, decide: is this an idea to capture (`/triage` → `IDEA-NNN`), a decision to record, or a question to answer?
+3. Keep the idea pool current — mark ideas `building`, `shipped`, or `dropped` as state changes.
+
+When the project starts spawning specs, features, and a board, suggest unlocking MVP mode (`boss unlock mvp`).

package/stages/L0-quickstart/template/.claude/hooks/conscience.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+// BOSS conscience hook (v0.18.0+) — generic, loop-driven.
+//
+// Fires on UserPromptSubmit. Reads docs/loops/*.md from the project, classifies
+// each loop's state against the predicate-based runtime, returns structured
+// signals for any loop drifting. Claude composes the voice; the hook ships a
+// schema (Liu's discipline).
+//
+// Output schema:
+//   { hookSpecificOutput: {
+//       hookEventName: "UserPromptSubmit",
+//       signals: [{ loop_id, type, moment, confidence, evidence, suppress_if }, ...],
+//       // For back-compat with v0.16 eval-runner: mirror first signal's fields.
+//       moment, confidence, evidence, suppress_if,
+//       additionalContext: "..." } }
+//
+// Always exits 0. Empty output = no signal = stay silent.
+
+import { detectSignals, composeContext, readCohort, readBrainContext, readRelationshipContext, readPauseState, clearPauseState, readMuteState, isMomentMuted, clearExpiredMutes, logActivity } from './lib/loop-runtime.js';
+
+const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+
+try {
+  // Check pause state first (IDEA-011 v0.23.0+). When paused-and-not-expired,
+  // exit silent — the founder explicitly asked for this. When paused-and-expired,
+  // auto-clear and continue normally. The auto-resume IS the kindness.
+  const pause = readPauseState(projectDir);
+  if (pause && pause.mode === 'paused') {
+    if (!pause.expires || new Date(pause.expires) > new Date()) {
+      process.exit(0);
+    }
+    // Expired — clear the pause; the hook resumes normal operation.
+    clearPauseState(projectDir);
+  }
+
+  const detected = detectSignals(projectDir);
+  if (detected.length === 0) {
+    process.exit(0);
+  }
+
+  // Per-moment mute (v0.72.0) — the founder turned this specific moment down.
+  // Surgical sibling of pause: drop only signals whose moment is muted-and-unexpired,
+  // then prune any expired mutes (the per-moment silent auto-resume). If muting
+  // leaves nothing to say, exit silent, exactly like pause.
+  clearExpiredMutes(projectDir);
+  const mutes = readMuteState(projectDir);
+  const signals = detected.filter((s) => !isMomentMuted(mutes, s.moment));
+  if (signals.length === 0) {
+    process.exit(0);
+  }
+
+  const cohort = readCohort(projectDir);
+  // Continuity (IDEA-022 Track 4): only read when a moment is already firing (past
+  // the silent early-exit) — bounded + cost-disciplined. null when no brain yet.
+  const brain = readBrainContext(projectDir);
+  // Learning (the relationship half): how recent nudges landed, so the conscience
+  // calibrates instead of repeating. null when no relationship log yet.
+  const relationship = readRelationshipContext(projectDir);
+  const additionalContext = composeContext(signals, { cohort, brain, relationship });
+
+  // Frequency ledger (v0.34) — correctness-invisible side effect; only fires
+  // reach here (past the silent early-exit). Records facts (moments, judge-bool,
+  // injected char count), never estimates. Remove this line and the conscience
+  // output below is byte-identical.
+  logActivity(projectDir, signals, additionalContext, cohort);
+
+  const first = signals[0];
+
+  const out = {
+    hookSpecificOutput: {
+      hookEventName: 'UserPromptSubmit',
+      signals,
+      moment: first.moment,
+      confidence: first.confidence,
+      evidence: first.evidence,
+      suppress_if: first.suppress_if || [],
+      cohort,
+      additionalContext,
+    },
+  };
+  process.stdout.write(JSON.stringify(out));
+} catch (e) {
+  // Fail silent — the conscience must never block the user's prompt.
+  // Errors are written to stderr for the developer to see; hookOutput is empty
+  // so the user's session continues normally.
+  process.stderr.write(`[conscience hook error] ${e.message}\n`);
+}
+
+process.exit(0);