peaks-loop 4.0.8 → 4.0.10

package/dist/services/capability-guard-runner/contracts/J10.d.ts

@@ -0,0 +1,2 @@
+import type { GuardContext, GuardRunResult } from '../types.js';
+export declare function runJ10Contract(ctx: GuardContext): Promise<GuardRunResult>;

package/dist/services/capability-guard-runner/contracts/J10.js

@@ -0,0 +1,40 @@
+// src/services/capability-guard-runner/contracts/J10.ts
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const CANDIDATE_FILES = [
+    'src/cli/commands/hooks-commands.ts',
+    'src/cli/commands/ide-commands.ts',
+    'src/cli/commands/hook-handle.ts',
+    'src/hooks/pre-tool-use-sub-agent.ts'
+];
+export async function runJ10Contract(ctx) {
+    const existing = CANDIDATE_FILES.filter((f) => existsSync(join(ctx.projectRoot, f)));
+    if (existing.length === 0) {
+        return {
+            journeyId: 'J10',
+            contract: 'hook-assertion',
+            status: 'fail',
+            diff: { before: 'a hooks/ide/handle CLI file exists', after: 'no candidate found', reason: 'J10#1 broken: no IDE install/hook infrastructure is present' },
+            artifactPath: 'src/cli/commands/hooks-commands.ts'
+        };
+    }
+    const primary = existing.some((f) => {
+        const src = readFileSync(join(ctx.projectRoot, f), 'utf8').toLowerCase();
+        return src.includes('hook') || src.includes('install') || src.includes('ide') || src.includes('adapter');
+    });
+    if (!primary) {
+        return {
+            journeyId: 'J10',
+            contract: 'hook-assertion',
+            status: 'fail',
+            diff: { before: 'hooks/ide commands reference install/hook/ide/adapter', after: 'no such reference', reason: 'J10#1 broken: hooks/ide commands do not implement install/hook/ide/adapter' },
+            artifactPath: existing[0]
+        };
+    }
+    return {
+        journeyId: 'J10',
+        contract: 'hook-assertion',
+        status: 'pass',
+        artifactPath: existing[0]
+    };
+}

package/dist/services/capability-guard-runner/contracts/J11.d.ts

@@ -0,0 +1,2 @@
+import type { GuardContext, GuardRunResult } from '../types.js';
+export declare function runJ11Contract(ctx: GuardContext): Promise<GuardRunResult>;

package/dist/services/capability-guard-runner/contracts/J11.js

@@ -0,0 +1,39 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const CANDIDATE_FILES = [
+    'src/services/doctor/doctor-service.ts',
+    'src/services/audit/audit-service.ts',
+    'src/cli/commands/openspec-commands.ts',
+    'src/services/openspec/openspec-propose-from-doctor-service.ts'
+];
+export async function runJ11Contract(ctx) {
+    const existing = CANDIDATE_FILES.filter((f) => existsSync(join(ctx.projectRoot, f)));
+    if (existing.length === 0) {
+        return {
+            journeyId: 'J11',
+            contract: 'cli-output-golden',
+            status: 'fail',
+            diff: { before: 'a doctor/audit/openspec service exists', after: 'no candidate found', reason: 'J11#1 broken: no doctor surface is present' },
+            artifactPath: 'src/services/doctor/doctor-service.ts'
+        };
+    }
+    const primary = existing.some((f) => {
+        const src = readFileSync(join(ctx.projectRoot, f), 'utf8').toLowerCase();
+        return src.includes('doctor') || src.includes('audit') || src.includes('openspec') || src.includes('health');
+    });
+    if (!primary) {
+        return {
+            journeyId: 'J11',
+            contract: 'cli-output-golden',
+            status: 'fail',
+            diff: { before: 'doctor/audit/openspec references health/audit/openspec', after: 'no such reference', reason: 'J11#1 broken: doctor/audit/openspec services are not wired' },
+            artifactPath: existing[0]
+        };
+    }
+    return {
+        journeyId: 'J11',
+        contract: 'cli-output-golden',
+        status: 'pass',
+        artifactPath: existing[0]
+    };
+}

package/dist/services/capability-guard-runner/contracts/J12.d.ts

