@open-product-primer/cli 2.1.0 → 2.2.0

package/dist/lib/spec-delta.d.ts

@@ -0,0 +1,30 @@
+export type DeltaSection = 'ADDED' | 'MODIFIED' | 'REMOVED';
+export interface FoldResult {
+    content: string;
+    notes: string[];
+}
+export interface CrossBetConflict {
+    betA: string;
+    betB: string;
+    capability: string;
+    header: string;
+}
+/** Extracts `### Requirement:` header text from a `## ADDED/MODIFIED/REMOVED Requirements` section of a delta file. */
+export declare function parseRequirementHeaders(deltaContent: string, section: DeltaSection): string[];
+/** Extracts `### Requirement:` header text from current truth's flat `## Requirements` section. */
+export declare function parseCurrentTruthHeaders(currentTruthContent: string): string[];
+/**
+ * Folds a bet's spec delta into current truth, mirroring the ADDED-append /
+ * MODIFIED-replace-or-note / REMOVED-delete-or-note algorithm `/oprim:archive` uses.
+ * Throws if `currentTruth` is null and the delta contains MODIFIED/REMOVED requirements
+ * (nothing to modify/remove against yet).
+ */
+export declare function foldDelta(currentTruth: string | null, delta: string): FoldResult;
+/**
+ * Scans all active bet directories (excluding archived/) pairwise for overlapping
+ * `### Requirement:` headers within the same capability's spec delta.
+ */
+export declare function findCrossBetConflicts(betsDir: string): CrossBetConflict[];
+export declare function normalizeBetId(input: string): string;
+/** Resolves a bet ID (accepting `bet-005`, `005`, `5`, or `BET-005`) to its directory name under `betsDir`. */
+export declare function resolveBetDirectory(betsDir: string, betIdInput: string): string | null;

package/dist/lib/spec-delta.js

