ccqa 0.5.1 → 0.6.0

package/README.md

@@ -78,6 +78,7 @@ ccqa run tasks/create-and-complete --drift --format github
 | Assertion helper functions | [Assertions](./docs/assertions.md) |
 | Auto-fix failing tests | [Auto-fix](./docs/auto-fix.md) |
 | Detect spec/code drift in CI | [Drift](./docs/drift.md) |
+| Inventory existing test coverage | [Perspectives](./docs/perspectives.md) |
 
 ## Commands
 
@@ -87,9 +88,10 @@ ccqa trace <feature/spec>          Record browser actions for a spec (inlines an
 ccqa generate <feature/spec>       Generate test script from recorded actions
 ccqa run [feature/spec]            Execute generated test scripts (add --drift to analyze failures)
 ccqa drift [feature/spec]          Standalone spec ↔ codebase drift audit (for scheduled jobs)
+ccqa perspectives                  Inventory existing test coverage into .ccqa/perspectives.yaml
 ```
 
-All Claude-driven commands accept `-m, --model <name>` (alias `sonnet` | `opus` | `haiku`, or a full model ID). The flag overrides `CCQA_MODEL`; when both are unset, the Claude Code CLI default is used. Interactive commands authenticate via your local Claude Code login; commands that talk to Claude in CI (`ccqa run --drift`, `ccqa drift`) additionally honor `ANTHROPIC_API_KEY`.
+All Claude-driven commands accept `-m, --model <name>` (alias `sonnet` | `opus` | `haiku`, or a full model ID). The flag overrides `CCQA_MODEL`; when both are unset, the Claude Code CLI default is used. They also accept `--language <bcp47>` (e.g. `ja`, `en`) to set the language of human-readable output; the default `auto` follows the language of the spec/codebase. Interactive commands authenticate via your local Claude Code login; commands that talk to Claude in CI (`ccqa run --drift`, `ccqa drift`) additionally honor `ANTHROPIC_API_KEY`.
 
 `<feature/spec>` is a 2-segment alias for the on-disk path `.ccqa/features/<feature>/test-cases/<spec>/`.
 
@@ -97,11 +99,14 @@ All Claude-driven commands accept `-m, --model <name>` (alias `sonnet` | `opus`
 
 ```
 .ccqa/
+  perspectives.yaml              # Inventory of existing coverage (machine-readable, canonical)
+  perspectives.md                # Category index, regenerated from the YAML
   blocks/
     login/
       spec.yaml                  # Reusable block (params + steps)
   features/
     tasks/
+      perspectives.md            # Per-category detail tables (one per case)
       test-cases/
         create-and-complete/
           spec.yaml              # Test definition

package/dist/bin/ccqa.mjs

@@ -562,6 +562,71 @@ function isParamRequired(param) {
 	return param.required !== false;
 }
 //#endregion
+//#region src/spec/perspectives-schema.ts
+/**
+* `perspectives.yaml` is an inventory of the test coverage that already
+* exists under `.ccqa/` — the ccqa equivalent of a hand-kept QA spreadsheet,
+* but scoped deliberately to *facts about what is tested today*.
+*
+* It intentionally does NOT carry severity / importance / priority. Deciding
+* "how badly does it hurt the customer if this breaks" is a human + PdM
+* decision, not something ccqa should author or silently overwrite. Keeping
+* those columns out of the schema (and `.strict()` rejecting them) makes the
+* boundary explicit: perspectives is a factual stock-take, severity lives
+* wherever the team decides on it.
+*
+* It also does NOT attempt code-vs-test gap analysis (listing untested
+* areas). A flat dump of "things in code with no test" is noise without
+* prioritisation; that is a separate, later concern.
+*/
+/**
+* Whether the spec has been traced / generated. Both are derived mechanically
+* by the CLI from on-disk artifacts (actions.json / test.spec.ts), never
+* written by Claude — these are facts and must not drift.
+*/
+const PerspectiveStatusSchema = z.object({
+	traced: z.boolean(),
+	generated: z.boolean()
+}).strict();
+/**
+* One test case in the inventory.
+*
+* - `title` / `relatedPaths` are transcribed verbatim from the spec.yaml.
+* - `status` is mechanically derived (see PerspectiveStatusSchema).
+* - `summary` is a 1–2 sentence description of *what the spec verifies*,
+*   derived from its steps by Claude.
+* - `startScreen` / `testCondition` / `preconditions` mirror the columns a
+*   hand-kept QA table carries. They are Claude-derived from the spec's
+*   steps (the opening screen, the state the test assumes, and the setup
+*   prerequisites such as which role logs in). Optional: a spec may not
+*   express all of them.
+* - `note` is a human-only field. Regenerating perspectives preserves it.
+*
+* The detailed test procedure and expected results are deliberately NOT
+* duplicated here — the spec.yaml steps are the single source of truth for
+* those. The Markdown view links back to the spec instead of restating them.
+*/
+const PerspectiveSpecSchema = z.object({
+	specName: z.string().min(1),
+	title: z.string().min(1),
+	summary: z.string(),
+	startScreen: z.string().optional(),
+	testCondition: z.string().optional(),
+	preconditions: z.array(z.string().min(1)).optional(),
+	relatedPaths: z.array(z.string().min(1)).optional(),
+	status: PerspectiveStatusSchema,
+	note: z.string().optional()
+}).strict();
+const PerspectiveFeatureSchema = z.object({
+	featureName: z.string().min(1),
+	specs: z.array(PerspectiveSpecSchema)
+}).strict();
+/** Top-level perspectives schema. `.strict()` rejects any unknown key. */
+const PerspectivesSchema = z.object({
+	generatedAt: z.string().optional(),
+	features: z.array(PerspectiveFeatureSchema)
+}).strict();
+//#endregion
 //#region src/types.ts
 const RouteStepSchema = z.object({
 	title: z.string(),
@@ -633,7 +698,7 @@ const DraftIssueSchema = z.object({
 	]),
 	stepId: z.string().nullable(),
 	message: z.string(),
-	detail: z.string().optional()
+	detail: z.string().nullish()
 });
 const DraftReportSchema = z.object({
 	issues: z.array(DraftIssueSchema),
@@ -1205,6 +1270,8 @@ function collectIncludedBlockNames(spec) {
 //#region src/store/index.ts
 const CCQA_DIR = ".ccqa";
 const SPEC_FILE = "spec.yaml";
+const PERSPECTIVES_FILE = "perspectives.yaml";
+const PERSPECTIVES_MD_FILE = "perspectives.md";
 function getCcqaDir(cwd = process.cwd()) {
 	return join(cwd, CCQA_DIR);
 }
@@ -1250,6 +1317,56 @@ async function saveSpecFile(featureName, specName, content, cwd) {
 	await writeFile(specPath, content.endsWith("\n") ? content : content + "\n", "utf-8");
 	return specPath;
 }
+/** Absolute path to the single repo-wide `.ccqa/perspectives.yaml`. */
+function getPerspectivesPath(cwd) {
+	return join(getCcqaDir(cwd), PERSPECTIVES_FILE);
+}
+/**
+* Read `.ccqa/perspectives.yaml` raw. Returns null when the file does not
+* exist (first-ever generation) so callers can treat it as optional.
+*/
+async function tryReadPerspectives(cwd) {
+	return readFile(getPerspectivesPath(cwd), "utf-8").catch(() => null);
+}
+/**
+* Write `.ccqa/perspectives.yaml`. Mirrors `saveSpecFile`: ensures the
+* directory exists and the content ends in a trailing newline.
+*/
+async function savePerspectives(content, cwd) {
+	await mkdir(getCcqaDir(cwd), { recursive: true });
+	const path = getPerspectivesPath(cwd);
+	await writeFile(path, content.endsWith("\n") ? content : content + "\n", "utf-8");
+	return path;
+}
+/**
+* Human-readable Markdown companion to perspectives.yaml. The `.yaml` is the
+* machine-readable source of truth; the `.md` is a rendered view for review.
+*/
+function getPerspectivesMarkdownPath(cwd) {
+	return join(getCcqaDir(cwd), PERSPECTIVES_MD_FILE);
+}
+async function savePerspectivesMarkdown(content, cwd) {
+	await mkdir(getCcqaDir(cwd), { recursive: true });
+	const path = getPerspectivesMarkdownPath(cwd);
+	await writeFile(path, content.endsWith("\n") ? content : content + "\n", "utf-8");
+	return path;
+}
+/**
+* Per-category detail view: `.ccqa/features/<feature>/perspectives.md`. The
+* root `perspectives.md` is a thin category index that links here; this file
+* carries the full per-case tables for one feature. The feature dir already
+* exists (it holds the test cases), but `mkdir -p` keeps this safe when called
+* in isolation.
+*/
+function getFeaturePerspectivesMarkdownPath(featureName, cwd) {
+	return join(getFeatureDir(featureName, cwd), PERSPECTIVES_MD_FILE);
+}
+async function saveFeaturePerspectivesMarkdown(featureName, content, cwd) {
+	await mkdir(getFeatureDir(featureName, cwd), { recursive: true });
+	const path = getFeaturePerspectivesMarkdownPath(featureName, cwd);
+	await writeFile(path, content.endsWith("\n") ? content : content + "\n", "utf-8");
+	return path;
+}
 /**
 * Replace (or insert) the `relatedPaths` key in the spec. Preserves every
 * other top-level field and the entire steps array. Returns the absolute
@@ -2188,16 +2305,60 @@ function formatUnstableDrop(drop) {
 	return `${`${action.command}${action.assertType ? " " + action.assertType : ""}`}: contains unstable literal (${ids}) — ${samples}`;
 }
 //#endregion
+//#region src/prompts/language.ts
+/**
+* Shared language handling for every Claude-driven command. Each command
+* writes some human-readable text (drift findings, trace observations, draft
+* prose, diagnose hints, perspectives summaries), so the language policy is a
+* single cross-cutting concern rather than per-command logic.
+*
+* The value is a BCP-47 tag (e.g. "ja", "en") or the sentinel "auto". With
+* "auto" the model follows the language of the material it is given — Japanese
+* specs/codebase yield Japanese output — and `languageDirective` returns an
+* empty string so prompts stay byte-identical to the no-flag baseline.
+*/
+const DEFAULT_LANGUAGE = "auto";
+/**
+* The instruction appended to a command's system prompt. Empty for "auto"
+* (and undefined / blank), so the model keeps its natural material-following
+* behaviour; otherwise it pins every human-readable field to the given tag.
+*/
+function languageDirective(language) {
+	const lang = (language ?? "auto").trim();
+	if (lang === "" || lang === "auto") return "";
+	return `\n\nIMPORTANT: Write every human-readable field, message, and explanation in **${lang}** (BCP-47 language tag), regardless of the language of the spec or codebase.`;
+}
+/**
+* Whether the CLI's own interactive prompts (the strings ccqa prints itself,
+* not the model's output) should be Japanese. Only an explicit Japanese tag
+* (`ja`, `ja-JP`, …) opts in; `auto` (the default) and every other tag keep
+* the English prompts, so an English user running with no flag is unaffected.
+*/
+function useJapanesePrompts(language) {
+	return /^ja\b/i.test((language ?? "").trim());
+}
+//#endregion
+//#region src/cli/options.ts
+/**
+* Shared `--language` flag. Every Claude-driven command writes some
+* human-readable text, so language is a cross-cutting concern handled the same
+* way everywhere — much like `--model`. The value is a BCP-47 tag (e.g. "ja",
+* "en") or "auto" (default), which follows the language of the material.
+*/
+function addLanguageOption(command) {
+	return command.option("--language <bcp47>", "Language for human-readable output (e.g. 'en', 'ja'). Default 'auto' follows the language of the spec/codebase.", DEFAULT_LANGUAGE);
+}
+//#endregion
 //#region src/cli/trace.ts
 const VALIDATION_MODES = ["lenient", "strict"];
-const traceCommand = new Command("trace").argument("<feature/spec>", "Spec id in '<feature>/<spec>' form (resolves to .ccqa/features/<feature>/test-cases/<spec>/)").description("Run agent-browser, verify assertions, and record structured actions").option("-m, --model <name>", "Claude model alias ('sonnet'|'opus'|'haiku') or full ID. Overrides CCQA_MODEL.").option("--validation-mode <mode>", "Post-trace validation behaviour: 'lenient' (default) tags failing actions with a warning but keeps them; 'strict' drops them from actions.json.", (raw) => {
+const traceCommand = addLanguageOption(new Command("trace").argument("<feature/spec>", "Spec id in '<feature>/<spec>' form (resolves to .ccqa/features/<feature>/test-cases/<spec>/)").description("Run agent-browser, verify assertions, and record structured actions").option("-m, --model <name>", "Claude model alias ('sonnet'|'opus'|'haiku') or full ID. Overrides CCQA_MODEL.").option("--validation-mode <mode>", "Post-trace validation behaviour: 'lenient' (default) tags failing actions with a warning but keeps them; 'strict' drops them from actions.json.", (raw) => {
 	if (VALIDATION_MODES.includes(raw)) return raw;
 	throw new Error(`--validation-mode must be one of ${VALIDATION_MODES.join(" | ")}`);
-}, "lenient").action(async (specPath, opts) => {
+}, "lenient")).action(async (specPath, opts) => {
 	const { featureName, specName } = parseSpecPath(specPath);
-	await runTrace(featureName, specName, opts.model, opts.validationMode ?? "lenient");
+	await runTrace(featureName, specName, opts.model, opts.validationMode ?? "lenient", opts.language);
 });
-async function runTrace(featureName, specName, model, validationMode = "lenient") {
+async function runTrace(featureName, specName, model, validationMode = "lenient", language) {
 	header("trace", `${featureName}/${specName}`);
 	try {
 		meta("agent-browser", assertAgentBrowserAvailable());
@@ -2228,7 +2389,7 @@ async function runTrace(featureName, specName, model, validationMode = "lenient"
 	});
 	const userPrompt = await loadTraceUserPrompt();
 	if (userPrompt !== null) meta("user-prompt", ".ccqa/prompts/trace.user.md");
-	const systemPrompt = userPrompt === null ? baseSystemPrompt : `${baseSystemPrompt}\n## Project-specific guidance\n\n${userPrompt}\n`;
+	const systemPrompt = (userPrompt === null ? baseSystemPrompt : `${baseSystemPrompt}\n## Project-specific guidance\n\n${userPrompt}\n`) + languageDirective(language);
 	const prompt = buildTracePrompt(spec.title);
 	info("Running agent-browser session...");
 	blank();
@@ -3219,16 +3380,24 @@ function previewDiff(before, after) {
 //#endregion
 //#region src/diagnose/prompt.ts
 function buildDiagnosePrompt(input) {
-	const { script, specYaml, actions, failureLog, pageSnapshot, outputLanguage = "en" } = input;
+	const { script, specYaml, actions, failureLog, pageSnapshot, outputLanguage = "auto" } = input;
 	const numbered = script.split("\n").map((l, i) => `${i + 1}: ${l}`).join("\n");
+	const actionsSummary = actions.map((a, i) => {
+		const parts = [`${i + 1}. ${a.command}`];
+		if (a.assertType) parts.push(`assertType="${a.assertType}"`);
+		if (a.selector) parts.push(`selector="${a.selector}"`);
+		if (a.value) parts.push(`value="${a.value}"`);
+		if (a.observation) parts.push(`→ ${a.observation}`);
+		return parts.join(" ");
+	}).join("\n");
 	return `You are diagnosing a failing E2E test. The test was generated from a recorded trace of the original interaction. Compare the failing run against the original spec and recorded actions to determine WHY the test failed and what the right fix is.
 
-## Output language
+${outputLanguage === "auto" ? "" : `## Output language
 
 Write all human-readable fields (\`reasoning\`, \`reason\`) in **${outputLanguage}** (BCP-47 tag).
 Selectors, file paths, identifiers, code, type names (TIMING_ISSUE, etc.), JSON keys, and quoted strings stay verbatim regardless of language.
 
-## You have read-only filesystem tools
+`}## You have read-only filesystem tools
 
 You can call \`Grep\`, \`Glob\`, and \`Read\` against the current repository before producing the JSON.
 
@@ -3317,14 +3486,7 @@ Pick exactly ONE category. The output JSON must follow the shape for that catego
 ${specYaml}
 
 ## Recorded Actions (actions.json summary)
-${actions.map((a, i) => {
-		const parts = [`${i + 1}. ${a.command}`];
-		if (a.assertType) parts.push(`assertType="${a.assertType}"`);
-		if (a.selector) parts.push(`selector="${a.selector}"`);
-		if (a.value) parts.push(`value="${a.value}"`);
-		if (a.observation) parts.push(`→ ${a.observation}`);
-		return parts.join(" ");
-	}).join("\n")}
+${actionsSummary}
 
 ## Test Script (with line numbers)
 ${numbered}
@@ -3901,11 +4063,11 @@ function resolveMode(opts) {
 }
 //#endregion
 //#region src/cli/generate.ts
-const generateCommand = new Command("generate").argument("<feature/spec>", "Spec id in '<feature>/<spec>' form (resolves to .ccqa/features/<feature>/test-cases/<spec>/)").description("Generate agent-browser test script from recorded trace actions. test.spec.ts is regenerated from actions.json on every run; pass --force to overwrite manual edits.").option("--max-retries <n>", "Maximum number of auto-fix retries", "3").option("--auto", "Apply auto-fixes without confirmation regardless of confidence (CI use)").option("--no-interactive", "Never prompt; only auto-apply when confidence is high, otherwise give up").option("--force", "Overwrite an existing test.spec.ts without warning").option("--no-snapshot", "Don't pin AGENT_BROWSER_SESSION / capture page snapshots after a failure (debug toggle)").option("--language <bcp47>", "Language for diagnose reasoning / hint text (e.g. 'en', 'ja')", "en").option("-m, --model <name>", "Claude model alias ('sonnet'|'opus'|'haiku') or full ID. Overrides CCQA_MODEL.").action(async (specPath, opts) => {
+const generateCommand = addLanguageOption(new Command("generate").argument("<feature/spec>", "Spec id in '<feature>/<spec>' form (resolves to .ccqa/features/<feature>/test-cases/<spec>/)").description("Generate agent-browser test script from recorded trace actions. test.spec.ts is regenerated from actions.json on every run; pass --force to overwrite manual edits.").option("--max-retries <n>", "Maximum number of auto-fix retries", "3").option("--auto", "Apply auto-fixes without confirmation regardless of confidence (CI use)").option("--no-interactive", "Never prompt; only auto-apply when confidence is high, otherwise give up").option("--force", "Overwrite an existing test.spec.ts without warning").option("--no-snapshot", "Don't pin AGENT_BROWSER_SESSION / capture page snapshots after a failure (debug toggle)").option("-m, --model <name>", "Claude model alias ('sonnet'|'opus'|'haiku') or full ID. Overrides CCQA_MODEL.")).action(async (specPath, opts) => {
 	const { featureName, specName } = parseSpecPath(specPath);
 	const mode = resolveMode(opts);
 	const useSnapshot = opts.snapshot !== false;
-	await runGenerate(featureName, specName, parseInt(opts.maxRetries, 10), mode, opts.force ?? false, useSnapshot, opts.language ?? "en", opts.model);
+	await runGenerate(featureName, specName, parseInt(opts.maxRetries, 10), mode, opts.force ?? false, useSnapshot, opts.language ?? "auto", opts.model);
 });
 async function runGenerate(featureName, specName, maxRetries, mode, force, useSnapshot, outputLanguage, model) {
 	header("generate", `${featureName}/${specName}`);
@@ -4395,7 +4557,7 @@ const DEFAULT_CONCURRENCY$1 = 3;
 * `cli/run` calls this with just the failing specs after vitest.
 */
 async function analyzeDrift(input) {
-	const { targets, cwd, blocks, concurrency = DEFAULT_CONCURRENCY$1, model, onSpecStart } = input;
+	const { targets, cwd, blocks, concurrency = DEFAULT_CONCURRENCY$1, model, language, onSpecStart } = input;
 	const results = new Array(targets.length);
 	let cursor = 0;
 	const worker = async () => {
@@ -4407,7 +4569,8 @@ async function analyzeDrift(input) {
 			results[idx] = await checkSpec(target, {
 				cwd,
 				blocks,
-				model
+				model,
+				language
 			});
 		}
 	};
@@ -4426,7 +4589,7 @@ async function checkSpec(target, opts) {
 	};
 	const { result, isError } = await invokeClaudeStreaming({
 		prompt: buildDriftUserPrompt(existing),
-		systemPrompt: buildDriftSystemPrompt(opts.blocks),
+		systemPrompt: buildDriftSystemPrompt(opts.blocks) + languageDirective(opts.language),
 		allowedTools: [
 			"Read",
 			"Grep",
@@ -4634,7 +4797,7 @@ async function resolveVitestConfig() {
 		return bundledVitestConfigPath();
 	}
 }
-const runCommand = new Command("run").argument("[target]", "Spec to run: '<feature>/<spec>', '<feature>', or omit for all").description("Run generated agent-browser test scripts. Pass --drift to invoke a Claude-driven drift analysis on each failing spec (skipped silently when no test fails). Requires ANTHROPIC_API_KEY or a local Claude login.").option("--drift", "On vitest failure, run drift analysis on the failing specs").option("--drift-strict", "Treat drift ERROR findings as a run failure (exit 1 even if vitest passed). Implies --drift.").option("--format <fmt>", "Output format for the drift block: text | json | github", "text").option("-m, --model <name>", "Claude model alias ('sonnet'|'opus'|'haiku') or full ID. Used by --drift only. Overrides CCQA_MODEL.").action(async (target, opts) => {
+const runCommand = addLanguageOption(new Command("run").argument("[target]", "Spec to run: '<feature>/<spec>', '<feature>', or omit for all").description("Run generated agent-browser test scripts. Pass --drift to invoke a Claude-driven drift analysis on each failing spec (skipped silently when no test fails). Requires ANTHROPIC_API_KEY or a local Claude login.").option("--drift", "On vitest failure, run drift analysis on the failing specs").option("--drift-strict", "Treat drift ERROR findings as a run failure (exit 1 even if vitest passed). Implies --drift.").option("--format <fmt>", "Output format for the drift block: text | json | github", "text").option("-m, --model <name>", "Claude model alias ('sonnet'|'opus'|'haiku') or full ID. Used by --drift only. Overrides CCQA_MODEL.")).action(async (target, opts) => {
 	await runTests(target, opts);
 });
 async function runTests(target, opts) {
@@ -4754,6 +4917,7 @@ async function maybeRunDrift(summaries, opts, currentExitCode) {
 		blocks: await loadAvailableBlocks(cwd),
 		concurrency: Math.min(3, targets.length),
 		...opts.model ? { model: opts.model } : {},
+		...opts.language ? { language: opts.language } : {},
 		onSpecStart: (t) => {
 			if (format === "text") info(`drift: checking ${t.featureName}/${t.specName}`);
 		}
@@ -4866,7 +5030,7 @@ async function resolveSpecs(target) {
 //#endregion
 //#region src/cli/draft.ts
 const CATEGORY_LABEL = DRAFT_CATEGORY_LABEL;
-const draftCommand = new Command("draft").argument("[feature/spec]", "Optional spec path (e.g. tasks/create-and-complete). If omitted, Claude proposes one from your intent.").description("Interactively draft and refine a spec.yaml with Claude Code").option("--instruction <text>", "Non-interactive single-shot instruction (skips the interactive loop)").option("--apply", "Auto-apply each generated patch without [y/N] confirmation", false).action(async (specPath, opts) => {
+const draftCommand = addLanguageOption(new Command("draft").argument("[feature/spec]", "Optional spec path (e.g. tasks/create-and-complete). If omitted, Claude proposes one from your intent.").description("Interactively draft and refine a spec.yaml with Claude Code").option("--instruction <text>", "Non-interactive single-shot instruction (skips the interactive loop)").option("--apply", "Auto-apply each generated patch without [y/N] confirmation", false)).action(async (specPath, opts) => {
 	await ensureCcqaDir();
 	let featureName;
 	let specName;
@@ -4882,6 +5046,7 @@ const draftCommand = new Command("draft").argument("[feature/spec]", "Optional s
 });
 async function runDraft(featureName, specName, opts, prefilledIntent) {
 	header("draft", `${featureName}/${specName}`);
+	const ja = useJapanesePrompts(opts.language);
 	const oneShot = opts.instruction !== void 0;
 	let useIntentOnce = prefilledIntent !== null && !oneShot;
 	while (true) {
@@ -4892,7 +5057,7 @@ async function runDraft(featureName, specName, opts, prefilledIntent) {
 		else if (useIntentOnce && isFirstRun) {
 			userInput = prefilledIntent ?? "";
 			useIntentOnce = false;
-		} else userInput = await prompt(isFirstRun ? "What do you want to test? > " : "How would you like to refine? (empty = re-validate) > ");
+		} else userInput = await prompt(isFirstRun ? ja ? "何をテストしたいですか? > " : "What do you want to test? > " : ja ? "どのように修正しますか? (空欄で再検証) > " : "How would you like to refine? (empty = re-validate) > ");
 		if (isFirstRun && !userInput.trim()) {
 			error("intent required for the first draft (no spec exists yet)");
 			process.exit(1);
@@ -4902,11 +5067,12 @@ async function runDraft(featureName, specName, opts, prefilledIntent) {
 			specName,
 			existing,
 			userInput: userInput.trim(),
-			autoApply: opts.apply === true
+			autoApply: opts.apply === true,
+			language: opts.language
 		});
 		if (oneShot) process.exit(turnResult.hasError && !turnResult.applied ? 1 : 0);
 		blank();
-		if (/^y/i.test(await prompt("Are you done with this draft? [y/N] "))) {
+		if (/^y/i.test(await prompt(ja ? "このドラフトは完了ですか? [y/N] " : "Are you done with this draft? [y/N] "))) {
 			info("draft session complete.");
 			hint(`run 'ccqa trace ${featureName}/${specName}' to record actions`);
 			process.exit(0);
@@ -4914,9 +5080,9 @@ async function runDraft(featureName, specName, opts, prefilledIntent) {
 	}
 }
 async function runOneTurn(input) {
-	const { featureName, specName, existing, userInput, autoApply } = input;
+	const { featureName, specName, existing, userInput, autoApply, language } = input;
 	const isFirstRun = existing === null;
-	const systemPrompt = buildDraftSystemPrompt(await loadAvailableBlocks());
+	const systemPrompt = buildDraftSystemPrompt(await loadAvailableBlocks()) + languageDirective(language);
 	const userPrompt = buildDraftPrompt({
 		mode: isFirstRun ? "create" : "refine",
 		existing: existing ?? "",
@@ -4979,7 +5145,7 @@ async function runOneTurn(input) {
 	info("--- proposed changes ---");
 	printUnifiedDiff(original, report.patch);
 	blank();
-	if (!(autoApply ? true : /^y/i.test(await prompt("Apply this patch? [y/N] ")))) {
+	if (!(autoApply ? true : /^y/i.test(await prompt(useJapanesePrompts(language) ? "このパッチを適用しますか? [y/N] " : "Apply this patch? [y/N] ")))) {
 		info("aborted — no changes applied.");
 		return {
 			hasError,
@@ -5071,8 +5237,9 @@ function writeFinding(issue) {
 	if (issue.detail) process.stdout.write(`      └ ${issue.detail.replace(/\n/g, "\n        ")}\n`);
 }
 async function proposeNaming(opts) {
+	const ja = useJapanesePrompts(opts.language);
 	const oneShot = opts.instruction !== void 0;
-	const intent = oneShot ? opts.instruction ?? "" : await prompt("What do you want to test? > ");
+	const intent = oneShot ? opts.instruction ?? "" : await prompt(ja ? "何をテストしたいですか? > " : "What do you want to test? > ");
 	if (!intent.trim()) {
 		error("intent required to propose a feature/spec name");
 		process.exit(1);
@@ -5124,13 +5291,13 @@ async function proposeNaming(opts) {
 		naming: final,
 		intent: intent.trim()
 	};
-	const answer = await prompt(`Use this name? [y/N/edit] > `);
+	const answer = await prompt(ja ? "この名前を使いますか? [y/N/edit] > " : "Use this name? [y/N/edit] > ");
 	if (/^y/i.test(answer)) return {
 		naming: final,
 		intent: intent.trim()
 	};
 	if (/^e/i.test(answer)) {
-		const manual = await prompt("Enter feature/spec (e.g. tasks/create-and-complete) > ");
+		const manual = await prompt(ja ? "feature/spec を入力 (例 tasks/create-and-complete) > " : "Enter feature/spec (e.g. tasks/create-and-complete) > ");
 		const parts = manual.split("/");
 		if (parts.length !== 2 || !parts[0] || !parts[1]) {
 			error(`invalid spec path: "${manual}". Expected "<feature>/<spec>"`);
@@ -5503,7 +5670,7 @@ Return the spec keys that might be affected by any of the new files. Conservativ
 //#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 spec.yaml 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 driftCommand = addLanguageOption(new Command("drift").argument("[feature/spec]", "Optional spec id. If omitted, every spec under .ccqa/features/ is checked.").description("Check whether each spec.yaml 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);
@@ -5538,6 +5705,7 @@ const driftCommand = new Command("drift").argument("[feature/spec]", "Optional s
 		blocks,
 		concurrency,
 		...opts.model ? { model: opts.model } : {},
+		...opts.language ? { language: opts.language } : {},
 		onSpecStart: (t) => {
 			if (format === "text") info(`checking ${t.featureName}/${t.specName}`);
 		}
@@ -5650,6 +5818,446 @@ function parseConcurrency(raw) {
 	return n;
 }
 //#endregion
+//#region src/prompts/perspectives.ts
+/**
+* Build the system prompt. By default the descriptive fields follow the
+* spec's own language (Japanese specs → Japanese fields). An explicit
+* `--language` is applied by the CLI via `languageDirective`, appended to
+* this prompt, so the language handling lives in one shared place.
+*/
+function buildPerspectivesSystemPrompt() {
+	return `You produce a factual inventory of the E2E test coverage that already exists in a ccqa project.
+
+Think of it as a QA coverage stock-take: for each existing test case, fill in a few short, neutral descriptive fields derived from its steps. Nothing more.
+
+## Hard boundaries (do NOT cross)
+
+- Do NOT assign severity, importance, priority, or risk. Whether a failure hurts the customer is a human + PdM decision; you are not authoring that here.
+- Do NOT do gap analysis. Do NOT list untested areas, missing coverage, or things the code has but the tests lack.
+- Do NOT evaluate whether the feature is good, complete, or correct.
+- Do NOT propose new test cases.
+- Do NOT restate the full step-by-step procedure or the per-step expected results — the spec.yaml is the source of truth for those and the inventory links to it.
+- Do NOT touch status, relatedPaths, feature names, or spec names — the CLI already fixed those.
+
+## Fields to write (per spec)
+
+- \`summary\`: 1–2 sentences, factual and neutral. What the test exercises and what it ultimately asserts, derived from the spec's \`steps\` (\`instruction\` / \`expected\`).
+- \`startScreen\`: the screen/URL the test first lands on after setup (e.g. "Dashboard (/dashboard)"). Derive from the first non-login \`instruction\`. Omit if genuinely unclear.
+- \`testCondition\`: the state/precondition the scenario assumes, phrased as a condition (e.g. "Logged in as an admin", "Unauthenticated user"). Omit if none.
+- \`preconditions\`: array of short setup prerequisites (e.g. which role logs in, required prior state). Derive from \`include: login\` params and the opening steps. Empty/omit if none.
+
+## How to write
+
+- Same language as the spec's title (if titles are Japanese, write these fields in Japanese).
+- Keep each field short. These are index entries, not the test itself.
+- You may use Read/Grep/Glob sparingly to clarify domain vocabulary, but the steps are the primary source. Do not over-explore.
+
+## Output contract (STRICT)
+
+Output exactly ONE fenced \`\`\`json code block, and nothing else outside it. No prose before or after.
+
+Schema:
+
+\`\`\`json
+{
+  "summaries": [
+    {
+      "featureName": "<verbatim from input>",
+      "specName": "<verbatim from input>",
+      "summary": "<1–2 sentence factual description of what this test verifies>",
+      "startScreen": "<opening screen/URL, or omit>",
+      "testCondition": "<assumed state phrased as a condition, or omit>",
+      "preconditions": ["<setup prerequisite>", "..."]
+    }
+  ]
+}
+\`\`\`
+
+Return one entry per spec given in the input. Echo featureName and specName verbatim so the CLI can match them. \`startScreen\`, \`testCondition\`, and \`preconditions\` are optional — omit a field (or use an empty array for preconditions) when the spec does not express it.
+`;
+}
+function buildPerspectivesPrompt(specs, instruction) {
+	return `## Existing test cases to summarise
+
+${specs.map((s) => `### ${s.featureName}/${s.specName}
+title: ${s.title}
+
+\`\`\`yaml
+${s.specYaml.trimEnd()}
+\`\`\`
+`).join("\n")}
+${instruction?.trim() ? `## Extra guidance from the user\n\n${instruction.trim()}\n\n` : ""}## Task
+
+For each test case above, write a 1–2 sentence factual \`summary\` of what it verifies, derived from its steps. Return one entry per spec in the JSON contract. Do not assign severity, do gap analysis, or invent new cases.
+`;
+}
+//#endregion
+//#region src/cli/perspectives.ts
+const perspectivesCommand = addLanguageOption(new Command("perspectives").description("Generate/update .ccqa/perspectives.yaml — a factual inventory of existing test coverage (no severity, no gap analysis)").option("--instruction <text>", "Hint to steer how summaries are written").option("--apply", "Auto-apply without [y/N] confirmation", false).option("-m, --model <name>", "Claude model alias ('sonnet'|'opus'|'haiku') or full ID")).action(async (opts) => {
+	await runPerspectives(opts);
+});
+async function runPerspectives(opts) {
+	header("perspectives", ".ccqa/perspectives.yaml");
+	await ensureCcqaDir();
+	const skeleton = await buildSkeleton(await listFeatureTree());
+	const allSpecs = skeleton.flatMap((f) => f.specs);
+	if (allSpecs.length === 0) {
+		info("no test cases found under .ccqa/features — nothing to inventory.");
+		return;
+	}
+	const existingRaw = await tryReadPerspectives() ?? "";
+	const noteMap = extractNotes(existingRaw);
+	const specBodies = await loadSpecBodies(skeleton);
+	meta("language", opts.language ?? "auto");
+	info(`Summarising ${allSpecs.length} test case(s) across ${skeleton.length} feature(s)...`);
+	const summaries = await requestSummaries(specBodies, opts);
+	if (summaries === null) process.exit(1);
+	const merged = mergePerspectives(skeleton, summaries, noteMap);
+	let validated;
+	try {
+		validated = PerspectivesSchema.parse(merged);
+	} catch (e) {
+		error(`refused to write: assembled perspectives failed validation (${e.message})`);
+		process.exit(1);
+	}
+	const next = stringify(validated, { lineWidth: 0 });
+	if (withoutGeneratedAt(existingRaw) === withoutGeneratedAt(next)) {
+		blank();
+		info("perspectives already up to date — no changes.");
+		return;
+	}
+	blank();
+	info("--- proposed changes (perspectives.yaml) ---");
+	printUnifiedDiff(existingRaw, next);
+	blank();
+	if (!(opts.apply === true || /^y/i.test(await prompt(useJapanesePrompts(opts.language) ? "perspectives.yaml + .md を書き込みますか? [y/N] " : "Write perspectives.yaml + .md? [y/N] ")))) {
+		info("aborted — no changes written.");
+		return;
+	}
+	meta("saved", await savePerspectives(next));
+	const labels = labelsFor(opts.language);
+	meta("saved", await savePerspectivesMarkdown(renderIndexMarkdown(validated, labels)));
+	for (const feature of validated.features) meta("saved", await saveFeaturePerspectivesMarkdown(feature.featureName, renderFeatureMarkdown(feature, labels)));
+}
+/**
+* Turn the feature tree into the skeleton perspectives features: title +
+* relatedPaths transcribed from each spec, status derived mechanically from
+* on-disk artifacts. `summary` is left empty here; Claude fills it later.
+* Specs whose spec.yaml is missing or unparsable are skipped.
+*/
+async function buildSkeleton(tree) {
+	return (await Promise.all(tree.map(async (feature) => {
+		const specs = await Promise.all(feature.specs.filter((s) => s.hasSpecFile).map(async (s) => {
+			const spec = await readSpecMeta(feature.featureName, s.specName);
+			const status = await deriveStatus(feature.featureName, s.specName);
+			const entry = {
+				specName: s.specName,
+				title: spec.title,
+				summary: "",
+				status
+			};
+			if (s.relatedPaths) entry.relatedPaths = s.relatedPaths;
+			return entry;
+		}));
+		return {
+			featureName: feature.featureName,
+			specs
+		};
+	}))).filter((f) => f.specs.length > 0).map((f) => ({
+		featureName: f.featureName,
+		specs: [...f.specs].sort((a, b) => a.specName.localeCompare(b.specName))
+	})).sort((a, b) => a.featureName.localeCompare(b.featureName));
+}
+/**
+* `(featureName, specName)` → human note, parsed from an existing
+* perspectives.yaml. Notes are preserved across regeneration; everything
+* else (title, status, summary) is recomputed. Returns an empty map when the
+* input is empty or unparsable — note preservation is best-effort and never
+* blocks regeneration.
+*/
+function extractNotes(existingRaw) {
+	const map = /* @__PURE__ */ new Map();
+	if (!existingRaw.trim()) return map;
+	let parsed;
+	try {
+		parsed = parse(existingRaw);
+	} catch {
+		return map;
+	}
+	const result = PerspectivesSchema.safeParse(parsed);
+	if (!result.success) return map;
+	for (const feature of result.data.features) for (const spec of feature.specs) if (spec.note !== void 0 && spec.note !== "") map.set(noteKey(feature.featureName, spec.specName), spec.note);
+	return map;
+}
+/**
+* Merge the mechanical skeleton with Claude's summaries and the preserved
+* notes into the final perspectives object. Summaries are matched by
+* (featureName, specName); an unmatched spec keeps its empty summary.
+*/
+function mergePerspectives(skeleton, summaries, noteMap) {
+	const summaryMap = /* @__PURE__ */ new Map();
+	for (const s of summaries) summaryMap.set(noteKey(s.featureName, s.specName), s);
+	const features = skeleton.map((feature) => ({
+		featureName: feature.featureName,
+		specs: feature.specs.map((spec) => {
+			const key = noteKey(feature.featureName, spec.specName);
+			const entry = summaryMap.get(key);
+			const merged = {
+				...spec,
+				summary: entry?.summary ?? spec.summary
+			};
+			if (entry?.startScreen) merged.startScreen = entry.startScreen;
+			if (entry?.testCondition) merged.testCondition = entry.testCondition;
+			if (entry?.preconditions && entry.preconditions.length > 0) merged.preconditions = entry.preconditions;
+			const note = noteMap.get(key);
+			if (note !== void 0) merged.note = note;
+			return merged;
+		})
+	}));
+	return {
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		features
+	};
+}
+/**
+* Strip the top-level `generatedAt:` line so two serialised perspectives can
+* be compared for substantive equality without the always-fresh timestamp
+* defeating the "already up to date" check. Exported for unit testing.
+*/
+function withoutGeneratedAt(yamlText) {
+	return yamlText.split("\n").filter((line) => !/^generatedAt:/.test(line)).join("\n").trim();
+}
+function noteKey(featureName, specName) {
+	return `${featureName}/${specName}`;
+}
+async function readSpecMeta(featureName, specName) {
+	const raw = await tryReadSpecFile(featureName, specName);
+	if (raw === null) return { title: specName };
+	try {
+		const parsed = parse(raw);
+		if (typeof parsed.title === "string" && parsed.title.length > 0) return { title: parsed.title };
+	} catch {}
+	return { title: specName };
+}
+async function deriveStatus(featureName, specName) {
+	return {
+		traced: await stat(join(getSpecDir(featureName, specName), "actions.json")).then(() => true).catch(() => false),
+		generated: await getTestScript(featureName, specName) !== null
+	};
+}
+async function loadSpecBodies(skeleton) {
+	return await Promise.all(skeleton.flatMap((feature) => feature.specs.map(async (spec) => {
+		const specYaml = await tryReadSpecFile(feature.featureName, spec.specName) ?? "";
+		return {
+			featureName: feature.featureName,
+			specName: spec.specName,
+			title: spec.title,
+			specYaml
+		};
+	})));
+}
+async function requestSummaries(specs, opts) {
+	const toolCounts = {};
+	const startedAt = Date.now();
+	const { result, isError } = await invokeClaudeStreaming({
+		prompt: buildPerspectivesPrompt(specs, opts.instruction),
+		systemPrompt: buildPerspectivesSystemPrompt() + languageDirective(opts.language),
+		allowedTools: [
+			"Read",
+			"Grep",
+			"Glob"
+		],
+		silenceBashLog: true,
+		...opts.model ? { model: opts.model } : {}
+	}, (msg) => {
+		if (msg.type !== "assistant") return;
+		for (const block of msg.message.content ?? []) if (block.type === "tool_use") toolCounts[block.name] = (toolCounts[block.name] ?? 0) + 1;
+	});
+	process.stdout.write(`${formatToolSummary(toolCounts, Date.now() - startedAt)}\n`);
+	if (isError) {
+		error("Claude returned an error result");
+		return null;
+	}
+	const json = extractJsonBlock(result);
+	if (!json) {
+		error("Claude did not return a json block");
+		return null;
+	}
+	return parseSummaries(json);
+}
+/**
+* Parse the `{ summaries: [...] }` JSON contract into typed entries. Returns
+* null and logs when the payload is malformed. Exported for unit testing.
+*/
+function parseSummaries(json) {
+	let payload;
+	try {
+		payload = JSON.parse(json);
+	} catch (e) {
+		error(`failed to parse summaries JSON: ${e.message}`);
+		return null;
+	}
+	if (typeof payload !== "object" || payload === null) {
+		error("summaries payload is not an object");
+		return null;
+	}
+	const summaries = payload.summaries;
+	if (!Array.isArray(summaries)) {
+		error("summaries payload missing a `summaries` array");
+		return null;
+	}
+	const out = [];
+	for (const item of summaries) {
+		const rec = item ?? {};
+		const { featureName, specName, summary } = rec;
+		if (typeof featureName === "string" && typeof specName === "string" && typeof summary === "string") {
+			const entry = {
+				featureName,
+				specName,
+				summary
+			};
+			if (typeof rec.startScreen === "string" && rec.startScreen.length > 0) entry.startScreen = rec.startScreen;
+			if (typeof rec.testCondition === "string" && rec.testCondition.length > 0) entry.testCondition = rec.testCondition;
+			if (Array.isArray(rec.preconditions)) {
+				const pre = rec.preconditions.filter((p) => typeof p === "string" && p.length > 0);
+				if (pre.length > 0) entry.preconditions = pre;
+			}
+			out.push(entry);
+		}
+	}
+	return out;
+}
+const LABELS_JA = {
+	indexTitle: "テスト観点インデックス (perspectives)",
+	caseCol: "ケース",
+	itemCol: "項目",
+	valueCol: "内容",
+	summary: "検証内容",
+	preconditions: "前提条件",
+	startScreen: "開始画面",
+	relatedCode: "関連コード"
+};
+const LABELS_EN = {
+	indexTitle: "Test Perspectives (perspectives)",
+	caseCol: "Case",
+	itemCol: "Item",
+	valueCol: "Value",
+	summary: "Verifies",
+	preconditions: "Preconditions",
+	startScreen: "Start screen",
+	relatedCode: "Related code"
+};
+/**
+* Pick the label set for a `--language` value. Only an explicit English tag
+* (`en`, `en-US`, …) switches to English labels; `auto`, `ja`, and anything
+* else keep Japanese, matching the source-following default the rest of the
+* command uses.
+*/
+function labelsFor(language) {
+	return /^en\b/i.test(language?.trim() ?? "") ? LABELS_EN : LABELS_JA;
+}
+/**
+* Path to a spec.yaml relative to the **root** `.ccqa/perspectives.md`
+* (i.e. relative to the `.ccqa/` dir). Used for the category index links.
+*/
+function specRelPathFromRoot(featureName, specName) {
+	return `features/${featureName}/test-cases/${specName}/spec.yaml`;
+}
+/**
+* Path to a category detail file relative to the **root** `.ccqa/perspectives.md`.
+* The detail file is written to `.ccqa/features/<feature>/perspectives.md`
+* (see `getFeaturePerspectivesMarkdownPath`), so the link must include the
+* `features/` segment — otherwise the category heading link 404s.
+*/
+function featureDetailRelPathFromRoot(featureName) {
+	return `features/${featureName}/perspectives.md`;
+}
+/**
+* Path to a spec.yaml relative to the **category** detail file
+* `.ccqa/features/<feature>/perspectives.md`. The spec lives alongside under
+* `test-cases/<spec>/`, so the category file links to it directly — which is
+* what makes the link resolve both on GitHub and in a local editor.
+*/
+function specRelPathFromCategory(specName) {
+	return `test-cases/${specName}/spec.yaml`;
+}
+/**
+* Render the root `.ccqa/perspectives.md`: a category-grouped index of which
+* cases exist. Each feature is a heading (linking to its own detail
+* `perspectives.md`) followed by a row per case — title, status, and a link
+* to that case's spec.yaml. The per-case *detail* (検証内容, preconditions,
+* note) still lives only in the per-category file; the root stays a scannable
+* "what is tested, and where" overview.
+*
+* Pure and deterministic, so the index rendering is easy to unit-test.
+*/
+function renderIndexMarkdown(perspectives, labels = LABELS_JA) {
+	const lines = [];
+	lines.push(`# ${labels.indexTitle}`);
+	lines.push("");
+	for (const feature of perspectives.features) {
+		const detailLink = featureDetailRelPathFromRoot(feature.featureName);
+		lines.push(`## [${feature.featureName}](${detailLink})`);
+		lines.push("");
+		lines.push(`| ${labels.caseCol} | spec |`);
+		lines.push("| --- | --- |");
+		for (const spec of feature.specs) {
+			const specLink = specRelPathFromRoot(feature.featureName, spec.specName);
+			lines.push(`| ${mdCell(spec.title)} | [spec](${specLink}) |`);
+		}
+		lines.push("");
+	}
+	return lines.join("\n");
+}
+/**
+* Render one category's `.ccqa/features/<feature>/perspectives.md`: every
+* case in the category as a self-contained vertical table. All columns —
+* including the verification summary (検証内容) and the human note — live
+* inside the table; nothing is emitted outside it. Detailed steps / expected
+* results are still not restated (the spec.yaml is their single home); the
+* table links back to each spec instead.
+*
+* Pure and deterministic, so the per-case rendering is easy to unit-test.
+*/
+function renderFeatureMarkdown(feature, labels = LABELS_JA) {
+	const lines = [];
+	lines.push(`# ${feature.featureName}`);
+	lines.push("");
+	for (const spec of feature.specs) lines.push(...renderSpecMarkdown(spec, labels));
+	return lines.join("\n");
+}
+/**
+* Render one spec as a single vertical (item | content) Markdown table for a
+* category file. Verification summary and preconditions lead. The spec link
+* is relative to this category file so it resolves both on GitHub and in a
+* local editor. Related-code paths stay inline code rather than links: their
+* base (the cwd that hosts `.ccqa/`) is not reliably recoverable here — specs
+* carry a mix of cwd-relative (`src/...`) and repo-root (`pkg/app/src/...`)
+* forms — and many are globs that no link could open anyway. 検証内容
+* (summary) and note are rows inside the table; no prose blocks are emitted
+* around it. Exported for focused unit testing.
+*/
+function renderSpecMarkdown(spec, labels = LABELS_JA) {
+	const lines = [];
+	lines.push(`## ${spec.title}`);
+	lines.push("");
+	lines.push(`| ${labels.itemCol} | ${labels.valueCol} |`);
+	lines.push("| --- | --- |");
+	if (spec.summary) lines.push(`| ${labels.summary} | ${mdCell(spec.summary)} |`);
+	if (spec.preconditions && spec.preconditions.length > 0) lines.push(`| ${labels.preconditions} | ${spec.preconditions.map(mdCell).join("<br>")} |`);
+	if (spec.startScreen) lines.push(`| ${labels.startScreen} | ${mdCell(spec.startScreen)} |`);
+	const specPath = specRelPathFromCategory(spec.specName);
+	lines.push(`| spec | [${specPath}](${specPath}) |`);
+	if (spec.relatedPaths && spec.relatedPaths.length > 0) lines.push(`| ${labels.relatedCode} | ${spec.relatedPaths.map((p) => `\`${p}\``).join("<br>")} |`);
+	if (spec.note) lines.push(`| 📝 note | ${mdCell(spec.note)} |`);
+	lines.push("");
+	return lines;
+}
+/** Escape pipes / newlines so a value stays inside one Markdown table cell. */
+function mdCell(value) {
+	return value.replace(/\|/g, "\\|").replace(/\n/g, " ");
+}
+//#endregion
 //#region src/cli/index.ts
 const packageJsonPath = resolvePackageJson();
 const { version } = JSON.parse(readFileSync(packageJsonPath, "utf8"));
@@ -5667,6 +6275,7 @@ 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(perspectivesCommand);
 program.addCommand(traceCommand);
 program.addCommand(generateCommand);
 program.addCommand(runCommand);

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccqa",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "type": "module",
   "description": "Browser test recorder powered by Claude Code and agent-browser",
   "repository": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccqa",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "type": "module",
   "description": "Browser test recorder powered by Claude Code and agent-browser",
   "repository": {