@xopcai/xopc 0.0.321 → 0.0.324

package/dist/src/gateway/side-chat/promotion-service.js

@@ -0,0 +1,111 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { init_session_context_for_llm, isRuntimeOnlyTranscriptMessage } from "../../session/session-context-for-llm.js";
+import { SideChatError } from "./manager.js";
+//#region src/gateway/side-chat/promotion-service.ts
+init_session_context_for_llm();
+init_logger();
+const log = createLogger("Gateway:SideChatPromotion");
+var SideChatPromotionService = class {
+	constructor(options) {
+		this.options = options;
+	}
+	async promote(sideChatId, clientInstanceId) {
+		const existing = await this.options.sessionIndex.getSessionMetadata(sideChatId);
+		if (existing) {
+			if (existing.customData?.promotedFromSideChatId !== sideChatId) throw new SideChatError("A session already uses this side chat id", "CONFLICT");
+			return {
+				conversationId: sideChatId,
+				created: false,
+				session: existing
+			};
+		}
+		const snapshot = this.options.manager.beginPromotion(sideChatId, clientInstanceId);
+		const parent = snapshot.parentMetadata;
+		const agentId = parent.routing?.agentId?.trim() || parent.agentId;
+		const chatId = `chat_${sideChatId}`;
+		const rows = [{
+			type: "side_chat_origin",
+			version: 1,
+			parentConversationId: snapshot.context.parentConversationId,
+			parentTranscriptId: snapshot.context.parentTranscriptId,
+			createdAt: snapshot.context.createdAt,
+			contentHash: snapshot.context.contentHash,
+			contextMessages: snapshot.contextMessages
+		}, ...snapshot.conversationRows.filter((row) => !isRuntimeOnlyTranscriptMessage(row))];
+		try {
+			await this.options.sessionIndex.createSessionFromRows({
+				targetKey: sideChatId,
+				cwd: parent.cwd || "",
+				metadata: {
+					agentId,
+					sourceChannel: "webchat",
+					sourceChatId: `default:direct:${chatId}`,
+					sessionType: "chat",
+					tags: [...new Set([...parent.tags ?? [], "side-chat"])],
+					projectId: parent.projectId,
+					parentConversationId: snapshot.context.parentConversationId,
+					hiddenFromSessionList: false,
+					routing: {
+						agentId,
+						source: "webchat",
+						accountId: "default",
+						peerKind: "direct",
+						peerId: chatId
+					},
+					customData: {
+						genericNewChatShell: false,
+						promotedFromSideChatId: sideChatId,
+						promotedFromParentTranscriptId: snapshot.context.parentTranscriptId,
+						sideChatContextHash: snapshot.context.contentHash,
+						promotedAt: (/* @__PURE__ */ new Date()).toISOString()
+					}
+				},
+				rows,
+				config: {
+					...snapshot.parentConfig ?? {},
+					modelOverride: snapshot.config.modelRef,
+					thinkingLevel: snapshot.config.thinkingLevel
+				}
+			});
+		} catch (error) {
+			this.options.manager.cancelPromotion(sideChatId, clientInstanceId);
+			throw error;
+		}
+		const firstUserText = snapshot.conversationRows.find((row) => isAgentMessageWithRole(row, "user"));
+		if (firstUserText) try {
+			this.options.getAgentService().enqueueProvisionalSessionTitle(sideChatId, messageText(firstUserText));
+		} catch (err) {
+			log.warn({
+				err,
+				sideChatId,
+				phase: "side_chat_promote_title"
+			}, "Saved side chat but title generation could not start");
+		}
+		await this.options.manager.disposePromoted(sideChatId, clientInstanceId).catch((err) => {
+			log.warn({
+				err,
+				sideChatId,
+				phase: "side_chat_promote_cleanup"
+			}, "Saved side chat but cleanup failed");
+		});
+		const session = await this.options.sessionIndex.getSessionMetadata(sideChatId);
+		if (!session) throw new Error(`Promoted session not found: ${sideChatId}`);
+		return {
+			conversationId: sideChatId,
+			created: true,
+			session
+		};
+	}
+};
+function isAgentMessageWithRole(row, role) {
+	return Boolean(row && typeof row === "object" && row.role === role);
+}
+function messageText(message) {
+	const content = message.content;
+	if (typeof content === "string") return content.trim();
+	if (!Array.isArray(content)) return "";
+	return content.filter((part) => Boolean(part && typeof part === "object" && part.type === "text" && typeof part.text === "string")).map((part) => part.text).join("\n").trim();
+}
+//#endregion
+export { SideChatPromotionService };

