@opengsd/gsd-core 1.12.0 → 1.13.0

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

@@ -114,6 +114,50 @@ function readGsdEffectiveModelOverrides(targetDir = null, options = {}) {
     // Per-project wins on conflict; preserve non-conflicting global keys.
     return { ...(global || {}), ...(projectOverrides || {}) };
 }
+function readGsdAgentTools(config) {
+    const raw = config?.agent_tools;
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const result = {};
+    for (const [selector, value] of Object.entries(raw)) {
+        // An explicitly present selector always has a verdict. Invalid values are
+        // empty so a project config cannot accidentally restore a global grant.
+        result[selector] = Array.isArray(value)
+            ? value.filter((entry) => typeof entry === 'string')
+                .map((entry) => entry.trim())
+                .filter((entry) => entry.length > 0
+                && !entry.endsWith(':')
+                && !/[\s\u0000-\u001F\u007F-\u009F,#"'\u2028\u2029]/.test(entry))
+            : [];
+    }
+    return result;
+}
+/**
+ * Resolve valid install-time `agent_tools` grants from global defaults and
+ * the nearest project config. Project selectors replace only matching global
+ * selectors; malformed whole files remain harmless absence like the existing
+ * model override resolver.
+ */
+function readGsdEffectiveAgentTools(targetDir = null, options = {}) {
+    const home = options.homedir ? options.homedir() : node_os_1.default.homedir();
+    const globalConfig = _readGsdConfigFile(node_path_1.default.join(home, '.gsd', 'defaults.json'), 'global defaults');
+    let projectConfig = null;
+    if (targetDir) {
+        const candidate = _findAncestorGsdConfigPath(targetDir);
+        if (candidate) {
+            projectConfig = _readGsdConfigFile(candidate, 'project config');
+        }
+    }
+    const global = readGsdAgentTools(globalConfig);
+    const project = readGsdAgentTools(projectConfig);
+    if (projectConfig
+        && Object.prototype.hasOwnProperty.call(projectConfig, 'agent_tools')
+        && project === null)
+        return {};
+    if (!global && !project)
+        return null;
+    return { ...(global || {}), ...(project || {}) };
+}
 /**
  * Build a runtime-aware tier resolver for the install path (#2517).
  *
@@ -230,6 +274,7 @@ function resolveAgentModelOverride(agentName, modelOverrides, runtimeResolver) {
 module.exports = {
     readGsdGlobalModelOverrides,
     readGsdEffectiveModelOverrides,
+    readGsdEffectiveAgentTools,
     readGsdRuntimeProfileResolver,
     resolveAgentModelOverride,
 };

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

@@ -32,7 +32,7 @@ const shell_command_projection_cjs_1 = require("./shell-command-projection.cjs")
 const external_descriptor_trust_cjs_1 = require("./external-descriptor-trust.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, } = conversionModule;
+const { applyAgentPathRewrites: _applyAgentPathRewrites, processAttribution: _processAttribution, normalizeAgentBodyForRuntime: _normalizeAgentBodyForRuntime, readGsdCommandNames: _readGsdCommandNames, deriveAgentName: _deriveAgentName, applyAgentFrontmatterExtensions: _applyAgentFrontmatterExtensions, appendAgentTools: _appendAgentTools, } = 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 —
@@ -40,6 +40,8 @@ const { applyAgentPathRewrites: _applyAgentPathRewrites, processAttribution: _pr
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const workflowFragmentsModule = require("./workflow-fragments.cjs");
 const { composeWorkflow: _composeWorkflow } = workflowFragmentsModule;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const installModelOverrideResolver = require("./install-model-override-resolver.cjs");
 // ---------------------------------------------------------------------------
 // Profile definitions
 // ---------------------------------------------------------------------------
@@ -896,14 +898,14 @@ function stageSkillsForRuntimeAsSkills(srcCommandsDir, resolvedProfile, converte
  * agent loop in bin/install.js exactly:
  *   1. applyAgentPathRewrites   (4 base ~/.claude/ regexes; skipped for copilot/antigravity)
  *   2. processAttribution       (Co-Authored-By policy)
- *   3. converter                (runtime-specific frontmatter/body transform)
- *   4. applyAgentFrontmatterExtensions (#2875 Part 2: effort/disallowedTools,
+ *   3. appendAgentTools         (#4032: validated agent_tools grants, before host conversion)
+ *   4. converter                (runtime-specific frontmatter/body transform)
+ *   5. applyAgentFrontmatterExtensions (#2875 Part 2: effort/disallowedTools,
  *      gated by hostBehaviors.agentFrontmatterExtensions — no-op for a runtime
  *      that declares nothing, e.g. every non-Claude runtime today)
- *   5. normalizeAgentBodyForRuntime (colon→hyphen refs; no-op for trivial group)
- * When `agentCtx` is absent, only the converter is applied (backward-compat for
- * the feat-1173 synthetic-descriptor tests and the copilot/antigravity paths
- * that handle cross-cutting inside their converters).
+ *   6. normalizeAgentBodyForRuntime (colon→hyphen refs; no-op for trivial group)
+ * When `agentCtx` is absent, only global `agent_tools` augmentation and the
+ * converter run; other cross-cutting remains absent for backward compatibility.
  *
  * @param srcAgentsDir    source agents directory (e.g. agents/)
  * @param resolvedProfile profile filter from resolveProfile()
@@ -917,8 +919,7 @@ function stageSkillsForRuntimeAsSkills(srcCommandsDir, resolvedProfile, converte
  *                        every OTHER converter's contract — converters that don't declare a
  *                        3rd parameter simply never read it.
  * @param isGlobal        install scope passed through to the converter
- * @param agentCtx        optional cross-cutting context (ADR-1235 §1); when absent,
- *                        only the converter is applied (backward compat)
+ * @param agentCtx        optional cross-cutting context (ADR-1235 §1)
  */
 function stageAgentsForRuntimeWithConverter(srcAgentsDir, resolvedProfile, converter, isGlobal = false, agentCtx) {
     if (!installFs().existsSync(srcAgentsDir))
@@ -950,6 +951,7 @@ function stageAgentsForRuntimeWithConverter(srcAgentsDir, resolvedProfile, conve
     try {
         // Resolve cmdNames once per staging call (not per file) for performance.
         const cmdNames = agentCtx ? _readGsdCommandNames() : [];
+        const agentTools = installModelOverrideResolver.readGsdEffectiveAgentTools(agentCtx?.projectDir ?? agentCtx?.targetDir ?? null);
         for (const entry of entries) {
             if (!entry.isFile())
                 continue;
@@ -969,25 +971,31 @@ function stageAgentsForRuntimeWithConverter(srcAgentsDir, resolvedProfile, conve
             // throws loudly naming the file for a malformed marker, never emitting a
             // half-composed agent.
             content = _composeWorkflow(content, { sourcePath: agentSourcePath });
+            const agentName = _deriveAgentName(entry.name);
+            const grants = [
+                ...(agentTools?.['*'] || []),
+                ...(agentTools?.[agentName] || []),
+            ];
             if (agentCtx) {
                 // #2875 Part 2 / row I3: derived exactly as the inline loop does —
                 // single-sourced via deriveAgentName (runtime-artifact-conversion.cts).
-                const agentName = _deriveAgentName(entry.name);
                 // ADR-1235 §1: pre-converter cross-cutting (matches inline loop order exactly)
                 // Step 1: path rewrites (4 base ~/.claude/ regexes; skipped for copilot/antigravity)
                 content = _applyAgentPathRewrites(content, agentCtx.runtime, agentCtx.pathPrefix);
                 // Step 2: attribution
                 content = _processAttribution(content, agentCtx.attribution);
-                // Step 3: converter (runtime-specific frontmatter/body transform)
+                // 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 });
-                // Step 4: frontmatter extensions (effort/disallowedTools; no-op unless
+                // Step 5: frontmatter extensions (effort/disallowedTools; no-op unless
                 // the runtime declares hostBehaviors.agentFrontmatterExtensions)
                 content = _applyAgentFrontmatterExtensions(content, { runtime: agentCtx.runtime, agentName, targetDir: agentCtx.targetDir });
-                // Step 5: normalize colon→hyphen refs (no-op for trivial group)
+                // Step 6: normalize colon→hyphen refs (no-op for trivial group)
                 content = _normalizeAgentBodyForRuntime(content, agentCtx.runtime, cmdNames);
             }
             else {
-                // Backward-compat: only apply the converter (no cross-cutting)
+                content = _appendAgentTools(content, grants);
                 content = converter(content, isGlobal);
             }
             installFs().writeFileSync(node_path_1.default.join(stageDir, entry.name), content, 'utf8');

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

@@ -55,6 +55,7 @@ exports.BUNDLED_GSD_HOOK_FILES = Object.freeze(new Set([
     'hooks/gsd-prompt-guard.js',
     'hooks/gsd-read-guard.js',
     'hooks/gsd-read-injection-scanner.js',
+    'hooks/gsd-secret-read-guard.js',
     'hooks/gsd-session-state.sh',
     'hooks/gsd-statusline.js',
     'hooks/gsd-update-banner.js',

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

@@ -205,6 +205,40 @@ function output(result, raw, rawValue) {
     // and skipping process.exit() lets the event loop drain naturally.
     writeAllSync(1, data);
 }
+/**
+ * Single owner of the "a no-op decline reports the real condition" pairing:
+ * a `[gsd-tools] WARNING:` stderr disclosure plus the matching
+ * `{ [flagKey]: false, ...computed, reason }` JSON payload (#3957, epic
+ * #3473 B9). Before this helper, each CLI command's no-op arm hand-wrote
+ * both halves independently, and #3957's own sweep found sites where one
+ * half drifted: a decline that discarded values it had already computed, a
+ * `reason` string naming a condition that hadn't actually fired, or no
+ * stderr disclosure at all (missing the `[gsd-tools] WARNING:` convention
+ * #3217, ADR-3180 §7.6 rule 4, established for exactly this situation —
+ * a JSON `reason` field alone is easy for a caller piping stdout through
+ * `--json` to never read). Routing every no-op decline through one call
+ * site makes the convention structural — a call site, not a habit a fifth
+ * arm can independently forget — rather than leaving it to per-site
+ * discipline.
+ *
+ * `disclosure` is written to stderr VERBATIM. Like `error()`'s `message`
+ * argument (see that function's own doc comment above `formatDiagnosticToken`),
+ * this function stays a dumb, faithful writer and does not sanitize it — a
+ * caller that interpolates an UNTRUSTED substring (a caller-supplied
+ * blocker/session-field string, an argv token) into `disclosure` MUST pass
+ * that substring through `formatDiagnosticToken` first. Skipping that step
+ * lets an embedded `\n` forge a second, attacker-authored
+ * `[gsd-tools] WARNING:` line — the same risk `error()`'s doc comment
+ * documents for its own stderr write.
+ */
+function declineNoOp(raw, flagKey, reason, disclosure, computed = {}) {
+    // `process.stderr.write`, matching the `[gsd-tools] WARNING:` call sites
+    // this helper replaces (state.cts's stateReplaceFieldWithFallback and the
+    // cmdStateUpdateProgress decline arms) — not the `writeAllSync(2, …)`
+    // primitive `error()` uses, which is reserved for the fatal-exit path.
+    process.stderr.write(`[gsd-tools] WARNING: ${disclosure}\n`);
+    output({ [flagKey]: false, ...computed, reason }, raw, 'false');
+}
 /**
  * Frozen enum of typed reason codes used by error() for structured errors.
  * Each subcommand contributes its own codes; the enum exists so tests can
@@ -392,6 +426,7 @@ module.exports = {
     ensureGsdTempDir,
     reapStaleTempFiles,
     output,
+    declineNoOp,
     serializeForOutput,
     ERROR_REASON,
     setJsonErrorMode,

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

@@ -40,7 +40,7 @@ const { resolveCapabilityRuntimeState } = capabilityStateModule;
 // ─── Capability-activation engine (single owner for config-key precedence) ────
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const capabilityActivationModule = require("./capability-activation.cjs");
-const { _getNestedConfigValue, _readRawConfigKey, _resolveActivationValue, resolveConfigKey } = capabilityActivationModule;
+const { _getNestedConfigValue, _readRawConfigKey, _resolveActivationValue, _resolvePointGate, resolveConfigKey } = capabilityActivationModule;
 // ─── Canonical points (derived from LOOP_HOST_CONTRACT — authoritative 12) ───
 // FIX 2: Derive the authoritative canonical set from LOOP_HOST_CONTRACT so it
 // cannot drift from the host contract. CANONICAL_POINTS_FALLBACK is kept as an
@@ -125,13 +125,15 @@ function resolveLoopHooks(input) {
     // Helper: check activation using single-key precedence resolver (FIX 1 + FIX 3)
     function isActive(hook) {
         const when = hook['when'];
-        // No `when` → unconditional hook, always active
-        if (when === undefined || when === null)
-            return true;
-        // FIX 3: `when` present but not a non-empty string → malformed registry data → INACTIVE
-        if (typeof when !== 'string' || when.length === 0)
-            return false;
-        return _resolveActivationValue(when, config, cwd, registry);
+        if (when !== undefined && when !== null) {
+            // FIX 3: `when` present but not a non-empty string → malformed registry data → INACTIVE
+            if (typeof when !== 'string' || when.length === 0)
+                return false;
+            if (!_resolveActivationValue(when, config, cwd, registry))
+                return false;
+        }
+        // #3661: optional point-selection gate — see capability-activation.cts.
+        return _resolvePointGate(hook['pointFrom'], point, config, cwd, registry);
     }
     function isCapabilityActive(capId) {
         if (!capabilityStatesById)
@@ -555,6 +557,10 @@ module.exports = {
     // Re-exported for identity parity guard (FIX 2: resolveConfigValues in this module
     // calls resolveConfigKey; exporting it here makes the single-owner contract testable).
     resolveConfigKey,
+    // #3661: re-exported for the same identity parity guard — isActive calls
+    // _resolvePointGate; exporting it here makes the single-owner contract testable
+    // (see tests/capability-precedence-parity.test.cjs's identity guard describe block).
+    _resolvePointGate,
     CANONICAL_POINTS_FALLBACK,
     CANONICAL_POINTS,
 };

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

@@ -23,6 +23,7 @@ exports.findTableBySchema = findTableBySchema;
 exports.findTableWithColumns = findTableWithColumns;
 exports.escapeCell = escapeCell;
 exports.appendQuickTaskRow = appendQuickTaskRow;
+exports.migrateQuickTasksTable = migrateQuickTasksTable;
 exports.resetQuickTaskRows = resetQuickTaskRows;
 const markdown_sectionizer_cjs_1 = require("./markdown-sectionizer.cjs");
 // ─── Schema registry ──────────────────────────────────────────────────────────
@@ -776,6 +777,128 @@ function appendQuickTaskRow(stateContent, fields) {
     const content = (0, markdown_sectionizer_cjs_1.replaceSection)(stateContent, section, newBody);
     return { ok: true, value: { content, row, variant: match.label } };
 }
+// ─── migrateQuickTasksTable (#3730 option b) ───────────────────────────────
+/**
+ * Column-name → canonical-cell mapping for migrating a legacy Quick Tasks table
+ * (#3730). Name-based, case-insensitive; every column NOT in this map lands in
+ * the Description bucket (joined with ' · ' in original column order, unknown
+ * names kept as `name: value`) so no historical datum is dropped.
+ */
+const QUICK_TASKS_COLUMN_ALIASES = {
+    '#': '#', id: '#',
+    date: 'Date', when: 'Date',
+    commit: 'Commit', sha: 'Commit',
+    status: 'Status',
+    directory: 'Directory', artifacts: 'Directory', path: 'Directory', dir: 'Directory',
+    description: 'Description', task: 'Description', summary: 'Description',
+    slug: 'Description', scope: 'Description', title: 'Description',
+};
+/**
+ * Migrate STATE.md's "Quick Tasks Completed" table onto the canonical
+ * `with-status` schema (#3730, maintainer decision 2026-09-02: option b).
+ *
+ * The pre-registry prose template licensed arbitrary column shapes GSD itself
+ * emitted, and `appendQuickTaskRow` fails loud on every one of them — leaving a
+ * project permanently unappendable. This is the supported repair path: the
+ * `gsd-tools quick-tasks-migrate` subcommand, plus an automatic check on the
+ * first `quick`/`fast` run (the workflow calls this before appending), which is
+ * a silent no-op when the section is absent, the table is already canonical, or
+ * the user never runs quick at all.
+ *
+ * Same section-selection, parse, and fail-loud posture as `appendQuickTaskRow`
+ * (ADR-2143 §7 upheld — append still rejects; this REPAIRS). Returns
+ * `{ok:true, value:{content, migrated:false}}` for the no-op cases so callers
+ * can stay silent, and `{migrated:true, from, rows}` when a rewrite happened so
+ * the CLI can report exactly what moved.
+ */
+function migrateQuickTasksTable(stateContent) {
+    const section = selectQuickTasksSection(stateContent);
+    if (!section) {
+        return { ok: true, value: { content: stateContent, migrated: false } };
+    }
+    const parsed = parseMarkdownTable(section.body);
+    if (!parsed.ok) {
+        return { ok: false, reason: `quick-tasks table: ${parsed.reason}` };
+    }
+    const match = matchTableSchema(parsed.value.columns);
+    if (match && match.id === 'QuickTasks') {
+        return { ok: true, value: { content: stateContent, migrated: false } };
+    }
+    const canonical = exports.TABLE_SCHEMAS.QuickTasks.find((v) => v.label === 'with-status').columns;
+    // Map each legacy column to its canonical target; unmapped names keep their
+    // identity so the Description bucket can render them losslessly.
+    const targets = parsed.value.columns.map((c) => QUICK_TASKS_COLUMN_ALIASES[c.trim().toLowerCase()] ?? null);
+    const rows = parsed.value.rows.map((row, rowIdx) => {
+        const bucket = {
+            '#': '', Description: '', Date: '', Commit: '', Status: '', Directory: '',
+        };
+        const descriptionParts = [];
+        // parseMarkdownTable hands back name-keyed records (rows[i][columnName]).
+        parsed.value.columns.forEach((col, i) => {
+            const raw = (row[col] ?? '').trim();
+            const target = targets[i];
+            if (target === 'Description') {
+                if (raw)
+                    descriptionParts.push(raw);
+            }
+            else if (target) {
+                // Collision-safe (#3730 review): two legacy columns aliasing the same
+                // canonical target must not silently overwrite — the displaced value
+                // joins the Description bucket under its own name, same convention as
+                // an unknown column, so no historical datum is dropped.
+                if (raw && bucket[target]) {
+                    descriptionParts.push(`${col.trim()}: ${raw}`);
+                }
+                else if (raw) {
+                    bucket[target] = raw;
+                }
+            }
+            else if (raw) {
+                descriptionParts.push(`${col.trim()}: ${raw}`);
+            }
+        });
+        bucket['#'] = bucket['#'] || String(rowIdx + 1);
+        bucket.Description = descriptionParts.join(' · ');
+        bucket.Date = bucket.Date || '—';
+        bucket.Commit = bucket.Commit || '—';
+        bucket.Status = bucket.Status || '—';
+        bucket.Directory = bucket.Directory || '—';
+        return `| ${canonical.map((c) => escapeCell(bucket[c])).join(' | ')} |`;
+    });
+    const eol = /\r\n/.test(section.body) ? '\r\n' : '\n';
+    const lines = section.body.split(/\r?\n/);
+    // CONTIGUOUS-run bound (#3730 review), mirroring resetQuickTaskRows: the
+    // section body may carry a SECOND table (a `#### Notes` subsection or a
+    // trailing table after a blank line) that parseMarkdownTable never read —
+    // scanning for the last pipe line anywhere in the body would splice the
+    // rewrite across it and silently destroy it. Only the first CONTIGUOUS run
+    // of pipe lines — the table that was parsed — is replaced.
+    const firstTableLineIdx = lines.findIndex((l) => l.trim().startsWith('|'));
+    let lastTableLineIdx = firstTableLineIdx;
+    while (lastTableLineIdx + 1 < lines.length && lines[lastTableLineIdx + 1].trim().startsWith('|')) {
+        lastTableLineIdx++;
+    }
+    const header = `| ${canonical.join(' | ')} |`;
+    // Widths match workflows/quick.md's canonical template byte-for-byte
+    // (#3730 review): its delimiter is max(3, len+2) per column.
+    const delimiter = `| ${canonical.map((c) => '-'.repeat(Math.max(3, c.length + 2))).join(' | ')} |`;
+    const newBody = [
+        ...lines.slice(0, firstTableLineIdx),
+        header,
+        delimiter,
+        ...rows,
+        ...lines.slice(lastTableLineIdx + 1),
+    ].join(eol);
+    return {
+        ok: true,
+        value: {
+            content: (0, markdown_sectionizer_cjs_1.replaceSection)(stateContent, section, newBody),
+            migrated: true,
+            from: parsed.value.columns,
+            rows: rows.length,
+        },
+    };
+}
 // ─── resetQuickTaskRows (#2142) ────────────────────────────────────────────
 /**
  * Clear every DATA row from STATE.md's "Quick Tasks Completed" table, leaving

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

@@ -55,7 +55,7 @@ const { scanPhasePlans } = planScanMod;
 // eslint-disable-next-line @typescript-eslint/no-require-imports -- phase-locator.cjs is an export= CommonJS module
 const phaseLocatorMod = require("./phase-locator.cjs");
 const { listMilestonePhaseDirs } = phaseLocatorMod;
-const { planningPaths } = planningWorkspace;
+const { planningPaths, resolvePhaseIdConvention } = planningWorkspace;
 const { extractFrontmatter } = frontmatterMod;
 // ADR-3408 §8.3 / #3469: `writeStateMd` gets sync and NO preservation — the
 // same #3374-shaped exposure the milestone-complete write used to carry (a
@@ -702,6 +702,22 @@ function cmdMilestoneComplete(cwd, version, options, raw) {
     let totalPlans = 0;
     let totalTasks = 0;
     const accomplishments = [];
+    // #2761 (round-11 BLOCKER): resolved ONCE, ambiently (no explicit `ws` —
+    // this function has none of its own and already resolves everything else
+    // off `cwd` via planningPaths(cwd), matching the ambient-workstream
+    // contract `resolvePhaseIdConvention`/`planningDir` share), and threaded
+    // into the single `listMilestonePhaseDirs` call directly below. Left
+    // unthreaded, `phaseIdConvention` stays `undefined` and
+    // `getMilestonePhaseFilter` silently resolves it FROM CONFIG itself —
+    // which is exactly the behavior the changeset originally (and wrongly)
+    // claimed this PR does not reach: on a bracket-convention project that
+    // lazily-resolved convention changes `milestonePhaseDirs`/
+    // `milestonePhaseScope` below, and this function goes on to ARCHIVE
+    // (rename/move) whatever that set names. Resolving explicitly here removes
+    // the silent-inherit path without changing behavior for `null` /
+    // `milestone-prefixed` projects, whose resolved convention is the same
+    // value `undefined` would have lazily produced anyway.
+    const phaseConvention = resolvePhaseIdConvention(cwd);
     // #3597 (ADR-3180 Decision 2): SINGLE resolution of "which phase
     // directories belong to the current milestone" AND the SCOPE discriminator
     // that resolution came from — shared verbatim by the read-only stats loop
@@ -715,7 +731,11 @@ function cmdMilestoneComplete(cwd, version, options, raw) {
     // disk, same as before #3597. Only the destructive archive pass (and its
     // --dry-run preview) refuses to act on a non-COMPLETE (non-answer) scope;
     // see the guard built from `milestonePhaseScope` further down.
-    const { value: milestonePhaseDirs, scope: milestonePhaseScope } = listMilestonePhaseDirs(phasesDir, { cwd, versionOverride: version });
+    const { value: milestonePhaseDirs, scope: milestonePhaseScope } = listMilestonePhaseDirs(phasesDir, {
+        cwd,
+        versionOverride: version,
+        phaseIdConvention: phaseConvention,
+    });
     try {
         for (const dir of milestonePhaseDirs) {
             phaseCount++;

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

@@ -6,7 +6,7 @@
  * Unsupported in this router:
  * - scaffold: routed through top-level scaffold command.
  *
- * CJS-only subcommands: mvp-mode (dispatched directly, before hub).
+ * CJS-only subcommands: mvp-mode, tdd-applicable (dispatched directly, before hub).
  *
  * #3788: dispatch is mediated by CommandRoutingHub. The public entry point
  * and observable CLI behaviour are unchanged.
@@ -57,6 +57,13 @@ function routePhaseCommand({ phase, args, cwd, raw, error }) {
         phase.cmdPhaseMvpMode(cwd, args.slice(2), raw);
         return;
     }
+    // `tdd-applicable` (#4273): same CJS-native dispatch shape as `mvp-mode`
+    // immediately above — a precedence cascade over plan/task/config sources
+    // with its own typed JSON result, not routed through the SDK query layer.
+    if (subcommand === 'tdd-applicable') {
+        phase.cmdPhaseTddApplicable(cwd, args.slice(2), raw);
+        return;
+    }
     // ── Build the CJS registry ──────────────────────────────────────────────────
     // Each handler receives a ctx object from the hub and must return a HubResult.
     const cjsRegistry = {
@@ -224,14 +231,14 @@ function routePhaseCommand({ phase, args, cwd, raw, error }) {
     // ── Build manifest (available subcommands for UnknownCommand detection) ─────
     // `availableSubcommands` is what the error message shows. It excludes
     // unsupported commands (already handled above) but does NOT include 'mvp-mode'
-    // because it was absent from PHASE_SUBCOMMANDS in the original and was not
-    // shown in the "Available:" list there either.
+    // or 'tdd-applicable' (#4273) because both are absent from PHASE_SUBCOMMANDS
+    // and were not shown in the "Available:" list there either.
     //
     // `manifestSubcommands` is the full routing set for the hub — it includes
-    // 'mvp-mode' (which the original code routed via a handler even without a
-    // manifest entry) so the hub's UnknownCommand check passes for it.
+    // 'mvp-mode' and 'tdd-applicable' (both routed via a handler even without a
+    // manifest entry) so the hub's UnknownCommand check passes for them.
     const availableSubcommands = command_aliases_cjs_1.PHASE_SUBCOMMANDS.filter(s => !UNSUPPORTED[s]);
-    const manifestSubcommands = ['mvp-mode', ...availableSubcommands];
+    const manifestSubcommands = ['mvp-mode', 'tdd-applicable', ...availableSubcommands];
     const manifest = { phase: manifestSubcommands };
     // ── Construct hub ──────────────────────────────────────────────────────────
     // #175: Hub is CJS-only — no mode param, no sdkLoader.