@xopcai/xopc 0.0.383 → 0.0.385

package/dist/src/share/site-proxy.js

@@ -1,8 +1,8 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
+import { request } from "undici";
 import { Readable } from "node:stream";
 import * as ws from "ws";
-import { request } from "undici";
 //#region src/share/site-proxy.ts
 init_logger();
 const wsAny = ws;

package/dist/src/share/site-share-store.js

@@ -3,8 +3,8 @@ import { init_logger } from "../utils/logger.js";
 import { init_connection, requireXopcDatabase } from "../storage/sqlite/connection.js";
 import { init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { DurableState } from "../storage/sqlite/durable-state.js";
-import { isPathUnderWorkspace } from "../gateway/workspace-editor-path.js";
 import { SITE_SHARE_CONFIG_DEFAULTS } from "./site-share-types.js";
+import { isPathUnderWorkspace } from "../gateway/workspace-editor-path.js";
 import { relative, resolve } from "node:path";
 import { randomBytes, randomUUID } from "node:crypto";
 import { lstat, readdir, realpath, stat } from "node:fs/promises";

package/dist/src/storage/sqlite/connection-wait-repository.d.ts

@@ -35,3 +35,5 @@ export declare function reviseCurrentConnectionObjective(conversationId: string,
 export declare function cancelConnectionObjective(conversationId: string): void;
 export declare function getConnectionResumeInput(conversationId: string, runId: string): SessionInput | undefined;
 export declare function listConnectionWaitsToCheck(): ConnectionWait[];
+/** A queued wait has not crossed consumeConnectionResume's execution boundary. */
+export declare function reconcileConnectionWaits(afterRestart?: boolean): string[];

package/dist/src/storage/sqlite/connection-wait-repository.js

@@ -203,7 +203,9 @@ function queueConnectionResolution(wait, resolution, resolvePersonal) {
 			...wait,
 			status: "queued",
 			resolution,
-			queuedInputId: input.id
+			queuedInputId: input.id,
+			checking: void 0,
+			recoveryError: void 0
 		}, wait.version);
 	});
 }
@@ -243,7 +245,8 @@ function consumeConnectionResume(input) {
 		}
 		updateConnectionWait({
 			...wait,
-			status: "closed"
+			status: "closed",
+			checking: void 0
 		}, wait.version);
 		return true;
 	});
@@ -345,6 +348,8 @@ function invalidateConnectionResumeIntent(conversationId) {
 			status: "open",
 			intent: void 0,
 			queuedInputId: void 0,
+			checking: void 0,
+			recoveryError: void 0,
 			objectiveRevision: wait.objectiveRevision + 1,
 			scopeConfirmedAt: void 0,
 			reviewRequired: true
@@ -372,6 +377,8 @@ function reviseCurrentConnectionObjective(conversationId, summary) {
 			},
 			status: "open",
 			resolution: void 0,
+			checking: void 0,
+			recoveryError: void 0,
 			intent: void 0,
 			queuedInputId: void 0,
 			scopeConfirmedAt: void 0,
@@ -420,7 +427,8 @@ function cancelConnectionObjective(conversationId) {
 			...wait,
 			status: "closed",
 			resolution: "cancelled",
-			intent: void 0
+			intent: void 0,
+			checking: void 0
 		}, wait.version);
 		if (personalRequest && personalRequest.state !== "cancelled") updatePersonalRequest(personalRequest, { state: "cancelled" });
 	});