package/dist/src/gateway/side-chat/run-service.js

@@ -16,6 +16,7 @@ var SideChatRunService = class {
 		const text = input.content.trim();
 		if (!text && !input.attachments?.length) throw new SideChatError("content or attachments are required", "INVALID_REQUEST");
 		const sideChat = this.options.manager.get(sideChatId, clientInstanceId);
+		if (sideChat.status !== "idle") throw new SideChatError("A side chat run is already active", "CONFLICT");
 		if (this.activeBySideChat.has(sideChatId)) throw new SideChatError("A side chat run is already active", "CONFLICT");
 		const run = {
 			sideChatId,

package/dist/src/gateway/side-chat/types.d.ts

@@ -1,5 +1,5 @@
 import type { ThinkingLevel } from '@earendil-works/pi-agent-core';
-export type SideChatStatus = 'idle' | 'running' | 'waiting-approval' | 'waiting-input' | 'closing';
+export type SideChatStatus = 'idle' | 'running' | 'waiting-approval' | 'waiting-input' | 'promoting' | 'closing';
 export type SideChatSelection = {
     id: string;
     type: 'message';

package/dist/src/gateway/xopc-cloud-capability-setup.d.ts

@@ -1,4 +1,5 @@
 import type { Config } from '../config/schema.js';
+import type { AgentDefaults } from '../agent-config/index.js';
 import type { CatalogSource } from '../providers/model-catalog-store.js';
 type CloudCapability = 'chat' | 'vision' | 'image-generation' | 'stt' | 'tts';
 export interface XopcCloudCapabilitySelection {
@@ -12,6 +13,7 @@ export interface XopcCloudCapabilitySelection {
 export type PrepareXopcCloudCapabilitySetupResult = {
     ok: true;
     config: Config;
+    defaults: AgentDefaults;
     selection: XopcCloudCapabilitySelection;
 } | {
     ok: false;

package/dist/src/gateway/xopc-cloud-capability-setup.js

@@ -1,7 +1,10 @@
+import { AgentCatalogRepository, init_repository } from "../agent-catalog/repository.js";
+import { AgentCatalogService } from "../agent-catalog/service.js";
 import { getModelCatalogStore, init_model_catalog_store } from "../providers/model-catalog-store.js";
 import { compareCatalogModels } from "../providers/model-catalog-ranking.js";
 import { prepareUpdateGlobalDefaults } from "./global-defaults-admin.js";
 //#region src/gateway/xopc-cloud-capability-setup.ts
+init_repository();
 init_model_catalog_store();
 function supportsCapability(model, capability) {
 	if (model.availability !== "available") return false;
@@ -49,9 +52,10 @@ function prepareXopcCloudCapabilitySetup(config, source) {
 		missing: selected.missing
 	};
 	const selection = selected.selection;
-	const currentModels = config.agents.defaults.models;
-	const defaultsUpdate = prepareUpdateGlobalDefaults(config, { defaults: {
-		...config.agents.defaults,
+	const currentDefaults = new AgentCatalogRepository().getSettings().defaults;
+	const currentModels = currentDefaults.models;
+	const defaultsUpdate = prepareUpdateGlobalDefaults({ defaults: {
+		...currentDefaults,
 		models: {
 			...currentModels,
 			chat: {
@@ -75,18 +79,18 @@ function prepareXopcCloudCapabilitySetup(config, source) {
 		error: defaultsUpdate.error,
 		missing: []
 	};
-	const withDefaults = defaultsUpdate.data.nextConfig;
-	const currentStt = withDefaults.tools?.media?.audio;
-	const currentTts = withDefaults.messages?.tts;
+	const currentStt = config.tools?.media?.audio;
+	const currentTts = config.messages?.tts;
 	return {
 		ok: true,
 		selection,
+		defaults: defaultsUpdate.data.defaults,
 		config: {
-			...withDefaults,
+			...config,
 			tools: {
-				...withDefaults.tools,
+				...config.tools,
 				media: {
-					...withDefaults.tools?.media,
+					...config.tools?.media,
 					audio: {
 						...currentStt,
 						enabled: true,
@@ -106,7 +110,7 @@ function prepareXopcCloudCapabilitySetup(config, source) {
 				}
 			},
 			messages: {
-				...withDefaults.messages,
+				...config.messages,
 				tts: {
 					...currentTts,
 					enabled: true,
@@ -144,6 +148,7 @@ async function applyXopcCloudCapabilitySetup(service) {
 		configured: false,
 		error: saved.error ?? "Failed to save XOPC Cloud capability configuration"
 	};
+	new AgentCatalogService().updateDefaults(prepared.defaults);
 	return {
 		configured: true,
 		selection: prepared.selection

package/dist/src/home-intelligence/application-service.d.ts

@@ -0,0 +1,31 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { HomeOpportunityActionResponse } from '@xopcai/gateway-contract';
+import { type HomeOpportunityFeedbackInput, type HomePrincipal } from './repository.js';
+export declare class HomeOpportunityNotFoundError extends Error {
+}
+export declare class HomeOpportunityActionError extends Error {
+}
+export declare class HomeOpportunityApplicationService {
+    private readonly db;
+    private readonly principal;
+    private readonly resolveAgentId;
+    private readonly repository;
+    private readonly tasks;
+    private readonly taskApplication;
+    constructor(db: DatabaseSync, principal: HomePrincipal, resolveAgentId?: () => string);
+    start(input: {
+        opportunityId: string;
+        expectedRevision: number;
+        idempotencyKey: string;
+        now: number;
+    }, options?: {
+        degraded?: boolean;
+    }): HomeOpportunityActionResponse;
+    discuss(input: {
+        opportunityId: string;
+        expectedRevision: number;
+        idempotencyKey: string;
+        now: number;
+    }): HomeOpportunityActionResponse;
+    feedback(opportunityId: string, input: HomeOpportunityFeedbackInput): void;
+}

package/dist/src/home-intelligence/application-service.js

@@ -0,0 +1,134 @@
+import { init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { TaskRepository, init_task_repository } from "../tasks/task-repository.js";
+import { TaskApplicationService } from "../tasks/task-application-service.js";
+import { HomeIntelligenceRepository } from "./repository.js";
+//#region src/home-intelligence/application-service.ts
+init_task_repository();
+init_transaction();
+var HomeOpportunityNotFoundError = class extends Error {};
+var HomeOpportunityActionError = class extends Error {};
+var HomeOpportunityApplicationService = class {
+	repository;
+	tasks = new TaskRepository();
+	taskApplication = new TaskApplicationService();
+	constructor(db, principal, resolveAgentId = () => "main") {
+		this.db = db;
+		this.principal = principal;
+		this.resolveAgentId = resolveAgentId;
+		this.repository = new HomeIntelligenceRepository(db);
+	}
+	start(input, options = {}) {
+		return runSqliteWriteTransaction((db) => {
+			if (db !== this.db) throw new Error("Home opportunity service database mismatch");
+			const taskKey = `home-opportunity:${input.opportunityId}:${input.idempotencyKey}`;
+			const existing = this.tasks.getByIdempotencyKey(taskKey);
+			if (existing) return {
+				outcome: "task",
+				taskId: existing.id,
+				href: `/tasks/${encodeURIComponent(existing.id)}`
+			};
+			const opportunity = this.repository.getOpportunity(this.principal, input.opportunityId, input.now);
+			if (!opportunity) throw new HomeOpportunityNotFoundError("Home opportunity is unavailable");
+			if (opportunity.revision !== input.expectedRevision) throw new HomeOpportunityActionError("Home opportunity changed; refresh before starting");
+			if (opportunity.evidence.some((item) => item.freshUntil <= input.now)) throw new HomeOpportunityActionError("Home opportunity evidence expired; refresh before starting");
+			const degraded = Boolean(options.degraded);
+			if (degraded && !opportunity.degradedActionPrompt) throw new HomeOpportunityActionError("This opportunity has no degraded start path");
+			if (!degraded && !opportunity.actions.canStart || opportunity.risk === "external_write") throw new HomeOpportunityActionError("This opportunity must be discussed before it can start");
+			const agentId = this.resolveAgentId();
+			const created = this.taskApplication.create({
+				idempotencyKey: taskKey,
+				title: opportunity.title,
+				projectId: opportunity.projectId,
+				priority: opportunity.urgency === "now" ? "high" : "normal",
+				delegateAgentId: agentId,
+				contract: {
+					objective: degraded ? opportunity.degradedActionPrompt : opportunity.actionPrompt,
+					expectedOutputs: [opportunity.outcome],
+					acceptanceCriteria: opportunity.verification,
+					constraints: degraded ? ["Use only currently available capabilities and the attached evidence."] : [],
+					approvalRequired: [],
+					assumptions: [],
+					risks: [opportunity.risk],
+					acceptancePolicy: "verified_then_review",
+					outputDestinations: []
+				},
+				dependencies: [],
+				context: opportunity.evidence.map((item) => ({
+					targetKind: item.sourceType === "file" ? "file" : "source",
+					targetId: item.sourceRef,
+					role: "evidence",
+					title: item.observation.slice(0, 200),
+					pinned: true,
+					retrievalPolicy: {},
+					metadata: {
+						evidenceId: item.id,
+						revision: item.revision
+					}
+				})),
+				authorityGrants: [],
+				activation: {
+					mode: "start",
+					executor: {
+						kind: "agent",
+						agentId
+					}
+				}
+			}, { kind: "user" });
+			if (created.ok === false) throw new HomeOpportunityActionError(`Could not start task: ${created.reason}`);
+			const task = created.model.task;
+			this.repository.recordFeedback(this.principal, input.opportunityId, {
+				idempotencyKey: input.idempotencyKey,
+				kind: "started",
+				expectedRevision: input.expectedRevision,
+				createdAt: input.now,
+				resolution: {
+					kind: "task",
+					ref: task.id
+				}
+			});
+			return {
+				outcome: "task",
+				taskId: task.id,
+				href: `/tasks/${encodeURIComponent(task.id)}`
+			};
+		});
+	}
+	discuss(input) {
+		const replay = this.repository.isFeedbackRecorded(input.opportunityId, input.idempotencyKey);
+		const opportunity = replay ? this.repository.getOpportunitySnapshot(this.principal, input.opportunityId) : this.repository.getOpportunity(this.principal, input.opportunityId, input.now);
+		if (!opportunity) throw new HomeOpportunityNotFoundError("Home opportunity is unavailable");
+		if (!replay) {
+			if (opportunity.revision !== input.expectedRevision) throw new HomeOpportunityActionError("Home opportunity changed; refresh before discussing");
+			this.repository.recordFeedback(this.principal, input.opportunityId, {
+				idempotencyKey: input.idempotencyKey,
+				kind: "discussed",
+				expectedRevision: input.expectedRevision,
+				createdAt: input.now,
+				resolution: {
+					kind: "session",
+					ref: "draft"
+				}
+			});
+		}
+		const query = new URLSearchParams({ draft: opportunity.actionPrompt });
+		if (opportunity.projectId) query.set("projectId", opportunity.projectId);
+		return {
+			outcome: "chat_draft",
+			href: `/chat/new?${query.toString()}`
+		};
+	}
+	feedback(opportunityId, input) {
+		if (this.repository.isFeedbackRecorded(opportunityId, input.idempotencyKey)) return;
+		const opportunity = this.repository.getOpportunity(this.principal, opportunityId, input.createdAt);
+		if (!opportunity) throw new HomeOpportunityNotFoundError("Home opportunity is unavailable");
+		this.repository.recordFeedback(this.principal, opportunityId, {
+			...input,
+			scope: input.scope ?? {
+				kind: opportunity.kind,
+				projectId: opportunity.projectId
+			}
+		});
+	}
+};
+//#endregion
+export { HomeOpportunityActionError, HomeOpportunityApplicationService, HomeOpportunityNotFoundError };

package/dist/src/home-intelligence/capability-preflight.d.ts

@@ -0,0 +1,32 @@
+import type { HomeCapabilityPreflight, HomeCapabilityReadiness } from '@xopcai/gateway-contract';
+import type { Config } from '../config/schema.js';
+import type { AgentSkillUnavailableReason } from '../agent/agent-manager.js';
+import type { HomeCapabilityInventory } from './types.js';
+export interface HomeCapabilityRequirement {
+    kind: 'connector' | 'skill' | 'agent';
+    capability: string;
+    required: boolean;
+}
+export interface HomeSkillAvailability {
+    name: string;
+    availableForCurrentAgent: boolean;
+    unavailableReason: AgentSkillUnavailableReason | null;
+}
+export interface HomeCapabilityResolution {
+    capabilities: HomeCapabilityReadiness[];
+    preflight: HomeCapabilityPreflight;
+}
+export interface HomeCapabilityPreflightDeps {
+    config(): Config;
+    agentId(): string;
+    skills(agentId: string): HomeSkillAvailability[];
+    principalId: string;
+}
+export declare class HomeCapabilityPreflightService {
+    private readonly deps;
+    constructor(deps: HomeCapabilityPreflightDeps);
+    inventory(): HomeCapabilityInventory;
+    resolve(requirements: readonly HomeCapabilityRequirement[], options?: {
+        degradedActionAvailable?: boolean;
+    }): HomeCapabilityResolution;
+}

package/dist/src/home-intelligence/capability-preflight.js

@@ -0,0 +1,118 @@
+import { listConnectorInstances } from "../connectors/instances.js";
+import { preflightConnectorRequirements } from "../connectors/workflow-preflight.js";
+//#region src/home-intelligence/capability-preflight.ts
+const SKILL_CODE = {
+	"agent-denied": "agent_not_allowed",
+	disabled: "disabled",
+	"requirements-unmet": "requirements_unmet",
+	"model-invocation-disabled": "model_invocation_disabled",
+	"tool-gated": "tool_gated"
+};
+function withReturnPath(path) {
+	return `${path}${path.includes("?") ? "&" : "?"}returnTo=${encodeURIComponent("/")}`;
+}
+var HomeCapabilityPreflightService = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	inventory() {
+		const config = this.deps.config();
+		const agentId = this.deps.agentId();
+		const connectorRequirements = listConnectorInstances(config).map((instance) => ({
+			kind: "connector",
+			capability: instance.connectorId,
+			required: true
+		}));
+		const connectorResolution = this.resolve(connectorRequirements);
+		return {
+			agentId,
+			connectors: new Set(connectorResolution.capabilities.filter((capability) => capability.kind === "connector" && capability.readiness === "ready").map((capability) => capability.capability)),
+			skills: new Set(this.deps.skills(agentId).filter((skill) => skill.availableForCurrentAgent).map((skill) => skill.name))
+		};
+	}
+	resolve(requirements, options = {}) {
+		const agentId = this.deps.agentId();
+		const skills = requirements.some((item) => item.kind === "skill") ? this.deps.skills(agentId) : [];
+		const connectorResult = preflightConnectorRequirements({
+			requirements: requirements.filter((item) => item.kind === "connector").map((item) => ({
+				connectorId: item.capability,
+				scope: "read",
+				optional: !item.required
+			})),
+			config: this.deps.config(),
+			agentId,
+			principalId: this.deps.principalId
+		});
+		const connectorIssues = new Map([...connectorResult.issues, ...connectorResult.optionalIssues].map((issue) => [issue.connectorId, issue]));
+		const blockers = [];
+		const capabilities = requirements.map((requirement) => {
+			if (requirement.kind === "agent") return {
+				...requirement,
+				resolvedId: agentId,
+				readiness: "ready"
+			};
+			if (requirement.kind === "connector") {
+				const issue = connectorIssues.get(requirement.capability);
+				if (!issue) return {
+					...requirement,
+					resolvedId: requirement.capability,
+					readiness: "ready"
+				};
+				const blocker = {
+					kind: "connector",
+					capability: requirement.capability,
+					code: issue.code,
+					message: issue.message,
+					recoveryPath: withReturnPath(issue.recoveryPath)
+				};
+				if (requirement.required) blockers.push(blocker);
+				return {
+					...requirement,
+					readiness: "needs_setup",
+					recoveryPath: blocker.recoveryPath,
+					reason: blocker.message
+				};
+			}
+			const skill = skills.find((item) => item.name.toLocaleLowerCase() === requirement.capability.toLocaleLowerCase());
+			if (skill?.availableForCurrentAgent) return {
+				...requirement,
+				resolvedId: skill.name,
+				readiness: "ready"
+			};
+			const code = skill?.unavailableReason ? SKILL_CODE[skill.unavailableReason] : "not_installed";
+			const recoveryTab = code === "not_installed" ? "marketplace" : "installed";
+			const blocker = {
+				kind: "skill",
+				capability: requirement.capability,
+				code,
+				message: skill ? `${skill.name} is unavailable: ${skill.unavailableReason}.` : `${requirement.capability} is not installed.`,
+				recoveryPath: withReturnPath(`/skills?tab=${recoveryTab}&q=${encodeURIComponent(requirement.capability)}`)
+			};
+			if (requirement.required) blockers.push(blocker);
+			return {
+				...requirement,
+				readiness: "needs_setup",
+				recoveryPath: blocker.recoveryPath,
+				reason: blocker.message
+			};
+		});
+		if (!blockers.length) return {
+			capabilities,
+			preflight: { state: "ready" }
+		};
+		return {
+			capabilities,
+			preflight: {
+				state: "needs_setup",
+				blockers,
+				recoveryActions: [...new Map(blockers.map((blocker) => [blocker.capability, {
+					capability: blocker.capability,
+					href: blocker.recoveryPath
+				}])).values()],
+				...options.degradedActionAvailable ? { degradedAction: { mode: "degraded_start" } } : {}
+			}
+		};
+	}
+};
+//#endregion
+export { HomeCapabilityPreflightService };

package/dist/src/home-intelligence/evaluation.d.ts

@@ -0,0 +1,34 @@
+import type { HomeOpportunity } from '@xopcai/gateway-contract';
+import type { HomeCapabilityRequirement, HomeCapabilityResolution } from './capability-preflight.js';
+import type { HomeModelResult } from './generator.js';
+import type { HomeContextSnapshot } from './snapshot.js';
+import type { HomeAdvicePersonalization } from './strategy.js';
+export interface HomeAdviceReplayCase {
+    id: string;
+    snapshot: HomeContextSnapshot;
+    model: HomeModelResult;
+    expected: {
+        state: 'quiet' | 'clarification' | 'ready';
+        acceptedKinds?: HomeOpportunity['kind'][];
+    };
+    suppressedKeys?: ReadonlySet<string>;
+    successfulCounts?: ReadonlyMap<string, number>;
+    personalization?: HomeAdvicePersonalization;
+}
+export interface HomeAdviceReplayReport {
+    total: number;
+    passed: number;
+    failures: Array<{
+        id: string;
+        reasons: string[];
+    }>;
+    hardGates: {
+        expectedOutcomesMatch: boolean;
+        evidenceReferencesValid: boolean;
+        capabilityClaimsValid: boolean;
+        externalWritesRequireConfirmation: boolean;
+    };
+}
+export declare function evaluateHomeAdviceReplay(cases: readonly HomeAdviceReplayCase[], resolveCapabilities: (requirements: readonly HomeCapabilityRequirement[], options?: {
+    degradedActionAvailable?: boolean;
+}) => HomeCapabilityResolution): HomeAdviceReplayReport;

package/dist/src/home-intelligence/evaluation.js

@@ -0,0 +1,49 @@
+import { HomeAdvicePolicy } from "./policy.js";
+//#region src/home-intelligence/evaluation.ts
+function evaluateHomeAdviceReplay(cases, resolveCapabilities) {
+	let evidenceReferencesValid = true;
+	let capabilityClaimsValid = true;
+	let externalWritesRequireConfirmation = true;
+	const failures = [];
+	for (const fixture of cases) {
+		const result = new HomeAdvicePolicy(resolveCapabilities, fixture.suppressedKeys, fixture.successfulCounts, fixture.personalization).apply(fixture.snapshot, fixture.model, fixture.snapshot.generatedAt);
+		const reasons = [];
+		if (result.state !== fixture.expected.state) reasons.push(`expected state ${fixture.expected.state}, received ${result.state}`);
+		if (result.state === "ready") {
+			const acceptedKinds = result.opportunities.map((item) => item.kind);
+			if (fixture.expected.acceptedKinds && JSON.stringify(acceptedKinds) !== JSON.stringify(fixture.expected.acceptedKinds)) reasons.push(`expected kinds ${fixture.expected.acceptedKinds.join(",")}, received ${acceptedKinds.join(",")}`);
+			const evidenceIds = new Set(fixture.snapshot.evidence.map((item) => item.id));
+			for (const opportunity of result.opportunities) {
+				if (opportunity.evidence.some((item) => !evidenceIds.has(item.id) || item.freshUntil <= fixture.snapshot.generatedAt)) {
+					evidenceReferencesValid = false;
+					reasons.push("accepted opportunity contains unknown or expired evidence");
+				}
+				if (opportunity.capabilities.some((item) => item.readiness === "ready" && !item.resolvedId)) {
+					capabilityClaimsValid = false;
+					reasons.push("ready capability has no resolved id");
+				}
+				if (opportunity.risk === "external_write" && opportunity.actions.canStart) {
+					externalWritesRequireConfirmation = false;
+					reasons.push("external write can start without confirmation");
+				}
+			}
+		}
+		if (reasons.length > 0) failures.push({
+			id: fixture.id,
+			reasons
+		});
+	}
+	return {
+		total: cases.length,
+		passed: cases.length - failures.length,
+		failures,
+		hardGates: {
+			expectedOutcomesMatch: failures.every((failure) => failure.reasons.every((reason) => !reason.startsWith("expected state") && !reason.startsWith("expected kinds"))),
+			evidenceReferencesValid,
+			capabilityClaimsValid,
+			externalWritesRequireConfirmation
+		}
+	};
+}
+//#endregion
+export { evaluateHomeAdviceReplay };