@xopcai/xopc 0.0.358 → 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/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/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

@@ -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 { 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 { TaskConversationRepository } from "../task-conversation-repository.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/write.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 { defineAtomicCapability } from "../../capabilities/runtime/dispatcher.js";
-import { TaskApplicationService } from "../task-application-service.js";
 import { resolveProjectAgentId } from "../../projects/project-agent.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

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 { getExecutionEnvironmentForSession } from "../execution-environments/subject.js";
 import { TaskConversationRepository } from "./task-conversation-repository.js";
+import { getExecutionEnvironmentForSession } from "../execution-environments/subject.js";
 //#region src/tasks/execution-context.ts
 init_sqlite();
 const ORIGINS = new Set([

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

@@ -2,11 +2,11 @@ import { TaskRepository, init_task_repository } from "./task-repository.js";
 import { isHomeAttentionAcknowledged } from "../storage/sqlite/home-attention-repository.js";
 import { listConnectorApprovals } from "../storage/sqlite/connector-repository.js";
 import { init_sqlite } from "../storage/sqlite/index.js";
-import "../automations/domain/defaults.js";
-import "../automations/index.js";
 import { TaskReadModelProjector } from "./task-read-model-projector.js";
-import { listGatewayAgents } from "../gateway/agents-admin.js";
+import "../automations/domain/defaults.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,14 +1,13 @@
 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 { TaskConversationConflictError, TaskConversationRepository } from "./task-conversation-repository.js";
 import { TaskReadModelProjector } from "./task-read-model-projector.js";
+import { TaskContextRepository } from "./task-context-repository.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 { assembleTaskContext, buildDelegatedTaskDirective, buildTaskExecutionDirective, getTaskContextManifest, getTaskExecutionBrief } from "./task-context-assembler.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";
@@ -16,6 +15,7 @@ import { HomeQueryService, buildHomeWorkbench, decisionFromTask } from "./home-q
 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-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

@@ -4,12 +4,13 @@ import { init_src } from "../../packages/gateway-contract/src/index.js";
 import { enqueueTaskAttentionRequiredEvent, 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 { 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 { TaskCollaborationRepository } from "./task-collaboration-repository.js";
-import { TaskConversationRepository } from "./task-conversation-repository.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-collaboration-delivery.js

@@ -3,8 +3,8 @@ import { init_logger } from "../utils/logger.js";
 import { getSqliteDatabase, init_transaction } from "../storage/sqlite/transaction.js";
 import { TaskRepository, init_task_repository } from "./task-repository.js";
 import { TaskRunRepository, init_task_run_repository } from "./task-run-repository.js";
-import { TaskCollaborationRepository } from "./task-collaboration-repository.js";
 import { TaskConversationRepository } from "./task-conversation-repository.js";
+import { TaskCollaborationRepository } from "./task-collaboration-repository.js";
 import { TaskApplicationService } from "./task-application-service.js";
 //#region src/tasks/task-collaboration-delivery.ts
 init_task_repository();

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

@@ -4,9 +4,9 @@ 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 { init_sqlite } from "../storage/sqlite/index.js";
+import { TaskConversationRepository } from "./task-conversation-repository.js";
 import { TaskContextRepository } from "./task-context-repository.js";
 import { TaskCollaborationRepository } from "./task-collaboration-repository.js";
-import { TaskConversationRepository } from "./task-conversation-repository.js";
 import { TaskOriginRepository } from "./task-origin-repository.js";
 //#region src/tasks/task-context-assembler.ts
 init_src();
@@ -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-handoff-service.js

@@ -5,8 +5,8 @@ import { TaskRunRepository, init_task_run_repository } from "./task-run-reposito
 import { normalizeAgentId } from "../agent-catalog/id.js";
 import { init_agent_scope, listAgentEntries } from "../agent/agent-scope.js";
 import { init_session_key, resolveConversationId, sanitizeSegment } from "../routing/session-key.js";
-import { TaskContextRepository } from "./task-context-repository.js";
 import { TaskConversationRepository } from "./task-conversation-repository.js";
+import { TaskContextRepository } from "./task-context-repository.js";
 //#region src/tasks/task-handoff-service.ts
 init_agent_scope();
 init_session_key();

package/dist/src/tasks/task-main-update-decision-service.js

@@ -1,8 +1,8 @@
 import { TaskRepository, init_task_repository } from "./task-repository.js";
 import { TaskRunRepository, init_task_run_repository } from "./task-run-repository.js";
-import { extractAssistantText, getAssistantMessageErrorReason, stripCodeFences } from "../providers/model-response.js";
 import { init_providers, resolveModel } from "../providers/index.js";
 import { completeWithResolvedCredentials } from "../providers/model-call.js";
+import { extractAssistantText, getAssistantMessageErrorReason, stripCodeFences } from "../providers/model-response.js";
 import { TaskCollaborationRepository } from "./task-collaboration-repository.js";
 import { getPersonalAgentByConversation } from "../personal-agent/repository.js";
 //#region src/tasks/task-main-update-decision-service.ts

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