@open-product-primer/cli 2.0.0 → 2.2.0

package/dist/lib/remote-context.d.ts

@@ -0,0 +1,50 @@
+export interface GitSource {
+    name: string;
+    git: string;
+    description?: string;
+}
+export interface PathSource {
+    name: string;
+    path: string;
+    description?: string;
+}
+export type RemoteContextSource = GitSource | PathSource;
+export interface RemoteContextConfig {
+    enabled: boolean;
+    sources: RemoteContextSource[];
+}
+export interface RemoteContextIdentity {
+    name: string;
+    version: string;
+    description?: string;
+}
+export declare function isGitSource(source: RemoteContextSource): source is GitSource;
+export declare function isPathSource(source: RemoteContextSource): source is PathSource;
+export declare function readRemoteContextConfig(projectRoot: string): RemoteContextConfig;
+export declare function writeRemoteContextConfig(projectRoot: string, config: RemoteContextConfig): void;
+export declare function findSourceByName(config: RemoteContextConfig, name: string): RemoteContextSource | undefined;
+export declare function identityFilePath(rootDir: string): string;
+export declare function readIdentity(rootDir: string): RemoteContextIdentity | null;
+export declare function writeIdentity(rootDir: string, identity: RemoteContextIdentity): void;
+export interface ResolvedIdentity {
+    identity: RemoteContextIdentity | null;
+    stale: boolean;
+    error?: string;
+    nameMismatch?: {
+        declared: string;
+        resolved: string;
+    };
+}
+export interface ResolvedContent {
+    workspaceRoot: string;
+    stale: boolean;
+    error?: string;
+    nameMismatch?: {
+        declared: string;
+        resolved: string;
+    };
+}
+export declare function resolveIdentityOnly(source: RemoteContextSource): ResolvedIdentity;
+export declare function hasEverFullyResolved(source: RemoteContextSource): boolean;
+export declare function resolveFull(source: RemoteContextSource): ResolvedContent;
+export declare function assembleOprimWorkspaceContent(workspaceRoot: string): string;

package/dist/lib/remote-context.js

