@opengsd/gsd-core 1.20.0 → 1.21.0

package/gsd-core/bin/lib/install-manifest-record.cjs

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * Install manifest per-file hash ownership (#5683).
+ *
+ * `gsd-file-manifest.json` records `sha256(file bytes)` per installed file,
+ * keyed by path relative to the runtime config dir. `effort sync --apply`
+ * rewrites installed agents, so it re-records exactly those files here.
+ * `bin/install.js` fileHash delegates to this module: one hash function.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileHash = fileHash;
+exports.tryFileHash = tryFileHash;
+exports.recordManifestFileHashes = recordManifestFileHashes;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_crypto_1 = require("node:crypto");
+const shell_command_projection_cjs_1 = require("./shell-command-projection.cjs");
+const MANIFEST_NAME = 'gsd-file-manifest.json';
+/** SHA256 (lowercase hex) of a file's bytes — the manifest's per-file hash. */
+function fileHash(filePath) {
+    return (0, node_crypto_1.createHash)('sha256').update((0, node_fs_1.readFileSync)(filePath)).digest('hex');
+}
+/** fileHash that returns null instead of throwing — for capturing a pre-rewrite hash. */
+function tryFileHash(filePath) {
+    try {
+        return fileHash(filePath);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Update ONLY the manifest entries for `rewritten` files (under `configDir`),
+ * and only those that were GSD-owned before the rewrite: `preHash` equal to the
+ * recorded manifest entry. A file the user had already edited keeps its stale
+ * entry so the next install still detects it and backs it up.
+ * Skips silently (returns false) when the manifest is absent, unparseable or
+ * not the documented shape; publishes via tmp + rename.
+ */
+function recordManifestFileHashes(configDir, rewritten) {
+    if (rewritten.length === 0)
+        return false;
+    const manifestPath = (0, node_path_1.join)(configDir, MANIFEST_NAME);
+    let manifest;
+    try {
+        const parsed = JSON.parse((0, node_fs_1.readFileSync)(manifestPath, 'utf8'));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return false;
+        manifest = parsed;
+    }
+    catch {
+        return false;
+    }
+    const files = manifest['files'];
+    if (!files || typeof files !== 'object' || Array.isArray(files))
+        return false;
+    const entries = files;
+    let changed = false;
+    for (const { path: absPath, preHash } of rewritten) {
+        const rel = (0, node_path_1.relative)(configDir, absPath).replace(/\\/g, '/');
+        if (rel === '' || rel.startsWith('..') || (0, node_path_1.isAbsolute)(rel))
+            continue;
+        if (preHash === null || entries[rel] !== preHash)
+            continue;
+        try {
+            entries[rel] = fileHash(absPath);
+            changed = true;
+        }
+        catch { /* unreadable file: leave its entry as recorded */ }
+    }
+    if (!changed)
+        return false;
+    const tmpPath = `${manifestPath}.tmp.${process.pid}`;
+    try {
+        (0, node_fs_1.writeFileSync)(tmpPath, JSON.stringify(manifest, null, 2));
+        (0, shell_command_projection_cjs_1.retryRenameSync)(tmpPath, manifestPath);
+        return true;
+    }
+    catch {
+        try {
+            (0, node_fs_1.unlinkSync)(tmpPath);
+        }
+        catch { /* already gone or never created */ }
+        return false;
+    }
+}

package/gsd-core/bin/lib/install-model-override-resolver.cjs

@@ -35,9 +35,33 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 const node_path_1 = __importDefault(require("node:path"));
 const node_os_1 = __importDefault(require("node:os"));
 const runtime_homes_cjs_1 = require("./runtime-homes.cjs");
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- config-file-read.cjs is an export= CommonJS module
+const configFileReadMod = require("./config-file-read.cjs");
+const { unboundedConfigFileReason, printablePath, readConfigFileBounded } = configFileReadMod;
+/**
+ * Text of an install-time config file, or null (with a printable-path warning) when it is not a
+ * regular file within the cap or cannot be read. The real fs uses the descriptor-bound reader;
+ * an injected adapter gets the stat guard before its own read (#5759).
+ */
+function readInstallConfigText(absPath, label) {
+    try {
+        if (isRealInstallFs())
+            return readConfigFileBounded(absPath);
+        const unbounded = unboundedConfigFileReason(absPath);
+        if (unbounded !== null) {
+            process.stderr.write(`gsd: warning — could not read ${label} (${printablePath(absPath)}): ${unbounded}\n`);
+            return null;
+        }
+        return installFs().readFileSync(absPath, 'utf-8');
+    }
+    catch (err) {
+        process.stderr.write(`gsd: warning — could not read ${label} (${printablePath(absPath)}): ${printablePath(err.message)}\n`);
+        return null;
+    }
+}
 // eslint-disable-next-line @typescript-eslint/no-require-imports -- install-fs-adapter.cjs is an export= CommonJS module
 const installFsAdapter = require("./install-fs-adapter.cjs");
-const { installFs } = installFsAdapter;
+const { installFs, isRealInstallFs } = installFsAdapter;
 // eslint-disable-next-line @typescript-eslint/no-require-imports -- install-effort-resolver.cjs is an export= CommonJS module
 const installEffortResolver = require("./install-effort-resolver.cjs");
 const { _readGsdConfigFile, _findAncestorGsdConfigPath } = installEffortResolver;
@@ -62,7 +86,9 @@ function readGsdGlobalModelOverrides(options = {}) {
         const defaultsPath = node_path_1.default.join(home, '.gsd', 'defaults.json');
         if (!installFs().existsSync(defaultsPath))
             return null;
-        const raw = installFs().readFileSync(defaultsPath, 'utf-8');
+        const raw = readInstallConfigText(defaultsPath, 'global defaults'); // #5759: never block on a planted FIFO
+        if (raw === null)
+            return null;
         const parsed = JSON.parse(raw);
         const overrides = parsed.model_overrides;
         if (!overrides || typeof overrides !== 'object')
@@ -99,7 +125,11 @@ function readGsdEffectiveModelOverrides(targetDir = null, options = {}) {
         const candidate = _findAncestorGsdConfigPath(targetDir);
         if (candidate) {
             try {
-                const parsed = JSON.parse(installFs().readFileSync(candidate, 'utf-8'));
+                // #5759: refuse a FIFO/device/oversized project config before the adapter's blocking read.
+                const text = readInstallConfigText(candidate, 'project config');
+                if (text === null)
+                    throw new Error('unusable project config');
+                const parsed = JSON.parse(text);
                 if (parsed && typeof parsed === 'object' && parsed.model_overrides && typeof parsed.model_overrides === 'object') {
                     projectOverrides = parsed.model_overrides;
                 }

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

@@ -35,7 +35,7 @@ const external_descriptor_trust_cjs_1 = require("./external-descriptor-trust.cjs
 const capabilityLedger = require("./capability-ledger.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const conversionModule = require("./runtime-artifact-conversion.cjs");
-const { applyAgentPathRewrites: _applyAgentPathRewrites, processAttribution: _processAttribution, normalizeAgentBodyForRuntime: _normalizeAgentBodyForRuntime, readGsdCommandNames: _readGsdCommandNames, deriveAgentName: _deriveAgentName, applyAgentFrontmatterExtensions: _applyAgentFrontmatterExtensions, appendAgentTools: _appendAgentTools, } = conversionModule;
+const { applyAgentPathRewrites: _applyAgentPathRewrites, processAttribution: _processAttribution, normalizeAgentBodyForRuntime: _normalizeAgentBodyForRuntime, readGsdCommandNames: _readGsdCommandNames, deriveAgentName: _deriveAgentName, applyAgentFrontmatterExtensions: _applyAgentFrontmatterExtensions, appendAgentTools: _appendAgentTools, _shieldAgentConverterPrefix, } = conversionModule;
 // #2995 (epic #1671 Phase 6.4): agent bodies join the fragment model. Markers are
 // stripped at emit BEFORE any path rewrite or converter runs, so a `.claude/` ->
 // `.windsurf/` regex can never reach inside a marker attribute and corrupt it —
@@ -1011,7 +1011,9 @@ function stageAgentsForRuntimeWithConverter(srcAgentsDir, resolvedProfile, conve
                 // Step 3: validated canonical grants, before host conversion.
                 content = _appendAgentTools(content, grants);
                 // Step 4: converter (runtime-specific frontmatter/body transform)
-                content = converter(content, isGlobal, { agentName });
+                // #5715: the converter runs after the prefix pass above; shield the emitted prefix
+                // from it, except where the runtime declares no path rewrite (nothing was emitted).
+                content = _shieldAgentConverterPrefix(content, agentCtx.runtime, agentCtx.pathPrefix, (shielded) => converter(shielded, isGlobal, { agentName, pathPrefix: agentCtx.pathPrefix }));
                 // Step 5: frontmatter extensions (effort/disallowedTools; no-op unless
                 // the runtime declares hostBehaviors.agentFrontmatterExtensions)
                 content = _applyAgentFrontmatterExtensions(content, { runtime: agentCtx.runtime, agentName, targetDir: agentCtx.targetDir });

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

@@ -364,6 +364,10 @@ const ERROR_REASON = Object.freeze({
     COMMIT_DOCS_GUARD_NOT_A_REPO: 'commit_docs_guard_not_a_repo',
     COMMIT_DOCS_GUARD_FOREIGN_HOOK: 'commit_docs_guard_foreign_hook',
     COMMIT_DOCS_GUARD_HOOKS_PATH_SET: 'commit_docs_guard_hooks_path_set',
+    // commit verb (#6043, ADR-4908 §3): it commits in the worktree the process
+    // runs in, or refuses with one of these. Wire values are the typed `reason`.
+    COMMIT_NOT_GIT_REPO: 'not_git_repo',
+    COMMIT_OUTSIDE_WORKTREE: 'outside_worktree',
     // security-scan
     SECURITY_SCAN_FAILED: 'security_scan_failed',
     // --pick (#3365 / #3358, ADR-3473 §8.4): an absent field or non-JSON
@@ -499,6 +503,8 @@ const REASON_TO_OUTCOME = Object.freeze({
     [ERROR_REASON.COMMIT_DOCS_GUARD_NOT_A_REPO]: 'UNAVAILABLE',
     [ERROR_REASON.COMMIT_DOCS_GUARD_FOREIGN_HOOK]: 'UNAVAILABLE',
     [ERROR_REASON.COMMIT_DOCS_GUARD_HOOKS_PATH_SET]: 'UNAVAILABLE',
+    [ERROR_REASON.COMMIT_NOT_GIT_REPO]: 'UNAVAILABLE',
+    [ERROR_REASON.COMMIT_OUTSIDE_WORKTREE]: 'FAIL',
     // Its own docstring: "an absent field or non-JSON command output is a
     // failure, never a demotion to an empty answer" — the field/output was
     // supposed to be there and was not; a prerequisite of the query failed.

package/gsd-core/bin/lib/markdown-sectionizer.cjs

@@ -12,6 +12,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.XML_DECISION_TAG_NAMES = void 0;
+exports.matchFenceDelimiter = matchFenceDelimiter;
 exports.stripFencedCode = stripFencedCode;
 exports.stripInlineCode = stripInlineCode;
 exports.scanInlineCodeSpans = scanInlineCodeSpans;
@@ -24,6 +25,7 @@ exports.iterateBullets = iterateBullets;
 exports.updateBullet = updateBullet;
 exports.updateHeading = updateHeading;
 exports.extractTaggedBlocks = extractTaggedBlocks;
+exports.extractTaggedBlockSpans = extractTaggedBlockSpans;
 exports.stripTaggedBlocks = stripTaggedBlocks;
 exports.editOutsideTaggedBlocks = editOutsideTaggedBlocks;
 exports.maskFences = maskFences;
@@ -35,6 +37,30 @@ exports.editHeadingSlice = editHeadingSlice;
 exports.deleteSection = deleteSection;
 exports.extractXmlTagBodies = extractXmlTagBodies;
 const pattern_cjs_1 = require("./pattern.cjs");
+const FENCE_DELIMITER_RE = /^( {0,3})(`{3,}|~{3,})(.*)$/;
+/**
+ * The single CommonMark fence-delimiter grammar: ≤3 spaces of indent, a run of
+ * ≥3 backticks or tildes, then trailing text. A trailing `\r` is stripped first
+ * (CRLF safety). Returns `null` when the line is not a delimiter line at all.
+ * `stripFencedCode`, `scanFencedBlocks`, `tokenizeHeadings` and the roadmap
+ * parser's comment/fence blanking all classify delimiter lines through this one
+ * matcher.
+ */
+function matchFenceDelimiter(line) {
+    const m = FENCE_DELIMITER_RE.exec(line.replace(/\r$/, ''));
+    if (m === null)
+        return null;
+    const char = m[2][0];
+    const len = m[2].length;
+    const trailing = m[3];
+    return {
+        char,
+        len,
+        trailing,
+        canOpen: !(char === '`' && trailing.includes('`')),
+        closes: (opener) => char === opener.char && len >= opener.len && /^\s*$/.test(trailing),
+    };
+}
 // ─── stripFencedCode ──────────────────────────────────────────────────────────
 /**
  * CommonMark-correct fenced-code-block stripper.
@@ -62,27 +88,20 @@ function stripFencedCode(content) {
     const lines = content.split('\n');
     const kept = [];
     let openFence = null;
-    // Matches: optional indent (≤3 spaces per CommonMark), fence run, optional info string
-    const delimRe = /^( {0,3})(`{3,}|~{3,})(.*)$/;
     for (const rawLine of lines) {
-        // Strip trailing \r for delimiter matching (CRLF safety)
-        const line = rawLine.replace(/\r$/, '');
-        const m = delimRe.exec(line);
+        const m = matchFenceDelimiter(rawLine);
         if (m) {
-            const char = m[2][0];
-            const len = m[2].length;
-            const trailing = m[3];
             if (openFence === null) {
                 // CommonMark §4.5: backtick fence info string must not contain a backtick.
                 // If it does, this line is NOT a valid fence opener (treat as ordinary content).
-                if (char === '`' && trailing.includes('`')) {
+                if (!m.canOpen) {
                     kept.push(rawLine);
                     continue;
                 }
                 // Opening delimiter — record fence state, drop this line
-                openFence = { char, len };
+                openFence = { char: m.char, len: m.len };
             }
-            else if (char === openFence.char && len >= openFence.len && /^\s*$/.test(trailing)) {
+            else if (m.closes(openFence)) {
                 // Closing delimiter (same char, sufficient length, no trailing content) — close and drop
                 openFence = null;
             }
@@ -213,9 +232,8 @@ function stripInlineCodeLine(line) {
  * different-info-string fence, a fence nested/indented inside another fence,
  * and a `~~~` fence are all classified exactly as `stripFencedCode` would.
  *
- * Tracked duplication (same status as `tokenizeHeadings`'s copy, see its
- * comment above): this is a second independent copy of the fence state
- * machine, pending a T-tier consolidation.
+ * Delimiter classification goes through `matchFenceDelimiter`, the one shared
+ * grammar (also used by `stripFencedCode` and `tokenizeHeadings`).
  *
  * Exported so `context-predicates.cts` can consume this seam directly for its
  * line-preserving fenced-line skip detection, instead of carrying a third
@@ -223,24 +241,19 @@ function stripInlineCodeLine(line) {
  * comment).
  */
 function scanFencedBlocks(lines) {
-    const delimRe = /^( {0,3})(`{3,}|~{3,})(.*)$/;
     const blocks = [];
     let open = null;
     for (let i = 0; i < lines.length; i++) {
-        const line = lines[i].replace(/\r$/, '');
-        const m = delimRe.exec(line);
+        const m = matchFenceDelimiter(lines[i]);
         if (!m)
             continue;
-        const char = m[2][0];
-        const len = m[2].length;
-        const trailing = m[3];
         if (open === null) {
             // CommonMark §4.5: backtick fence info string must not contain a backtick.
-            if (char === '`' && trailing.includes('`'))
+            if (!m.canOpen)
                 continue; // not a valid opener — ordinary content
-            open = { char, len, infoString: trailing.trim(), openLineIdx: i };
+            open = { char: m.char, len: m.len, infoString: m.trailing.trim(), openLineIdx: i };
         }
-        else if (char === open.char && len >= open.len && /^\s*$/.test(trailing)) {
+        else if (m.closes(open)) {
             blocks.push({
                 char: open.char,
                 len: open.len,
@@ -319,30 +332,26 @@ function tokenizeHeadings(content) {
     const tokens = [];
     // We re-run the fence state machine to know which lines are "kept", so we
     // can map line index in original to whether it survived.
-    const delimRe = /^( {0,3})(`{3,}|~{3,})(.*)$/;
     let openFence = null;
     // Accumulate character offset as we iterate lines
     let charOffset = 0;
     for (let i = 0; i < originalLines.length; i++) {
         const rawLine = originalLines[i];
         const line = rawLine.replace(/\r$/, '');
-        const dm = delimRe.exec(line);
+        const dm = matchFenceDelimiter(rawLine);
         if (dm) {
-            const char = dm[2][0];
-            const len = dm[2].length;
-            const trailing = dm[3];
             if (openFence === null) {
                 // CommonMark §4.5: backtick fence info string must not contain a backtick.
-                if (char === '`' && trailing.includes('`')) {
+                if (!dm.canOpen) {
                     // Not a valid fence opener — check for heading on this line (will fall through)
                 }
                 else {
-                    openFence = { char, len };
+                    openFence = { char: dm.char, len: dm.len };
                     charOffset += rawLine.length + 1;
                     continue;
                 }
             }
-            else if (char === openFence.char && len >= openFence.len && /^\s*$/.test(trailing)) {
+            else if (dm.closes(openFence)) {
                 openFence = null;
                 charOffset += rawLine.length + 1;
                 continue;
@@ -818,6 +827,28 @@ function extractTaggedBlocks(content, tagName, allowAttributes = false) {
     }
     return results;
 }
+/**
+ * Offset spans of the bodies `extractTaggedBlocks` returns (#4309): same
+ * pattern, same blocks, but each body is reported as `{ start, end }` into
+ * `content` so a caller can test whether an arbitrary offset lies inside a
+ * block (and dedupe nested blocks) without re-harvesting the text.
+ * `content.slice(span.start, span.end)` equals the matching extracted body.
+ */
+function extractTaggedBlockSpans(content, tagName, allowAttributes = false) {
+    if (typeof content !== 'string' || content.length === 0)
+        return [];
+    if (typeof tagName !== 'string' || tagName.length === 0)
+        return [];
+    const closeLength = `</${tagName}>`.length;
+    const pattern = taggedBlockPattern(tagName, 'g', allowAttributes);
+    const spans = [];
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+        const end = match.index + match[0].length - closeLength;
+        spans.push({ start: end - match[1].length, end });
+    }
+    return spans;
+}
 /**
  * Build the single, ReDoS-safe `<tag>…</tag>` block regex shared by
  * `extractTaggedBlocks` (extract bodies) and `stripTaggedBlocks` (remove blocks).

package/gsd-core/bin/lib/markdown-table.cjs

@@ -26,6 +26,7 @@ exports.appendQuickTaskRow = appendQuickTaskRow;
 exports.migrateQuickTasksTable = migrateQuickTasksTable;
 exports.resetQuickTaskRows = resetQuickTaskRows;
 exports.updateTraceabilityCell = updateTraceabilityCell;
+exports.traceabilityRowExists = traceabilityRowExists;
 const markdown_sectionizer_cjs_1 = require("./markdown-sectionizer.cjs");
 // ─── Schema registry ──────────────────────────────────────────────────────────
 /**
@@ -979,6 +980,8 @@ function resetQuickTaskRows(stateContent) {
     const content = (0, markdown_sectionizer_cjs_1.replaceSection)(stateContent, section, newBody);
     return { ok: true, value: { content, cleared, variant: match.label } };
 }
+/** The one Traceability heading rule shared by the write and the existence read. */
+const TRACEABILITY_HEADING_RE = /^Traceability(?:[ \t]+Status)?\b/i;
 /**
  * `updateTableCell` scoped to REQUIREMENTS.md's `## Traceability` (or
  * `## Traceability Status`) section (#2245 F1, #5762): `updateTableCell` binds
@@ -991,7 +994,7 @@ function resetQuickTaskRows(stateContent) {
  */
 function updateTraceabilityCell(text, match, column, newValue) {
     const headings = (0, markdown_sectionizer_cjs_1.tokenizeHeadings)(text);
-    const index = headings.findIndex((h) => h.level === 2 && /^Traceability(?:[ \t]+Status)?\b/i.test(h.text));
+    const index = headings.findIndex((h) => h.level === 2 && TRACEABILITY_HEADING_RE.test(h.text));
     if (index === -1)
         return updateTableCell(text, match, column, newValue);
     let result = { ok: false, reason: 'no matching row' };
@@ -1001,5 +1004,40 @@ function updateTraceabilityCell(text, match, column, newValue) {
     });
     return result.ok ? { ok: true, value: edited } : result;
 }
+/**
+ * Row-existence READ for REQUIREMENTS.md's Traceability section (#5844): true
+ * when any table row in the section has `id` (case-insensitive) as its first
+ * cell, whatever the table's columns. `updateTraceabilityCell(..., 'Status', …)`
+ * answers "is there a row" only for tables that HAVE a Status column; this
+ * answers it for every table. Scoping mirrors `updateTraceabilityCell`: the
+ * same heading rule, and only the FIRST table of the scoped text (with no
+ * Traceability heading that is the first table in the file), so a table
+ * elsewhere whose first cell equals the ID is not a Traceability row.
+ */
+function traceabilityRowExists(text, id) {
+    const headings = (0, markdown_sectionizer_cjs_1.tokenizeHeadings)(text);
+    const index = headings.findIndex((h) => h.level === 2 && TRACEABILITY_HEADING_RE.test(h.text));
+    let scoped = text;
+    if (index !== -1) {
+        (0, markdown_sectionizer_cjs_1.editHeadingSlice)(text, (0, markdown_sectionizer_cjs_1.headingSliceRange)(text, headings, index, 2), (slice) => {
+            scoped = slice;
+            return slice;
+        });
+    }
+    const wanted = id.trim().toLowerCase();
+    let inTable = false;
+    for (const line of scoped.split(/\r?\n/)) {
+        if (!line.trim().startsWith('|')) {
+            if (inTable)
+                return false;
+            continue;
+        }
+        inTable = true;
+        const cells = splitTableRow(line);
+        if (cells.length > 0 && cells[0].trim().toLowerCase() === wanted)
+            return true;
+    }
+    return false;
+}
 // Consumers: require('../gsd-core/bin/lib/markdown-table.cjs')
 // Named CJS exports are the canonical surface (ADR-457 .cts → .cjs build-at-publish).

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

@@ -43,7 +43,7 @@ const pattern_cjs_1 = require("./pattern.cjs");
 const milestone_release_map_cjs_1 = require("./milestone-release-map.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const roadmapParserMod = require("./roadmap-parser.cjs");
-const { getMilestonePhaseFilter, extractCurrentMilestone, getMilestoneInfo, sliceMilestoneWindow, } = roadmapParserMod;
+const { getMilestonePhaseFilter, extractCurrentMilestone, getMilestoneInfo, sliceMilestoneWindow, classifyMilestoneScalar, readStateMilestoneScalar, sameMilestoneVersion, } = roadmapParserMod;
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const planningScopeMod = require("./planning-scope.cjs");
 const { SCOPE } = planningScopeMod;
@@ -225,7 +225,9 @@ function cmdRequirementsMarkComplete(cwd, reqIdsRaw, raw) {
         // Surface traceability drift: checkbox reconciled (this run or before) but the
         // table has no row for this ID. This is what makes a partial reconcile
         // distinguishable from a full one (#2140).
-        if (hasTable && doneCheckbox && !hasRow) {
+        // #5844: a row in a table with no Status column is still a row; only the
+        // Status write is impossible there, so existence is read directly.
+        if (hasTable && doneCheckbox && !hasRow && !(0, markdown_table_cjs_1.traceabilityRowExists)(reqContent, reqId)) {
             tableUnmatched.push(reqId);
         }
     }
@@ -603,15 +605,15 @@ function cmdMilestoneComplete(cwd, version, options, raw) {
             try {
                 const stateRaw = node_fs_1.default.existsSync(statePath) ? node_fs_1.default.readFileSync(statePath, 'utf-8') : null;
                 if (stateRaw) {
-                    const milestoneMatch = stateRaw.match(/^milestone:\s*(.+)/m);
-                    if (milestoneMatch)
-                        stateVersion = milestoneMatch[1].trim();
+                    // One owner for the STATE `milestone:` scalar (#5726): quoted, null and
+                    // empty values and a body `milestone:` line are not drift.
+                    stateVersion = classifyMilestoneScalar(readStateMilestoneScalar(stateRaw)).version;
                 }
             }
             catch {
                 /* skip — stateVersion stays null, scan still runs */
             }
-            if (stateVersion !== null && stateVersion !== version) {
+            if (stateVersion !== null && !sameMilestoneVersion(stateVersion, version)) {
                 // #2946: emit a WARNING so the suspicious STATE mismatch is visible
                 // rather than silently disarming the guard. Plain-text diagnostic on
                 // stderr, matching the existing [gsd-tools] WARNING convention

package/gsd-core/bin/lib/model-resolver.cjs

@@ -11,7 +11,7 @@
  * epic #1267; callers import resolvers from model-resolver.cjs directly.
  *
  * Dependencies (leaf modules only):
- *   - node:fs / node:path (read the per-install .gsd-runtime marker + project config for the #2297 omit gate)
+ *   - node:path (project config path for the #2297 omit gate; read via config-loader's bounded reader, #5759)
  *   - ./runtime-name-policy.cjs (resolveRuntimeNameFromCandidates — canonicalize the active runtime)
  *   - ./planning-workspace.cjs  (planningDir — workstream/project-aware project-config path)
  *   - ./config-loader.cjs    (loadConfig)
@@ -25,14 +25,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const configLoaderModule = require("./config-loader.cjs");
-const { loadConfig } = configLoaderModule;
+const { loadConfig, readConfigFileBounded } = configLoaderModule;
 // ─── Configuration Module (for CANONICAL_CONFIG_DEFAULTS used by effort/fast_mode resolvers) ─
 const configuration_cjs_1 = require("./configuration.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const modelProfiles = require("./model-profiles.cjs");
 const { MODEL_PROFILES, AGENT_TO_PHASE_TYPE, AGENT_DEFAULT_TIERS, VALID_AGENT_TIERS, nextTier } = modelProfiles;
 const model_catalog_cjs_1 = require("./model-catalog.cjs");
-const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const runtime_name_policy_cjs_1 = require("./runtime-name-policy.cjs");
 const runtime_slash_cjs_1 = require("./runtime-slash.cjs");
@@ -87,7 +86,12 @@ function projectExplicitlySetsOmit(cwd) {
     const layers = wsDir === rootDir ? [rootDir] : [wsDir, rootDir]; // workstream > root
     for (const dir of layers) {
         try {
-            const parsed = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(dir, 'config.json'), 'utf8'));
+            // Same bounded regular-file reader as the loader (#5759): a FIFO/device/oversized
+            // layer throws instead of blocking, and an absent layer returns null.
+            const raw = readConfigFileBounded(node_path_1.default.join(dir, 'config.json'));
+            if (raw === null)
+                continue;
+            const parsed = JSON.parse(raw);
             const value = parsed?.['resolve_model_ids'];
             // First layer that sets the key wins (matches loadConfig's deep-merge
             // precedence). A layer that omits the key falls through to the next.

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

@@ -32,6 +32,7 @@ exports.phaseEntryRegExp = phaseEntryRegExp;
 exports.phaseEntrySplitRegExp = phaseEntrySplitRegExp;
 exports.isPhaseEntryChecked = isPhaseEntryChecked;
 exports.isBoxCharChecked = isBoxCharChecked;
+exports.stripInsertedMarker = stripInsertedMarker;
 const MARKER_SRC = '[-*]';
 // A list item has 1 to 4 spaces or tabs after its marker (CommonMark: none is not a list item,
 // five or more makes the rest an indented code block), so `-[ ] **Phase 1**` is not an entry.
@@ -117,3 +118,16 @@ function isPhaseEntryChecked(entryText) {
 function isBoxCharChecked(boxChar) {
     return boxChar.toLowerCase() === 'x';
 }
+/**
+ * #5824: `phase insert` writes `(INSERTED)` into the heading text as
+ * bookkeeping; it is not part of the phase's name. The single place that
+ * removes it: only a TRAILING `(INSERTED)` (case-insensitive) is dropped, then
+ * a trim — `phase insert` always appends it last, and a `(INSERTED)` inside the
+ * user's own text is kept. A name that is only the marker is returned as
+ * written rather than reduced to an empty name. Every phase-name reader goes
+ * through here so none can drift from the others.
+ */
+function stripInsertedMarker(name) {
+    const stripped = name.replace(/\s*\(INSERTED\)\s*$/i, '').trim();
+    return stripped === '' ? name.trim() : stripped;
+}

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

@@ -71,6 +71,8 @@ const OPTIONAL_PHASE_TAG_SOURCE = '(?:\\s*\\([^)\\n]{0,200}\\))?';
 // (scripts/lint-phase-id-drift.cjs) fails CI if a literal re-derivation is
 // introduced outside this module without a `// phase-id-owner:` justification.
 const PHASE_NUMBER_TOKEN_SOURCE = '\\d+[A-Z]?(?:\\.\\d+)*';
+// #5676: milestone-prefixed M-NN token grammar (one optional -NN segment, the #5626 grammar).
+const PHASE_NUMBER_TOKEN_SOURCE_MILESTONE_PREFIXED = '\\d+(?:-\\d+)?[A-Z]?(?:\\.\\d+)*';
 // #4764: a legacy phase REFERENCE in depends-on PROSE — the token in context, directly
 // following "Phase"/"Phases", with bare-token list continuation ("Phases 1 and 2",
 // "Phase 1, 2, and 3", "Phase 1-3"). Built HERE, beside the token grammar it is
@@ -381,7 +383,7 @@ function phaseHeadingPrefixSrcFor(baseline, convention, capturing = false) {
 function parsePhaseChecklistLine(line, convention, context) {
     const capturesBracketId = convention === 'bracket';
     const intro = phaseHeadingPrefixSrcFor(PHASE_HEADING_BASELINE.LABEL_ONLY, convention, capturesBracketId);
-    const pattern = (0, phase_entry_grammar_cjs_1.phaseEntryRegExp)(`${intro}(${context ? phaseScanTokenSource(context) : PHASE_NUMBER_TOKEN_SOURCE})`
+    const pattern = (0, phase_entry_grammar_cjs_1.phaseEntryRegExp)(`${intro}(${context ? phaseScanTokenSource(context, convention) : phaseNumberTokenSource(convention)})`
         + `${OPTIONAL_PHASE_TAG_SOURCE}(?=[:\\s])`, 'i', { state: 'captured' });
     const match = pattern.exec(line);
     if (!match)
@@ -413,7 +415,7 @@ function buildPhaseHeadingScanRegex(baseline, convention, context) {
     const bracketGroup = convention === 'bracket' ? 1 : null;
     const phaseNumGroup = bracketGroup ? 2 : 1;
     const phaseNameGroup = phaseNumGroup + 1;
-    const regex = new RegExp(`^ {0,3}#{2,4}\\s*${phaseHeadingPrefixSrcFor(baseline, convention, true)}(${context && convention !== 'bracket' ? phaseScanTokenSource(context) : PHASE_NUMBER_TOKEN_SOURCE})${OPTIONAL_PHASE_TAG_SOURCE}:\\s*([^\\n]+)`, 'gim');
+    const regex = new RegExp(`^ {0,3}#{2,4}\\s*${phaseHeadingPrefixSrcFor(baseline, convention, true)}(${context && convention !== 'bracket' ? phaseScanTokenSource(context, convention) : phaseNumberTokenSource(convention)})${OPTIONAL_PHASE_TAG_SOURCE}:\\s*([^\\n]+)`, 'gim');
     return { regex, bracketGroup, phaseNumGroup, phaseNameGroup };
 }
 /**
@@ -435,7 +437,7 @@ function buildPhaseDeclarationScans(convention, withBullets = true) {
     // Under bracket a numbered-list item (`1. [ ] **[GSD.02] 05: n**`) is a checklist row too.
     const bullet = bracket ? '^[ \\t]*(?:-|\\d+[.)])[ \\t]*' : '^[ \\t]*-[ \\t]*';
     // Bracket ids may carry a letter suffix (`12A`), as the heading scan's phase token does.
-    const tail = bracket ? '(\\d+)(?=[A-Za-z]?(?:[:.\\s*]|$))' : '(\\d+)(?=[:.\\s*]|$)';
+    const tail = bracket ? '(\\d+)(?=[A-Za-z]?(?:[:.\\s*]|$))' : convention === 'milestone-prefixed' ? `(${phaseNumberTokenSource(convention)})(?=[:.\\s*]|$)` : '(\\d+)(?=[:.\\s*]|$)';
     const checkbox = `\\[${bracket ? `(?!${BRACKET_ID_SRC}\\])` : ''}[^\\]]{0,200}\\][ \\t]*`;
     if (!bracket) {
         if (withBullets)
@@ -1582,9 +1584,17 @@ const CUSTOM_PHASE_ID_FILE = '.phase-id';
 function phaseDirectoryContext(config, roadmap = '', knownIds = []) {
     return { phaseNaming: typeof config.phase_naming === 'string' ? config.phase_naming.toLowerCase() : config.phase_naming, projectCode: config.project_code ?? null, roadmap, knownIds };
 }
-/** Custom scans reuse the numeric source verbatim outside configured custom projects. */
-function phaseScanTokenSource(context) {
-    return context?.phaseNaming === 'custom' ? '[^ \t:\n]+' : PHASE_NUMBER_TOKEN_SOURCE;
+/** #5676: the single owner of the numeric phase-token source per convention. */
+function phaseNumberTokenSource(convention) {
+    return convention === 'milestone-prefixed' ? PHASE_NUMBER_TOKEN_SOURCE_MILESTONE_PREFIXED : PHASE_NUMBER_TOKEN_SOURCE;
+}
+/**
+ * Custom scans reuse the numeric source verbatim outside configured custom projects.
+ * #5676: under `milestone-prefixed` the numeric source admits the `M-NN` token
+ * (`3-02`), so a `03-02-beta` directory is read as phase `3-02`, not phase `3`.
+ */
+function phaseScanTokenSource(context, convention) {
+    return context?.phaseNaming === 'custom' ? '[^ \t:\n]+' : phaseNumberTokenSource(convention);
 }
 const customIdentityIndexes = new WeakMap();
 function customIdentityIndex(options) {
@@ -1986,12 +1996,17 @@ function phaseKeyFromDir(dirName, convention, context) {
  * `Phase:` value. Markdown emphasis is stripped first so a bolded cell is not
  * mistaken for a non-phase. Returns null when the value does not BEGIN with a
  * phase token (`parsePhaseFromProse` anchoring, #2111).
+ *
+ * #5675: `convention` is the project's `phase_id_convention`. Under `milestone-prefixed` the id is
+ * the whole `M-NN` (`3-01`), so the key equals `phaseKeyFromDir` for the same phase; every other
+ * convention (and an absent one) keeps the leading-integer read. It is the trailing parameter so the
+ * existing `(value, context)` callers stay byte-identical.
  */
-function phaseKeyFromProse(value, context) {
+function phaseKeyFromProse(value, context, convention) {
     if (value == null)
         return null;
     const clean = String(value).replace(/[*_`~]/g, '');
-    const { phase } = parsePhaseFromProse(clean, undefined, context);
+    const { phase } = parsePhaseFromProse(clean, convention, context);
     return phase === null ? null : phaseKeyFromToken(phase, context);
 }
 /**
@@ -2031,7 +2046,7 @@ function isPlannedPhaseStatusPhrase(value) {
 // (`3-01`), so the number capture takes one optional `-NN` segment; every other convention (and an absent
 // one) keeps the dotted-only capture, where `3-01` reads as phase `3` exactly as before.
 const PHASE_PROSE_RE = /^\s*(?:Phase\s+)?(?:[A-Z][A-Z0-9_]*-)?(\d+[A-Z]?(?:\.\d+)*)\b/i;
-const PHASE_PROSE_MILESTONE_PREFIXED_RE = /^\s*(?:Phase\s+)?(?:[A-Z][A-Z0-9_]*-)?(\d+(?:-\d+)?[A-Z]?(?:\.\d+)*)\b/i;
+const PHASE_PROSE_MILESTONE_PREFIXED_RE = new RegExp(`^\\s*(?:Phase\\s+)?(?:[A-Z][A-Z0-9_]*-)?(${PHASE_NUMBER_TOKEN_SOURCE_MILESTONE_PREFIXED})\\b`, 'i');
 function parsePhaseFromProse(value, convention, context) {
     if (!value)
         return { phase: null, name: null };
@@ -2206,6 +2221,8 @@ const phaseIdExports = {
     OPTIONAL_PROJECT_CODE_PREFIX_SOURCE,
     OPTIONAL_PHASE_TAG_SOURCE,
     PHASE_NUMBER_TOKEN_SOURCE,
+    PHASE_NUMBER_TOKEN_SOURCE_MILESTONE_PREFIXED,
+    phaseNumberTokenSource,
     PHASE_DEP_REF_SOURCE,
     tokenizePhaseDependencyReferences,
     extractPhaseDependencyTokens,