@open-product-primer/cli 0.11.0 → 0.13.0

package/dist/cli.js

@@ -10,6 +10,7 @@ const update_1 = require("./commands/update");
 const doctor_1 = require("./commands/doctor");
 const migrate_1 = require("./commands/migrate");
 const measure_1 = require("./commands/measure");
+const ovw_1 = require("./commands/ovw");
 const package_json_1 = __importDefault(require("../package.json"));
 const program = new commander_1.Command();
 program
@@ -21,4 +22,5 @@ program.addCommand((0, update_1.updateCommand)());
 program.addCommand((0, doctor_1.doctorCommand)());
 program.addCommand((0, migrate_1.migrateCommand)());
 program.addCommand((0, measure_1.measureCommand)());
+program.addCommand((0, ovw_1.ovwCommand)());
 program.parse();

package/dist/commands/init.js

@@ -48,7 +48,7 @@ function initCommand() {
     return new commander_1.Command('init')
         .description('Initialize oprim in the current repository')
         .option('--name <name>', 'project name (defaults to directory name)')
-        .option('--agent <name>', 'AI agent to install skills for (repeatable; supported: claude, cursor)', (val, prev) => [...prev, val], [])
+        .option('--agent <name>', 'AI agent to install skills for (repeatable; supported: claude, cursor, codex, gemini, poolside)', (val, prev) => [...prev, val], [])
         .action(async (opts) => {
         const projectRoot = process.cwd();
         const projectName = opts.name ?? path.basename(projectRoot);

package/dist/commands/ovw.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function ovwCommand(): Command;

package/dist/commands/ovw.js

@@ -0,0 +1,263 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ovwCommand = ovwCommand;
+const commander_1 = require("commander");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const chalk_1 = __importDefault(require("chalk"));
+const yaml = __importStar(require("js-yaml"));
+function resolveBetDecisionPath(betsDir, betId) {
+    if (!fs.existsSync(betsDir))
+        return null;
+    const entries = fs.readdirSync(betsDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isDirectory() && entry.name.startsWith(betId)) {
+            const candidate = path.join(betsDir, entry.name, 'bet-decision.md');
+            if (fs.existsSync(candidate))
+                return candidate;
+        }
+    }
+    return null;
+}
+function extractDoorType(content) {
+    if (/\[x\]\s*2-way door/i.test(content))
+        return '2-way';
+    if (/\[x\]\s*1-way door/i.test(content))
+        return '1-way';
+    return null;
+}
+function extractRiskLevel(content, label) {
+    const match = content.match(new RegExp(`\\*\\*${label}\\*\\*:\\s*(Low|Medium|High)`, 'i'));
+    if (!match)
+        return null;
+    const raw = match[1];
+    if (raw.toLowerCase() === 'low')
+        return 'Low';
+    if (raw.toLowerCase() === 'medium')
+        return 'Medium';
+    if (raw.toLowerCase() === 'high')
+        return 'High';
+    return null;
+}
+function extractRiskProfile(content) {
+    return {
+        value: extractRiskLevel(content, 'Value risk'),
+        usability: extractRiskLevel(content, 'Usability risk'),
+        feasibility: extractRiskLevel(content, 'Feasibility risk'),
+        viability: extractRiskLevel(content, 'Business viability risk'),
+    };
+}
+function loadBetMeta(betsDir, betId) {
+    const decisionPath = resolveBetDecisionPath(betsDir, betId);
+    if (!decisionPath)
+        return { doorType: null, risks: null };
+    try {
+        const content = fs.readFileSync(decisionPath, 'utf-8');
+        return {
+            doorType: extractDoorType(content),
+            risks: extractRiskProfile(content),
+        };
+    }
+    catch {
+        return { doorType: null, risks: null };
+    }
+}
+function abbreviate(level) {
+    if (level === 'Low')
+        return 'L';
+    if (level === 'Medium')
+        return 'M';
+    if (level === 'High')
+        return 'H';
+    return '?';
+}
+function renderInlineMeta(meta) {
+    if (!meta.doorType && !meta.risks)
+        return '[risk: unknown]';
+    const door = meta.doorType ?? '?-way';
+    if (!meta.risks)
+        return `[${door} | risk: unknown]`;
+    const { value, usability, feasibility, viability } = meta.risks;
+    return `[${door} | value:${abbreviate(value)} usability:${abbreviate(usability)} feasibility:${abbreviate(feasibility)} viability:${abbreviate(viability)}]`;
+}
+function renderBlockers(bet) {
+    if (!bet.blocked_by || bet.blocked_by.length === 0)
+        return '';
+    return ` [blocked by: ${bet.blocked_by.join(', ')}]`;
+}
+function renderLane(label, bets, betsDir, showMeta) {
+    console.log(chalk_1.default.bold.cyan(`\n── ${label.toUpperCase()} ──`));
+    if (bets.length === 0) {
+        console.log('  (empty)');
+        return;
+    }
+    for (const bet of bets) {
+        if (showMeta) {
+            const meta = loadBetMeta(betsDir, bet.id);
+            const inline = renderInlineMeta(meta);
+            const blockers = renderBlockers(bet);
+            console.log(`  ${bet.id}  ${bet.title}  ${inline}${blockers}`);
+        }
+        else {
+            const blockers = renderBlockers(bet);
+            console.log(`  ${bet.id}  ${bet.title}${blockers}`);
+        }
+    }
+}
+function isElevated(level) {
+    return level === 'Medium' || level === 'High';
+}
+function buildAdvisory(board, betsDir) {
+    const nudges = [];
+    const now = board.now ?? [];
+    const next = board.next ?? [];
+    // Board-shape rules
+    if (now.length === 0) {
+        nudges.push('Now lane is empty — consider promoting a bet from next');
+    }
+    if (now.length > 3) {
+        nudges.push(`Focus risk: now lane has ${now.length} active bets — consider narrowing`);
+    }
+    for (const bet of now) {
+        const blockers = bet.blocked_by ?? [];
+        const inFlightIds = new Set([...now.map((b) => b.id), ...next.map((b) => b.id)]);
+        for (const blocker of blockers) {
+            if (!inFlightIds.has(blocker)) {
+                nudges.push(`${bet.id} may be stuck — its blocker ${blocker} is not in a flight lane`);
+            }
+        }
+    }
+    // Door-type sequencing rules
+    const inFlightIds = new Set([...now.map((b) => b.id), ...next.map((b) => b.id)]);
+    const metaCache = new Map();
+    const getMeta = (betId) => {
+        if (!metaCache.has(betId))
+            metaCache.set(betId, loadBetMeta(betsDir, betId));
+        return metaCache.get(betId);
+    };
+    const nowMetas = now.map((b) => ({ bet: b, meta: getMeta(b.id) }));
+    const nextMetas = next.map((b) => ({ bet: b, meta: getMeta(b.id) }));
+    const inFlightMetas = [...nowMetas, ...nextMetas];
+    // 2-way bets in flight that unlock 1-way bets (used to check unrisker presence)
+    const twowayUnlocks = new Set();
+    for (const { bet, meta } of inFlightMetas) {
+        if (meta.doorType === '2-way') {
+            for (const unlockedId of bet.unlocks ?? [])
+                twowayUnlocks.add(unlockedId);
+        }
+    }
+    const allNow1Way = nowMetas.length > 0 && nowMetas.every(({ meta }) => meta.doorType === '1-way');
+    if (allNow1Way) {
+        nudges.push('Your now lane has no 2-way door bets — you are in full-commitment mode with no reversible fallback');
+    }
+    for (const { bet, meta } of nowMetas) {
+        if (meta.doorType === '1-way' && !twowayUnlocks.has(bet.id)) {
+            nudges.push(`${bet.id} is a 1-way door with no 2-way door unrisker in flight — consider sequencing a reversible spike first`);
+        }
+    }
+    // 2-way door blocked by a 1-way door (inverted order)
+    for (const { bet, meta } of inFlightMetas) {
+        if (meta.doorType === '2-way') {
+            for (const blockerId of bet.blocked_by ?? []) {
+                const blockerMeta = getMeta(blockerId);
+                if (blockerMeta.doorType === '1-way') {
+                    nudges.push(`${bet.id} (2-way) is blocked by ${blockerId} (1-way) — order may be inverted; 2-way doors should precede 1-way doors`);
+                }
+            }
+        }
+    }
+    // Risk advisory rules for now lane
+    for (const { bet, meta } of nowMetas) {
+        if (!meta.risks)
+            continue;
+        const { value, usability, feasibility, viability } = meta.risks;
+        if (isElevated(value) && meta.doorType === '1-way') {
+            nudges.push(`${bet.id}: high commitment with unvalidated value — consider a 2-way door discovery bet first`);
+        }
+        if (isElevated(feasibility)) {
+            nudges.push(`${bet.id}: feasibility risk is elevated — ensure a spike or prototype is in plan before full build`);
+        }
+        if (isElevated(usability)) {
+            nudges.push(`${bet.id}: usability risk is elevated — plan for user testing before shipping`);
+        }
+        if (isElevated(viability)) {
+            nudges.push(`${bet.id}: business viability risk is elevated — align with stakeholders before committing`);
+        }
+    }
+    return nudges;
+}
+function ovwCommand() {
+    return new commander_1.Command('ovw')
+        .description('Show the sequencing board with door type, risk profile, and advisory guidance')
+        .action(() => {
+        const projectRoot = process.cwd();
+        const sequencePath = path.join(projectRoot, 'oprim', 'sequence.yaml');
+        const betsDir = path.join(projectRoot, 'oprim', 'bets');
+        if (!fs.existsSync(sequencePath)) {
+            console.error("No oprim/sequence.yaml found — run 'oprim init' first");
+            process.exit(1);
+            return;
+        }
+        let board;
+        try {
+            board = yaml.load(fs.readFileSync(sequencePath, 'utf-8')) ?? {};
+        }
+        catch {
+            console.error('Failed to parse oprim/sequence.yaml');
+            process.exit(1);
+            return;
+        }
+        const lanes = [
+            { key: 'now', label: 'now', showMeta: true },
+            { key: 'next', label: 'next', showMeta: true },
+            { key: 'later', label: 'later', showMeta: false },
+            { key: 'backlog', label: 'backlog', showMeta: false },
+        ];
+        for (const { key, label, showMeta } of lanes) {
+            renderLane(label, board[key] ?? [], betsDir, showMeta);
+        }
+        const nudges = buildAdvisory(board, betsDir);
+        if (nudges.length > 0) {
+            console.log(chalk_1.default.bold.yellow('\n── ADVISORY ──'));
+            for (const nudge of nudges) {
+                console.log(`  • ${nudge}`);
+            }
+        }
+    });
+}

package/dist/lib/detect.js

@@ -72,6 +72,8 @@ function detectAvailableAgents(projectRoot) {
         detected.push('codex');
     if (fs.existsSync(path.join(projectRoot, 'GEMINI.md')))
         detected.push('gemini');
+    if (fs.existsSync(path.join(projectRoot, '.poolside')))
+        detected.push('poolside');
     return detected;
 }
 function writeAgentsToConfig(agents, projectRoot) {

package/dist/lib/install-agent.d.ts

@@ -1,4 +1,4 @@
-export type Agent = 'claude' | 'cursor' | 'codex' | 'gemini';
+export type Agent = 'claude' | 'cursor' | 'codex' | 'gemini' | 'poolside';
 export declare const SUPPORTED_AGENTS: readonly Agent[];
 export declare function promptFrameworkSelection(projectRoot: string): Promise<string>;
 export declare function promptAgentSelection(projectRoot: string): Promise<string[]>;
@@ -7,8 +7,10 @@ export declare function installAgentSkills(agent: Agent, projectRoot: string, fr
 export declare const OPRIM_CONTEXT_SKILL_STEP = "## Step 0: Check relevant product decisions\nInvoke the `oprim:context` skill using the Skill tool. If matching PDRs are surfaced, review them before proceeding. If no PDRs match or `oprim/decisions/` is empty, the skill exits silently \u2014 continue to Step 1 immediately.";
 export declare const CLAUDE_SKILLS: Record<string, string>;
 export declare const CLAUDE_COMMANDS: Record<string, string>;
+export declare const POOLSIDE_SKILLS: Record<string, string>;
 export declare const CURSOR_SKILLS: Record<string, string>;
 export declare const CURSOR_COMMANDS: Record<string, string>;
 export declare function writeAgentInstructionFile(filePath: string, section: string): void;
 export declare function codexInstructions(): string;
 export declare function geminiInstructions(): string;
+export declare function poolsideInstructions(): string;

package/dist/lib/install-agent.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CURSOR_COMMANDS = exports.CURSOR_SKILLS = exports.CLAUDE_COMMANDS = exports.CLAUDE_SKILLS = exports.OPRIM_CONTEXT_SKILL_STEP = exports.SUPPORTED_AGENTS = void 0;
+exports.CURSOR_COMMANDS = exports.CURSOR_SKILLS = exports.POOLSIDE_SKILLS = exports.CLAUDE_COMMANDS = exports.CLAUDE_SKILLS = exports.OPRIM_CONTEXT_SKILL_STEP = exports.SUPPORTED_AGENTS = void 0;
 exports.promptFrameworkSelection = promptFrameworkSelection;
 exports.promptAgentSelection = promptAgentSelection;
 exports.promptPdrSurfacing = promptPdrSurfacing;
@@ -44,12 +44,13 @@ exports.installAgentSkills = installAgentSkills;
 exports.writeAgentInstructionFile = writeAgentInstructionFile;
 exports.codexInstructions = codexInstructions;
 exports.geminiInstructions = geminiInstructions;
+exports.poolsideInstructions = poolsideInstructions;
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const chalk_1 = __importDefault(require("chalk"));
 const scaffold_1 = require("./scaffold");
 const detect_1 = require("./detect");
-exports.SUPPORTED_AGENTS = ['claude', 'cursor', 'codex', 'gemini'];
+exports.SUPPORTED_AGENTS = ['claude', 'cursor', 'codex', 'gemini', 'poolside'];
 async function promptFrameworkSelection(projectRoot) {
     const configPath = path.join(projectRoot, '.claude', 'hooks', 'config.json');
     if (fs.existsSync(configPath)) {
@@ -87,6 +88,7 @@ async function promptAgentSelection(projectRoot) {
             { name: 'Cursor', value: 'cursor', checked: detected.includes('cursor') },
             { name: 'Codex', value: 'codex', checked: detected.includes('codex') },
             { name: 'Gemini CLI', value: 'gemini', checked: detected.includes('gemini') },
+            { name: 'Poolside', value: 'poolside', checked: detected.includes('poolside') },
         ],
     });
 }
@@ -170,6 +172,21 @@ function installAgentSkills(agent, projectRoot, framework = 'openspec', pdrSurfa
             console.log(chalk_1.default.dim('  .claude/ created — Claude Code will discover these files automatically.'));
         }
     }
+    else if (agent === 'poolside') {
+        const poolsideDir = path.join(projectRoot, '.poolside');
+        const dirCreated = !fs.existsSync(poolsideDir);
+        const skillsBase = path.join(poolsideDir, 'skills');
+        for (const [name, content] of Object.entries(exports.POOLSIDE_SKILLS)) {
+            (0, scaffold_1.writeFile)(path.join(skillsBase, name, 'SKILL.md'), content);
+            console.log(chalk_1.default.green('✓') + ` .poolside/skills/${name}/SKILL.md`);
+        }
+        const agentsFile = path.join(projectRoot, 'AGENTS.md');
+        writeAgentInstructionFile(agentsFile, poolsideInstructions());
+        console.log(chalk_1.default.green('✓') + ' AGENTS.md (oprim section written)');
+        if (dirCreated) {
+            console.log(chalk_1.default.dim('  .poolside/ created — Poolside will discover these files automatically.'));
+        }
+    }
     else if (agent === 'codex') {
         const agentsFile = path.join(projectRoot, 'AGENTS.md');
         writeAgentInstructionFile(agentsFile, codexInstructions());
@@ -280,6 +297,15 @@ exports.CLAUDE_COMMANDS = {
     'sequence.md': claudeWrapper('OPRIM: Sequence', 'Validate and update the primer sequencing board', sequenceContent()),
     'archive.md': claudeWrapper('OPRIM: Archive', 'Archive a completed bet — move it out of the active board', archiveCommandContent()),
 };
+// ─── Poolside skill playbooks ─────────────────────────────────────────────────
+exports.POOLSIDE_SKILLS = {
+    'oprim-pdr': pdrSkill(),
+    'oprim-bet': betSkill(),
+    'oprim-criteria': criteriaSkill(),
+    'oprim-review': reviewSkill(),
+    'oprim-archive': archiveSkill(),
+    'oprim-sequence': oprimSequenceSkill(),
+};
 // ─── Cursor skill playbooks ───────────────────────────────────────────────────
 exports.CURSOR_SKILLS = {
     'oprim-pdr': pdrSkill(),
@@ -426,6 +452,15 @@ If \`oprim/sequence.yaml\` not found: report and stop — advise \`oprim init\`.
 ### 4. Gather content
 Ask: Decision (Build now / Defer / Kill, default Build now), Owner, Review date (YYYY-MM-DD), Why now, Alternatives considered, Expected outcomes (metric: baseline → target in timeframe), Kill criteria / rollback trigger, PDR links (optional).
 
+Then ask about reversibility:
+- "Is this a **2-way door** (reversible — easy to undo, safe to try) or a **1-way door** (hard to reverse — requires high confidence)?"
+
+Then ask about each of the four risk dimensions (Low / Medium / High + short rationale):
+- "**Value risk**: Will users/customers actually use or buy this? (Low / Medium / High — and why?)"
+- "**Usability risk**: Can users figure out how to use it without help? (Low / Medium / High — and why?)"
+- "**Feasibility risk**: Can we build this with our current skills, time, and technology? (Low / Medium / High — and why?)"
+- "**Business viability risk**: Does this solution work for the business (revenue, legal, ops)? (Low / Medium / High — and why?)"
+
 ### 5. Write oprim/bets/BET-NNN-<slug>/bet-decision.md
 \`\`\`
 # Decision: BET-NNN <title>
@@ -437,6 +472,16 @@ Ask: Decision (Build now / Defer / Kill, default Build now), Owner, Review date
 - Owner: <owner>
 - Review date: <review date>
 
+## Door type
+- [<x if 2-way>] 2-way door (reversible — safe to try, easy to undo)
+- [<x if 1-way>] 1-way door (hard to reverse — requires higher confidence before committing)
+
+## Risk profile
+- **Value risk**: <Low / Medium / High> — <rationale>
+- **Usability risk**: <Low / Medium / High> — <rationale>
+- **Feasibility risk**: <Low / Medium / High> — <rationale>
+- **Business viability risk**: <Low / Medium / High> — <rationale>
+
 ## Why now
 <why-now as bullet list>
 
@@ -1108,3 +1153,6 @@ function codexInstructions() {
 function geminiInstructions() {
     return oprimWorkflowsInline();
 }
+function poolsideInstructions() {
+    return oprimWorkflowsInline();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-product-primer/cli",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "Open Product Primer CLI — product decisions, sequencing, and KPI tracking for repositories",
   "keywords": [
     "product",