phasegate 0.143.0 → 0.144.0

package/CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.144.0] - 2026-05-10
+
+### Added
+
+- **WI-129 / WI-130 — semantic L2 test-quality validation** — `L2-003 test-quality` を test case 単位の semantic AAA / assertion strength モデルへ更新した。
+  - TypeScript adapter は AST から `TestCaseStructure` / `SemanticAssertion` を構築し、複数 Act、Act 観測不足、Act 以外への Assert、domain/internal mock、weak truthiness / snapshot only / length only / interaction only、error contract 不足を warning として検出する。
+  - lifecycle/E2E と parameterized test の例外を追加し、weak assertion policy は constructor option で差し替え可能にした。
+
 ## [0.142.0] - 2026-05-10
 
 ### Added

package/README.ja.md

@@ -142,7 +142,7 @@ npx phasegate update-skills   # スキルを最新版に再デプロイ
 |     @unit / @layer メタデータ, レイヤー違反, AI アンチパターン   |
 +------------------------------------------------------------------+
 | L2  pre-commit                                                   |
-|     phase-gate, story-reflection, テスト品質 (AAA/日本語名)       |
+|     phase-gate, story-reflection, テスト品質 (semantic AAA)       |
 +------------------------------------------------------------------+
 | L3  CI/CD                                                        |
 |     security, performance, coverage 90%/95%, 要件カバレッジ        |

package/README.md

@@ -139,7 +139,7 @@ npx phasegate update-skills
 +------------------------------------------------------------------+
 |  L2  PRE-COMMIT            Validators                            |
 |  phase-gate, metadata completeness, story-reflection,            |
-|  test-quality (AAA pattern)                                      |
+|  test-quality (semantic AAA + assertion strength)                |
 +------------------------------------------------------------------+
 |  L3  CI/CD                 Validators                            |
 |  security, performance, coverage threshold, nyquist traceability |

package/docs/guide/layer-model.md

@@ -108,7 +108,7 @@ L2 validators run before every commit. They enforce process discipline and test
 |-----------|-------------|
 | **phase-gate** | Enforces design-before-implementation order. Code changes to `scripts/harness/` are blocked unless the corresponding design documents exist in `docs/product/construction/`. |
 | **metadata** | Verifies completeness of source file annotations: `@unit`, `@layer`, `@US-XXX`, and `@story` |
-| **test-quality** | Enforces test authoring standards: AAA pattern (Arrange/Act/Assert), `actual` variable naming, single-act-per-test, and no mocking in domain layer tests |
+| **test-quality** | Enforces test authoring standards through a runner-independent semantic model: AAA pattern (Arrange/Act/Assert), named Act observation, single-act-per-test, assertion strength, lifecycle/E2E exceptions, and no domain/internal mocking in domain layer tests |
 
 **Command:**
 

package/docs/guide/quick-vs-full-mode.md

@@ -46,7 +46,7 @@ flowchart TD
 | L4 Scheduled | drift + consistency + dead-code | skipped |
 | Commit prefix | conventional (`feat:`, `fix:`, ...) | `[quick] ...` |
 
-Both modes keep **L1 in full strength** and **L2 metadata / test-quality** — `@unit` / `@layer` comments and AAA test structure are non-negotiable regardless of flow.
+Both modes keep **L1 in full strength** and **L2 metadata / test-quality** — `@unit` / `@layer` comments, semantic AAA structure, and assertion-strength checks are non-negotiable regardless of flow.
 
 ---
 

package/docs/principles/testing-rules.md

@@ -12,6 +12,24 @@
 - 実行結果は `actual` に代入する。
 - テストの関心外の共通準備はヘルパーやファクトリに寄せる。ただし、各テストの前提が読めなくなるほど隠蔽しない。
 