@@ -439,6 +447,77 @@ function listConnectionWaitsToCheck() {
     JOIN sessions session ON session.active_transcript_id = wait.transcript_id
     WHERE wait.status = 'open'`).all().map((row) => JSON.parse(row.data_json)).filter((wait) => wait.principalId === "local-owner" && wait.intent && wait.intent.validUntil > Date.now());
 }
+/** A queued wait has not crossed consumeConnectionResume's execution boundary. */
+function reconcileConnectionWaits(afterRestart = false) {
+	if (!isXopcDatabaseOpen()) return [];
+	return runSqliteWriteTransaction((db) => {
+		const rows = db.prepare(`SELECT wait.data_json FROM session_connection_waits wait
+      JOIN sessions session ON session.active_transcript_id = wait.transcript_id
+      WHERE wait.status IN ('open', 'queued')`).all();
+		const wake = /* @__PURE__ */ new Set();
+		for (const row of rows) {
+			const wait = JSON.parse(row.data_json);
+			if (wait.status === "open") {
+				if (afterRestart && wait.checking) {
+					updateConnectionWait({
+						...wait,
+						checking: void 0,
+						lastAction: void 0,
+						recoveryError: "restart_interrupted"
+					}, wait.version);
+					log.info({
+						conversationId: wait.conversationId,
+						waitId: wait.id,
+						phase: "restart_reconcile"
+					}, "Interrupted connection check preserved for recovery");
+					publishConnectionWait(wait.conversationId);
+				}
+				continue;
+			}
+			const input = wait.queuedInputId ? getSessionInputById(wait.conversationId, wait.queuedInputId) : void 0;
+			const matches = input?.kind === "connection_resume" && input.payload?.waitId === wait.id && input.payload.objectiveRevision === wait.objectiveRevision && input.expectedTranscriptId === wait.transcriptId;
+			if (matches && input.status === "running") continue;
+			if (matches && (input.status === "queued" || input.status === "interrupted")) {
+				if (input.status === "interrupted") {
+					setSessionInputStatus(input.id, "queued");
+					updateConnectionWait({
+						...wait,
+						checking: void 0,
+						recoveryError: "restart_interrupted"
+					}, wait.version);
+					log.info({
+						conversationId: wait.conversationId,
+						waitId: wait.id,
+						inputId: input.id,
+						phase: "restart_reconcile"
+					}, "Unconsumed connection continuation requeued");
+					publishConnectionWait(wait.conversationId);
+				}
+				wake.add(wait.conversationId);
+				continue;
+			}
+			updateConnectionWait({
+				...wait,
+				status: "open",
+				queuedInputId: void 0,
+				intent: void 0,
+				checking: void 0,
+				recoveryError: "restart_interrupted",
+				resolution: void 0,
+				objectiveRevision: wait.objectiveRevision + 1
+			}, wait.version);
+			log.warn({
+				conversationId: wait.conversationId,
+				waitId: wait.id,
+				inputId: wait.queuedInputId,
+				inputStatus: input?.status,
+				phase: "resume_reconcile"
+			}, "Unavailable connection continuation preserved for retry");
+			publishConnectionWait(wait.conversationId);
+		}
+		return [...wake];
+	});
+}
 var log, events;
 var init_connection_wait_repository = __esmMin((() => {
 	init_logger();
@@ -455,4 +534,4 @@ var init_connection_wait_repository = __esmMin((() => {
 }));
 //#endregion
 init_connection_wait_repository();
-export { bindObjectiveAccount, cancelConnectionObjective, connectionBinding, connectionBindings, connectorObjectiveScope, consumeConnectionResume, getActiveConnectionWait, getConnectionResumeInput, getConnectionWait, init_connection_wait_repository, invalidateConnectionResumeIntent, isConnectionSuspended, listConnectionWaitsToCheck, onConnectionWaitChanged, publishConnectionWait, queueConnectionResolution, requireSessionConnection, reviseCurrentConnectionObjective, updateConnectionWait };
+export { bindObjectiveAccount, cancelConnectionObjective, connectionBinding, connectionBindings, connectorObjectiveScope, consumeConnectionResume, getActiveConnectionWait, getConnectionResumeInput, getConnectionWait, init_connection_wait_repository, invalidateConnectionResumeIntent, isConnectionSuspended, listConnectionWaitsToCheck, onConnectionWaitChanged, publishConnectionWait, queueConnectionResolution, reconcileConnectionWaits, requireSessionConnection, reviseCurrentConnectionObjective, updateConnectionWait };

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

@@ -7,7 +7,7 @@ import { init_node_sqlite, requireNodeSqlite } from "../../infra/node-sqlite.js"
 import { ensureXopcDatabaseSchema, init_schema } from "./schema.js";
 import { init_unhandled_rejections, installSqliteTransientRejectionHandler } from "../../infra/unhandled-rejections.js";
 import path from "node:path";
-import fsSync from "node:fs";
+import fs from "node:fs";
 import childProcess from "node:child_process";
 //#region src/storage/sqlite/connection.ts
 function normalizeNonNegativeInteger(value, label) {
@@ -17,7 +17,7 @@ function normalizeNonNegativeInteger(value, label) {
 function findExistingVolumePath(targetPath) {
 	let current = path.resolve(targetPath);
 	while (true) try {
-		return fsSync.statSync(current).isDirectory() ? current : path.dirname(current);
+		return fs.statSync(current).isDirectory() ? current : path.dirname(current);
 	} catch {
 		const parent = path.dirname(current);
 		if (parent === current) return null;
@@ -64,7 +64,7 @@ function parseMountCommandEntries(contents) {
 }
 function readMountEntries() {
 	try {
-		return parseProcMountInfoEntries(fsSync.readFileSync(PROC_MOUNTINFO_PATH, "utf8"));
+		return parseProcMountInfoEntries(fs.readFileSync(PROC_MOUNTINFO_PATH, "utf8"));
 	} catch {}
 	try {
 		return parseMountCommandEntries(String(childProcess.execFileSync("mount", [])));
@@ -91,7 +91,7 @@ function isNetworkMountEntryPath(targetPath) {
 	return mountEntry ? isNetworkMountType(mountEntry.fsType) : false;
 }
 function isNetworkBackedPath(targetPath) {
-	if (typeof fsSync.statfsSync !== "function") return isNetworkMountEntryPath(targetPath);
+	if (typeof fs.statfsSync !== "function") return isNetworkMountEntryPath(targetPath);
 	const checkedPath = findExistingVolumePath(targetPath);
 	if (!checkedPath) return false;
 	try {
@@ -100,7 +100,7 @@ function isNetworkBackedPath(targetPath) {
 			4283649346,
 			4266872130,
 			20859
-		].includes(fsSync.statfsSync(checkedPath).type >>> 0)) return true;
+		].includes(fs.statfsSync(checkedPath).type >>> 0)) return true;
 	} catch {
 		return isNetworkMountEntryPath(checkedPath);
 	}
@@ -145,13 +145,13 @@ function ensureDatabasePermissions(pathname) {
 	if (pathname === ":memory:") return;
 	const dir = pathname.slice(0, Math.max(pathname.lastIndexOf("/"), pathname.lastIndexOf("\\")));
 	if (dir) {
-		fsSync.mkdirSync(dir, { recursive: true });
-		fsSync.chmodSync(dir, DB_DIR_MODE);
+		fs.mkdirSync(dir, { recursive: true });
+		fs.chmodSync(dir, DB_DIR_MODE);
 	}
 	for (const suffix of DB_SIDECAR_SUFFIXES) {
 		const candidate = `${pathname}${suffix}`;
-		if (!fsSync.existsSync(candidate)) continue;
-		fsSync.chmodSync(candidate, DB_FILE_MODE);
+		if (!fs.existsSync(candidate)) continue;
+		fs.chmodSync(candidate, DB_FILE_MODE);
 	}
 }
 function openDatabaseAtPath(pathname) {

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 = 248;
+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 ?? 248;
+	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 ?? 248;
+	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 = 248;
+	XOPC_DB_SCHEMA_VERSION = 249;
 }));
 //#endregion
 init_runner();

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

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

package/dist/src/storage/sqlite/transcript-repository.d.ts

@@ -43,6 +43,8 @@ export declare function findLatestAssistantTranscriptEntryId(conversationId: str
 /** Attach generated media to one exact assistant row without rewriting the transcript. */
 export declare function appendMediaToAssistantTranscriptEntry(conversationId: string, entryId: string, media: MediaRef): boolean;
 export declare function replaceTranscriptRows(conversationId: string, rows: TranscriptStoredRow[]): void;
+/** Keep entry identities and failed-attempt evidence while excluding failed responses from model replay. */
+export declare function archiveFailedModelAttempts(conversationId: string, afterIndex: number): void;
 export declare function paginateTranscriptMessages(conversationId: string, options?: {
     offset?: number;
     limit?: number;

package/dist/src/storage/sqlite/transcript-repository.js

@@ -294,6 +294,30 @@ function replaceTranscriptRows(conversationId, rows) {
       WHERE conversation_id = ?`).run(llm.length, estimateTokensFromMessages(llm), now, now, now, conversationId);
 	});
 }
