@dezycro-ai/agent-plugin 2.0.0

package/dist/hooks/lib/controller-match.js

@@ -0,0 +1,96 @@
+/**
+ * controller-match.ts — match file paths against `controllerPaths` globs from
+ * `.dezycro/config.json` (TRD §5.2).
+ *
+ * Minimal glob subset (stdlib only):
+ *   - `**`   zero or more path segments
+ *   - `*`    any chars within a single segment (no slashes)
+ *   - `?`    any single char within a single segment
+ *   - `{a,b}` alternation (`*.{kt,java}`)
+ *
+ * Limitations: no character classes, no escaping, forward-slash only.
+ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandAlternation = expandAlternation;
+exports.globToRegex = globToRegex;
+exports.matchesControllerPath = matchesControllerPath;
+exports.selectControllers = selectControllers;
+function normalizePath(p) {
+    return String(p || '').replace(/\\/g, '/');
+}
+function expandAlternation(glob) {
+    const m = glob.match(/\{([^{}]+)\}/);
+    if (!m || m.index === undefined)
+        return [glob];
+    const whole = m[0];
+    const inner = m[1];
+    const parts = inner.split(',');
+    const out = [];
+    for (const part of parts) {
+        const expanded = glob.slice(0, m.index) + part + glob.slice(m.index + whole.length);
+        out.push(...expandAlternation(expanded));
+    }
+    return out;
+}
+function globToRegex(glob) {
+    let re = '^';
+    for (let i = 0; i < glob.length; i += 1) {
+        const c = glob[i];
+        if (c === '*') {
+            if (glob[i + 1] === '*') {
+                i += 1;
+                if (glob[i + 1] === '/') {
+                    i += 1;
+                    re += '(?:.*/)?';
+                }
+                else {
+                    re += '.*';
+                }
+            }
+            else {
+                re += '[^/]*';
+            }
+        }
+        else if (c === '?') {
+            re += '[^/]';
+        }
+        else if ('.+^$()|[]\\'.indexOf(c) !== -1) {
+            re += '\\' + c;
+        }
+        else {
+            re += c;
+        }
+    }
+    re += '$';
+    return new RegExp(re);
+}
+const _regexCache = new Map();
+function compileGlob(glob) {
+    const hit = _regexCache.get(glob);
+    if (hit)
+        return hit;
+    const patterns = expandAlternation(glob).map(globToRegex);
+    _regexCache.set(glob, patterns);
+    return patterns;
+}
+function matchesControllerPath(filePath, globs) {
+    if (!filePath || !Array.isArray(globs) || globs.length === 0)
+        return false;
+    const norm = normalizePath(filePath);
+    for (const glob of globs) {
+        if (typeof glob !== 'string' || glob.length === 0)
+            continue;
+        const regexes = compileGlob(glob);
+        for (const re of regexes) {
+            if (re.test(norm))
+                return true;
+        }
+    }
+    return false;
+}
+function selectControllers(filePaths, globs) {
+    if (!Array.isArray(filePaths))
+        return [];
+    return filePaths.filter((p) => matchesControllerPath(p, globs));
+}

package/dist/hooks/lib/coverage.d.ts

@@ -0,0 +1,17 @@
+/**
+ * coverage.ts — deterministic coverage-snapshot formatter (TRD §5.4.2).
+ *
+ * One-liner format:
+ *   Coverage: N path[s] uncovered, M endpoint[s] not in spec, K baseline[s] stale
+ *
+ * Zero-count segments are omitted. If all counts are zero, returns null.
+ */
+import type { CoverageSnapshot } from '../types';
+export declare function formatOneLiner(snapshot: CoverageSnapshot | null | undefined): string | null;
+export declare function formatDelta(prev: CoverageSnapshot | null | undefined, next: CoverageSnapshot | null | undefined): string | null;
+/**
+ * Detached coverage-fetch entry point. Deferred to V2.1 — for V2.0 the
+ * /dezycro:verify skill calls get_coverage_report directly and updates
+ * state via `companion-runner state --patch=…`.
+ */
+export declare function fetch(_featureId: string): Promise<null>;

