@open-product-primer/cli 2.1.0 → 2.2.0

package/dist/lib/workflow-schema.js

@@ -0,0 +1,126 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadWorkflowSchema = loadWorkflowSchema;
+exports.loadWorkflowTemplate = loadWorkflowTemplate;
+exports.loadWorkflowVariant = loadWorkflowVariant;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+// Bundled workflow definitions ship inside the compiled package at dist/workflows/ (copied
+// there at build time by scripts/copy-workflow-assets.js — see package.json's "build" script).
+const BUNDLED_DIR = path.join(__dirname, '..', 'workflows');
+function overridesDir(projectRoot) {
+    return path.join(projectRoot, 'oprim', 'workflows');
+}
+function requireField(obj, field, filePath) {
+    if (!(field in obj) || obj[field] === undefined || obj[field] === null) {
+        throw new Error(`Invalid workflow schema at ${filePath}: missing required field "${field}"`);
+    }
+    return obj[field];
+}
+function parseSchema(raw, filePath) {
+    let doc;
+    try {
+        doc = yaml.load(raw);
+    }
+    catch (err) {
+        throw new Error(`Invalid workflow schema at ${filePath}: ${err.message}`);
+    }
+    if (typeof doc !== 'object' || doc === null || Array.isArray(doc)) {
+        throw new Error(`Invalid workflow schema at ${filePath}: expected a YAML mapping`);
+    }
+    const obj = doc;
+    requireField(obj, 'id', filePath);
+    requireField(obj, 'description', filePath);
+    const claude = requireField(obj, 'claude', filePath);
+    const cursor = requireField(obj, 'cursor', filePath);
+    const poolside = requireField(obj, 'poolside', filePath);
+    requireField(obj, 'inline', filePath);
+    return {
+        id: obj.id,
+        skillName: obj.skillName ?? null,
+        title: obj.title ?? null,
+        description: obj.description,
+        cursorDescription: obj.cursorDescription ?? null,
+        claude: { skill: Boolean(claude.skill), command: claude.command ?? null },
+        cursor: { skill: Boolean(cursor.skill), command: cursor.command ?? null },
+        poolside: { skill: Boolean(poolside.skill) },
+        inline: Boolean(obj.inline),
+        variants: obj.variants ?? null,
+    };
+}
+/**
+ * Loads a workflow's schema.yaml, resolving a project-level
+ * `oprim/workflows/<id>.schema.yaml` override over the CLI-bundled default.
+ * Throws an actionable, file-naming error if an override exists but fails to parse
+ * or is missing required fields — never silently falls back to the bundled default.
+ */
+function loadWorkflowSchema(id, projectRoot) {
+    if (projectRoot) {
+        const overridePath = path.join(overridesDir(projectRoot), `${id}.schema.yaml`);
+        if (fs.existsSync(overridePath)) {
+            return parseSchema(fs.readFileSync(overridePath, 'utf-8'), overridePath);
+        }
+    }
+    const bundledPath = path.join(BUNDLED_DIR, `${id}.schema.yaml`);
+    return parseSchema(fs.readFileSync(bundledPath, 'utf-8'), bundledPath);
+}
+/**
+ * Loads a workflow's template.md, resolving a project-level
+ * `oprim/workflows/<id>.template.md` override over the CLI-bundled default.
+ */
+function loadWorkflowTemplate(id, projectRoot) {
+    if (projectRoot) {
+        const overridePath = path.join(overridesDir(projectRoot), `${id}.template.md`);
+        if (fs.existsSync(overridePath)) {
+            return fs.readFileSync(overridePath, 'utf-8');
+        }
+    }
+    const bundledPath = path.join(BUNDLED_DIR, `${id}.template.md`);
+    return fs.readFileSync(bundledPath, 'utf-8');
+}
+/**
+ * Loads a bundled, non-overridable variant file (Cursor's condensed command body, the
+ * Codex/Gemini/Poolside inline section, promote's per-framework bodies). Only
+ * `<id>.schema.yaml` and `<id>.template.md` are project-forkable — see
+ * workflow-schema-authoring spec. Returns null if the workflow has no such variant.
+ */
+function loadWorkflowVariant(filename) {
+    const p = path.join(BUNDLED_DIR, filename);
+    if (!fs.existsSync(p))
+        return null;
+    return fs.readFileSync(p, 'utf-8');
+}