+/** Keep entry identities and failed-attempt evidence while excluding failed responses from model replay. */
+function archiveFailedModelAttempts(conversationId, afterIndex) {
+	runSqliteWriteTransaction((db) => {
+		const transcriptId = readCurrentTranscriptId(db, conversationId);
+		if (!transcriptId) throw new Error(`Session not found: ${conversationId}`);
+		const rows = db.prepare(`SELECT entry_id, payload_json FROM transcript_entries
+      WHERE transcript_id = ? ORDER BY seq`).all(transcriptId);
+		for (const row of rows.slice(afterIndex)) {
+			const message = JSON.parse(row.payload_json);
+			if (message.role !== "assistant" || message.stopReason !== "error") continue;
+			const archived = {
+				type: "custom",
+				customType: "model_attempt_error",
+				data: message,
+				timestamp: new Date(message.timestamp ?? Date.now()).toISOString()
+			};
+			db.prepare(`UPDATE transcript_entries SET role = NULL, entry_kind = 'custom', payload_json = ?
+        WHERE transcript_id = ? AND entry_id = ?`).run(JSON.stringify(archived), transcriptId, row.entry_id);
+			db.prepare("DELETE FROM transcript_fts WHERE transcript_id = ? AND entry_id = ?").run(transcriptId, row.entry_id);
+		}
+		const messages = buildSessionContextForLlm(loadTranscriptRowsForSession(conversationId));
+		db.prepare("UPDATE sessions SET message_count = ?, estimated_tokens = ? WHERE conversation_id = ?").run(messages.length, estimateTokensFromMessages(messages), conversationId);
+	});
+}
 function paginateTranscriptMessages(conversationId, options = {}) {
 	const transcriptId = getCurrentTranscriptId(conversationId);
 	if (!transcriptId) return {
@@ -422,4 +446,4 @@ var init_transcript_repository = __esmMin((() => {
 }));
 //#endregion
 init_transcript_repository();
-export { appendCompactionBoundaryIfUnchanged, appendMediaToAssistantTranscriptEntry, appendTranscriptEntry, findLatestAssistantTranscriptEntryId, init_transcript_repository, listCompactionBoundaries, loadCompactionSourceSnapshot, loadLlmMessagesForSession, loadTranscriptHistoryRowsForSession, loadTranscriptRows, loadTranscriptRowsForSession, paginateTranscriptMessages, replaceTranscriptRows, restoreBeforeCompactionBoundary, searchSessionTranscript };
+export { appendCompactionBoundaryIfUnchanged, appendMediaToAssistantTranscriptEntry, appendTranscriptEntry, archiveFailedModelAttempts, findLatestAssistantTranscriptEntryId, init_transcript_repository, listCompactionBoundaries, loadCompactionSourceSnapshot, loadLlmMessagesForSession, loadTranscriptHistoryRowsForSession, loadTranscriptRows, loadTranscriptRowsForSession, paginateTranscriptMessages, replaceTranscriptRows, restoreBeforeCompactionBoundary, searchSessionTranscript };

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

@@ -4,10 +4,10 @@ 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 { TaskContextRepository } from "../task-context-repository.js";
 import { TaskReadModelProjector } from "../task-read-model-projector.js";
-import { TaskDependencyService } from "../task-dependency-service.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";
 import { TaskValueMetricsService } from "../task-value-metrics-service.js";
 //#region src/tasks/capabilities/read.ts

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;
+}