@@ -0,0 +1,2 @@
+import type { GuardContext, GuardRunResult } from '../types.js';
+export declare function runJ12Contract(ctx: GuardContext): Promise<GuardRunResult>;

package/dist/services/capability-guard-runner/contracts/J12.js

@@ -0,0 +1,34 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const CANDIDATE_FILES = [
+    'src/services/worktree/lease-store.ts',
+    'src/services/worktree/worktree-lease.ts',
+    'src/services/dispatch/sub-agent-dispatcher.ts',
+    'src/services/lease-metrics/lease-metrics-service.ts'
+];
+const REQUIRED_FRAGMENTS = ['lease', 'release'];
+export async function runJ12Contract(ctx) {
+    const existing = CANDIDATE_FILES.filter((f) => existsSync(join(ctx.projectRoot, f)));
+    if (existing.length === 0) {
+        return {
+            journeyId: 'J12',
+            contract: 'concurrency-lease',
+            status: 'fail',
+            diff: { before: 'a worktree/lease/dispatch service exists', after: 'no candidate found', reason: 'J12#1 broken: no lease infrastructure is present' },
+            artifactPath: 'src/services/worktree/'
+        };
+    }
+    // Soft: at least one file references BOTH 'lease' AND 'release' in its content.
+    const fullCoverage = existing.some((f) => {
+        const src = readFileSync(join(ctx.projectRoot, f), 'utf8').toLowerCase();
+        return REQUIRED_FRAGMENTS.every((frag) => src.includes(frag));
+    });
+    const ok = fullCoverage;
+    return {
+        journeyId: 'J12',
+        contract: 'concurrency-lease',
+        status: ok ? 'pass' : 'fail',
+        ...(ok ? {} : { diff: { before: 'a worktree/lease service references both lease and release', after: 'no such file', reason: 'J12#1 broken: lease lifecycle (lease + release) is incomplete' } }),
+        artifactPath: existing[0]
+    };
+}

package/dist/services/capability-guard-runner/contracts/J13.d.ts

@@ -0,0 +1,2 @@
+import type { GuardContext, GuardRunResult } from '../types.js';
+export declare function runJ13Contract(ctx: GuardContext): Promise<GuardRunResult>;

package/dist/services/capability-guard-runner/contracts/J13.js

@@ -0,0 +1,45 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const CANDIDATE_FILES = [
+    'skills/peaks-content/SKILL.md',
+    'src/services/content/',
+    'src/services/workflow/workflow-router-service.ts',
+    '.peaks/standards/loop-engineering-guidelines.md'
+];
+const STAGES = ['draft', 'edit', 'tone', 'publish', 'archive'];
+export async function runJ13Contract(ctx) {
+    const existing = CANDIDATE_FILES.filter((f) => existsSync(join(ctx.projectRoot, f)));
+    if (existing.length === 0) {
+        return {
+            journeyId: 'J13',
+            contract: 'workflow-trace',
+            status: 'fail',
+            diff: { before: 'a content / peaks-content skill exists', after: 'no candidate found', reason: 'J13#1 broken: no content production surface is present' },
+            artifactPath: 'skills/peaks-content/SKILL.md'
+        };
+    }
+    // Soft check: at least 3 of 5 stages appear in any existing file's content.
+    const matchedStages = new Set();
+    for (const file of existing) {
+        const src = readFileSync(join(ctx.projectRoot, file), 'utf8').toLowerCase();
+        for (const stage of STAGES) {
+            if (src.includes(stage))
+                matchedStages.add(stage);
+        }
+    }
+    if (matchedStages.size < 3) {
+        return {
+            journeyId: 'J13',
+            contract: 'workflow-trace',
+            status: 'fail',
+            diff: { before: 'at least 3 of draft/edit/tone/publish/archive stages are referenced', after: `only ${[...matchedStages].join(',')} found`, reason: 'J13#1 broken: content pipeline has too few stages' },
+            artifactPath: existing[0]
+        };
+    }
+    return {
+        journeyId: 'J13',
+        contract: 'workflow-trace',
+        status: 'pass',
+        artifactPath: existing[0]
+    };
+}

package/dist/services/capability-guard-runner/contracts/J14.d.ts