package/dist/workflows/archive.inline.md

@@ -0,0 +1,10 @@
+### Bet archiving (oprim-archive)
+Archive a completed bet.
+
+1. Ask for bet ID (accept bet-005, 005, 5, BET-005 — normalize to BET-NNN).
+2. Verify `oprim/bets/BET-NNN/` exists.
+3. Check `oprim/sequence.yaml` for entries where `blocked_by` or `unlocks` reference the target bet — warn if found. Also check other active bet dirs for delta specs against the same requirement (matching `### Requirement:` headers, whitespace-insensitive) — warn if an overlap is found. Ask "Archive anyway? (y/N)" if either warning fires.
+4. If `oprim/bets/BET-NNN/specs/` exists, fold each capability's `## ADDED`/`## MODIFIED`/`## REMOVED Requirements` delta into `oprim/specs/<capability>/spec.md` (matching by `### Requirement:` header; create the current-truth file if the delta is entirely ADDED) — last-write-wins on overlaps, no 3-way merge. Skip this step entirely if no `specs/` dir is present.
+5. Move directory: `oprim/bets/BET-NNN → oprim/bets/archived/BET-NNN`.
+6. Remove the bet entry from `oprim/sequence.yaml`.
+7. Report what was done.

package/dist/workflows/archive.schema.yaml

@@ -0,0 +1,13 @@
+id: archive
+skillName: oprim-archive
+title: "OPRIM: Archive"
+description: Archive a completed bet — move it out of the active board
+claude:
+  skill: true
+  command: archive.md
+cursor:
+  skill: false
+  command: null
+poolside:
+  skill: true
+inline: true

package/dist/workflows/archive.template.md

