@opengsd/gsd-core 1.17.0 → 1.19.0

package/gsd-core/bin/lib/gate-ui-safety.cjs

@@ -21,6 +21,8 @@ const gate_phase_context_cjs_1 = require("./gate-phase-context.cjs");
 const gate_evaluation_scope_cjs_1 = require("./gate-evaluation-scope.cjs");
 const runtime_slash_cjs_1 = require("./runtime-slash.cjs");
 const ui_safety_gate_cjs_1 = require("./ui-safety-gate.cjs");
+const ui_frontend_evidence_cjs_1 = require("./ui-frontend-evidence.cjs");
+const gate_evidence_cjs_1 = require("./gate-evidence.cjs");
 const UI_FILE_EXTENSIONS_RE = /\.(tsx|jsx|css|scss|sass|less|vue|svelte|html)$/i;
 const UI_PATH_PATTERNS_RE = /\/(components|pages|views|screens|layouts|ui|frontend)\//i;
 /**
@@ -32,7 +34,10 @@ const UI_PATH_PATTERNS_RE = /\/(components|pages|views|screens|layouts|ui|fronte
  *       git call is bounded by the resolver's seam; an unreadable scope is reported, not "clean").
  *   (d) Phase directory → `*-UI-SPEC.md`.
  *
- * `block = frontend && hasUiFiles && !hasUiSpec`.
+ *   (c') Static frontend evidence (`readStaticFrontendEvidence`, the definition `computeUiPlanGate` uses),
+ *       probed only for a frontend phase that changed UI files (#5646).
+ *
+ * `block = frontend && hasUiFiles && hasFrontendEvidence && !hasUiSpec`.
  */
 function computeUiSafetyGate(projectDir, phase) {
     // (a) phase section text (same two-pass lookup as computeUiPlanGate)
@@ -43,14 +48,27 @@ function computeUiSafetyGate(projectDir, phase) {
     // (c) any UI files in the phase's own commits? (deleted paths count: a removed component is a UI change)
     const scope = (0, gate_evaluation_scope_cjs_1.resolveEvaluationScope)(projectDir, { kind: 'phase', phase });
     const hasUiFiles = scope.changedFiles.some((f) => f.trim() && (UI_FILE_EXTENSIONS_RE.test(f) || UI_PATH_PATTERNS_RE.test(f)));
+    // (c') #5646 — static structural corroboration, the same evidence `computeUiPlanGate` requires (#3312):
+    // `hasUiFiles` is a weak signal (an `.html` fixture, or any file under a `ui/` directory in any
+    // language), so on its own it halted projects with no frontend that the plan gate had cleared. Only
+    // probed when it could change the answer. `unreadable` (#5170) is a manifest or tree the probe could
+    // not look at: absence of evidence is then not established, and the verdict says so (below).
+    const frontendEvidence = frontend && hasUiFiles ? (0, ui_frontend_evidence_cjs_1.readStaticFrontendEvidence)(projectDir) : (0, gate_evidence_cjs_1.evidenceNone)();
+    const hasFrontendEvidence = frontendEvidence.kind === 'found';
     // (d) phase directory and *-UI-SPEC.md
     // `none` is "no spec"; `unreadable` is "could not look" (#5170) and is carried to the verdict.
     const uiSpec = (0, gate_phase_context_cjs_1.locateUiSpec)(projectDir, phase);
     const hasUiSpec = uiSpec.kind === 'found';
-    const readError = roadmapReadError ?? (uiSpec.kind === 'unreadable' ? uiSpec.reason : undefined);
-    // block only when: this is a frontend phase AND UI files were changed AND no UI-SPEC exists
-    const block = frontend && hasUiFiles && !hasUiSpec;
-    const result = { frontend, hasUiFiles, hasUiSpec, block };
+    // Unreadable frontend evidence only matters when it could flip the verdict: with a UI-SPEC present the
+    // gate does not block whatever the tree holds.
+    const frontendReadError = frontendEvidence.kind === 'unreadable' && !hasUiSpec
+        ? `static frontend evidence could not be read (${frontendEvidence.reason})`
+        : undefined;
+    const readError = roadmapReadError ?? (uiSpec.kind === 'unreadable' ? uiSpec.reason : undefined) ?? frontendReadError;
+    // block only when: this is a frontend phase AND UI files were changed AND the project has static
+    // frontend evidence AND no UI-SPEC exists
+    const block = frontend && hasUiFiles && hasFrontendEvidence && !hasUiSpec;
+    const result = { frontend, hasUiFiles, hasFrontendEvidence, hasUiSpec, block };
     if (block) {
         result.message = `UI files changed in this wave but no UI-SPEC.md exists for Phase ${phase}. ` +
             `Run ${(0, runtime_slash_cjs_1.runtimeCommand)(projectDir, `ui-phase ${phase}`)} to generate the design contract before continuing.`;

package/gsd-core/bin/lib/git-info-exclude.cjs

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * Keep a machine-local file out of `git status` without touching any tracked
+ * file: append an anchored entry to the enclosing repo's `info/exclude` (#5551).
+ *
+ * Used for files GSD writes under `.planning/` that are per-machine state, not
+ * project content (the milestone claim). A copy that is already tracked is left
+ * alone — an exclude entry never untracks, and migrating it is the user's call.
+ *
+ * Best-effort by contract: never throws. Ignoring is optional, so no failure
+ * here (no git, read-only `.git`, odd path) may perturb the caller.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.excludeFromGit = excludeFromGit;
+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");
+const text_lines_cjs_1 = require("./text-lines.cjs");
+/** Escape gitignore metacharacters so a directory or file name matches literally. */
+function escapeGitignore(s) {
+    return s.replace(/[\\*?[]/g, '\\$&');
+}
+/**
+ * Exclude `<dir>/<filename>` from git via the repo-local `info/exclude`.
+ * `dir` must already exist (it is the spawn cwd).
+ */
+function excludeFromGit(dir, filename) {
+    try {
+        // gitignore cannot express a newline in a pattern, and git's line output could not be split.
+        if (/[\r\n]/.test(dir))
+            return;
+        // cwd must pick the repo: drop inherited repository-location variables (e.g. inside a git hook).
+        const env = { GIT_DIR: undefined, GIT_WORK_TREE: undefined, GIT_INDEX_FILE: undefined, GIT_COMMON_DIR: undefined };
+        // The prefix goes last: stdout is trimmed, and a non-empty prefix ends in `/`, so only an
+        // empty prefix (dir is the git root) loses its line; a leading space survives.
+        const revParse = (0, shell_command_projection_cjs_1.execGit)(['rev-parse', '--git-path', 'info/exclude', '--show-prefix'], {
+            cwd: dir,
+            env: env,
+        });
+        const [excludeRel, prefix = ''] = (0, text_lines_cjs_1.splitLines)(String(revParse.stdout));
+        if (revParse.exitCode !== 0 || !excludeRel)
+            return;
+        const exclude = node_path_1.default.resolve(dir, excludeRel);
+        const entry = `/${escapeGitignore(prefix)}${escapeGitignore(filename)}`;
+        const existing = node_fs_1.default.existsSync(exclude) ? node_fs_1.default.readFileSync(exclude, 'utf8') : '';
+        if ((0, text_lines_cjs_1.splitLines)(existing).includes(entry))
+            return;
+        node_fs_1.default.mkdirSync(node_path_1.default.dirname(exclude), { recursive: true });
+        node_fs_1.default.appendFileSync(exclude, (existing && !existing.endsWith('\n') ? '\n' : '') + entry + '\n');
+    }
+    catch {
+        // advisory: see the module header.
+    }
+}

package/gsd-core/bin/lib/health-diagnostic-rules/phase-structure.cjs

@@ -42,7 +42,7 @@
  */
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const healthDiagnosticMod = require("../health-diagnostic-types.cjs");
-const { SEVERITY, adviseRemedy } = healthDiagnosticMod;
+const { SEVERITY, REMEDY_ACTION, REMEDY_RISK, adviseRemedy } = healthDiagnosticMod;
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const validateMod = require("../validate.cjs");
 // #612: `isPhaseDirName` is the convention-SELECTED shape test wrapping
@@ -57,6 +57,9 @@ const phaseIdMod = require("../phase-id.cjs");
 const { extractPhaseToken, normalizePhaseName, comparePhaseNum } = phaseIdMod;
 // #5060: the Phase Status Module owns the status-label ladder.
 const phase_status_cjs_1 = require("../phase-status.cjs");
+// #5291: W030 asks whether a raw report status has a known repair. The lookup is
+// a pure read of a frozen table, so `check` stays free of ambient I/O (§8.1 rule 1).
+const verification_cjs_1 = require("../verification.cjs");
 // ─── W005 — phase directory doesn't follow NN-name format (verify.cts:1893-1902) ─
 function checkW005(snapshot) {
     const diagnostics = [];
@@ -174,11 +177,21 @@ function checkW030(snapshot) {
         const invalid = phase.verificationStatusError;
         if (!invalid)
             continue;
+        // #5291: a KNOWN legacy status is repairable (rewritten to its closed-set
+        // equivalent, original kept in `legacy_status`); any other value has no
+        // mapping and keeps the advise-only remedy — it stays refused.
+        const target = (0, verification_cjs_1.legacyStatusRepairTarget)(invalid.rawStatus);
         diagnostics.push({
             code: 'W030',
             severity: SEVERITY.WARNING,
             message: `Phase ${phase.dir}: ${invalid.message}`,
-            remedy: adviseRemedy('Set the report frontmatter `status` to one of passed | gaps_found | human_needed, or delete the report and re-run the phase verification'),
+            remedy: target === null
+                ? adviseRemedy('Set the report frontmatter `status` to one of passed | gaps_found | human_needed, or delete the report and re-run the phase verification')
+                : {
+                    action: REMEDY_ACTION.REPAIR_VERIFICATION_STATUS,
+                    risk: REMEDY_RISK.NONE,
+                    args: { file: invalid.file, from: invalid.rawStatus, to: target },
+                },
         });
     }
     return diagnostics;
@@ -217,7 +230,9 @@ const RULES = [
         code: 'W030',
         severity: SEVERITY.WARNING,
         description: 'Phase verification report status is outside the closed set',
-        repairable: false,
+        // #5291: repairable per finding — a KNOWN legacy status (`pass_with_caveats`)
+        // is rewritten by `--repair`; any other value stays advise-only.
+        repairable: true,
         check: checkW030,
     },
 ];

package/gsd-core/bin/lib/health-diagnostic-types.cjs

@@ -38,6 +38,10 @@ const REMEDY_ACTION = Object.freeze({
     ADD_NYQUIST_KEY: 'addNyquistKey',
     ADD_AI_INTEGRATION_PHASE_KEY: 'addAiIntegrationPhaseKey',
     BACKFILL_MILESTONES: 'backfillMilestones',
+    // #5291: rewrite a KNOWN legacy verification `status` (W030) to its closed-set
+    // equivalent, keeping the original in `legacy_status`. Per-finding: only
+    // emitted when the raw value has a mapping; every other W030 stays ADVISE.
+    REPAIR_VERIFICATION_STATUS: 'repairVerificationStatus',
     // §8.3 rule 5 — every non-repairable finding's `fix` string becomes an
     // ADVISE payload; ADVISE never acts, only describes.
     ADVISE: 'advise',

package/gsd-core/bin/lib/health-diagnostic.cjs

@@ -118,6 +118,9 @@ const { getMilestoneInfo } = roadmapParserMod;
 const stateMod = require("./state.cjs");
 const { writeStateMd, assertVerificationReportsReadable } = stateMod;
 // eslint-disable-next-line @typescript-eslint/no-require-imports
+const verificationMod = require("./verification.cjs");
+const { repairLegacyVerificationStatus } = verificationMod;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
 const frontmatter = require("./frontmatter.cjs");
 const { extractFrontmatter } = frontmatter;
 // eslint-disable-next-line @typescript-eslint/no-require-imports
@@ -252,9 +255,27 @@ function computeMissingMilestoneVersions(milestonesArchiveDir, milestonesPath) {
  * shape, collapsed to one seam here since every case now shares one
  * caller).
  */
-function runRepairAction(cwd, action, paths) {
+function runRepairAction(cwd, action, paths, args = {}) {
     const { rootBase, configPath, statePath, milestonesPath, milestonesArchiveDir } = paths;
     switch (action) {
+        case REMEDY_ACTION.REPAIR_VERIFICATION_STATUS: {
+            // #5291: the report path comes from the finding's own remedy args, not
+            // from user input; `repairLegacyVerificationStatus` re-verifies that it is
+            // a report contained in its phase directory before it writes a byte.
+            const file = typeof args['file'] === 'string' ? args['file'] : '';
+            if (file === '')
+                return { success: false, error: 'no report path on the finding' };
+            const repaired = repairLegacyVerificationStatus(file);
+            if (!repaired.ok)
+                return { success: false, error: repaired.reason };
+            return {
+                success: true,
+                path: node_path_1.default.relative(cwd, file).split(node_path_1.default.sep).join('/'),
+                detail: repaired.legacyStatusKept
+                    ? `status ${repaired.from} -> ${repaired.to}; the report's existing legacy_status was left as it was`
+                    : `status ${repaired.from} -> ${repaired.to}; original kept as legacy_status`,
+            };
+        }
         case REMEDY_ACTION.CREATE_CONFIG:
         case REMEDY_ACTION.RESET_CONFIG: {
             (0, shell_command_projection_cjs_1.platformWriteSync)(configPath, JSON.stringify(defaultConfigPayload(), null, 2));
@@ -390,6 +411,34 @@ function applyRepairs(cwd, diagnostics, repair, backfill) {
     const refused = [];
     const details = [];
     const paths = repairPaths(cwd);
+    // #5291: a legacy-status repair is the CURE for the refusal the pre-check
+    // below enforces, so it runs first (a report edit is its only write and it
+    // validates its own target); the pre-check then sees the repaired reports.
+    const statusRepairs = new Set();
+    if (repair) {
+        for (const diagnostic of diagnostics) {
+            const { remedy, code } = diagnostic;
+            if (remedy.action !== REMEDY_ACTION.REPAIR_VERIFICATION_STATUS || remedy.risk === REMEDY_RISK.DESTRUCTIVE)
+                continue;
+            statusRepairs.add(diagnostic);
+            try {
+                const outcome = runRepairAction(cwd, remedy.action, paths, remedy.args);
+                details.push({
+                    code,
+                    action: remedy.action,
+                    success: outcome.success,
+                    ...(outcome.path ? { path: outcome.path } : {}),
+                    ...(outcome.detail ? { detail: outcome.detail } : {}),
+                    ...(outcome.error ? { error: outcome.error } : {}),
+                });
+                if (outcome.success)
+                    applied.push(code);
+            }
+            catch (err) {
+                details.push({ code, action: remedy.action, success: false, error: err instanceof Error ? err.message : String(err) });
+            }
+        }
+    }
     // #5118 (no write before the error): a requested REGENERATE_STATE rewrites
     // STATE.md from every phase's report and throws on one whose `status` is
     // outside the closed set — but other repairs in the SAME run (config,
@@ -411,6 +460,8 @@ function applyRepairs(cwd, diagnostics, repair, backfill) {
         const { remedy, code } = diagnostic;
         if (remedy.action === REMEDY_ACTION.ADVISE)
             continue;
+        if (statusRepairs.has(diagnostic))
+            continue;
         const requested = remedy.action === REMEDY_ACTION.BACKFILL_MILESTONES ? repair || backfill : repair;
         if (!requested)
             continue;

package/gsd-core/bin/lib/host-integration.cjs

@@ -620,7 +620,7 @@ function hookEventSurfaceFor(hookEvents) {
 // event subset (imperative hosts' extension API). They are not the same thing.
 //
 // Values are documentation-sourced (ADR-1239 §research): OpenCode ~25 plugin
-// events (session/tool/file/permission); pi ~30 fine-grained extension events;
+// events (session/tool/file/permission); pi 41 fine-grained extension events (pi 1.3.0);
 // 'none' = the host exposes no extension surface and the engine owns the bus
 // (VS Code). Declarative hosts (no plugin API) do not set `extensionEvents`.
 // OpenCode's plugin event surface (ADR-1239 §research; ~25 documented events,
@@ -655,11 +655,13 @@ const EXTENSION_EVENT_SURFACES = Object.freeze({
         'pre_gateway_dispatch', 'pre_approval_request',
         'transform_tool_result',
     ]),
-    // #2102 Stage 2 — pi's real ExtensionAPI event vocabulary (~30 fine-grained
-    // extension events; documentation-sourced, ADR-1239 §research). Replaces the
-    // placeholder single-event ['tool_call'] surface — the Stage 1 value only
-    // covered the one event pi/gsd.cjs happened to bind at the time, not the
-    // full declared surface.
+    // pi's real ExtensionAPI event vocabulary: the 41 `on(event: "...")` overloads
+    // declared by pi 1.3.0 (@earendil-works/pi-coding-agent
+    // dist/core/extensions/types.d.ts, sourceCommit 71023aec15, #5557). #2102
+    // Stage 2 declared the first 30 from pi.dev prose; the last 11 on the final
+    // row group were added when the host's own declarations were read. The
+    // pi.dev extensions page lists a lossy subset (it omits session_before_compact,
+    // which pi/gsd.cjs binds), so the type declarations are the source of truth.
     pi: Object.freeze([
         'session_start', 'project_trust', 'resources_discover', 'input',
         'before_agent_start', 'agent_start', 'message_start', 'message_update',
@@ -669,6 +671,11 @@ const EXTENSION_EVENT_SURFACES = Object.freeze({
         'session_before_switch', 'session_shutdown', 'session_before_fork',
         'session_info_changed', 'session_before_compact', 'session_compact',
         'session_before_tree', 'session_tree', 'thinking_level_select', 'model_select',
+        // Added in pi 1.3.0 (#5557):
+        'agent_before_settle', 'agent_settled', 'before_provider_headers',
+        'cache_warming_decision', 'context_with_system', 'mcp_servers_change',
+        'provider_stream_event', 'session_compact_failed', 'ui_prompt_end',
+        'ui_prompt_start', 'user_bash',
     ]),
     none: Object.freeze([]),
 });

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

@@ -20,6 +20,8 @@ const markdown_sectionizer_cjs_1 = require("./markdown-sectionizer.cjs");
 const io = require("./io.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports -- config-loader.cjs is an export= CommonJS module
 const configLoader = require("./config-loader.cjs");
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- capability-ledger.cjs is an export= CommonJS module
+const capabilityLedger = require("./capability-ledger.cjs");
 const project_root_cjs_1 = require("./project-root.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports -- model-resolver.cjs is an export= CommonJS module
 const modelResolver = require("./model-resolver.cjs");
@@ -96,7 +98,7 @@ const { getRoadmapPhaseInternal, getMilestoneInfo, stripShippedMilestones, extra
 const { pathExistsInternal, generateSlugInternal, toPosixPath } = coreUtils;
 const { comparePhaseNum, normalizePhaseName, stripProjectCodePrefix, PHASE_NUMBER_TOKEN_SOURCE, PHASE_DEP_REF_SOURCE, isForeignPrefixedPhaseQuery, isSentinelPhaseId, extractPhaseToken, scopeToPhase, renderPhaseBranchName, parsePhaseId, renderPhaseId, phaseHeadingPrefixSrcFor, PHASE_HEADING_BASELINE, buildPhaseHeadingScanRegex, } = phaseId;
 const { pruneOrphanedWorktrees } = worktreeSafety;
-const { planningPaths, planningDir, planningRoot, todosDir, listAvailableWorkstreams, peekActiveWorkstream, resolveEnvWorkstream, diagnoseUnresolvedActiveWorkstream, describeUnresolvedWorkstreamReason, findContextMdIn, resolvePhaseIdConvention, worktreesOptedOut, } = planningWorkspace;
+const { planningPaths, planningDir, planningRoot, todosDir, listAvailableWorkstreams, peekActiveWorkstream, resolveEnvWorkstream, diagnoseUnresolvedActiveWorkstream, describeUnresolvedWorkstreamReason, findContextMdIn, findPhaseSpecIn, resolvePhaseIdConvention, worktreesOptedOut, } = planningWorkspace;
 const { extractFrontmatter, frontmatterBlock } = frontmatterMod;
 const { isPhaseComplete, resolveVerificationFile, resolveUatFile, VERIFICATION_STATUS, VerificationStatusError } = verificationMod;
 const { evaluateUatPassed } = uatPredicateMod;
@@ -175,6 +177,28 @@ function resolvePhaseDisplayName(phaseInfo, roadmapPhase) {
         || phaseInfo?.['phase_name']
         || null;
 }
+/**
+ * #5629: the phase SPEC as init facts, for every init payload a SPEC-consuming workflow parses
+ * (discuss-phase via `phase-op`, discuss-phase-assumptions, plan-phase). `has_spec` is always present;
+ * `spec_path` (absolute, posix) only when a plain `NN-SPEC.md` exists. One predicate (`findPhaseSpecIn`, shared
+ * with the context-drift gate) decides, so a UI-SPEC or AI-SPEC is never mistaken for the requirements lock and
+ * no workflow globs for it. A phase with no directory yet, or one that cannot be read, has no SPEC.
+ */
+function phaseSpecFacts(phaseDirAbs) {
+    if (!phaseDirAbs)
+        return { has_spec: false };
+    let files;
+    try {
+        files = node_fs_1.default.readdirSync(phaseDirAbs);
+    }
+    catch {
+        return { has_spec: false };
+    }
+    // Scoped to THIS phase's own artifacts first (#3511), like the sibling artifact lookups: a misfiled
+    // `02-SPEC.md` in phase 03's directory must not win (the context-drift gate scopes the same way).
+    const spec = findPhaseSpecIn(scopeToPhase(files, node_path_1.default.basename(phaseDirAbs)));
+    return spec ? { has_spec: true, spec_path: toPosixPath(node_path_1.default.join(phaseDirAbs, spec)) } : { has_spec: false };
+}
 /**
  * #2994 (review finding, DEFECT.GENERATIVE-FIX): shared archived/not-found
  * fallback applied identically by `cmdInitExecutePhase`, `cmdInitPlanPhase`,
@@ -598,6 +622,28 @@ function detectFallowConfig(cwd) {
 function detectGitCreateTag(cwd) {
     return readConfigJsonValue(cwd, ['git', 'create_tag']) !== false;
 }
+/**
+ * `git.repo_tagging` ground truth (#5706, epic #3628): the milestone tagging
+ * mode exposed to `complete-milestone.md`. Only the documented `per_repo`
+ * opts in; an absent key or any other stored value reads as the default
+ * `single` (today's behavior), matching `loadConfig`'s resolution.
+ */
+function detectRepoTagging(cwd) {
+    return readConfigJsonValue(cwd, ['git', 'repo_tagging']) === 'per_repo' ? 'per_repo' : 'single';
+}
+/**
+ * The configured `planning.sub_repos` (#5706): an array of non-empty repo
+ * names, possibly empty. A legacy top-level `sub_repos` is honored when the
+ * nested key is absent, the same flat-then-nested order `loadConfig` applies.
+ * Non-string members are dropped; any degraded read yields `[]`.
+ */
+function detectSubRepos(cwd) {
+    const nested = readConfigJsonValue(cwd, ['planning', 'sub_repos']);
+    const raw = nested !== undefined ? nested : readConfigJsonValue(cwd, ['sub_repos']);
+    if (!Array.isArray(raw))
+        return [];
+    return raw.filter((name) => typeof name === 'string' && name.trim() !== '');
+}
 /**
  * `state:phase-mvp-mode` ground truth (design doc §Behavior table: ROADMAP.md
  * `**Mode:** mvp` for the CURRENT phase). Bounded, non-throwing — an absent
@@ -1137,6 +1183,8 @@ function cmdInitPlanPhase(cwd, phase, raw, options = {}) {
         state_path: node_fs_1.default.existsSync(statePath) ? toPosixPath(statePath) : null,
         roadmap_path: node_fs_1.default.existsSync(roadmapPath) ? toPosixPath(roadmapPath) : null,
         requirements_path: node_fs_1.default.existsSync(requirementsPath) ? toPosixPath(requirementsPath) : null,
+        // #5629: the phase SPEC (plan-phase lifts its Edge Coverage from it; no workflow globs for it).
+        ...phaseSpecFacts(phaseInfo?.['directory'] ? node_path_1.default.join(cwd, phaseInfo['directory']) : null),
         patterns_path: null,
     };
     if (phaseInfo?.['directory']) {
@@ -1932,6 +1980,8 @@ function cmdInitDiscussPhaseAssumptions(cwd, phase, raw, options = {}) {
         plan_count: phaseInfo?.['plans']?.length || 0,
         roadmap_exists: node_fs_1.default.existsSync(node_path_1.default.join(planningDir(cwd), 'ROADMAP.md')),
         planning_exists: node_fs_1.default.existsSync(planningDir(cwd)),
+        // #5629: the phase SPEC, so assumptions mode honours it like the default flow does.
+        ...phaseSpecFacts(phaseDir ? node_path_1.default.join(cwd, phaseDir) : null),
     };
     // #2994 (Phase 6.3): additive, optional field — degrades to null, never throws.
     const sectionManifestOptions = {
@@ -2063,6 +2113,8 @@ function cmdInitPhaseOp(cwd, phase, raw) {
         state_path: node_fs_1.default.existsSync(statePath) ? toPosixPath(statePath) : null,
         roadmap_path: node_fs_1.default.existsSync(roadmapPath) ? toPosixPath(roadmapPath) : null,
         requirements_path: node_fs_1.default.existsSync(requirementsPath) ? toPosixPath(requirementsPath) : null,
+        // #5629: the phase SPEC (discuss-phase reads it from here; no workflow globs for it).
+        ...phaseSpecFacts(phaseDir ? node_path_1.default.join(cwd, phaseDir) : null),
     };
     if (phaseInfo?.['directory']) {
         const phaseDirFull = node_path_1.default.join(cwd, phaseInfo['directory']);
@@ -3014,9 +3066,23 @@ function cmdInitCompleteMilestone(cwd, raw, options = {}) {
         milestones_path: node_fs_1.default.existsSync(milestonesPath) ? toPosixPath(milestonesPath) : null,
         project_path: node_fs_1.default.existsSync(projectPath) ? toPosixPath(projectPath) : null,
         requirements_path: node_fs_1.default.existsSync(requirementsPath) ? toPosixPath(requirementsPath) : null,
+        // #5706 (epic #3628): the repositories configured for this project and the
+        // milestone tagging mode, so the workflow reads both from one init call.
+        sub_repos: detectSubRepos(cwd),
+        repo_tagging: detectRepoTagging(cwd),
     };
+    // #5195: `state:flat-mode` gates the PROJECT.md evolution review. PROJECT.md
+    // is shared across workstreams (the `projectPath` comment above), so a
+    // workstream's milestone close must not rewrite or stage it — the same
+    // decision `cmdInitNewMilestone` applies to its Part A (#2308), resolved from
+    // the same authority (`GSD_WORKSTREAM` env, else the stored pointer) so the
+    // gate cannot disagree with the workstream-scoped paths returned above.
+    // Read-only peek: no self-heal side effect from building a report field (#3579).
+    const workstreamActive = !!(resolveEnvWorkstream() ?? peekActiveWorkstream(cwd));
     result['section_manifest'] = buildSectionManifestField(cwd, null, options, 'complete-milestone', {
         gitCreateTag,
+        workstreamActive,
+        flatMode: !workstreamActive,
     });
     output(withProjectRoot(cwd, result), raw);
 }
@@ -3773,7 +3839,7 @@ function buildAgentSkillsBlock(config, agentType, projectRoot, diagnostics) {
     }).join('\n');
     return `<agent_skills>\nRead these user-configured skills:\n${lines}\n</agent_skills>`;
 }
-function cmdAgentSkills(cwd, agentType, raw, jsonMode) {
+function cmdAgentSkills(cwd, agentType, raw, jsonMode, skillsOnly = false) {
     if (!agentType) {
         output('', raw, '');
         return;
@@ -3804,8 +3870,13 @@ function cmdAgentSkills(cwd, agentType, raw, jsonMode) {
     // (a real exit code) instead of a prose config-get gate. Compact is tried
     // first when requested; a missing compact sibling falls back to canonical
     // with the fallback disclosed in the payload itself, never a silent switch.
+    //
+    // #5122: `skillsOnly` (the CLI's `--skills-only`) is the agent's own
+    // self-load. It wants configured skills and nothing else, so it skips the
+    // fallback on every runtime — otherwise a non-Claude agent reads its own
+    // persona back into itself as if it were a skills block.
     let agentPayloadVariant = null;
-    if (!block) {
+    if (!block && !skillsOnly) {
         const runtime = (config && config['runtime']) || process.env['GSD_RUNTIME'] || 'claude';
         if (runtime !== 'claude') {
             const agentCheck = checkAgentsInstalled(runtime, projectRoot);
@@ -4071,7 +4142,7 @@ function buildSkillManifest(cwd, skillsDir = null) {
             if (!entry.isDirectory())
                 continue;
             const skillMdPath = node_path_1.default.join(rootPath, entry.name, 'SKILL.md');
-            const content = (0, shell_command_projection_cjs_1.platformReadSync)(skillMdPath);
+            const content = capabilityLedger.readSkillFile(skillMdPath);
             if (content !== null) {
                 if (pushSkillEntry(`${entry.name}/SKILL.md`, content, skillMdPath))
                     skillCount++;
@@ -4096,7 +4167,7 @@ function buildSkillManifest(cwd, skillsDir = null) {
                 if (!nested.isDirectory())
                     continue;
                 const nestedSkillMd = node_path_1.default.join(nestedSkillsDir, nested.name, 'SKILL.md');
-                const nestedContent = (0, shell_command_projection_cjs_1.platformReadSync)(nestedSkillMd);
+                const nestedContent = capabilityLedger.readSkillFile(nestedSkillMd);
                 if (nestedContent === null)
                     continue;
                 // Use forward-slash separator explicitly so manifest paths are posix-style

package/gsd-core/bin/lib/install-effort-resolver.cjs

@@ -35,7 +35,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
  */
 const node_fs_1 = __importDefault(require("node:fs"));
 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 -- install-fs-adapter.cjs is an export= CommonJS module
 const installFsAdapter = require("./install-fs-adapter.cjs");
 const { installFs } = installFsAdapter;
@@ -154,7 +154,7 @@ function _findAncestorGsdConfigPath(targetDir) {
  * @param targetDir  Runtime install root (walks up to find .planning/).
  */
 function readGsdEffectiveEffortConfig(targetDir = null) {
-    const homeDefaults = _readGsdConfigFile(node_path_1.default.join(node_os_1.default.homedir(), '.gsd', 'defaults.json'), '~/.gsd/defaults.json');
+    const homeDefaults = _readGsdConfigFile(node_path_1.default.join((0, runtime_homes_cjs_1.resolveGsdHome)(), '.gsd', 'defaults.json'), '~/.gsd/defaults.json');
     let projectConfig = null;
     if (targetDir) {
         const candidate = _findAncestorGsdConfigPath(targetDir);