package/dist/hooks/lib/coverage.js

@@ -0,0 +1,66 @@
+/**
+ * coverage.ts — deterministic coverage-snapshot formatter (TRD §5.4.2).
+ *
+ * One-liner format:
+ *   Coverage: N path[s] uncovered, M endpoint[s] not in spec, K baseline[s] stale
+ *
+ * Zero-count segments are omitted. If all counts are zero, returns null.
+ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatOneLiner = formatOneLiner;
+exports.formatDelta = formatDelta;
+exports.fetch = fetch;
+function plural(n, word) {
+    return `${n} ${word}${n === 1 ? '' : 's'}`;
+}
+function snapshotCounts(snapshot) {
+    if (!snapshot || typeof snapshot !== 'object')
+        return null;
+    return {
+        uncoveredPaths: Number(snapshot.uncoveredPaths ?? 0) || 0,
+        endpointsNotInSpec: Number(snapshot.endpointsNotInSpec ?? 0) || 0,
+        staleBaselines: Number(snapshot.staleBaselines ?? 0) || 0,
+    };
+}
+function formatOneLiner(snapshot) {
+    const c = snapshotCounts(snapshot);
+    if (!c)
+        return null;
+    const segments = [];
+    if (c.uncoveredPaths > 0)
+        segments.push(`${plural(c.uncoveredPaths, 'path')} uncovered`);
+    if (c.endpointsNotInSpec > 0)
+        segments.push(`${plural(c.endpointsNotInSpec, 'endpoint')} not in spec`);
+    if (c.staleBaselines > 0)
+        segments.push(`${plural(c.staleBaselines, 'baseline')} stale`);
+    if (segments.length === 0)
+        return null;
+    return `Coverage: ${segments.join(', ')}`;
+}
+function formatDelta(prev, next) {
+    const a = snapshotCounts(prev);
+    const b = snapshotCounts(next);
+    if (!b)
+        return null;
+    if (!a)
+        return formatOneLiner(next);
+    const deltas = [
+        ['paths uncovered', b.uncoveredPaths - a.uncoveredPaths],
+        ['endpoints not in spec', b.endpointsNotInSpec - a.endpointsNotInSpec],
+        ['baselines stale', b.staleBaselines - a.staleBaselines],
+    ];
+    const nonZero = deltas.filter(([, d]) => d !== 0);
+    if (nonZero.length === 0)
+        return null;
+    const parts = nonZero.map(([label, d]) => `${d > 0 ? '+' : ''}${d} ${label}`);
+    return `Coverage delta since last verify: ${parts.join(', ')}`;
+}
+/**
+ * Detached coverage-fetch entry point. Deferred to V2.1 — for V2.0 the
+ * /dezycro:verify skill calls get_coverage_report directly and updates
+ * state via `companion-runner state --patch=…`.
+ */
+async function fetch(_featureId) {
+    return null;
+}

package/dist/hooks/lib/hashing.d.ts

@@ -0,0 +1,8 @@
+/**
+ * hashing.ts — content-hash dedup for auto-logged workbook items (TRD §3.4).
+ *
+ * SHA-1 of `lowercase(<entity-kind>::<summary>::<linked-task-id-or-empty>)`
+ * truncated to 16 hex chars.
+ */
+export type EntityKind = 'decision' | 'issue' | 'assumption' | 'task-status';
+export declare function hashCandidate(entityKind: EntityKind | string, summary: string, linkedTaskId: string | null): string;

package/dist/hooks/lib/hashing.js

@@ -0,0 +1,49 @@
+/**
+ * hashing.ts — content-hash dedup for auto-logged workbook items (TRD §3.4).
+ *
+ * SHA-1 of `lowercase(<entity-kind>::<summary>::<linked-task-id-or-empty>)`
+ * truncated to 16 hex chars.
+ */
+'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.hashCandidate = hashCandidate;
+const crypto = __importStar(require("crypto"));
+function hashCandidate(entityKind, summary, linkedTaskId) {
+    const kind = String(entityKind || '').toLowerCase().trim();
+    const text = String(summary || '').toLowerCase().trim().replace(/\s+/g, ' ');
+    const link = String(linkedTaskId || '').toLowerCase().trim();
+    return crypto.createHash('sha1').update(`${kind}::${text}::${link}`).digest('hex').slice(0, 16);
+}