@@ -0,0 +1,106 @@
+---
+name: oprim-archive
+description: Archive a completed bet — moves it to oprim/bets/archived/, removes its sequence.yaml entry, and folds any spec deltas under its specs/ directory into oprim/specs/ current truth
+---
+
+Archive a completed bet by moving it to `oprim/bets/archived/`, removing it from `sequence.yaml`, and (if present) merging its spec deltas into current truth.
+
+**Interactive prompts:** Use the **AskUserQuestion tool** for every question in this skill — do not write questions as plain text.
+
+## Steps
+
+### 1. Get the bet ID
+
+If provided as an argument (e.g., `/oprim:archive BET-005`), use it directly.
+
+If not provided, ask: "Which bet ID would you like to archive? (e.g., BET-005)"
+
+Normalize the input: accept `bet-005`, `005`, `5`, or `BET-005` — always treat as `BET-NNN` zero-padded to 3 digits.
+
+### 2. Resolve the bet directory
+
+Look for the bet directory in `oprim/bets/` using two patterns:
+1. Exact match: `oprim/bets/BET-NNN/` (legacy non-slug format)
+2. Slug variant: any directory starting with `BET-NNN-` (e.g., `BET-NNN-<slug>/`)
+
+Use whichever pattern matches. Call this the **resolved directory name**.
+
+If multiple directories match (e.g., both `BET-NNN/` and `BET-NNN-slug/` exist):
+- Report: "Ambiguous: found multiple directories for BET-NNN: [list them]. Please archive manually."
+- Stop.
+
+If neither pattern matches:
+- Report: "Bet BET-NNN was not found in oprim/bets/. Nothing was changed."
+- Stop.
+
+### 3. Check for active dependencies and concurrent spec-delta conflicts
+
+Read `oprim/sequence.yaml`. Scan every entry across all buckets (now, next, later, backlog) for any entry whose `blocked_by` or `unlocks` list contains the target bet ID.
+
+Separately, if `oprim/bets/<resolved-dir>/specs/` exists: for each `<capability>/spec.md` delta file under it, extract every `### Requirement:` header from its `## ADDED`/`## MODIFIED`/`## REMOVED Requirements` sections. Then scan every other bet directory directly under `oprim/bets/` (excluding `archived/` and the bet being archived) for a `specs/<capability>/spec.md` file for the same capability; if one exists, extract its `### Requirement:` headers too. Flag any header that matches (whitespace-insensitive) between the archiving bet's delta and another still-active bet's delta as an **overlap**.
+
+If either sequence.yaml dependents or delta overlaps are found:
+- Show a combined warning listing each dependent entry and each overlapping requirement.
+
+  Example:
+  ```
+  ⚠ Warning: BET-005 is referenced by active bets:
+    - BET-007 (blocked_by: [BET-005])
+    - BET-008 (unlocks: [BET-005])
+  ⚠ Warning: BET-005's delta for requirement "The system SHALL ..." in capability foo overlaps with active bet BET-009's delta for the same requirement. Archiving BET-005 now applies its version to oprim/specs/foo/spec.md; if BET-009 archives later, its version will overwrite this requirement again (last-write-wins — no 3-way merge is attempted).
+  ```
+- Ask: "Archive BET-NNN anyway? (y/N)"
+  - If "n" or Enter: stop, no changes made.
+  - If "y": proceed.
+
+If neither is found: proceed without warning.
+
+### 4. Fold spec deltas into current truth
+
+If `oprim/bets/<resolved-dir>/specs/` does not exist: skip this step entirely and go to Step 5 — archive behavior is unchanged from before spec deltas existed.
+
+Otherwise, for each capability subdirectory under `oprim/bets/<resolved-dir>/specs/` containing a `spec.md`:
+
+1. Read the delta file's `## ADDED Requirements` / `## MODIFIED Requirements` / `## REMOVED Requirements` sections. Each `### Requirement:` block runs from its header through its body and any `#### Scenario:` sub-entries, up to the next `### Requirement:` or `## ` header.
+2. Read `oprim/specs/<capability>/spec.md` if it exists (current truth uses a single flat `## Requirements` section).
+   - **If it does not exist:**
+     - If the delta is entirely `## ADDED Requirements` (no MODIFIED/REMOVED sections): create `oprim/specs/<capability>/spec.md` with a `## Requirements` header and append each ADDED requirement block beneath it.
+     - If the delta contains any MODIFIED or REMOVED requirements: stop before moving anything and report an error — "cannot modify/remove requirement '<header>' in capability <capability> — no current-truth spec exists yet for this capability."
+   - **If it does exist:**
+     - **ADDED**: append the requirement block to the end of the `## Requirements` section.
+     - **MODIFIED**: find the existing `### Requirement:` block whose header text matches the delta's (whitespace-insensitive); replace that entire block (header, body, and scenarios) with the delta's version. If no match is found, treat it as ADDED instead (append) and note this in the final report.
+     - **REMOVED**: find and delete the matching block entirely. If no match is found, note this in the final report and continue — nothing to remove.
+3. Write the updated `oprim/specs/<capability>/spec.md`.
+
+This fold always overwrites the matched requirement wholesale — it never reconciles two bets' overlapping changes. If a later bet's archive touches the same requirement again, its version simply replaces this one (last-write-wins, confirmed by construction — no 3-way merge).
+
+Track which capabilities were merged (and any no-match notes) for the final report.
+
+### 5. Move the bet directory to archive
+
+Create the archive subfolder if it doesn't exist:
+```bash
+mkdir -p oprim/bets/archived
+```
+
+Move the resolved directory:
+```bash
+mv oprim/bets/<resolved-dir> oprim/bets/archived/<resolved-dir>
+```
+
+### 6. Remove the bet entry from sequence.yaml
+
+Read `oprim/sequence.yaml`, parse it, and remove the entry with `id: BET-NNN` from whichever bucket it appears in (now, next, later, or backlog). Write the updated YAML back using 2-space indentation. Do not modify any other entries.
+
+### 7. Report what was done
+
+```
+## Bet Archived
+
+**Bet:** BET-NNN
+**Archived to:** oprim/bets/archived/<resolved-dir>/
+**Removed from sequence.yaml:** ✓
+**Spec deltas merged:** <capability-1>, <capability-2> (omit this line if no specs/ directory was present)
+
+The bet is preserved in full at the archive location.
+```

package/dist/workflows/bet.cursor-command.md

