@opengsd/gsd-core 1.3.0-rc.1 → 1.3.0

package/gsd-core/bin/lib/update-context.cjs

@@ -0,0 +1,218 @@
+"use strict";
+/**
+ * Update-context resolver (issue #498, candidate 3).
+ *
+ * ADR-457 build-at-publish: the hand-written bin/lib/update-context.cjs
+ * collapsed to a TypeScript source of truth. Behaviour is preserved
+ * byte-for-behaviour from the prior hand-written .cjs; only types are added.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUNTIME_DIRS = void 0;
+exports.inferPreferredRuntime = inferPreferredRuntime;
+exports.envRuntimeDirs = envRuntimeDirs;
+exports.resolveUpdateContext = resolveUpdateContext;
+exports.loadUpdateContext = loadUpdateContext;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+// Runtime -> candidate relative dir. Order matters: it is the probe order, and
+// mirrors the RUNTIME_DIRS array the bash used (a runtime may have several
+// candidate dirs). Kept here, not derived from the installer's getDirName,
+// because update detection probes ALL historical dirs per runtime.
+exports.RUNTIME_DIRS = [
+    ['claude', '.claude'],
+    ['opencode', '.config/opencode'],
+    ['opencode', '.opencode'],
+    ['antigravity', '.gemini/antigravity-ide'],
+    ['antigravity', '.gemini/antigravity-cli'],
+    ['antigravity', '.gemini/antigravity'],
+    ['antigravity', '.agent'], // local Antigravity install dir (#503; bin/install.js getDirName('antigravity'))
+    ['gemini', '.gemini'],
+    ['kilo', '.config/kilo'],
+    ['kilo', '.kilo'],
+    ['codex', '.codex'],
+];
+const SEMVER_PREFIX = /^\d+\.\d+\.\d+/;
+function expandHome(p, home) {
+    if (!p)
+        return '';
+    return p.startsWith('~/') ? node_path_1.default.join(home, p.slice(2)) : p;
+}
+function versionFile(dir) { return node_path_1.default.join(dir, 'gsd-core', 'VERSION'); }
+function markerFile(dir) { return node_path_1.default.join(dir, 'gsd-core', 'workflows', 'update.md'); }
+// Detection: a dir "has GSD" if it carries a VERSION file or the update.md
+// workflow marker.
+function hasInstall(fs, dir) {
+    return fs.exists(versionFile(dir)) || fs.exists(markerFile(dir));
+}
+// Read VERSION at dir; return a trimmed semver string, or null if missing/invalid.
+function validVersionAt(fs, dir) {
+    const raw = fs.readFile(versionFile(dir));
+    if (raw == null)
+        return null;
+    const trimmed = String(raw).trim();
+    return SEMVER_PREFIX.test(trimmed) ? trimmed : null;
+}
+// A version is TRUSTED only when BOTH the VERSION file and the update.md marker
+// exist (and VERSION is valid semver).
+function trustedVersionAt(fs, dir) {
+    return dir && fs.exists(markerFile(dir)) ? validVersionAt(fs, dir) : null;
+}
+// Infer the preferred runtime from preferredConfigDir config files, then env.
+function inferPreferredRuntime({ fs, env, preferredConfigDir }) {
+    if (preferredConfigDir) {
+        if (fs.exists(node_path_1.default.join(preferredConfigDir, 'kilo.json')) ||
+            fs.exists(node_path_1.default.join(preferredConfigDir, 'kilo.jsonc')))
+            return 'kilo';
+        if (fs.exists(node_path_1.default.join(preferredConfigDir, 'opencode.json')) ||
+            fs.exists(node_path_1.default.join(preferredConfigDir, 'opencode.jsonc')))
+            return 'opencode';
+        if (fs.exists(node_path_1.default.join(preferredConfigDir, 'config.toml')))
+            return 'codex';
+    }
+    if (env['CODEX_HOME'])
+        return 'codex';
+    if (env['ANTIGRAVITY_CONFIG_DIR'])
+        return 'antigravity';
+    if (env['GEMINI_CONFIG_DIR'])
+        return 'gemini';
+    if (env['KILO_CONFIG_DIR'] || env['KILO_CONFIG'])
+        return 'kilo';
+    if (env['OPENCODE_CONFIG_DIR'] || env['OPENCODE_CONFIG'])
+        return 'opencode';
+    if (env['CLAUDE_CONFIG_DIR'])
+        return 'claude';
+    return 'claude';
+}
+// Absolute env-override candidates, mirroring the bash ENV_RUNTIME_DIRS block.
+function envRuntimeDirs({ env, home }) {
+    const out = [];
+    const ex = (v) => expandHome(v, home);
+    if (env['CLAUDE_CONFIG_DIR'])
+        out.push(['claude', ex(env['CLAUDE_CONFIG_DIR'])]);
+    if (env['ANTIGRAVITY_CONFIG_DIR'])
+        out.push(['antigravity', ex(env['ANTIGRAVITY_CONFIG_DIR'])]);
+    if (env['GEMINI_CONFIG_DIR'])
+        out.push(['gemini', ex(env['GEMINI_CONFIG_DIR'])]);
+    if (env['KILO_CONFIG_DIR'])
+        out.push(['kilo', ex(env['KILO_CONFIG_DIR'])]);
+    else if (env['KILO_CONFIG'])
+        out.push(['kilo', node_path_1.default.dirname(ex(env['KILO_CONFIG']))]);
+    else if (env['XDG_CONFIG_HOME'])
+        out.push(['kilo', node_path_1.default.join(ex(env['XDG_CONFIG_HOME']), 'kilo')]);
+    if (env['OPENCODE_CONFIG_DIR'])
+        out.push(['opencode', ex(env['OPENCODE_CONFIG_DIR'])]);
+    else if (env['OPENCODE_CONFIG'])
+        out.push(['opencode', node_path_1.default.dirname(ex(env['OPENCODE_CONFIG']))]);
+    else if (env['XDG_CONFIG_HOME'])
+        out.push(['opencode', node_path_1.default.join(ex(env['XDG_CONFIG_HOME']), 'opencode')]);
+    if (env['CODEX_HOME'])
+        out.push(['codex', ex(env['CODEX_HOME'])]);
+    return out;
+}
+// Stable reorder: entries whose runtime === preferred first, original order kept.
+function preferFirst(entries, preferred) {
+    const pref = entries.filter(([rt]) => rt === preferred);
+    const rest = entries.filter(([rt]) => rt !== preferred);
+    return [...pref, ...rest];
+}
+/**
+ * Pure resolver. Returns { installedVersion, scope, runtime, gsdDir }.
+ */
+function resolveUpdateContext({ home, cwd, env = {}, fs, preferredConfigDir = '', preferredRuntime = '', }) {
+    // Expand a leading `~/` before any probe.
+    preferredConfigDir = expandHome(preferredConfigDir, home);
+    const preferred = preferredRuntime || inferPreferredRuntime({ fs, env, preferredConfigDir });
+    // Fast path: a validated preferredConfigDir (custom --config-dir install).
+    if (preferredConfigDir && hasInstall(fs, preferredConfigDir)) {
+        const resolvedPref = node_path_1.default.resolve(preferredConfigDir);
+        let scope = 'GLOBAL';
+        for (const [, reldir] of exports.RUNTIME_DIRS) {
+            if (node_path_1.default.resolve(cwd, reldir) === resolvedPref) {
+                scope = 'LOCAL';
+                break;
+            }
+        }
+        return {
+            installedVersion: trustedVersionAt(fs, preferredConfigDir) ?? '0.0.0',
+            scope,
+            runtime: preferred,
+            gsdDir: preferredConfigDir,
+        };
+    }
+    const orderedEnv = preferFirst(envRuntimeDirs({ env, home }), preferred);
+    const orderedRuntime = preferFirst(exports.RUNTIME_DIRS, preferred);
+    // LOCAL probe (relative to cwd).
+    let localRuntime = '', localDir = '';
+    for (const [rt, reldir] of orderedRuntime) {
+        const cand = node_path_1.default.resolve(cwd, reldir);
+        if (hasInstall(fs, cand)) {
+            localRuntime = rt;
+            localDir = cand;
+            break;
+        }
+    }
+    // GLOBAL probe: absolute env candidates first, then $HOME-relative.
+    let globalRuntime = '', globalDir = '';
+    for (const [rt, absdir] of orderedEnv) {
+        if (hasInstall(fs, absdir)) {
+            globalRuntime = rt;
+            globalDir = node_path_1.default.resolve(absdir);
+            break;
+        }
+    }
+    if (!globalRuntime) {
+        for (const [rt, reldir] of orderedRuntime) {
+            const cand = node_path_1.default.resolve(home, reldir);
+            if (hasInstall(fs, cand)) {
+                globalRuntime = rt;
+                globalDir = cand;
+                break;
+            }
+        }
+    }
+    const localValid = trustedVersionAt(fs, localDir);
+    const isLocal = !!localValid && (!globalDir || localDir !== globalDir);
+    if (isLocal) {
+        return { installedVersion: localValid, scope: 'LOCAL', runtime: localRuntime, gsdDir: localDir };
+    }
+    const globalValid = trustedVersionAt(fs, globalDir);
+    if (globalValid) {
+        return { installedVersion: globalValid, scope: 'GLOBAL', runtime: globalRuntime, gsdDir: globalDir };
+    }
+    // A runtime dir was detected (VERSION or marker present) but is not a
+    // complete, valid install: keep scope/runtime/dir and report 0.0.0 so the
+    // caller re-installs.
+    if (localRuntime && (!globalDir || localDir !== globalDir)) {
+        return { installedVersion: '0.0.0', scope: 'LOCAL', runtime: localRuntime, gsdDir: localDir };
+    }
+    if (globalRuntime) {
+        return { installedVersion: '0.0.0', scope: 'GLOBAL', runtime: globalRuntime, gsdDir: globalDir };
+    }
+    return { installedVersion: '0.0.0', scope: 'UNKNOWN', runtime: 'claude', gsdDir: '' };
+}
+/**
+ * CLI wiring: resolve against the real filesystem.
+ */
+function loadUpdateContext(opts = {}) {
+    const fs = {
+        exists: (p) => node_fs_1.default.existsSync(p),
+        readFile: (p) => { try {
+            return node_fs_1.default.readFileSync(p, 'utf8');
+        }
+        catch {
+            return null;
+        } },
+    };
+    return resolveUpdateContext({
+        home: opts.home ?? node_os_1.default.homedir(),
+        cwd: opts.cwd ?? process.cwd(),
+        env: opts.env ?? process.env,
+        fs,
+        preferredConfigDir: opts.preferredConfigDir ?? '',
+        preferredRuntime: opts.preferredRuntime ?? '',
+    });
+}

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

