@xopcai/xopc 0.0.359 → 0.0.361

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/storage/sqlite/transcript-repository.d.ts

@@ -10,6 +10,7 @@ export interface TranscriptSourceEntry {
     row: TranscriptStoredRow;
 }
 export interface CompactionSourceSnapshot {
+    fingerprint?: string;
     transcriptId: string;
     lastSeq: number;
     entries: TranscriptSourceEntry[];
@@ -25,7 +26,9 @@ export declare function appendTranscriptEntry(conversationId: string, row: Trans
     transcriptId?: string;
     tokenDelta?: number;
 }): TranscriptEntryRow;
-export declare function appendCompactionBoundaryIfUnchanged(conversationId: string, expected: Pick<CompactionSourceSnapshot, 'transcriptId' | 'lastSeq'>, row: Omit<XopcTranscriptCompactionEntry, 'baseSeq'>): TranscriptEntryRow | null;
+export declare function appendCompactionBoundaryIfUnchanged(conversationId: string, expected: Pick<CompactionSourceSnapshot, 'transcriptId' | 'lastSeq'> & {
+    fingerprint?: string;
+}, row: Omit<XopcTranscriptCompactionEntry, 'baseSeq'>): TranscriptEntryRow | null;
 export declare function loadCompactionSourceSnapshot(conversationId: string): CompactionSourceSnapshot | null;
 export declare function searchSessionTranscript(conversationId: string, query: string, options?: {
     limit?: number;

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

@@ -5,7 +5,7 @@ import { buildSessionContextForLlm, init_session_context_for_llm, isRuntimeOnlyT
 import { classifyStoredRow, estimateTokensFromMessages, extractFtsContent, init_row_mappers, transcriptEntryRowToStoredRow } from "./row-mappers.js";
 import { escapeFts5Query, init_fts } from "./fts.js";
 import { getCurrentTranscriptId, init_session_repository } from "./session-repository.js";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 //#region src/storage/sqlite/transcript-repository.ts
 function nextSeq(db, transcriptId) {
 	return (db.prepare(`SELECT COALESCE(MAX(seq), 0) AS max_seq FROM transcript_entries WHERE transcript_id = ?`).get(transcriptId).max_seq ?? 0) + 1;
@@ -100,12 +100,25 @@ function appendTranscriptEntry(conversationId, row, opts) {
 		return inserted;
 	});
 }
+function compactionRowsFingerprint(rows) {
+	const hash = createHash("sha256");
+	for (const row of rows) hash.update(JSON.stringify([
+		row.entry_id,
+		row.seq,
+		row.payload_json,
+		row.created_at
+	]));
+	return hash.digest("hex");
+}
 function appendCompactionBoundaryIfUnchanged(conversationId, expected, row) {
 	return runSqliteWriteTransaction((db) => {
 		const transcriptId = readCurrentTranscriptId(db, conversationId);
 		if (!transcriptId) throw new Error(`Session not found: ${conversationId}`);
 		if (transcriptId !== expected.transcriptId) return null;
 		if (nextSeq(db, transcriptId) - 1 !== expected.lastSeq) return null;
+		if (expected.fingerprint) {
+			if (compactionRowsFingerprint(db.prepare("SELECT entry_id, seq, payload_json, created_at FROM transcript_entries WHERE transcript_id = ? ORDER BY seq ASC").all(transcriptId)) !== expected.fingerprint) return null;
+		}
 		const boundary = {
 			...row,
 			baseSeq: expected.lastSeq
@@ -138,6 +151,7 @@ function loadCompactionSourceSnapshot(conversationId) {
 	return {
 		transcriptId,
 		lastSeq: rows.at(-1)?.seq ?? 0,
+		fingerprint: compactionRowsFingerprint(rows),
 		entries: rows.map((entry) => ({
 			entryId: entry.entry_id,
 			seq: entry.seq,

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-decision-service.js

@@ -3,8 +3,8 @@ import { TaskRunRepository, init_task_run_repository } from "./task-run-reposito
 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";
+import { TaskCollaborationRepository } from "./task-collaboration-repository.js";
 //#region src/tasks/task-main-update-decision-service.ts
 init_providers();
 init_task_repository();

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

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

@@ -0,0 +1,128 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.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 { appendTranscriptEntry, init_transcript_repository } from "../storage/sqlite/transcript-repository.js";
+import { TaskConversationRepository } from "./task-conversation-repository.js";
+import { tryParseMediaUri } from "../media/uri.js";
+import { resolveMediaBufferPath } from "../media/store.js";
+import { emitSessionTranscriptUpdate } from "../session/transcript-events.js";
+import { TaskResultDeliveryRepository } from "./task-result-delivery-repository.js";
+import { lstat } from "node:fs/promises";
+//#region src/tasks/task-result-delivery-service.ts
+init_src();
+init_transcript_repository();
+init_transaction();
+init_logger();
+init_task_run_repository();
+const log = createLogger("TaskResultDelivery");
+async function materializedArtifact(item) {
+	const { workspaceRelativePath: _path, thumbnailUrl: _thumbnail, ...artifact } = item;
+	if (item.availability !== "available") return {
+		...artifact,
+		uri: void 0,
+		shareUrl: void 0,
+		capabilities: []
+	};
+	const media = item.uri ? tryParseMediaUri(item.uri) : null;
+	if (media?.bucket === "outbound" && item.location === "artifact_store") {
+		const file = await lstat(resolveMediaBufferPath(media.id, media.bucket)).catch(() => null);
+		if (file?.isFile() && file.size <= 52428800) return {
+			...artifact,
+			sizeBytes: file.size,
+			shareUrl: void 0,
+			capabilities: item.capabilities.filter((capability) => capability === "preview" || capability === "download")
+		};
+		return {
+			...artifact,
+			availability: "missing",
+			uri: void 0,
+			shareUrl: void 0,
+			capabilities: []
+		};
+	}
+	if (item.kind === "site" && item.location === "external_host") try {
+		const url = new URL(item.shareUrl ?? item.uri ?? "");
+		if (url.protocol === "https:" && !url.username && !url.password) return {
+			...artifact,
+			uri: url.href,
+			shareUrl: url.href,
+			capabilities: ["open"]
+		};
+	} catch {}
+	return {
+		...artifact,
+		availability: "failed",
+		uri: void 0,
+		shareUrl: void 0,
+		capabilities: []
+	};
+}
+var TaskResultDeliveryService = class {
+	#repository = new TaskResultDeliveryRepository();
+	async drain(notify, limit = 20) {
+		let delivered = 0;
+		for (const row of this.#repository.pending(limit)) try {
+			const delivery = TaskResultDeliverySchema.parse(JSON.parse(row.payload_json));
+			if (row.status === "pending") {
+				const deliverables = await Promise.all(delivery.outcome.deliverables.map(materializedArtifact));
+				if (!runSqliteWriteTransaction((db) => {
+					const current = db.prepare("SELECT status FROM task_result_deliveries WHERE delivery_id = ?").get(row.delivery_id);
+					if (current?.status !== "pending") return current?.status === "delivered";
+					const run = new TaskRunRepository().get(delivery.taskRunId);
+					const state = new TaskConversationRepository().getState(delivery.taskId);
+					const session = db.prepare("SELECT active_transcript_id FROM sessions WHERE conversation_id = ?").get(delivery.conversationId);
+					const task = db.prepare("SELECT resolution FROM tasks WHERE task_id = ?").get(delivery.taskId);
+					if (!session || !run || !["succeeded", "failed"].includes(run.status) || task.resolution && task.resolution !== "done" || new TaskRunRepository().getLatestRoot(delivery.taskId)?.id !== run.id || state?.assignmentEpoch !== delivery.assignmentEpoch || state.activeConversationId !== run.conversationId) {
+						db.prepare("UPDATE task_result_deliveries SET status = 'stale' WHERE delivery_id = ?").run(row.delivery_id);
+						return false;
+					}
+					const available = deliverables.filter((item) => item.availability === "available").length;
+					const outcome = {
+						...delivery.outcome,
+						deliverables,
+						status: deliverables.length > 0 && available === 0 ? "failed" : available < deliverables.length ? "partial" : delivery.outcome.status
+					};
+					const statusText = db.prepare("SELECT locale FROM tasks WHERE task_id = ?").get(delivery.taskId).locale?.startsWith("zh") === true ? `${delivery.taskTitle}：${available === deliverables.length ? "成果已生成" : available > 0 ? "部分成果已生成" : "成果暂不可用"}。` : `${delivery.taskTitle}: ${available === deliverables.length ? "Results ready" : available > 0 ? "Partial results ready" : "Results unavailable"}.`;
+					const content = delivery.text ? `${statusText}\n\n${delivery.text}` : statusText;
+					const details = {
+						...delivery,
+						outcome
+					};
+					const entry = appendTranscriptEntry(delivery.conversationId, {
+						role: "custom",
+						customType: "task_result_delivery",
+						content,
+						display: true,
+						details,
+						timestamp: Date.now()
+					});
+					db.prepare(`UPDATE task_result_deliveries SET status = 'delivered', payload_json = ?,
+              message_entry_id = ?, delivered_at = ? WHERE delivery_id = ?`).run(JSON.stringify(details), entry.entry_id, Date.now(), row.delivery_id);
+					return true;
+				})) continue;
+			}
+			emitSessionTranscriptUpdate({ conversationId: delivery.conversationId });
+			notify(delivery.conversationId, delivery.deliveryId);
+			getSqliteDatabase().prepare("UPDATE task_result_deliveries SET notified_at = ? WHERE delivery_id = ?").run(Date.now(), row.delivery_id);
+			delivered += 1;
+			log.info({
+				conversationId: delivery.conversationId,
+				taskId: delivery.taskId,
+				deliveryId: delivery.deliveryId,
+				durationMs: Date.now() - delivery.createdAt
+			}, "Task result delivered to main Chat");
+		} catch (error) {
+			this.#repository.retry(row.delivery_id, error instanceof Error ? error.message : String(error));
+			if (row.attempts === 0 || row.attempts === 7) log.warn({
+				err: error,
+				deliveryId: row.delivery_id
+			}, "Task result delivery failed");
+		}
+		return delivered;
+	}
+};
+//#endregion
+export { TaskResultDeliveryService };

package/dist/src/tasks/task-run-coordinator.js

@@ -2,6 +2,7 @@ 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 { TaskCollaborationRepository } from "./task-collaboration-repository.js";
+import { TaskResultDeliveryRepository } from "./task-result-delivery-repository.js";
 import { TaskApplicationService } from "./task-application-service.js";
 //#region src/tasks/task-run-coordinator.ts
 init_task_repository();
@@ -10,6 +11,7 @@ var TaskRunCoordinator = class TaskRunCoordinator {
 	#evidence = [];
 	#application = new TaskApplicationService();
 	#runs = new TaskRunRepository();
+	#hasDeliverables = false;
 	constructor(runId) {
 		this.runId = runId;
 	}
@@ -81,6 +83,8 @@ var TaskRunCoordinator = class TaskRunCoordinator {
 		}
 	}
 	captureOutcome(outcome) {
+		new TaskResultDeliveryRepository().capture(this.runId, outcome);
+		this.#hasDeliverables ||= outcome.deliverables.some((item) => item.availability === "available");
 		for (const item of outcome.evidence) {
 			if (item.kind !== "check") continue;
 			this.addEvidence({
@@ -113,12 +117,13 @@ var TaskRunCoordinator = class TaskRunCoordinator {
 		if (run.status === "waiting" && this.#runs.listActiveWaits(run.taskId).length > 0) return;
 		const hasAssistantResult = Boolean(input.assistantText?.trim() && input.assistantText.trim() !== "NO_REPLY");
 		const hasBoardResult = new TaskCollaborationRepository().recent(run.taskId, void 0, 20).some((entry) => entry.taskRunId === run.id && entry.kind === "result");
-		const emptySuccess = input.status === "succeeded" && !hasAssistantResult && !hasBoardResult && this.#evidence.length === 0;
+		const emptySuccess = input.status === "succeeded" && !hasAssistantResult && !hasBoardResult && !this.#hasDeliverables && this.#evidence.length === 0;
 		const status = emptySuccess ? "failed" : input.status;
 		const summary = emptySuccess ? "Agent run returned no result or evidence" : input.summary;
 		this.#application.completeRun({
 			runId: run.id,
 			expectedRunVersion: run.version,
+			resultText: input.assistantText,
 			receipt: {
 				status,
 				summary,

package/dist/src/tasks/task-run-dispatcher.d.ts

@@ -8,6 +8,7 @@ export declare class TaskRunDispatcher {
         runAgent: (runId: string, conversationId: string, message: string) => Promise<void>;
     });
     dispatch(): void;
+    stop(): void;
     drain(): Promise<void>;
     private reconcileExpiredRuns;
     private drainSlot;

package/dist/src/tasks/task-run-dispatcher.js

@@ -16,13 +16,24 @@ var TaskRunDispatcher = class {
 	#application = new TaskApplicationService();
 	#draining = /* @__PURE__ */ new Set();
 	#activeRunIds = /* @__PURE__ */ new Set();
+	#heartbeats = /* @__PURE__ */ new Set();
+	#stopped = false;
 	constructor(deps) {
 		this.deps = deps;
 	}
 	dispatch() {
-		this.drain();
+		this.drain().catch((error) => {
+			if (this.#stopped) return;
+			log.error({ err: error }, `TaskRun dispatch failed: ${error instanceof Error ? error.message : String(error)}`);
+		});
+	}
+	stop() {
+		this.#stopped = true;
+		for (const heartbeat of this.#heartbeats) clearInterval(heartbeat);
+		this.#heartbeats.clear();
 	}
 	async drain() {
+		if (this.#stopped) return;
 		this.reconcileExpiredRuns();
 		const count = Math.max(1, Math.min(8, this.deps.maxConcurrency ?? 3));
 		await Promise.all(Array.from({ length: count }, (_, slot) => this.drainSlot(`${this.deps.workerId}:${slot}`)));
@@ -67,7 +78,7 @@ var TaskRunDispatcher = class {
 		if (this.#draining.has(workerId)) return;
 		this.#draining.add(workerId);
 		try {
-			while (true) {
+			while (!this.#stopped) {
 				const run = this.#runs.claimNext({
 					owner: workerId,
 					leaseMs: LEASE_MS,
@@ -89,22 +100,29 @@ var TaskRunDispatcher = class {
 					}) : run)) continue;
 					const agentId = typeof run.executorRef.agentId === "string" ? run.executorRef.agentId : void 0;
 					const conversationId = await this.deps.ensureSession(task.id, run.id, agentId);
+					if (this.#stopped) return;
 					this.#activeRunIds.add(run.id);
 					const heartbeat = setInterval(() => {
 						if (!this.#runs.heartbeat({
 							runId: run.id,
 							owner: workerId,
 							leaseMs: LEASE_MS
-						})) clearInterval(heartbeat);
+						})) {
+							clearInterval(heartbeat);
+							this.#heartbeats.delete(heartbeat);
+						}
 					}, HEARTBEAT_MS);
 					heartbeat.unref?.();
+					this.#heartbeats.add(heartbeat);
 					try {
 						await this.deps.runAgent(run.id, conversationId, buildTaskRunMessage(task.contract?.objective ?? task.title, run.trigger, task.body));
 					} finally {
 						clearInterval(heartbeat);
+						this.#heartbeats.delete(heartbeat);
 						this.#activeRunIds.delete(run.id);
 					}
 				} catch (error) {
+					if (this.#stopped) return;
 					const current = this.#runs.get(run.id);
 					if (current && [
 						"queued",
@@ -142,6 +160,7 @@ var TaskRunDispatcher = class {
 				}
 			}
 		} catch (error) {
+			if (this.#stopped) return;
 			log.error({ err: error }, `TaskRun dispatch failed: ${error instanceof Error ? error.message : String(error)}`);
 		} finally {
 			this.#draining.delete(workerId);