@@ -0,0 +1 @@
+Create a new bet in `oprim/bets/`. First explain: "A bet is a product decision you're committing to explore — a problem worth solving, a hypothesis worth testing, or a direction worth taking. You'll name it, explain why now, and set a kill criterion." Then show: "Naming tip: verb + object [for context] — Good: 'Improve bet naming for scannability' / Bad: 'Naming'". Scan `BET-(\d+)` dirs for next ID (zero-padded, default 001). Check `oprim/sequence.yaml` exists (stop if not — advise oprim init). Read `oprim/config.yaml`'s `rules.bet` — if non-empty, apply it as additional guidance and reflect it in the generated content; if empty, behavior is unchanged. After receiving the title, validate: if fewer than 4 words OR fewer than 25 characters, warn "this title may be too vague", suggest a reformulation, and ask "Proceed anyway? (y/N)" — if "n", prompt for a revised title. Gather: decision (default Build now), owner, review date, why-now, alternatives, expected outcomes, kill criteria, PDR links. Write `oprim/bets/BET-NNN/bet-decision.md` with an inline naming tip comment in the header. Append entry to sequence.yaml backlog: `{id, title, blocked_by: [], unlocks: [], requires_pdrs: []}`. Then ask: "Do you want to scaffold a discovery.md now? (y/N)" — if "y", write `oprim/bets/BET-NNN/discovery.md` from the discovery template (sections: Problem Framing, User Research Signals, Competitive Context, Open Questions); if "n" or Enter, skip silently. Report what was created.

package/dist/workflows/bet.inline.md

@@ -0,0 +1,13 @@
+### Bet authoring (oprim-bet)
+Create a new bet in `oprim/bets/` and register it on the sequencing board.
+
+1. Show naming tip: "verb + object [for context] — e.g. 'Improve bet naming for scannability'"
+2. Ask for the bet title. Validate: fewer than 4 words OR fewer than 25 chars → warn, suggest reformulation, ask "Proceed anyway? (y/N)".
+3. Assign next BET ID: scan `oprim/bets/BET-(\d+)` dirs, max+1 zero-padded to 3 digits (default 001).
+4. Check `oprim/sequence.yaml` exists — stop if not, advise `oprim init`.
+4b. Read `oprim/config.yaml`'s `rules.bet` — if non-empty, apply it as additional guidance and reflect it in the generated content; if empty, behavior is unchanged.
+5. Gather: decision (default Build now), owner, review date (YYYY-MM-DD), why now, alternatives, expected outcomes, kill criteria, PDR links.
+6. Write `oprim/bets/BET-NNN/bet-decision.md` with all fields.
+7. Append to `oprim/sequence.yaml` backlog: `{id, title, blocked_by: [], unlocks: [], requires_pdrs: []}`.
+8. Ask: "Scaffold a discovery.md now? (y/N)" — if "y", write `oprim/bets/BET-NNN/discovery.md`.
+9. Report what was created.

package/dist/workflows/bet.schema.yaml

@@ -0,0 +1,14 @@
+id: bet
+skillName: oprim-bet
+title: null
+description: Create a new bet directory and bet-decision artifact in oprim/bets/, and add the bet to oprim/sequence.yaml backlog
+cursorDescription: Create a new bet decision and register it on the sequencing board
+claude:
+  skill: true
+  command: null
+cursor:
+  skill: true
+  command: oprim-bet.md
+poolside:
+  skill: true
+inline: true

package/dist/workflows/bet.template.md