@@ -0,0 +1,216 @@
+"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.parseRequirementHeaders = parseRequirementHeaders;
+exports.parseCurrentTruthHeaders = parseCurrentTruthHeaders;
+exports.foldDelta = foldDelta;
+exports.findCrossBetConflicts = findCrossBetConflicts;
+exports.normalizeBetId = normalizeBetId;
+exports.resolveBetDirectory = resolveBetDirectory;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+function normalizeHeader(header) {
+    return header.trim().replace(/\s+/g, ' ').toLowerCase();
+}
+function extractSection(markdown, sectionTitle) {
+    const lines = markdown.split('\n');
+    const startIdx = lines.findIndex((l) => l.trim() === `## ${sectionTitle}`);
+    if (startIdx === -1)
+        return null;
+    let endIdx = lines.length;
+    for (let i = startIdx + 1; i < lines.length; i++) {
+        if (/^##\s/.test(lines[i])) {
+            endIdx = i;
+            break;
+        }
+    }
+    return lines.slice(startIdx + 1, endIdx).join('\n');
+}
+function parseRequirementBlocks(sectionContent) {
+    const lines = sectionContent.split('\n');
+    const blocks = [];
+    let current = null;
+    for (const line of lines) {
+        const match = line.match(/^### Requirement:\s*(.*)$/);
+        if (match) {
+            if (current) {
+                blocks.push({ header: current.header, content: current.lines.join('\n').trim() });
+            }
+            current = { header: match[1].trim(), lines: [line] };
+        }
+        else if (current) {
+            current.lines.push(line);
+        }
+    }
+    if (current) {
+        blocks.push({ header: current.header, content: current.lines.join('\n').trim() });
+    }
+    return blocks;
+}
+/** Extracts `### Requirement:` header text from a `## ADDED/MODIFIED/REMOVED Requirements` section of a delta file. */
+function parseRequirementHeaders(deltaContent, section) {
+    const sectionContent = extractSection(deltaContent, `${section} Requirements`);
+    if (sectionContent === null)
+        return [];
+    return parseRequirementBlocks(sectionContent).map((b) => b.header);
+}
+/** Extracts `### Requirement:` header text from current truth's flat `## Requirements` section. */
+function parseCurrentTruthHeaders(currentTruthContent) {
+    const sectionContent = extractSection(currentTruthContent, 'Requirements');
+    if (sectionContent === null)
+        return [];
+    return parseRequirementBlocks(sectionContent).map((b) => b.header);
+}
+/**
+ * Folds a bet's spec delta into current truth, mirroring the ADDED-append /
+ * MODIFIED-replace-or-note / REMOVED-delete-or-note algorithm `/oprim:archive` uses.
+ * Throws if `currentTruth` is null and the delta contains MODIFIED/REMOVED requirements
+ * (nothing to modify/remove against yet).
+ */
+function foldDelta(currentTruth, delta) {
+    const notes = [];
+    const addedSection = extractSection(delta, 'ADDED Requirements');
+    const modifiedSection = extractSection(delta, 'MODIFIED Requirements');
+    const removedSection = extractSection(delta, 'REMOVED Requirements');
+    const added = addedSection !== null ? parseRequirementBlocks(addedSection) : [];
+    const modified = modifiedSection !== null ? parseRequirementBlocks(modifiedSection) : [];
+    const removed = removedSection !== null ? parseRequirementBlocks(removedSection) : [];
+    if (currentTruth === null) {
+        if (modified.length > 0 || removed.length > 0) {
+            throw new Error('cannot modify/remove a requirement — no current-truth spec exists yet for this capability.');
+        }
+        const body = added.map((b) => b.content).join('\n\n');
+        return { content: `## Requirements\n\n${body}\n`, notes };
+    }
+    const reqSection = extractSection(currentTruth, 'Requirements') ?? '';
+    const blocks = parseRequirementBlocks(reqSection);
+    for (const block of modified) {
+        const idx = blocks.findIndex((b) => normalizeHeader(b.header) === normalizeHeader(block.header));
+        if (idx === -1) {
+            blocks.push(block);
+            notes.push(`MODIFIED requirement "${block.header}" had no match in current truth — treated as ADDED`);
+        }
+        else {
+            blocks[idx] = block;
+        }
+    }
+    for (const block of removed) {
+        const idx = blocks.findIndex((b) => normalizeHeader(b.header) === normalizeHeader(block.header));
+        if (idx === -1) {
+            notes.push(`REMOVED requirement "${block.header}" had no match in current truth — nothing removed`);
+        }
+        else {
+            blocks.splice(idx, 1);
+        }
+    }
+    for (const block of added) {
+        blocks.push(block);
+    }
+    const body = blocks.map((b) => b.content).join('\n\n');
+    return { content: `## Requirements\n\n${body}\n`, notes };
+}
+/**
+ * Scans all active bet directories (excluding archived/) pairwise for overlapping
+ * `### Requirement:` headers within the same capability's spec delta.
+ */
+function findCrossBetConflicts(betsDir) {
+    if (!fs.existsSync(betsDir))
+        return [];
+    const betNames = fs
+        .readdirSync(betsDir, { withFileTypes: true })
+        .filter((e) => e.isDirectory() && e.name !== 'archived')
+        .map((e) => e.name);
+    const betCapHeaders = new Map();
+    for (const betName of betNames) {
+        const specsDir = path.join(betsDir, betName, 'specs');
+        if (!fs.existsSync(specsDir))
+            continue;
+        const capMap = new Map();
+        const capEntries = fs.readdirSync(specsDir, { withFileTypes: true }).filter((e) => e.isDirectory());
+        for (const capEntry of capEntries) {
+            const specPath = path.join(specsDir, capEntry.name, 'spec.md');
+            if (!fs.existsSync(specPath))
+                continue;
+            const content = fs.readFileSync(specPath, 'utf-8');
+            const headers = [
+                ...parseRequirementHeaders(content, 'ADDED'),
+                ...parseRequirementHeaders(content, 'MODIFIED'),
+                ...parseRequirementHeaders(content, 'REMOVED'),
+            ];
+            capMap.set(capEntry.name, headers);
+        }
+        betCapHeaders.set(betName, capMap);
+    }
+    const conflicts = [];
+    const names = [...betCapHeaders.keys()];
+    for (let i = 0; i < names.length; i++) {
+        for (let j = i + 1; j < names.length; j++) {
+            const capMapA = betCapHeaders.get(names[i]);
+            const capMapB = betCapHeaders.get(names[j]);
+            for (const [capability, headersA] of capMapA) {
+                const headersB = capMapB.get(capability);
+                if (!headersB)
+                    continue;
+                for (const headerA of headersA) {
+                    const match = headersB.find((h) => normalizeHeader(h) === normalizeHeader(headerA));
+                    if (match) {
+                        conflicts.push({ betA: names[i], betB: names[j], capability, header: headerA });
+                    }
+                }
+            }
+        }
+    }
+    return conflicts;
+}
+function normalizeBetId(input) {
+    const digits = input.replace(/[^0-9]/g, '');
+    return `BET-${digits.padStart(3, '0')}`;
+}
+/** Resolves a bet ID (accepting `bet-005`, `005`, `5`, or `BET-005`) to its directory name under `betsDir`. */
+function resolveBetDirectory(betsDir, betIdInput) {
+    if (!fs.existsSync(betsDir))
+        return null;
+    const betId = normalizeBetId(betIdInput);
+    const entries = fs
+        .readdirSync(betsDir, { withFileTypes: true })
+        .filter((e) => e.isDirectory() && e.name !== 'archived');
+    const exact = entries.find((e) => e.name === betId);
+    if (exact)
+        return exact.name;
+    const slugMatches = entries.filter((e) => e.name.startsWith(`${betId}-`));
+    if (slugMatches.length === 1)
+        return slugMatches[0].name;
+    return null;
+}

package/dist/lib/validate-checks.d.ts

@@ -0,0 +1,13 @@
+import { type Check } from './integrity';
+/**
+ * Flags a promoted bet (one whose bet-decision.md links a non-placeholder OpenSpec
+ * change) that has no criteria.yaml alongside it. Un-promoted bets are not checked.
+ */
+export declare function checkBetDefinitionOfDone(projectRoot: string, checks: Check[]): void;
+/**
+ * Flags a MODIFIED/REMOVED requirement in an active bet's spec delta whose header no
+ * longer text-matches (whitespace-insensitive) current truth.
+ */
+export declare function checkSpecDeltaDrift(projectRoot: string, checks: Check[]): void;
+/** Surfaces overlapping requirement headers across active bets' spec deltas. */
+export declare function checkCrossBetConflicts(projectRoot: string, checks: Check[]): void;

package/dist/lib/validate-checks.js

@@ -0,0 +1,145 @@
+"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.checkBetDefinitionOfDone = checkBetDefinitionOfDone;
+exports.checkSpecDeltaDrift = checkSpecDeltaDrift;
+exports.checkCrossBetConflicts = checkCrossBetConflicts;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const spec_delta_1 = require("./spec-delta");
+function normalizeHeader(header) {
+    return header.trim().replace(/\s+/g, ' ').toLowerCase();
+}
+function extractBetId(dirName) {
+    const match = dirName.match(/^(BET-\d+)/);
+    return match ? match[1] : dirName;
+}
+function activeBetDirs(betsDir) {
+    if (!fs.existsSync(betsDir))
+        return [];
+    return fs
+        .readdirSync(betsDir, { withFileTypes: true })
+        .filter((e) => e.isDirectory() && e.name !== 'archived');
+}
+function isPromoted(betDecisionContent) {
+    const linksMatch = betDecisionContent.match(/## Links\n([\s\S]*?)(?=\n## |$)/);
+    const linksSection = linksMatch ? linksMatch[1] : betDecisionContent;
+    const lineMatch = linksSection.match(/^- *OpenSpec change:\s*(.*)$/m);
+    if (!lineMatch)
+        return false;
+    const value = lineMatch[1].trim().replace(/^<|>$/g, '').trim();
+    if (value === '')
+        return false;
+    if (/to be filled when promoted/i.test(value))
+        return false;
+    if (/^path once promoted$/i.test(value))
+        return false;
+    return true;
+}
+/**
+ * Flags a promoted bet (one whose bet-decision.md links a non-placeholder OpenSpec
+ * change) that has no criteria.yaml alongside it. Un-promoted bets are not checked.
+ */
+function checkBetDefinitionOfDone(projectRoot, checks) {
+    const betsDir = path.join(projectRoot, 'oprim', 'bets');
+    for (const entry of activeBetDirs(betsDir)) {
+        const betDir = path.join(betsDir, entry.name);
+        const decisionPath = path.join(betDir, 'bet-decision.md');
+        if (!fs.existsSync(decisionPath))
+            continue;
+        const content = fs.readFileSync(decisionPath, 'utf-8');
+        if (!isPromoted(content))
+            continue;
+        const hasCriteria = fs.existsSync(path.join(betDir, 'criteria.yaml'));
+        if (!hasCriteria) {
+            const betId = extractBetId(entry.name);
+            checks.push({
+                name: `bet: ${betId} promoted without criteria.yaml`,
+                pass: false,
+                note: `Add criteria.yaml to oprim/bets/${entry.name}/, or run the oprim-criteria skill`,
+                required: false,
+            });
+        }
+    }
+}
+/**
+ * Flags a MODIFIED/REMOVED requirement in an active bet's spec delta whose header no
+ * longer text-matches (whitespace-insensitive) current truth.
+ */
+function checkSpecDeltaDrift(projectRoot, checks) {
+    const betsDir = path.join(projectRoot, 'oprim', 'bets');
+    for (const entry of activeBetDirs(betsDir)) {
+        const betId = extractBetId(entry.name);
+        const specsDir = path.join(betsDir, entry.name, 'specs');
+        if (!fs.existsSync(specsDir))
+            continue;
+        const capEntries = fs.readdirSync(specsDir, { withFileTypes: true }).filter((e) => e.isDirectory());
+        for (const capEntry of capEntries) {
+            const deltaPath = path.join(specsDir, capEntry.name, 'spec.md');
+            if (!fs.existsSync(deltaPath))
+                continue;
+            const deltaContent = fs.readFileSync(deltaPath, 'utf-8');
+            const currentTruthPath = path.join(projectRoot, 'oprim', 'specs', capEntry.name, 'spec.md');
+            const currentHeaders = fs.existsSync(currentTruthPath)
+                ? (0, spec_delta_1.parseCurrentTruthHeaders)(fs.readFileSync(currentTruthPath, 'utf-8'))
+                : [];
+            for (const section of ['MODIFIED', 'REMOVED']) {
+                for (const header of (0, spec_delta_1.parseRequirementHeaders)(deltaContent, section)) {
+                    const matches = currentHeaders.some((h) => normalizeHeader(h) === normalizeHeader(header));
+                    if (!matches) {
+                        checks.push({
+                            name: `spec-delta: ${betId}'s ${section} requirement "${header}" in ${capEntry.name} no longer matches current truth`,
+                            pass: false,
+                            note: `No matching requirement header found in oprim/specs/${capEntry.name}/spec.md`,
+                            required: true,
+                        });
+                    }
+                }
+            }
+        }
+    }
+}
+/** Surfaces overlapping requirement headers across active bets' spec deltas. */
+function checkCrossBetConflicts(projectRoot, checks) {
+    const betsDir = path.join(projectRoot, 'oprim', 'bets');
+    for (const conflict of (0, spec_delta_1.findCrossBetConflicts)(betsDir)) {
+        checks.push({
+            name: `spec-delta: ${extractBetId(conflict.betA)} and ${extractBetId(conflict.betB)} both touch "${conflict.header}" in ${conflict.capability}`,
+            pass: false,
+            note: 'Overlapping requirement header between active bets — archiving one first applies last-write-wins to the other (no 3-way merge)',
+            required: true,
+        });
+    }
+}

package/dist/lib/workflow-renderer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The full workflow body — a workflow's own frontmatter (`name:`/`description:`) plus its
+ * instructional steps — used verbatim as the Claude/Cursor/Poolside SKILL.md content.
+ */
+export declare function renderSkillBody(id: string, projectRoot?: string): string;
+/**
+ * A thin Claude command wrapper that delegates to the workflow's skill via the Skill tool
+ * (archive/sequence/context), or promote's dynamic per-framework content.
+ */
+export declare function renderClaudeCommand(id: string, projectRoot?: string, framework?: string): string;
+/**
+ * A full Cursor command file: promote's dynamic per-framework content, or a condensed
+ * `<id>.cursor-command.md` body (Cursor has no Skill tool, so content is always inlined).
+ */
+export declare function renderCursorCommand(id: string, projectRoot?: string, framework?: string): string;
+/** A workflow's condensed section for the shared Codex/Gemini/Poolside inline instruction block. */
+export declare function renderInlineSection(id: string): string | null;
+/** The full `<!-- oprim:start -->`-delimited inline instruction block written into AGENTS.md/GEMINI.md. */
+export declare function renderAgentInstructions(): string;

package/dist/lib/workflow-renderer.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderSkillBody = renderSkillBody;
+exports.renderClaudeCommand = renderClaudeCommand;
+exports.renderCursorCommand = renderCursorCommand;
+exports.renderInlineSection = renderInlineSection;
+exports.renderAgentInstructions = renderAgentInstructions;
+const workflow_schema_1 = require("./workflow-schema");
+// Fixed order the pre-refactor oprimWorkflowsInline() concatenated its per-workflow sections in —
+// preserved here so Codex/Gemini/Poolside output is unchanged.
+const INLINE_SECTION_ORDER = ['bet', 'note', 'criteria', 'pdr', 'review', 'archive', 'sequence'];
+function claudeWrapper(name, description, body) {
+    return `---
+name: "${name}"
+description: ${description}
+category: Workflow
+tags: [workflow, primer]
+---
+
+${description}.
+
+${body}`;
+}
+function cursorWrapper(id, description, body) {
+    return `---
+name: /${id}
+id: ${id}
+category: Workflow
+description: ${description}
+---
+
+${body}`;
+}
+function promoteVariantBody(id, schema, framework) {
+    const variants = schema.variants;
+    if (!variants)
+        throw new Error(`workflow "${id}" has no variants configured`);
+    const variantId = variants.includes(framework) ? framework : variants[0];
+    const content = (0, workflow_schema_1.loadWorkflowVariant)(`${id}.${variantId}.template.md`);
+    if (content === null) {
+        throw new Error(`Missing variant template ${id}.${variantId}.template.md for workflow "${id}"`);
+    }
+    return content;
+}
+/**
+ * The full workflow body — a workflow's own frontmatter (`name:`/`description:`) plus its
+ * instructional steps — used verbatim as the Claude/Cursor/Poolside SKILL.md content.
+ */
+function renderSkillBody(id, projectRoot) {
+    return (0, workflow_schema_1.loadWorkflowTemplate)(id, projectRoot);
+}
+/**
+ * A thin Claude command wrapper that delegates to the workflow's skill via the Skill tool
+ * (archive/sequence/context), or promote's dynamic per-framework content.
+ */
+function renderClaudeCommand(id, projectRoot, framework = 'openspec') {
+    const schema = (0, workflow_schema_1.loadWorkflowSchema)(id, projectRoot);
+    if (!schema.claude.command) {
+        throw new Error(`workflow "${id}" has no Claude command target`);
+    }
+    const body = schema.variants
+        ? promoteVariantBody(id, schema, framework)
+        : schema.skillName
+            ? `Use the Skill tool to invoke the \`${schema.skillName}\` skill.`
+            : (() => {
+                throw new Error(`workflow "${id}" Claude command has neither a skillName nor variants`);
+            })();
+    return claudeWrapper(schema.title ?? schema.id, schema.description, body);
+}
+/**
+ * A full Cursor command file: promote's dynamic per-framework content, or a condensed
+ * `<id>.cursor-command.md` body (Cursor has no Skill tool, so content is always inlined).
+ */
+function renderCursorCommand(id, projectRoot, framework = 'openspec') {
+    const schema = (0, workflow_schema_1.loadWorkflowSchema)(id, projectRoot);
+    if (!schema.cursor.command) {
+        throw new Error(`workflow "${id}" has no Cursor command target`);
+    }
+    const cursorId = schema.cursor.command.replace(/\.md$/, '');
+    const body = schema.variants
+        ? promoteVariantBody(id, schema, framework)
+        : (() => {
+            const content = (0, workflow_schema_1.loadWorkflowVariant)(`${id}.cursor-command.md`);
+            if (content === null)
+                throw new Error(`Missing ${id}.cursor-command.md for workflow "${id}"`);
+            return content;
+        })();
+    return cursorWrapper(cursorId, schema.cursorDescription ?? schema.description, body);
+}
+/** A workflow's condensed section for the shared Codex/Gemini/Poolside inline instruction block. */
+function renderInlineSection(id) {
+    return (0, workflow_schema_1.loadWorkflowVariant)(`${id}.inline.md`);
+}
+/** The full `<!-- oprim:start -->`-delimited inline instruction block written into AGENTS.md/GEMINI.md. */
+function renderAgentInstructions() {
+    const sections = INLINE_SECTION_ORDER.map((id) => {
+        const content = renderInlineSection(id);
+        if (content === null)
+            throw new Error(`Missing inline section for workflow "${id}"`);
+        return content;
+    });
+    return '\n## oprim workflows\n\n' + sections.join('\n\n') + '\n';
+}

package/dist/lib/workflow-schema.d.ts

@@ -0,0 +1,37 @@
+export interface WorkflowAgentTarget {
+    skill: boolean;
+    command: string | null;
+}
+export interface WorkflowSchema {
+    id: string;
+    skillName: string | null;
+    title: string | null;
+    description: string;
+    cursorDescription: string | null;
+    claude: WorkflowAgentTarget;
+    cursor: WorkflowAgentTarget;
+    poolside: {
+        skill: boolean;
+    };
+    inline: boolean;
+    variants: string[] | 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.
+ */
+export declare function loadWorkflowSchema(id: string, projectRoot?: string): WorkflowSchema;
+/**
+ * Loads a workflow's template.md, resolving a project-level
+ * `oprim/workflows/<id>.template.md` override over the CLI-bundled default.
+ */
+export declare function loadWorkflowTemplate(id: string, projectRoot?: string): string;
+/**
+ * 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.
+ */
+export declare function loadWorkflowVariant(filename: string): string | null;