@pareto4/pp-core 1.5.0

package/pp-core/bin/lib/configuration.cjs

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * Configuration Module — legacy-key normalization, defaults merge, and explicit
+ * on-disk migration. Pure normalization primitives consumed by config-loader.cjs
+ * and config-schema.cjs. `loadConfig` was extracted to config-loader.cjs per
+ * ADR-857 phase 2e (#885) and removed from this module per #893.
+ *
+ * ADR-457 build-at-publish: the hand-written bin/lib/configuration.cjs collapsed
+ * to a TypeScript source of truth. Behaviour is preserved byte-for-behaviour
+ * from the prior hand-written .cjs; only types are added.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DYNAMIC_KEY_PATTERNS = exports.RUNTIME_STATE_KEYS = exports.VALID_CONFIG_KEYS = exports.CONFIG_DEFAULTS = void 0;
+exports.normalizeLegacyKeys = normalizeLegacyKeys;
+exports.mergeDefaults = mergeDefaults;
+exports.migrateOnDisk = migrateOnDisk;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+// In .cts (CommonJS output) files, `require` is available as a global.
+const _require = require;
+// ─── Manifest requires ───────────────────────────────────────────────────────
+function loadConfigurationManifest(fileName) {
+    const candidates = [
+        // Installed runtime layout: gsd-core/bin/shared/*.manifest.json
+        (0, node_path_1.join)(__dirname, '..', 'shared', fileName),
+    ];
+    let lastErr = null;
+    for (const candidate of candidates) {
+        try {
+            return _require(candidate);
+        }
+        catch (err) {
+            const e = err;
+            const isMissingCandidate = e && e.code === 'MODULE_NOT_FOUND' && String(e.message || '').includes(candidate);
+            if (!isMissingCandidate)
+                throw err;
+            lastErr = e;
+        }
+    }
+    throw new Error(`${fileName} not found. Tried:\n${candidates.map((p) => `  ${p}`).join('\n')}\nLast error: ${lastErr?.message}`);
+}
+const CONFIG_DEFAULTS = loadConfigurationManifest('config-defaults.manifest.json');
+exports.CONFIG_DEFAULTS = CONFIG_DEFAULTS;
+const SCHEMA_MANIFEST = loadConfigurationManifest('config-schema.manifest.json');
+const VALID_CONFIG_KEYS = new Set(SCHEMA_MANIFEST.validKeys);
+exports.VALID_CONFIG_KEYS = VALID_CONFIG_KEYS;
+const RUNTIME_STATE_KEYS = new Set(SCHEMA_MANIFEST.runtimeStateKeys);
+exports.RUNTIME_STATE_KEYS = RUNTIME_STATE_KEYS;
+const DYNAMIC_KEY_PATTERNS = SCHEMA_MANIFEST.dynamicKeyPatterns.map((p) => {
+    const pattern = new RegExp(p.source);
+    return {
+        ...p,
+        test: (key) => {
+            pattern.lastIndex = 0;
+            return pattern.test(key);
+        },
+    };
+});
+exports.DYNAMIC_KEY_PATTERNS = DYNAMIC_KEY_PATTERNS;
+// ─── Depth → Granularity mapping ─────────────────────────────────────────────
+const DEPTH_TO_GRANULARITY = {
+    quick: 'coarse',
+    standard: 'standard',
+    comprehensive: 'fine',
+};
+// ─── Internal helpers ─────────────────────────────────────────────────────────
+function planningDir(cwd, workstream) {
+    if (!workstream)
+        return (0, node_path_1.join)(cwd, '.planning');
+    return (0, node_path_1.join)(cwd, '.planning', 'workstreams', workstream);
+}
+function detectSubRepos(cwd) {
+    const results = [];
+    try {
+        const entries = (0, node_fs_1.readdirSync)(cwd, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (entry.name.startsWith('.') || entry.name === 'node_modules')
+                continue;
+            const gitPath = (0, node_path_1.join)(cwd, entry.name, '.git');
+            try {
+                if ((0, node_fs_1.existsSync)(gitPath)) {
+                    results.push(entry.name);
+                }
+            }
+            catch { /* ignore */ }
+        }
+    }
+    catch { /* ignore */ }
+    return results.sort();
+}
+function deepMergeConfig(base, overlay) {
+    const result = { ...base };
+    for (const key of Object.keys(overlay)) {
+        const ov = overlay[key];
+        if (ov !== null && ov !== undefined && typeof ov === 'object' && !Array.isArray(ov)) {
+            const bv = base[key];
+            if (bv !== null && bv !== undefined && typeof bv === 'object' && !Array.isArray(bv)) {
+                result[key] = deepMergeConfig(bv, ov);
+            }
+            else {
+                result[key] = deepMergeConfig({}, ov);
+            }
+        }
+        else {
+            result[key] = ov;
+        }
+    }
+    return result;
+}
+// ─── Exported functions ───────────────────────────────────────────────────────
+function normalizeLegacyKeys(parsed) {
+    const result = { ...parsed };
+    const normalizations = [];
+    // 1. branching_strategy → git.branching_strategy
+    if (Object.prototype.hasOwnProperty.call(result, 'branching_strategy')) {
+        const value = result['branching_strategy'];
+        const git = (result['git'] ?? {});
+        if (git['branching_strategy'] === undefined) {
+            result['git'] = { ...git, branching_strategy: value };
+        }
+        else {
+            // canonical nested wins — just delete the stale top-level
+            result['git'] = { ...git };
+        }
+        delete result['branching_strategy'];
+        normalizations.push({ from: 'branching_strategy', to: 'git.branching_strategy', value });
+    }
+    // 2. top-level sub_repos → planning.sub_repos
+    if (Object.prototype.hasOwnProperty.call(result, 'sub_repos')) {
+        const value = result['sub_repos'];
+        const planning = (result['planning'] ?? {});
+        if (planning['sub_repos'] === undefined) {
+            result['planning'] = { ...planning, sub_repos: value };
+        }
+        else {
+            // canonical nested wins — just drop the stale top-level
+            result['planning'] = { ...planning };
+        }
+        delete result['sub_repos'];
+        normalizations.push({ from: 'sub_repos', to: 'planning.sub_repos', value });
+    }
+    // 3. multiRepo: true → marker (filesystem detection deferred to migrateOnDisk / caller)
+    if (result['multiRepo'] === true) {
+        delete result['multiRepo'];
+        normalizations.push({ from: 'multiRepo', to: 'planning.sub_repos', value: true, requiresFilesystem: true });
+    }
+    // 4. top-level depth → granularity
+    if (Object.prototype.hasOwnProperty.call(result, 'depth') && !Object.prototype.hasOwnProperty.call(result, 'granularity')) {
+        const rawDepth = result['depth'];
+        const mapped = DEPTH_TO_GRANULARITY[rawDepth] ?? rawDepth;
+        result['granularity'] = mapped;
+        delete result['depth'];
+        normalizations.push({ from: 'depth', to: 'granularity', value: mapped });
+    }
+    return { parsed: result, normalizations };
+}
+function mergeDefaults(parsed) {
+    // Start with a deep clone of defaults, then overlay parsed
+    const defaults = structuredClone(CONFIG_DEFAULTS);
+    return deepMergeConfig(defaults, parsed);
+}
+function migrateOnDisk(cwd, workstream) {
+    const configPath = (0, node_path_1.join)(planningDir(cwd, workstream), 'config.json');
+    let raw;
+    try {
+        raw = (0, node_fs_1.readFileSync)(configPath, 'utf-8');
+    }
+    catch {
+        // File missing — nothing to migrate
+        return { migrated: false, normalizations: [], wrote: null };
+    }
+    const trimmed = raw.trim();
+    if (trimmed === '') {
+        return { migrated: false, normalizations: [], wrote: null };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        // Malformed — can't migrate
+        return { migrated: false, normalizations: [], wrote: null };
+    }
+    const { parsed: normalized, normalizations } = normalizeLegacyKeys(parsed);
+    if (normalizations.length === 0) {
+        return { migrated: false, normalizations: [], wrote: null };
+    }
+    // Resolve multiRepo filesystem detection
+    const result = { ...normalized };
+    for (const norm of normalizations) {
+        if (norm.requiresFilesystem) {
+            const detected = detectSubRepos(cwd);
+            if (detected.length > 0) {
+                const planning = (result['planning'] ?? {});
+                result['planning'] = { ...planning, sub_repos: detected, commit_docs: false };
+            }
+        }
+    }
+    try {
+        (0, node_fs_1.writeFileSync)(configPath, JSON.stringify(result, null, 2));
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`Failed to write migrated config at ${configPath}: ${msg}`);
+    }
+    return { migrated: true, normalizations, wrote: configPath };
+}

