@xopcai/xopc 0.0.383 → 0.0.384

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

@@ -76,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";
@@ -87,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";
@@ -179,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";
@@ -190,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";

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

@@ -5,9 +5,9 @@ import { TaskRunRepository, init_task_run_repository } from "../task-run-reposit
 import { CapabilityError } from "../../capabilities/runtime/errors.js";
 import { defineAtomicCapability } from "../../capabilities/runtime/dispatcher.js";
 import { resolveTaskLocale } from "../task-language.js";
-import { TaskApplicationService } from "../task-application-service.js";
 import { resolveProjectAgentId } from "../../projects/project-agent.js";
 import { resolveResponseLanguageForSession } from "../../agent/prompt/response-language.js";
+import { TaskApplicationService } from "../task-application-service.js";
 import { TaskSignalService } from "../task-signal-service.js";
 import { z } from "zod";
 //#region src/tasks/capabilities/write.ts
@@ -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);
@@ -73,14 +74,14 @@ function registerTaskWriteCapabilities(dispatcher, deps) {
 				...input,
 				locale,
 				originConversationId,
-				delegateAgentId: agentId,
+				delegateAgentId: input.activation.mode === "allocate" ? void 0 : agentId,
 				activation,
 				idempotencyKey: context.idempotencyKey
 			};
 			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({
@@ -111,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/execution-context.js

@@ -1,7 +1,7 @@
 import { isXopcDatabaseOpen } from "../storage/sqlite/connection.js";
 import { init_sqlite } from "../storage/sqlite/index.js";
-import { TaskConversationRepository } from "./task-conversation-repository.js";
 import { getExecutionEnvironmentForSession } from "../execution-environments/subject.js";
+import { TaskConversationRepository } from "./task-conversation-repository.js";
 //#region src/tasks/execution-context.ts
 init_sqlite();
 const ORIGINS = new Set([

package/dist/src/tasks/home-query-service.js

@@ -4,9 +4,9 @@ import { listConnectorApprovals } from "../storage/sqlite/connector-repository.j
 import { init_sqlite } from "../storage/sqlite/index.js";
 import { TaskReadModelProjector } from "./task-read-model-projector.js";
 import "../automations/domain/defaults.js";
-import "../automations/index.js";
-import { listGatewayAgents } from "../gateway/agents-admin.js";
 import { AttentionGovernor } from "./attention-governor.js";
+import { listGatewayAgents } from "../gateway/agents-admin.js";
+import "../automations/index.js";
 //#region src/tasks/home-query-service.ts
 init_sqlite();
 init_task_repository();

package/dist/src/tasks/index.js

@@ -1,21 +1,21 @@
 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 { TaskContextRepository } from "./task-context-repository.js";
 import { TaskReadModelProjector } from "./task-read-model-projector.js";
-import { TaskDependencyError, TaskDependencyService } from "./task-dependency-service.js";
 import { TaskConversationConflictError, TaskConversationRepository } from "./task-conversation-repository.js";
-import { TaskApplicationService } from "./task-application-service.js";
-import { defineTaskContract } from "./task-contract-definition.js";
-import { assembleTaskContext, buildDelegatedTaskDirective, buildTaskExecutionDirective, getTaskContextManifest, getTaskExecutionBrief } from "./task-context-assembler.js";
+import { TaskContextRepository } from "./task-context-repository.js";
+import { TaskDependencyError, TaskDependencyService } from "./task-dependency-service.js";
 import { TaskValueMetricsService } from "./task-value-metrics-service.js";
 import { TaskDeletionService } from "./task-deletion-service.js";
+import { TaskApplicationService } from "./task-application-service.js";
 import { TaskSignalService } from "./task-signal-service.js";
 import { resolveExecutionContext } from "./execution-context.js";
 import { AttentionGovernor } from "./attention-governor.js";
 import { HomeQueryService, buildHomeWorkbench, decisionFromTask } from "./home-query-service.js";
 import { TaskWorkflowCoordinator } from "./task-workflow-coordinator.js";
+import { defineTaskContract } from "./task-contract-definition.js";
 import { ModelTaskContractPlanner, parseTaskContractResponse } from "./task-contract-planner.js";
+import { assembleTaskContext, buildDelegatedTaskDirective, buildTaskExecutionDirective, getTaskContextManifest, getTaskExecutionBrief } from "./task-context-assembler.js";
 import { TaskRunCoordinator } from "./task-run-coordinator.js";
 import { ProjectOperatingViewService, summarizeProjectOperatingView } from "./project-operating-view-service.js";
 import { TaskHandoffService } from "./task-handoff-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 {};