ccqa 0.3.9 → 0.3.10

package/dist/bin/ccqa.mjs

@@ -4,25 +4,30 @@ import { Command } from "commander";
 import { accessSync, readFileSync, statSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { access, mkdir, mkdtemp, readFile, readdir, rm, stat, unlink, writeFile } from "node:fs/promises";
-import { delimiter, dirname, join, resolve } from "node:path";
+import { delimiter, dirname, join, relative, resolve } from "node:path";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import matter from "gray-matter";
-import { spawn } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import { createInterface } from "node:readline";
 import { tmpdir } from "node:os";
 import { createInterface as createInterface$1 } from "node:readline/promises";
 import { z } from "zod";
+import { promisify } from "node:util";
 //#region src/prompts/trace.ts
 function generateSessionName() {
 	return `ccqa-trace-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
 }
 function buildTraceSystemPrompt(spec, options) {
+	return buildTraceSystemPromptInner(spec, options, true);
+}
+function buildTraceSystemPromptInner(spec, options, emitRelatedPaths) {
 	const sessionName = options?.sessionName ?? generateSessionName();
 	const skipCookiesClear = options?.skipCookiesClear ?? false;
 	const stepsText = spec.steps.map((step) => `### ${step.id}: ${step.title}
 - **Instruction**: ${step.instruction}
 - **Expected**: ${step.expected}`).join("\n\n");
 	const prereqText = spec.prerequisites ? `## Prerequisites\n${spec.prerequisites}\n\n` : "";
+	const relatedPathsBlock = emitRelatedPaths ? buildRelatedPathsInstruction() : "";
 	return `You are an expert QA engineer executing a browser E2E test. Execute each step precisely and record every browser action as a structured log line.
 
 ## Session
@@ -240,7 +245,7 @@ After each step (outside any code block):
 ROUTE_STEP|<step-id>|<step-title>|ACTION:<what you did>|OBSERVATION:<what you verified>|STATUS:<PASSED|FAILED|SKIPPED>
 \`\`\`
 
-## Start
+${relatedPathsBlock}## Start
 
 ${skipCookiesClear ? `A setup procedure has already been executed in this session. Do NOT clear cookies — keep the existing session state.
 
@@ -264,15 +269,49 @@ AB_ACTION|open|${spec.baseUrl}
 
 Then emit \`STEP_START|step-01|...\` and begin.`;
 }
+function buildRelatedPathsInstruction() {
+	return `## Post-run: emit \`relatedPaths\` block
+
+After all steps are complete (regardless of pass/fail) and **before** \`RUN_COMPLETED\`, you MUST emit a single \`RELATED_PATHS\` block. The host (not you) writes these paths into the spec's frontmatter — your only job is to emit the block.
+
+\`relatedPaths\` is a list of glob patterns identifying the source files this spec depends on. CI uses them to decide whether a code change should trigger a drift check for this spec.
+
+**Do NOT modify any source files.** You have only \`Read\`, \`Grep\`, and \`Glob\` for source inspection. The block you emit is the only output the host uses to update the spec.
+
+**Inputs to consider:**
+- The URLs you opened (\`AB_ACTION|open|...\`)
+- The aria-labels, placeholders, and visible texts you clicked / filled / waited on
+- The component / page / route files that render those strings (find them with \`Grep\`/\`Read\`/\`Glob\`)
+
+**How to choose paths:**
+1. For each URL the test navigates to, locate the route/page file and include it (e.g. \`src/app/tasks/page.tsx\`, \`src/pages/tasks/index.tsx\`).
+2. For each unique aria-label / placeholder / visible text you interacted with, \`Grep\` the codebase, find the defining component, and include either the file or its parent feature directory.
+3. Prefer **directory globs** (e.g. \`src/features/tasks/**\`) over individual files when several related components live in the same area. Otherwise list specific files.
+4. Skip third-party files (\`node_modules/\`), build output (\`dist/\`, \`.next/\`), and generated code.
+5. Be conservative — false positives (extra paths) are fine; false negatives (missing paths) cause drift to be missed in CI. When unsure whether a path is relevant, include it.
+
+**Output format (STRICT — one line per path, no leading dashes, no commentary inside the block):**
+
+\`\`\`
+RELATED_PATHS_BEGIN
+src/features/tasks/**
+src/app/tasks/page.tsx
+RELATED_PATHS_END
+\`\`\`
+
+Emit the block outside any other code block, on its own lines. If the test could not exercise the feature at all (e.g. blocked early), emit the block anyway with whatever paths you can identify; emit \`RELATED_PATHS_BEGIN\` immediately followed by \`RELATED_PATHS_END\` only if you genuinely could not identify any related file.
+
+`;
+}
 function buildTracePrompt(spec) {
 	return `Execute the test for "${spec.title}" at ${spec.baseUrl}.`;
 }
 function buildSetupTraceSystemPrompt(spec) {
-	return buildTraceSystemPrompt({
+	return buildTraceSystemPromptInner({
 		title: spec.title,
 		baseUrl: "about:blank",
 		steps: spec.steps
-	});
+	}, void 0, false);
 }
 function buildSetupTracePrompt(spec) {
 	return `Execute the setup procedure "${spec.title}". Follow each step precisely.`;
@@ -348,7 +387,7 @@ function resolveModel(explicit) {
 	return envModel && envModel.length > 0 ? envModel : void 0;
 }
 async function invokeClaudeStreaming(options, onEvent) {
-	const { prompt, systemPrompt, allowedTools, disableBuiltinTools = false, maxTurns, env, model, onAbAction, onAbActionFailed, silenceBashLog = false } = options;
+	const { prompt, systemPrompt, allowedTools, disableBuiltinTools = false, maxTurns, env, model, cwd, onAbAction, onAbActionFailed, silenceBashLog = false } = options;
 	const resolvedModel = resolveModel(model);
 	let lastAbToolUseId = null;
 	const sdkOptions = {
@@ -358,6 +397,7 @@ async function invokeClaudeStreaming(options, onEvent) {
 		permissionMode: "bypassPermissions",
 		allowDangerouslySkipPermissions: true,
 		...resolvedModel ? { model: resolvedModel } : {},
+		...cwd ? { cwd } : {},
 		...env ? { env: {
 			...process.env,
 			...env
@@ -521,20 +561,93 @@ async function* replayMockMessages(path) {
 	}
 }
 //#endregion
+//#region src/spec/parser.ts
+function parseTestSpec(content) {
+	const { data, content: body } = matter(content);
+	const steps = parseSteps(body);
+	const prerequisites = parsePrerequisites(body);
+	return {
+		title: String(data["title"] ?? "Untitled"),
+		baseUrl: String(data["baseUrl"] ?? "http://localhost:3000"),
+		prerequisites: prerequisites || void 0,
+		setups: parseSetupRefs(data["setups"]),
+		relatedPaths: parseRelatedPaths(data["relatedPaths"]),
+		steps
+	};
+}
+function parseRelatedPaths(raw) {
+	if (!Array.isArray(raw)) return void 0;
+	const paths = [];
+	for (const item of raw) if (typeof item === "string" && item.trim().length > 0) paths.push(item.trim());
+	return paths.length > 0 ? paths : void 0;
+}
+function parseSetupSpec(content) {
+	const { data, content: body } = matter(content);
+	const steps = parseSteps(body);
+	const placeholders = parsePlaceholders(data["placeholders"]);
+	return {
+		title: String(data["title"] ?? "Untitled"),
+		placeholders: Object.keys(placeholders).length > 0 ? placeholders : void 0,
+		steps
+	};
+}
+function parsePlaceholders(raw) {
+	if (!raw || typeof raw !== "object") return {};
+	const result = {};
+	for (const [key, val] of Object.entries(raw)) if (val && typeof val === "object" && "dummy" in val) {
+		const v = val;
+		result[key] = {
+			dummy: String(v["dummy"]),
+			description: v["description"] ? String(v["description"]) : void 0
+		};
+	}
+	return result;
+}
+function parseSetupRefs(raw) {
+	if (!Array.isArray(raw)) return void 0;
+	const refs = [];
+	for (const item of raw) if (typeof item === "object" && item !== null && "name" in item) {
+		const i = item;
+		refs.push({
+			name: String(i["name"]),
+			params: i["params"] && typeof i["params"] === "object" ? Object.fromEntries(Object.entries(i["params"]).map(([k, v]) => [k, String(v)])) : void 0
+		});
+	}
+	return refs.length > 0 ? refs : void 0;
+}
+function parsePrerequisites(body) {
+	const match = body.match(/##\s+Prerequisites\s+([\s\S]*?)(?=##|$)/);
+	if (!match || !match[1]) return null;
+	return match[1].trim();
+}
+function parseSteps(body) {
+	const stepBlocks = body.split(/###\s+Step\s+\d+:/);
+	const steps = [];
+	for (let i = 1; i < stepBlocks.length; i++) {
+		const block = stepBlocks[i];
+		if (!block) continue;
+		const titleMatch = block.match(/^(.+)/);
+		const instructionMatch = block.match(/\*\*Instruction\*\*:\s*(.+)/);
+		const expectedMatch = block.match(/\*\*Expected\*\*:\s*(.+)/);
+		if (!titleMatch || !instructionMatch || !expectedMatch) continue;
+		steps.push({
+			id: `step-${String(i).padStart(2, "0")}`,
+			title: titleMatch[1]?.trim() ?? "",
+			instruction: instructionMatch[1]?.trim() ?? "",
+			expected: expectedMatch[1]?.trim() ?? ""
+		});
+	}
+	return steps;
+}
+//#endregion
 //#region src/store/index.ts
 const CCQA_DIR = ".ccqa";
 function getCcqaDir(cwd = process.cwd()) {
 	return join(cwd, CCQA_DIR);
 }
-/**
-* Accepts both the canonical 2-segment alias and the on-disk 4-segment path
-* (which is what shell tab-completion produces):
-*   - "tasks/create-and-complete"
-*   - "features/tasks/test-cases/create-and-complete"
-*   - ".ccqa/features/tasks/test-cases/create-and-complete"
-* All forms resolve to { featureName: "tasks", specName: "create-and-complete" }.
-* Trailing slashes are tolerated.
-*/
+function specKey(ref) {
+	return `${ref.featureName}/${ref.specName}`;
+}
 function parseSpecPath(specPath) {
 	const parts = specPath.replace(/^\.\/+/, "").replace(/\/+$/, "").split("/").filter((p) => p.length > 0);
 	if (parts[0] === ".ccqa") parts.shift();
@@ -573,6 +686,22 @@ async function saveSpecFile(featureName, specName, content, cwd) {
 	await writeFile(specPath, content.endsWith("\n") ? content : content + "\n", "utf-8");
 	return specPath;
 }
+/**
+* Replace (or insert) the `relatedPaths` key in the spec's YAML frontmatter.
+* Preserves every other frontmatter key and the entire body. Returns the
+* absolute path that was written, or null if the spec file does not exist.
+*/
+async function updateSpecRelatedPaths(featureName, specName, relatedPaths, cwd) {
+	const specPath = join(getSpecDir(featureName, specName, cwd), "test-spec.md");
+	const existing = await readFile(specPath, "utf-8").catch(() => null);
+	if (existing === null) return null;
+	const parsed = matter(existing);
+	const data = { ...parsed.data };
+	if (relatedPaths.length > 0) data["relatedPaths"] = relatedPaths;
+	else delete data["relatedPaths"];
+	await writeFile(specPath, matter.stringify(parsed.content, data), "utf-8");
+	return specPath;
+}
 async function saveRoute(featureName, specName, route, cwd) {
 	const specDir = getSpecDir(featureName, specName, cwd);
 	await mkdir(specDir, { recursive: true });
@@ -660,8 +789,8 @@ async function listSpecsForFeature(featureName, cwd) {
 }
 /**
 * Lists every feature/spec dir under .ccqa/features/, regardless of whether
-* the spec is fully drafted yet. Used by `ccqa draft` to suggest non-colliding
-* feature/spec names that fit the existing structure.
+* the spec is fully drafted yet. Each spec file is read at most once: title
+* and relatedPaths are both extracted from the same parse.
 */
 async function listFeatureTree(cwd) {
 	const featuresDir = join(getCcqaDir(cwd), "features");
@@ -677,11 +806,21 @@ async function listFeatureTree(cwd) {
 					specName,
 					hasSpecFile: false
 				};
-				return {
-					specName,
-					hasSpecFile: true,
-					title: content.match(/^title:\s*"?([^"\n]+)"?/m)?.[1]?.trim()
-				};
+				try {
+					const spec = parseTestSpec(content);
+					const entry = {
+						specName,
+						hasSpecFile: true
+					};
+					if (spec.title && spec.title !== "Untitled") entry.title = spec.title;
+					if (spec.relatedPaths) entry.relatedPaths = spec.relatedPaths;
+					return entry;
+				} catch {
+					return {
+						specName,
+						hasSpecFile: true
+					};
+				}
 			}))
 		};
 	}));
@@ -706,76 +845,28 @@ function routeToMarkdown(route) {
 	return lines.join("\n");
 }
 //#endregion
-//#region src/spec/parser.ts
-function parseTestSpec(content) {
-	const { data, content: body } = matter(content);
-	const steps = parseSteps(body);
-	const prerequisites = parsePrerequisites(body);
-	return {
-		title: String(data["title"] ?? "Untitled"),
-		baseUrl: String(data["baseUrl"] ?? "http://localhost:3000"),
-		prerequisites: prerequisites || void 0,
-		setups: parseSetupRefs(data["setups"]),
-		steps
-	};
-}
-function parseSetupSpec(content) {
-	const { data, content: body } = matter(content);
-	const steps = parseSteps(body);
-	const placeholders = parsePlaceholders(data["placeholders"]);
-	return {
-		title: String(data["title"] ?? "Untitled"),
-		placeholders: Object.keys(placeholders).length > 0 ? placeholders : void 0,
-		steps
-	};
-}
-function parsePlaceholders(raw) {
-	if (!raw || typeof raw !== "object") return {};
-	const result = {};
-	for (const [key, val] of Object.entries(raw)) if (val && typeof val === "object" && "dummy" in val) {
-		const v = val;
-		result[key] = {
-			dummy: String(v["dummy"]),
-			description: v["description"] ? String(v["description"]) : void 0
-		};
-	}
-	return result;
-}
-function parseSetupRefs(raw) {
-	if (!Array.isArray(raw)) return void 0;
-	const refs = [];
-	for (const item of raw) if (typeof item === "object" && item !== null && "name" in item) {
-		const i = item;
-		refs.push({
-			name: String(i["name"]),
-			params: i["params"] && typeof i["params"] === "object" ? Object.fromEntries(Object.entries(i["params"]).map(([k, v]) => [k, String(v)])) : void 0
-		});
-	}
-	return refs.length > 0 ? refs : void 0;
-}
-function parsePrerequisites(body) {
-	const match = body.match(/##\s+Prerequisites\s+([\s\S]*?)(?=##|$)/);
-	if (!match || !match[1]) return null;
-	return match[1].trim();
-}
-function parseSteps(body) {
-	const stepBlocks = body.split(/###\s+Step\s+\d+:/);
-	const steps = [];
-	for (let i = 1; i < stepBlocks.length; i++) {
-		const block = stepBlocks[i];
-		if (!block) continue;
-		const titleMatch = block.match(/^(.+)/);
-		const instructionMatch = block.match(/\*\*Instruction\*\*:\s*(.+)/);
-		const expectedMatch = block.match(/\*\*Expected\*\*:\s*(.+)/);
-		if (!titleMatch || !instructionMatch || !expectedMatch) continue;
-		steps.push({
-			id: `step-${String(i).padStart(2, "0")}`,
-			title: titleMatch[1]?.trim() ?? "",
-			instruction: instructionMatch[1]?.trim() ?? "",
-			expected: expectedMatch[1]?.trim() ?? ""
-		});
+//#region src/drift/parse-related-paths.ts
+/**
+* Pull a `RELATED_PATHS_BEGIN ... RELATED_PATHS_END` block out of the trace
+* agent's combined text output. Lines inside the block become entries; blank
+* lines, bullet markers, and code fences are tolerated. Returns null when the
+* agent did not emit a block at all so the caller can warn instead of silently
+* clearing the spec's existing relatedPaths.
+*/
+function parseRelatedPathsBlock(text) {
+	const match = text.match(/RELATED_PATHS_BEGIN\s*\n?([\s\S]*?)\n?RELATED_PATHS_END/);
+	if (!match || match[1] === void 0) return null;
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const raw of match[1].split("\n")) {
+		const line = raw.replace(/^```.*$/, "").trim();
+		if (!line) continue;
+		const cleaned = line.replace(/^[-*]\s+/, "").trim();
+		if (!cleaned || seen.has(cleaned)) continue;
+		seen.add(cleaned);
+		out.push(cleaned);
 	}
-	return steps;
+	return out;
 }
 //#endregion
 //#region src/runtime/bundled-config.ts
@@ -1061,6 +1152,7 @@ async function runTrace(featureName, specName, model) {
 	const routeSteps = [];
 	let overallStatus = "passed";
 	const traceActions = [];
+	let relatedPathsBuffer = null;
 	const { isError } = await invokeClaudeStreaming({
 		prompt,
 		systemPrompt,
@@ -1087,6 +1179,11 @@ async function runTrace(featureName, specName, model) {
 		for (const block of msg.message.content ?? []) {
 			if (block.type !== "text" || !block.text) continue;
 			const text = block.text;
+			if (relatedPathsBuffer !== null) relatedPathsBuffer += text + "\n";
+			else {
+				const idx = text.indexOf("RELATED_PATHS_BEGIN");
+				if (idx !== -1) relatedPathsBuffer = text.slice(idx) + "\n";
+			}
 			const statusLine = parseStatusLine(text);
 			if (statusLine) step(statusLine.type, statusLine.stepId, statusLine.detail);
 			for (const line of text.split("\n")) {
@@ -1117,6 +1214,11 @@ async function runTrace(featureName, specName, model) {
 	meta("saved", actionsPath);
 	meta("actions", traceActions.length);
 	meta("status", overallStatus.toUpperCase());
+	const relatedPaths = relatedPathsBuffer !== null ? parseRelatedPathsBlock(relatedPathsBuffer) : null;
+	if (relatedPaths !== null) {
+		const written = await updateSpecRelatedPaths(featureName, specName, relatedPaths);
+		if (written) meta("relatedPaths", `${relatedPaths.length} path(s) written to ${written}`);
+	} else warn("trace did not emit a RELATED_PATHS block; drift --changed cannot scope this spec");
 	hint(`run 'ccqa generate ${featureName}/${specName}' to generate a test script`);
 }
 /**
@@ -2820,6 +2922,20 @@ async function cleanupActions(actions, model) {
 	return actions;
 }
 //#endregion
+//#region src/claude/extract-json.ts
+/**
+* Pulls a JSON object out of a Claude completion. Accepts either a fenced
+* ```json block or a bare `{...}` payload that constitutes the whole reply.
+* Returns null when neither shape is present.
+*/
+function extractJsonBlock(text) {
+	const fenced = text.match(/```(?:json)?\s*\n([\s\S]*?)\n```/);
+	if (fenced && fenced[1]) return fenced[1].trim();
+	const trimmed = text.trim();
+	if (trimmed.startsWith("{") && trimmed.endsWith("}")) return trimmed;
+	return null;
+}
+//#endregion
 //#region src/prompts/draft.ts
 function buildNamingSystemPrompt() {
 	return `You name a new ccqa test case based on the user's intent and the existing feature tree.
@@ -2877,6 +2993,7 @@ Frontmatter fields:
 - baseUrl: string (required, e.g. http://localhost:3000)
 - prerequisites: string (optional, free text)
 - setups: array of { name: string, params?: Record<string,string> } (optional)
+- relatedPaths: array of string (optional) — glob patterns identifying source files this spec depends on. Used by \`ccqa drift --changed\` in CI to skip drift checks for unrelated changes.
 
 Body must contain a \`## Steps\` section followed by step blocks:
 
@@ -2900,7 +3017,8 @@ Body must contain a \`## Steps\` section followed by step blocks:
 
 1. Read the codebase under cwd to find concrete strings: routes, button labels, aria-labels, page titles, placeholders. Use those exact strings in **Expected**.
 2. If the spec references setups, Read \`.ccqa/setups/<name>/setup-spec.md\` and verify each \`params\` key matches the setup's \`placeholders\`.
-3. Validate the (current or proposed) spec on four axes — emit one issue per finding:
+3. Populate \`relatedPaths\` in the frontmatter with **provisional** glob patterns pointing at the source files this spec touches: the route/page file for each URL the spec visits, plus the component files (or their parent feature directory) that render the aria-labels, placeholders, or visible texts the spec asserts on. Prefer directory globs (e.g. \`src/features/tasks/**\`) when several files in one area are involved. Be conservative — include a path if you're unsure rather than omit it. \`ccqa trace\` will refine this list later from real browser observations.
+4. Validate the (current or proposed) spec on four axes — emit one issue per finding:
    - **assertable**: each Expected can be verified against a string/URL/state that exists in code.
    - **setups**: referenced setup exists; params keys match placeholders.
    - **granularity**: not too coarse (multiple actions per step) nor too fine (snapshot-only steps); order is logical.
@@ -2986,6 +3104,7 @@ z.object({
 	baseUrl: z.string(),
 	prerequisites: z.string().optional(),
 	setups: z.array(SetupRefSchema).optional(),
+	relatedPaths: z.array(z.string()).optional(),
 	steps: z.array(TestStepSchema)
 });
 const PlaceholderDefSchema = z.object({
@@ -3041,7 +3160,7 @@ const DraftNamingSchema = z.object({
 });
 //#endregion
 //#region src/cli/draft.ts
-const CATEGORY_LABEL = {
+const CATEGORY_LABEL$1 = {
 	assertable: "Assertability",
 	setups: "Setup references",
 	granularity: "Step granularity",
@@ -3230,24 +3349,24 @@ function printReviewBlock(issues) {
 	}
 	if (errors.length) {
 		process.stdout.write(`  ERRORS (${errors.length})\n`);
-		for (const issue of errors) writeFinding(issue);
+		for (const issue of errors) writeFinding$1(issue);
 		process.stdout.write("\n");
 	}
 	if (warnings.length) {
 		process.stdout.write(`  WARNINGS (${warnings.length})\n`);
-		for (const issue of warnings) writeFinding(issue);
+		for (const issue of warnings) writeFinding$1(issue);
 		process.stdout.write("\n");
 	}
 	if (passed.length) {
-		const names = passed.map((i) => CATEGORY_LABEL[i.category]).join(", ");
+		const names = passed.map((i) => CATEGORY_LABEL$1[i.category]).join(", ");
 		process.stdout.write(`  PASSED (${passed.length})\n    ${names}\n`);
 	}
 	process.stdout.write(`\n${RULE}\n\n`);
 	return errors.length > 0;
 }
-function writeFinding(issue) {
+function writeFinding$1(issue) {
 	const stepPart = issue.stepId ? `  ${issue.stepId}` : "";
-	process.stdout.write(`    ${CATEGORY_LABEL[issue.category]}${stepPart}\n`);
+	process.stdout.write(`    ${CATEGORY_LABEL$1[issue.category]}${stepPart}\n`);
 	process.stdout.write(`      ${issue.message}\n`);
 	if (issue.detail) process.stdout.write(`      └ ${issue.detail.replace(/\n/g, "\n        ")}\n`);
 }
@@ -3367,13 +3486,6 @@ function ensureUnique(tree, featureName, specName) {
 		specName: `${specName}-${Date.now()}`
 	};
 }
-function extractJsonBlock(text) {
-	const fenced = text.match(/```(?:json)?\s*\n([\s\S]*?)\n```/);
-	if (fenced && fenced[1]) return fenced[1].trim();
-	const trimmed = text.trim();
-	if (trimmed.startsWith("{") && trimmed.endsWith("}")) return trimmed;
-	return null;
-}
 function printUnifiedDiff(before, after) {
 	const lines = computeLineDiff(before.split("\n"), after.split("\n"));
 	for (const line of lines) process.stdout.write(line + "\n");
@@ -3421,6 +3533,645 @@ function truncate(s, n) {
 	return s.slice(s.length - n);
 }
 //#endregion
+//#region src/prompts/drift.ts
+function buildDriftSystemPrompt() {
+	return `${buildDraftSystemPrompt()}
+
+## Drift mode
+
+You are running non-interactively in CI. The user will not see or apply the patch — only the \`issues\` array.
+
+- Always set \`patch\` to "" in your response.
+- Focus issue messages on what is **out of sync** between the spec and the current codebase: missing aria-labels, renamed routes, removed buttons, placeholders that no longer exist, setup references that point to non-existent files.
+- Do NOT raise issues about stylistic preferences in the spec wording.
+- Treat \`category: unimplemented\` as the primary signal for drift: anything the spec asserts that you cannot find in code is a drift finding.
+
+## Drift severity policy (STRICT)
+
+The CLI exits non-zero when any issue has \`severity: "ERROR"\` (default) or — with \`--severity warn\` — when any \`WARN\` is present. Pick severity by **whether a deterministic replay of this spec would fail today**, not by how confident you are in your own analysis.
+
+Use **ERROR** when the spec would break on replay:
+- A selector the spec relies on (\`aria-label\`, \`placeholder\`, \`data-testid\`, button text) **does not exist anywhere in the source**.
+- A URL / route the spec navigates to is no longer defined.
+- An **Expected** asserts a string or visible text that is no longer rendered by the relevant component.
+- A \`setups[].name\` does not resolve to \`.ccqa/setups/<name>/setup-spec.md\`, or a \`params\` key is not declared in that setup's \`placeholders\`.
+- The spec references a feature/page that has been removed from the codebase.
+
+Use **WARN** when the spec is still likely to work, but quality could improve:
+- The Expected is vague ("a message appears") when a precise string exists in code.
+- A step bundles multiple actions, or a needed intermediate verification step is missing.
+- Stable signals exist that the spec could leverage but currently doesn't.
+- You are unsure whether a referenced string exists (give the user the benefit of the doubt; do not hard-fail CI on uncertainty).
+
+Use **OK** for axes you actively verified and found no issue.
+
+If you cannot decide between ERROR and WARN, choose WARN. Reserve ERROR for findings you can back up with a specific file path or grep result that proves the drift.
+`;
+}
+function buildDriftUserPrompt(existing) {
+	return buildDraftPrompt({
+		mode: "refine",
+		existing,
+		userInput: ""
+	});
+}
+//#endregion
+//#region src/drift/affected.ts
+const execFileP = promisify(execFile);
+/**
+* Resolve the base ref to diff against for `ccqa drift --changed`.
+* Precedence: explicit override > GITHUB_BASE_REF > origin/main.
+*/
+function resolveBaseRef(explicit) {
+	if (explicit && explicit.length > 0) return explicit;
+	const ghBase = process.env["GITHUB_BASE_REF"];
+	if (ghBase && ghBase.length > 0) return ghBase.startsWith("origin/") ? ghBase : `origin/${ghBase}`;
+	return "origin/main";
+}
+/**
+* Run `git diff --name-status base...HEAD` from `cwd` and return one entry per
+* changed file. Renames are reported under their NEW path with status
+* "renamed" — the OLD path is dropped because the spec mapping is against the
+* post-rename layout.
+*
+* Paths are re-rooted to be relative to `cwd`, not the git repo root. In a
+* monorepo where `cwd` is a sub-package (e.g. `js/apps/knowledge-webapp`),
+* git emits paths relative to the repo root, but specs declare relatedPaths
+* relative to their own package. Changes outside `cwd` are dropped so an
+* unrelated PR can never accidentally scope a sub-package's specs in.
+*/
+async function getChangedFiles(base, cwd) {
+	const [{ stdout: rootOut }, { stdout: diffOut }] = await Promise.all([execFileP("git", ["rev-parse", "--show-toplevel"], { cwd }), execFileP("git", [
+		"diff",
+		"--name-status",
+		"-M",
+		`${base}...HEAD`
+	], {
+		cwd,
+		maxBuffer: 32 * 1024 * 1024
+	})]);
+	return rerootChangedFiles(parseGitDiffOutput(diffOut), rootOut.trim(), cwd);
+}
+/**
+* Convert paths in `entries` from git-repo-root relative to `cwd` relative,
+* dropping anything outside `cwd`. Exported for unit tests.
+*/
+function rerootChangedFiles(entries, repoRoot, cwd) {
+	const prefix = relative(repoRoot, cwd);
+	if (!prefix) return entries;
+	const out = [];
+	for (const e of entries) {
+		const rel = relative(prefix, e.path);
+		if (rel.startsWith("..") || rel === "") continue;
+		out.push({
+			...e,
+			path: rel
+		});
+	}
+	return out;
+}
+function parseGitDiffOutput(stdout) {
+	const out = [];
+	for (const line of stdout.split("\n")) {
+		if (!line.trim()) continue;
+		const parts = line.split("	");
+		const code = parts[0];
+		if (!code) continue;
+		if (code.startsWith("R")) {
+			const newPath = parts[2];
+			if (newPath) out.push({
+				path: newPath,
+				status: "renamed"
+			});
+			continue;
+		}
+		if (code.startsWith("C")) {
+			const newPath = parts[2];
+			if (newPath) out.push({
+				path: newPath,
+				status: "added"
+			});
+			continue;
+		}
+		const path = parts[1];
+		if (!path) continue;
+		switch (code[0]) {
+			case "A":
+				out.push({
+					path,
+					status: "added"
+				});
+				break;
+			case "M":
+			case "T":
+				out.push({
+					path,
+					status: "modified"
+				});
+				break;
+			case "D":
+				out.push({
+					path,
+					status: "deleted"
+				});
+				break;
+			default: out.push({
+				path,
+				status: "modified"
+			});
+		}
+	}
+	return out;
+}
+function stripLeadingDotSlash(s) {
+	return s.startsWith("./") ? s.slice(2) : s;
+}
+const REGEX_CACHE = /* @__PURE__ */ new Map();
+/** Compiles `pattern` to a RegExp, memoized so repeated `--changed` matches don't re-build. */
+function compileGlob(pattern) {
+	const cached = REGEX_CACHE.get(pattern);
+	if (cached) return cached;
+	const compiled = globToRegExp(stripLeadingDotSlash(pattern));
+	REGEX_CACHE.set(pattern, compiled);
+	return compiled;
+}
+function globToRegExp(pattern) {
+	let re = "^";
+	let i = 0;
+	while (i < pattern.length) {
+		const ch = pattern[i];
+		if (ch === "?") {
+			re += "[^/]";
+			i++;
+			continue;
+		}
+		if (ch !== "*") {
+			re += /[.+^${}()|[\]\\]/.test(ch) ? "\\" + ch : ch;
+			i++;
+			continue;
+		}
+		if (pattern[i + 1] !== "*") {
+			re += "[^/]*";
+			i++;
+			continue;
+		}
+		const hasLeadingSlash = re.endsWith("/");
+		const hasTrailingSlash = pattern[i + 2] === "/";
+		if (hasLeadingSlash) re = re.slice(0, -1);
+		if (hasLeadingSlash || hasTrailingSlash) re += "(?:/?.*)?";
+		else re += ".*";
+		i += hasTrailingSlash ? 3 : 2;
+	}
+	return new RegExp(re + "$");
+}
+/**
+* Returns true if `changedPath` is covered by any of `relatedPaths`. An empty
+* `relatedPaths` returns false — callers handle the "unscoped spec" case
+* separately (treat the spec as always-affected) before calling this.
+*/
+function isPathAffectedBy(changedPath, relatedPaths) {
+	const stripped = stripLeadingDotSlash(changedPath);
+	for (const pattern of relatedPaths) if (compileGlob(pattern).test(stripped)) return true;
+	return false;
+}
+//#endregion
+//#region src/drift/route-new-files.ts
+/**
+* Lightweight Claude call: given a list of new files in the PR and the existing
+* specs (with their relatedPaths globs as a hint), return the spec keys (in
+* "<feature>/<spec>" form) that the new files plausibly affect.
+*
+* Conservative by design — false positives are safer than false negatives,
+* because a missed spec turns into undetected drift in CI. When the router
+* call itself fails, we log a warning rather than fail-close: the surrounding
+* glob match is the primary signal; the router only adds coverage for new
+* paths no glob captures.
+*/
+async function routeNewFilesToSpecs(input) {
+	const { newFiles, specs, cwd, model } = input;
+	const empty = /* @__PURE__ */ new Set();
+	if (newFiles.length === 0 || specs.length === 0) return empty;
+	const { result, isError } = await invokeClaudeStreaming({
+		prompt: buildRouterPrompt(await Promise.all(newFiles.map(async (path) => ({
+			path,
+			head: await readHead(join(cwd, path))
+		}))), specs),
+		systemPrompt: buildRouterSystemPrompt(),
+		allowedTools: [
+			"Read",
+			"Grep",
+			"Glob"
+		],
+		silenceBashLog: true,
+		cwd,
+		...model ? { model } : {}
+	}, (_msg) => {});
+	if (isError) {
+		warn("new-file router: Claude returned an error; skipping router signal");
+		return empty;
+	}
+	const json = extractJsonBlock(result);
+	if (!json) {
+		warn("new-file router: no JSON block in response; skipping router signal");
+		return empty;
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(json);
+	} catch (e) {
+		warn(`new-file router: failed to parse JSON (${e.message}); skipping router signal`);
+		return empty;
+	}
+	const out = /* @__PURE__ */ new Set();
+	const validKeys = new Set(specs.map((s) => `${s.featureName}/${s.specName}`));
+	if (typeof parsed === "object" && parsed !== null && "affectedSpecs" in parsed) {
+		const arr = parsed.affectedSpecs;
+		if (Array.isArray(arr)) {
+			for (const item of arr) if (typeof item === "string" && validKeys.has(item)) out.add(item);
+		}
+	}
+	return out;
+}
+async function readHead(absPath) {
+	const content = await readFile(absPath, "utf-8").catch(() => "");
+	if (!content) return "";
+	return content.split("\n").slice(0, 40).join("\n");
+}
+function buildRouterSystemPrompt() {
+	return `You triage which ccqa test specs are potentially affected by NEW source files added in a pull request.
+
+You will receive:
+- A list of new files (path + first ~40 lines of each)
+- A list of existing specs with their declared relatedPaths globs
+
+Your job: return the spec keys (in "<feature>/<spec>" form) whose behaviour might depend on any of the new files.
+
+## Rules
+
+- Be **conservative**: when in doubt, include the spec. A spurious inclusion costs one extra drift check; a missed spec lets real drift slip through CI.
+- Use \`Read\`, \`Grep\`, \`Glob\` if you need to inspect the spec body or related code, but stay focused — this is a triage step, not a full review.
+- Ignore specs whose relatedPaths clearly point to a different area than every new file (e.g. \`src/auth/**\` specs vs new files only under \`src/billing/**\`).
+- Files like tests, generated code, build artifacts, vendor dirs typically do not affect any spec. Skip them.
+
+## Output (STRICT)
+
+Output ONE fenced \`\`\`json block, nothing else:
+
+\`\`\`json
+{
+  "affectedSpecs": ["feature/spec", "feature/spec"]
+}
+\`\`\`
+
+Use exactly the keys you saw in the input ("<feature>/<spec>"). Return an empty array if no spec is affected.
+`;
+}
+function buildRouterPrompt(previews, specs) {
+	return `## New files
+
+${previews.map((p) => {
+		const headBlock = p.head ? `\n\`\`\`\n${p.head}\n\`\`\`` : "\n(empty or unreadable)";
+		return `### ${p.path}${headBlock}`;
+	}).join("\n\n")}
+
+## Existing specs
+
+${specs.map((s) => {
+		const title = s.title ? ` — ${s.title}` : "";
+		const paths = s.relatedPaths.length === 0 ? "  (no relatedPaths declared)" : s.relatedPaths.map((p) => `  - ${p}`).join("\n");
+		return `- ${s.featureName}/${s.specName}${title}\n${paths}`;
+	}).join("\n")}
+
+## Task
+
+Return the spec keys that might be affected by any of the new files. Conservative inclusion is preferred over missing real drift.
+`;
+}
+//#endregion
+//#region src/cli/drift.ts
+const DEFAULT_CONCURRENCY = 3;
+const driftCommand = new Command("drift").argument("[feature/spec]", "Optional spec id. If omitted, every spec under .ccqa/features/ is checked.").description("Check whether each test-spec.md is still in sync with the current codebase (CI-friendly, no patches applied).").option("--format <fmt>", "Output format: text | json | github", "text").option("--severity <level>", "Exit non-zero on this severity or higher: warn | error", "error").option("--concurrency <n>", `Parallel spec checks (default: ${DEFAULT_CONCURRENCY})`).option("-m, --model <name>", "Claude model alias ('sonnet'|'opus'|'haiku') or full ID. Overrides CCQA_MODEL.").option("--cwd <path>", "Working directory used as both the .ccqa root and the codebase Claude reads. Useful for monorepos. Defaults to process.cwd().").option("--changed", "Restrict drift checks to specs whose relatedPaths intersect the git diff against --base (or, in CI, $GITHUB_BASE_REF, else origin/main). New files are routed to specs via a single lightweight Claude call.").option("--base <ref>", "Base ref to diff against when --changed is set. Defaults to $GITHUB_BASE_REF (CI) or origin/main.").action(async (specPath, opts) => {
+	const format = parseFormat(opts.format);
+	const threshold = parseSeverity(opts.severity);
+	const concurrency = parseConcurrency(opts.concurrency);
+	const cwd = opts.cwd ? resolve(opts.cwd) : process.cwd();
+	await ensureCcqaDir(cwd);
+	if (opts.changed && specPath) {
+		error("--changed and an explicit spec id cannot be combined; --changed only applies to a full sweep");
+		process.exit(2);
+	}
+	let targets = await collectTargets(specPath, cwd);
+	if (targets.length === 0) exitWithNoSpecs(format, "no test specs found under .ccqa/features/");
+	if (format === "text") {
+		header("drift", specPath ?? `${targets.length} spec${targets.length > 1 ? "s" : ""}`);
+		if (opts.cwd) meta("cwd", cwd);
+	}
+	if (opts.changed) {
+		const total = targets.length;
+		targets = await filterByChanged({
+			targets,
+			cwd,
+			baseOverride: opts.base,
+			format,
+			model: opts.model
+		});
+		if (format === "text") meta("scoped", `${targets.length} of ${total} spec${total > 1 ? "s" : ""}`);
+		if (targets.length === 0) exitWithNoSpecs(format, "no specs intersect the changed file set; nothing to check");
+	}
+	const results = await runChecks(targets, concurrency, opts.model, cwd, format);
+	emitReport(results, format, cwd);
+	process.exit(determineExitCode(results, threshold));
+});
+function exitWithNoSpecs(format, message) {
+	if (format === "json") process.stdout.write(`${JSON.stringify({ specs: [] }, null, 2)}\n`);
+	else if (format === "text") info(message);
+	process.exit(0);
+}
+async function filterByChanged(input) {
+	const { targets, cwd, baseOverride, format, model } = input;
+	const base = resolveBaseRef(baseOverride);
+	let changed;
+	try {
+		changed = await getChangedFiles(base, cwd);
+	} catch (e) {
+		error(`failed to run 'git diff' against ${base}: ${e.message}`);
+		process.exit(2);
+	}
+	if (format === "text") {
+		meta("changed-base", base);
+		meta("changed-files", changed.length);
+	}
+	if (changed.length === 0) return [];
+	const newFiles = changed.filter((f) => f.status === "added");
+	const existingChanges = changed.filter((f) => f.status !== "added");
+	const affected = /* @__PURE__ */ new Set();
+	for (const t of targets) {
+		if (!t.relatedPaths) {
+			affected.add(specKey(t));
+			continue;
+		}
+		if (existingChanges.some((f) => isPathAffectedBy(f.path, t.relatedPaths)) || newFiles.some((f) => isPathAffectedBy(f.path, t.relatedPaths))) affected.add(specKey(t));
+	}
+	if (newFiles.length > 0) {
+		if (format === "text") info(`routing ${newFiles.length} new file(s) to specs via Claude...`);
+		const routed = await routeNewFilesToSpecs({
+			newFiles: newFiles.map((f) => f.path),
+			specs: targets.filter((t) => t.relatedPaths).map((t) => ({
+				featureName: t.featureName,
+				specName: t.specName,
+				title: t.title,
+				relatedPaths: t.relatedPaths
+			})),
+			cwd,
+			model
+		});
+		for (const key of routed) affected.add(key);
+	}
+	return targets.filter((t) => affected.has(specKey(t)));
+}
+async function collectTargets(specPath, cwd) {
+	if (specPath) {
+		const { featureName, specName } = parseSpecPath(specPath);
+		if (await tryReadSpecFile(featureName, specName, cwd) === null) {
+			error(`spec not found: ${featureName}/${specName} (under ${cwd})`);
+			process.exit(1);
+		}
+		return [{
+			featureName,
+			specName
+		}];
+	}
+	const tree = await listFeatureTree(cwd);
+	const out = [];
+	for (const feature of tree) for (const spec of feature.specs) {
+		if (!spec.hasSpecFile) continue;
+		const t = {
+			featureName: feature.featureName,
+			specName: spec.specName
+		};
+		if (spec.relatedPaths) t.relatedPaths = spec.relatedPaths;
+		if (spec.title) t.title = spec.title;
+		out.push(t);
+	}
+	return out;
+}
+async function runChecks(targets, concurrency, model, cwd, format) {
+	const results = new Array(targets.length);
+	let cursor = 0;
+	const worker = async () => {
+		while (true) {
+			const idx = cursor++;
+			if (idx >= targets.length) return;
+			const target = targets[idx];
+			results[idx] = await checkSpec(target, model, cwd, format);
+		}
+	};
+	const pool = Array.from({ length: Math.min(concurrency, targets.length) }, () => worker());
+	await Promise.all(pool);
+	return results;
+}
+async function checkSpec(target, model, cwd, format) {
+	const { featureName, specName } = target;
+	const existing = await tryReadSpecFile(featureName, specName, cwd);
+	if (existing === null) return {
+		target,
+		ok: false,
+		issues: [],
+		error: `spec file disappeared after enumeration: ${featureName}/${specName}`
+	};
+	if (format === "text") info(`checking ${featureName}/${specName}`);
+	const { result, isError } = await invokeClaudeStreaming({
+		prompt: buildDriftUserPrompt(existing),
+		systemPrompt: buildDriftSystemPrompt(),
+		allowedTools: [
+			"Read",
+			"Grep",
+			"Glob"
+		],
+		silenceBashLog: true,
+		cwd,
+		...model ? { model } : {}
+	}, (_msg) => {});
+	if (isError) return {
+		target,
+		ok: false,
+		issues: [],
+		error: "Claude returned an error result"
+	};
+	const json = extractJsonBlock(result);
+	if (!json) return {
+		target,
+		ok: false,
+		issues: [],
+		error: "Claude did not return a json block"
+	};
+	let report;
+	try {
+		report = DraftReportSchema.parse(JSON.parse(json));
+	} catch (e) {
+		return {
+			target,
+			ok: false,
+			issues: [],
+			error: `failed to parse drift report: ${e.message}`
+		};
+	}
+	return {
+		target,
+		ok: true,
+		issues: report.issues
+	};
+}
+function emitReport(results, format, cwd) {
+	if (format === "json") {
+		emitJson(results);
+		return;
+	}
+	if (format === "github") {
+		emitGithub(results, cwd);
+		return;
+	}
+	emitText(results);
+}
+const CATEGORY_LABEL = {
+	assertable: "Assertability",
+	setups: "Setup references",
+	granularity: "Step granularity",
+	unimplemented: "Unimplemented checks"
+};
+const HEAVY_RULE = "═".repeat(72);
+function emitText(results) {
+	for (const r of results) {
+		blank();
+		const heading = `══ ${r.target.featureName}/${r.target.specName} `;
+		const tail = "═".repeat(Math.max(3, 72 - heading.length));
+		process.stdout.write(`${heading}${tail}\n`);
+		if (r.error) {
+			process.stdout.write(`  ERROR  ${r.error}\n`);
+			continue;
+		}
+		const errors = r.issues.filter((i) => i.severity === "ERROR");
+		const warnings = r.issues.filter((i) => i.severity === "WARN");
+		const passed = r.issues.filter((i) => i.severity === "OK");
+		if (errors.length === 0 && warnings.length === 0) {
+			const label = passed.length === 1 ? "check" : "checks";
+			const detail = passed.length > 0 ? `all ${passed.length} ${label} passed` : "no issues";
+			process.stdout.write(`  ✓  ${detail}\n`);
+			continue;
+		}
+		for (const issue of errors) writeFinding("ERROR", issue);
+		for (const issue of warnings) writeFinding("WARN", issue);
+		if (passed.length > 0) {
+			const names = passed.map((i) => CATEGORY_LABEL[i.category]).join(", ");
+			process.stdout.write(`\n  ✓  passed (${passed.length}): ${names}\n`);
+		}
+	}
+	blank();
+	process.stdout.write(`${HEAVY_RULE}\n`);
+	const totals = summarize(results);
+	meta("specs", `${results.length} (${totals.errored} errored)`);
+	meta("findings", `${totals.error} error, ${totals.warn} warn, ${totals.ok} ok`);
+}
+function writeFinding(level, issue) {
+	const stepPart = issue.stepId ? ` ${issue.stepId}` : "";
+	process.stdout.write(`\n  ${level}  ${CATEGORY_LABEL[issue.category]}${stepPart}\n`);
+	process.stdout.write(`    ${issue.message}\n`);
+	if (issue.detail) process.stdout.write(`    └ ${issue.detail.replace(/\n/g, "\n      ")}\n`);
+}
+function emitJson(results) {
+	const payload = { specs: results.map((r) => ({
+		feature: r.target.featureName,
+		spec: r.target.specName,
+		ok: r.ok,
+		...r.error ? { error: r.error } : {},
+		issues: r.issues.map((i) => ({
+			severity: i.severity,
+			category: i.category,
+			stepId: i.stepId,
+			message: i.message,
+			...i.detail ? { detail: i.detail } : {}
+		}))
+	})) };
+	process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+}
+function emitGithub(results, cwd) {
+	const repoRoot = process.env["GITHUB_WORKSPACE"] ?? process.cwd();
+	for (const r of results) {
+		const file = githubRelPath(cwd, repoRoot, r.target.featureName, r.target.specName);
+		if (r.error) {
+			process.stdout.write(`::error file=${file}::${escapeGhMessage(r.error)}\n`);
+			continue;
+		}
+		for (const issue of r.issues) {
+			if (issue.severity === "OK") continue;
+			const level = issue.severity === "ERROR" ? "error" : "warning";
+			const title = `${r.target.featureName}/${r.target.specName} — ${issue.category}${issue.stepId ? ` (${issue.stepId})` : ""}`;
+			const body = issue.detail ? `${issue.message}\n${issue.detail}` : issue.message;
+			process.stdout.write(`::${level} file=${file},title=${escapeGhProp(title)}::${escapeGhMessage(body)}\n`);
+		}
+	}
+}
+function githubRelPath(cwd, repoRoot, featureName, specName) {
+	const abs = resolve(cwd, ".ccqa", "features", featureName, "test-cases", specName, "test-spec.md");
+	const rel = relative(repoRoot, abs);
+	return rel.startsWith("..") ? abs : rel;
+}
+function escapeGhMessage(s) {
+	return s.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A");
+}
+function escapeGhProp(s) {
+	return s.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A").replace(/,/g, "%2C").replace(/:/g, "%3A");
+}
+function summarize(results) {
+	let error = 0;
+	let warn = 0;
+	let ok = 0;
+	let errored = 0;
+	for (const r of results) {
+		if (r.error) errored++;
+		for (const issue of r.issues) if (issue.severity === "ERROR") error++;
+		else if (issue.severity === "WARN") warn++;
+		else ok++;
+	}
+	return {
+		error,
+		warn,
+		ok,
+		errored
+	};
+}
+function determineExitCode(results, threshold) {
+	for (const r of results) {
+		if (r.error) return 1;
+		for (const issue of r.issues) {
+			if (issue.severity === "ERROR") return 1;
+			if (threshold === "warn" && issue.severity === "WARN") return 1;
+		}
+	}
+	return 0;
+}
+function parseFormat(raw) {
+	const v = raw ?? "text";
+	if (v === "text" || v === "json" || v === "github") return v;
+	error(`invalid --format: ${v} (expected text|json|github)`);
+	process.exit(2);
+}
+function parseSeverity(raw) {
+	const v = raw ?? "error";
+	if (v === "warn" || v === "error") return v;
+	error(`invalid --severity: ${v} (expected warn|error)`);
+	process.exit(2);
+}
+function parseConcurrency(raw) {
+	if (raw === void 0) return DEFAULT_CONCURRENCY;
+	const n = Number.parseInt(raw, 10);
+	if (!Number.isFinite(n) || n < 1) {
+		error(`invalid --concurrency: ${raw} (expected positive integer)`);
+		process.exit(2);
+	}
+	return n;
+}
+//#endregion
 //#region src/cli/index.ts
 const packageJsonPath = resolvePackageJson();
 const { version } = JSON.parse(readFileSync(packageJsonPath, "utf8"));
@@ -3437,6 +4188,7 @@ function resolvePackageJson() {
 const program = new Command();
 program.name("ccqa").description("E2E test CLI using Claude Code + agent-browser").version(version);
 program.addCommand(draftCommand);
+program.addCommand(driftCommand);
 program.addCommand(traceCommand);
 program.addCommand(generateCommand);
 program.addCommand(runCommand);