package/pp-core/bin/lib/context-utilization.cjs

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * Context-utilization classifier for `gsd-health --context` (ADR-457
+ * build-at-publish: the hand-written bin/lib/context-utilization.cjs collapsed
+ * to a TypeScript source of truth). Behaviour is preserved byte-for-behaviour
+ * from the prior hand-written .cjs; only types are added.
+ *
+ * Pure function. Callers pass tokensUsed + contextWindow; the
+ * classifier returns the percent and one of three states. Recommendation
+ * strings are NOT in this module — formatting is the renderer's job
+ * (see `validate context` in gsd-tools.cjs). That separation lets the
+ * copy change without touching this module's tests.
+ *
+ * Thresholds:
+ *   < 60%   healthy   no action
+ *   60–70%  warning   approaching the fracture zone
+ *   ≥ 70%   critical  reasoning quality may degrade
+ *
+ * State boundaries use the exact ratio. The displayed `percent` is
+ * rounded for human reading and may differ from the boundary by ±1 in
+ * edge cases (e.g. 59.999% displays as 60 but classifies as healthy).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATES = void 0;
+exports.classifyContextUtilization = classifyContextUtilization;
+exports.STATES = Object.freeze({
+    HEALTHY: 'healthy',
+    WARNING: 'warning',
+    CRITICAL: 'critical',
+});
+function classifyContextUtilization(tokensUsed, contextWindow) {
+    if (!Number.isInteger(tokensUsed) || tokensUsed < 0) {
+        throw new TypeError(`tokensUsed must be a non-negative integer, got: ${tokensUsed} (${typeof tokensUsed})`);
+    }
+    if (!Number.isInteger(contextWindow) || contextWindow <= 0) {
+        throw new TypeError(`contextWindow must be a positive integer, got: ${contextWindow} (${typeof contextWindow})`);
+    }
+    const ratio = Math.min(tokensUsed / contextWindow, 1);
+    const percent = Math.min(Math.round(ratio * 100), 100);
+    let state;
+    if (ratio < 0.60)
+        state = exports.STATES.HEALTHY;
+    else if (ratio < 0.70)
+        state = exports.STATES.WARNING;
+    else
+        state = exports.STATES.CRITICAL;
+    return { percent, state };
+}

