phasegate 0.133.0 → 0.135.0

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "phasegate",
-  "version": "0.133.0",
+  "version": "0.135.0",
   "packageManager": "pnpm@10.30.1",
   "description": "Phasegate — AI-agnostic quality defense toolkit. Enforces structural integrity between design intent and code.",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/junpei-9898/phasegate.git"
+    "url": "git+https://github.com/junpei-9898/phasegate.git"
   },
   "homepage": "https://github.com/junpei-9898/phasegate#readme",
   "bugs": {
@@ -35,6 +35,7 @@
     "skills/**",
     "templates/**",
     "docs/ADR/**",
+    "docs/contracts/**",
     "docs/principles/**",
     "docs/guide/**",
     "docs/folder_management_rules.md",
@@ -42,7 +43,7 @@
     "CHANGELOG.md"
   ],
   "bin": {
-    "phasegate": "./bin/phasegate"
+    "phasegate": "bin/phasegate"
   },
   "scripts": {
     "phasegate": "npx tsx scripts/harness/main.ts",

package/scripts/harness/config-foundation/application/mappers/validator-system-config-mapper.ts

@@ -1,7 +1,7 @@
 /**
  * @layer application
  * @unit config-foundation
- * @work-item-id WI-092 / WI-094
+ * @work-item-id WI-092 / WI-094 / WI-033
  */
 import type { HarnessConfigV2 } from '../../domain/harness-config.js';
 
@@ -13,7 +13,7 @@ export function toValidatorSystemConfig(resolvedConfig: HarnessConfigV2 | undefi
     layers: {
       L2: { enabled: resolvedConfig.layers.L2.enabled },
       L3: { enabled: resolvedConfig.layers.L3.enabled },
-      L4: { enabled: resolvedConfig.layers.L4.enabled },
+      L4: { enabled: resolvedConfig.layers.L4.enabled, validators: resolvedConfig.layers.L4.validators },
     },
     validate: {
       failOnWarning: resolvedConfig.validate.failOnWarning,

package/scripts/harness/config-foundation/infrastructure/presets/minimal.json

@@ -15,7 +15,7 @@
     },
     "L4": {
       "enabled": false,
-      "validators": ["drift-detector"],
+      "validators": ["drift-detector", "doc-freshness-checker", "pointer-validator"],
       "schedule": "0 0 * * *"
     }
   },

package/scripts/harness/config-foundation/infrastructure/presets/standard.json

@@ -15,7 +15,7 @@
     },
     "L4": {
       "enabled": false,
-      "validators": ["drift-detector"],
+      "validators": ["drift-detector", "doc-freshness-checker", "pointer-validator"],
       "schedule": "0 0 * * *"
     }
   },

package/scripts/harness/config-foundation/infrastructure/presets/strict.json

@@ -15,7 +15,7 @@
     },
     "L4": {
       "enabled": true,
-      "validators": ["drift-detector", "dead-code-detector"],
+      "validators": ["drift-detector", "consistency-checker", "dead-code-detector", "doc-freshness-checker", "pointer-validator"],
       "schedule": "0 1 * * *"
     }
   },

package/scripts/harness/config-foundation/infrastructure/schemas/harness-config-v2.schema.json