@@ -0,0 +1,114 @@
+---
+name: oprim-bet
+description: Create a new bet directory and bet-decision artifact in oprim/bets/, and add the bet to oprim/sequence.yaml backlog
+---
+
+Create a new bet in `oprim/bets/` and register it on the sequencing board.
+
+**Interactive prompts:** Use the **AskUserQuestion tool** for every question in this skill — do not write questions as plain text.
+
+## What you're creating
+
+A bet is a product decision you're committing to explore: a problem worth solving, a hypothesis worth testing, or a direction worth taking. You'll name it, explain why now, and set a kill criterion so you know when to stop.
+
+## Steps
+
+### 1. Get the bet title
+Display the naming convention before asking:
+
+> **Naming tip:** Use "verb + object [for context]"
+> - Good: "Improve bet naming for scannability"
+> - Bad: "Naming"
+
+If not provided, ask: "What is the title of this bet?"
+
+After receiving the title, validate: if fewer than 4 words OR fewer than 25 characters:
+- Show: "Warning: this title may be too vague to scan at a glance."
+- Suggest a reformulation, e.g. "Consider: 'Improve <what> for <why>'"
+- Ask: "Proceed with this title anyway? (y/N)"
+  - If "n" or Enter: ask for a revised title and re-validate
+  - If "y": proceed with the original title
+
+### 2. Assign the next BET ID
+Scan both `oprim/bets/` and `oprim/bets/archived/` for directories whose names match `BET-(\d+)(-[^/]*)?` (handles both `BET-NNN/` and `BET-NNN-<slug>/`). Extract the numeric part from each match. Assign max+1, zero-padded to 3 digits. Default `001` if none found in either location.
+
+### 2b. Derive the slug
+From the bet title: lowercase all characters, replace any character that is not a letter or digit with a hyphen, collapse consecutive hyphens to one, strip leading/trailing hyphens, truncate to 40 characters at the last hyphen boundary. This becomes `<slug>`. Example: "Add title slugs to bet directories for scannability" → `add-title-slugs-to-bet-dirs-for`.
+
+### 3. Check sequence.yaml exists
+If `oprim/sequence.yaml` not found: report and stop — advise `oprim init`.
+
+### 3b. Check for custom rules
+Read `oprim/config.yaml`. If it has a non-empty `rules.bet` value, treat it as additional guidance from the team — factor it into the questions you ask in step 4 and reflect it in the generated `bet-decision.md` content. If `rules.bet` is absent or empty, skip this step; behavior is unchanged.
+
+### 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?)"
+
+### 4b. Check for OKF frontmatter
+Read `oprim/templates/bet-decision.md`. If it begins with a YAML frontmatter block (`---` ... `---`), this workspace has OKF frontmatter enabled. Ask for a one-line description and comma-separated tags (subject-area keywords). Prepare a frontmatter block with `type: bet-decision`, `title: <title>`, `description: <description>`, `tags: [<tags>]`, `timestamp: <today's date, ISO 8601>`, to prepend in step 5.
+If no frontmatter block is found in the template, skip this step — write the file with no frontmatter, matching current behavior.
+
+### 5. Write oprim/bets/BET-NNN-<slug>/bet-decision.md
+Prepend the frontmatter block from step 4b, if one was prepared.
+```
+# Decision: BET-NNN <title>
+<!-- Naming tip: verb + object [for context] — e.g. "Improve bet naming for scannability" not "Naming" -->
+
+## Status
+- Decision: <decision>
+- Date: <today YYYY-MM-DD>
+- 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>
+
+## Alternatives considered
+<alternatives as bullet list>
+
+## Expected outcomes
+<outcomes as bullet list>
+
+## Kill criteria / rollback trigger
+<kill criteria as bullet list>
+
+## Links
+- PDRs: <PDR-IDs or "None">
+- OpenSpec change: <to be filled when promoted>
+```
+
+### 6. Append to oprim/sequence.yaml backlog
+Read → parse YAML → append → write back (2-space indentation):
+```yaml
+- id: BET-NNN
+  title: "<title>"
+  blocked_by: []
+  unlocks: []
+  requires_pdrs: []
+```
+
+### 7. Prompt for optional discovery scaffolding
+Ask: "Do you want to scaffold a discovery.md now? (y/N)"
+- If "y": write `oprim/bets/BET-NNN-<slug>/discovery.md` from the discovery template (same structure as `oprim/templates/discovery.md`).
+- If "n" or Enter: skip silently.
+
+### 8. Report what was created

package/dist/workflows/context.schema.yaml

@@ -0,0 +1,13 @@
+id: context
+skillName: oprim-context-init
+title: "OPRIM: Context Init"
+description: Declare the current project a citable remote context, guided by a short Q&A to draft its description
+claude:
+  skill: true
+  command: context-init.md
+cursor:
+  skill: false
+  command: null
+poolside:
+  skill: false
+inline: false

package/dist/workflows/context.template.md