package/dist/hooks/lib/logging.d.ts

@@ -0,0 +1,13 @@
+/**
+ * logging.ts — JSON-lines logger for Companion.
+ *
+ * Writes to `.dezycro/companion.log` per TRD §12 (Observability). Best-effort:
+ * never throws upstream — a logging failure must never break a hook.
+ */
+type Fields = Record<string, unknown> | undefined;
+/** Append a single JSON-lines record to `<repoRoot>/.dezycro/companion.log`. */
+export declare function append(repoRoot: string, record: Record<string, unknown>): void;
+export declare function info(repoRoot: string, event: string, fields?: Fields): void;
+export declare function warn(repoRoot: string, event: string, fields?: Fields): void;
+export declare function error(repoRoot: string, event: string, fields?: Fields): void;
+export {};

package/dist/hooks/lib/logging.js

@@ -0,0 +1,72 @@
+/**
+ * logging.ts — JSON-lines logger for Companion.
+ *
+ * Writes to `.dezycro/companion.log` per TRD §12 (Observability). Best-effort:
+ * never throws upstream — a logging failure must never break a hook.
+ */
+'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.append = append;
+exports.info = info;
+exports.warn = warn;
+exports.error = error;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const LOG_FILENAME = 'companion.log';
+/** Append a single JSON-lines record to `<repoRoot>/.dezycro/companion.log`. */
+function append(repoRoot, record) {
+    try {
+        const dezycroDir = path.join(repoRoot, '.dezycro');
+        if (!fs.existsSync(dezycroDir)) {
+            // We don't create the dir here — Companion init owns that.
+            return;
+        }
+        const line = JSON.stringify({ ts: new Date().toISOString(), ...record }) + '\n';
+        fs.appendFileSync(path.join(dezycroDir, LOG_FILENAME), line, { encoding: 'utf8' });
+    }
+    catch {
+        // Swallow — logging must never propagate.
+    }
+}
+function info(repoRoot, event, fields) {
+    append(repoRoot, { level: 'info', event, ...(fields || {}) });
+}
+function warn(repoRoot, event, fields) {
+    append(repoRoot, { level: 'warn', event, ...(fields || {}) });
+}
+function error(repoRoot, event, fields) {
+    append(repoRoot, { level: 'error', event, ...(fields || {}) });
+}

package/dist/hooks/lib/publish-spec.d.ts

@@ -0,0 +1,17 @@
+/**
+ * publish-spec.ts — helper consumed by the `/dezycro:verify` skill to detect
+ * pending controller edits and announce + chain `/dezycro:publish-spec` before
+ * verifying (TRD §5.2).
+ *
+ * The hook layer does NOT run this. PostToolUse:edit sets `needsSpecPublish`
+ * + appends to `controllerEditsSinceLastPublish` (in router.ts); the verify
+ * skill reads via `needsPublishBeforeVerify`, announces, chains publish-spec,
+ * then runs verify. After publish-spec completes the skill clears the flags.
+ */
+export interface PublishCheckResult {
+    needed: boolean;
+    controllerPaths: string[];
+    lastEditTs: string | null;
+}
+export declare function needsPublishBeforeVerify(repoRoot: string | null | undefined): PublishCheckResult;
+export declare function buildAnnouncement(controllerPaths: string[]): string;

package/dist/hooks/lib/publish-spec.js

