@xopcai/xopc 0.0.382 → 0.0.384

package/dist/src/personal-agent/task-cancel.js

@@ -0,0 +1,76 @@
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { TaskRepository, init_task_repository } from "../tasks/task-repository.js";
+import { TaskRunRepository, init_task_run_repository } from "../tasks/task-run-repository.js";
+import { TaskAllocationRepository } from "../tasks/task-allocation-repository.js";
+import { TaskOriginRepository } from "../tasks/task-origin-repository.js";
+import { abortEmbeddedRun } from "../agent/embedded/runs.js";
+import { TaskApplicationService } from "../tasks/task-application-service.js";
+//#region src/personal-agent/task-cancel.ts
+init_transaction();
+init_task_repository();
+init_task_run_repository();
+/** Close before aborting so a late router decision or receipt cannot restart the task. */
+async function cancelPersonalTask(taskId, conversationId, key) {
+	if (!new TaskOriginRepository().owns(taskId, conversationId)) throw new Error("Task does not belong to this personal conversation");
+	const runs = new TaskRunRepository();
+	const { active, changed } = runSqliteWriteTransaction(() => {
+		const task = new TaskRepository().require(taskId);
+		const run = runs.getActiveRoot(taskId);
+		if (task.phase !== "closed") {
+			if (!new TaskApplicationService().execute({
+				taskId,
+				expectedVersion: task.version,
+				idempotencyKey: `personal-cancel:${key}`,
+				command: {
+					type: "close",
+					resolution: "cancelled"
+				},
+				actor: { kind: "user" }
+			}).ok) throw new Error("Task changed while cancelling");
+		} else if (task.resolution !== "cancelled") throw new Error("Task is already closed");
+		getSqliteDatabase().prepare("UPDATE task_allocations SET status = 'cancelled', lease_token = NULL, updated_at = ? WHERE task_id = ? AND status != 'cancelled'").run(Date.now(), taskId);
+		return {
+			active: run,
+			changed: task.phase !== "closed"
+		};
+	});
+	const latest = active ?? runs.getLatestRoot(taskId);
+	let executionStopConfirmed = !latest || !latest.conversationId && !latest.startedAt && ["queued", "cancelled"].includes(latest.status);
+	if (active?.conversationId) {
+		await abortEmbeddedRun(active.conversationId);
+		executionStopConfirmed = false;
+	}
+	const current = active ? runs.get(active.id) : void 0;
+	if (current && runs.getActiveRoot(taskId)?.id === current.id) new TaskApplicationService().completeRun({
+		runId: current.id,
+		expectedRunVersion: current.version,
+		actor: { kind: "user" },
+		terminalCode: "cancelled_by_user",
+		suppressAttention: true,
+		receipt: {
+			status: "cancelled",
+			summary: "Task cancelled",
+			changes: [],
+			evidence: [],
+			verification: {
+				status: "unverified",
+				checks: []
+			},
+			remainingWork: [],
+			needsUser: false,
+			completionVerdict: "not_achieved"
+		}
+	});
+	if (changed && new TaskAllocationRepository().get(taskId)) {
+		const zh = new TaskRepository().require(taskId).locale === "zh";
+		runSqliteWriteTransaction(() => new TaskAllocationRepository().publish(taskId, zh ? "任务已取消。" : "Task cancelled."));
+	}
+	return {
+		ok: true,
+		taskId,
+		status: "cancelled",
+		executionStopConfirmed
+	};
+}
+//#endregion
+export { cancelPersonalTask };

package/dist/src/session/client-history.js