@@ -0,0 +1,34 @@
+---
+name: oprim-context-init
+description: Guide the user through drafting a description before declaring the current project a citable remote context
+---
+
+Declare the current project a citable remote context, with a clear description other projects and agents can use to decide whether to pull it.
+
+**Interactive prompts:** Use the **AskUserQuestion tool** for every question in this skill — do not write questions as plain text.
+
+## What this does
+
+A remote context is an oprim workspace (decisions, bets, specs) that other projects can reference read-only via `oprim context register`. Without a description, other projects have no cheap way to know what a remote context covers short of fully pulling it — so this skill exists to make sure one gets written.
+
+## Steps
+
+### 1. Check for an existing identity
+Check whether `.oprim-context/context.yaml` already exists in the current project. If it does, report that a remote context identity already exists (do not re-run the drafting flow below) and stop.
+
+### 2. Ask what this workspace covers
+Ask the user, one at a time:
+- "What does this project's oprim workspace cover? (e.g. product decisions, a specific domain, a team's specs)"
+- "Who is this meant for — which teams or projects would reference it?"
+
+If the user declines to answer either question, treat that as opting out of guided drafting — skip to step 4 with no description.
+
+### 3. Draft and confirm the description
+From the answers, draft a single-sentence description (aim for under 120 characters — this is what `oprim context list` will show other projects). Show the draft to the user and ask: "Use this description? (Enter to accept, or type a replacement)"
+
+### 4. Call oprim context init
+- If a description was drafted or accepted: use the Bash tool to run `oprim context init --description "<final text>"`.
+- If the user opted out in step 2: warn clearly that the resulting remote context will show as description-less in `oprim context list`, then use the Bash tool to run `oprim context init` with no `--description` flag.
+
+### 5. Report what was created
+Report the path (`.oprim-context/context.yaml`) and the description that was set (or the description-less warning, if opted out).

package/dist/workflows/criteria.cursor-command.md

@@ -0,0 +1 @@
+Add metrics to `oprim/bets/BET-NNN/criteria.yaml`. Verify bet dir exists. Gather: metric ID, name, baseline, target, timeframe, launch date, segment. Ask source type (amplitude or bigquery). Amplitude: event, aggregation, denominator_event. BigQuery: table, metric_column, filter, aggregation, denominator_query. If file exists: append to metrics list (never overwrite). If not: create. Ask if adding more metrics. Report what was created.

package/dist/workflows/criteria.inline.md

@@ -0,0 +1,11 @@
+### Criteria authoring (oprim-criteria)
+Create or append to `oprim/bets/BET-NNN/criteria.yaml`.
+
+1. Ask which bet (e.g. BET-042). Verify dir exists.
+2. Gather: metric ID (snake_case), name, baseline, target, timeframe, launch date, segment.
+3. Ask source type (amplitude / bigquery).
+   - Amplitude: event, aggregation (unique_users/event_count/property_sum), denominator_event.
+   - BigQuery: table, metric_column, filter, aggregation, denominator_query.
+4. If file exists: append to `metrics` list (never overwrite). If not: create.
+5. Ask if adding more metrics.
+6. Report what was created.

package/dist/workflows/criteria.schema.yaml

@@ -0,0 +1,14 @@
+id: criteria
+skillName: oprim-criteria
+title: null
+description: Create or append to a criteria.yaml contract for a bet, with structured Amplitude and BigQuery source mapping
+cursorDescription: Create or append to a criteria.yaml contract for a bet
+claude:
+  skill: true
+  command: null
+cursor:
+  skill: true
+  command: oprim-criteria.md
+poolside:
+  skill: true
+inline: true

package/dist/workflows/criteria.template.md

