feat(#1169): complete ADR-857 phase 6 — migrate features to Capabilities, revive dead gates, harden conformance gate (#1183)
* test(#1168): make phase-6 gate un-gameable — reject empty stubs + require loop shrink The migration assertion previously checked only role==feature, so a registration-only stub (empty hooks, logic left inline) would turn the gate green while phase 6 stayed incomplete — the exact false-completion pattern this gate exists to prevent. Strengthen it: each ADR-named feature must OWN its behavior (>=1 hook, or a command family); and plan-phase.md/execute-phase.md must shrink strictly below their frozen pre-phase-6 sizes (94519/93166 LF bytes), which also defeats double-run gaming (declare a hook but keep the inline block -> file does not shrink -> red). Gate now 5 pass / 4 fail (orphaned execute:wave:post, empty/unregistered features, config-key leaks, no shrink). Green is now reachable only by REAL migration. Refs #1168, #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * feat(#1169): migrate gap-analysis to a Capability (plan:post gate) First real ADR-857 phase-6 migration (pattern-defining tracer). gap-analysis moves from an inline post_planning_gaps branch in plan-phase.md to a real plan:post gate Capability: - capabilities/gap-analysis/capability.json: role:feature, plan:post gate (when=workflow.post_planning_gaps, blocking:false advisory), OWNS workflow.post_planning_gaps (federated out of central schema). - plan-phase.md: inline config-get + gsd_run gap-analysis block replaced with a plan:post render-hooks call site dispatching the gate; file shrinks 94519->93279. - src/check-command-router.cts: cmdGapAnalysisPlanPost runs the real gap analysis via gap-checker. - post_planning_gaps removed from central manifest; resolves via federated config (default true preserved). - tests/post-planning-gaps-2493: re-pointed to assert capability ownership. Verified: gate 5 pass / 4 fail (gap-analysis cleared from migration, plan:post-orphan, config-leak, and plan-phase shrink checks); loadConfig still returns post_planning_gaps=true; check command runs real analysis; 392/392 in the config/registry/federation/router net. Refs #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * feat(#1169): migrate profile-pipeline to a command-family Capability ADR-857 Decision 7: profile-pipeline becomes a command-family Capability (like audit/intel/graphify). capabilities/profile-pipeline/capability.json declares an 8-command family (scan-sessions, extract-messages, profile-sample, write-profile, profile-questionnaire, generate-dev-preferences, generate-claude-profile, generate-claude-md) backed by a new gsd-core/bin/lib/profile-pipeline-command-router.cjs; the inline case arms are removed from gsd-tools.cjs. Owns profile-pipeline.enabled (federated). Verified: registry shows role:feature with commands.length=8; scan-sessions/profile-sample run live via the family; gate cleared profile-pipeline from the empty-stub failure (only tdd/schema-gate/drift remain); 296/296 registry+inventory+gsd-tools tests; lint 0 errors. Refs #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * fix(#1167): wire execute:wave:post + implement ui.safety-gate check Revives the second dead gate from #1167: ui.gates@execute:wave:post was declared but never dispatched AND its check.query (ui.safety-gate) was unimplemented. Adds the per-wave execute:wave:post render-hooks call site in execute-phase.md (fires after each wave's merge/cleanup, before the next forks) and implements cmdUiSafetyGate (frontend + UI-SPEC aware, mirrors cmdUiPlanGate) in check-command-router. +17 regression tests. Verified: phase-6 orphaned-points conformance test now PASSES (gate 6 pass / 3 fail); ui-safety-gate routable in dot+hyphen forms; check-ui-safety-gate 17/17, check-ui-plan-gate 18/18; lint 0 errors. Refs #1167, #1168. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * feat(#1169): migrate drift (schema + codebase) to execute:wave:post gates Removes the inline schema_drift_gate + codebase_drift_gate steps (77 lines) from execute-phase.md; drift becomes a Capability with two execute:wave:post gates (verify.schema-drift blocking, verify.codebase-drift advisory) dispatched via the per-wave render-hooks call site. check-command-router routes verify.schema-drift / verify.codebase-drift to the real detectors. Federates workflow.drift_threshold / drift_action / schema_drift_gate out of central. Also fixes the execute:wave:post dispatch prose to run NON-blocking (advisory) gates too — the prior version only ran blocking gates, which would have silently dropped the codebase-drift advisory after its inline step was removed. Behavior preserved. Verified: gate 7 pass / 2 fail (drift cleared from stub + config-leak; execute-phase.md 92297 < 93166 frozen -> shrink passes); both drift checks run real detection; loadConfig defaults preserved (threshold=3, action=warn, gate=true); drift-detection 56/56 + schema-drift 34/34; lint 0 errors. Refs #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * feat(#1169): migrate tdd to a Capability (plan:pre contribution + execute:post gate) tdd becomes a real Capability: a plan:pre contribution injects the <tdd_mode_active> planner guidance (rendered from PLAN_PRE_HOOKS_JSON like security's contribution), and an execute:post gate (tdd.review-checkpoint, advisory) runs the real end-of-phase RED/GREEN review via a new check-command handler. Inline tdd_mode reads + the inline planner block + the tdd_review_checkpoint step are removed; workflow.tdd_mode is federated out of central. The MVP+TDD per-task RED-commit gate is preserved — TDD_MODE is now derived from the execute:post hooks (capId==tdd active), not an inline config-get. BEHAVIOR CHANGE (documented, not silent): the --tdd CLI flag now persists workflow.tdd_mode=true via config-set instead of being per-invocation. Rationale: tdd is now a config-toggled Capability, and env vars do not persist across the workflow's separate bash blocks (config does), so an ephemeral override isn't cleanly achievable; --tdd therefore enables the tdd capability, consistent with how all capabilities are toggled. Verified: gate 7 pass / 2 fail (tdd cleared from stub + config-leak; plan-phase + execute-phase both < frozen sizes); contribution injection + execute:post gate dispatch wired; MVP+TDD gate preserved; tdd.review-checkpoint runs real review; full unit suite 556/0; lint 0 errors. Refs #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * feat(#1169): migrate schema-gate to a plan:pre contribution Capability The plan-time schema-push detection (former plan-phase.md §5.7) becomes a schema-gate Capability: a plan:pre contribution (into:planner, when:workflow.schema_push_detection) whose fragment carries the full ORM-detection + [BLOCKING] schema-push-task injection logic, rendered into the planner via the existing plan:pre render-hooks dispatch. The inline §5.7 block is removed (plan-phase.md 94519->90445). workflow.schema_push_detection is a new capability-owned (federated) key, default true. (The execute-side schema-drift gate was migrated separately into the drift capability.) Verified: registry inlines the fragment (len 2704) so it is actually delivered at plan:pre; gate 8 pass / 1 fail — all 5 ADR-named features now real Capabilities, only the config-leak test remains (intel/security, next unit). Refs #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * feat(#1169): close the 3 capability config-key leaks — phase-6 gate now GREEN Removes the last inline config-get reads of capability-owned keys from plan-phase.md. security_asvs_level/security_block_on now flow through the security plan:pre contribution via a new loop-resolver configValues mechanism (resolves declared config keys with the same 4-level precedence as activation and attaches them to the rendered hook); the §5.55 banner reads them from PLAN_PRE_HOOKS_JSON. intel.enabled becomes a real intel plan:pre step (ref.command: intel api-surface) dispatched via render-hooks; the inline intel branch is gone. gen-capability-registry now validates ref.command as a third dispatch shape. Verified: phase-6 capstone conformance gate is FULLY GREEN (9/0); 3 leaks gone (grep=0); security configValues resolve to {2,medium}/default {1,high}; intel step present only when enabled; loop-render-hooks 62/0, capability-registry 287/0, capability-state/federated-config 113/0; lint 0 errors. Closes the migration half of #1169. Refs #1139, #1167, #1168. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * fix(#1169): address adversarial review — restore schema-drift block, generic planner injection, uniform gate contract Adversarial review caught 2 real regressions the green gate missed: (1) schema-drift no longer blocked — the execute:wave:post dispatch read GATE_RESULT.block but verify.schema-drift emitted drift_detected/blocking, and onError:skip wrongly bypassed positive blocks; (2) only tdd's plan:pre contribution was injected into the planner, dropping schema-gate's schema-push detection and security's threat-model guidance. Fixes: (A) every gate check returns a uniform boolean 'block' under --raw (the dispatch form), with advisory gates (tdd/gap) carrying their report in 'message'; (B) gate-dispatch contract corrected at all sites — onError governs command errors only, a blocking gate's positive block always halts; (C) generic planner injection of all plan:pre contributions where into=='planner' (tdd + schema-gate + security incl configValues); (D) two new conformance assertions: planner contributions injected generically + every gate check.query returns boolean block under --raw. Verified: gate 11/11; all 6 gate checks return boolean block under --raw; full suite 595/0; lint 0 errors. Refs #1167, #1168, #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * fix(#1169): restore MVP+TDD end-of-phase blocking escalation (2nd adversarial pass) The migrated tdd execute:post gate is statically blocking:false, but the contract (references/execute-mvp-tdd.md + CONTEXT.md) requires the end-of-phase TDD review to ESCALATE from advisory to blocking when MVP_MODE && TDD_MODE && a TDD plan misses a RED/GREEN commit. The migration prose had downgraded this to a 'strong advisory recommendation' — silent loss of the blocking escalation. Restore it: the tdd-gate dispatch now refuses to mark the phase complete (Phase blocked message) under MVP+TDD when GATE_RESULT.block is true; advisory otherwise. Also strengthen tests/execute-mvp-tdd-gate.test.cjs: hasBlockingEscalation previously matched any line with 'blocking'+'mvp+tdd' (so 'advisory (blocking: false) ... under MVP+TDD' was a false green); now it requires the real refusal semantics ('refuse to mark the phase complete' / 'phase blocked'). Caught by 2nd adversarial review pass. Verified: execute-phase.md 92702 < 93166 frozen; mvp-tdd-gate + phase-6 gate 19/0; full suite green; lint 0 errors. Refs #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * fix(#1169): restore MVP+TDD proceed-block, codebase auto-remap, schema skip-flag (3rd adversarial pass) 3rd adversarial pass found 4 more silent regressions: (1) the tdd MVP+TDD 'refuse to mark complete' was nullified by a downstream 'ALWAYS proceed regardless of gate results' line — proceed is now conditional (stops on an active MVP+TDD block); (2) the test now asserts the proceed is NOT an unconditional override; (3) codebase-drift auto-remap (spawn gsd-codebase-mapper when drift_action=auto-remap) was dropped — the execute:wave:post advisory dispatch now consumes spawn_mapper/directive; (4) GSD_SKIP_SCHEMA_CHECK bypass was lost from the gate path — cmdVerifySchemaDrift now honors the env var (block:false when set). Verified: no unconditional proceed; GSD_SKIP_SCHEMA_CHECK=true -> block:false; gate 11/11 + mvp-tdd 9/9; full suite 569/0; lint 0; execute-phase.md 93109 < 93166. Refs #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * fix(#1169): init.cts reads federated config keys from nested path (4th adversarial pass) Config federation moved tdd_mode/research/nyquist_validation from flat config.<key> to nested config.workflow.<key>, but src/init.cts still read them flat — so init.plan-phase/init.execute-phase emitted tdd_mode:false / research_enabled:undefined / nyquist:undefined regardless of config (a public command-contract regression; the migrated loops use render-hooks so enforcement was unaffected). Read via config.workflow (type-safe Record cast). Now init reflects the same resolved values + federated defaults (research/nyquist default true) as the render-hooks path. Verified: build clean; init.plan-phase emits tdd_mode:true/research:false/nyquist:false for set config, defaults true for empty; full suite 591/0; lint 0. Refs #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * docs(#1169): add changeset for ADR-857 phase-6 completion (PR #1183) Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * fix(#1169): complete phase-6 migration fallout — restore TEXT_MODE, fix registry .claude leak, re-point stale workflow-contract tests The capability migration left real regressions and stale consumer tests that the per-module unit suite missed but the full cross-platform suite caught (27 failing tests): Real source regressions (fixed): - execute-phase.md lost its AskUserQuestion TEXT_MODE plain-text fallback when the inline schema_drift_gate step was removed — non-Claude runtimes would stall. Restored, and the execute:post gate-dispatch prose de-duplicated to cite the execute:wave:post contract (loop body shrinks below the frozen pre-phase-6 ceiling while keeping every onError/blocking nuance). - capabilities/tdd inline fragment hardcoded `@~/.claude/gsd-core/references/tdd.md`, baked verbatim into the committed capability-registry.cjs and leaked the install path on 11 non-Claude runtimes (registry .cjs is copied, not path-converted). Made the fragment path-free; regenerated the registry. The phase-6 conformance gate now guards this (no ~/.claude install path in any capability source or the generated registry). - plan-phase.md: removed a §5.7 stub re-added in error and routed Branch 2 to step 6 (schema-gate is a plan:pre capability, §5.7 is gone). Stale workflow-contract tests re-pointed to the capability dispatch they now must assert (behavior verified preserved in source first, assertions kept equal-or-stronger): bug-621 + bug-2851 (gap-analysis via gsd_run render-hooks plan:post + registry binding), feat-2527 (tdd_mode federated out of central), phase6-planning + plan-phase-ui-redirect (§5.6 bounded by ## 6.), plan-phase-drift-guard (intel when:intel.enabled skip branch). profile-pipeline-command-router.cjs un-ignored from eslint (hand-written, no TS source) + stale disable comments removed. Size baseline regenerated. Verified: full suite 15140 tests / 0 fail; lint 0 errors; conformance gate green legitimately. Refs #1139, #1167, #1168, #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * test(#1169): add ADR-857 E2E content-test coverage for the 12 loop points + capability deliverables Grounds the capability engine in behavioral E2E tests (drive the real render-hooks/check CLI + the real registry, assert typed result content — no source-grep), structured around what ADR-857 says to deliver. 207 tests; each genuineness-checked (flip the expectation, confirm it fails). Per-loop-point dispatch (7 files): empty-point negative-space across the 6 no-hook points; verify:post 3-step resolution+ordering+onError; plan:pre contribution/configValues + ui.plan-gate + intel; plan:post gap-analysis; execute:wave:post drift+ui gates via the check route (schema-drift block/skip, codebase-drift threshold BVA, auto-remap); execute:post tdd.review-checkpoint RED/GREEN; ship:pre security gate resolution + frontmatter-get predicate pieces. ADR-deliverable coverage (4 files): predicate boundary held (edge/prohibition probes stay core, not off-by-default Feature Capabilities — phase-6 exception); core loop runs with zero capabilities (all 12 points empty, init bundles resolve); contribution merge (multiple ordered <contribution from=> blocks); federated-config key removal on uninstall. federated-config allowlisted for its 3-file split (unit + integration + lifecycle). Refs #1139, #1167, #1168, #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * fix(#1169): remove dead drifted converter dups + address adversarial review Lint cleanup (root-caused, not waved off): src/runtime-artifact-conversion.cts carried 11 agent-converter functions (+5 orphaned consts/helpers) that were never exported, never called, and had silently DRIFTED from the live hand-authored copies in bin/install.js (one even referenced an undefined `claudeToCopilotTools`). Deleted the dead duplicates; install.js's live copies are untouched (it never imported these). Lint now 0 errors / 0 warnings. Adversarial-review (Codex) findings fixed: - HIGH: execute-phase.md TDD_MODE used `jq ... || echo false`, silently disabling the MVP+TDD blocking gate on jq-less runtimes. Reverted to the `node -e` form (node is guaranteed; matches the file's other node-e usages) so a missing optional tool can no longer fail-open a blocking safety path. - MEDIUM: federated-config-key-removal orphan-key test was vacuous (it skipped the orphan assertion). Now asserts the removed capability's key is genuinely not surfaced/validated after uninstall. - LOW: phase-6 conformance leak regex broadened to catch absolute-home and Windows-backslash `.claude/(gsd-core|commands|agents|hooks)` paths, not only `~`/`$HOME` forward-slash forms. - LOW: bug-2851 plan:post dispatch assertion now requires `--raw` (matched its stated contract). - nit: plan-pre intel-step test duplicate assertion replaced with a distinct structured-output check. Size baseline regenerated (execute-phase.md 93089 < 93166 frozen). Refs #1167, #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * test(#1169): make runtime-homes-descriptor-drive titles environment-independent The descriptor-equivalence test embedded the absolute golden config path (`os.homedir()`-derived) directly in each `test(...)` title, so titles differed between macOS (`/Users/x/.claude`) and Docker (`/home/gsdtest/.claude`). Every test PASSES on both platforms (15885/0 leaf tests each), but gsd-test-summary compares results by title and reported 29+29 false "only in Mac / only in Docker" discrepancies for tests that actually pass everywhere. Move the golden path out of the title and into the assertion message (still shown on failure); titles are now byte-identical across platforms so the cross-platform comparator matches them. No assertion logic or golden values changed. Refs #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * fix(#1169): derive TDD_MODE via gsd_run --active-cap, not node -e (fix prompt-injection CI gate) The prior fix reverted execute-phase.md:181 from jq to `node -e` to close a Codex HIGH (jq||echo-false silently disabling the MVP+TDD blocking gate on jq-less runtimes) — but the CI prompt-injection scanner BLOCKS new `node -e` in workflow markdown (inline code-exec = injection vector), turning the security gate red. Both forms were wrong: node -e fails the scanner; jq fail-opens a blocking safety gate; `config-get workflow.tdd_mode` is forbidden by the conformance leak gate (tdd_mode is capability-owned). Correct fix (what Codex recommended): a gsd_run-native boolean. Add an `--active-cap <capId>` flag to `loop render-hooks <point>` that resolves hooks the normal way and prints exactly `true`/`false` for whether a capId is active — scanner-safe (canonical launcher, no inline code), node-reliable (no optional jq to fail-open), and leak-free (render-hooks resolution, not config-get). execute-phase.md:181 now `TDD_MODE=$(gsd_run loop render-hooks execute:post --active-cap tdd)`. +5 behavioral tests for the flag. Verified: prompt-injection-scan --diff origin/next → 0 findings; conformance gate 13/13 (execute-phase.md 92934 < 93166); execute-mvp-tdd + tdd-mode + loop-render-hooks 87/0; lint 0/0. Refs #1167, #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
Tom Boucher
@@ -16,8 +16,14 @@ import { parseDecisions } from './decisions.cjs';
|
||||
import type { Decision } from './decisions.cjs';
|
||||
import { checkUiPresence } from './ui-safety-gate.cjs';
|
||||
// eslint-disable-next-line @typescript-eslint/no-require-imports
|
||||
import verifyModule = require('./verify.cjs');
|
||||
const { cmdVerifySchemaDrift, cmdVerifyCodebaseDrift } = verifyModule;
|
||||
// eslint-disable-next-line @typescript-eslint/no-require-imports
|
||||
import roadmapModule = require('./roadmap.cjs');
|
||||
const { getRoadmapPhaseWithFallback } = roadmapModule;
|
||||
// eslint-disable-next-line @typescript-eslint/no-require-imports
|
||||
import gapCheckerModule = require('./gap-checker.cjs');
|
||||
const { runGapAnalysis } = gapCheckerModule;
|
||||
|
||||
// ─── Helpers ──────────────────────────────────────────────────────────────────
|
||||
|
||||
@@ -462,6 +468,367 @@ function cmdUiPlanGate(projectDir: string, args: string[], raw: boolean): void {
|
||||
output(computeUiPlanGate(projectDir, phase), raw, undefined);
|
||||
}
|
||||
|
||||
// ─── ui-safety-gate ───────────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* ui-safety-gate: post-wave check that verifies UI-changed files conform to
|
||||
* the active UI-SPEC for the phase. Called after each wave by execute:wave:post.
|
||||
*
|
||||
* Returns JSON: { frontend: boolean, hasUiFiles: boolean, hasUiSpec: boolean, block: boolean, message?: string }
|
||||
* block = frontend && hasUiFiles && !hasUiSpec
|
||||
*
|
||||
* Args: check ui-safety-gate <phase>
|
||||
* Invocable as: gsd_run check ui-safety-gate <phase>
|
||||
* or gsd_run check ui.safety-gate <phase> (dots normalized to hyphens)
|
||||
*
|
||||
* Uses checkUiPresence from ui-safety-gate.cjs — does NOT reimplement frontend detection.
|
||||
* Checks whether any files changed in recent git history match frontend file patterns.
|
||||
* Also checks whether a *-UI-SPEC.md exists in the phase directory (same as ui-plan-gate).
|
||||
*
|
||||
* Limitation: uses git diff HEAD~1..HEAD which covers only the last commit; in a
|
||||
* multi-plan wave the wave-start commit would be more accurate but is not yet stored
|
||||
* in the wave manifest. This is tracked as a known limitation.
|
||||
*/
|
||||
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;
|
||||
|
||||
/**
|
||||
* Pure logic for ui-safety-gate — exposed for direct behavioral testing.
|
||||
*
|
||||
* Given a projectDir and phase number:
|
||||
* (a) Reads the phase section from ROADMAP.md via getRoadmapPhaseWithFallback —
|
||||
* same lookup as computeUiPlanGate — to determine if this is a frontend phase.
|
||||
* (b) Runs checkUiPresence (frontend detection) — no reimplementation.
|
||||
* (c) Checks git diff HEAD~1..HEAD for UI file changes in the current worktree.
|
||||
* (d) Resolves the phase directory via core.findPhaseInternal; checks for *-UI-SPEC.md.
|
||||
*
|
||||
* Returns: { frontend, hasUiFiles, hasUiSpec, block, message?, phaseLookupFailed? }
|
||||
* block = frontend && hasUiFiles && !hasUiSpec
|
||||
* phaseLookupFailed = ROADMAP.md present but phase header not found
|
||||
*/
|
||||
function computeUiSafetyGate(projectDir: string, phase: string): {
|
||||
frontend: boolean;
|
||||
hasUiFiles: boolean;
|
||||
hasUiSpec: boolean;
|
||||
block: boolean;
|
||||
message?: string;
|
||||
phaseLookupFailed?: boolean;
|
||||
} {
|
||||
// (a) Read the phase section text (same two-pass lookup as computeUiPlanGate)
|
||||
let phaseSection = '';
|
||||
let phaseLookupFailed: boolean | undefined;
|
||||
try {
|
||||
const section = getRoadmapPhaseWithFallback(projectDir, phase);
|
||||
if (section === null) {
|
||||
const planDir: string = typeof (core as unknown as Record<string, unknown>)['planningDir'] === 'function'
|
||||
? (core as unknown as Record<string, (cwd: string) => string>)['planningDir'](projectDir)
|
||||
: path.join(projectDir, '.planning');
|
||||
const roadmapPath = path.join(planDir, 'ROADMAP.md');
|
||||
if (fs.existsSync(roadmapPath)) {
|
||||
phaseLookupFailed = true;
|
||||
}
|
||||
} else {
|
||||
phaseSection = section;
|
||||
}
|
||||
} catch { /* roadmap read failure → treat as empty (non-frontend) */ }
|
||||
|
||||
// (b) Run checkUiPresence (frontend detection) — reuse existing helper; no reimplementation
|
||||
const presenceResult = checkUiPresence(phaseSection);
|
||||
const frontend = presenceResult.hasUI;
|
||||
|
||||
// (c) Check whether any UI files were changed in recent git commits
|
||||
// Uses git diff HEAD~1..HEAD to detect frontend file changes since last commit.
|
||||
// Known limitation: multi-plan waves may need the wave-start commit for full coverage.
|
||||
let hasUiFiles = false;
|
||||
try {
|
||||
const changed = execFileSync('git', ['diff', '--name-only', 'HEAD~1', 'HEAD'], {
|
||||
cwd: projectDir,
|
||||
encoding: 'utf-8',
|
||||
maxBuffer: 2 * 1024 * 1024,
|
||||
windowsHide: true,
|
||||
});
|
||||
hasUiFiles = changed.split('\n').some((f) =>
|
||||
f.trim() && (UI_FILE_EXTENSIONS_RE.test(f) || UI_PATH_PATTERNS_RE.test(f)),
|
||||
);
|
||||
} catch { /* git unavailable or no prior commit — treat as no UI files changed */ }
|
||||
|
||||
// (d) Resolve phase directory and check for *-UI-SPEC.md (same as computeUiPlanGate)
|
||||
const coreModule = core as unknown as Record<string, unknown>;
|
||||
let phaseDir = '';
|
||||
try {
|
||||
const findPhase = coreModule['findPhaseInternal'] as ((cwd: string, phase: string) => Record<string, unknown> | string | null) | undefined;
|
||||
if (typeof findPhase === 'function') {
|
||||
const result = findPhase(projectDir, phase);
|
||||
if (result && typeof result === 'object') {
|
||||
const relDir = typeof result['directory'] === 'string' ? result['directory'] : '';
|
||||
if (relDir) {
|
||||
phaseDir = path.resolve(projectDir, relDir);
|
||||
}
|
||||
} else if (typeof result === 'string') {
|
||||
phaseDir = result;
|
||||
}
|
||||
}
|
||||
} catch { /* phase dir lookup failure → hasUiSpec=false */ }
|
||||
|
||||
const uiSpecPath = findUiSpecInDir(phaseDir);
|
||||
const hasUiSpec = uiSpecPath !== '';
|
||||
|
||||
// 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: boolean;
|
||||
hasUiFiles: boolean;
|
||||
hasUiSpec: boolean;
|
||||
block: boolean;
|
||||
message?: string;
|
||||
phaseLookupFailed?: boolean;
|
||||
} = { frontend, hasUiFiles, hasUiSpec, block };
|
||||
|
||||
if (block) {
|
||||
result.message = `UI files changed in this wave but no UI-SPEC.md exists for Phase ${phase}. ` +
|
||||
`Run /gsd:ui-phase ${phase} to generate the design contract before continuing.`;
|
||||
}
|
||||
if (phaseLookupFailed) result.phaseLookupFailed = true;
|
||||
return result;
|
||||
}
|
||||
|
||||
function cmdUiSafetyGate(projectDir: string, args: string[], raw: boolean): void {
|
||||
// args[0] = 'check', args[1] = 'ui-safety-gate', args[2] = phase
|
||||
const phase = args[2] || '';
|
||||
if (!phase) {
|
||||
error('ui-safety-gate requires a phase argument: check ui-safety-gate <phase>', ERROR_REASON.SDK_MISSING_ARG);
|
||||
return;
|
||||
}
|
||||
output(computeUiSafetyGate(projectDir, phase), raw, undefined);
|
||||
}
|
||||
|
||||
// ─── tdd-review-checkpoint ────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* tdd-review-checkpoint: end-of-phase advisory check that scans type:tdd plans
|
||||
* for RED/GREEN/REFACTOR gate-sequence compliance and surfaces a review table.
|
||||
*
|
||||
* Logic from gsd-core/references/tdd.md <end_of_phase_review> and
|
||||
* execute-phase.md <step name="tdd_review_checkpoint"> (now removed).
|
||||
*
|
||||
* Returns JSON:
|
||||
* { passed: true, tddPlans: N, violations: N, table: string, rows: PlanRow[] }
|
||||
* where passed is always true (advisory gate — never blocks).
|
||||
*
|
||||
* Args: check tdd.review-checkpoint <phase>
|
||||
* Phase can be a number or phase-dir path; if not resolvable the check
|
||||
* returns passed:true with tddPlans:0 (no plans to review).
|
||||
*/
|
||||
interface TddPlanRow {
|
||||
planId: string;
|
||||
red: boolean;
|
||||
green: boolean;
|
||||
refactor: boolean;
|
||||
status: 'Pass' | 'FAIL';
|
||||
missing: string[];
|
||||
}
|
||||
|
||||
function cmdTddReviewCheckpoint(projectDir: string, args: string[], raw: boolean): void {
|
||||
// args[0] = 'check', args[1] = 'tdd-review-checkpoint' (normalized), args[2] = phase
|
||||
const phase = args[2] || '';
|
||||
if (!phase) {
|
||||
error('tdd.review-checkpoint requires a phase argument: check tdd.review-checkpoint <phase>', ERROR_REASON.SDK_MISSING_ARG);
|
||||
return;
|
||||
}
|
||||
|
||||
// Resolve phase directory
|
||||
const coreModule = core as unknown as Record<string, unknown>;
|
||||
let phaseDir = '';
|
||||
try {
|
||||
const findPhase = coreModule['findPhaseInternal'] as ((cwd: string, phase: string) => Record<string, unknown> | string | null) | undefined;
|
||||
if (typeof findPhase === 'function') {
|
||||
const result = findPhase(projectDir, phase);
|
||||
if (result && typeof result === 'object') {
|
||||
const relDir = typeof result['directory'] === 'string' ? result['directory'] : '';
|
||||
if (relDir) phaseDir = path.resolve(projectDir, relDir);
|
||||
} else if (typeof result === 'string') {
|
||||
phaseDir = result;
|
||||
}
|
||||
}
|
||||
} catch { /* phase dir lookup failure */ }
|
||||
|
||||
// Find all PLAN.md files with type: tdd in frontmatter
|
||||
const tddPlanFiles: string[] = [];
|
||||
if (phaseDir) {
|
||||
try {
|
||||
const files = fs.readdirSync(phaseDir).filter(f => f.endsWith('-PLAN.md'));
|
||||
for (const file of files) {
|
||||
const planPath = path.join(phaseDir, file);
|
||||
const content = readIfExists(planPath);
|
||||
// Check frontmatter for type: tdd
|
||||
const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
|
||||
if (frontmatterMatch) {
|
||||
const fm = frontmatterMatch[1];
|
||||
if (/^type:\s*tdd\s*$/m.test(fm)) {
|
||||
tddPlanFiles.push(planPath);
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch { /* directory read failure */ }
|
||||
}
|
||||
|
||||
if (tddPlanFiles.length === 0) {
|
||||
const result = {
|
||||
// Uniform gate contract: block = violations > 0 (advisory; never truly blocks).
|
||||
block: false,
|
||||
passed: true,
|
||||
tddPlans: 0,
|
||||
violations: 0,
|
||||
table: '',
|
||||
rows: [] as TddPlanRow[],
|
||||
message: `No type:tdd plans found in phase ${phase}. TDD review skipped.`,
|
||||
};
|
||||
// Pass undefined as rawValue so --raw emits JSON (not plain text).
|
||||
// The human-readable report is carried in `result.message` for the
|
||||
// dispatch's advisory branch to surface.
|
||||
output(result, raw, undefined);
|
||||
return;
|
||||
}
|
||||
|
||||
// For each TDD plan, extract the plan ID (padded plan number) and check git log
|
||||
const rows: TddPlanRow[] = [];
|
||||
for (const planPath of tddPlanFiles) {
|
||||
// Extract plan ID from filename (e.g. "01-02-PLAN.md" → "01-02", or "03-PLAN.md" → "03")
|
||||
const basename = path.basename(planPath, '-PLAN.md');
|
||||
// planId for commit grep: phase-plan format, e.g. "01-02"
|
||||
const planId = basename;
|
||||
|
||||
// Check for RED gate commit: test({planId}):
|
||||
let red = false;
|
||||
let green = false;
|
||||
let refactor = false;
|
||||
try {
|
||||
const redCommit = execFileSync(
|
||||
'git', ['log', '--oneline', `--grep=^test(${planId}):`, '--', '.'],
|
||||
{ cwd: projectDir, encoding: 'utf-8', maxBuffer: 1024 * 1024, windowsHide: true },
|
||||
);
|
||||
red = redCommit.trim().length > 0;
|
||||
} catch { /* git unavailable or no match */ }
|
||||
|
||||
try {
|
||||
const greenCommit = execFileSync(
|
||||
'git', ['log', '--oneline', `--grep=^feat(${planId}):`, '--', '.'],
|
||||
{ cwd: projectDir, encoding: 'utf-8', maxBuffer: 1024 * 1024, windowsHide: true },
|
||||
);
|
||||
green = greenCommit.trim().length > 0;
|
||||
} catch { /* git unavailable or no match */ }
|
||||
|
||||
try {
|
||||
const refactorCommit = execFileSync(
|
||||
'git', ['log', '--oneline', `--grep=^refactor(${planId}):`, '--', '.'],
|
||||
{ cwd: projectDir, encoding: 'utf-8', maxBuffer: 1024 * 1024, windowsHide: true },
|
||||
);
|
||||
refactor = refactorCommit.trim().length > 0;
|
||||
} catch { /* git unavailable or no match */ }
|
||||
|
||||
const missing: string[] = [];
|
||||
if (!red) missing.push('RED');
|
||||
if (!green) missing.push('GREEN');
|
||||
const status: 'Pass' | 'FAIL' = missing.length === 0 ? 'Pass' : 'FAIL';
|
||||
|
||||
rows.push({ planId, red, green, refactor, status, missing });
|
||||
}
|
||||
|
||||
const violations = rows.filter(r => r.status === 'FAIL').length;
|
||||
|
||||
// Build review table
|
||||
const sep = '━'.repeat(53);
|
||||
const tableHeader = '| Plan | RED | GREEN | REFACTOR | Status |';
|
||||
const tableDivider = '|------|-----|-------|----------|--------|';
|
||||
const tableRows = rows.map(r =>
|
||||
`| ${r.planId.padEnd(4)} | ${r.red ? ' ✓ ' : ' ✗ '} | ${r.green ? ' ✓ ' : ' ✗ '} | ${r.refactor ? ' ✓ ' : ' — '} | ${r.status.padEnd(6)} |`,
|
||||
);
|
||||
|
||||
let table = [
|
||||
sep,
|
||||
` TDD REVIEW — Phase ${phase}`,
|
||||
sep,
|
||||
'',
|
||||
`TDD Plans: ${tddPlanFiles.length} | Gate violations: ${violations}`,
|
||||
'',
|
||||
tableHeader,
|
||||
tableDivider,
|
||||
...tableRows,
|
||||
].join('\n');
|
||||
|
||||
if (violations > 0) {
|
||||
table += '\n\n⚠ Gate violations are advisory — review before advancing.';
|
||||
for (const r of rows.filter(row => row.status === 'FAIL')) {
|
||||
table += `\n Plan ${r.planId} missing: ${r.missing.join(', ')} gate commit(s).`;
|
||||
table += `\n Expected commit pattern: test(${r.planId}): ... → feat(${r.planId}): ...`;
|
||||
}
|
||||
}
|
||||
|
||||
const result = {
|
||||
// Uniform gate contract: block = violations > 0.
|
||||
// This gate is advisory (blocking: false in capability.json) so block:true
|
||||
// only surfaces as a warning, never halts. Kept here so the host-loop
|
||||
// dispatch can read a single consistent `block` field.
|
||||
block: violations > 0,
|
||||
passed: true,
|
||||
tddPlans: tddPlanFiles.length,
|
||||
violations,
|
||||
table,
|
||||
rows,
|
||||
// Human-readable report in `message` so the dispatch's advisory branch
|
||||
// can surface it. --raw emits JSON (rawValue=undefined), not plain text.
|
||||
message: table,
|
||||
};
|
||||
// Pass undefined as rawValue so --raw emits JSON (not the raw table text).
|
||||
// The review table is carried in `result.message` and `result.table` so
|
||||
// the host-loop dispatch's advisory branch can surface it.
|
||||
output(result, raw, undefined);
|
||||
}
|
||||
|
||||
// ─── gap-analysis-plan-post ───────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* gap-analysis-plan-post: non-blocking advisory check that runs the post-planning
|
||||
* gap analysis after all PLAN.md files are generated for a phase.
|
||||
*
|
||||
* Cross-references every REQ-ID and D-ID from REQUIREMENTS.md and CONTEXT.md
|
||||
* against the concatenated text of all *-PLAN.md files, emitting a coverage table.
|
||||
*
|
||||
* This gate is always advisory (passed: true) — it never blocks phase advancement.
|
||||
*
|
||||
* Args: check gap-analysis.plan-post <phase-dir> [phase-req-ids]
|
||||
* Invocable as: gsd_run check gap-analysis.plan-post <phase-dir> [phase-req-ids]
|
||||
*/
|
||||
function cmdGapAnalysisPlanPost(projectDir: string, args: string[], raw: boolean): void {
|
||||
// args[0] = 'check', args[1] = 'gap-analysis-plan-post' (normalized), args[2] = phaseDir, args[3] = phaseReqIds
|
||||
const phaseDir = args[2] || '';
|
||||
if (!phaseDir) {
|
||||
error('gap-analysis.plan-post requires a phase-dir argument: check gap-analysis.plan-post <phase-dir> [phase-req-ids]', ERROR_REASON.SDK_MISSING_ARG);
|
||||
return;
|
||||
}
|
||||
const phaseReqIds = args[3] ?? undefined;
|
||||
const result = runGapAnalysis(projectDir, phaseDir, { phaseReqIds });
|
||||
// Uniform gate contract: block = false (gap-analysis is always advisory, never blocks).
|
||||
// `message` carries the human-readable gap analysis report so the dispatch's
|
||||
// advisory branch can surface it. --raw emits JSON (rawValue=undefined), not
|
||||
// plain markdown text.
|
||||
output(
|
||||
{
|
||||
block: false,
|
||||
passed: true,
|
||||
enabled: result.enabled,
|
||||
table: result.table,
|
||||
summary: result.summary,
|
||||
counts: result.counts,
|
||||
// Human-readable report in `message` for the host-loop advisory branch.
|
||||
message: result.table || result.summary || '',
|
||||
},
|
||||
raw,
|
||||
undefined,
|
||||
);
|
||||
}
|
||||
|
||||
interface RouteCheckCommandOptions {
|
||||
args: string[];
|
||||
cwd: string;
|
||||
@@ -493,7 +860,34 @@ function routeCheckCommand({ args, cwd, raw }: RouteCheckCommandOptions): void {
|
||||
cmdUiPlanGate(cwd, args, raw);
|
||||
return;
|
||||
}
|
||||
error('Unknown check subcommand. Available: auto-mode, decision-coverage-plan, decision-coverage-verify, ui-plan-gate', ERROR_REASON.SDK_UNKNOWN_COMMAND);
|
||||
if (subcommand === 'gap-analysis-plan-post') {
|
||||
cmdGapAnalysisPlanPost(cwd, args, raw);
|
||||
return;
|
||||
}
|
||||
if (subcommand === 'tdd-review-checkpoint') {
|
||||
cmdTddReviewCheckpoint(cwd, args, raw);
|
||||
return;
|
||||
}
|
||||
if (subcommand === 'ui-safety-gate') {
|
||||
cmdUiSafetyGate(cwd, args, raw);
|
||||
return;
|
||||
}
|
||||
if (subcommand === 'verify-schema-drift') {
|
||||
// Delegates to verify.schema-drift — drift capability gate at execute:wave:post (blocking).
|
||||
// Dot-to-hyphen normalization means query "verify.schema-drift" routes here.
|
||||
// Honor GSD_SKIP_SCHEMA_CHECK=true to bypass the gate (preserves the original inline gate behavior).
|
||||
const phaseArg = typeof args[2] === 'string' ? args[2] : '';
|
||||
const skipSchemaCheck = process.env['GSD_SKIP_SCHEMA_CHECK'] === 'true';
|
||||
cmdVerifySchemaDrift(cwd, phaseArg, skipSchemaCheck, raw);
|
||||
return;
|
||||
}
|
||||
if (subcommand === 'verify-codebase-drift') {
|
||||
// Delegates to verify.codebase-drift — drift capability gate at execute:wave:post (non-blocking).
|
||||
// Dot-to-hyphen normalization means query "verify.codebase-drift" routes here.
|
||||
cmdVerifyCodebaseDrift(cwd, raw);
|
||||
return;
|
||||
}
|
||||
error('Unknown check subcommand. Available: auto-mode, decision-coverage-plan, decision-coverage-verify, gap-analysis-plan-post, tdd-review-checkpoint, ui-plan-gate, ui-safety-gate, verify-schema-drift, verify-codebase-drift', ERROR_REASON.SDK_UNKNOWN_COMMAND);
|
||||
}
|
||||
|
||||
export = {
|
||||
@@ -501,4 +895,7 @@ export = {
|
||||
decisionMentioned,
|
||||
extractPlanDesignatedSections,
|
||||
computeUiPlanGate,
|
||||
computeUiSafetyGate,
|
||||
cmdGapAnalysisPlanPost,
|
||||
cmdTddReviewCheckpoint,
|
||||
};
|
||||
|
||||
Reference in New Issue
Block a user