@@ -0,0 +1,2 @@
+import type { GuardContext, GuardRunResult } from '../types.js';
+export declare function runJ14Contract(ctx: GuardContext): Promise<GuardRunResult>;

package/dist/services/capability-guard-runner/contracts/J14.js

@@ -0,0 +1,36 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const CANDIDATE_FILES = [
+    'skills/peaks-issue-fix-orchestrator/SKILL.md',
+    '.peaks/memory/peaks-loop-positioning-loop-engineering.md',
+    '.peaks/standards/loop-engineering-guidelines.md'
+];
+const REQUIRED_STAGES = ['triage', 'classify', 'fix', 'commit'];
+export async function runJ14Contract(ctx) {
+    const existing = CANDIDATE_FILES.filter((f) => existsSync(join(ctx.projectRoot, f)));
+    if (existing.length === 0) {
+        return {
+            journeyId: 'J14',
+            contract: 'workflow-trace',
+            status: 'fail',
+            diff: { before: 'a peaks-issue-fix-orchestrator skill or memory file exists', after: 'no candidate found', reason: 'J14#1 broken: no issue-sweep surface is present' },
+            artifactPath: 'skills/peaks-issue-fix-orchestrator/SKILL.md'
+        };
+    }
+    const matched = new Set();
+    for (const file of existing) {
+        const src = readFileSync(join(ctx.projectRoot, file), 'utf8').toLowerCase();
+        for (const stage of REQUIRED_STAGES) {
+            if (src.includes(stage))
+                matched.add(stage);
+        }
+    }
+    const ok = matched.size >= 2;
+    return {
+        journeyId: 'J14',
+        contract: 'workflow-trace',
+        status: ok ? 'pass' : 'fail',
+        ...(ok ? {} : { diff: { before: 'at least 2 of triage/classify/fix/commit are referenced', after: `only ${[...matched].join(',')} found`, reason: 'J14#1 broken: issue-sweep pipeline has too few stages' } }),
+        artifactPath: existing[0]
+    };
+}

package/dist/services/capability-guard-runner/contracts/J15.d.ts

@@ -0,0 +1,2 @@
+import type { GuardContext, GuardRunResult } from '../types.js';
+export declare function runJ15Contract(ctx: GuardContext): Promise<GuardRunResult>;

package/dist/services/capability-guard-runner/contracts/J15.js

@@ -0,0 +1,40 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const CANDIDATE_FILES = [
+    'src/services/openspec/openspec-archive-service.ts',
+    'src/services/openspec/coverage-evidence-reader.ts',
+    'src/cli/commands/openspec-commands.ts'
+];
+const REQUIRED_FRAGMENTS = ['Capability Mapping', 'coverage'];
+export async function runJ15Contract(ctx) {
+    const existing = CANDIDATE_FILES.filter((f) => existsSync(join(ctx.projectRoot, f)));
+    if (existing.length === 0) {
+        return {
+            journeyId: 'J15',
+            contract: 'spec-coverage',
+            status: 'fail',
+            diff: { before: 'an openspec archive/coverage service exists', after: 'no candidate found', reason: 'J15#1 broken: no openspec/coverage surface is present' },
+            artifactPath: 'src/services/openspec/'
+        };
+    }
+    // At least one file references BOTH "Capability Mapping" AND "coverage".
+    const fullCoverage = existing.some((f) => {
+        const src = readFileSync(join(ctx.projectRoot, f), 'utf8');
+        return REQUIRED_FRAGMENTS.every((frag) => src.includes(frag));
+    });
+    if (!fullCoverage) {
+        return {
+            journeyId: 'J15',
+            contract: 'spec-coverage',
+            status: 'fail',
+            diff: { before: 'openspec services reference both "Capability Mapping" and "coverage"', after: 'no such service', reason: 'J15#1 broken: openspec archive gate is missing the Capability Mapping + coverage cross-check' },
+            artifactPath: existing[0]
+        };
+    }
+    return {
+        journeyId: 'J15',
+        contract: 'spec-coverage',
+        status: 'pass',
+        artifactPath: existing[0]
+    };
+}

package/dist/services/capability-guard-runner/diff.d.ts