@@ -68,22 +68,6 @@
       "type": "object",
       "additionalProperties": false,
       "properties": {
-        "L0": {
-          "type": "object",
-          "additionalProperties": false,
-          "properties": {
-            "enabled": {
-              "type": "boolean"
-            },
-            "validators": {
-              "type": "array",
-              "items": {
-                "type": "string"
-              },
-              "uniqueItems": true
-            }
-          }
-        },
         "L1": {
           "type": "object",
           "additionalProperties": false,

package/scripts/harness/config-foundation/infrastructure/schemas/harness-config-v3.schema.json

@@ -68,22 +68,6 @@
       "type": "object",
       "additionalProperties": false,
       "properties": {
-        "L0": {
-          "type": "object",
-          "additionalProperties": false,
-          "properties": {
-            "enabled": {
-              "type": "boolean"
-            },
-            "validators": {
-              "type": "array",
-              "items": {
-                "type": "string"
-              },
-              "uniqueItems": true
-            }
-          }
-        },
         "L1": {
           "type": "object",
           "additionalProperties": false,

package/scripts/harness/harness-error/infrastructure/adapters/validator-registry-bridge-adapter.ts

@@ -64,6 +64,8 @@ const DEFAULT_VALIDATOR_IDS = [
   'drift-detect',
   'consistency-check',
   'dead-code',
+  'doc-freshness',
+  'pointer-validation',
 ] as const;
 
 export const DEFAULT_VALIDATOR_ENTRYPOINTS = new Map<

package/scripts/harness/harness-error/infrastructure/registry/l4-error-definitions.ts

@@ -50,4 +50,18 @@ export const L4_ERROR_DEFINITIONS = Object.freeze([
     ownerValidatorId: 'dead-code',
     defaultFixExample: 'const actual = "remove unused export";',
   }),
+  createDefinition({
+    code: 'L4-004',
+    title: '設計ドキュメントの鮮度が閾値を超過した',
+    category: 'consistency',
+    ownerValidatorId: 'doc-freshness',
+    defaultFixExample: 'const actual = "review or refresh stale design document";',
+  }),
+  createDefinition({
+    code: 'L4-005',
+    title: '設計ドキュメント内のポインタ参照が解決できない',
+    category: 'consistency',
+    ownerValidatorId: 'pointer-validation',
+    defaultFixExample: 'const actual = "fix unresolved document pointer";',
+  }),
 ]);

package/scripts/harness/main.ts

@@ -110,7 +110,7 @@ Commands:
 
   lint                         Run lint checks (--json, --target <path>)
 
-  validate                     Run validators (--layer L0|L2|L3|L4|all, --unit, --format human|agent|ci)
+  validate                     Run validators (--layer L2|L3|L4|all; L0 prints runtime hook info, --unit, --format human|agent|ci)
   ci-check                     CI check (--quick for quick mode, --fail-on-reject, --dry-run, --files)
 
   phasegate:check-ready         Check ready status (--json)
@@ -263,10 +263,10 @@ Options:
   --help, -h                      Show this help`,
   validate: `Usage: phasegate validate [options]
 
-Run validators against the project. Without --layer, runs all enabled layers (L0/L2/L3/L4).
+Run validators against the project. Without --layer, runs all enabled validator layers (L2/L3/L4).
 
 Options:
-  --layer <L0|L2|L3|L4>           Run only the specified layer
+  --layer <L0|L2|L3|L4>           Run only the specified validator layer; L0 prints runtime hook info
   --json                          Output machine-readable JSON
   --help, -h                      Show this help`,
   lint: `Usage: phasegate lint [options]

package/scripts/harness/phase2-extensions/composition-root.ts

@@ -25,7 +25,13 @@ import { ValidatePointersHandler } from './presentation/handlers/validate-pointe
 
 export function buildPhase2Extensions(projectRoot: string, config?: HarnessConfigV2) {
   const configAdapter = new HarnessConfigFreshnessAdapter(config);
-  const documentScanner = new FileSystemDocumentScannerAdapter(projectRoot);
+  const inceptionDocsRoot = config?.paths?.inceptionDocs.replace(/\\/g, '/').replace(/\/+$/g, '') ?? 'docs/inception';
+  const documentScanner = new FileSystemDocumentScannerAdapter(projectRoot, {
+    excludePatterns: [
+      new RegExp(`^${inceptionDocsRoot.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}/`),
+      /^docs\/.*\/archive\//,
+    ],
+  });
   const documentAge = new GitLogDocumentAgeAdapter(projectRoot);
   const pointerExtractor = new RegexPointerExtractorAdapter(projectRoot);
   const pointerResolver = new FileSystemPointerResolverAdapter(projectRoot);

package/scripts/harness/phase2-extensions/infrastructure/adapters/file-system-document-scanner-adapter.ts

@@ -6,6 +6,10 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import type { DocumentScannerPort } from '../../domain/ports/document-scanner-port.js';
 
+export interface FileSystemDocumentScannerAdapterOptions {
+  readonly excludePatterns?: readonly RegExp[];
+}
+
 function escapeRegex(value: string): string {
   return value.replace(/[|\\{}()[\]^$+?.]/g, '\\$&');
 }
@@ -67,11 +71,21 @@ async function walk(root: string, current = ''): Promise<string[]> {
 }
 
 export class FileSystemDocumentScannerAdapter implements DocumentScannerPort {
-  constructor(private readonly projectRoot: string) {}
+  private readonly excludePatterns: readonly RegExp[];
+
+  constructor(
+    private readonly projectRoot: string,
+    options: FileSystemDocumentScannerAdapterOptions = {},
+  ) {
+    this.excludePatterns = options.excludePatterns ?? [];
+  }
 
   async scan(pattern: string): Promise<string[]> {
     const files = await walk(this.projectRoot);
     const regex = toPatternRegex(pattern);
-    return files.filter((file) => regex.test(file)).sort();
+    return files
+      .filter((file) => regex.test(file))
+      .filter((file) => !this.excludePatterns.some((excludePattern) => excludePattern.test(file)))
+      .sort();
   }
 }

package/scripts/harness/phase2-extensions/infrastructure/adapters/harness-config-freshness-adapter.ts

@@ -9,6 +9,10 @@ import type { FreshnessConfigPort } from '../../domain/ports/freshness-config-po
 import { FreshnessThreshold } from '../../domain/value-objects/freshness-threshold.js';
 
 type Phase2RuleConfig = {
+  paths?: {
+    designDocs?: string;
+    inceptionDocs?: string;
+  };
   phase2Extensions?: {
     freshnessRules?: Array<{
       ruleId: string;
@@ -25,16 +29,22 @@ type Phase2RuleConfig = {
   };
 };
 
+function normalizePathPatternRoot(value: string | undefined): string {
+  const normalized = value?.replace(/\\/g, '/').replace(/\/+$/g, '');
+  return normalized && normalized.length > 0 ? normalized : 'docs/product/construction';
+}
+
 export class HarnessConfigFreshnessAdapter implements FreshnessConfigPort {
   constructor(private readonly config?: HarnessConfigV2 | Phase2RuleConfig) {}
 
   async loadRules(): Promise<DocFreshnessRule[]> {
     const configRules = this.config && 'phase2Extensions' in this.config ? this.config.phase2Extensions?.freshnessRules : undefined;
     if (!configRules || configRules.length === 0) {
+      const designDocsRoot = normalizePathPatternRoot(this.config?.paths?.designDocs);
       return [
         DocFreshnessRule.create({
           ruleId: 'default-doc-freshness',
-          documentPattern: 'docs/**/*.md',
+          documentPattern: `${designDocsRoot}/**/*.md`,
           threshold: FreshnessThreshold.create({ warnThresholdDays: 30, errorThresholdDays: 90 }),
           enabled: true,
         }),
@@ -57,10 +67,11 @@ export class HarnessConfigFreshnessAdapter implements FreshnessConfigPort {
   async loadPointerRules(): Promise<PointerRule[]> {
     const configRules = this.config && 'phase2Extensions' in this.config ? this.config.phase2Extensions?.pointerRules : undefined;
     if (!configRules || configRules.length === 0) {
+      const designDocsRoot = normalizePathPatternRoot(this.config?.paths?.designDocs);
       return [
         PointerRule.create({
           ruleId: 'default-pointer-rule',
-          documentPattern: 'docs/**/*.md',
+          documentPattern: `${designDocsRoot}/**/*.md`,
           failOnBroken: true,
         }),
       ];

package/scripts/harness/phase2-extensions/infrastructure/adapters/regex-pointer-extractor-adapter.ts

@@ -8,12 +8,38 @@ import type { PointerExtractorPort } from '../../domain/ports/pointer-extractor-
 import { Pointer } from '../../domain/value-objects/pointer.js';
 
 const MARKDOWN_LINK_REGEX = /\[([^\]]+)\]\(([^)]+)\)/g;
-const RELATIVE_PATH_REGEX = /(?:^|\s)((?:docs|scripts)\/[^\s,'")\]]+)/gm;
+const RELATIVE_PATH_REGEX = /(?:^|\s)((?:docs|scripts)\/[^\s,'"`")\]）]+)/gm;
 
 function isUrlTarget(target: string): boolean {
   return target.startsWith('http://') || target.startsWith('https://');
 }
 
+function hasFileExtension(target: string): boolean {
+  return /\.[A-Za-z0-9]+$/u.test(path.posix.basename(target));
+}
+
+function normalizeFileTarget(documentPath: string, rawTarget: string): string | null {
+  const withoutFragment = rawTarget.split('#')[0] ?? '';
+  const cleaned = withoutFragment
+    .replace(/^`+|`+$/g, '')
+    .replace(/（.*$/u, '')
+    .replace(/:\d+$/u, '')
+    .replace(/[.,;:]+$/g, '')
+    .trim();
+
+  if (cleaned.length === 0) return null;
+  if (cleaned.includes('{') || cleaned.includes('}') || cleaned.includes('*') || cleaned.includes('...')) return null;
+  if (/[^\x00-\x7F]/u.test(cleaned)) return null;
+  if (cleaned.startsWith('/')) return path.posix.normalize(cleaned);
+  if (cleaned.startsWith('docs/') || cleaned.startsWith('scripts/')) return path.posix.normalize(cleaned);
+  if (!cleaned.includes('/') && !hasFileExtension(cleaned)) return null;
+  if (cleaned.startsWith('./') || cleaned.startsWith('../') || !cleaned.includes('/')) {
+    return path.posix.normalize(path.posix.join(path.posix.dirname(documentPath), cleaned));
+  }
+
+  return path.posix.normalize(cleaned);
+}
+
 export class RegexPointerExtractorAdapter implements PointerExtractorPort {
   constructor(private readonly projectRoot: string) {}
 
@@ -29,15 +55,20 @@ export class RegexPointerExtractorAdapter implements PointerExtractorPort {
         continue;
       }
       const type = isUrlTarget(target) ? 'url' : 'file-path';
-      const key = `${type}:${target}`;
+      const normalizedTarget = type === 'url' ? target : normalizeFileTarget(documentPath, target);
+      if (!normalizedTarget) {
+        continue;
+      }
+      const key = `${type}:${normalizedTarget}`;
       if (!seen.has(key)) {
         seen.add(key);
-        pointers.push(Pointer.create({ type, rawText, target }));
+        pointers.push(Pointer.create({ type, rawText, target: normalizedTarget }));
       }
     }
 
     for (const match of content.matchAll(RELATIVE_PATH_REGEX)) {
-      const target = match[1]?.trim();
+      const rawTarget = match[1]?.trim();
+      const target = rawTarget ? normalizeFileTarget(documentPath, rawTarget) : null;
       if (!target) {
         continue;
       }

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

@@ -9,7 +9,7 @@ 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',
   'L3-001', 'L3-002', 'L3-003', 'L3-004',
-  'L4-001', 'L4-002', 'L4-003',
+  'L4-001', 'L4-002', 'L4-003', 'L4-004', 'L4-005',
 ]);
 
 export class ValidatorSystemValidatorIdRegistryAdapter {

package/scripts/harness/skill-quality/infrastructure/adapters/validator-id-registry-bridge-adapter.ts

@@ -8,7 +8,7 @@ const FALLBACK_VALIDATOR_IDS = [
   'L1-001', 'L1-002', 'L1-003', 'L1-004', 'L1-005', 'L1-006', 'L1-007', 'L1-008',
   'L2-001', 'L2-002', 'L2-003',
   'L3-001', 'L3-002', 'L3-003', 'L3-004',
-  'L4-001', 'L4-002', 'L4-003',
+  'L4-001', 'L4-002', 'L4-003', 'L4-004', 'L4-005',
 ];
 
 export class ValidatorIdRegistryBridgeAdapter implements ValidatorIdRegistryPort {

package/scripts/harness/validator-system/application/dto/run-l4-validators-input.ts

@@ -8,4 +8,5 @@ export interface RunL4ValidatorsInput {
   readonly validatorIds?: readonly string[];
   readonly targetUnits?: readonly string[];
   readonly strictMode?: boolean;
+  readonly forceLayerEnabled?: boolean;
 }

package/scripts/harness/validator-system/application/use-cases/run-full-validation-usecase.ts

@@ -78,6 +78,7 @@ export class RunFullValidationUseCase {
     if (runL4) {
       l4Results = await this.l4UseCase.execute({
         targetUnits: input.targetUnits,
+        forceLayerEnabled: input.targetLayers?.length === 1 && input.targetLayers.includes('L4'),
       });
     }
 

package/scripts/harness/validator-system/application/use-cases/run-l4-validators-usecase.ts

@@ -6,6 +6,7 @@
  */
 import { ValidatorId } from '../../domain/value-objects/validator-id.js';
 import { ValidationResult } from '../../domain/value-objects/validation-result.js';
+import { LayerConfig } from '../../domain/value-objects/layer-config.js';
 import { ValidatorRegistry } from '../../domain/services/validator-registry.js';
 import { ValidatorExecutionService, ValidatorExecutionError } from '../../domain/services/validator-execution-service.js';
 import { ValidationResultContractMapper } from '../mappers/validation-result-contract-mapper.js';
@@ -16,6 +17,38 @@ import type { DriftDetectionService } from '../../domain/services/l4/drift-detec
 import type { ConsistencyCheckService } from '../../domain/services/l4/consistency-check-service.js';
 import type { DeadCodeDetectionService } from '../../domain/services/l4/dead-code-detection-service.js';
 
+interface ScheduledHarnessErrorContract {
+  readonly severity: string;
+  readonly message: string;
+  readonly suggestion: string;
+}
+
+interface CheckDocFreshnessOutputContract {
+  readonly results: readonly {
+    readonly level: 'ok' | 'warn' | 'error';
+    readonly message: string;
+  }[];
+  readonly errors: readonly ScheduledHarnessErrorContract[];
+}
+
+interface ValidateDocPointersOutputContract {
+  readonly results: readonly {
+    readonly documentPath: string;
+    readonly pointerTarget: string;
+    readonly isResolvable: boolean;
+    readonly errorMessage: string | null;
+  }[];
+  readonly errors: readonly ScheduledHarnessErrorContract[];
+}
+
+interface CheckDocFreshnessUseCasePort {
+  execute(input: { targetPattern?: string; format?: 'text' | 'json'; dryRun?: boolean }): Promise<CheckDocFreshnessOutputContract>;
+}
+
+interface ValidateDocPointersUseCasePort {
+  execute(input: { targetPattern?: string; includeUrlPointers?: boolean; format?: 'text' | 'json' }): Promise<ValidateDocPointersOutputContract>;
+}
+
 export class DesignDocumentReadError extends Error {
   constructor(message: string) {
     super(message);
@@ -31,6 +64,8 @@ export interface RunL4ValidatorsUseCaseDeps {
   driftDetectionService?: DriftDetectionService;
   consistencyCheckService?: ConsistencyCheckService;
   deadCodeDetectionService?: DeadCodeDetectionService;
+  checkDocFreshnessUseCase?: CheckDocFreshnessUseCasePort;
+  validateDocPointersUseCase?: ValidateDocPointersUseCasePort;
 }
 
 export class RunL4ValidatorsUseCase {
@@ -41,6 +76,8 @@ export class RunL4ValidatorsUseCase {
   private readonly driftDetectionService?: DriftDetectionService;
   private readonly consistencyCheckService?: ConsistencyCheckService;
   private readonly deadCodeDetectionService?: DeadCodeDetectionService;
+  private readonly checkDocFreshnessUseCase?: CheckDocFreshnessUseCasePort;
+  private readonly validateDocPointersUseCase?: ValidateDocPointersUseCasePort;
 
   constructor(deps: RunL4ValidatorsUseCaseDeps) {
     this.registry = deps.validatorRegistry;
@@ -50,6 +87,8 @@ export class RunL4ValidatorsUseCase {
     this.driftDetectionService = deps.driftDetectionService;
     this.consistencyCheckService = deps.consistencyCheckService;
     this.deadCodeDetectionService = deps.deadCodeDetectionService;
+    this.checkDocFreshnessUseCase = deps.checkDocFreshnessUseCase;
+    this.validateDocPointersUseCase = deps.validateDocPointersUseCase;
   }
 
   async execute(input: RunL4ValidatorsInput): Promise<readonly ValidationResultContract[]> {
@@ -69,11 +108,22 @@ export class RunL4ValidatorsUseCase {
       throw new ValidatorExecutionError(`Failed to get L4 LayerConfig: ${err instanceof Error ? err.message : String(err)}`, err);
     }
 
-    if (!layerConfig.enabled) {
+    if (!layerConfig.enabled && !input.forceLayerEnabled) {
       return [];
     }
 
-    const results = this.executionService.execute(definitions, [layerConfig]);
+    const effectiveLayerConfig = input.forceLayerEnabled && !layerConfig.enabled
+      ? LayerConfig.create({
+          layer: layerConfig.layer,
+          enabled: true,
+          validatorIds: layerConfig.validatorIds,
+          thresholds: { ...layerConfig.thresholds },
+          strictOnly: layerConfig.strictOnly,
+          preset: layerConfig.preset,
+        })
+      : layerConfig;
+
+    const results = this.executionService.execute(definitions, [effectiveLayerConfig]);
     const overrideMap = new Map<string, ValidationResult>(results.map((result) => [result.validatorId.value, result]));
 
     if (this.driftDetectionService) {
@@ -109,7 +159,7 @@ export class RunL4ValidatorsUseCase {
     if (this.deadCodeDetectionService) {
       const l4003Result = overrideMap.get('L4-003');
       if (l4003Result && !l4003Result.skipped) {
-        const strictOnly = input.strictMode ?? layerConfig.strictOnly ?? false;
+        const strictOnly = input.strictMode ?? effectiveLayerConfig.strictOnly ?? false;
         const report = await this.deadCodeDetectionService.detect({ strictOnly });
         if (report.hasDeadCode()) {
           overrideMap.set(
@@ -120,9 +170,89 @@ export class RunL4ValidatorsUseCase {
       }
     }
 
+    if (this.checkDocFreshnessUseCase) {
+      const l4004Result = overrideMap.get('L4-004');
+      if (l4004Result && !l4004Result.skipped) {
+        const freshnessOutput = await this.checkDocFreshnessUseCase.execute({ format: 'json' });
+        const errors = this.toDocFreshnessHarnessErrors(freshnessOutput);
+        overrideMap.set(
+          'L4-004',
+          errors.length > 0
+            ? ValidationResult.fail(ValidatorId.create('L4-004'), errors, 0)
+            : ValidationResult.pass(ValidatorId.create('L4-004'), 0),
+        );
+      }
+    }
+
+    if (this.validateDocPointersUseCase) {
+      const l4005Result = overrideMap.get('L4-005');
+      if (l4005Result && !l4005Result.skipped) {
+        const pointerOutput = await this.validateDocPointersUseCase.execute({ includeUrlPointers: false, format: 'json' });
+        const errors = this.toPointerValidationHarnessErrors(pointerOutput);
+        overrideMap.set(
+          'L4-005',
+          errors.length > 0
+            ? ValidationResult.fail(ValidatorId.create('L4-005'), errors, 0)
+            : ValidationResult.pass(ValidatorId.create('L4-005'), 0),
+        );
+      }
+    }
+
     const finalResults = definitions.map(
       (definition) => overrideMap.get(definition.validatorId.value) ?? ValidationResult.skip(definition.validatorId),
     );
     return this.mapper.toContracts(finalResults);
   }
+
+  private toDocFreshnessHarnessErrors(output: CheckDocFreshnessOutputContract): readonly ValidationResult['errors'][number][] {
+    const executionErrors = output.errors.map((error) => this.toHarnessErrorLike(
+      'L4-004',
+      error.severity,
+      error.message,
+      error.suggestion,
+    ));
+    const freshnessFindings = output.results
+      .filter((result) => result.level !== 'ok')
+      .map((result) => this.toHarnessErrorLike(
+        'L4-004',
+        result.level === 'error' ? 'error' : 'warning',
+        result.message,
+        'Review the document freshness threshold or update the design document.',
+      ));
+
+    return [...executionErrors, ...freshnessFindings];
+  }
+
+  private toPointerValidationHarnessErrors(output: ValidateDocPointersOutputContract): readonly ValidationResult['errors'][number][] {
+    const executionErrors = output.errors.map((error) => this.toHarnessErrorLike(
+      'L4-005',
+      error.severity,
+      error.message,
+      error.suggestion,
+    ));
+    const brokenPointers = output.results
+      .filter((result) => !result.isResolvable)
+      .map((result) => this.toHarnessErrorLike(
+        'L4-005',
+        'warning',
+        `${result.documentPath} has an unresolved pointer to ${result.pointerTarget}`,
+        result.errorMessage ?? 'Fix or remove the pointer target.',
+      ));
+
+    return [...executionErrors, ...brokenPointers];
+  }
+
+  private toHarnessErrorLike(
+    code: string,
+    severity: string,
+    message: string,
+    suggestion: string,
+  ): ValidationResult['errors'][number] {
+    return {
+      code: { value: code, toString: () => code },
+      severity: { value: severity, toString: () => severity },
+      message,
+      suggestion,
+    };
+  }
 }