@@ -0,0 +1,299 @@
+"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.isGitSource = isGitSource;
+exports.isPathSource = isPathSource;
+exports.readRemoteContextConfig = readRemoteContextConfig;
+exports.writeRemoteContextConfig = writeRemoteContextConfig;
+exports.findSourceByName = findSourceByName;
+exports.identityFilePath = identityFilePath;
+exports.readIdentity = readIdentity;
+exports.writeIdentity = writeIdentity;
+exports.resolveIdentityOnly = resolveIdentityOnly;
+exports.hasEverFullyResolved = hasEverFullyResolved;
+exports.resolveFull = resolveFull;
+exports.assembleOprimWorkspaceContent = assembleOprimWorkspaceContent;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const crypto = __importStar(require("crypto"));
+const child_process_1 = require("child_process");
+const yaml = __importStar(require("js-yaml"));
+function isGitSource(source) {
+    return 'git' in source && typeof source.git === 'string';
+}
+function isPathSource(source) {
+    return 'path' in source && typeof source.path === 'string';
+}
+// ─── oprim/config.yaml — remote_context block ──────────────────────────────
+const REMOTE_CONTEXT_KEY = 'remote_context';
+function configPath(projectRoot) {
+    return path.join(projectRoot, 'oprim', 'config.yaml');
+}
+function readRemoteContextConfig(projectRoot) {
+    const p = configPath(projectRoot);
+    if (!fs.existsSync(p))
+        return { enabled: false, sources: [] };
+    const parsed = yaml.load(fs.readFileSync(p, 'utf-8'));
+    const raw = parsed?.[REMOTE_CONTEXT_KEY];
+    if (!raw)
+        return { enabled: false, sources: [] };
+    return {
+        enabled: raw.enabled ?? false,
+        sources: Array.isArray(raw.sources) ? raw.sources : [],
+    };
+}
+// Surgical replace of just the `remote_context:` top-level block, leaving every other
+// line in oprim/config.yaml byte-for-byte untouched — mirrors the non-destructive approach
+// in config-merge.ts (never parse+re-dump the whole file).
+function replaceTopLevelBlock(content, key, blockContent) {
+    const lines = content.split('\n');
+    const startIdx = lines.findIndex((l) => new RegExp(`^${key}:`).test(l));
+    const blockLines = blockContent.replace(/\n$/, '').split('\n');
+    if (startIdx === -1) {
+        const separator = content.endsWith('\n') || content === '' ? '' : '\n';
+        return content + separator + blockLines.join('\n') + '\n';
+    }
+    let endIdx = lines.length;
+    for (let i = startIdx + 1; i < lines.length; i++) {
+        if (/^[A-Za-z_]/.test(lines[i])) {
+            endIdx = i;
+            break;
+        }
+    }
+    return [...lines.slice(0, startIdx), ...blockLines, ...lines.slice(endIdx)].join('\n');
+}
+function writeRemoteContextConfig(projectRoot, config) {
+    const p = configPath(projectRoot);
+    const existing = fs.existsSync(p) ? fs.readFileSync(p, 'utf-8') : '';
+    const dumped = yaml.dump({ [REMOTE_CONTEXT_KEY]: config }, { lineWidth: -1 });
+    const updated = replaceTopLevelBlock(existing, REMOTE_CONTEXT_KEY, dumped);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, updated, 'utf-8');
+}
+function findSourceByName(config, name) {
+    return config.sources.find((s) => s.name === name);
+}
+// ─── Remote context identity (.oprim-context/context.yaml) ─────────────────
+function identityFilePath(rootDir) {
+    return path.join(rootDir, '.oprim-context', 'context.yaml');
+}
+function readIdentity(rootDir) {
+    const p = identityFilePath(rootDir);
+    if (!fs.existsSync(p))
+        return null;
+    try {
+        const parsed = yaml.load(fs.readFileSync(p, 'utf-8'));
+        if (!parsed?.name || !parsed?.version)
+            return null;
+        return { name: parsed.name, version: parsed.version, description: parsed.description };
+    }
+    catch {
+        return null;
+    }
+}
+function writeIdentity(rootDir, identity) {
+    const p = identityFilePath(rootDir);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, yaml.dump(identity, { lineWidth: -1 }), 'utf-8');
+}
+// ─── Cache directory layout (git sources only) ─────────────────────────────
+// 5 minutes — see design.md open question. Overridable for tests that need to exercise
+// post-throttle-window behavior without actually waiting.
+function throttleMs() {
+    const override = process.env['OPRIM_REMOTE_CONTEXT_THROTTLE_MS'];
+    return override ? Number(override) : 5 * 60 * 1000;
+}
+// Overridable so tests never write into the real user's home directory.
+function cacheRoot() {
+    return process.env['OPRIM_REMOTE_CONTEXT_CACHE_DIR'] ?? path.join(os.homedir(), '.oprim', 'remote-context-cache');
+}
+function sourceCacheKey(source) {
+    const hash = crypto.createHash('sha1').update(source.git).digest('hex').slice(0, 12);
+    return `${source.name}-${hash}`;
+}
+function fullCacheDir(source) {
+    return path.join(cacheRoot(), sourceCacheKey(source), 'full');
+}
+function identityCacheDir(source) {
+    return path.join(cacheRoot(), sourceCacheKey(source), 'identity');
+}
+function markerPath(dir) {
+    return path.join(dir, '.oprim-last-fetch');
+}
+function isWithinThrottle(dir) {
+    const marker = markerPath(dir);
+    if (!fs.existsSync(marker))
+        return false;
+    const last = Number(fs.readFileSync(marker, 'utf-8').trim() || '0');
+    return Date.now() - last < throttleMs();
+}
+function touchMarker(dir) {
+    fs.writeFileSync(markerPath(dir), String(Date.now()), 'utf-8');
+}
+function git(args, cwd) {
+    (0, child_process_1.execFileSync)('git', args, { cwd, stdio: 'ignore' });
+}
+function withNameMismatch(source, identity) {
+    if (!identity)
+        return undefined;
+    if (identity.name === source.name)
+        return undefined;
+    return { declared: source.name, resolved: identity.name };
+}
+// ─── Git source resolution ─────────────────────────────────────────────────
+function ensureFullGitClone(source) {
+    const dir = fullCacheDir(source);
+    const exists = fs.existsSync(path.join(dir, '.git'));
+    if (exists && isWithinThrottle(dir)) {
+        return { dir, stale: false };
+    }
+    try {
+        if (!exists) {
+            fs.mkdirSync(path.dirname(dir), { recursive: true });
+            git(['clone', '--depth', '1', '--quiet', source.git, dir]);
+        }
+        else {
+            git(['fetch', '--depth', '1', '--quiet', 'origin', 'HEAD'], dir);
+            git(['reset', '--hard', '--quiet', 'FETCH_HEAD'], dir);
+        }
+        touchMarker(dir);
+        return { dir, stale: false };
+    }
+    catch (err) {
+        if (exists) {
+            // Last-known-good fallback — resolution degrades to stale rather than failing outright.
+            return { dir, stale: true };
+        }
+        return { dir, stale: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+function ensureIdentityOnlyGitClone(source) {
+    const dir = identityCacheDir(source);
+    const exists = fs.existsSync(path.join(dir, '.git'));
+    if (exists && isWithinThrottle(dir)) {
+        return { dir };
+    }
+    try {
+        if (!exists) {
+            fs.mkdirSync(path.dirname(dir), { recursive: true });
+            // Partial clone (blob:none) + cone sparse-checkout scoped to .oprim-context/ — this is
+            // the "targeted single-file fetch" from design.md decision 5, implemented as an
+            // equivalent narrow fetch: git only downloads the one blob it needs to check out,
+            // not the whole workspace. `git archive --remote` was considered and rejected — GitHub
+            // and most managed git hosts disable the upload-archive service, so it isn't portable.
+            git(['clone', '--filter=blob:none', '--no-checkout', '--depth', '1', '--quiet', source.git, dir]);
+            git(['sparse-checkout', 'init', '--cone'], dir);
+            git(['sparse-checkout', 'set', '.oprim-context'], dir);
+            git(['checkout', '--quiet'], dir);
+        }
+        else {
+            git(['fetch', '--depth', '1', '--quiet', 'origin', 'HEAD'], dir);
+            git(['reset', '--hard', '--quiet', 'FETCH_HEAD'], dir);
+        }
+        touchMarker(dir);
+        return { dir };
+    }
+    catch (err) {
+        return { dir, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+function resolveIdentityOnly(source) {
+    if (isPathSource(source)) {
+        if (!fs.existsSync(source.path)) {
+            return { identity: null, stale: false, error: `path not found: ${source.path}` };
+        }
+        const identity = readIdentity(source.path);
+        return { identity, stale: false, nameMismatch: withNameMismatch(source, identity) };
+    }
+    const { dir, error } = ensureIdentityOnlyGitClone(source);
+    if (error)
+        return { identity: null, stale: false, error };
+    const identity = readIdentity(dir);
+    return { identity, stale: false, nameMismatch: withNameMismatch(source, identity) };
+}
+// Local-path sources are always read live (no persistent cache), so "has this ever been
+// resolved" is only a meaningful question for git sources, where full resolution populates
+// a durable cache directory that outlives any single command invocation.
+function hasEverFullyResolved(source) {
+    if (isPathSource(source))
+        return true;
+    return fs.existsSync(path.join(fullCacheDir(source), '.git'));
+}
+function resolveFull(source) {
+    if (isPathSource(source)) {
+        if (!fs.existsSync(source.path)) {
+            return { workspaceRoot: source.path, stale: false, error: `path not found: ${source.path}` };
+        }
+        const identity = readIdentity(source.path);
+        return {
+            workspaceRoot: source.path,
+            stale: false,
+            nameMismatch: withNameMismatch(source, identity),
+        };
+    }
+    const { dir, stale, error } = ensureFullGitClone(source);
+    if (error)
+        return { workspaceRoot: dir, stale: false, error };
+    const identity = readIdentity(dir);
+    return { workspaceRoot: dir, stale, nameMismatch: withNameMismatch(source, identity) };
+}
+// ─── Assembling oprim/ workspace content for printing ──────────────────────
+function walkTextFiles(dir, base, out) {
+    if (!fs.existsSync(dir))
+        return;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        const rel = path.join(base, entry.name);
+        if (entry.isDirectory()) {
+            walkTextFiles(full, rel, out);
+        }
+        else if (entry.isFile() && /\.(md|yaml|yml)$/.test(entry.name)) {
+            out.push(rel);
+        }
+    }
+}
+function assembleOprimWorkspaceContent(workspaceRoot) {
+    const oprimDir = path.join(workspaceRoot, 'oprim');
+    const files = [];
+    walkTextFiles(oprimDir, 'oprim', files);
+    files.sort();
+    return files
+        .map((rel) => {
+        const content = fs.readFileSync(path.join(workspaceRoot, rel), 'utf-8');
+        return `─── ${rel} ───\n${content}`;
+    })
+        .join('\n\n');
+}

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/templates.js

@@ -31,8 +31,9 @@ sequencing:
     now: 2
 context: ""
 rules: {}
-store:
+remote_context:
   enabled: false
+  sources: []
 `;
 }
 // OKF (Open Knowledge Format) — https://github.com/GoogleCloudPlatform/okf

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;