@@ -0,0 +1,2 @@
+import type { GuardDiff } from './types.js';
+export declare function formatHumanReadableDiff(diff: GuardDiff): string;

package/dist/services/capability-guard-runner/diff.js

@@ -0,0 +1,7 @@
+export function formatHumanReadableDiff(diff) {
+    return [
+        `reason: ${diff.reason}`,
+        `- ${diff.before}`,
+        `+ ${diff.after}`
+    ].join('\n');
+}

package/dist/services/capability-guard-runner/runner.d.ts

@@ -0,0 +1,9 @@
+import type { GuardContract, GuardContext, GuardRunResult } from './types.js';
+export declare function runGuard(contract: GuardContract, ctx: GuardContext): Promise<GuardRunResult>;
+export declare function runAllGuards(contracts: ReadonlyArray<GuardContract>, ctx: GuardContext): Promise<{
+    readonly pass: number;
+    readonly fail: number;
+    readonly skipped: number;
+    readonly total: number;
+    readonly results: ReadonlyArray<GuardRunResult>;
+}>;

package/dist/services/capability-guard-runner/runner.js

@@ -0,0 +1,22 @@
+function assertBaselineRef(contract) {
+    if (!contract.source.baselineRow || !contract.source.invariant) {
+        throw new Error('GUARD_CONTRACT_MISSING_BASELINE_REF: contract must reference a baseline row and invariant');
+    }
+}
+export async function runGuard(contract, ctx) {
+    assertBaselineRef(contract);
+    return contract.execute(ctx);
+}
+export async function runAllGuards(contracts, ctx) {
+    const results = [];
+    for (const c of contracts) {
+        results.push(await runGuard(c, ctx));
+    }
+    return {
+        pass: results.filter((r) => r.status === 'pass').length,
+        fail: results.filter((r) => r.status === 'fail').length,
+        skipped: results.filter((r) => r.status === 'skipped').length,
+        total: results.length,
+        results
+    };
+}

package/dist/services/capability-guard-runner/types.d.ts

@@ -0,0 +1,39 @@
+import type { JourneyId } from '../capability-baseline/types.js';
+export type ContractKind = 'cli-envelope' | 'workflow-trace' | 'hook-assertion' | 'cli-output-golden' | 'asset-roundtrip' | 'concurrency-lease' | 'sop-register' | 'spec-coverage' | 'envelope-arg-shapes';
+export interface GuardContract {
+    readonly journeyId: JourneyId;
+    readonly kind: ContractKind;
+    readonly source: {
+        readonly baselineRow: JourneyId;
+        readonly invariant: string;
+    };
+    readonly execute: (ctx: GuardContext) => Promise<GuardRunResult>;
+    readonly evidence: {
+        readonly kind: ContractKind;
+        readonly artifact: string;
+    };
+}
+export interface GuardContext {
+    readonly projectRoot: string;
+    readonly sessionId: string;
+    readonly contract: GuardContract;
+    readonly baselineInvariant: string;
+}
+export type GuardStatus = 'pass' | 'fail' | 'skipped';
+export interface GuardDiff {
+    readonly before: string;
+    readonly after: string;
+    readonly reason: string;
+}
+export interface GuardRunResult {
+    readonly journeyId: JourneyId;
+    readonly contract: ContractKind;
+    readonly status: GuardStatus;
+    readonly diff?: GuardDiff;
+    readonly artifactPath: string;
+}
+export type GuardErrorCode = 'GUARD_CONTRACT_MISSING_BASELINE_REF' | 'GUARD_DIFF_DETECTED' | 'GUARD_TEST_FLAKY';
+export interface GuardError {
+    readonly code: GuardErrorCode;
+    readonly message: string;
+}

package/dist/services/capability-guard-runner/types.js

@@ -0,0 +1 @@
+export {};

package/dist/services/container/container-lease.js

@@ -29,6 +29,7 @@
  */
 import { randomBytes } from 'node:crypto';
 import { posix as path } from 'node:path';