@@ -0,0 +1,64 @@
+/**
+ * publish-spec.ts — helper consumed by the `/dezycro:verify` skill to detect
+ * pending controller edits and announce + chain `/dezycro:publish-spec` before
+ * verifying (TRD §5.2).
+ *
+ * The hook layer does NOT run this. PostToolUse:edit sets `needsSpecPublish`
+ * + appends to `controllerEditsSinceLastPublish` (in router.ts); the verify
+ * skill reads via `needsPublishBeforeVerify`, announces, chains publish-spec,
+ * then runs verify. After publish-spec completes the skill clears the flags.
+ */
+'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.needsPublishBeforeVerify = needsPublishBeforeVerify;
+exports.buildAnnouncement = buildAnnouncement;
+const state = __importStar(require("./state"));
+function needsPublishBeforeVerify(repoRoot) {
+    if (!repoRoot)
+        return { needed: false, controllerPaths: [], lastEditTs: null };
+    const s = state.read(repoRoot);
+    const edits = Array.isArray(s.controllerEditsSinceLastPublish)
+        ? s.controllerEditsSinceLastPublish
+        : [];
+    const controllerPaths = edits.map((e) => e && e.path).filter(Boolean);
+    const lastEditTs = edits.length > 0 ? (edits[edits.length - 1].editedTs || null) : null;
+    const needed = Boolean(s.needsSpecPublish) && controllerPaths.length > 0;
+    return { needed, controllerPaths, lastEditTs };
+}
+function buildAnnouncement(controllerPaths) {
+    const list = (controllerPaths || []).join(', ');
+    return 'Controllers changed since last published spec: ' + list + '. Publishing spec before verify.';
+}

package/dist/hooks/lib/quality-gate.d.ts

@@ -0,0 +1,67 @@
+/**
+ * quality-gate.ts — deterministic TRD-approval checks + code-side enforcement
+ * of the P-9 LLM result. TRD §5.5.3 QUALITY_GATE and §6.9 enforcement notes.
+ *
+ * No LLM calls live here. The skill markdown is responsible for invoking P-9;
+ * `enforceP9Result` is the tamper-proof code-side guard run against P-9's
+ * structured output.
+ */
+export declare const INVENTION_KEYWORDS: readonly string[];
+export interface RequiredHeading {
+    id: string;
+    pattern: RegExp;
+}
+export declare const REQUIRED_TRD_HEADINGS: readonly RequiredHeading[];
+export declare const PLACEHOLDER_REGEX: RegExp;
+export declare const MIN_TRD_LENGTH = 1000;
+export declare const PILLAR_HEADING_REGEX: RegExp;
+export declare const MIN_CONTEXT_CATEGORIES: readonly string[];
+export declare const MIN_CONTEXT_EVIDENCE_CHARS = 80;
+export declare const MIN_P9_SCORE = 0.85;
+export declare function parsePrdPillarNames(prdContent: string | null | undefined): string[];
+export interface BlockingIssue {
+    section: string;
+    issue: string;
+    required_fix: string;
+}
+export interface DeterministicGateResult {
+    passed: boolean;
+    blockingIssues: BlockingIssue[];
+    deterministic: true;
+}
+export declare function deterministicTrdGate(opts: {
+    trdContent: string | null | undefined;
+    prdContent: string | null | undefined;
+}): DeterministicGateResult;
+export interface MinContextGateInput {
+    discoverySummary: {
+        confirmed_context?: Record<string, string[]>;
+        likely_conventions?: Record<string, string[]>;
+        [extra: string]: unknown;
+    } | null;
+    answeredCategories: Record<string, string[]> | null;
+}
+export interface MinContextGateResult {
+    ready: boolean;
+    missing: Record<string, string[]>;
+}
+export declare function minContextGate(opts: MinContextGateInput): MinContextGateResult;
+export interface P9Output {
+    approved?: boolean;
+    score?: number;
+    suspected_inventions?: Array<{
+        claim?: string;
+    }>;
+    blocking_issues?: Array<{
+        issue?: string;
+    }>;
+}
+export interface P9EnforcementResult {
+    passed: boolean;
+    reason: string | null;
+    score: number;
+    suspectedInventions: Array<{
+        claim?: string;
+    }>;
+}
+export declare function enforceP9Result(p9Output: P9Output | null | undefined): P9EnforcementResult;

package/dist/hooks/lib/quality-gate.js

