phasegate 0.141.0 → 0.143.0

package/scripts/harness/main.ts

@@ -46,6 +46,7 @@ import {
   deployHookScripts,
   deployHuskyCommitMsgHook,
   deployHuskyHook,
+  deployHuskyPrePushHook,
   deploySkills,
   getCategoryForSkill,
   getDeployedVersion,
@@ -98,6 +99,7 @@ Commands:
   disable-feature <name>       Disable a harness feature
   list-features                List available features
   migrate                      Migrate phasegate.config.json (--schema v3, --config <path>)
+  work-items:status            Report or apply derived WI frontmatter status (--dry-run|--apply, --id, --fail-on-stale, --json)
 
   render-errors                Render harness errors (--format human|agent|ci)
   validate-fix                 Validate fix examples (--code <code>)
@@ -153,6 +155,7 @@ Commands:
   hook <pre-tool-use|post-tool-use|stop|session-start|user-prompt-submit>  Run agent hook (reads JSON from stdin; writes JSON to stdout for session-start/user-prompt-submit)
   pre-commit                              Run L2 pre-commit validators on staged files
   commit-msg <message-file>               Validate commit message trailers against staged files
+  bypass:audit --base <ref> [--head <ref>] Audit bypass evidence for a push/CI commit range
   delegate-sonnet [...args]               Delegate task to Sonnet 4.6 (forwards args to scripts/delegate-sonnet.sh)
 
 Skills:
@@ -306,6 +309,19 @@ Options:
   "phasegate:status": `Usage: phasegate phasegate:status
 
 Display harness status (enabled validators, schema version, hook deployment).`,
+  "work-items:status": `Usage: phasegate work-items:status (--dry-run|--apply) [options]
+
+Derive WI frontmatter status from inception, product reflection, implementation, and test evidence.
+
+Options:
+  --dry-run         Print current status, derived status, reason, and next action.
+  --apply           Update only the status line in each stale description.md frontmatter.
+  --id <WI-XXX>     Limit report/apply to one work item.
+  --fail-on-stale   Return exit code 1 when dry-run finds stale status.
+  --allow-downgrade Allow apply to lower a frontmatter status.
+  --changed-only    Reserve apply scope for changed WI files; currently accepted as a no-op policy flag.
+  --json            Output machine-readable JSON.
+  --help, -h        Show this help`,
   "phasegate:detect-drift": `Usage: phasegate phasegate:detect-drift [options]
 
 Run L4-001 drift detection between design documents and source code. WARNING: scans the project filesystem.
@@ -704,6 +720,7 @@ async function main(): Promise<void> {
         const withHusky = hasFlag(args, "--with-husky");
         const huskyResult = withHusky ? await deployHuskyHook(harnessRoot, rootDir) : null;
         const huskyCommitMsgResult = withHusky ? await deployHuskyCommitMsgHook(harnessRoot, rootDir) : null;
+        const huskyPrePushResult = withHusky ? await deployHuskyPrePushHook(harnessRoot, rootDir) : null;
         const ciWorkflowResult = withCi ? await deployCiWorkflows(harnessRoot, rootDir) : null;
         console.log(
           `✓ Skills deployed to ${result.targetDir} (${result.deployedSkills.length} skills, set: ${skillSet})`,
@@ -769,6 +786,13 @@ async function main(): Promise<void> {
             console.log(`  .husky/commit-msg already exists, skipped`);
           }
         }
+        if (huskyPrePushResult !== null) {
+          if (huskyPrePushResult.created) {
+            console.log(`✓ .husky/pre-push deployed`);
+          } else {
+            console.log(`  .husky/pre-push already exists, skipped`);
+          }
+        }
         if (ciWorkflowResult !== null) {
           if (ciWorkflowResult.copiedFiles.length > 0) {
             console.log(`✓ CI workflows deployed (${ciWorkflowResult.copiedFiles.length} files)`);
@@ -962,6 +986,25 @@ async function main(): Promise<void> {
         break;
       }
 
+      case "work-items:status": {
+        const mod = createTraceabilityModelModule(
+          rootDir,
+          toTraceabilityModelOptions(resolvedConfig),
+        );
+        const result = await mod.workItemStatusCommandHandler.execute({
+          dryRun: hasFlag(args, "--dry-run"),
+          apply: hasFlag(args, "--apply"),
+          failOnStale: hasFlag(args, "--fail-on-stale"),
+          allowDowngrade: hasFlag(args, "--allow-downgrade"),
+          changedOnly: hasFlag(args, "--changed-only"),
+          id: parseFlag(args, "--id"),
+          json,
+        });
+        console.log(result.text);
+        process.exit(result.exitCode);
+        break;
+      }
+
       // ── phase-dependency-model ──
       case "check-phase-gate": {
         const phaseConfig = resolvedConfig ? toPhaseConfigSection(resolvedConfig) : undefined;
@@ -1554,6 +1597,15 @@ Examples:
         break;
       }
 
+      case "bypass:audit": {
+        const preCommitPath = join(harnessRoot, "scripts/harness/integrations/pre-commit.js");
+        const preCommitMod = (await import(preCommitPath)) as {
+          runBypassAuditCli: (args: readonly string[]) => Promise<void>;
+        };
+        await preCommitMod.runBypassAuditCli(args.slice(1));
+        break;
+      }
+
       case "delegate-sonnet": {
         const { spawn } = await import("node:child_process");
         const scriptPath = join(harnessRoot, "scripts/delegate-sonnet.sh");

package/scripts/harness/quick-mode/domain/value-objects/validator-relaxation-profile.ts

@@ -1,11 +1,12 @@
 /**
  * @layer domain
  * @unit quick-mode
+ * @work-item-id WI-140
  *
  * Quick Mode時のバリデータ実行構成を表す値オブジェクト
  */
 
-const L2_IDS = ['L2-001', 'L2-002', 'L2-003'] as const;
+const L2_IDS = ['L2-001', 'L2-002', 'L2-003', 'L2-014'] as const;
 const L3_IDS = ['L3-001', 'L3-002', 'L3-003', 'L3-004'] as const;
 
 type L2Id = (typeof L2_IDS)[number];
@@ -48,7 +49,7 @@ export class ValidatorRelaxationProfile {
     return new ValidatorRelaxationProfile({
       levelDependencyRelaxed: false,
       l1: { all: true },
-      l2: { maintained: ['L2-002', 'L2-003'], skipped: ['L2-001'] },
+      l2: { maintained: ['L2-002', 'L2-003', 'L2-014'], skipped: ['L2-001'] },
       l3: { maintained: ['L3-001'], skipped: ['L3-002', 'L3-003', 'L3-004'] },
       l4: { all: false },
       phaseExecution: { twoPhaseRequired: false },
@@ -65,7 +66,7 @@ export class ValidatorRelaxationProfile {
   }): ValidatorRelaxationProfile {
     const { l2, l3 } = params;
 
-    // INV-P5: l2.maintained ∪ l2.skipped = {L2-001, L2-002, L2-003}
+    // INV-P5: l2.maintained ∪ l2.skipped = {L2-001, L2-002, L2-003, L2-014}
     const l2Union = [...l2.maintained, ...l2.skipped].sort();
     const l2Expected = [...L2_IDS].sort();
     if (JSON.stringify(l2Union) !== JSON.stringify(l2Expected)) {

package/scripts/harness/quick-mode/infrastructure/adapters/harness-config-quick-mode-config-adapter.ts

@@ -1,6 +1,7 @@
 /**
  * @layer infrastructure
  * @unit quick-mode
+ * @work-item-id WI-140
  *
  * phasegate.config.json から QuickModeConfig を取得する Adapter
  */
@@ -25,7 +26,7 @@ export class HarnessConfigParseError extends Error {
 
 const DEFAULT_QUICK_MODE_CONFIG = {
   allowedCategories: ['bugfix', 'docs', 'test', 'config'],
-  maintainedLayers: ['L1', 'L2-002', 'L2-003', 'L3-001'],
+  maintainedLayers: ['L1', 'L2-002', 'L2-003', 'L2-014', 'L3-001'],
   relaxedGates: ['L2-001', 'L3-002', 'L3-003', 'L3-004', 'L4'],
 };
 

package/scripts/harness/quick-mode/infrastructure/adapters/validator-system-validator-id-registry-adapter.ts

@@ -1,13 +1,14 @@
 /**
  * @layer infrastructure
  * @unit quick-mode
+ * @work-item-id WI-140
  *
  * integration_contract.md §9 の確定ID一覧を静的定義で保持する ValidatorIdRegistry Adapter
  */
 
 const STATIC_VALIDATOR_IDS: readonly string[] = Object.freeze([
   'L1-001', 'L1-002', 'L1-003', 'L1-004', 'L1-005', 'L1-006', 'L1-007', 'L1-008',
-  'L2-001', 'L2-002', 'L2-003',
+  'L2-001', 'L2-002', 'L2-003', 'L2-014',
   'L3-001', 'L3-002', 'L3-003', 'L3-004',
   'L4-001', 'L4-002', 'L4-003', 'L4-004', 'L4-005',
 ]);

package/scripts/harness/setup/skill-deployer.ts

@@ -617,6 +617,25 @@ export async function deployHuskyCommitMsgHook(
   return { created: true, path: targetPath };
 }
 
+export async function deployHuskyPrePushHook(
+  harnessRoot: string,
+  projectRoot: string,
+): Promise<DeployHuskyHookResult> {
+  const targetPath = join(projectRoot, ".husky", "pre-push");
+
+  try {
+    await fs.access(targetPath);
+    return { created: false, path: targetPath };
+  } catch {}
+
+  const sourcePath = join(harnessRoot, "docs", "templates", "hooks", "pre-push");
+  await fs.mkdir(join(projectRoot, ".husky"), { recursive: true });
+  await fs.copyFile(sourcePath, targetPath);
+  await fs.chmod(targetPath, 0o755);
+
+  return { created: true, path: targetPath };
+}
+
 export interface DeployCodexHooksResult {
   created: boolean;
   path: string;

package/scripts/harness/traceability-model/application/usecases/apply-work-item-status-usecase.ts

@@ -0,0 +1,55 @@
+// @unit traceability-model
+// @layer application
+// @work-item-id WI-126 / WI-140
+
+import type { WorkItemStatusPort } from "../../domain/ports/work-item-status-port.js";
+import type { WorkItemStatusApplyResult, WorkItemStatusReport } from "../../domain/value-objects/work-item-status-report.js";
+import type { DeriveWorkItemStatusUseCase } from "./derive-work-item-status-usecase.js";
+import type { WorkItemStatus } from "../../domain/value-objects/work-item-frontmatter.js";
+
+export interface ApplyWorkItemStatusUseCaseDeps {
+  readonly deriveWorkItemStatusUseCase: Pick<DeriveWorkItemStatusUseCase, "execute">;
+  readonly workItemStatusPort: WorkItemStatusPort;
+}
+
+export class ApplyWorkItemStatusUseCase {
+  private readonly deriveWorkItemStatusUseCase: Pick<DeriveWorkItemStatusUseCase, "execute">;
+  private readonly workItemStatusPort: WorkItemStatusPort;
+
+  constructor(deps: ApplyWorkItemStatusUseCaseDeps) {
+    this.deriveWorkItemStatusUseCase = deps.deriveWorkItemStatusUseCase;
+    this.workItemStatusPort = deps.workItemStatusPort;
+  }
+
+  async execute(input: { readonly id?: string; readonly allowDowngrade?: boolean; readonly changedOnly?: boolean } = {}): Promise<WorkItemStatusApplyResult> {
+    const reports = await this.deriveWorkItemStatusUseCase.execute();
+    const targetReports = input.id
+      ? reports.filter((report) => report.id === input.id)
+      : reports;
+    const blocked = input.allowDowngrade ? [] : targetReports.filter((report) => this.isDowngrade(report));
+    const allowed = input.allowDowngrade ? targetReports : targetReports.filter((report) => !this.isDowngrade(report));
+    const result = await this.workItemStatusPort.applyDerivedStatuses(allowed);
+    return Object.freeze({
+      updated: result.updated,
+      unchanged: result.unchanged,
+      blocked: Object.freeze([...result.blocked, ...blocked]),
+    });
+  }
+
+  private isDowngrade(report: WorkItemStatusReport): boolean {
+    if (!report.stale) return false;
+    return statusOrder(report.derivedStatus) < statusOrder(report.currentStatus);
+  }
+}
+
+const STATUS_ORDER: Record<WorkItemStatus, number> = {
+  drafted: 0,
+  reflected: 1,
+  implemented: 2,
+  tested: 3,
+  completed: 3,
+};
+
+function statusOrder(status: WorkItemStatus): number {
+  return STATUS_ORDER[status];
+}

package/scripts/harness/traceability-model/application/usecases/derive-work-item-status-usecase.ts

@@ -0,0 +1,27 @@
+// @unit traceability-model
+// @layer application
+// @work-item-id WI-126
+
+import type { WorkItemStatusPort } from "../../domain/ports/work-item-status-port.js";
+import { WorkItemStatusDerivationService } from "../../domain/services/work-item-status-derivation-service.js";
+import type { WorkItemStatusReport } from "../../domain/value-objects/work-item-status-report.js";
+
+export interface DeriveWorkItemStatusUseCaseDeps {
+  readonly workItemStatusPort: WorkItemStatusPort;
+  readonly derivationService: WorkItemStatusDerivationService;
+}
+
+export class DeriveWorkItemStatusUseCase {
+  private readonly workItemStatusPort: WorkItemStatusPort;
+  private readonly derivationService: WorkItemStatusDerivationService;
+
+  constructor(deps: DeriveWorkItemStatusUseCaseDeps) {
+    this.workItemStatusPort = deps.workItemStatusPort;
+    this.derivationService = deps.derivationService;
+  }
+
+  async execute(): Promise<readonly WorkItemStatusReport[]> {
+    const inputs = await this.workItemStatusPort.listWorkItemStatusInputs();
+    return Object.freeze(inputs.map((input) => this.derivationService.derive(input)));
+  }
+}

package/scripts/harness/traceability-model/composition-root.ts

@@ -7,6 +7,8 @@
  */
 
 import { ApplyWorkItemMigrationUseCase } from "./application/usecases/apply-work-item-migration-usecase.js";
+import { ApplyWorkItemStatusUseCase } from "./application/usecases/apply-work-item-status-usecase.js";
+import { DeriveWorkItemStatusUseCase } from "./application/usecases/derive-work-item-status-usecase.js";
 import { PlanWorkItemMigrationUseCase } from "./application/usecases/plan-work-item-migration-usecase.js";
 import { ValidateDesignStoryAnnotationsUseCase } from "./application/usecases/validate-design-story-annotations-usecase.js";
 import { ValidateImplementationMetadataUseCase } from "./application/usecases/validate-implementation-metadata-usecase.js";
@@ -14,17 +16,20 @@ import { ValidateTestStoryMetadataUseCase } from "./application/usecases/validat
 import { MetadataValidator } from "./domain/services/metadata-validator.js";
 import { StoryIdAliasResolver } from "./domain/services/story-id-alias-resolver.js";
 import { TraceabilityChainBuilder } from "./domain/services/traceability-chain-builder.js";
+import { WorkItemStatusDerivationService } from "./domain/services/work-item-status-derivation-service.js";
 import { ProjectRelativePath } from "./domain/value-objects/project-relative-path.js";
 import { FileSystemInceptionPlanGateway } from "./infrastructure/gateways/file-system-inception-plan-gateway.js";
 import { FileSystemMetadataReader } from "./infrastructure/gateways/file-system-metadata-reader.js";
 import { FileSystemWorkItemMigrationApplyGateway } from "./infrastructure/gateways/file-system-work-item-migration-apply-gateway.js";
 import { FileSystemWorkItemMigrationSourceGateway } from "./infrastructure/gateways/file-system-work-item-migration-source-gateway.js";
 import { FileSystemWorkItemIdentityGateway } from "./infrastructure/gateways/file-system-work-item-identity-gateway.js";
+import { FileSystemWorkItemStatusGateway } from "./infrastructure/gateways/file-system-work-item-status-gateway.js";
 import { MarkdownDesignDocumentGateway } from "./infrastructure/gateways/markdown-design-document-gateway.js";
 import { MarkdownStoryCatalogGateway } from "./infrastructure/gateways/markdown-story-catalog-gateway.js";
 import { MarkdownUnitDefinitionGateway } from "./infrastructure/gateways/markdown-unit-definition-gateway.js";
 import { MigrateWorkItemsCommandHandler } from "./presentation/cli/migrate-work-items-command-handler.js";
 import { ValidateMetadataCommandHandler } from "./presentation/cli/validate-metadata-command-handler.js";
+import { WorkItemStatusCommandHandler } from "./presentation/cli/work-item-status-command-handler.js";
 
 export interface TraceabilityModelPathRoots {
   readonly designDocsRoot: string;
@@ -63,6 +68,7 @@ export function createTraceabilityModelModule(
   const workItemMigrationSource = new FileSystemWorkItemMigrationSourceGateway({ rootDir });
   const workItemMigrationApply = new FileSystemWorkItemMigrationApplyGateway({ rootDir });
   const workItemIdentity = new FileSystemWorkItemIdentityGateway({ rootDir });
+  const workItemStatus = new FileSystemWorkItemStatusGateway({ rootDir });
 
   // Domain services
   const metadataValidator = new MetadataValidator({
@@ -78,6 +84,7 @@ export function createTraceabilityModelModule(
     storyCatalogPath,
   });
   const storyIdAliasResolver = new StoryIdAliasResolver(storyCatalog);
+  const workItemStatusDerivationService = new WorkItemStatusDerivationService();
 
   // Usecases
   const validateImplementationMetadataUseCase = new ValidateImplementationMetadataUseCase({
@@ -100,6 +107,14 @@ export function createTraceabilityModelModule(
     planWorkItemMigrationUseCase,
     applyPort: workItemMigrationApply,
   });
+  const deriveWorkItemStatusUseCase = new DeriveWorkItemStatusUseCase({
+    workItemStatusPort: workItemStatus,
+    derivationService: workItemStatusDerivationService,
+  });
+  const applyWorkItemStatusUseCase = new ApplyWorkItemStatusUseCase({
+    deriveWorkItemStatusUseCase,
+    workItemStatusPort: workItemStatus,
+  });
 
   // Presentation handlers
   const validateMetadataCommandHandler = new ValidateMetadataCommandHandler({
@@ -112,10 +127,15 @@ export function createTraceabilityModelModule(
     planWorkItemMigrationUseCase,
     applyWorkItemMigrationUseCase,
   });
+  const workItemStatusCommandHandler = new WorkItemStatusCommandHandler({
+    deriveWorkItemStatusUseCase,
+    applyWorkItemStatusUseCase,
+  });
 
   return {
     validateMetadataCommandHandler,
     migrateWorkItemsCommandHandler,
+    workItemStatusCommandHandler,
     // expose key services for cross-unit use
     storyCatalog,
     traceabilityChainBuilder,

package/scripts/harness/traceability-model/domain/ports/work-item-status-port.ts

@@ -0,0 +1,16 @@
+// @unit traceability-model
+// @layer domain
+// @work-item-id WI-126
+
+import type {
+  WorkItemStatusApplyResult,
+  WorkItemStatusInput,
+  WorkItemStatusReport,
+} from "../value-objects/work-item-status-report.js";
+
+export interface WorkItemStatusPort {
+  listWorkItemStatusInputs(): Promise<readonly WorkItemStatusInput[]>;
+  applyDerivedStatuses(
+    reports: readonly WorkItemStatusReport[],
+  ): Promise<WorkItemStatusApplyResult>;
+}

package/scripts/harness/traceability-model/domain/services/work-item-status-derivation-service.ts

@@ -0,0 +1,137 @@
+// @unit traceability-model
+// @layer domain
+// @work-item-id WI-126 / WI-140
+
+import type { WorkItemStatus } from "../value-objects/work-item-frontmatter.js";
+import type {
+  WorkItemStatusInput,
+  WorkItemStatusReport,
+} from "../value-objects/work-item-status-report.js";
+
+const ORDER: Record<WorkItemStatus, number> = {
+  drafted: 0,
+  reflected: 1,
+  implemented: 2,
+  tested: 3,
+  completed: 3,
+};
+
+export class WorkItemStatusDerivationService {
+  derive(input: WorkItemStatusInput): WorkItemStatusReport {
+    const derivedStatus = this.deriveStatus(input);
+    const currentStatus = input.frontmatter.status ?? "drafted";
+    const reason = this.reasonFor(input, derivedStatus);
+    const nextAction = this.nextActionFor(input, derivedStatus);
+
+    return Object.freeze({
+      id: input.frontmatter.id,
+      type: input.frontmatter.type,
+      descriptionPath: input.descriptionPath,
+      currentStatus,
+      derivedStatus,
+      stale: currentStatus !== derivedStatus,
+      reason,
+      nextAction,
+      evidence: Object.freeze({
+        hasRequiredInceptionArtifacts: this.hasRequiredInceptionArtifacts(input),
+        missingInceptionArtifacts: Object.freeze([...this.missingInceptionArtifacts(input)]),
+        reflectedUnits: Object.freeze([...this.reflectedUnits(input)]),
+        missingReflectionUnits: Object.freeze([...this.missingReflectionUnits(input)]),
+        implementationPaths: Object.freeze([...input.implementationPaths]),
+        testPaths: Object.freeze([...input.testPaths]),
+        missingImplementation: this.missingImplementation(input),
+        missingTests: this.missingTests(input),
+        validation: Object.freeze({
+          state: "not-run" as const,
+          source: "work-items:status",
+          blockingValidation: Object.freeze([]),
+        }),
+      }),
+    });
+  }
+
+  private deriveStatus(input: WorkItemStatusInput): WorkItemStatus {
+    const type = input.frontmatter.type;
+    if (type === "chore") return "drafted";
+
+    const reflected = this.missingReflectionUnits(input).length === 0;
+    const implemented = input.implementationPaths.length > 0;
+    const tested = input.testPaths.length > 0;
+
+    if (type === "fix") {
+      if (implemented) return "implemented";
+      if (reflected) return "reflected";
+      return "drafted";
+    }
+
+    if (!reflected) return "drafted";
+    if (!implemented) return "reflected";
+    if (tested) return "tested";
+    return "implemented";
+  }
+
+  private reasonFor(input: WorkItemStatusInput, status: WorkItemStatus): string {
+    if (!this.hasRequiredInceptionArtifacts(input)) {
+      return `missing inception artifacts: ${this.missingInceptionArtifacts(input).join(", ")}`;
+    }
+    if (status === "tested") return "test evidence with @work-item-id exists";
+    if (status === "implemented") return "implementation evidence with @work-item-id exists";
+    if (status === "reflected") return "all affected units have product reflection";
+    if (input.frontmatter.type === "chore") return "chore work items complete at drafted";
+    return "product reflection is not complete";
+  }
+
+  private nextActionFor(input: WorkItemStatusInput, status: WorkItemStatus): string {
+    const missingArtifacts = this.missingInceptionArtifacts(input);
+    if (missingArtifacts.length > 0) {
+      return `create inception artifacts: ${missingArtifacts.join(", ")}`;
+    }
+    const missingUnits = this.missingReflectionUnits(input);
+    if (missingUnits.length > 0) {
+      return `reflect @work-item-id ${input.frontmatter.id} in product docs for: ${missingUnits.join(", ")}`;
+    }
+    if (input.frontmatter.type === "chore") return "no further status transition required";
+    if (status === "reflected") return `add implementation annotated with @work-item-id ${input.frontmatter.id}`;
+    if (status === "implemented" && input.frontmatter.type !== "fix") {
+      return `add tests annotated with @work-item-id ${input.frontmatter.id}`;
+    }
+    return "status is up to date";
+  }
+
+  private hasRequiredInceptionArtifacts(input: WorkItemStatusInput): boolean {
+    return this.missingInceptionArtifacts(input).length === 0;
+  }
+
+  private missingInceptionArtifacts(input: WorkItemStatusInput): readonly string[] {
+    const existing = new Set(input.existingInceptionArtifacts);
+    return input.requiredInceptionArtifacts.filter((artifact) => !existing.has(artifact));
+  }
+
+  private reflectedUnits(input: WorkItemStatusInput): readonly string[] {
+    const reflected = new Set<string>();
+    for (const filePath of input.productReflectionPaths) {
+      const unit = this.extractConstructionUnit(filePath);
+      if (unit) reflected.add(unit);
+    }
+    return input.affectedUnits.filter((unit) => reflected.has(unit));
+  }
+
+  private missingReflectionUnits(input: WorkItemStatusInput): readonly string[] {
+    if (input.frontmatter.type === "chore") return [];
+    const reflected = new Set(this.reflectedUnits(input));
+    return input.affectedUnits.filter((unit) => !reflected.has(unit));
+  }
+
+  private missingImplementation(input: WorkItemStatusInput): boolean {
+    return input.frontmatter.type !== "chore" && this.missingReflectionUnits(input).length === 0 && input.implementationPaths.length === 0;
+  }
+
+  private missingTests(input: WorkItemStatusInput): boolean {
+    return input.frontmatter.type !== "chore" && input.frontmatter.type !== "fix" && input.implementationPaths.length > 0 && input.testPaths.length === 0;
+  }
+
+  private extractConstructionUnit(filePath: string): string | null {
+    const match = /^docs\/product\/construction\/([^/]+)\//.exec(filePath);
+    return match?.[1] ?? null;
+  }
+}

package/scripts/harness/traceability-model/domain/value-objects/work-item-status-report.ts

@@ -0,0 +1,56 @@
+// @unit traceability-model
+// @layer domain
+// @work-item-id WI-126 / WI-140
+
+import type {
+  WorkItemFrontmatter,
+  WorkItemStatus,
+  WorkItemType,
+} from "./work-item-frontmatter.js";
+
+export interface WorkItemStatusEvidence {
+  readonly hasRequiredInceptionArtifacts: boolean;
+  readonly missingInceptionArtifacts: readonly string[];
+  readonly reflectedUnits: readonly string[];
+  readonly missingReflectionUnits: readonly string[];
+  readonly implementationPaths: readonly string[];
+  readonly testPaths: readonly string[];
+  readonly missingImplementation: boolean;
+  readonly missingTests: boolean;
+  readonly validation: {
+    readonly state: "passed" | "failed" | "not-run";
+    readonly source: string;
+    readonly blockingValidation: readonly string[];
+  };
+}
+
+export interface WorkItemStatusInput {
+  readonly descriptionPath: string;
+  readonly directoryId: string;
+  readonly ownerUnit: string | null;
+  readonly frontmatter: WorkItemFrontmatter;
+  readonly requiredInceptionArtifacts: readonly string[];
+  readonly existingInceptionArtifacts: readonly string[];
+  readonly affectedUnits: readonly string[];
+  readonly productReflectionPaths: readonly string[];
+  readonly implementationPaths: readonly string[];
+  readonly testPaths: readonly string[];
+}
+
+export interface WorkItemStatusReport {
+  readonly id: string;
+  readonly type: WorkItemType;
+  readonly descriptionPath: string;
+  readonly currentStatus: WorkItemStatus;
+  readonly derivedStatus: WorkItemStatus;
+  readonly stale: boolean;
+  readonly reason: string;
+  readonly nextAction: string;
+  readonly evidence: WorkItemStatusEvidence;
+}
+
+export interface WorkItemStatusApplyResult {
+  readonly updated: readonly WorkItemStatusReport[];
+  readonly unchanged: readonly WorkItemStatusReport[];
+  readonly blocked: readonly WorkItemStatusReport[];
+}