@@ -0,0 +1,52 @@
+---
+name: oprim-criteria
+description: Create or append to a criteria.yaml contract for a bet, with structured Amplitude and BigQuery source mapping
+---
+
+Create or append to `oprim/bets/BET-NNN/criteria.yaml`.
+
+**Interactive prompts:** Use the **AskUserQuestion tool** for every question in this skill — do not write questions as plain text.
+
+## Steps
+
+### 1. Identify the bet
+If not provided, ask: "Which bet are you adding criteria for? (e.g. BET-042)"
+
+### 2. Verify bet exists
+If `oprim/bets/BET-NNN/` not found: report and stop — advise using the `oprim-bet` skill first.
+
+### 3. Gather metric details
+Ask: metric ID (snake_case), metric name, baseline (numeric), target (numeric), timeframe, launch date (YYYY-MM-DD or TBD), segment (optional).
+
+### 4. Gather source mapping
+Ask: source type (amplitude / bigquery)
+
+If amplitude: event name, aggregation (unique_users / event_count / property_sum), denominator event (optional).
+```yaml
+source:
+  type: amplitude
+  definition:
+    event: <event_name>
+    aggregation: <aggregation>
+    denominator_event: <event_name | null>
+```
+
+If bigquery: table, metric column, SQL filter, aggregation (sum / count / count_distinct / avg), denominator query (optional).
+```yaml
+source:
+  type: bigquery
+  definition:
+    table: "<project.dataset.table>"
+    metric_column: "<column>"
+    filter: "<sql_filter>"
+    aggregation: <aggregation>
+    denominator_query: <sql | null>
+```
+
+### 5. Build metric entry and write
+If file exists: read → parse → append to `metrics` → write back (never overwrite).
+If not: create with `metrics:` list.
+
+### 6. Ask if more metrics needed. If yes, return to step 3.
+
+### 7. Report what was created

package/dist/workflows/note.cursor-command.md

@@ -0,0 +1 @@
+Create a new note in `oprim/notes/` for lightweight thinking capture — an observation, idea, or connection that hasn't yet earned a place in a bet or PDR. Notes carry no owner or kill criterion; promote one into a bet later with `/oprim:promote NOTE-NNN`. Ask for a short title. Scan `oprim/notes/NOTE-(\d+)-` for the next id (zero-padded, default 001). Ask for the note body (free-form), tags, and optional related BET-IDs. Tags are checked against `oprim/config.yaml`'s `notes.tags`; any new tag is accepted and appended to that list rather than rejected — the vocabulary grows from usage. Read `oprim/templates/note.md` — if its frontmatter has a `description:` field, this workspace is on the OKF tier and needs a one-line description; if it has no `description:` field, use the minimal tier; if the file doesn't exist, fall back to reading `okf.enabled` directly from `oprim/config.yaml`. Write `oprim/notes/NOTE-NNN-<slug>.md` with the correct frontmatter tier and a `## Bets` section listing any related BET-IDs. For each related bet, append `- Notes: NOTE-NNN` to that bet-decision's `## Links` section. Report what was created.

package/dist/workflows/note.inline.md

@@ -0,0 +1,11 @@
+### Note authoring (oprim-note)
+Create a new note in `oprim/notes/` for lightweight thinking capture — not a bet, no owner or kill criterion.
+
+1. Ask for a short title.
+2. Assign next NOTE ID: scan `oprim/notes/NOTE-(\d+)-`, max+1 zero-padded to 3 digits (default 001).
+3. Ask for the note body (free-form), tags, and optional related BET-IDs.
+4. Tags: check against `oprim/config.yaml`'s `notes.tags` — accept and append any new tag rather than rejecting it (the vocabulary grows from usage).
+5. Check `oprim/templates/note.md`: a `description:` field in its frontmatter means the OKF tier (gather a one-line description); no field means the minimal tier; if the file is missing, fall back to `okf.enabled` in `oprim/config.yaml`.
+6. Write `oprim/notes/NOTE-NNN-<slug>.md` with the correct frontmatter tier and a `## Bets` section.
+7. For each related bet, append `- Notes: NOTE-NNN` to that bet's `## Links` section.
+8. Report what was created.

package/dist/workflows/note.schema.yaml

@@ -0,0 +1,14 @@
+id: note
+skillName: oprim-note
+title: null
+description: Create a new atomic note in oprim/notes/ for lightweight thinking capture, with tiered frontmatter and optional bet links
+cursorDescription: Create a new atomic note for lightweight thinking capture
+claude:
+  skill: true
+  command: null
+cursor:
+  skill: true
+  command: oprim-note.md
+poolside:
+  skill: true
+inline: true