@@ -0,0 +1,187 @@
+/**
+ * quality-gate.ts — deterministic TRD-approval checks + code-side enforcement
+ * of the P-9 LLM result. TRD §5.5.3 QUALITY_GATE and §6.9 enforcement notes.
+ *
+ * No LLM calls live here. The skill markdown is responsible for invoking P-9;
+ * `enforceP9Result` is the tamper-proof code-side guard run against P-9's
+ * structured output.
+ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIN_P9_SCORE = exports.MIN_CONTEXT_EVIDENCE_CHARS = exports.MIN_CONTEXT_CATEGORIES = exports.PILLAR_HEADING_REGEX = exports.MIN_TRD_LENGTH = exports.PLACEHOLDER_REGEX = exports.REQUIRED_TRD_HEADINGS = exports.INVENTION_KEYWORDS = void 0;
+exports.parsePrdPillarNames = parsePrdPillarNames;
+exports.deterministicTrdGate = deterministicTrdGate;
+exports.minContextGate = minContextGate;
+exports.enforceP9Result = enforceP9Result;
+exports.INVENTION_KEYWORDS = Object.freeze([
+    'architecture',
+    'data model',
+    'data-model',
+    'datamodel',
+    'api contract',
+    'api-contract',
+    'apicontract',
+    'migration',
+    'auth',
+    'queue',
+    'verifier-behavior',
+    'verifier behavior',
+]);
+exports.REQUIRED_TRD_HEADINGS = Object.freeze([
+    { id: 'architecture', pattern: /^##\s+architecture\b/im },
+    { id: 'data_model', pattern: /^##\s+data\s+model\b/im },
+    { id: 'api_contracts', pattern: /^##\s+api\s+contracts?\b/im },
+    { id: 'failure_modes', pattern: /^##\s+failure\s+modes?/im },
+    { id: 'migration', pattern: /^##\s+migration\b/im },
+    { id: 'open_questions', pattern: /^##\s+open\s+questions?\b/im },
+]);
+exports.PLACEHOLDER_REGEX = /\b(TBD|TODO|FIXME|fill in later|to be determined)\b/i;
+exports.MIN_TRD_LENGTH = 1000;
+exports.PILLAR_HEADING_REGEX = /^##\s+Pillar\s+\d+\s*:\s*(.+?)\s*$/gim;
+exports.MIN_CONTEXT_CATEGORIES = Object.freeze([
+    'data_model',
+    'api_contracts',
+    'state_or_persistence',
+    'failure_modes',
+    'migration_or_rollout',
+]);
+exports.MIN_CONTEXT_EVIDENCE_CHARS = 80;
+exports.MIN_P9_SCORE = 0.85;
+function normalizeWhitespace(s) {
+    return (s || '').toString().replace(/\s+/g, ' ').trim();
+}
+function parsePrdPillarNames(prdContent) {
+    if (!prdContent || typeof prdContent !== 'string')
+        return [];
+    const names = [];
+    exports.PILLAR_HEADING_REGEX.lastIndex = 0;
+    let match;
+    while ((match = exports.PILLAR_HEADING_REGEX.exec(prdContent)) !== null) {
+        const name = match[1].trim();
+        if (name)
+            names.push(name);
+    }
+    return names;
+}
+function deterministicTrdGate(opts) {
+    const { trdContent, prdContent } = opts;
+    const issues = [];
+    const trd = (trdContent || '').toString();
+    const trdLen = trd.trim().length;
+    if (trdLen < exports.MIN_TRD_LENGTH) {
+        issues.push({
+            section: 'document',
+            issue: `TRD is too short (${trdLen} chars; minimum ${exports.MIN_TRD_LENGTH}).`,
+            required_fix: 'Expand the draft with concrete technical detail.',
+        });
+    }
+    for (const required of exports.REQUIRED_TRD_HEADINGS) {
+        if (!required.pattern.test(trd)) {
+            issues.push({
+                section: required.id,
+                issue: `Required H2 section is missing.`,
+                required_fix: `Add a "## ${required.id.replace(/_/g, ' ')}" section grounded in the PRD + discovery.`,
+            });
+        }
+    }
+    const placeholderMatch = trd.match(exports.PLACEHOLDER_REGEX);
+    if (placeholderMatch) {
+        issues.push({
+            section: 'placeholders',
+            issue: `Placeholder token "${placeholderMatch[0]}" present — TRDs must not ship with unresolved placeholders.`,
+            required_fix: 'Resolve or move the open item into the ## Open Questions section.',
+        });
+    }
+    const pillarNames = parsePrdPillarNames(prdContent);
+    if (pillarNames.length > 0) {
+        const missing = [];
+        const haystack = trd.toLowerCase();
+        for (const name of pillarNames) {
+            if (!haystack.includes(name.toLowerCase()))
+                missing.push(name);
+        }
+        if (missing.length > 0) {
+            issues.push({
+                section: 'pillar_coverage',
+                issue: `TRD does not mention PRD pillar(s): ${missing.join(', ')}.`,
+                required_fix: 'Add a per-pillar technical-design section, or reference each pillar by name in the relevant TRD section.',
+            });
+        }
+    }
+    return {
+        passed: issues.length === 0,
+        blockingIssues: issues,
+        deterministic: true,
+    };
+}
+function minContextGate(opts) {
+    const summary = opts.discoverySummary || {};
+    const confirmed = summary.confirmed_context || {};
+    const likely = summary.likely_conventions || {};
+    const answers = opts.answeredCategories || {};
+    const missing = {};
+    for (const cat of exports.MIN_CONTEXT_CATEGORIES) {
+        const items = []
+            .concat(confirmed[cat] || [])
+            .concat(likely[cat] || [])
+            .concat(answers[cat] || []);
+        const combined = normalizeWhitespace(items.join(' '));
+        const reasons = [];
+        if (items.length === 0) {
+            reasons.push('no evidence in confirmed_context, likely_conventions, or QA answers');
+        }
+        else if (combined.length < exports.MIN_CONTEXT_EVIDENCE_CHARS) {
+            reasons.push(`evidence too thin (${combined.length} chars; need \u2265 ${exports.MIN_CONTEXT_EVIDENCE_CHARS})`);
+        }
+        if (reasons.length > 0)
+            missing[cat] = reasons;
+    }
+    return {
+        ready: Object.keys(missing).length === 0,
+        missing,
+    };
+}
+function enforceP9Result(p9Output) {
+    const out = p9Output || {};
+    const score = typeof out.score === 'number' ? out.score : 0;
+    const suspected = Array.isArray(out.suspected_inventions) ? out.suspected_inventions : [];
+    if (score < exports.MIN_P9_SCORE) {
+        return {
+            passed: false,
+            reason: `P-9 score ${score.toFixed(2)} is below the minimum ${exports.MIN_P9_SCORE.toFixed(2)} — TRD is not approved.`,
+            score,
+            suspectedInventions: suspected,
+        };
+    }
+    const flagged = [];
+    for (const inv of suspected) {
+        const claim = (inv && inv.claim ? inv.claim : '').toString().toLowerCase();
+        if (!claim)
+            continue;
+        const hit = exports.INVENTION_KEYWORDS.find((kw) => claim.includes(kw));
+        if (hit)
+            flagged.push({ claim: String(inv.claim), keyword: hit });
+    }
+    if (flagged.length > 0) {
+        const summary = flagged
+            .map((f) => `"${f.claim}" (keyword: ${f.keyword})`)
+            .join('; ');
+        return {
+            passed: false,
+            reason: `P-9 flagged invented technical claim(s): ${summary}. Move to Open Questions or ask the user.`,
+            score,
+            suspectedInventions: suspected,
+        };
+    }
+    if (out.approved !== true) {
+        return {
+            passed: false,
+            reason: out.blocking_issues && out.blocking_issues.length > 0
+                ? `P-9 reviewer rejected: ${String(out.blocking_issues[0].issue || 'blocking issue')}`
+                : 'P-9 reviewer did not approve the TRD.',
+            score,
+            suspectedInventions: suspected,
+        };
+    }
+    return { passed: true, reason: null, score, suspectedInventions: suspected };
+}