+## Semantic AAA と Assertion Quality
+
+<!-- @work-item-id WI-129, WI-130 -->
+
+AAA は特定の runner やコメント表記ではなく、テストケースが以下の意味構造を持つこととして扱う。
+
+| 構造 | 意味 |
+|------|------|
+| Arrange | 前提条件、入力、fixture、制御可能な依存を組み立てる |
+| Act | 観測したいふるまいを実行する。Unit / Integration では原則 1 つ |
+| Assert | Act の観測結果、状態変化、発行イベント、永続化結果、error contract、interaction を検証する |
+
+Assertion Quality は matcher 名だけで判断しない。観測対象は `observed output` / `state` / `emitted event` / `persisted effect` / `error contract` / `interaction` に分類し、観測強度は `exact value` / `shape` / `invariant` / `range` / `weak truthiness` / `snapshot only` / `interaction only` / `length only` に分類する。
+
+- `toBeTruthy()` 相当の truthiness のみ、snapshot のみ、length のみ、mock call count のみは弱い観測として扱う。
+- error case は error type / code / message / recovery hint などの contract を検証する。
+- E2E の一連のライフサイクルは複数 Act を許可してよいが、各 Act の直後に観測可能な Assert を置く。
+
 ## テスト構造
 
 `target` / `describe` / `context` / `it` は以下の役割で使う。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phasegate",
-  "version": "0.143.0",
+  "version": "0.144.0",
   "packageManager": "pnpm@10.30.1",
   "description": "Phasegate — AI-agnostic quality defense toolkit. Enforces structural integrity between design intent and code.",
   "license": "MIT",

package/scripts/harness/validator-system/domain/value-objects/test-quality-semantics.ts

@@ -0,0 +1,58 @@
+// @unit validator-system
+// @layer domain
+// @work-item-id WI-129
+// @work-item-id WI-130
+
+export type TestCaseKind = 'unit' | 'integration' | 'e2e' | 'lifecycle';
+
+export type TestStepKind = 'arrange' | 'act' | 'assert';
+
+export type AssertionTarget =
+  | 'observed-output'
+  | 'state'
+  | 'emitted-event'
+  | 'persisted-effect'
+  | 'error-contract'
+  | 'interaction';
+
+export type AssertionStrength =
+  | 'exact-value'
+  | 'shape'
+  | 'invariant'
+  | 'range'
+  | 'weak-truthiness'
+  | 'snapshot-only'
+  | 'interaction-only'
+  | 'length-only';
+
+export interface SemanticAssertion {
+  readonly target: AssertionTarget;
+  readonly strength: AssertionStrength;
+  readonly subject: string;
+  readonly line: number;
+}
+
+export interface TestStep {
+  readonly kind: TestStepKind;
+  readonly expression: string;
+  readonly line: number;
+  readonly observedName?: string;
+  readonly assertion?: SemanticAssertion;
+}
+
+export interface TestDoubleReplacement {
+  readonly target: string;
+  readonly line: number;
+  readonly dependencyKind: 'external' | 'domain-internal';
+}
+
+export interface TestCaseStructure {
+  readonly filePath: string;
+  readonly name: string;
+  readonly line: number;
+  readonly kind: TestCaseKind;
+  readonly steps: readonly TestStep[];
+  readonly assertions: readonly SemanticAssertion[];
+  readonly mocks: readonly TestDoubleReplacement[];
+  readonly allowsMultipleActs: boolean;
+}

package/scripts/harness/validator-system/infrastructure/adapters/biome-ast-test-quality-analyzer-adapter.ts

@@ -1,57 +1,475 @@
 /**
  * @layer infrastructure
  * @unit validator-system
+ * @work-item-id WI-129
+ * @work-item-id WI-130
  *
- * BiomeAstTestQualityAnalyzerAdapter — TestQualityAnalyzerPort実装
- * testing-rules.md準拠チェック: 日本語テスト名・actual変数・AAA構造
+ * BiomeAstTestQualityAnalyzerAdapter — TestQualityAnalyzerPort implementation.
  */
 import { readFile } from 'node:fs/promises';
+import * as ts from 'typescript';
 import type { TestQualityAnalyzerPort } from '../../domain/ports/test-quality-analyzer-port.js';