+import { normalizePath } from '../../shared/path-utils.js';
 export const DEFAULT_TTL_BY_ROLE = Object.freeze({
     rd: 30 * 60 * 1_000,
     qa: 15 * 60 * 1_000,
@@ -126,7 +127,7 @@ export function deserializeContainerLease(raw) {
 function joinPath(...segments) {
     if (segments.length === 0)
         return '';
-    const normalized = segments.map((s) => s.replace(/\\/g, '/'));
+    const normalized = segments.map((s) => normalizePath(s));
     let acc = normalized[0];
     for (let i = 1; i < normalized.length; i++) {
         acc = path.join(acc, normalized[i]);

package/dist/services/evolution/evolution-types.d.ts

@@ -73,12 +73,12 @@ export declare const EvolutionProposalInputSchema: z.ZodObject<{
     red_lines: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     source_traces: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
+    diff: Record<string, unknown>;
     target_kind: "loop" | "bee" | "gate" | "policy" | "evaluator";
     target_release_id: string;
     optimization_dimension: string;
     before_snapshot: Record<string, unknown>;
     after_snapshot: Record<string, unknown>;
-    diff: Record<string, unknown>;
     before_score: number;
     after_score: number;
     score_delta_min: number;
@@ -97,9 +97,9 @@ export declare const EvolutionProposalInputSchema: z.ZodObject<{
     author_id: string;
     single_object: true;
     single_optimization_dimension: true;
+    diff?: Record<string, unknown> | undefined;
     before_snapshot?: Record<string, unknown> | undefined;
     after_snapshot?: Record<string, unknown> | undefined;
-    diff?: Record<string, unknown> | undefined;
     score_delta_min?: number | undefined;
     rubric?: Record<string, unknown> | undefined;
     red_lines?: string[] | undefined;
@@ -154,12 +154,12 @@ export declare const EvolutionProposalSchema: z.ZodObject<{
     schema_version: "peaks.evolution/1";
     id: string;
     created_at: string;
+    diff: Record<string, unknown>;
     target_kind: "loop" | "bee" | "gate" | "policy" | "evaluator";
     target_release_id: string;
     optimization_dimension: string;
     before_snapshot: Record<string, unknown>;
     after_snapshot: Record<string, unknown>;
-    diff: Record<string, unknown>;
     before_score: number;
     after_score: number;
     score_delta_min: number;
@@ -187,9 +187,9 @@ export declare const EvolutionProposalSchema: z.ZodObject<{
     target_count: 1;
     score_delta: number;
     schema_version?: "peaks.evolution/1" | undefined;
+    diff?: Record<string, unknown> | undefined;
     before_snapshot?: Record<string, unknown> | undefined;
     after_snapshot?: Record<string, unknown> | undefined;
-    diff?: Record<string, unknown> | undefined;
     score_delta_min?: number | undefined;
     rubric?: Record<string, unknown> | undefined;
     red_lines?: string[] | undefined;
@@ -293,12 +293,12 @@ export declare const EvolutionEvaluationInputSchema: z.ZodObject<{
         schema_version: "peaks.evolution/1";
         id: string;
         created_at: string;
+        diff: Record<string, unknown>;
         target_kind: "loop" | "bee" | "gate" | "policy" | "evaluator";
         target_release_id: string;
         optimization_dimension: string;
         before_snapshot: Record<string, unknown>;
         after_snapshot: Record<string, unknown>;
-        diff: Record<string, unknown>;
         before_score: number;
         after_score: number;
         score_delta_min: number;
@@ -326,9 +326,9 @@ export declare const EvolutionEvaluationInputSchema: z.ZodObject<{
         target_count: 1;
         score_delta: number;
         schema_version?: "peaks.evolution/1" | undefined;
+        diff?: Record<string, unknown> | undefined;
         before_snapshot?: Record<string, unknown> | undefined;
         after_snapshot?: Record<string, unknown> | undefined;
-        diff?: Record<string, unknown> | undefined;
         score_delta_min?: number | undefined;
         rubric?: Record<string, unknown> | undefined;
         red_lines?: string[] | undefined;
@@ -374,16 +374,17 @@ export declare const EvolutionEvaluationInputSchema: z.ZodObject<{
     schema_version: "peaks.evolution/1";
     id: string;
     created_at: string;
+    verdict: "keep" | "revert" | "needs-user-decision";
     proposal: {
         schema_version: "peaks.evolution/1";
         id: string;
         created_at: string;
+        diff: Record<string, unknown>;
         target_kind: "loop" | "bee" | "gate" | "policy" | "evaluator";
         target_release_id: string;
         optimization_dimension: string;
         before_snapshot: Record<string, unknown>;
         after_snapshot: Record<string, unknown>;
-        diff: Record<string, unknown>;
         before_score: number;
         after_score: number;
         score_delta_min: number;
@@ -410,12 +411,12 @@ export declare const EvolutionEvaluationInputSchema: z.ZodObject<{
         safetyRegressionRisks: string[];
         blocker?: string | undefined;
     };
-    verdict: "keep" | "revert" | "needs-user-decision";
     user_confirmation_pointer?: string | undefined;
     brief_pointer?: string | undefined;
 }, {
     id: string;
     created_at: string;
+    verdict: "keep" | "revert" | "needs-user-decision";
     proposal: {
         id: string;
         created_at: string;
@@ -431,9 +432,9 @@ export declare const EvolutionEvaluationInputSchema: z.ZodObject<{
         target_count: 1;
         score_delta: number;
         schema_version?: "peaks.evolution/1" | undefined;
+        diff?: Record<string, unknown> | undefined;
         before_snapshot?: Record<string, unknown> | undefined;
         after_snapshot?: Record<string, unknown> | undefined;
-        diff?: Record<string, unknown> | undefined;
         score_delta_min?: number | undefined;
         rubric?: Record<string, unknown> | undefined;
         red_lines?: string[] | undefined;
@@ -452,7 +453,6 @@ export declare const EvolutionEvaluationInputSchema: z.ZodObject<{
         safetyRegressionRisks?: string[] | undefined;
         blocker?: string | undefined;
     };
-    verdict: "keep" | "revert" | "needs-user-decision";
     schema_version?: "peaks.evolution/1" | undefined;
     user_confirmation_pointer?: string | undefined;
     brief_pointer?: string | undefined;
@@ -506,12 +506,12 @@ export declare const EvolutionEvaluationSchema: z.ZodObject<{
         schema_version: "peaks.evolution/1";
         id: string;
         created_at: string;
+        diff: Record<string, unknown>;
         target_kind: "loop" | "bee" | "gate" | "policy" | "evaluator";
         target_release_id: string;
         optimization_dimension: string;
         before_snapshot: Record<string, unknown>;
         after_snapshot: Record<string, unknown>;
-        diff: Record<string, unknown>;
         before_score: number;
         after_score: number;
         score_delta_min: number;
@@ -539,9 +539,9 @@ export declare const EvolutionEvaluationSchema: z.ZodObject<{
         target_count: 1;
         score_delta: number;
         schema_version?: "peaks.evolution/1" | undefined;
+        diff?: Record<string, unknown> | undefined;
         before_snapshot?: Record<string, unknown> | undefined;
         after_snapshot?: Record<string, unknown> | undefined;
-        diff?: Record<string, unknown> | undefined;
         score_delta_min?: number | undefined;
         rubric?: Record<string, unknown> | undefined;
         red_lines?: string[] | undefined;
@@ -589,17 +589,18 @@ export declare const EvolutionEvaluationSchema: z.ZodObject<{
     schema_version: "peaks.evolution/1";
     id: string;
     created_at: string;
+    verdict: "keep" | "revert" | "needs-user-decision";
     score_delta: number;
     proposal: {
         schema_version: "peaks.evolution/1";
         id: string;
         created_at: string;
+        diff: Record<string, unknown>;
         target_kind: "loop" | "bee" | "gate" | "policy" | "evaluator";
         target_release_id: string;
         optimization_dimension: string;
         before_snapshot: Record<string, unknown>;
         after_snapshot: Record<string, unknown>;
-        diff: Record<string, unknown>;
         before_score: number;
         after_score: number;
         score_delta_min: number;
@@ -626,12 +627,12 @@ export declare const EvolutionEvaluationSchema: z.ZodObject<{
         safetyRegressionRisks: string[];
         blocker?: string | undefined;
     };
-    verdict: "keep" | "revert" | "needs-user-decision";
     user_confirmation_pointer?: string | undefined;
     brief_pointer?: string | undefined;
 }, {
     id: string;
     created_at: string;
+    verdict: "keep" | "revert" | "needs-user-decision";
     score_delta: number;
     proposal: {
         id: string;
@@ -648,9 +649,9 @@ export declare const EvolutionEvaluationSchema: z.ZodObject<{
         target_count: 1;
         score_delta: number;
         schema_version?: "peaks.evolution/1" | undefined;
+        diff?: Record<string, unknown> | undefined;
         before_snapshot?: Record<string, unknown> | undefined;
         after_snapshot?: Record<string, unknown> | undefined;
-        diff?: Record<string, unknown> | undefined;
         score_delta_min?: number | undefined;
         rubric?: Record<string, unknown> | undefined;
         red_lines?: string[] | undefined;
@@ -669,7 +670,6 @@ export declare const EvolutionEvaluationSchema: z.ZodObject<{
         safetyRegressionRisks?: string[] | undefined;
         blocker?: string | undefined;
     };
-    verdict: "keep" | "revert" | "needs-user-decision";
     schema_version?: "peaks.evolution/1" | undefined;
     user_confirmation_pointer?: string | undefined;
     brief_pointer?: string | undefined;

package/dist/services/final-review/final-review-service.d.ts

@@ -10,6 +10,7 @@ export interface LlmRunner {
     }>;
 }
 import type { FinalReviewOutput } from './final-review-types.js';
+import type { CapabilityAuditResult } from '../capability-audit-service/types.js';
 export interface PrepareFinalReviewOptions {
     readonly projectRoot: string;
     readonly sessionId: string;
@@ -20,3 +21,10 @@ export declare class IncompleteFinalReviewError extends Error {
     constructor(message: string);
 }
 export declare function prepareFinalReview(rid: string, opts: PrepareFinalReviewOptions): Promise<FinalReviewOutput>;
+export declare function decideFifthDimension(input: {
+    readonly audit: CapabilityAuditResult | null;
+    readonly nowMs: number;
+}): {
+    readonly verdict: 'pass' | 'fail' | 'inconclusive';
+    readonly reason: string;
+};

package/dist/services/final-review/final-review-service.js

@@ -1,5 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { isStale } from '../capability-audit-service/staleness.js';
 const REQUIRED_DIMENSIONS = [
     'functional-completeness',
     'problem-resolution',
@@ -50,3 +51,16 @@ export async function prepareFinalReview(rid, opts) {
     }
     return output;
 }
+export function decideFifthDimension(input) {
+    if (input.audit === null)
+        return { verdict: 'inconclusive', reason: 'AUDIT_GUARD_NOT_RUN' };
+    if (isStale(input.audit.auditedAt, input.nowMs))
+        return { verdict: 'inconclusive', reason: 'AUDIT_STALE' };
+    if (input.audit.crossCheck.guardVsAudit === 'diverge')
+        return { verdict: 'inconclusive', reason: 'AUDIT_CROSS_CHECK_DIVERGE' };
+    if (input.audit.verdict === 'consistent')
+        return { verdict: 'pass', reason: 'audit consistent' };
+    if (input.audit.verdict === 'drifted')
+        return { verdict: 'fail', reason: 'audit drifted' };
+    return { verdict: 'inconclusive', reason: 'audit inconclusive' };
+}

package/dist/services/final-review/final-review-types.d.ts

@@ -15,7 +15,7 @@
  *     failure (return to human for re-prompting) — autonomous work must
  *     never proceed on a partial review.
  */
-export type DimensionKind = 'functional-completeness' | 'problem-resolution' | 'no-new-bugs' | 'existing-functionality-intact';
+export type DimensionKind = 'functional-completeness' | 'problem-resolution' | 'no-new-bugs' | 'existing-functionality-intact' | 'capability-consistency';
 export type DimensionVerdict = 'pass' | 'fail' | 'inconclusive';
 export type EvidenceKind = 'test-result' | 'test-coverage' | 'manual-spot-check' | 'pre-post-diff' | 'regression-suite' | 'ac-mapping';
 export type DimensionConfidence = 'high' | 'medium' | 'low';