@xopcai/xopc 0.0.359 → 0.0.360

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

@@ -6,6 +6,7 @@ import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "
 import { init_session_instance_repository, readCurrentTranscriptId } from "./session-instance-repository.js";
 import { bumpSessionInputRevision, getSessionInputById, getSessionInputState, init_session_input_repository, insertSessionInput, setSessionInputStatus } from "./session-input-repository.js";
 import { TaskRunRepository, init_task_run_repository } from "../../tasks/task-run-repository.js";
+import { init_request_repository, personalRequestForExecution, personalRequestForWait, updatePersonalRequest } from "../../personal-agent/request-repository.js";
 import { getConnectorAccount, init_connector_account_repository } from "./connector-account-repository.js";
 import { getConnectorConnection, init_connector_repository } from "./connector-repository.js";
 import { randomUUID } from "node:crypto";
@@ -68,8 +69,10 @@ function requireSessionConnection(input) {
 	return runSqliteWriteTransaction((db) => {
 		const transcriptId = readCurrentTranscriptId(db, input.conversationId);
 		const runtime = getSessionInputState(input.conversationId);
-		const origin = runtime.activeInputId ? getSessionInputById(input.conversationId, runtime.activeInputId) : void 0;
-		if (!transcriptId || !origin || !runtime.activeRunId) throw new Error("Connection recovery requires a queued chat execution.");
+		const originId = input.origin?.inputId ?? runtime.activeInputId;
+		const origin = originId ? getSessionInputById(input.conversationId, originId) : void 0;
+		const originRunId = input.origin?.runId ?? runtime.activeRunId;
+		if (!transcriptId || !origin || !originRunId || origin.expectedTranscriptId && origin.expectedTranscriptId !== transcriptId) throw new Error("Connection recovery requires a queued chat execution.");
 		const resumed = origin.payload ? getConnectionWait(origin.payload.waitId) : void 0;
 		if (resumed?.resolution === "skipped") return { status: "skipped" };
 		const active = getActiveConnectionWait(input.conversationId);
@@ -97,7 +100,9 @@ function requireSessionConnection(input) {
 		}
 		const lastEntry = db.prepare("SELECT entry_id FROM transcript_entries WHERE transcript_id = ? ORDER BY seq DESC LIMIT 1").get(transcriptId);
 		const wait = {
-			...input,
+			conversationId: input.conversationId,
+			principalId: input.principalId,
+			agentId: input.agentId,
 			needs: [...new Map(input.needs.map((need) => [need.key, need])).values()],
 			id: randomUUID(),
 			transcriptId,
@@ -105,7 +110,7 @@ function requireSessionConnection(input) {
 			objectiveRevision: (resumed?.objectiveRevision ?? 0) + 1,
 			objectiveUpdatedAt: resumed?.objectiveUpdatedAt ?? origin.createdAtMs,
 			originInputId: origin.id,
-			originRunId: runtime.activeRunId,
+			originRunId,
 			taskRunId: origin.taskRunId,
 			checkpoint: {
 				entryId: lastEntry?.entry_id,
@@ -158,10 +163,16 @@ function requireSessionConnection(input) {
 	});
 }
 /** The input and the wait transition commit together, using the existing queue's unique key. */
-function queueConnectionResolution(wait, resolution) {
+function queueConnectionResolution(wait, resolution, resolvePersonal) {
 	return runSqliteWriteTransaction(() => {
 		const current = getConnectionWait(wait.id);
 		if (!current || current.version !== wait.version || current.status !== "open") throw new Error("WAIT_CHANGED");
+		if (resolvePersonal?.(wait, resolution)) return updateConnectionWait({
+			...wait,
+			status: "closed",
+			resolution,
+			intent: void 0
+		}, wait.version);
 		const origin = getSessionInputById(wait.conversationId, wait.originInputId);
 		if (!origin) throw new Error("Original input is unavailable.");
 		const input = insertSessionInput({
@@ -239,6 +250,21 @@ function consumeConnectionResume(input) {
 }
 function connectionBindings(conversationId) {
 	if (!isXopcDatabaseOpen()) return [];
+	const personalRequest = personalRequestForExecution(conversationId);
+	if (personalRequest?.accountId) {
+		const account = getConnectorAccount(personalRequest.accountId);
+		return [{
+			key: `${personalRequest.connectorId}:${personalRequest.accountId}`,
+			target: {
+				type: "connector",
+				connectorId: personalRequest.connectorId
+			},
+			label: personalRequest.connectorId,
+			capabilities: [],
+			accountId: personalRequest.accountId,
+			connectionId: account?.currentConnectionId
+		}];
+	}
 	let sessionContext = getConnectionSessionContext(conversationId);
 	if (sessionContext?.sessionType === "workflow-subagent" && sessionContext.parentConversationId) sessionContext = getConnectionSessionContext(sessionContext.parentConversationId);
 	const workflowAccounts = sessionContext?.sessionType === "workflow-run" ? sessionContext.customData.connectorAccounts : void 0;
@@ -360,9 +386,11 @@ function cancelConnectionObjective(conversationId) {
 	if (!wait) return;
 	runSqliteWriteTransaction(() => {
 		if (wait.queuedInputId) setSessionInputStatus(wait.queuedInputId, "cancelled");
-		if (wait.taskRunId) {
-			const runs = new TaskRunRepository();
-			const run = runs.get(wait.taskRunId);
+		const personalRequest = personalRequestForWait(wait.id);
+		const runs = new TaskRunRepository();
+		const taskRunId = wait.taskRunId ?? (personalRequest?.taskId ? runs.getActiveRoot(personalRequest.taskId)?.id : void 0);
+		if (taskRunId) {
+			const run = runs.get(taskRunId);
 			if (run?.status === "waiting") {
 				for (const taskWait of runs.listActiveWaits(run.taskId)) if (taskWait.condition.connectionWaitId === wait.id) runs.resolveWait({
 					waitId: taskWait.id,
@@ -394,6 +422,7 @@ function cancelConnectionObjective(conversationId) {
 			resolution: "cancelled",
 			intent: void 0
 		}, wait.version);
+		if (personalRequest && personalRequest.state !== "cancelled") updatePersonalRequest(personalRequest, { state: "cancelled" });
 	});
 	publishConnectionWait(conversationId);
 }
@@ -414,6 +443,7 @@ var log, events;
 var init_connection_wait_repository = __esmMin((() => {
 	init_logger();
 	init_task_run_repository();
+	init_request_repository();
 	init_connection();
 	init_connector_account_repository();
 	init_connector_repository();

package/dist/src/storage/sqlite/migrations/231_task_result_deliveries.sql

@@ -0,0 +1,32 @@
+ALTER TABLE task_origin_links ADD COLUMN origin_transcript_id TEXT;
+ALTER TABLE task_origin_links ADD COLUMN request_input_id TEXT;
+UPDATE task_origin_links SET origin_transcript_id = (
+  SELECT active_transcript_id FROM sessions WHERE sessions.conversation_id = task_origin_links.conversation_id
+);
+
+CREATE TABLE task_run_outcomes (
+  task_run_id TEXT NOT NULL REFERENCES task_runs(run_id) ON DELETE CASCADE,
+  outcome_id TEXT NOT NULL,
+  assignment_epoch INTEGER NOT NULL,
+  outcome_json TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  PRIMARY KEY(task_run_id, outcome_id)
+);
+
+CREATE TABLE task_result_deliveries (
+  delivery_id TEXT PRIMARY KEY,
+  task_run_id TEXT NOT NULL REFERENCES task_runs(run_id) ON DELETE CASCADE,
+  conversation_id TEXT NOT NULL REFERENCES sessions(conversation_id) ON DELETE CASCADE,
+  payload_json TEXT NOT NULL,
+  status TEXT NOT NULL CHECK(status IN ('pending', 'delivered', 'stale', 'failed')),
+  message_entry_id TEXT,
+  attempts INTEGER NOT NULL DEFAULT 0,
+  next_attempt_at INTEGER NOT NULL,
+  last_error TEXT,
+  created_at INTEGER NOT NULL,
+  delivered_at INTEGER,
+  notified_at INTEGER,
+  UNIQUE(task_run_id, conversation_id)
+);
+CREATE INDEX idx_task_result_deliveries_pending
+  ON task_result_deliveries(status, next_attempt_at);

package/dist/src/storage/sqlite/migrations/232_personal_requests.sql

@@ -0,0 +1,28 @@
+CREATE TABLE personal_requests (
+  request_id TEXT PRIMARY KEY,
+  conversation_id TEXT NOT NULL REFERENCES sessions(conversation_id) ON DELETE CASCADE,
+  transcript_id TEXT NOT NULL,
+  input_id TEXT NOT NULL,
+  idempotency_key TEXT NOT NULL,
+  request_hash TEXT NOT NULL,
+  objective TEXT NOT NULL,
+  connector_id TEXT NOT NULL,
+  executor_agent_id TEXT NOT NULL,
+  account_id TEXT,
+  parameters_json TEXT NOT NULL,
+  state TEXT NOT NULL CHECK(state IN ('preflighting','waiting_connection','queued','running','completed','failed','cancelled')),
+  connection_wait_id TEXT UNIQUE,
+  task_id TEXT UNIQUE REFERENCES tasks(task_id) ON DELETE SET NULL,
+  result_json TEXT,
+  result_run_id TEXT,
+  delivery_entry_id TEXT,
+  notified_at INTEGER,
+  delivery_attempts INTEGER NOT NULL DEFAULT 0,
+  delivery_next_attempt_at INTEGER NOT NULL DEFAULT 0,
+  delivery_error TEXT,
+  version INTEGER NOT NULL DEFAULT 1,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  UNIQUE(conversation_id, transcript_id, idempotency_key)
+);
+CREATE INDEX idx_personal_requests_conversation ON personal_requests(conversation_id, created_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 = 230;
+export declare const XOPC_DB_SCHEMA_VERSION = 232;
 export declare function resolveMigrationsDir(override?: string): string;
 /**
  * Apply sequential SQL migrations from (currentVersion + 1) through targetVersion.

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

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

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

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

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

@@ -3,6 +3,7 @@ import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "
 import { validateConversationId, validateTranscriptId } from "../../../packages/gateway-contract/src/conversation-identity.js";
 import { init_src } from "../../../packages/gateway-contract/src/index.js";
 import { init_session_instance_repository, readCurrentTranscriptId } from "./session-instance-repository.js";
+import { TaskRunRepository, init_task_run_repository } from "../../tasks/task-run-repository.js";
 import { buildDefaultSessionMetadata, init_session_metadata } from "./session-metadata.js";
 import { init_timestamps, optionalTimestampToMs } from "./timestamps.js";
 import { buildGlobalSessionStats, init_row_mappers, metadataToSessionInsert, sessionRowToMetadata } from "./row-mappers.js";
@@ -311,6 +312,37 @@ function deleteSessionRecord(conversationId) {
 		db.prepare(`UPDATE transcripts SET status = 'archived', archive_reason = 'delete', archived_at = ?
        WHERE transcript_id = ?`).run(now, existing.active_transcript_id);
 		cancelConnectionObjective(conversationId);
+		if (db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'personal_requests'").get()) {
+			const requests = db.prepare("SELECT task_id FROM personal_requests WHERE conversation_id = ? AND task_id IS NOT NULL").all(conversationId);
+			const runs = new TaskRunRepository();
+			for (const request of requests) {
+				const run = runs.getActiveRoot(request.task_id);
+				if (!run) continue;
+				for (const wait of runs.listActiveWaits(request.task_id)) runs.resolveWait({
+					waitId: wait.id,
+					actor: { kind: "user" },
+					resolution: { cancelled: true }
+				});
+				runs.finalize({
+					runId: run.id,
+					expectedVersion: run.version,
+					actor: { kind: "user" },
+					receipt: {
+						status: "cancelled",
+						summary: "Originating Personal conversation deleted",
+						changes: [],
+						evidence: [],
+						verification: {
+							status: "unverified",
+							checks: []
+						},
+						remainingWork: [],
+						needsUser: false,
+						completionVerdict: "not_achieved"
+					}
+				});
+			}
+		}
 		db.prepare(`DELETE FROM sessions WHERE conversation_id = ?`).run(conversationId);
 		return true;
 	});
@@ -334,6 +366,7 @@ function resolveSessionAgentId(conversationId) {
 }
 var init_session_repository = __esmMin((() => {
 	init_connection_wait_repository();
+	init_task_run_repository();
 	init_src();
 	init_changes();
 	init_session_metadata();

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

@@ -2,10 +2,10 @@ import { ProductReadContracts } from "../../../packages/gateway-contract/src/cap
 import { init_src } from "../../../packages/gateway-contract/src/index.js";
 import { TaskRepository, init_task_repository } from "../task-repository.js";
 import { TaskRunRepository, init_task_run_repository } from "../task-run-repository.js";
-import { TaskConversationRepository } from "../task-conversation-repository.js";
-import { TaskReadModelProjector } from "../task-read-model-projector.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 { 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/task-application-service.d.ts

@@ -28,6 +28,7 @@ export declare class TaskApplicationService {
         terminalCode?: string;
         terminalMessage?: string;
         suppressAttention?: boolean;
+        resultText?: string;
     }): TaskApplicationResult;
     private start;
     private lifecycle;

package/dist/src/tasks/task-application-service.js

@@ -10,6 +10,7 @@ import { TaskContextRepository } from "./task-context-repository.js";
 import { TaskDependencyService } from "./task-dependency-service.js";
 import { TaskCriterionReviewRepository } from "./task-criterion-review-repository.js";
 import { TaskCollaborationRepository } from "./task-collaboration-repository.js";
+import { TaskResultDeliveryRepository } from "./task-result-delivery-repository.js";
 import { createHash, randomUUID } from "node:crypto";
 //#region src/tasks/task-application-service.ts
 init_src();
@@ -97,6 +98,11 @@ var TaskApplicationService = class {
 			if (input.originConversationId) {
 				if (db.prepare(`INSERT INTO task_origin_links (task_id, conversation_id, created_at)
           SELECT ?, conversation_id, ? FROM sessions WHERE conversation_id = ?`).run(task.id, task.createdAt, input.originConversationId).changes !== 1) throw new Error("Task origin conversation not found");
+				db.prepare(`UPDATE task_origin_links SET
+          origin_transcript_id = (SELECT active_transcript_id FROM sessions WHERE conversation_id = ?),
+          request_input_id = (SELECT id FROM session_inputs WHERE conversation_id = ?
+            AND status = 'running' ORDER BY created_at_ms DESC LIMIT 1)
+          WHERE task_id = ?`).run(input.originConversationId, input.originConversationId, task.id);
 				db.prepare(`INSERT INTO task_main_agent_links (task_id, agent_id, origin_conversation_id, created_at)
           SELECT ?, agent_id, conversation_id, ? FROM sessions WHERE conversation_id = ?`).run(task.id, task.createdAt, input.originConversationId);
 			}
@@ -491,6 +497,7 @@ var TaskApplicationService = class {
 				body: input.receipt.summary || (input.receipt.status === "succeeded" ? "TaskRun completed" : "TaskRun failed"),
 				idempotencyKey: `task-run-receipt:${run.id}`
 			});
+			if (input.receipt.status === "succeeded" || input.receipt.status === "failed") new TaskResultDeliveryRepository().enqueue(run.id, input.receipt.summary, input.receipt.status, input.resultText);
 			if (input.receipt.status !== "succeeded") {
 				const model = this.#projector.project(task);
 				if (!input.suppressAttention) enqueueTaskAttentionRequiredEvent(db, {

package/dist/src/tasks/task-context-assembler.js

@@ -145,6 +145,7 @@ function buildTaskExecutionDirective(conversationId) {
 		handoffPayload ? `Handoff snapshot: ${handoffPayload}` : "",
 		collaboration.length ? `Recent task collaboration:\n${collaboration.map((entry) => `- ${entry.sequence} ${entry.authorKind} ${entry.kind}: ${JSON.stringify(entry.body.slice(0, 1e3))}`).join("\n")}` : "",
 		"Report meaningful progress with xopc_use task collaboration_post. If blocked, post a question and stop this execution turn until answered.",
+		"For user-facing files, publish completed outputs with publish_artifacts before finishing. image_generate already publishes its images. Return structured artifact references rather than only local file paths. Published final outcomes are delivered automatically to the originating chat. Keep the final summary short and distinguish generated outputs from verified or accepted results.",
 		"Take safe in-scope steps and produce inspectable evidence. Do not claim completion without verification.",
 		"</xopc_task_execution>"
 	].filter(Boolean).join("\n");

package/dist/src/tasks/task-main-update-delivery.js

@@ -1,14 +1,41 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
+import { TaskRunRepository, init_task_run_repository } from "./task-run-repository.js";
+import { init_request_repository, personalRequestForTask } from "../personal-agent/request-repository.js";
 import { TaskCollaborationRepository } from "./task-collaboration-repository.js";
+import { TaskResultDeliveryRepository } from "./task-result-delivery-repository.js";
 //#region src/tasks/task-main-update-delivery.ts
 init_logger();
+init_task_run_repository();
+init_request_repository();
 const log = createLogger("TaskMainUpdateDelivery");
 var TaskMainUpdateDelivery = class {
 	#entries = new TaskCollaborationRepository();
 	async drain(input, limit = 20) {
 		let delivered = 0;
 		for (const { entry, conversationId, decision, decisionReason } of this.#entries.pendingMainUpdates(limit)) {
+			if ([
+				"result",
+				"failure",
+				"progress"
+			].includes(entry.kind) && personalRequestForTask(entry.taskId)) {
+				this.#entries.markMainUpdateDelivered(entry.id);
+				continue;
+			}
+			const results = new TaskResultDeliveryRepository();
+			const isResult = entry.kind === "result" && entry.taskRunId;
+			if (isResult && results.hasForRun(entry.taskRunId)) {
+				this.#entries.markMainUpdateDelivered(entry.id);
+				continue;
+			}
+			if (isResult && results.hasCapturedOutcome(entry.taskRunId) && [
+				"running",
+				"waiting",
+				"verifying"
+			].includes(new TaskRunRepository().get(entry.taskRunId)?.status ?? "")) {
+				this.#entries.deferMainUpdate(entry.id);
+				continue;
+			}
 			if (!input.isAvailable(conversationId)) {
 				this.#entries.deferMainUpdate(entry.id);
 				continue;
@@ -31,6 +58,10 @@ var TaskMainUpdateDelivery = class {
 					entry
 				});
 				if (!decision) this.#entries.decideMainUpdate(entry.id, verdict.notify ? "notify" : "silent", verdict.reason);
+				if (isResult && results.hasForRun(entry.taskRunId)) {
+					this.#entries.markMainUpdateDelivered(entry.id);
+					continue;
+				}
 				if (!verdict.notify) {
 					this.#entries.markMainUpdateDelivered(entry.id);
 					delivered += 1;
@@ -40,7 +71,7 @@ var TaskMainUpdateDelivery = class {
 					`A delegated Task has a new ${entry.kind} update. Task ID: ${entry.taskId}.`,
 					`Collaboration entry ID: ${entry.id}.`,
 					`Your private notification decision: ${JSON.stringify(verdict.reason)}.`,
-					"Read the Task and collaboration board with xopc_use. If this is a worker question, first answer it from the Task brief or conversation with personal_task(command=\"answer\", taskId, questionId, instruction) when available; ask the user only for a genuinely missing fact. For failures, inspect the actual blocker and try a suitable alternative within the user’s authorization before reporting an impasse. Then tell the user what matters in your own words. Keep the response proportionate to the update and recent conversation. Do not expose this internal trigger or repeat already reported details. If a result receipt is generic, use the board for the actual outcome. A finished TaskRun is not proof that the Task passed verification or was accepted; check its receipt and use precise status language. Do not ask the user to close a Task unless requested. Use tools without preliminary user-facing commentary, then give one concise reply."
+					"Read the Task and collaboration board with personal_task(command=\"get\", taskId) when available, otherwise xopc_use. If this is a worker question, first answer it from the Task brief or conversation with personal_task(command=\"answer\", taskId, questionId, instruction) when available; ask the user only for a genuinely missing fact. For failures, inspect the actual blocker and try a suitable alternative within the user’s authorization before reporting an impasse. Then tell the user what matters in your own words. Keep the response proportionate to the update and recent conversation. Do not expose this internal trigger or repeat already reported details. If a result receipt is generic, use the board for the actual outcome. A finished TaskRun is not proof that the Task passed verification or was accepted; check its receipt and use precise status language. Do not ask the user to close a Task unless requested. Use tools without preliminary user-facing commentary, then give one concise reply."
 				].join("\n");
 				if (await input.submitAndConfirm({
 					conversationId,

package/dist/src/tasks/task-result-delivery-repository.d.ts

@@ -0,0 +1,18 @@
+import { type TurnOutcome } from '@xopcai/gateway-contract';
+export declare function onTaskResultQueued(listener: () => void): () => void;
+export interface TaskResultDeliveryRow {
+    delivery_id: string;
+    payload_json: string;
+    status: 'pending' | 'delivered' | 'stale' | 'failed';
+    attempts: number;
+    message_entry_id: string | null;
+}
+export declare class TaskResultDeliveryRepository {
+    capture(runId: string, value: TurnOutcome): void;
+    /** Called inside the run completion transaction, after stale receipts are rejected. */
+    enqueue(runId: string, summary: string, status: 'succeeded' | 'failed', resultText?: string): boolean;
+    hasForRun(runId: string): boolean;
+    hasCapturedOutcome(runId: string): boolean;
+    pending(limit?: number): TaskResultDeliveryRow[];
+    retry(id: string, error: string): void;
+}

package/dist/src/tasks/task-result-delivery-repository.js

@@ -0,0 +1,144 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { afterSqliteCommit, getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { TurnOutcomeSchema } from "../../packages/gateway-contract/src/turn-outcome.js";
+import { TaskResultDeliverySchema } from "../../packages/gateway-contract/src/task-result-delivery.js";
+import { init_src } from "../../packages/gateway-contract/src/index.js";
+import { TaskRunRepository, init_task_run_repository } from "./task-run-repository.js";
+import { init_request_repository, personalRequestForTask } from "../personal-agent/request-repository.js";
+import { TaskConversationRepository } from "./task-conversation-repository.js";
+import { TaskCollaborationRepository } from "./task-collaboration-repository.js";
+import { randomUUID } from "node:crypto";
+//#region src/tasks/task-result-delivery-repository.ts
+init_src();
+init_transaction();
+init_task_run_repository();
+init_logger();
+init_request_repository();
+const log = createLogger("TaskResultDelivery");
+const queuedListeners = /* @__PURE__ */ new Set();
+function onTaskResultQueued(listener) {
+	queuedListeners.add(listener);
+	return () => {
+		queuedListeners.delete(listener);
+	};
+}
+var TaskResultDeliveryRepository = class {
+	capture(runId, value) {
+		const outcome = TurnOutcomeSchema.parse({
+			...value,
+			evidence: [],
+			changeSet: void 0,
+			summary: value.summary.slice(0, 2e3)
+		});
+		if (outcome.deliverables.length > 50 || JSON.stringify(outcome).length > 256e3) throw new Error("Task outcome exceeds delivery limits");
+		const run = new TaskRunRepository().get(runId);
+		if (!run || ![
+			"running",
+			"waiting",
+			"verifying"
+		].includes(run.status)) return;
+		const state = new TaskConversationRepository().getState(run.taskId);
+		if (!state || state.activeConversationId !== run.conversationId) return;
+		getSqliteDatabase().prepare(`INSERT INTO task_run_outcomes
+      (task_run_id, outcome_id, assignment_epoch, outcome_json, created_at)
+      VALUES (?, ?, ?, ?, ?) ON CONFLICT(task_run_id, outcome_id) DO NOTHING`).run(runId, outcome.outcomeId, state.assignmentEpoch, JSON.stringify(outcome), Date.now());
+	}
+	/** Called inside the run completion transaction, after stale receipts are rejected. */
+	enqueue(runId, summary, status, resultText) {
+		const db = getSqliteDatabase();
+		const run = new TaskRunRepository().get(runId);
+		if (!run || run.parentRunId) return false;
+		const state = new TaskConversationRepository().getState(run.taskId);
+		if (!state || state.activeConversationId !== run.conversationId) return false;
+		const origin = db.prepare(`SELECT origin.*, task.title FROM task_origin_links origin
+      JOIN tasks task ON task.task_id = origin.task_id
+      WHERE origin.task_id = ?`).get(run.taskId);
+		if (!origin?.origin_transcript_id) return false;
+		const outcomes = db.prepare(`SELECT outcome_json FROM task_run_outcomes
+      WHERE task_run_id = ? AND assignment_epoch = ? ORDER BY created_at, rowid LIMIT 100`).all(runId, state.assignmentEpoch).map((row) => TurnOutcomeSchema.parse(JSON.parse(row.outcome_json)));
+		const latest = outcomes.at(-1);
+		if (!latest) return false;
+		const artifacts = /* @__PURE__ */ new Map();
+		for (const outcome of outcomes) for (const item of outcome.deliverables) artifacts.set(item.sourceFileId ?? item.artifactId, item);
+		const deliverables = [...artifacts.values()].slice(-50);
+		const text = resultText?.trim() && resultText.trim() !== "NO_REPLY" ? resultText.trim().slice(0, 8e3) : void 0;
+		if (!deliverables.length && (!text || status !== "succeeded")) return false;
+		if (!deliverables.length && personalRequestForTask(run.taskId)) return false;
+		const outcome = {
+			...latest,
+			deliverables,
+			evidence: [],
+			changeSet: void 0,
+			summary: summary.slice(0, 2e3),
+			status: status === "failed" || deliverables.some((item) => item.availability !== "available") ? "partial" : "succeeded"
+		};
+		const now = Date.now();
+		const delivery = TaskResultDeliverySchema.parse({
+			version: 1,
+			deliveryId: randomUUID(),
+			taskId: run.taskId,
+			taskRunId: runId,
+			taskTitle: origin.title.slice(0, 300),
+			conversationId: origin.conversation_id,
+			originTranscriptId: origin.origin_transcript_id,
+			...origin.request_input_id ? { requestInputId: origin.request_input_id } : {},
+			assignmentEpoch: state.assignmentEpoch,
+			outcome,
+			...text ? { text } : {},
+			createdAt: now
+		});
+		db.prepare(`INSERT INTO task_result_deliveries
+      (delivery_id, task_run_id, conversation_id, payload_json, status, next_attempt_at, created_at)
+      VALUES (?, ?, ?, ?, 'pending', ?, ?) ON CONFLICT(task_run_id, conversation_id) DO NOTHING`).run(delivery.deliveryId, runId, origin.conversation_id, JSON.stringify(delivery), now, now);
+		db.prepare(`UPDATE task_main_update_deliveries SET status = 'delivered', decision = 'silent',
+      decision_reason = 'Structured task result delivery', updated_at = ?
+      WHERE entry_id IN (SELECT entry_id FROM task_collaboration_entries
+        WHERE task_run_id = ? AND kind IN ('result', 'progress'))`).run(now, runId);
+		afterSqliteCommit(() => {
+			for (const listener of queuedListeners) try {
+				listener();
+			} catch (err) {
+				log.warn({
+					err,
+					runId
+				}, "Task result wake failed; polling will recover");
+			}
+		});
+		return true;
+	}
+	hasForRun(runId) {
+		return Boolean(getSqliteDatabase().prepare(`SELECT 1 FROM task_result_deliveries
+      WHERE task_run_id = ? AND status IN ('pending', 'delivered')`).get(runId));
+	}
+	hasCapturedOutcome(runId) {
+		return Boolean(getSqliteDatabase().prepare("SELECT 1 FROM task_run_outcomes WHERE task_run_id = ? LIMIT 1").get(runId));
+	}
+	pending(limit = 20) {
+		return getSqliteDatabase().prepare(`SELECT * FROM task_result_deliveries
+      WHERE status IN ('pending', 'delivered') AND next_attempt_at <= ? AND notified_at IS NULL
+      ORDER BY created_at LIMIT ?`).all(Date.now(), limit);
+	}
+	retry(id, error) {
+		runSqliteWriteTransaction((db) => {
+			db.prepare(`UPDATE task_result_deliveries SET attempts = attempts + 1,
+        status = CASE WHEN status = 'pending' AND attempts >= 7 THEN 'failed' ELSE status END,
+        notified_at = CASE WHEN status = 'delivered' AND attempts >= 7 THEN -1 ELSE notified_at END,
+        next_attempt_at = ? + MIN(60000, 1000 * (1 << MIN(attempts, 6))), last_error = ?
+        WHERE delivery_id = ? AND status IN ('pending', 'delivered')`).run(Date.now(), error.slice(0, 500), id);
+			const row = db.prepare("SELECT task_run_id FROM task_result_deliveries WHERE delivery_id = ? AND status = 'failed'").get(id);
+			const run = row ? new TaskRunRepository().get(row.task_run_id) : void 0;
+			if (run) new TaskCollaborationRepository().append({
+				taskId: run.taskId,
+				taskRunId: run.id,
+				authorKind: "system",
+				authorId: "task-result-delivery",
+				kind: "failure",
+				body: "The task produced results, but delivery to the main chat failed. Inspect the published artifacts and retry delivery; do not regenerate paid outputs just to send them.",
+				idempotencyKey: `task-result-delivery-failed:${id}`
+			});
+		});
+	}
+};
+//#endregion
+export { TaskResultDeliveryRepository, onTaskResultQueued };

package/dist/src/tasks/task-result-delivery-service.d.ts

@@ -0,0 +1,4 @@
+export declare class TaskResultDeliveryService {
+    #private;
+    drain(notify: (conversationId: string, deliveryId: string) => void, limit?: number): Promise<number>;
+}