+import type {
+  AssertionStrength,
+  AssertionTarget,
+  SemanticAssertion,
+  TestCaseKind,
+  TestCaseStructure,
+  TestDoubleReplacement,
+  TestStep,
+} from '../../domain/value-objects/test-quality-semantics.js';
 import type { HarnessErrorLike } from '../../domain/value-objects/validation-result.js';
 
-// Japanese character ranges: hiragana, katakana, kanji
 const JAPANESE_CHAR = /[\u3040-\u309f\u30a0-\u30ff\u4e00-\u9faf]/;
+const TEST_FUNCTION_NAMES = new Set(['it', 'test']);
+const WEAK_ASSERTION_STRENGTHS = new Set<AssertionStrength>([
+  'weak-truthiness',
+  'snapshot-only',
+  'interaction-only',
+  'length-only',
+]);
 
-// Matches it('...') or test('...') lines
-const IT_OR_TEST_LINE = /^\s*(?:it|test)\s*\(\s*['"`](.*?)['"`]/;
+export interface TestQualityAnalyzerOptions {
+  readonly weakAssertionStrengths?: readonly AssertionStrength[];
+}
 
-function createViolation(code: string, message: string, suggestion: string): HarnessErrorLike {
+function createViolation(message: string, suggestion: string): HarnessErrorLike {
   return {
-    code: { value: code, toString: () => code },
+    code: { value: 'L2-003', toString: () => 'L2-003' },
     severity: { value: 'warning', toString: () => 'warning' },
     message,
     suggestion,
   };
 }
 
-function analyzeContent(filePath: string, content: string): HarnessErrorLike[] {
+function lineOf(sourceFile: ts.SourceFile, node: ts.Node): number {
+  return sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+}
+
+function textOf(sourceFile: ts.SourceFile, node: ts.Node): string {
+  return node.getText(sourceFile).replace(/\s+/g, ' ').trim();
+}
+
+function unwrapAwait(expression: ts.Expression): ts.Expression {
+  return ts.isAwaitExpression(expression) ? expression.expression : expression;
+}
+
+function isCallLikeAct(expression: ts.Expression): boolean {
+  const unwrapped = unwrapAwait(expression);
+  if (!ts.isCallExpression(unwrapped) && !ts.isNewExpression(unwrapped)) {
+    return false;
+  }
+  const text = unwrapped.getText();
+  return !/^expect\s*\(/.test(text);
+}
+
+function isDerivedFromObservedName(sourceFile: ts.SourceFile, expression: ts.Expression, observedNames: ReadonlySet<string>): boolean {
+  const expressionText = textOf(sourceFile, unwrapAwait(expression));
+  return [...observedNames].some((name) => (
+    expressionText === name || expressionText.startsWith(`${name}.`) || expressionText.startsWith(`${name}[`)
+  ));
+}
+
+function isTestCallee(expression: ts.Expression): boolean {
+  if (ts.isIdentifier(expression)) {
+    return TEST_FUNCTION_NAMES.has(expression.text);
+  }
+  if (ts.isPropertyAccessExpression(expression)) {
+    if (expression.name.text === 'each') {
+      return isTestCallee(expression.expression);
+    }
+    return false;
+  }
+  if (ts.isCallExpression(expression)) {
+    return isTestCallee(expression.expression);
+  }
+  return false;
+}
+
+function findCallback(args: ts.NodeArray<ts.Expression>): ts.ArrowFunction | ts.FunctionExpression | undefined {
+  return args.find((arg): arg is ts.ArrowFunction | ts.FunctionExpression => (
+    ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)
+  ));
+}
+
+function extractTestName(args: ts.NodeArray<ts.Expression>): string | undefined {
+  const nameArg = args.find((arg) => ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg));
+  return nameArg && (ts.isStringLiteral(nameArg) || ts.isNoSubstitutionTemplateLiteral(nameArg))
+    ? nameArg.text
+    : undefined;
+}
+
+function isExpectCall(expression: ts.Expression): expression is ts.CallExpression {
+  return ts.isCallExpression(expression)
+    && ts.isIdentifier(expression.expression)
+    && expression.expression.text === 'expect';
+}
+
+function extractExpectCall(expression: ts.Expression): {
+  expectCall: ts.CallExpression;
+  matcher: string;
+} | undefined {
+  const unwrapped = unwrapAwait(expression);
+  if (!ts.isCallExpression(unwrapped)) {
+    return undefined;
+  }
+
+  let cursor: ts.Expression = unwrapped.expression;
+  let matcher = '';
+  while (ts.isPropertyAccessExpression(cursor)) {
+    if (!matcher) {
+      matcher = cursor.name.text;
+    }
+    cursor = cursor.expression;
+  }
+
+  if (ts.isCallExpression(cursor) && isExpectCall(cursor)) {
+    return { expectCall: cursor, matcher };
+  }
+  return undefined;
+}
+
+function classifyAssertion(
+  sourceFile: ts.SourceFile,
+  statement: ts.Statement,
+  expression: ts.Expression,
+): SemanticAssertion | undefined {
+  const expectInfo = extractExpectCall(expression);
+  if (!expectInfo) {
+    return undefined;
+  }
+
+  const subject = expectInfo.expectCall.arguments[0]
+    ? textOf(sourceFile, expectInfo.expectCall.arguments[0])
+    : '';
+  const matcher = expectInfo.matcher;
+  const target = classifyAssertionTarget(subject, matcher);
+  const strength = classifyAssertionStrength(matcher, subject, expression);
+
+  return {
+    target,
+    strength,
+    subject,
+    line: lineOf(sourceFile, statement),
+  };
+}
+
+function classifyAssertionTarget(subject: string, matcher: string): AssertionTarget {
+  if (/toHaveBeenCalled|toBeCalled|toHaveReturned/.test(matcher) || /\.mock\b/.test(subject)) {
+    return 'interaction';
+  }
+  if (/throw/i.test(matcher) || /^\(\s*\)\s*=>/.test(subject)) {
+    return 'error-contract';
+  }
+  if (/event|emit|dispatch/i.test(subject)) {
+    return 'emitted-event';
+  }
+  if (/repository|store|db|database|persist/i.test(subject)) {
+    return 'persisted-effect';
+  }
+  if (/state|status|enabled|visible/i.test(subject)) {
+    return 'state';
+  }
+  return 'observed-output';
+}
+
+function classifyAssertionStrength(matcher: string, subject: string, expression: ts.Expression): AssertionStrength {
+  if (/toMatchSnapshot|toMatchInlineSnapshot/.test(matcher)) {
+    return 'snapshot-only';
+  }
+  if (/toBeTruthy|toBeFalsy|toBeDefined|toBeUndefined|toBeNull/.test(matcher)) {
+    return 'weak-truthiness';
+  }
+  if (/toHaveLength/.test(matcher) || /\.length$/.test(subject)) {
+    return 'length-only';
+  }
+  if (/toHaveBeenCalled|toBeCalled/.test(matcher)) {
+    return 'interaction-only';
+  }
+  if (/toThrow|toThrowError/.test(matcher) && ts.isCallExpression(unwrapAwait(expression))) {
+    const matcherCall = unwrapAwait(expression) as ts.CallExpression;
+    if (matcherCall.arguments.length === 0) {
+      return 'weak-truthiness';
+    }
+  }
+  if (/toMatchObject|toEqual|toContainEqual/.test(matcher)) {
+    return 'shape';
+  }
+  if (/toBeGreaterThan|toBeGreaterThanOrEqual|toBeLessThan|toBeLessThanOrEqual/.test(matcher)) {
+    return 'range';
+  }
+  if (/toContain|toSatisfy/.test(matcher)) {
+    return 'invariant';
+  }
+  return 'exact-value';
+}
+
+function classifyTestKind(filePath: string, testName: string): TestCaseKind {
+  const lower = `${filePath} ${testName}`.toLowerCase();
+  if (/\be2e\b|lifecycle|ライフサイクル|一連/.test(lower)) {
+    return 'e2e';
+  }
+  if (/\bintegration\b|\.it\.test|統合/.test(lower)) {
+    return 'integration';
+  }
+  return 'unit';
+}
+
+function allowsMultipleActs(kind: TestCaseKind, testName: string): boolean {
+  return kind === 'e2e' || kind === 'lifecycle' || /ライフサイクル|一連|flow|journey/i.test(testName);
+}
+
+function extractMockReplacements(sourceFile: ts.SourceFile): TestDoubleReplacement[] {
+  const replacements: TestDoubleReplacement[] = [];
+
+  function visit(node: ts.Node): void {
+    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+      const api = `${node.expression.expression.getText(sourceFile)}.${node.expression.name.text}`;
+      if ((api === 'vi.mock' || api === 'jest.mock') && node.arguments[0]) {
+        const target = textOf(sourceFile, node.arguments[0]).replace(/^['"`]|['"`]$/g, '');
+        replacements.push({
+          target,
+          line: lineOf(sourceFile, node),
+          dependencyKind: isDomainInternalReplacement(target) ? 'domain-internal' : 'external',
+        });
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+
+  visit(sourceFile);
+  return replacements;
+}
+
+function isDomainInternalReplacement(target: string): boolean {
+  return /(^|\/)(domain|domains|entities|entity|value-objects|aggregates|aggregate|services)(\/|$)/i.test(target);
+}
+
+function extractSteps(sourceFile: ts.SourceFile, body: ts.ConciseBody): TestStep[] {
+  if (!ts.isBlock(body)) {
+    const assertion = classifyAssertion(sourceFile, body as unknown as ts.Statement, body);
+    return [{
+      kind: assertion ? 'assert' : 'act',
+      expression: textOf(sourceFile, body),
+      line: lineOf(sourceFile, body),
+      assertion,
+    }];
+  }
+
+  const steps: TestStep[] = [];
+  const observedNames = new Set<string>();
+  for (const statement of body.statements) {
+    if (ts.isVariableStatement(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        const name = declaration.name.getText(sourceFile);
+        const initializer = declaration.initializer;
+        const expression = initializer ? textOf(sourceFile, initializer) : textOf(sourceFile, declaration);
+        const isAct = Boolean(initializer) && (
+          name === 'actual'
+          || (
+            observedNames.size > 0
+            && initializer !== undefined
+            && isCallLikeAct(initializer)
+            && !isDerivedFromObservedName(sourceFile, initializer, observedNames)
+          )
+        );
+        if (isAct) {
+          observedNames.add(name);
+        }
+        steps.push({
+          kind: isAct ? 'act' : 'arrange',
+          expression,
+          line: lineOf(sourceFile, declaration),
+          observedName: isAct ? name : undefined,
+        });
+      }
+      continue;
+    }
+
+    if (ts.isExpressionStatement(statement)) {
+      const assertion = classifyAssertion(sourceFile, statement, statement.expression);
+      if (assertion) {
+        steps.push({
+          kind: 'assert',
+          expression: textOf(sourceFile, statement.expression),
+          line: lineOf(sourceFile, statement),
+          assertion,
+        });
+      } else if (isCallLikeAct(statement.expression)) {
+        steps.push({
+          kind: 'act',
+          expression: textOf(sourceFile, statement.expression),
+          line: lineOf(sourceFile, statement),
+        });
+      } else {
+        steps.push({
+          kind: 'arrange',
+          expression: textOf(sourceFile, statement),
+          line: lineOf(sourceFile, statement),
+        });
+      }
+      continue;
+    }
+
+    steps.push({
+      kind: 'arrange',
+      expression: textOf(sourceFile, statement),
+      line: lineOf(sourceFile, statement),
+    });
+  }
+
+  return steps;
+}
+
+function extractTestCases(filePath: string, sourceFile: ts.SourceFile): TestCaseStructure[] {
+  const mocks = extractMockReplacements(sourceFile);
+  const testCases: TestCaseStructure[] = [];
+
+  function visit(node: ts.Node): void {
+    if (ts.isCallExpression(node) && isTestCallee(node.expression)) {
+      const name = extractTestName(node.arguments);
+      const callback = findCallback(node.arguments);
+      if (name && callback) {
+        const kind = classifyTestKind(filePath, name);
+        const steps = extractSteps(sourceFile, callback.body);
+        const assertions = steps
+          .map((step) => step.assertion)
+          .filter((assertion): assertion is SemanticAssertion => assertion !== undefined);
+        testCases.push({
+          filePath,
+          name,
+          line: lineOf(sourceFile, node),
+          kind,
+          steps,
+          assertions,
+          mocks,
+          allowsMultipleActs: allowsMultipleActs(kind, name),
+        });
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+
+  visit(sourceFile);
+  return testCases;
+}
+
+function analyzeTestCase(
+  testCase: TestCaseStructure,
+  weakAssertionStrengths: ReadonlySet<AssertionStrength>,
+): HarnessErrorLike[] {
   const violations: HarnessErrorLike[] = [];
-  const lines = content.split('\n');
+  const acts = testCase.steps.filter((step) => step.kind === 'act');
+  const asserts = testCase.steps.filter((step) => step.kind === 'assert');
+  const firstActIndex = testCase.steps.findIndex((step) => step.kind === 'act');
+  const firstAssertIndex = testCase.steps.findIndex((step) => step.kind === 'assert');
+
+  if (!JAPANESE_CHAR.test(testCase.name)) {
+    violations.push(createViolation(
+      `テスト名が日本語ではありません: "${testCase.name}" at ${testCase.filePath}:${testCase.line}`,
+      'テスト名は日本語で仕様を表してください。',
+    ));
+  }
+
+  if (acts.length === 0) {
+    violations.push(createViolation(
+      `Act が見つかりません: "${testCase.name}" at ${testCase.filePath}:${testCase.line}`,
+      'ふるまいの実行を Act として名前付きの観測値に保持してください。',
+    ));
+  }
 
-  for (let i = 0; i < lines.length; i++) {
-    const itMatch = lines[i].match(IT_OR_TEST_LINE);
-    if (itMatch && !JAPANESE_CHAR.test(itMatch[1])) {
+  if (asserts.length === 0) {
+    violations.push(createViolation(
+      `Assert が見つかりません: "${testCase.name}" at ${testCase.filePath}:${testCase.line}`,
+      'Act の観測結果を Assert してください。',
+    ));
+  }
+
+  if (!testCase.allowsMultipleActs && acts.length > 1) {
+    violations.push(createViolation(
+      `Act が複数あります: "${testCase.name}" at ${testCase.filePath}:${acts[1].line}`,
+      'Unit/Integration テストでは 1 テスト 1 Act に分割してください。',
+    ));
+  }
+
+  if (firstActIndex >= 0 && firstAssertIndex >= 0 && firstAssertIndex < firstActIndex) {
+    violations.push(createViolation(
+      `Assert が Act より前にあります: "${testCase.name}" at ${testCase.filePath}:${testCase.steps[firstAssertIndex].line}`,
+      'Arrange / Act / Assert の順序に整理してください。',
+    ));
+  }
+
+  const observedNames = new Set(acts.map((step) => step.observedName).filter((name): name is string => Boolean(name)));
+  if (acts.length > 0 && observedNames.size === 0) {
+    violations.push(createViolation(
+      `Act の観測結果が名前付き値として保持されていません: "${testCase.name}" at ${testCase.filePath}:${acts[0].line}`,
+      'Act の戻り値を const actual = ... のような名前付き値に保持してください。',
+    ));
+  }
+
+  for (const name of observedNames) {
+    if (!testCase.allowsMultipleActs && name !== 'actual') {
       violations.push(createViolation(
-        'L2-003',
-        `テスト名が日本語ではありません: "${itMatch[1]}" at ${filePath}:${i + 1}`,
-        'テスト名は日本語で記述してください（testing-rules.md準拠）',
+        `Act の観測値名が actual ではありません: "${name}" at ${testCase.filePath}:${acts.find((step) => step.observedName === name)?.line ?? testCase.line}`,
+        'TypeScript テストでは const actual = ... を使用してください。',
       ));
     }
   }
 
-  // If file uses expect() but lacks `const actual` assignment
-  if (/\bexpect\s*\(/.test(content) && !/\bconst\s+actual\b/.test(content)) {
+  const observesAct = testCase.assertions.some((assertion) => (
+    [...observedNames].some((name) => assertion.subject === name || assertion.subject.startsWith(`${name}.`))
+  ));
+  const observesExternalEffect = testCase.assertions.some((assertion) => assertion.target !== 'observed-output');
+  if (acts.length > 0 && testCase.assertions.length > 0 && !observesAct && !observesExternalEffect) {
     violations.push(createViolation(
-      'L2-003',
-      `\`actual\` 変数が未使用: ${filePath}`,
-      'アサーション前に const actual = ... で結果を変数に格納してください（testing-rules.md準拠）',
+      `Assert が Act の観測結果を検証していません: "${testCase.name}" at ${testCase.filePath}:${testCase.assertions[0].line}`,
+      'Assert は Act の戻り値、状態変化、イベント、永続化結果、error contract、interaction のいずれかを検証してください。',
     ));
   }
 
+  for (const assertion of testCase.assertions) {
+    if (weakAssertionStrengths.has(assertion.strength)) {
+      violations.push(createViolation(
+        `弱い assertion です (${assertion.strength}): "${testCase.name}" at ${testCase.filePath}:${assertion.line}`,
+        'exact value、shape、invariant、range、または error contract を観測してください。',
+      ));
+    }
+    if (assertion.target === 'error-contract' && assertion.strength === 'weak-truthiness') {
+      violations.push(createViolation(
+        `error contract の詳細が検証されていません: "${testCase.name}" at ${testCase.filePath}:${assertion.line}`,
+        'error type、code、message、recovery hint などを検証してください。',
+      ));
+    }
+  }
+
+  for (const replacement of testCase.mocks) {
+    if (replacement.dependencyKind === 'domain-internal') {
+      violations.push(createViolation(
+        `domain/internal dependency を mock しています: ${replacement.target} at ${testCase.filePath}:${replacement.line}`,
+        'Domain object や内部 module は実体を使い、外部I/O・時刻・乱数・Port実装のみを置き換えてください。',
+      ));
+    }
+  }
+
   return violations;
 }
 
+function analyzeContent(
+  filePath: string,
+  content: string,
+  weakAssertionStrengths: ReadonlySet<AssertionStrength>,
+): HarnessErrorLike[] {
+  const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  return extractTestCases(filePath, sourceFile).flatMap((testCase) => analyzeTestCase(testCase, weakAssertionStrengths));
+}
+
 export class BiomeAstTestQualityAnalyzerAdapter implements TestQualityAnalyzerPort {
+  private readonly weakAssertionStrengths: ReadonlySet<AssertionStrength>;
+
+  constructor(options: TestQualityAnalyzerOptions = {}) {
+    this.weakAssertionStrengths = new Set(options.weakAssertionStrengths ?? WEAK_ASSERTION_STRENGTHS);
+  }
+
   async analyzeTestFiles(targetPaths: readonly string[]): Promise<{
     results: readonly { filePath: string; passed: boolean; violations: readonly HarnessErrorLike[] }[];
   }> {
@@ -59,7 +477,7 @@ export class BiomeAstTestQualityAnalyzerAdapter implements TestQualityAnalyzerPo
       targetPaths.map(async (filePath) => {
         try {
           const content = await readFile(filePath, 'utf-8');
-          const violations = analyzeContent(filePath, content);
+          const violations = analyzeContent(filePath, content, this.weakAssertionStrengths);
           return { filePath, passed: violations.length === 0, violations };
         } catch {
           return { filePath, passed: true, violations: [] as HarnessErrorLike[] };