@xopcai/xopc 0.0.382 → 0.0.383

package/dist/src/agent/tools/tts-tool.js

@@ -1,8 +1,8 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { speak } from "../../voice/tts/speak-core.js";
 import { mergeTtsConfigFromAppConfig } from "../../voice/tts/merge-config.js";
 import { getChannelOutputFormat } from "../../voice/tts/service.js";
+import { speak } from "../../voice/tts/speak-core.js";
 import { compressAudio } from "../../voice/tts/audio.js";
 import { persistOutboundTtsAudio } from "../../channels/attachments/outbound-tts-persist.js";
 import { Type } from "@sinclair/typebox";

package/dist/src/agent/tools/user-context-tool.js

@@ -1,8 +1,8 @@
 import { deleteUserAssertion, getAssertionSlot, getUserAssertion, listUserAssertionSources, listUserAssertions, reconcileAssertion, setAssertionStatus } from "../../user-model/repository.js";
 import { canUseAssertion } from "../../user-model/usage-policy.js";
 import "../../user-model/index.js";
-import "./local-read-budget.js";
 import { retrievalLexicalSimilarity } from "../../retrieval/textFeatures.js";
+import "./local-read-budget.js";
 import { Type } from "@sinclair/typebox";
 //#region src/agent/tools/user-context-tool.ts
 const SearchSchema = Type.Object({

package/dist/src/agent/tools/write.js

@@ -1,9 +1,9 @@
 import { appendProductDeliveryText } from "../../../packages/gateway-contract/src/product-delivery.js";
 import { init_src } from "../../../packages/gateway-contract/src/index.js";
+import { fileResourceId, fileSpaceId } from "../../files/file-service.js";
+import { isBareProfileMarkdownFileName, resolvePathUnderWorkspace, resolveProfileMarkdownPathIfBareName } from "./tool-paths.js";
 import { writeWorkspaceFile } from "../sandbox/fileAccess.js";
 import { checkFileSafety } from "../prompt/safety.js";
-import { isBareProfileMarkdownFileName, resolvePathUnderWorkspace, resolveProfileMarkdownPathIfBareName } from "./tool-paths.js";
-import { fileResourceId, fileSpaceId } from "../../files/file-service.js";
 import { basename, relative, sep } from "path";
 import { realpath } from "fs/promises";
 import { Type } from "@sinclair/typebox";

package/dist/src/agent/tools/xopc-use-tool.d.ts

@@ -8,6 +8,7 @@ import type { NotesService } from '../../notes/index.js';
 import { type ProjectService } from '../../projects/index.js';
 import type { LocalAppService } from '../../local-apps/index.js';
 import type { ChatPreviewService } from '../../chat-previews/index.js';
+import { TaskApplicationService } from '../../tasks/task-application-service.js';
 declare const XopcUseToolSchema: import("@sinclair/typebox").TObject<{
     mode: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"context">, import("@sinclair/typebox").TLiteral<"scene">, import("@sinclair/typebox").TLiteral<"project">, import("@sinclair/typebox").TLiteral<"automation">, import("@sinclair/typebox").TLiteral<"note">, import("@sinclair/typebox").TLiteral<"task">, import("@sinclair/typebox").TLiteral<"task_run">, import("@sinclair/typebox").TLiteral<"local_app">, import("@sinclair/typebox").TLiteral<"chat_preview">, import("@sinclair/typebox").TLiteral<"agent">, import("@sinclair/typebox").TLiteral<"settings">]>;
     command: import("@sinclair/typebox").TString;
@@ -35,6 +36,7 @@ export interface XopcUseToolDeps {
     getLocalAppService?: () => LocalAppService | undefined;
     getChatPreviewService?: () => ChatPreviewService | undefined;
     dispatchTaskEvents?: () => void;
+    createTask?: TaskApplicationService['create'];
     dispatchTaskRuns?: () => void;
     onAgentCatalogMutate?: () => void;
 }

package/dist/src/agent/tools/xopc-use-tool.js

@@ -12,22 +12,22 @@ import { init_sqlite } from "../../storage/sqlite/index.js";
 import "../../activity/index.js";
 import { CapabilityError } from "../../capabilities/runtime/errors.js";
 import "../../capabilities/runtime/dispatcher.js";
-import { getDefaultAgentId, init_resolve_route } from "../../routing/resolve-route.js";
-import { TaskConversationRepository } from "../../tasks/task-conversation-repository.js";
 import { resolveTaskLocale } from "../../tasks/task-language.js";
+import { TaskCollaborationRepository } from "../../tasks/task-collaboration-repository.js";
+import { TaskConversationRepository } from "../../tasks/task-conversation-repository.js";
+import { TaskApplicationService } from "../../tasks/task-application-service.js";
+import { getDefaultAgentId, init_resolve_route } from "../../routing/resolve-route.js";
+import { defineTaskContract } from "../../tasks/task-contract-definition.js";
 import { resolveProjectAgentId } from "../../projects/project-agent.js";
 import "../../projects/index.js";
+import { TaskOriginRepository } from "../../tasks/task-origin-repository.js";
 import { resolveResponseLanguageForSession } from "../prompt/response-language.js";
 import { TaskDeletionService } from "../../tasks/task-deletion-service.js";
 import { TaskDeleteOutputSchema } from "../../tasks/capabilities/management.js";
-import { TaskCollaborationRepository } from "../../tasks/task-collaboration-repository.js";
-import { TaskApplicationService } from "../../tasks/task-application-service.js";
 import { AutomationCreateCapabilityInputSchema, AutomationUpdatePatchSchema } from "../../automations/capabilities/write.js";
 import { TaskMutationOutputSchema } from "../../tasks/capabilities/write.js";
 import { createProductDispatcher } from "../../capabilities/runtime/product.js";
 import { localAppCapabilities } from "../../local-apps/capabilities/runtime.js";
-import { defineTaskContract } from "../../tasks/task-contract-definition.js";
-import { TaskOriginRepository } from "../../tasks/task-origin-repository.js";
 import "../../tasks/index.js";
 import { randomUUID } from "node:crypto";
 import { Type } from "@sinclair/typebox";
@@ -1883,6 +1883,7 @@ async function handleChatPreview(command, args, deps, dryRun) {
 }
 function createXopcUseTool(deps) {
 	const capabilities = createProductDispatcher(deps.getNotesService, {
+		createTask: deps.createTask,
 		getConfig: deps.getConfig,
 		getProjects: deps.getProjectService,
 		getWorkDiscovery: deps.getWorkDiscovery,

package/dist/src/agent/transcript/index.js

@@ -1,7 +1,7 @@
-import { resolveTranscriptPolicy } from "./transcript-policy.js";
-import { dropThinkingBlocks } from "./thinking.js";
 import { extractToolCallsFromAssistant, extractToolResultId, sanitizeToolCallId, sanitizeToolCallIdsForCloudCodeAssist } from "./tool-call-id.js";
 import { makeMissingToolResult, repairToolUseResultPairing, sanitizeToolCallInputs, sanitizeToolUseResultPairing, stripToolResultDetails } from "./session-transcript-repair.js";
+import { resolveTranscriptPolicy } from "./transcript-policy.js";
+import { dropThinkingBlocks } from "./thinking.js";
 import { applySessionTranscriptHygiene, applySessionTranscriptHygieneForPersistence, applySessionTranscriptHygieneWithPolicy, resolvePolicyForModel, tryApplySessionTranscriptHygiene, tryApplySessionTranscriptHygieneForPersistence } from "./transcript-hygiene.js";
 import { stripToolMessages } from "./strip-tool-messages.js";
 export { applySessionTranscriptHygiene, applySessionTranscriptHygieneForPersistence, applySessionTranscriptHygieneWithPolicy, dropThinkingBlocks, extractToolCallsFromAssistant, extractToolResultId, makeMissingToolResult, repairToolUseResultPairing, resolvePolicyForModel, resolveTranscriptPolicy, sanitizeToolCallId, sanitizeToolCallIdsForCloudCodeAssist, sanitizeToolCallInputs, sanitizeToolUseResultPairing, stripToolMessages, stripToolResultDetails, tryApplySessionTranscriptHygiene, tryApplySessionTranscriptHygieneForPersistence };

package/dist/src/agent/transcript/transcript-hygiene.js

@@ -1,9 +1,9 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { resolveTranscriptPolicy } from "./transcript-policy.js";
-import { dropThinkingBlocks } from "./thinking.js";
 import { sanitizeToolCallIdsForCloudCodeAssist } from "./tool-call-id.js";
 import { sanitizeToolCallInputs, sanitizeToolUseResultPairing, stripToolResultDetails } from "./session-transcript-repair.js";
+import { resolveTranscriptPolicy } from "./transcript-policy.js";
+import { dropThinkingBlocks } from "./thinking.js";
 //#region src/agent/transcript/transcript-hygiene.ts
 init_logger();
 const log = createLogger("transcript-hygiene");

package/dist/src/agent/workflow/subagent-runner.js

@@ -1,11 +1,11 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { createSqliteTranscriptRuntime } from "../embedded/transcript-runtime.js";
+import { STRUCTURED_OUTPUT_TOOL_NAME, createStructuredOutputTool } from "./structured-output-tool.js";
 import { createDelegateChildHandle } from "../child-agent-factory.js";
 import { DELEGATION_TOOL_CAPABILITIES, protectDelegatedTool, resolveDelegationTools } from "../tools/delegation-policy.js";
 import { DELEGATE_BLOCKED_TOOLS } from "../tools/delegate-tool.js";
 import { createDelegationParentPolicy } from "../tools/delegation-parent-policy.js";
-import { STRUCTURED_OUTPUT_TOOL_NAME, createStructuredOutputTool } from "./structured-output-tool.js";
 //#region src/agent/workflow/subagent-runner.ts
 init_logger();
 const log = createLogger("Agent:WorkflowSubagent");

package/dist/src/agent-config/resolver.js

@@ -95,6 +95,7 @@ function resolveEffectiveAgentConfig(params) {
 	const workspace = agent.workspace ?? params.defaultWorkspace?.(agent.id) ?? `~/.xopc/workspace/${agent.id}`;
 	sources.workspace = agent.workspace ? "agent" : "system";
 	if (agent.profile) markObjectSources(agent.profile, "agent", "profile", sources);
+	if (agent.specialistProfile) markObjectSources(agent.specialistProfile, "agent", "specialistProfile", sources);
 	if (agent.toolAllowlist) sources.toolAllowlist = "agent";
 	return {
 		config: EffectiveAgentConfigSchema.parse({
@@ -102,6 +103,7 @@ function resolveEffectiveAgentConfig(params) {
 			enabled: agent.enabled,
 			workspace,
 			...agent.profile ? { profile: structuredClone(agent.profile) } : {},
+			...agent.specialistProfile ? { specialistProfile: structuredClone(agent.specialistProfile) } : {},
 			models,
 			skills,
 			tools,

package/dist/src/agent-config/schema.d.ts

@@ -2,8 +2,8 @@ import { z } from 'zod';
 export declare const DEFAULT_AGENT_MODEL_REF = "xopc-cloud/auto";
 export declare const DEFAULT_CORE_SKILLS: readonly ["doc-coauthoring", "define-task", "find-skills", "summarize"];
 export declare const DEFAULT_SKILL_POLICY: {
-    mode: "selected";
-    include: ("doc-coauthoring" | "define-task" | "find-skills" | "summarize")[];
+    mode: "all-enabled";
+    exclude: any[];
 };
 export declare const AgentIdSchema: z.ZodString;
 export declare const ModelRefSchema: z.ZodString;
@@ -402,6 +402,19 @@ export declare const AgentEntrySchema: z.ZodObject<{
         }, z.core.$strict>>;
         instructions: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
+    specialistProfile: z.ZodOptional<z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        domains: z.ZodArray<z.ZodString>;
+        taskTypes: z.ZodArray<z.ZodString>;
+        inputKinds: z.ZodArray<z.ZodString>;
+        outputKinds: z.ZodArray<z.ZodString>;
+        specialties: z.ZodArray<z.ZodString>;
+        examples: z.ZodArray<z.ZodObject<{
+            request: z.ZodString;
+            deliverable: z.ZodString;
+        }, z.core.$strict>>;
+        limitations: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
     models: z.ZodOptional<z.ZodObject<{
         chat: z.ZodOptional<z.ZodObject<{
             primary: z.ZodString;
@@ -551,6 +564,19 @@ export declare const EffectiveAgentConfigSchema: z.ZodObject<{
         }, z.core.$strict>>;
         instructions: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
+    specialistProfile: z.ZodOptional<z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        domains: z.ZodArray<z.ZodString>;
+        taskTypes: z.ZodArray<z.ZodString>;
+        inputKinds: z.ZodArray<z.ZodString>;
+        outputKinds: z.ZodArray<z.ZodString>;
+        specialties: z.ZodArray<z.ZodString>;
+        examples: z.ZodArray<z.ZodObject<{
+            request: z.ZodString;
+            deliverable: z.ZodString;
+        }, z.core.$strict>>;
+        limitations: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
     models: z.ZodObject<{
         chat: z.ZodObject<{
             primary: z.ZodString;

package/dist/src/agent-config/schema.js

@@ -1,8 +1,11 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { SpecialistProfileSchema } from "../../packages/gateway-contract/src/specialists.js";
+import { init_src } from "../../packages/gateway-contract/src/index.js";
 import { z } from "zod";
 //#region src/agent-config/schema.ts
 var DEFAULT_AGENT_MODEL_REF, DEFAULT_CORE_SKILLS, DEFAULT_SKILL_POLICY, AgentIdSchema, ModelRefSchema, ModelRouteSchema, ImageGenerationRouteSchema, ComputerModelRouteSchema, ModelIntentSchema, ModelIntentRoutesSchema, ModelIntentOverridesSchema, AgentModelsDefaultsSchema, AgentModelsOverrideSchema, ToolModeSchema, ToolPolicySchema, ToolPoliciesSchema, SkillDefaultsSchema, SkillOverrideSchema, WorkflowPolicySchema, RuntimePolicySchema, AgentDefaultsSchema, ResponsePreferencesSchema, AgentProfileSchema, AgentEntrySchema, EffectiveAgentConfigSchema;
 var init_schema = __esmMin((() => {
+	init_src();
 	DEFAULT_AGENT_MODEL_REF = "xopc-cloud/auto";
 	DEFAULT_CORE_SKILLS = [
 		"doc-coauthoring",
@@ -11,8 +14,8 @@ var init_schema = __esmMin((() => {
 		"summarize"
 	];
 	DEFAULT_SKILL_POLICY = {
-		mode: "selected",
-		include: [...DEFAULT_CORE_SKILLS]
+		mode: "all-enabled",
+		exclude: []
 	};
 	AgentIdSchema = z.string().regex(/^[a-z][a-z0-9_-]{0,63}$/);
 	ModelRefSchema = z.string().trim().min(1).refine((value) => {
@@ -181,6 +184,7 @@ var init_schema = __esmMin((() => {
 		enabled: z.boolean().default(true),
 		workspace: z.string().trim().min(1).optional(),
 		profile: AgentProfileSchema.optional(),
+		specialistProfile: SpecialistProfileSchema.optional(),
 		models: AgentModelsOverrideSchema.optional(),
 		skills: SkillOverrideSchema.optional(),
 		tools: ToolPoliciesSchema.optional(),
@@ -193,6 +197,7 @@ var init_schema = __esmMin((() => {
 		enabled: z.boolean(),
 		workspace: z.string().min(1),
 		profile: AgentProfileSchema.optional(),
+		specialistProfile: SpecialistProfileSchema.optional(),
 		models: AgentModelsDefaultsSchema,
 		skills: SkillDefaultsSchema,
 		tools: ToolPoliciesSchema,

package/dist/src/agent-matching/delegation-service.d.ts

@@ -0,0 +1,17 @@
+import type { ActorRef, TaskCreateRequest } from '@xopcai/gateway-contract';
+import { type TaskApplicationResult } from '../tasks/task-application-service.js';
+import { type SelectionRecord } from './selection-repository.js';
+import { type MatchingContext, type SpecialistAssessment } from './service.js';
+import type { SpecialistTaskRequirements } from './schema.js';
+export declare function assertSpecialistEligible(assessment: SpecialistAssessment): void;
+/** Runs inside the product capability transaction; no async work or dispatch occurs here. */
+export declare function createSelectedTask(input: TaskCreateRequest, actor: ActorRef | undefined, selection: {
+    conversationId: string;
+    requirements: SpecialistTaskRequirements;
+    context: MatchingContext;
+    candidates?: SelectionRecord['candidates'];
+    requestHash?: string;
+    reason?: string;
+    source: SelectionRecord['selectionSource'];
+    previousSelectionId?: string;
+}): TaskApplicationResult;

package/dist/src/agent-matching/delegation-service.js

@@ -0,0 +1,87 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { afterSqliteCommit, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { TaskRunRepository, init_task_run_repository } from "../tasks/task-run-repository.js";
+import { TaskReadModelProjector } from "../tasks/task-read-model-projector.js";
+import { TaskApplicationService } from "../tasks/task-application-service.js";
+import { AgentSelectionRepository, selectionRequestHash } from "./selection-repository.js";
+import { assessSpecialist } from "./service.js";
+//#region src/agent-matching/delegation-service.ts
+init_logger();
+init_transaction();
+init_task_run_repository();
+const log = createLogger("AgentMatching");
+function assertSpecialistEligible(assessment) {
+	if (assessment.eligibility !== "eligible") {
+		const failures = assessment.checks.filter((check) => check.state === "blocked" || check.state === "unknown");
+		throw new Error(`Specialist Agent is unavailable: ${assessment.id}: ${failures.map((check) => `${check.condition} ${check.detail ?? check.reasonCode}`).join("; ")}`);
+	}
+}
+/** Runs inside the product capability transaction; no async work or dispatch occurs here. */
+function createSelectedTask(input, actor, selection) {
+	return runSqliteWriteTransaction(() => {
+		if (input.originConversationId !== selection.conversationId) throw new Error("Task selection origin mismatch");
+		if (input.activation.mode !== "start" || !input.delegateAgentId || input.activation.executor?.kind !== "agent" || input.activation.executor.agentId !== input.delegateAgentId) throw new Error("Selection must match the Task executor");
+		const repository = new AgentSelectionRepository();
+		const hash = selection.requestHash ?? selectionRequestHash({
+			input,
+			requirements: selection.requirements
+		});
+		const previous = repository.find(selection.conversationId, input.idempotencyKey);
+		if (previous) {
+			if (previous.requestHash !== hash) throw new Error("Idempotency key was reused with different input");
+			if (previous.taskId) {
+				const model = new TaskReadModelProjector().get(previous.taskId);
+				if (!model) throw new Error("Selected Task no longer exists");
+				const run = new TaskRunRepository().getActiveRoot(previous.taskId);
+				if (previous.status === "start_failed") return {
+					ok: false,
+					reason: "invalid_transition",
+					model
+				};
+				return previous.status === "start_blocked" ? {
+					ok: false,
+					reason: "blocked",
+					model
+				} : {
+					ok: true,
+					model,
+					...run ? { runId: run.id } : {}
+				};
+			}
+			throw new Error("Previous selection attempt was rejected; use a new attempt key");
+		}
+		const assessment = assessSpecialist(input.delegateAgentId, selection.requirements, selection.context);
+		assertSpecialistEligible(assessment);
+		const record = repository.create({
+			conversationId: selection.conversationId,
+			key: input.idempotencyKey,
+			requestHash: hash,
+			requirements: selection.requirements,
+			assessment,
+			candidates: selection.candidates,
+			source: selection.source,
+			reason: selection.reason,
+			previousSelectionId: selection.previousSelectionId,
+			status: "task_linked"
+		});
+		const result = new TaskApplicationService().create(input, actor);
+		repository.link(record.id, {
+			taskId: result.model?.task.id,
+			runId: result.ok ? result.runId : void 0,
+			status: result.ok === false ? result.reason === "blocked" ? "start_blocked" : "start_failed" : "task_linked",
+			reasonCode: result.ok === false ? result.reason : void 0
+		});
+		afterSqliteCommit(() => log.info({
+			selectionId: record.id,
+			conversationId: selection.conversationId,
+			agentId: assessment.id,
+			taskId: result.model?.task.id,
+			phase: "delegate",
+			reasonCode: result.ok === false ? result.reason : "task_linked"
+		}, "Specialist selection recorded"));
+		return result;
+	});
+}
+//#endregion
+export { assertSpecialistEligible, createSelectedTask };

package/dist/src/agent-matching/schema.d.ts

@@ -0,0 +1,2 @@
+export { SpecialistProfileSchema, SpecialistTaskRequirementsSchema, normalizeSpecialistRequirements } from '@xopcai/gateway-contract';
+export type { SpecialistProfile, SpecialistTaskRequirements } from '@xopcai/gateway-contract';

package/dist/src/agent-matching/schema.js

@@ -0,0 +1,6 @@
+import { SpecialistProfileSchema, SpecialistTaskRequirementsSchema, normalizeSpecialistRequirements } from "../../packages/gateway-contract/src/specialists.js";
+import { init_src } from "../../packages/gateway-contract/src/index.js";
+//#region src/agent-matching/schema.ts
+init_src();
+//#endregion
+export { SpecialistProfileSchema, SpecialistTaskRequirementsSchema, normalizeSpecialistRequirements };

package/dist/src/agent-matching/selection-repository.d.ts

@@ -0,0 +1,53 @@
+import type { SpecialistAssessment } from './service.js';
+import type { SpecialistTaskRequirements } from './schema.js';
+export type SelectionStatus = 'pending_connection' | 'rejected' | 'task_linked' | 'start_blocked' | 'start_failed';
+export interface SelectionRecord {
+    id: string;
+    conversationId: string;
+    taskId?: string;
+    taskRunId?: string;
+    personalRequestId?: string;
+    decisionGroupId: string;
+    previousSelectionId?: string;
+    idempotencyKey: string;
+    requestHash: string;
+    selectedAgentId: string;
+    requirements: SpecialistTaskRequirements;
+    assessment: SpecialistAssessment;
+    candidates?: Array<Pick<SpecialistAssessment, 'id' | 'revision' | 'eligibility' | 'checks' | 'matched' | 'missing'>>;
+    selectionSource: 'snapshot' | 'match' | 'explicit' | 'legacy';
+    selectionReason: string;
+    reasonSource: 'model' | 'system';
+    status: SelectionStatus;
+    reasonCode?: string;
+    createdAt: number;
+}
+export declare function selectionRequestHash(value: unknown): string;
+export declare class AgentSelectionRepository {
+    find(conversationId: string, key: string): SelectionRecord | undefined;
+    list(conversationId: string, filter?: {
+        taskId?: string;
+        requestId?: string;
+        offset?: number;
+    }): SelectionRecord[];
+    create(input: {
+        conversationId: string;
+        key: string;
+        requestHash: string;
+        requirements: SpecialistTaskRequirements;
+        assessment: SpecialistAssessment;
+        source: SelectionRecord['selectionSource'];
+        reason?: string;
+        reasonSource?: SelectionRecord['reasonSource'];
+        candidates?: SelectionRecord['candidates'];
+        previousSelectionId?: string;
+        requestId?: string;
+        status: SelectionStatus;
+    }): SelectionRecord;
+    link(id: string, result: {
+        taskId?: string;
+        runId?: string;
+        status: SelectionStatus;
+        reasonCode?: string;
+    }): void;
+}

package/dist/src/agent-matching/selection-repository.js

@@ -0,0 +1,83 @@
+import { getSqliteDatabase, init_transaction } from "../storage/sqlite/transaction.js";
+import { init_session_instance_repository, readCurrentTranscriptId } from "../storage/sqlite/session-instance-repository.js";
+import { getSessionInputState, init_session_input_repository } from "../storage/sqlite/session-input-repository.js";
+import { getSessionMetadata } from "../storage/sqlite/session-read-repository.js";
+import { init_sqlite } from "../storage/sqlite/index.js";
+import { createHash, randomUUID } from "node:crypto";
+//#region src/agent-matching/selection-repository.ts
+init_transaction();
+init_sqlite();
+init_session_input_repository();
+init_session_instance_repository();
+function decode(row) {
+	return {
+		id: row.id,
+		conversationId: row.conversation_id,
+		taskId: row.task_id ?? void 0,
+		taskRunId: row.task_run_id ?? void 0,
+		personalRequestId: row.personal_request_id ?? void 0,
+		decisionGroupId: row.decision_group_id,
+		previousSelectionId: row.previous_selection_id ?? void 0,
+		idempotencyKey: row.idempotency_key,
+		requestHash: row.request_hash,
+		selectedAgentId: row.selected_agent_id,
+		requirements: JSON.parse(row.requirements_json),
+		assessment: JSON.parse(row.assessment_json),
+		candidates: row.candidates_json ? JSON.parse(row.candidates_json) : void 0,
+		selectionSource: row.selection_source,
+		selectionReason: row.selection_reason,
+		reasonSource: row.reason_source,
+		status: row.status,
+		reasonCode: row.reason_code ?? void 0,
+		createdAt: row.created_at
+	};
+}
+function selectionRequestHash(value) {
+	const normalize = (input) => Array.isArray(input) ? input.map(normalize) : input && typeof input === "object" ? Object.fromEntries(Object.entries(input).filter(([, v]) => v !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, normalize(item)])) : input;
+	return createHash("sha256").update(JSON.stringify(normalize(value))).digest("hex");
+}
+var AgentSelectionRepository = class {
+	find(conversationId, key) {
+		const row = getSqliteDatabase().prepare("SELECT * FROM agent_selection_records WHERE conversation_id = ? AND idempotency_key = ?").get(conversationId, key);
+		return row && decode(row);
+	}
+	list(conversationId, filter = {}) {
+		const clauses = ["conversation_id = ?"];
+		const args = [conversationId];
+		if (filter.taskId) {
+			clauses.push("task_id = ?");
+			args.push(filter.taskId);
+		}
+		if (filter.requestId) {
+			clauses.push("personal_request_id = ?");
+			args.push(filter.requestId);
+		}
+		return getSqliteDatabase().prepare(`SELECT * FROM agent_selection_records WHERE ${clauses.join(" AND ")}
+      ORDER BY created_at DESC, id DESC LIMIT 20 OFFSET ?`).all(...args, Math.max(0, filter.offset ?? 0)).map(decode);
+	}
+	create(input) {
+		const existing = this.find(input.conversationId, input.key);
+		if (existing) {
+			if (existing.requestHash !== input.requestHash) throw new Error("Idempotency key was reused with different input");
+			return existing;
+		}
+		const db = getSqliteDatabase();
+		if (!getSessionMetadata(input.conversationId)) throw new Error("Selection conversation not found");
+		const previous = input.previousSelectionId ? db.prepare("SELECT * FROM agent_selection_records WHERE id = ? AND conversation_id = ?").get(input.previousSelectionId, input.conversationId) : void 0;
+		if (input.previousSelectionId && !previous) throw new Error("Previous selection does not belong to this conversation");
+		const id = randomUUID();
+		const now = Date.now();
+		db.prepare(`INSERT INTO agent_selection_records(id, conversation_id, transcript_id, input_id,
+      personal_request_id, decision_group_id, previous_selection_id, idempotency_key, request_hash,
+      selected_agent_id, selected_agent_revision, matcher_version, catalog_revision, requirements_json,
+      selected_profile_json, assessment_json, candidates_json, selection_source, reason_source, selection_reason, status, reason_code, created_at, updated_at)
+      VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(id, input.conversationId, readCurrentTranscriptId(db, input.conversationId) ?? null, getSessionInputState(input.conversationId).activeInputId ?? null, input.requestId ?? null, previous?.decision_group_id ?? id, previous?.id ?? null, input.key, input.requestHash, input.assessment.id, input.assessment.revision ?? null, input.assessment.matcherVersion, input.assessment.catalogRevision, JSON.stringify(input.requirements), input.assessment.specialistProfile ? JSON.stringify(input.assessment.specialistProfile) : null, JSON.stringify(input.assessment), input.candidates ? JSON.stringify(input.candidates.slice(0, 10)) : null, input.source, input.reasonSource ?? (input.reason ? "model" : "system"), (input.reason ?? "Legacy delegation; selected Agent revalidated").slice(0, 500), input.status, input.status === "rejected" ? input.assessment.checks.find((check) => check.state === "blocked" || check.state === "unknown")?.reasonCode ?? "unavailable" : null, now, now);
+		return this.find(input.conversationId, input.key);
+	}
+	link(id, result) {
+		getSqliteDatabase().prepare(`UPDATE agent_selection_records SET task_id = COALESCE(?, task_id),
+      task_run_id = COALESCE(?, task_run_id), status = ?, reason_code = ?, updated_at = ? WHERE id = ?`).run(result.taskId ?? null, result.runId ?? null, result.status, result.reasonCode ?? null, Date.now(), id);
+	}
+};
+//#endregion
+export { AgentSelectionRepository, selectionRequestHash };

package/dist/src/agent-matching/service.d.ts

@@ -0,0 +1,85 @@
+import { type EffectiveAgentConfig } from '../agent-config/index.js';
+import type { Config } from '../config/schema.js';
+import { type SpecialistTaskRequirements } from './schema.js';
+export declare const MATCHER_VERSION = 1;
+export type Eligibility = 'eligible' | 'needs_verification' | 'blocked';
+export interface AvailabilityCheck {
+    condition: string;
+    state: 'verified' | 'configured' | 'unknown' | 'blocked';
+    reasonCode: string;
+    detail?: string;
+}
+export interface MatchingContext {
+    ownAgentId: string;
+    getConfig?: () => Config | undefined;
+    getAgentSkillAvailability?: (agentId: string) => {
+        skills: Array<{
+            name: string;
+            availableForCurrentAgent: boolean;
+            unavailableReason?: string | null;
+        }>;
+    };
+    legacyToolPolicyOnly?: boolean;
+    getAgentToolAvailability?: (agentId: string, tool: string) => AvailabilityCheck;
+    checkConnector?: (agentId: string, connector: NonNullable<SpecialistTaskRequirements['connector']>) => AvailabilityCheck;
+}
+export interface SpecialistAssessment {
+    id: string;
+    revision?: number;
+    name: string;
+    description: string;
+    profileSource: 'declared' | 'legacy';
+    specialistProfile?: EffectiveAgentConfig['specialistProfile'];
+    availableTools: string[];
+    model: {
+        available: boolean;
+        reason?: string;
+    };
+    verifiedSkills: string[];
+    eligibility: Eligibility;
+    checks: AvailabilityCheck[];
+    matched: string[];
+    missing: string[];
+    catalogRevision: number;
+    checkedAt: number;
+    matcherVersion: number;
+}
+export declare function assessSpecialist(agentId: string, input: SpecialistTaskRequirements, context: MatchingContext): SpecialistAssessment;
+export declare function matchSpecialists(input: SpecialistTaskRequirements, context: MatchingContext, options?: {
+    cursor?: string;
+    limit?: number;
+}): {
+    nextCursor?: string;
+    matcherVersion: number;
+    catalogRevision: number;
+    checkedAt: number;
+    total: number;
+    candidates: SpecialistAssessment[];
+};
+export declare function listSpecialistSummaries(context: MatchingContext): {
+    nextCursor?: string;
+    matcherVersion: number;
+    catalogRevision: number;
+    checkedAt: number;
+    total: number;
+    candidates: SpecialistAssessment[];
+};
+/** Cheap snapshot projection; configuration is not proof of runtime tool readiness. */
+export declare function summarizeSpecialist(config: EffectiveAgentConfig, context: Pick<MatchingContext, 'getConfig'>): {
+    domains: string[];
+    taskTypes: string[];
+    outputKinds: string[];
+    specialties: string[];
+    id: string;
+    role: string;
+    tools: string[];
+    available: boolean;
+    toolEvidence: string;
+} | {
+    profileSource: string;
+    id: string;
+    role: string;
+    tools: string[];
+    available: boolean;
+    toolEvidence: string;
+};