package/dist/workflows/note.template.md

@@ -0,0 +1,66 @@
+---
+name: oprim-note
+description: Create a new atomic note in oprim/notes/ for lightweight thinking capture, with tiered frontmatter and optional bet links
+---
+
+Create a new note in `oprim/notes/` for lightweight thinking capture — an observation, idea, or connection that hasn't yet earned a place in a bet or PDR.
+
+**Interactive prompts:** Use the **AskUserQuestion tool** for every question in this skill — do not write questions as plain text.
+
+## What you're creating
+
+A note is a small, disposable unit of thinking: an observation, a stray idea, or a connection between bets, captured before it's proven enough to belong in a discovery hypothesis or bet-decision. Notes carry no owner and no kill criterion — they're not commitments. Promote a note into a bet later with `/oprim:promote NOTE-NNN` once it's worth committing to.
+
+## Steps
+
+### 1. Get the note title
+If not provided, ask: "What is this note about? (a short title)"
+
+### 2. Assign the next NOTE ID
+Scan `oprim/notes/` for files matching `NOTE-(\d+)-`. Extract the numeric part from each match. Assign max+1, zero-padded to 3 digits. Default `001` if none found.
+
+### 2b. Derive the slug
+From the note title: lowercase all characters, replace any character that is not a letter or digit with a hyphen, collapse consecutive hyphens to one, strip leading/trailing hyphens, truncate to 40 characters at the last hyphen boundary. This becomes `<slug>`.
+Output path: `oprim/notes/NOTE-NNN-<slug>.md`
+
+### 3. Gather the note body
+Ask: "What's the observation, idea, or connection?" (free-form prose — this becomes the note body).
+
+### 4. Gather tags
+Read `oprim/config.yaml`. If it has a `notes:` section with a `tags:` list, show it and ask the user to pick from it or add new ones. If `notes.tags` is absent or empty, ask for tags directly (comma-separated) — there's no vocabulary yet to constrain against.
+A tag not already in `notes.tags` SHALL be accepted, never rejected, and appended to `oprim/config.yaml`'s `notes.tags` list (creating the `notes:` section if absent) — the vocabulary grows from usage rather than requiring upfront authoring.
+
+### 5. Gather optional bet links
+Ask: "Does this relate to any existing bets? (comma-separated BET-IDs, or Enter to skip)"
+
+### 6. Check the frontmatter tier
+Read `oprim/templates/note.md`.
+- If it exists and its frontmatter block contains a `description:` field, this workspace is on the **OKF tier** — ask for a one-line description.
+- If it exists with no `description:` field, use the **minimal tier** — skip the description.
+- If the file doesn't exist (project initialized before notes were introduced), read `oprim/config.yaml` directly: `okf.enabled: true` → OKF tier (ask for a description); otherwise → minimal tier.
+
+### 7. Write oprim/notes/NOTE-NNN-<slug>.md
+
+Minimal tier:
+```
+---
+type: note
+title: "<title>"
+tags: [<tags>]
+timestamp: <today, ISO 8601>
+---
+
+# Note: <title>
+
+<body>
+
+## Bets
+- <BET-IDs from step 5, or "None">
+```
+
+OKF tier: same as above, with `description: "<description>"` inserted immediately after `title`.
+
+### 8. Link back from referenced bets
+For each BET-ID gathered in step 5: read `oprim/bets/BET-NNN/bet-decision.md`, and add `- Notes: NOTE-NNN` under its `## Links` section (append to an existing `Notes:` line, or add a new one).
+
+### 9. Report what was created

package/dist/workflows/pdr.cursor-command.md

@@ -0,0 +1 @@
+Create a new PDR in `oprim/decisions/`. Scan for `PDR-(\d+)-` to assign next ID (zero-padded, default 001). Read `oprim/config.yaml`'s `rules.pdr` — if non-empty, apply it as additional guidance and reflect it in the generated content; if empty, behavior is unchanged. Gather: title, context, decision, alternatives, consequences, evidence, related bets/specs. Ask if superseding an existing PDR. Write `oprim/decisions/PDR-NNN-<slug>.md`. If superseding: update old PDR Status to "Superseded by PDR-NNN". Report what was created.