package/pp-core/bin/lib/core-utils.cjs

@@ -0,0 +1,198 @@
+"use strict";
+/**
+ * Core Utilities — Shared low-level utility primitives
+ *
+ * ADR-857 rollout phase 2c: extracted from core.cts (issue #877).
+ * Owns POSIX path normalization, sub-repo/subdirectory scanning,
+ * phase file stats, slug/one-liner/plan-id helpers, and time-ago.
+ * Behaviour is preserved byte-for-behaviour from the prior location;
+ * only the module boundary moved. core.cjs re-exports every public symbol
+ * here under its own `export =` object so existing consumers are unaffected.
+ *
+ * New imports should pull core-utils helpers from core-utils.cjs directly.
+ *
+ * Dependencies (leaf modules only — no core.cjs, no loadConfig):
+ *   - node:fs / node:path (stdlib)
+ *   - ./phase-id.cjs       (comparePhaseNum, used by readSubdirectories)
+ *   - ./planning-workspace.cjs (findContextMdIn, used by getPhaseFileStats)
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const phaseIdModule = require("./phase-id.cjs");
+const { comparePhaseNum } = phaseIdModule;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const planningWorkspace = require("./planning-workspace.cjs");
+const { findContextMdIn } = planningWorkspace;
+// ─── Path helpers ────────────────────────────────────────────────────────────
+/** Normalize a relative path to always use forward slashes (cross-platform). */
+function toPosixPath(p) {
+    return p.split(node_path_1.default.sep).join('/');
+}
+/**
+ * Scan immediate child directories for separate git repos.
+ * Returns a sorted array of directory names that have their own `.git`.
+ * Excludes hidden directories and node_modules.
+ */
+function detectSubRepos(cwd) {
+    const results = [];
+    try {
+        const entries = node_fs_1.default.readdirSync(cwd, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (entry.name.startsWith('.') || entry.name === 'node_modules')
+                continue;
+            const gitPath = node_path_1.default.join(cwd, entry.name, '.git');
+            try {
+                if (node_fs_1.default.existsSync(gitPath)) {
+                    results.push(entry.name);
+                }
+            }
+            catch { /* ignore */ }
+        }
+    }
+    catch { /* ignore */ }
+    return results.sort();
+}
+// ─── Summary body helpers ─────────────────────────────────────────────────
+/**
+ * Extract a one-liner from the summary body when it's not in frontmatter.
+ */
+function extractOneLinerFromBody(content) {
+    if (!content)
+        return null;
+    const normalized = content.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    const body = normalized.replace(/^---\n[\s\S]*?\n---\n*/, '');
+    const match = body.match(/^#[^\n]*\n+\*\*([^*\n]+)\*\*([^\n]*)/m);
+    if (!match)
+        return null;
+    const boldInner = match[1].trim();
+    const afterBold = match[2];
+    if (/:\s*$/.test(boldInner)) {
+        const prose = afterBold.trim();
+        return prose.length > 0 ? prose : null;
+    }
+    return boldInner.length > 0 ? boldInner : null;
+}
+// ─── Misc utilities ───────────────────────────────────────────────────────────
+function pathExistsInternal(cwd, targetPath) {
+    const fullPath = node_path_1.default.isAbsolute(targetPath) ? targetPath : node_path_1.default.join(cwd, targetPath);
+    try {
+        node_fs_1.default.statSync(fullPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function generateSlugInternal(text) {
+    if (!text)
+        return null;
+    return text.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').substring(0, 60);
+}
+// ─── Phase file helpers ──────────────────────────────────────────────────────
+/** Filter a file list to just PLAN.md / *-PLAN.md entries. */
+function filterPlanFiles(files) {
+    return files.filter(f => f.endsWith('-PLAN.md') || f === 'PLAN.md');
+}
+/** Filter a file list to just SUMMARY.md / *-SUMMARY.md entries. */
+function filterSummaryFiles(files) {
+    return files.filter(f => f.endsWith('-SUMMARY.md') || f === 'SUMMARY.md');
+}
+/**
+ * Read a phase directory and return counts/flags for common file types.
+ */
+function getPhaseFileStats(phaseDir) {
+    const files = node_fs_1.default.readdirSync(phaseDir);
+    return {
+        plans: filterPlanFiles(files),
+        summaries: filterSummaryFiles(files),
+        hasResearch: files.some(f => f.endsWith('-RESEARCH.md') || f === 'RESEARCH.md'),
+        hasContext: findContextMdIn(files) !== null,
+        hasVerification: files.some(f => f.endsWith('-VERIFICATION.md') || f === 'VERIFICATION.md'),
+        hasReviews: files.some(f => f.endsWith('-REVIEWS.md') || f === 'REVIEWS.md'),
+    };
+}
+/**
+ * Read immediate child directories from a path.
+ * Returns [] if the path doesn't exist or can't be read.
+ * Pass sort=true to apply comparePhaseNum ordering.
+ */
+function readSubdirectories(dirPath, sort = false) {
+    try {
+        const entries = node_fs_1.default.readdirSync(dirPath, { withFileTypes: true });
+        const dirs = entries.filter(e => e.isDirectory()).map(e => e.name);
+        return sort ? dirs.sort((a, b) => comparePhaseNum(a, b)) : dirs;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Format a Date as a fuzzy relative time string (e.g. "5 minutes ago").
+ */
+function timeAgo(date) {
+    const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
+    if (seconds < 5)
+        return 'just now';
+    if (seconds < 60)
+        return `${seconds} seconds ago`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes === 1)
+        return '1 minute ago';
+    if (minutes < 60)
+        return `${minutes} minutes ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours === 1)
+        return '1 hour ago';
+    if (hours < 24)
+        return `${hours} hours ago`;
+    const days = Math.floor(hours / 24);
+    if (days === 1)
+        return '1 day ago';
+    if (days < 30)
+        return `${days} days ago`;
+    const months = Math.floor(days / 30);
+    if (months === 1)
+        return '1 month ago';
+    if (months < 12)
+        return `${months} months ago`;
+    const years = Math.floor(days / 365);
+    if (years === 1)
+        return '1 year ago';
+    return `${years} years ago`;
+}
+// ─── Plan ID helpers ─────────────────────────────────────────────────────────
+/**
+ * Extract the canonical plan ID from a filename.
+ * Private to the core cluster — exported so core.cjs:searchPhaseInDir can
+ * import it from this leaf without circular dependency, but NOT re-exported
+ * from core.cjs's public `export =` block.
+ */
+function extractCanonicalPlanId(filename) {
+    const base = filename.replace(/-PLAN\.md$/i, '').replace(/-SUMMARY\.md$/i, '').replace(/\.md$/i, '');
+    const parts = base.split('-').filter(Boolean);
+    const tokenRe = /^\d+[A-Z]?(?:\.\d+)*$/i;
+    const phaseIdx = parts.findIndex(p => tokenRe.test(p));
+    if (phaseIdx >= 0 && phaseIdx + 1 < parts.length && tokenRe.test(parts[phaseIdx + 1])) {
+        return `${parts[phaseIdx]}-${parts[phaseIdx + 1]}`;
+    }
+    return base;
+}
+module.exports = {
+    toPosixPath,
+    detectSubRepos,
+    extractOneLinerFromBody,
+    pathExistsInternal,
+    generateSlugInternal,
+    filterPlanFiles,
+    filterSummaryFiles,
+    getPhaseFileStats,
+    readSubdirectories,
+    timeAgo,
+    extractCanonicalPlanId,
+};

package/pp-core/bin/lib/decisions.cjs

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * Shared parser for CONTEXT.md <decisions> blocks (ADR-457 build-at-publish:
+ * the hand-written bin/lib/decisions.cjs collapsed to a TypeScript source of
+ * truth). Behaviour is preserved byte-for-behaviour from the prior hand-written
+ * .cjs; only types are added.
+ *
+ * Accepts both numeric (D-42) and alphanumeric (D-INFRA-01) IDs.
+ * Returns {id, text, category, tags, trackable} per decision.
+ * CJS callers that only use {id, text} safely ignore the extra fields.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDecisions = parseDecisions;
+const DISCRETION_HEADINGS = new Set([
+    "claude's discretion",
+    'claudes discretion',
+    'claude discretion',
+]);
+const NON_TRACKABLE_TAGS = new Set(['informational', 'folded', 'deferred']);
+/**
+ * Strip fenced code blocks from `content` so example `<decisions>` snippets
+ * inside ```` ``` ```` do not pollute the parser (review F11).
+ */
+function stripFencedCode(content) {
+    return content.replace(/```[\s\S]*?```/g, ' ').replace(/~~~[\s\S]*?~~~/g, ' ');
+}
+/**
+ * Extract the inner text of EVERY `<decisions>...</decisions>` block in
+ * order, concatenated by `\n\n`. Returns null when no block is present.
+ *
+ * CONTEXT.md may legitimately contain more than one block (for example, a
+ * "current decisions" block plus a "carry-over from prior phase" block);
+ * dropping all-but-the-first silently lost the second batch (review F13).
+ */
+function extractDecisionsBlock(content) {
+    const cleaned = stripFencedCode(content);
+    const matches = [...cleaned.matchAll(/<decisions>([\s\S]*?)<\/decisions>/g)];
+    if (matches.length === 0)
+        return null;
+    return matches.map((m) => m[1]).join('\n\n');
+}
+/**
+ * Parse trackable decisions from CONTEXT.md content.
+ *
+ * Returns ALL D-NN decisions found inside `<decisions>` (including
+ * non-trackable ones, with `trackable: false`). Callers that only want the
+ * gate-enforced decisions should filter `.filter(d => d.trackable)`.
+ */
+function parseDecisions(content) {
+    if (!content || typeof content !== 'string')
+        return [];
+    const block = extractDecisionsBlock(content);
+    if (block === null)
+        return [];
+    const lines = block.split(/\r?\n/);
+    const out = [];
+    let category = '';
+    let inDiscretion = false;
+    // Bullet line: `- **D-NN[ [tags]]:** text`
+    // Phase 6 (#3575): aligned to CJS regex — accepts alphanumeric IDs (D-01, D-INFRA-01, D-FOO_BAR)
+    // in addition to numeric-only IDs (D-42). The first character after `D-` must
+    // be alphanumeric, so malformed shapes like `D--foo` or `D-_bar` are rejected.
+    // CJS callers consume {id, text} and ignore the optional extras.
+    // #1343: `[^:*]*` replaces the old `\s*` before `:**` so that a freeform run
+    // such as `(parenthetical)`, an em-dash, or other prose between the optional
+    // bracket-tag group and the closing `:**` is tolerated rather than silently
+    // dropping the whole decision. `[^:*]*` subsumes plain whitespace and stops
+    // correctly at `:**`. Capture groups 1 (id), 2 (bracket tags), 3 (text) are
+    // unchanged.
+    const bulletRe = /^\s*-\s+\*\*D-([A-Za-z0-9][A-Za-z0-9_-]*)(?:\s*\[([^\]]+)\])?[^:*]*:\*\*\s*(.*)$/;
+    let current = null;
+    const flush = () => {
+        if (current) {
+            current.text = current.text.trim();
+            out.push(current);
+            current = null;
+        }
+    };
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Track category headings (`### Heading`)
+        const headingMatch = trimmed.match(/^###\s+(.+?)\s*$/);
+        if (headingMatch) {
+            flush();
+            category = headingMatch[1];
+            // Strip the full unicode-quote family so any rendering of "Claude's
+            // Discretion" (ASCII apostrophe, curly U+2019, U+2018, U+201A, U+201B,
+            // double-quote variants U+201C/D/E/F, etc.) collapses to the same key
+            // (review F20).
+            const normalized = category
+                .toLowerCase()
+                .replace(/[‘’‚‛“”„‟'"`]/g, '')
+                .trim();
+            inDiscretion = DISCRETION_HEADINGS.has(normalized);
+            continue;
+        }
+        const bulletMatch = line.match(bulletRe);
+        if (bulletMatch) {
+            flush();
+            const id = `D-${bulletMatch[1]}`;
+            const tags = bulletMatch[2]
+                ? bulletMatch[2]
+                    .split(',')
+                    .map((t) => t.trim().toLowerCase())
+                    .filter(Boolean)
+                : [];
+            const trackable = !inDiscretion && !tags.some((t) => NON_TRACKABLE_TAGS.has(t));
+            current = { id, text: bulletMatch[3], category, tags, trackable };
+            continue;
+        }
+        // Parse-miss guard (#1343): a line that looks like a `D-NN` decision bullet
+        // but failed `bulletRe` (e.g. a `:` or `*` inside the pre-colon run) must NOT
+        // be silently dropped — a narrowed trackable set lets a blocking coverage gate
+        // report a false pass. Surface it loudly instead.
+        if (/^\s*-\s+\*\*D-/.test(line)) {
+            // A malformed D-bullet still starts a (failed) new decision, so it ends the
+            // previous one — flush before warning so a following continuation line cannot
+            // be mis-appended to the prior valid decision.
+            flush();
+            console.warn(`parseDecisions: ignored unparseable decision bullet: ${trimmed}`);
+            continue;
+        }
+        // Continuation line for current decision (indented with space OR tab,
+        // non-bullet, non-empty) — tab indentation must work too (review F12).
+        if (current && trimmed !== '' && !trimmed.startsWith('-') && /^[ \t]/.test(line)) {
+            current.text += ' ' + trimmed;
+            continue;
+        }
+        // Blank line or unrelated content terminates the current decision
+        if (trimmed === '') {
+            flush();
+        }
+    }
+    flush();
+    return out;
+}