@@ -0,0 +1,91 @@
+"use strict";
+/**
+ * Manifest-backed validate subcommand router.
+ * Keeps gsd-tools.cjs thin while preserving existing command semantics.
+ *
+ * Phase 6: validate.consistency, validate.health, validate.agents are
+ * dispatched via executeForCjs when the SDK is available. CJS fallback
+ * retained when:
+ * - GSD_WORKSTREAM is active (workstream-scoped requests fall through to CJS).
+ * - SDK is unavailable (build not present).
+ *
+ * CJS-only subcommands:
+ * - context: complex inline logic using classifyContextUtilization and
+ *   output formatting that has no direct SDK counterpart. Remains CJS-native.
+ *
+ * SDK-only (unsupported in CJS router): none.
+ *
+ * ADR-457 build-at-publish: the hand-written bin/lib/validate-command-router.cjs
+ * collapsed to a TypeScript source of truth. Behaviour is preserved byte-for-behaviour
+ * from the prior hand-written .cjs; only types are added.
+ */
+const command_aliases_cjs_1 = require("./command-aliases.cjs");
+const runtime_slash_cjs_1 = require("./runtime-slash.cjs");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const cjsCommandRouterAdapter = require("./cjs-command-router-adapter.cjs");
+const { routeCjsCommandFamily } = cjsCommandRouterAdapter;
+const command_arg_projection_cjs_1 = require("./command-arg-projection.cjs");
+const context_utilization_cjs_1 = require("./context-utilization.cjs");
+// ─── Implementation ───────────────────────────────────────────────────────────
+function routeValidateCommand({ verify, args, cwd, raw, output: outputFn, error }) {
+    routeCjsCommandFamily({
+        args,
+        subcommands: command_aliases_cjs_1.VALIDATE_SUBCOMMANDS,
+        unsupported: {},
+        error,
+        unknownMessage: (_subcommand, available) => `Unknown validate subcommand. Available: ${available.join(', ')}`,
+        handlers: {
+            consistency: () => verify.cmdValidateConsistency(cwd, raw),
+            // Keep health on CJS for now so fix hints are rendered via runtime-slash
+            // helpers (codex expects $gsd-* command shape).
+            health: () => {
+                const repairFlag = args.includes('--repair');
+                const backfillFlag = args.includes('--backfill');
+                verify.cmdValidateHealth(cwd, { repair: repairFlag, backfill: backfillFlag }, raw);
+            },
+            agents: () => verify.cmdValidateAgents(cwd, raw),
+            // context: CJS-only — complex inline logic using classifyContextUtilization
+            // with custom output formatting that has no direct SDK counterpart.
+            context: () => {
+                const opts = (0, command_arg_projection_cjs_1.parseNamedArgs)(args, ['tokens-used', 'context-window']);
+                if (opts['tokens-used'] === null) {
+                    error('--tokens-used <integer> is required for `validate context`');
+                    return;
+                }
+                if (opts['context-window'] === null) {
+                    error('--context-window <integer> is required for `validate context`');
+                    return;
+                }
+                const threadCmd = String((0, runtime_slash_cjs_1.formatGsdSlash)('thread', (0, runtime_slash_cjs_1.resolveRuntime)(cwd)));
+                const RECOMMENDATIONS = {
+                    [context_utilization_cjs_1.STATES.HEALTHY]: null,
+                    [context_utilization_cjs_1.STATES.WARNING]: `Context is approaching the fracture zone — consider ${threadCmd} to continue in a fresh window.`,
+                    [context_utilization_cjs_1.STATES.CRITICAL]: `Reasoning quality may degrade past 70% utilization (fracture point). Run ${threadCmd} now to preserve output quality.`,
+                };
+                let classified;
+                try {
+                    classified = (0, context_utilization_cjs_1.classifyContextUtilization)(Number(opts['tokens-used']), Number(opts['context-window']));
+                }
+                catch (e) {
+                    const msg = e.message;
+                    const flag = /tokensUsed/.test(msg) ? '--tokens-used' : '--context-window';
+                    error(`${flag} must be a non-negative integer (window > 0), got the values supplied`);
+                    return;
+                }
+                const result = { ...classified, recommendation: RECOMMENDATIONS[classified.state] };
+                if (args.includes('--json')) {
+                    outputFn(result, raw);
+                }
+                else {
+                    const lines = [`Context utilization: ${result.percent}% (${result.state})`];
+                    if (result.recommendation)
+                        lines.push(result.recommendation);
+                    outputFn(result, true, lines.join('\n'));
+                }
+            },
+        },
+    });
+}
+module.exports = {
+    routeValidateCommand,
+};

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

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * Validate Helpers — pure computation helpers and regex constants extracted from
+ * sdk/src/query/validate.ts (ADR-457 build-at-publish: the hand-written
+ * bin/lib/validate.cjs collapsed to a TypeScript source of truth). Behaviour is
+ * preserved byte-for-behaviour from the prior hand-written .cjs; only types are
+ * added.
+ *
+ * No I/O. No async. No filesystem operations.
+ *
+ * Issue #6 drift items (three helpers):
+ *   1. phaseVariants() — replaces parseInt-based padded/unpadded check in verify.cjs
+ *      Check 8 (W006 disk-existence and W007 roadmap-membership checks).
+ *   2. buildRoadmapPhaseVariants() — replaces raw roadmapPhases set in W007 loop.
+ *   3. buildNotStartedPhaseVariants() — replaces raw+zero-padded notStartedPhases
+ *      in W006 skip logic.
+ *
+ * Issue #26 drift items (four constants/helpers):
+ *   4. phaseDirNameRe — W005 phase directory naming regex (was inline in verify.cjs Check 6).
+ *   5. PHASE_TOKEN_FROM_DIR_RE — extracts phase token from dir name (was inline in
+ *      verify.cjs forEachArchivedPhaseToken / collectDiskPhases).
+ *   6. MILESTONE_ARCHIVE_DIR_RE — identifies milestone archive directories (was inline).
+ *   7. canonicalPlanStem() — I001 PLAN/SUMMARY stem canonicalization (was inline in Check 7).
+ *
+ * I/O adapter pattern (ADR-3524 §4): pure transforms extracted from the SDK.
+ *
+ * References:
+ *   - ADR-3524 (docs/adr/3524-cjs-sdk-hard-seam.md)
+ *   - Issue #6 (open-gsd/gsd-core)
+ *   - Issue #26 (open-gsd/gsd-core)
+ *   - PR #154 (issue #4) — generator pattern precedent
+ *   - PR #156 (issue #6) — validate.ts generator that #26 extends
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MILESTONE_ARCHIVE_DIR_RE = exports.PHASE_TOKEN_FROM_DIR_RE = exports.phaseDirNameRe = void 0;
+exports.canonicalPlanStem = canonicalPlanStem;
+exports.phaseVariants = phaseVariants;
+exports.buildRoadmapPhaseVariants = buildRoadmapPhaseVariants;
+exports.buildNotStartedPhaseVariants = buildNotStartedPhaseVariants;
+// ── Issue #26: regex constants (W005, W006-archived) ────────────────────────
+// Matches legacy numeric dirs (01-setup), milestone-prefixed dirs (02-01-setup),
+// deep dirs (02-04-01-deep), and project-code-prefixed variants (GSD-02-01-setup).
+exports.phaseDirNameRe = /^(?:[A-Z]{1,6}-)?\d{2,}(?:-\d+)*(?:\.\d+)*-[\w-]+$/i;
+// Extracts the full phase token from a directory name, including milestone-prefixed
+// multi-segment tokens like "02-01" from "02-01-setup" or "GSD-02-01-setup".
+// Greedily captures all leading all-digit segments before the first letter-start segment.
+exports.PHASE_TOKEN_FROM_DIR_RE = /^(?:[A-Z]{1,6}-)?(\d+(?:-\d+)*[A-Z]?(?:\.\d+)*)(?:-[a-z]|$)/i;
+exports.MILESTONE_ARCHIVE_DIR_RE = /^v\d+.*-phases$/i;
+// ── Issue #26: I001 canonicalization ────────────────────────────────────────
+function canonicalPlanStem(stem) {
+    const m = stem.match(/^(\d+[A-Z]?(?:\.\d+)*-\d+)/i);
+    return m ? m[1] : stem;
+}
+// ── Issue #6: phase variant helpers (W006/W007) ──────────────────────────────
+function phaseVariants(phase) {
+    const variants = new Set([phase]);
+    const dotIdx = phase.indexOf('.');
+    const head = dotIdx === -1 ? phase : phase.slice(0, dotIdx);
+    const tail = dotIdx === -1 ? '' : phase.slice(dotIdx);
+    // Milestone-prefixed IDs: M-NN or M-N-N. Add padding-normalized variant.
+    // e.g. "2-01" → also "02-01"; "02-01" → also "2-01"
+    const milestoneHeadMatch = head.match(/^(\d+)((?:-\d+)+)([A-Z]?)$/i);
+    if (milestoneHeadMatch) {
+        const major = milestoneHeadMatch[1];
+        const subSegs = milestoneHeadMatch[2]; // e.g. "-01" or "-04-01"
+        const letter = milestoneHeadMatch[3] || '';
+        const paddedMajor = major.padStart(2, '0');
+        const unpaddedMajor = String(parseInt(major, 10));
+        // Pad/unpad sub-segments individually
+        const paddedSubs = subSegs.slice(1).split('-').map(s => s.padStart(2, '0')).join('-');
+        const unpaddedSubs = subSegs.slice(1).split('-').map(s => String(parseInt(s, 10))).join('-');
+        variants.add(`${paddedMajor}-${paddedSubs}${letter}${tail}`);
+        variants.add(`${unpaddedMajor}-${unpaddedSubs}${letter}${tail}`);
+        variants.add(`${unpaddedMajor}-${paddedSubs}${letter}${tail}`);
+        variants.add(`${paddedMajor}-${unpaddedSubs}${letter}${tail}`);
+        return variants;
+    }
+    // Plain numeric/decimal IDs: "1", "01", "12A", "12.1"
+    const headMatch = head.match(/^(\d+)([A-Z]?)$/i);
+    if (!headMatch)
+        return variants;
+    const numericHead = headMatch[1];
+    const letterSuffix = headMatch[2] || '';
+    variants.add(`${String(parseInt(numericHead, 10))}${letterSuffix}${tail}`);
+    variants.add(`${numericHead.padStart(2, '0')}${letterSuffix}${tail}`);
+    return variants;
+}
+function buildRoadmapPhaseVariants(roadmapContent) {
+    const roadmapPhases = new Set();
+    const roadmapPhaseVariants = new Set();
+    // Matches both legacy numeric (Phase 1:), decimal (Phase 2.1:), milestone-prefixed (Phase 2-01:),
+    // and bracket-prefixed (### [GSD] Phase 2-01:) headings.
+    const phasePattern = /#{2,4}\s*(?:\[[^\]]+\]\s*)?Phase\s+([\w][\w.-]*(?:-[\w.-]+)*)\s*:/gi;
+    let m;
+    while ((m = phasePattern.exec(roadmapContent)) !== null) {
+        roadmapPhases.add(m[1]);
+        for (const variant of phaseVariants(m[1]))
+            roadmapPhaseVariants.add(variant);
+    }
+    return { roadmapPhases, roadmapPhaseVariants };
+}
+function buildNotStartedPhaseVariants(roadmapContent) {
+    const notStartedPhases = new Set();
+    // Also matches milestone-prefixed and bracket-prefixed checklist items.
+    const uncheckedPattern = /-\s*\[\s\]\s*\*{0,2}Phase\s+([\w][\w.-]*(?:-[\w.-]+)*)[:\s*]/gi;
+    let um;
+    while ((um = uncheckedPattern.exec(roadmapContent)) !== null) {
+        for (const variant of phaseVariants(um[1]))
+            notStartedPhases.add(variant);
+    }
+    return notStartedPhases;
+}

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

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Manifest-backed verify subcommand router.
+ * Keeps gsd-tools.cjs thin while preserving existing command semantics.
+ *
+ * ADR-457 build-at-publish: the hand-written bin/lib/verify-command-router.cjs
+ * collapsed to a TypeScript source of truth. Behaviour is preserved byte-for-behaviour
+ * from the prior hand-written .cjs; only types are added.
+ */
+const command_aliases_cjs_1 = require("./command-aliases.cjs");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const cjsCommandRouterAdapter = require("./cjs-command-router-adapter.cjs");
+const { routeCjsCommandFamily } = cjsCommandRouterAdapter;
+// ─── Implementation ───────────────────────────────────────────────────────────
+function routeVerifyCommand({ verify, args, cwd, raw, error }) {
+    routeCjsCommandFamily({
+        args,
+        subcommands: command_aliases_cjs_1.VERIFY_SUBCOMMANDS,
+        unsupported: {},
+        error,
+        unknownMessage: (_subcommand, available) => `Unknown verify subcommand. Available: ${available.join(', ')}`,
+        handlers: {
+            'plan-structure': () => verify.cmdVerifyPlanStructure(cwd, args[2], raw),
+            'phase-completeness': () => verify.cmdVerifyPhaseCompleteness(cwd, args[2], raw),
+            references: () => verify.cmdVerifyReferences(cwd, args[2], raw),
+            commits: () => verify.cmdVerifyCommits(cwd, args.slice(2), raw),
+            artifacts: () => verify.cmdVerifyArtifacts(cwd, args[2], raw),
+            'key-links': () => verify.cmdVerifyKeyLinks(cwd, args[2], raw),
+            'schema-drift': () => {
+                const rest = args.slice(2);
+                const skipFlag = rest.includes('--skip');
+                const phaseArg = rest.find((arg) => !arg.startsWith('-'));
+                verify.cmdVerifySchemaDrift(cwd, phaseArg, skipFlag, raw);
+            },
+            // verify codebase-drift dispatches direct to CJS — drift is out-of-seam
+            // per ADR/PRD 3524 §3 / L160 (CJS-only by design). Routing through
+            // recursive dispatch would re-enter this router path.
+            'codebase-drift': () => verify.cmdVerifyCodebaseDrift(cwd, raw),
+        },
+    });
+}
+module.exports = {
+    routeVerifyCommand,
+};