@xopcai/xopc 0.0.382 → 0.0.384

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

@@ -1,5 +1,6 @@
 import { runWithActivityContext } from "../../activity/context.js";
 import { init_transaction, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { normalizeSpecialistRequirements } from "../../../packages/gateway-contract/src/specialists.js";
 import { TaskCommandSchema, TaskContextInputSchema } from "../../../packages/gateway-contract/src/tasks.js";
 import { ChatPreviewCreateInputSchema, ChatPreviewReviseInputSchema } from "../../../packages/gateway-contract/src/chat-previews.js";
 import { appendProductDeliveryText } from "../../../packages/gateway-contract/src/product-delivery.js";
@@ -13,8 +14,10 @@ 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 { TaskReadModelProjector } from "../../tasks/task-read-model-projector.js";
+import { TaskOriginRepository } from "../../tasks/task-origin-repository.js";
+import { TaskConversationRepository } from "../../tasks/task-conversation-repository.js";
 import { resolveProjectAgentId } from "../../projects/project-agent.js";
 import "../../projects/index.js";
 import { resolveResponseLanguageForSession } from "../prompt/response-language.js";
@@ -27,7 +30,6 @@ 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";
@@ -76,6 +78,7 @@ const TASK_PRIORITIES = new Set([
 	"critical"
 ]);
 const TASK_COMMANDS = new Set([
+	"retry_allocation",
 	"mark_ready",
 	"start",
 	"request_review",
@@ -85,7 +88,11 @@ const TASK_COMMANDS = new Set([
 	"resolve_wait",
 	"revise_contract"
 ]);
-const TASK_CREATE_MODES = new Set(["capture", "start"]);
+const TASK_CREATE_MODES = new Set([
+	"capture",
+	"start",
+	"allocate"
+]);
 function okText(details) {
 	return {
 		content: [{
@@ -1202,7 +1209,7 @@ async function handleTask(command, args, deps, dryRun, capabilities) {
 		};
 		return {
 			ok: true,
-			...new TaskOriginRepository().list(conversationId, finiteNumber(args.limit) ?? 20)
+			...new TaskOriginRepository().list(conversationId, finiteNumber(args.limit) ?? 20, { offset: finiteNumber(args.offset) ?? 0 })
 		};
 	}
 	if (command === "collaboration" || command === "collaboration_post") {
@@ -1379,7 +1386,7 @@ async function handleTask(command, args, deps, dryRun, capabilities) {
 			ok: false,
 			error: "Invalid createMode"
 		};
-		if (createMode === "start" && !deps.dispatchTaskRuns) return {
+		if (createMode !== "capture" && !deps.dispatchTaskRuns) return {
 			ok: false,
 			error: "Task execution service is unavailable"
 		};
@@ -1472,7 +1479,7 @@ async function handleTask(command, args, deps, dryRun, capabilities) {
 			priority: priority ?? "normal",
 			...dueAt === void 0 ? {} : { dueAt },
 			...projectId ? { projectId } : {},
-			delegateAgentId: agentId,
+			...createMode !== "allocate" ? { delegateAgentId: agentId } : {},
 			...originConversationId ? { originConversationId } : {},
 			locale: taskLocale,
 			contract: {
@@ -1490,7 +1497,10 @@ async function handleTask(command, args, deps, dryRun, capabilities) {
 				metadata: {}
 			}] : [],
 			authorityGrants: [],
-			activation: createMode === "capture" ? {
+			activation: createMode === "allocate" ? {
+				mode: "allocate",
+				requirements: normalizeSpecialistRequirements(args.requirements)
+			} : createMode === "capture" ? {
 				mode: "capture",
 				phase: "backlog"
 			} : {
@@ -1530,11 +1540,13 @@ async function handleTask(command, args, deps, dryRun, capabilities) {
 			error: created.reason,
 			...created
 		};
+		const currentModel = createMode === "allocate" ? new TaskReadModelProjector().get(created.model.task.id) ?? created.model : created.model;
 		return {
 			ok: true,
-			task: created.model.task,
-			operationalState: created.model.operationalState,
+			task: currentModel.task,
+			operationalState: currentModel.operationalState,
 			createMode,
+			allocation: currentModel.allocation,
 			...created.runId ? { runId: created.runId } : {}
 		};
 	}
@@ -1883,6 +1895,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-config/resolver.js

@@ -94,7 +94,9 @@ function resolveEffectiveAgentConfig(params) {
 	if (agent.runtime) markObjectSources(agent.runtime, "agent", "runtime", sources);
 	const workspace = agent.workspace ?? params.defaultWorkspace?.(agent.id) ?? `~/.xopc/workspace/${agent.id}`;
 	sources.workspace = agent.workspace ? "agent" : "system";
+	if (agent.purpose) sources.purpose = "agent";
 	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 +104,8 @@ function resolveEffectiveAgentConfig(params) {
 			enabled: agent.enabled,
 			workspace,
 			...agent.profile ? { profile: structuredClone(agent.profile) } : {},
+			...agent.purpose ? { purpose: agent.purpose } : {},
+			...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,23 @@ export declare const AgentEntrySchema: z.ZodObject<{
         }, z.core.$strict>>;
         instructions: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
+    purpose: z.ZodOptional<z.ZodEnum<{
+        specialist: "specialist";
+        task_dispatcher: "task_dispatcher";
+    }>>;
+    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 +568,23 @@ export declare const EffectiveAgentConfigSchema: z.ZodObject<{
         }, z.core.$strict>>;
         instructions: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
+    purpose: z.ZodOptional<z.ZodEnum<{
+        specialist: "specialist";
+        task_dispatcher: "task_dispatcher";
+    }>>;
+    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,8 @@ var init_schema = __esmMin((() => {
 		enabled: z.boolean().default(true),
 		workspace: z.string().trim().min(1).optional(),
 		profile: AgentProfileSchema.optional(),
+		purpose: z.enum(["specialist", "task_dispatcher"]).optional(),
+		specialistProfile: SpecialistProfileSchema.optional(),
 		models: AgentModelsOverrideSchema.optional(),
 		skills: SkillOverrideSchema.optional(),
 		tools: ToolPoliciesSchema.optional(),
@@ -193,6 +198,8 @@ var init_schema = __esmMin((() => {
 		enabled: z.boolean(),
 		workspace: z.string().min(1),
 		profile: AgentProfileSchema.optional(),
+		purpose: z.enum(["specialist", "task_dispatcher"]).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 { assessSpecialist } from "./service.js";
+import { AgentSelectionRepository, selectionRequestHash } from "./selection-repository.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,54 @@
+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;
+        limit?: 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 ? OFFSET ?`).all(...args, Math.min(100, Math.max(1, filter.limit ?? 20)), 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;
+};