@@ -329,7 +329,7 @@ function customRowToClientHistory(row) {
 	if (r.role !== "custom" && r.type !== "custom_message") return null;
 	const customType = optionalString(r.customType)?.trim();
 	if (!customType) return null;
-	if (customType === "personal_request_status") {
+	if (customType === "personal_request_status" || customType === "task_allocation_status") {
 		const content = typeof r.content === "string" ? r.content : "";
 		return {
 			role: "assistant",

package/dist/src/session/index.js

@@ -1,8 +1,8 @@
 import { buildSessionContextForLlm, init_session_context_for_llm, isTranscriptContextEntry, mergeLlmMessagesPreservingContextRows, transcriptRowsFromJsonArray } from "./session-context-for-llm.js";
 import { SessionStatus, init_types } from "./types.js";
 import { effectiveWorkspacePathForSession, normalizeWorkingDirectoryInput, projectWorkspacePath } from "./session-workspace.js";
-import { flattenMessageContent, messagesToClientHistory } from "./client-history.js";
 import { emitSessionTranscriptUpdate, onSessionTranscriptUpdate } from "./transcript-events.js";
+import { flattenMessageContent, messagesToClientHistory } from "./client-history.js";
 import { fallbackTitleFromMessages, generateSessionTitleFromMessages, getSessionTitleSource, isWebchatConversationId, maybeRefineSessionTitleWithLlm, maybeSetProvisionalSessionTitle, provisionalTitleFromUserText, sanitizeGeneratedSessionTitle, sanitizeSessionTitle, shouldAutoTitleConversationId, shouldRefineSessionTitleWithLlm } from "./session-title.js";
 import { SessionStore } from "./store.js";
 import { applySessionPatchToMetadata } from "./patch-metadata.js";

package/dist/src/storage/sqlite/migrations/247_agent_selection_records.sql

@@ -0,0 +1,32 @@
+CREATE TABLE agent_selection_records (
+  id TEXT PRIMARY KEY,
+  conversation_id TEXT NOT NULL REFERENCES sessions(conversation_id) ON DELETE CASCADE,
+  transcript_id TEXT,
+  input_id TEXT,
+  personal_request_id TEXT REFERENCES personal_requests(request_id) ON DELETE CASCADE,
+  task_id TEXT REFERENCES tasks(task_id) ON DELETE CASCADE,
+  task_run_id TEXT REFERENCES task_runs(run_id) ON DELETE SET NULL,
+  decision_group_id TEXT NOT NULL,
+  previous_selection_id TEXT REFERENCES agent_selection_records(id) ON DELETE SET NULL,
+  idempotency_key TEXT NOT NULL,
+  request_hash TEXT NOT NULL,
+  selected_agent_id TEXT NOT NULL,
+  selected_agent_revision INTEGER,
+  matcher_version INTEGER NOT NULL,
+  catalog_revision INTEGER NOT NULL,
+  requirements_json TEXT NOT NULL,
+  selected_profile_json TEXT,
+  assessment_json TEXT NOT NULL,
+  candidates_json TEXT,
+  selection_source TEXT NOT NULL CHECK(selection_source IN ('snapshot','match','explicit','legacy')),
+  reason_source TEXT NOT NULL CHECK(reason_source IN ('model','system')),
+  selection_reason TEXT NOT NULL,
+  status TEXT NOT NULL CHECK(status IN ('pending_connection','rejected','task_linked','start_blocked','start_failed')),
+  reason_code TEXT,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  UNIQUE(conversation_id, idempotency_key)
+);
+CREATE INDEX agent_selection_task ON agent_selection_records(task_id, created_at);
+CREATE INDEX agent_selection_request ON agent_selection_records(personal_request_id);
+CREATE INDEX agent_selection_origin ON agent_selection_records(conversation_id, created_at);

package/dist/src/storage/sqlite/migrations/248_next_turn_suggestions.sql

@@ -0,0 +1,20 @@
+CREATE TABLE next_turn_suggestions (
+  conversation_id TEXT NOT NULL REFERENCES sessions(conversation_id) ON DELETE CASCADE,
+  locale TEXT NOT NULL CHECK (locale IN ('zh', 'en')),
+  suggestion_id TEXT NOT NULL UNIQUE,
+  snapshot_key TEXT NOT NULL,
+  state TEXT NOT NULL CHECK (state IN ('ready', 'none')),
+  payload_json TEXT,
+  expires_at INTEGER NOT NULL,
+  PRIMARY KEY (conversation_id, locale)
+);
+CREATE TABLE next_turn_suggestion_feedback (
+  conversation_id TEXT NOT NULL REFERENCES sessions(conversation_id) ON DELETE CASCADE,
+  suggestion_id TEXT NOT NULL,
+  impression_id TEXT NOT NULL,
+  event TEXT NOT NULL CHECK (event IN ('shown', 'accepted', 'dismissed', 'submitted')),
+  edited INTEGER NOT NULL DEFAULT 0,
+  created_at INTEGER NOT NULL,
+  PRIMARY KEY (suggestion_id, impression_id, event)
+);
+CREATE INDEX idx_next_turn_feedback_created ON next_turn_suggestion_feedback(created_at);

package/dist/src/storage/sqlite/migrations/249_task_allocations.sql

@@ -0,0 +1,17 @@
+CREATE TABLE task_allocations (
+  id TEXT PRIMARY KEY,
+  task_id TEXT NOT NULL UNIQUE REFERENCES tasks(task_id) ON DELETE CASCADE,
+  origin_conversation_id TEXT NOT NULL REFERENCES sessions(conversation_id) ON DELETE CASCADE,
+  requirements_json TEXT NOT NULL,
+  task_version INTEGER NOT NULL,
+  status TEXT NOT NULL CHECK(status IN ('pending','selecting','assigned','blocked','failed','cancelled')),
+  selected_agent_id TEXT,
+  selection_reason TEXT,
+  reason_code TEXT,
+  attempts INTEGER NOT NULL DEFAULT 0,
+  lease_token TEXT,
+  lease_expires_at INTEGER,
+  next_attempt_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+CREATE INDEX task_allocations_pending ON task_allocations(status, next_attempt_at, lease_expires_at);

package/dist/src/storage/sqlite/migrations/runner.d.ts

@@ -3,7 +3,7 @@ import type { ApplyMigrationsOptions } from './types.js';
 /** Baseline schema version applied from schema.sql on first open. */
 export declare const XOPC_DB_BASELINE_SCHEMA_VERSION = 165;
 /** Latest schema version this release supports (increment when adding migrations). */
-export declare const XOPC_DB_SCHEMA_VERSION = 246;
+export declare const XOPC_DB_SCHEMA_VERSION = 249;
 export declare function resolveMigrationsDir(override?: string): string;
 /**
  * Apply sequential SQL migrations from (currentVersion + 1) through targetVersion.

package/dist/src/storage/sqlite/migrations/runner.js

@@ -59,7 +59,7 @@ function applySingleMigration(db, migration, discardOldScenes = false) {
 function applyPendingMigrations(db, options = {}) {
 	db.function("xopc_memory_search_text", { deterministic: true }, (value) => memorySearchText(String(value ?? "")));
 	db.function("xopc_operation_id", () => currentOperationId() ?? null);
-	const targetVersion = options.targetVersion ?? 246;
+	const targetVersion = options.targetVersion ?? 249;
 	let currentVersion = readSchemaVersion(db);
 	if (currentVersion > targetVersion) throw new DatabaseSchemaTooNewError(currentVersion, targetVersion);
 	if (!options.migrationsDir && currentVersion < 165) throw new DatabaseSchemaTooOldError(currentVersion, 165);
@@ -97,7 +97,7 @@ function applyPendingMigrations(db, options = {}) {
 }
 /** Inspect schema version without mutating the database. */
 function inspectSchemaMigrationStatus(db, options = {}) {
-	const appVersion = options.targetVersion ?? 246;
+	const appVersion = options.targetVersion ?? 249;
 	const dbVersion = readSchemaVersion(db);
 	if (dbVersion > appVersion) return {
 		dbVersion,
@@ -140,7 +140,7 @@ var init_runner = __esmMin((() => {
 	init_errors();
 	log = createLogger("Sqlite:Migrations");
 	XOPC_DB_BASELINE_SCHEMA_VERSION = 165;
-	XOPC_DB_SCHEMA_VERSION = 246;
+	XOPC_DB_SCHEMA_VERSION = 249;
 }));
 //#endregion
 init_runner();

package/dist/src/storage/sqlite/next-turn-suggestion-repository.d.ts

@@ -0,0 +1,4 @@
+import type { NextTurnSuggestion, NextTurnSuggestionFeedback, NextTurnSuggestionResponse } from '@xopcai/gateway-contract';
+export declare function readNextTurnSuggestion(conversationId: string, locale: string, snapshotKey: string, now?: number): NextTurnSuggestionResponse | undefined;
+export declare function saveNextTurnSuggestion(conversationId: string, locale: string, snapshotKey: string, id: string, expiresAt: number, suggestion: NextTurnSuggestion | null): void;
+export declare function recordNextTurnSuggestionFeedback(conversationId: string, feedback: NextTurnSuggestionFeedback): boolean;

package/dist/src/storage/sqlite/next-turn-suggestion-repository.js

@@ -0,0 +1,30 @@
+import { getSqliteDatabase, init_transaction } from "./transaction.js";
+//#region src/storage/sqlite/next-turn-suggestion-repository.ts
+init_transaction();
+function readNextTurnSuggestion(conversationId, locale, snapshotKey, now = Date.now()) {
+	const row = getSqliteDatabase().prepare(`SELECT state, payload_json FROM next_turn_suggestions
+    WHERE conversation_id = ? AND locale = ? AND snapshot_key = ? AND expires_at > ?`).get(conversationId, locale, snapshotKey, now);
+	return row ? {
+		status: row.state,
+		...row.payload_json ? { suggestion: JSON.parse(row.payload_json) } : {}
+	} : void 0;
+}
+function saveNextTurnSuggestion(conversationId, locale, snapshotKey, id, expiresAt, suggestion) {
+	getSqliteDatabase().prepare(`INSERT INTO next_turn_suggestions
+    (conversation_id, locale, snapshot_key, suggestion_id, state, payload_json, expires_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT(conversation_id, locale) DO UPDATE SET
+    snapshot_key = excluded.snapshot_key, suggestion_id = excluded.suggestion_id, state = excluded.state,
+    payload_json = excluded.payload_json, expires_at = excluded.expires_at`).run(conversationId, locale, snapshotKey, id, suggestion ? "ready" : "none", suggestion ? JSON.stringify(suggestion) : null, expiresAt);
+	getSqliteDatabase().prepare("DELETE FROM next_turn_suggestions WHERE expires_at <= ?").run(Date.now());
+	getSqliteDatabase().prepare("DELETE FROM next_turn_suggestion_feedback WHERE created_at < ?").run(Date.now() - 30 * 864e5);
+}
+function recordNextTurnSuggestionFeedback(conversationId, feedback) {
+	const db = getSqliteDatabase();
+	if (!db.prepare(`SELECT 1 FROM next_turn_suggestions WHERE conversation_id = ? AND suggestion_id = ? AND state = 'ready'
+    UNION ALL SELECT 1 FROM next_turn_suggestion_feedback WHERE conversation_id = ? AND suggestion_id = ? AND impression_id = ? AND event = 'accepted' LIMIT 1`).get(conversationId, feedback.suggestionId, conversationId, feedback.suggestionId, feedback.impressionId)) return false;
+	db.prepare(`INSERT OR IGNORE INTO next_turn_suggestion_feedback
+    (conversation_id, suggestion_id, impression_id, event, edited, created_at) VALUES (?, ?, ?, ?, ?, ?)`).run(conversationId, feedback.suggestionId, feedback.impressionId, feedback.event, feedback.edited ? 1 : 0, Date.now());
+	return true;
+}
+//#endregion
+export { readNextTurnSuggestion, recordNextTurnSuggestionFeedback, saveNextTurnSuggestion };

package/dist/src/storage/sqlite/schema.js

@@ -28,7 +28,7 @@ function ensureXopcDatabaseSchema(db, options = {}) {
 		currentVersion = 165;
 	}
 	applyPendingMigrations(db, {
-		targetVersion: 246,
+		targetVersion: 249,
 		databasePath: fresh ? void 0 : options.databasePath
 	});
 }

package/dist/src/tasks/capabilities/read.js

@@ -4,8 +4,8 @@ import { TaskRepository, init_task_repository } from "../task-repository.js";
 import { TaskRunRepository, init_task_run_repository } from "../task-run-repository.js";
 import { CapabilityError } from "../../capabilities/runtime/errors.js";
 import { defineReadCapability } from "../../capabilities/runtime/dispatcher.js";
-import { TaskConversationRepository } from "../task-conversation-repository.js";
 import { TaskReadModelProjector } from "../task-read-model-projector.js";
+import { TaskConversationRepository } from "../task-conversation-repository.js";
 import { TaskContextRepository } from "../task-context-repository.js";
 import { TaskDependencyService } from "../task-dependency-service.js";
 import { TaskCriterionReviewRepository } from "../task-criterion-review-repository.js";

package/dist/src/tasks/capabilities/relations.d.ts

@@ -86,10 +86,28 @@ export declare const TaskDependenciesOutputSchema: z.ZodObject<{
             duplicate: "duplicate";
             wont_do: "wont_do";
         }>>;
+        allocation: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            taskId: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                pending: "pending";
+                cancelled: "cancelled";
+                blocked: "blocked";
+                selecting: "selecting";
+                assigned: "assigned";
+            }>;
+            selectedAgentId: z.ZodOptional<z.ZodString>;
+            selectionReason: z.ZodOptional<z.ZodString>;
+            reasonCode: z.ZodOptional<z.ZodString>;
+            attempts: z.ZodNumber;
+            updatedAt: z.ZodNumber;
+        }, z.core.$strip>>;
         operationalState: z.ZodEnum<{
             failed: "failed";
             waiting: "waiting";
             cancelled: "cancelled";
+            allocating: "allocating";
             idle: "idle";
             queued: "queued";
             running: "running";
@@ -113,10 +131,28 @@ export declare const TaskDependenciesOutputSchema: z.ZodObject<{
             duplicate: "duplicate";
             wont_do: "wont_do";
         }>>;
+        allocation: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            taskId: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                pending: "pending";
+                cancelled: "cancelled";
+                blocked: "blocked";
+                selecting: "selecting";
+                assigned: "assigned";
+            }>;
+            selectedAgentId: z.ZodOptional<z.ZodString>;
+            selectionReason: z.ZodOptional<z.ZodString>;
+            reasonCode: z.ZodOptional<z.ZodString>;
+            attempts: z.ZodNumber;
+            updatedAt: z.ZodNumber;
+        }, z.core.$strip>>;
         operationalState: z.ZodEnum<{
             failed: "failed";
             waiting: "waiting";
             cancelled: "cancelled";
+            allocating: "allocating";
             idle: "idle";
             queued: "queued";
             running: "running";
@@ -147,9 +183,9 @@ export declare const TaskContextMutationOutputSchema: z.ZodObject<{
         role: z.ZodEnum<{
             evidence: "evidence";
             input: "input";
+            deliverable: "deliverable";
             reference: "reference";
             constraint: "constraint";
-            deliverable: "deliverable";
         }>;
         title: z.ZodOptional<z.ZodString>;
         pinned: z.ZodBoolean;
@@ -184,9 +220,9 @@ export declare const TaskContextMutationOutputSchema: z.ZodObject<{
         role: z.ZodEnum<{
             evidence: "evidence";
             input: "input";
+            deliverable: "deliverable";
             reference: "reference";
             constraint: "constraint";
-            deliverable: "deliverable";
         }>;
         title: z.ZodOptional<z.ZodString>;
         pinned: z.ZodBoolean;

package/dist/src/tasks/capabilities/write.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { type CapabilityDispatcher } from '../../capabilities/runtime/dispatcher.js';
+import { TaskApplicationService } from '../task-application-service.js';
 import type { Config } from '../../config/schema.js';
 import type { ProjectService } from '../../projects/index.js';
 export declare const TaskMutationOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -75,6 +76,8 @@ export declare const TaskMutationOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObj
         }, z.core.$strip>;
         attention: z.ZodArray<z.ZodObject<{
             kind: z.ZodEnum<{
+                allocation_blocked: "allocation_blocked";
+                allocation_failed: "allocation_failed";
                 input_required: "input_required";
                 approval_required: "approval_required";
                 dependency_blocked: "dependency_blocked";
@@ -86,10 +89,28 @@ export declare const TaskMutationOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObj
             summary: z.ZodString;
             sourceId: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
+        allocation: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            taskId: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                pending: "pending";
+                cancelled: "cancelled";
+                blocked: "blocked";
+                selecting: "selecting";
+                assigned: "assigned";
+            }>;
+            selectedAgentId: z.ZodOptional<z.ZodString>;
+            selectionReason: z.ZodOptional<z.ZodString>;
+            reasonCode: z.ZodOptional<z.ZodString>;
+            attempts: z.ZodNumber;
+            updatedAt: z.ZodNumber;
+        }, z.core.$strip>>;
         operationalState: z.ZodEnum<{
             failed: "failed";
             waiting: "waiting";
             cancelled: "cancelled";
+            allocating: "allocating";
             idle: "idle";
             queued: "queued";
             running: "running";
@@ -178,6 +199,8 @@ export declare const TaskMutationOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObj
         }, z.core.$strip>;
         attention: z.ZodArray<z.ZodObject<{
             kind: z.ZodEnum<{
+                allocation_blocked: "allocation_blocked";
+                allocation_failed: "allocation_failed";
                 input_required: "input_required";
                 approval_required: "approval_required";
                 dependency_blocked: "dependency_blocked";
@@ -189,10 +212,28 @@ export declare const TaskMutationOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObj
             summary: z.ZodString;
             sourceId: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
+        allocation: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            taskId: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                pending: "pending";
+                cancelled: "cancelled";
+                blocked: "blocked";
+                selecting: "selecting";
+                assigned: "assigned";
+            }>;
+            selectedAgentId: z.ZodOptional<z.ZodString>;
+            selectionReason: z.ZodOptional<z.ZodString>;
+            reasonCode: z.ZodOptional<z.ZodString>;
+            attempts: z.ZodNumber;
+            updatedAt: z.ZodNumber;
+        }, z.core.$strip>>;
         operationalState: z.ZodEnum<{
             failed: "failed";
             waiting: "waiting";
             cancelled: "cancelled";
+            allocating: "allocating";
             idle: "idle";
             queued: "queued";
             running: "running";
@@ -203,6 +244,7 @@ export declare const TaskMutationOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObj
     }, z.core.$strip>>;
 }, z.core.$strip>], "ok">;
 export interface TaskWriteCapabilityDeps {
+    createTask?: TaskApplicationService['create'];
     getConfig?: () => Config | undefined;
     getProjects?: () => ProjectService | undefined;
     wake?: (runs: boolean) => void;

package/dist/src/tasks/capabilities/write.js

@@ -18,7 +18,8 @@ const modelSchema = TaskDetailResponseSchema.pick({
 	task: true,
 	operationalState: true,
 	attention: true,
-	allowedCommands: true
+	allowedCommands: true,
+	allocation: true
 });
 const TaskMutationOutputSchema = z.discriminatedUnion("ok", [z.object({
 	ok: z.literal(true),
@@ -45,7 +46,7 @@ function registerTaskWriteCapabilities(dispatcher, deps) {
 		input: TaskCreateRequestSchema.omit({ idempotencyKey: true }),
 		output: TaskMutationOutputSchema,
 		execute(input, context) {
-			if (input.activation.mode === "start" && !deps.wake) throw new CapabilityError("UNAVAILABLE", "Task execution service is unavailable");
+			if (input.activation.mode !== "capture" && !deps.wake) throw new CapabilityError("UNAVAILABLE", "Task execution service is unavailable");
 			const config = deps.getConfig?.();
 			const projects = deps.getProjects?.();
 			const requestedAgentId = input.delegateAgentId ?? (input.activation.mode === "start" && input.activation.executor?.kind === "agent" ? input.activation.executor.agentId : void 0);
@@ -69,17 +70,18 @@ function registerTaskWriteCapabilities(dispatcher, deps) {
 				title: input.title,
 				contract: input.contract
 			}) : language === "zh-CN" ? "zh" : "en");
-			return new TaskApplicationService().create({
+			const request = {
 				...input,
 				locale,
 				originConversationId,
-				delegateAgentId: agentId,
+				delegateAgentId: input.activation.mode === "allocate" ? void 0 : agentId,
 				activation,
 				idempotencyKey: context.idempotencyKey
-			}, context.actor);
+			};
+			return deps.createTask ? deps.createTask(request, context.actor) : new TaskApplicationService().create(request, context.actor);
 		},
 		afterCommit(result) {
-			if (result.ok) deps.wake?.(Boolean(result.runId));
+			if (result.ok) deps.wake?.(Boolean(result.runId || result.model.allocation));
 		}
 	}));
 	dispatcher.register(defineAtomicCapability({
@@ -110,7 +112,7 @@ function registerTaskWriteCapabilities(dispatcher, deps) {
 				const activeRun = new TaskRunRepository().getActiveRoot(input.taskId);
 				if (activeRun?.conversationId && new TaskRepository().get(input.taskId)?.version === result.model.task.version) await deps.abortConversation?.(activeRun.conversationId);
 			}
-			deps.wake?.(Boolean(result.runId) || command.type === "resolve_wait" || command.type === "close");
+			deps.wake?.(Boolean(result.runId || result.model.allocation) || command.type === "resolve_wait" || command.type === "close");
 		}
 	}));
 }

package/dist/src/tasks/index.js

@@ -1,8 +1,8 @@
 import { enqueueTaskAttentionRequiredEvent, enqueueTaskChanged, enqueueTaskChangedEvent, init_task_change_events } from "./task-change-events.js";
 import { TaskRepository, init_task_repository } from "./task-repository.js";
 import { TaskRunRepository, init_task_run_repository } from "./task-run-repository.js";
-import { TaskConversationConflictError, TaskConversationRepository } from "./task-conversation-repository.js";
 import { TaskReadModelProjector } from "./task-read-model-projector.js";
+import { TaskConversationConflictError, TaskConversationRepository } from "./task-conversation-repository.js";
 import { TaskContextRepository } from "./task-context-repository.js";
 import { TaskDependencyError, TaskDependencyService } from "./task-dependency-service.js";
 import { TaskValueMetricsService } from "./task-value-metrics-service.js";

package/dist/src/tasks/task-allocation-repository.d.ts

@@ -0,0 +1,25 @@
+import type { TaskAllocation, SpecialistTaskRequirements } from '@xopcai/gateway-contract';
+export interface AllocationRow {
+    id: string;
+    task_id: string;
+    origin_conversation_id: string;
+    requirements_json: string;
+    task_version: number;
+    status: TaskAllocation['status'];
+    selected_agent_id: string | null;
+    selection_reason: string | null;
+    reason_code: string | null;
+    attempts: number;
+    lease_token: string | null;
+    lease_expires_at: number | null;
+    next_attempt_at: number;
+    updated_at: number;
+}
+export declare class TaskAllocationRepository {
+    get(taskId: string): AllocationRow | undefined;
+    summary(taskId: string): TaskAllocation | undefined;
+    create(taskId: string, conversationId: string, taskVersion: number, requirements: SpecialistTaskRequirements): void;
+    claim(now?: number): AllocationRow | undefined;
+    owns(row: AllocationRow): boolean;
+    publish(taskId: string, content: string): void;
+}

package/dist/src/tasks/task-allocation-repository.js

@@ -0,0 +1,82 @@
+import { afterSqliteCommit, getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { enqueueTaskChangedEvent, init_task_change_events } from "./task-change-events.js";
+import { appendTranscriptEntry, init_transcript_repository } from "../storage/sqlite/transcript-repository.js";
+import { emitSessionTranscriptUpdate } from "../session/transcript-events.js";
+import { resolveTaskLocale } from "./task-language.js";
+import { randomUUID } from "node:crypto";
+//#region src/tasks/task-allocation-repository.ts
+init_transaction();
+init_transcript_repository();
+init_task_change_events();
+var TaskAllocationRepository = class {
+	get(taskId) {
+		return getSqliteDatabase().prepare("SELECT * FROM task_allocations WHERE task_id = ?").get(taskId);
+	}
+	summary(taskId) {
+		const row = this.get(taskId);
+		return row ? {
+			id: row.id,
+			taskId,
+			status: row.status,
+			attempts: row.attempts,
+			updatedAt: row.updated_at,
+			...row.selected_agent_id ? { selectedAgentId: row.selected_agent_id } : {},
+			...row.selection_reason ? { selectionReason: row.selection_reason } : {},
+			...row.reason_code ? { reasonCode: row.reason_code } : {}
+		} : void 0;
+	}
+	create(taskId, conversationId, taskVersion, requirements) {
+		const now = Date.now();
+		getSqliteDatabase().prepare(`INSERT INTO task_allocations
+      (id, task_id, origin_conversation_id, requirements_json, task_version, status, next_attempt_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, 'pending', ?, ?)`).run(randomUUID(), taskId, conversationId, JSON.stringify(requirements), taskVersion, now, now);
+		const task = getSqliteDatabase().prepare("SELECT title, locale FROM tasks WHERE task_id = ?").get(taskId);
+		this.publish(taskId, resolveTaskLocale(task) === "zh" ? "任务已提交，正在分配执行者。" : "Task submitted; assigning an executor.");
+	}
+	claim(now = Date.now()) {
+		return runSqliteWriteTransaction((db) => {
+			db.prepare(`UPDATE task_allocations SET status = 'cancelled', lease_token = NULL
+        WHERE status IN ('pending','selecting') AND task_id IN (SELECT task_id FROM tasks WHERE phase = 'closed')`).run();
+			const row = db.prepare(`SELECT a.* FROM task_allocations a JOIN tasks t ON t.task_id = a.task_id
+        WHERE t.phase != 'closed' AND NOT EXISTS (SELECT 1 FROM task_waits w WHERE w.task_id = a.task_id AND w.status = 'active')
+        AND ((a.status = 'pending' AND a.next_attempt_at <= ?) OR (a.status = 'selecting' AND a.lease_expires_at <= ?))
+        ORDER BY a.next_attempt_at, a.id LIMIT 1`).get(now, now);
+			if (!row) return void 0;
+			const token = randomUUID();
+			db.prepare(`UPDATE task_allocations SET status = 'selecting', lease_token = ?, lease_expires_at = ?,
+        attempts = attempts + 1, updated_at = ? WHERE id = ?`).run(token, now + 6e4, now, row.id);
+			return this.get(row.task_id);
+		});
+	}
+	owns(row) {
+		const current = this.get(row.task_id);
+		return current?.status === "selecting" && current.lease_token === row.lease_token && (current.lease_expires_at ?? 0) > Date.now();
+	}
+	publish(taskId, content) {
+		const row = this.get(taskId);
+		if (!row) return;
+		const db = getSqliteDatabase();
+		const task = db.prepare("SELECT version, project_id FROM tasks WHERE task_id = ?").get(taskId);
+		appendTranscriptEntry(row.origin_conversation_id, {
+			role: "custom",
+			customType: "task_allocation_status",
+			content,
+			display: true,
+			details: {
+				taskId,
+				allocation: this.summary(taskId)
+			},
+			timestamp: Date.now()
+		});
+		enqueueTaskChangedEvent(db, {
+			taskId,
+			version: task.version,
+			projectId: task.project_id ?? void 0,
+			changedFields: ["delegateAgentId", "attention"],
+			source: "runtime"
+		});
+		afterSqliteCommit(() => emitSessionTranscriptUpdate({ conversationId: row.origin_conversation_id }));
+	}
+};
+//#endregion
+export { TaskAllocationRepository };

package/dist/src/tasks/task-allocation-service.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { type MatchingContext, type SpecialistAssessment } from '../agent-matching/service.js';
+import { TaskRepository } from './task-repository.js';
+declare const DecisionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"select">;
+    agentId: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"no_candidate">;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"needs_input">;
+    question: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type AllocationDecision = z.infer<typeof DecisionSchema>;
+export interface AllocationDecisionInput {
+    task: ReturnType<TaskRepository['require']>;
+    candidates: SpecialistAssessment[];
+    signal: AbortSignal;
+}
+/** The router is a separate Catalog Agent; it does not execute a TaskRun or call business tools. */
+export declare function decideTaskAllocation(input: AllocationDecisionInput): Promise<AllocationDecision>;
+export declare class TaskAllocationDispatcher {
+    #private;
+    private readonly deps;
+    constructor(deps: {
+        context: (conversationId: string) => MatchingContext;
+        decide?: (input: AllocationDecisionInput) => Promise<AllocationDecision>;
+        wake: () => void;
+    });
+    dispatch(): void;
+    stop(): void;
+    drain(): Promise<void>;
+    private drainSlot;
+    private allocate;
+    private cancel;
+    private finishFailure;
+}
+export {};