@opengsd/gsd-core 1.5.0-rc.3 → 1.5.0-rc.4

package/gsd-core/bin/lib/git-base-branch.cjs

@@ -0,0 +1,194 @@
+"use strict";
+/**
+ * Git Base-Branch Resolver — issue #1146.
+ *
+ * Single source of truth for detecting the repository's default branch.
+ * Replaces the duplicated per-workflow bash detection that only consulted
+ * `refs/remotes/origin/HEAD` then hardcoded `:-main`, which silently
+ * returned "main" for repos whose default branch is "master" whenever
+ * origin/HEAD was unset (git init + remote add / fetch without set-head /
+ * most CI checkouts / many worktrees).
+ *
+ * Precedence ladder (highest to lowest):
+ *   1. `git.base_branch` config override from .planning/config.json
+ *   2. `git symbolic-ref --short refs/remotes/origin/HEAD`  (fast, no network)
+ *   3. `git remote show origin` HEAD branch  ← AUTHORITATIVE; works when #2 unset
+ *   4. Local branch existence: "master" present + "main" absent → "master";
+ *      "main" present → "main"
+ *   5. "main"  (last-resort default)
+ *
+ * Every git subprocess is bounded with a timeout (≤ 30 s); on timeout/error
+ * the resolver degrades gracefully to the next tier — it never throws.
+ *
+ * Pure/testable: all I/O is injectable via the `deps` argument so unit
+ * tests can run without touching the real filesystem or spawning real git.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readConfigBaseBranch = readConfigBaseBranch;
+exports.trySymbolicRef = trySymbolicRef;
+exports.tryRemoteShow = tryRemoteShow;
+exports.tryLocalBranch = tryLocalBranch;
+exports.resolveBaseBranch = resolveBaseBranch;
+exports.cmdGitBaseBranch = cmdGitBaseBranch;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const shell_command_projection_cjs_1 = require("./shell-command-projection.cjs");
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+/**
+ * Safely look up `git.base_branch` from the project's config.json.
+ * Returns the configured value (a non-empty, non-null string) or null.
+ */
+function readConfigBaseBranch(planningDir, deps) {
+    const readFile = deps?.readFile ??
+        ((p) => { try {
+            return node_fs_1.default.readFileSync(p, 'utf8');
+        }
+        catch {
+            return null;
+        } });
+    const configPath = node_path_1.default.join(planningDir, 'config.json');
+    const raw = readFile(configPath);
+    if (!raw)
+        return null;
+    let cfg;
+    try {
+        cfg = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (!cfg || typeof cfg !== 'object' || Array.isArray(cfg))
+        return null;
+    const top = cfg;
+    // Support both "git.base_branch" (nested) and "base_branch" (flat legacy)
+    const gitSection = top.git;
+    if (gitSection && typeof gitSection === 'object' && !Array.isArray(gitSection)) {
+        const nested = gitSection.base_branch;
+        if (typeof nested === 'string' && nested.trim())
+            return nested.trim();
+    }
+    const flat = top.base_branch;
+    if (typeof flat === 'string' && flat.trim())
+        return flat.trim();
+    return null;
+}
+/**
+ * Try `git symbolic-ref --short refs/remotes/origin/HEAD` (no network).
+ * Strips the `origin/` prefix to return just the branch name.
+ * Returns null if unset or on error/timeout.
+ */
+function trySymbolicRef(cwd, execGit) {
+    try {
+        const r = execGit(['symbolic-ref', '--quiet', '--short', 'refs/remotes/origin/HEAD'], { cwd, timeout: 5_000 });
+        if (r.exitCode !== 0 || !r.stdout)
+            return null;
+        // Output is e.g. "origin/main" — strip the prefix
+        const branch = r.stdout.trim().replace(/^origin\//, '');
+        return branch || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Try `git remote show origin` to read the HEAD branch.
+ * This is authoritative when origin/HEAD is unset locally.
+ * Requires network access but succeeds in the common CI case where
+ * origin/HEAD was never set after `git init && git remote add origin`.
+ *
+ * Parses the line:  `HEAD branch: <name>`
+ * Returns null on error, timeout, or if the output is malformed.
+ */
+function tryRemoteShow(cwd, execGit) {
+    try {
+        const r = execGit(['remote', 'show', 'origin'], { cwd, timeout: 15_000 });
+        if (r.exitCode !== 0 || !r.stdout)
+            return null;
+        // The line looks like: "  HEAD branch: master"
+        const m = r.stdout.match(/^\s*HEAD branch:\s*(\S+)\s*$/m);
+        if (!m)
+            return null;
+        const branch = m[1];
+        // git emits "(unknown)" when the remote is offline but the local cache
+        // resolved it; treat that as non-authoritative and fall through.
+        if (!branch || branch === '(unknown)')
+            return null;
+        return branch;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Detect local branch existence as a tie-breaker when no remote info is available.
+ *
+ * Rules:
+ *   - "master" present AND "main" absent → "master"
+ *   - "main" present → "main"
+ *   - Neither → null (fall through to default)
+ *
+ * Returns null on error/timeout.
+ */
+function tryLocalBranch(cwd, execGit) {
+    try {
+        const r = execGit(['branch', '--list', 'main', 'master'], { cwd, timeout: 5_000 });
+        if (r.exitCode !== 0 || !r.stdout)
+            return null;
+        // `git branch --list main master` outputs one line per matching branch
+        const lines = r.stdout.split('\n').map(l => l.trim().replace(/^\*\s*/, ''));
+        const hasMain = lines.includes('main');
+        const hasMaster = lines.includes('master');
+        if (hasMaster && !hasMain)
+            return 'master';
+        if (hasMain)
+            return 'main';
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve the default/base branch for the repository at `cwd`.
+ *
+ * Consults the full precedence ladder and always returns a non-empty string.
+ * Never throws.
+ */
+function resolveBaseBranch(cwd, deps) {
+    const execGit = deps?.execGit ?? shell_command_projection_cjs_1.execGit;
+    // Derive .planning dir relative to cwd (mirrors planningDir() in core.cjs)
+    const planningDir = node_path_1.default.join(cwd, '.planning');
+    // 1. Config override
+    const configured = readConfigBaseBranch(planningDir, deps);
+    if (configured)
+        return configured;
+    // 2. symbolic-ref (fast, no network)
+    const symref = trySymbolicRef(cwd, execGit);
+    if (symref)
+        return symref;
+    // 3. git remote show origin (authoritative when origin/HEAD unset)
+    const remoteShow = tryRemoteShow(cwd, execGit);
+    if (remoteShow)
+        return remoteShow;
+    // 4. Local branch existence
+    const local = tryLocalBranch(cwd, execGit);
+    if (local)
+        return local;
+    // 5. Last-resort default
+    return 'main';
+}
+// ─── CLI entry point ──────────────────────────────────────────────────────────
+/**
+ * CLI command: `gsd-tools git base-branch`
+ * Resolves the default branch and writes it to stdout (raw string, newline-terminated).
+ * Called by workflows via `gsd_run query git.base-branch`.
+ */
+function cmdGitBaseBranch(cwd, _args, deps) {
+    const branch = resolveBaseBranch(cwd, deps);
+    const write = deps?.write ?? ((s) => process.stdout.write(s));
+    write(branch + '\n');
+    return branch;
+}

package/gsd-core/bin/lib/init.cjs

@@ -1533,7 +1533,9 @@ function buildAgentSkillsBlock(config, agentType, projectRoot) {
     // It returns [] cheaply when no roots are configured, so the realpath cost only
     // occurs when the caller has actually set trusted_global_roots.
     const trustedGlobalRoots = (0, security_cjs_1.loadTrustedGlobalRoots)(config);
-    const validPaths = [];
+    // Each entry is either a filesystem include ({ kind: 'include', ref, display }) or a
+    // Skill-tool directive ({ kind: 'directive', name }) for plugin-provided namespaced skills.
+    const validEntries = [];
     for (const skillPath of skillPaths) {
         if (typeof skillPath !== 'string')
             continue;
@@ -1543,10 +1545,25 @@ function buildAgentSkillsBlock(config, agentType, projectRoot) {
                 process.stderr.write(`[agent-skills] WARNING: "global:" prefix with empty skill name — skipping\n`);
                 continue;
             }
-            if (!/^[a-zA-Z0-9_-]+$/.test(skillName)) {
+            // Accept: one or more [A-Za-z0-9_-]+ segments joined by single colons.
+            // Rejects: empty segments (::), leading/trailing colon, dots, slashes, backslashes.
+            if (!/^[A-Za-z0-9_-]+(:[A-Za-z0-9_-]+)*$/.test(skillName)) {
                 process.stderr.write(`[agent-skills] WARNING: Invalid global skill name "${skillName}" — skipping\n`);
                 continue;
             }
+            const isNamespaced = skillName.includes(':');
+            if (isNamespaced) {
+                // Plugin-provided namespaced skill: no filesystem path exists locally.
+                if (runtime === 'claude') {
+                    // Emit a natural-language Skill-tool directive (not a @-include).
+                    validEntries.push({ kind: 'directive', name: skillName });
+                }
+                else {
+                    process.stderr.write(`[agent-skills] WARNING: Plugin-namespaced skill "global:${skillName}" requires a Skill-tool-capable runtime (claude) — skipping on runtime "${runtime}"\n`);
+                }
+                continue;
+            }
+            // Non-namespaced bare name: attempt filesystem resolution as before.
             if (globalSkillsBase === null) {
                 process.stderr.write(`[agent-skills] WARNING: Runtime "${runtime}" does not use a skills directory — "global:${skillName}" is not supported on this runtime\n`);
                 continue;
@@ -1570,7 +1587,7 @@ function buildAgentSkillsBlock(config, agentType, projectRoot) {
                 }
                 process.stderr.write(`[agent-skills] NOTE: Global skill "${skillName}" accepted via trusted_global_roots (resolves outside the default skills dir)\n`);
             }
-            validPaths.push({ ref: `${globalSkillDir}/SKILL.md`, display: displayPath });
+            validEntries.push({ kind: 'include', ref: `${globalSkillDir}/SKILL.md`, display: displayPath });
             continue;
         }
         const pathCheck = (0, security_cjs_1.validatePath)(skillPath, projectRoot);
@@ -1583,11 +1600,16 @@ function buildAgentSkillsBlock(config, agentType, projectRoot) {
             process.stderr.write(`[agent-skills] WARNING: Skill not found at "${skillPath}/SKILL.md" — skipping\n`);
             continue;
         }
-        validPaths.push({ ref: `${skillPath}/SKILL.md`, display: skillPath });
+        validEntries.push({ kind: 'include', ref: `${skillPath}/SKILL.md`, display: skillPath });
     }
-    if (validPaths.length === 0)
+    if (validEntries.length === 0)
         return '';
-    const lines = validPaths.map((p) => `- @${p.ref}`).join('\n');
+    const lines = validEntries.map((entry) => {
+        if (entry.kind === 'directive') {
+            return `- Load the \`${entry.name}\` skill via the Skill tool before proceeding (plugin-provided).`;
+        }
+        return `- @${entry.ref}`;
+    }).join('\n');
     return `<agent_skills>\nRead these user-configured skills:\n${lines}\n</agent_skills>`;
 }
 function cmdAgentSkills(cwd, agentType, raw, jsonMode) {

package/gsd-core/bin/lib/install-profiles.cjs

@@ -505,6 +505,60 @@ function stageSkillsForRuntimeAsSkills(srcCommandsDir, resolvedProfile, converte
     ensureExitCleanup();
     return stageDir;
 }
+/**
+ * Stage a converted copy of the agents directory for a given runtime.
+ *
+ * Analogous to `stageCommandsForRuntimeFlat` but for agent `.md` files. Each
+ * source `.md` is passed through `converter` and written as a flat `${name}.md`
+ * file in the staging directory. Agent filenames are kept verbatim (no prefix
+ * added here — the prefix is already embedded in agent stems, e.g. `gsd-planner.md`).
+ *
+ * This is used by the descriptor-driven `dispatchKindEntry` when an `agents` kind
+ * entry carries a non-null converter (ADR-457 / #1173). When `converter` is null,
+ * `agentsKind` falls back to the existing raw-copy path (`stageAgentsForProfile`).
+ *
+ * For the `full` profile (`skills === '*'`), all `.md` files are staged.
+ * For tiered profiles, only agents whose full stem is in `resolvedProfile.agents`
+ * are staged (mirrors `stageAgentsForProfile` behaviour).
+ *
+ * @param srcAgentsDir    source agents directory (e.g. agents/)
+ * @param resolvedProfile profile filter from resolveProfile()
+ * @param converter       (content: string) → string  pure per-file converter
+ */
+function stageAgentsForRuntimeWithConverter(srcAgentsDir, resolvedProfile, converter) {
+    if (!node_fs_1.default.existsSync(srcAgentsDir))
+        return srcAgentsDir;
+    const stageDir = node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), 'gsd-profile-runtime-agents-'));
+    try {
+        const entries = node_fs_1.default.readdirSync(srcAgentsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            if (!entry.name.endsWith('.md'))
+                continue;
+            // For tiered profiles, gate by agent stem (full filename without extension).
+            if (resolvedProfile.skills !== '*') {
+                const stem = entry.name.slice(0, -3);
+                if (!(resolvedProfile.agents instanceof Set && resolvedProfile.agents.has(stem))) {
+                    continue;
+                }
+            }
+            const content = node_fs_1.default.readFileSync(node_path_1.default.join(srcAgentsDir, entry.name), 'utf8');
+            const converted = converter(content);
+            node_fs_1.default.writeFileSync(node_path_1.default.join(stageDir, entry.name), converted, 'utf8');
+        }
+    }
+    catch (err) {
+        try {
+            node_fs_1.default.rmSync(stageDir, { recursive: true, force: true });
+        }
+        catch { /* best-effort */ }
+        throw err;
+    }
+    STAGED_DIRS.add(stageDir);
+    ensureExitCleanup();
+    return stageDir;
+}
 /**
  * Stage converted command files as flat `.md` files.
  *
@@ -723,6 +777,7 @@ module.exports = {
     mostRestrictiveProfile,
     stageSkillsForProfile,
     stageAgentsForProfile,
+    stageAgentsForRuntimeWithConverter,
     stageSkillsForRuntimeAsSkills,
     stageCommandsForRuntimeFlat,
     STAGED_DIRS,

package/gsd-core/bin/lib/installer-migration-report.cjs

@@ -38,6 +38,7 @@ exports.BUNDLED_GSD_HOOK_FILES = Object.freeze(new Set([
     'hooks/gsd-context-monitor.js',
     'hooks/gsd-cursor-post-tool.js',
     'hooks/gsd-cursor-session-start.js',
+    'hooks/gsd-ensure-canonical-path.js',
     'hooks/gsd-graphify-update.sh',
     'hooks/gsd-phase-boundary.sh',
     'hooks/gsd-prompt-guard.js',

package/gsd-core/bin/lib/phase.cjs

@@ -560,16 +560,29 @@ function cmdPhaseAdd(cwd, description, raw, customId) {
             _dirName = `${prefix}${_newPhaseId}-${slug}`;
         }
         else {
-            const phasePattern = /#{2,4}\s*Phase\s+(\d+)[A-Z]?(?:\.\d+)*:/gi;
-            let maxPhase = 0;
+            // Collect all phase numbers visible in the current-milestone content.
+            // Three sources are scanned so that a phase in ANY representation
+            // (section header, roadmap bullet, or on-disk directory) is counted:
+            // 1) Section headers: ### Phase N: / ## Phase N: / #### Phase N:
+            const headerPattern = /#{2,4}\s*Phase\s+(\d+)[A-Z]?(?:\.\d+)*:/gi;
+            // 2) Roadmap bullet entries: - [ ] **Phase N: ...** (all checkbox variants)
+            // The lookahead accepts colon, decimal-dot, whitespace, bold-close asterisk,
+            // or end-of-line so titleless forms ("- [ ] **Phase 11**", "- [ ] Phase 11")
+            // are counted and cannot collide with a freshly-added phase. (#1229)
+            const bulletPattern = /^[ \t]*-[ \t]*\[[^\]]*\][ \t]*\*{0,2}Phase[ \t]+(\d+)(?=[:.\s*]|$)/gim;
+            const usedPhaseNums = new Set();
             let m;
-            while ((m = phasePattern.exec(content)) !== null) {
+            while ((m = headerPattern.exec(content)) !== null) {
                 const num = parseInt(m[1], 10);
-                if (num === 999)
-                    continue;
-                if (num > maxPhase)
-                    maxPhase = num;
+                if (num !== 999)
+                    usedPhaseNums.add(num);
             }
+            while ((m = bulletPattern.exec(content)) !== null) {
+                const num = parseInt(m[1], 10);
+                if (num !== 999)
+                    usedPhaseNums.add(num);
+            }
+            // 3) On-disk phase directories (e.g. phases/11-foo/ with no header yet)
             const phasesOnDisk = node_path_1.default.join(planningDir(cwd), 'phases');
             if (node_fs_1.default.existsSync(phasesOnDisk)) {
                 const dirNumPattern = /^(?:[A-Z][A-Z0-9]*-)?(\d+)-/;
@@ -578,13 +591,16 @@ function cmdPhaseAdd(cwd, description, raw, customId) {
                     if (!match)
                         continue;
                     const num = parseInt(match[1], 10);
-                    if (num === 999)
-                        continue;
-                    if (num > maxPhase)
-                        maxPhase = num;
+                    if (num !== 999)
+                        usedPhaseNums.add(num);
                 }
             }
-            _newPhaseId = maxPhase + 1;
+            // phase.add appends after the highest *used* number. Collecting numbers from
+            // section headers, roadmap bullets, AND on-disk dirs above is what prevents the
+            // #1229 collision (a bullet-only Phase N is now counted), so max+1 cannot reuse
+            // an existing number.
+            const maxUsed = usedPhaseNums.size > 0 ? Math.max(...usedPhaseNums) : 0;
+            _newPhaseId = maxUsed + 1;
             const paddedNum = String(_newPhaseId).padStart(2, '0');
             _dirName = `${prefix}${paddedNum}-${slug}`;
         }

package/gsd-core/bin/lib/plan-drift-guard.cjs

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * ADR-22 Drift-Guard Decision Module
+ *
+ * Implements the authority ladder and severity classification table from
+ * ADR-22 (docs/adr/0022-source-grounding-drift-guard.md).
+ *
+ * Design constraints:
+ *   - Pure module: no I/O, no require() calls, no side effects.
+ *   - All inputs are validated; unknown values throw a TypeError.
+ *   - Consumed by the `gsd-tools drift-guard` CLI seam and by tests.
+ *
+ * Authority ladder (rung values determine MISSING severity):
+ *   grep=0  intel=1  treesitter=2  lsp=3  scip=4
+ *
+ * Hard-block threshold: rung >= 3 (lsp, scip) — these adapters can prove
+ * absence, so MISSING is a definite error (severity HIGH, hardBlock true).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUTHORITY_RUNGS = void 0;
+exports.getEffectiveAuthority = getEffectiveAuthority;
+exports.classifyDriftSeverity = classifyDriftSeverity;
+/**
+ * Frozen map from authority name to its rung number.
+ *
+ * Rung determines whether a MISSING symbol triggers a hard block:
+ * rung >= 3 (lsp, scip) → hard block; rung < 3 → acknowledgement only.
+ */
+exports.AUTHORITY_RUNGS = Object.freeze({
+    grep: 0,
+    intel: 1,
+    treesitter: 2,
+    lsp: 3,
+    scip: 4,
+});
+/** Rung at which MISSING transitions to hard-block (inclusive). */
+const HARD_BLOCK_RUNG_THRESHOLD = 3;
+const VALID_AUTHORITIES = new Set(Object.keys(exports.AUTHORITY_RUNGS));
+const VALID_STATUSES = new Set(['VERIFIED', 'MISSING', 'AMBIGUOUS', 'UNCHECKABLE']);
+/**
+ * Validate and return an authority value, normalising undefined to 'grep'.
+ *
+ * Throws TypeError for any non-null unknown string value so callers surface
+ * configuration errors at call time rather than silently defaulting.
+ *
+ * @param value - raw authority string from config or CLI arg
+ * @returns a validated Authority value
+ */
+function validateAuthority(value) {
+    if (value === undefined || value === null || value === '') {
+        return 'grep';
+    }
+    if (!VALID_AUTHORITIES.has(value)) {
+        throw new TypeError(`Unknown authority: ${JSON.stringify(value)}. ` +
+            `Valid values: ${[...VALID_AUTHORITIES].join(', ')}`);
+    }
+    return value;
+}
+/**
+ * Return the effective authority after applying the ADR-22 auto-upgrade rule.
+ *
+ * Auto-upgrade rule: if the configured authority is 'grep' AND intel is
+ * enabled (`intelEnabled === true`), upgrade to 'intel'. All other authority
+ * values are returned unchanged regardless of intelEnabled.
+ *
+ * @param authority   - configured authority (undefined → 'grep')
+ * @param intelEnabled - whether the intel capability is active in this project
+ * @returns the effective Authority after upgrade
+ * @throws TypeError if authority is not one of the five valid values
+ */
+function getEffectiveAuthority(authority, intelEnabled) {
+    const validated = validateAuthority(authority);
+    if (validated === 'grep' && intelEnabled === true) {
+        return 'intel';
+    }
+    return validated;
+}
+/**
+ * Classify a symbol verification result into a drift severity and hard-block flag.
+ *
+ * ADR-22 decision table:
+ *
+ * | Status       | Authority rung | severity               | hardBlock |
+ * |------------- |--------------- |----------------------- |---------- |
+ * | VERIFIED     | any            | 'none'                 | false     |
+ * | MISSING      | rung >= 3      | 'HIGH'                 | true      |
+ * | MISSING      | rung 0-2       | 'needs-acknowledgement'| false     |
+ * | AMBIGUOUS    | any            | 'MEDIUM'               | false     |
+ * | UNCHECKABLE  | any            | 'INFO'                 | false     |
+ *
+ * @param opts.status    - verdict from the source-grounding adapter
+ * @param opts.authority - the effective authority adapter used
+ * @returns { severity, hardBlock }
+ * @throws TypeError for unknown status or authority values
+ */
+function classifyDriftSeverity({ status, authority, }) {
+    if (!VALID_STATUSES.has(status)) {
+        throw new TypeError(`Unknown status: ${JSON.stringify(status)}. ` +
+            `Valid values: ${[...VALID_STATUSES].join(', ')}`);
+    }
+    // authority validation (also catches unknown values)
+    const validatedAuthority = validateAuthority(authority);
+    const rung = exports.AUTHORITY_RUNGS[validatedAuthority];
+    switch (status) {
+        case 'VERIFIED':
+            return { severity: 'none', hardBlock: false };
+        case 'MISSING':
+            if (rung >= HARD_BLOCK_RUNG_THRESHOLD) {
+                return { severity: 'HIGH', hardBlock: true };
+            }
+            return { severity: 'needs-acknowledgement', hardBlock: false };
+        case 'AMBIGUOUS':
+            return { severity: 'MEDIUM', hardBlock: false };
+        case 'UNCHECKABLE':
+            return { severity: 'INFO', hardBlock: false };
+    }
+}

package/gsd-core/bin/lib/probe-core.cjs

@@ -30,10 +30,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VALID_STATUS = void 0;
+exports.PROHIBITION_VALIDATORS = exports.VALID_STATUS = void 0;
 exports.validateRequirement = validateRequirement;
 exports.validateResolution = validateResolution;
 exports.analyzeCoverage = analyzeCoverage;
+exports.validateProhibitionResolution = validateProhibitionResolution;
+exports.projectProhibitions = projectProhibitions;
+exports.dispositionForProhibition = dispositionForProhibition;
 exports.runProbeCli = runProbeCli;
 const node_fs_1 = __importDefault(require("node:fs"));
 /** The LOCKED set of valid lifecycle statuses (the re-cut: no covered/backstop). */
@@ -203,6 +206,119 @@ function analyzeCoverage(items, resolutions = [], validators) {
     }
     return { items: merged, coverage: { applicable, resolved, unresolved, byVerification } };
 }
+/**
+ * The prohibition adapter's injected runtime validators (ADR-550 #5). There is no closed
+ * category taxonomy (recall is open-vocabulary values/safety/ethics prose), so `categories`
+ * is intentionally empty — `analyzeCoverage` is not the prohibition entry point and the
+ * round-trip schema layer does not gate on category. The verification tiers are
+ * `test | judgment` (ADR-550 D7a); both require only a present `resolution`/`reason` per their
+ * lifecycle (a resolved prohibition's checkable content is the `statement`, validated by the
+ * schema layer, not a `resolution` string), so `requiredFieldsByVerification` is the minimal
+ * fail-closed set: a dismissed item still needs its reason (enforced by `validateResolution`).
+ */
+exports.PROHIBITION_VALIDATORS = {
+    categories: [],
+    verification: ['test', 'judgment'],
+    // A resolved prohibition's checkable content is the `statement` (schema-layer validated), NOT a
+    // `resolution` string — the canonical fixtures and the reference doc's worked examples all carry
+    // `resolution: null`. So the per-tier required set is empty: `resolved` still requires a present
+    // verification tier (enforced in validateResolution) and `dismissed` still requires a reason
+    // (enforced unconditionally), but neither tier requires a `resolution`. This matches the corpus
+    // the docs-fixtures parity test pins; the validators.test.cjs regression keeps them aligned.
+    requiredFieldsByVerification: { test: [], judgment: [] },
+};
+/** Validate a prohibition resolution against the prohibition verification vocabulary. */
+function validateProhibitionResolution(resolution) {
+    return validateResolution(resolution, exports.PROHIBITION_VALIDATORS);
+}
+/**
+ * Deterministically project resolved prohibition items into the `must_haves.prohibitions:`
+ * list shape (the SPEC<->plan projection; ADR-550 Decision 5c). This is a FUNCTION the parity
+ * assertion round-trips, never a prompt: the same input always yields the same output, and the
+ * output is the exact re-readable block shape `parseMustHavesBlock(content, 'prohibitions')`
+ * returns — `{ statement, status, verification }` plus `reason` only when present (a dismissed
+ * item's audit trail). `resolution`/`requirement_id`/`category` are recall-stage bookkeeping
+ * and are intentionally NOT projected into the plan block (which is keyed on the must-NOT
+ * statement, not the source requirement). A non-array input projects to `[]` (fail-soft on the
+ * empty/zero-prohibition case), never a throw.
+ */
+function projectProhibitions(items) {
+    if (!Array.isArray(items))
+        return [];
+    const out = [];
+    for (const item of items) {
+        if (item == null || typeof item !== 'object')
+            continue;
+        const p = item;
+        const statement = typeof p.statement === 'string' ? p.statement : '';
+        const entry = {
+            statement,
+            status: typeof p.status === 'string' ? p.status : 'unresolved',
+        };
+        if (p.verification != null)
+            entry.verification = String(p.verification);
+        if (p.reason != null && String(p.reason).trim())
+            entry.reason = String(p.reason);
+        out.push(entry);
+    }
+    return out;
+}
+/**
+ * Deterministic verify-time disposition for a single prohibition — the FAIL-CLOSED default
+ * (ADR-550 Decision 5d, the safety half of the 2026-06-12 "B-with-guard" maintainer decision).
+ *
+ * This is the cheap safety guarantee: a well-formed prohibition that reaches verify-phase with NO
+ * wired enforcement evidence can NEVER be a silent pass. It is `{ status: 'unverified', flagged:
+ * true }` — never `green` — exactly like an unresolved judgment item. The HEAVY half (a real
+ * fail-first negative-test enforcement mechanism that, given evidence, would flip a test-tier item
+ * to green) is OUT of #644 scope and defers to a follow-up PR: #644's corpus is entirely
+ * judgment-tier, so wiring a contrived test-tier consumer here would be the delete-bad-tests /
+ * gold-plating failure mode. Until that follow-up lands, ANY prohibition without enforcement
+ * evidence — test- or judgment-tier — disposes as flagged-unverified.
+ *
+ * The function is pure: same input always yields the same disposition (no LLM judgment, ADR-550
+ * D5). The LLM-judge soft-gate for judgment-tier items is a verify-phase PROSE concern (the
+ * verifier records a non-authoritative verdict + the unverified-prohibition flag); this helper
+ * only owns the deterministic fail-closed default that the plan-01-01 CI safety assertion pins.
+ */
+function dispositionForProhibition(prohibition, context = {}) {
+    const p = (prohibition ?? {});
+    const tier = p.verification === 'test' || p.verification === 'judgment' ? p.verification : null;
+    const evidence = Array.isArray(context.enforcementEvidence) ? context.enforcementEvidence : [];
+    const hasEnforcement = evidence.length > 0;
+    // FAIL CLOSED: no wired enforcement evidence -> flagged unverified, never green. This holds for
+    // every tier today (the real enforcement mechanism that could flip a test-tier item to green is
+    // deferred to a follow-up PR). The guard the safety assertion proves: an unwired item can never
+    // be silently skipped.
+    if (!hasEnforcement) {
+        return {
+            status: 'unverified',
+            flagged: true,
+            tier,
+            reason: tier === 'test'
+                ? 'test-tier prohibition has no wired enforcement evidence — flagged unverified (fail-closed; real negative-test enforcement deferred to a follow-up PR, ADR-550 D5d)'
+                : 'prohibition has no enforcement evidence — flagged unverified (fail-closed; never a silent pass, ADR-550 D5d)',
+        };
+    }
+    // D4 GUARD: a judgment-tier (or unknown-tier) prohibition is NEVER a silent green from this
+    // deterministic helper — it always routes to human/LLM judgment review (ADR-550 D4; verify-phase.md).
+    // Only a test-tier item with wired enforcement evidence may go green, and even that is the deferred
+    // heavy half until the real negative-test enforcement mechanism lands (no #644 caller passes evidence).
+    if (tier === 'test') {
+        return {
+            status: 'green',
+            flagged: false,
+            tier,
+            reason: 'test-tier prohibition has wired enforcement evidence',
+        };
+    }
+    return {
+        status: 'unverified',
+        flagged: true,
+        tier,
+        reason: 'judgment-tier prohibition routes to judgment review — never a silent green (ADR-550 D4)',
+    };
+}
 /**
  * Read the requirements file (and optional resolutions file), run the adapter's `analyze`,
  * and write the report as pretty JSON + newline. With no requirements path, writes the usage