@xopcai/xopc 0.0.420 → 0.0.422

package/dist/src/gateway/service/session-input-coordinator.js

@@ -10,6 +10,7 @@ import { cancelConnectionObjective, consumeConnectionResume, getActiveConnection
 import { appendTranscriptEntry } from "../../storage/sqlite/transcript-repository.js";
 import "../../storage/sqlite/index.js";
 import { emitSessionTranscriptUpdate } from "../../session/transcript-events.js";
+import { consumePhoneAssistance, finishPhoneAssistance, phoneAssistance, queuePhoneAssistance, reconcilePhoneAssistance } from "../../phone/assistance.js";
 import { summarizeSourceContext } from "../../agent/source-context/types.js";
 import { TaskApplicationService } from "../../tasks/task-application-service.js";
 import { injectSourceContextsIntoUserMessage } from "../../agent/source-context/injector.js";
@@ -91,6 +92,11 @@ var SessionInputCoordinator = class {
 	snapshot(conversationId) {
 		return getSessionInputState(conversationId);
 	}
+	resumePhone(conversationId, waitId) {
+		queuePhoneAssistance(conversationId, waitId);
+		this.publish(conversationId);
+		this.drain(conversationId);
+	}
 	connectionTarget(conversationId, runtime = this.snapshot(conversationId)) {
 		const active = runtime.activeInputId ? getSessionInputById(conversationId, runtime.activeInputId) : void 0;
 		return getActiveConnectionWait(conversationId) ?? (active?.kind === "connection_resume" && active.payload ? getConnectionWait(active.payload.waitId) : void 0);
@@ -346,6 +352,41 @@ var SessionInputCoordinator = class {
 			};
 		}
 		const runtime = this.snapshot(conversationId);
+		const phoneWait = phoneAssistance(conversationId);
+		if (/^(?:我已(?:完成|登录|登陆|输入验证码)[，,、\s]*(?:请)?继续(?:原任务|任务)?|(?:登录|登陆|验证码|手机操作)(?:已)?完成[了]?[，,、\s]*(?:请)?继续(?:原任务|任务)?|好了[，,、\s]*继续(?:原任务|任务)?|(?:i(?: have|'ve) )?(?:logged in|finished on the phone|completed the phone action)[,\s]+(?:please )?(?:continue|resume)(?: the task)?)[。.!！\s]*$/iu.test(content) && phoneWait?.status === "open" && this.deps.completePhone && input.origin.type !== "system" && !attachments?.length && !input.contextRefs?.length && !getActiveConnectionWait(conversationId) && !getActiveClarification(conversationId)) {
+			if (input.expectedTranscriptId && input.expectedTranscriptId !== phoneWait.transcriptId) return {
+				ok: false,
+				code: "SESSION_CHANGED"
+			};
+			await this.deps.completePhone(phoneWait);
+			runSqliteWriteTransaction(() => {
+				const row = insertSessionInput({
+					id: crypto.randomUUID(),
+					conversationId,
+					clientMessageId,
+					expectedTranscriptId: phoneWait.transcriptId,
+					content,
+					requestedDelivery: "next",
+					effectiveDelivery: "next",
+					status: "queued",
+					origin: input.origin
+				});
+				queuePhoneAssistance(conversationId, phoneWait.id);
+				appendTranscriptEntry(conversationId, {
+					role: "user",
+					content,
+					timestamp: row.createdAtMs
+				});
+				setSessionInputStatus(row.id, "completed");
+			});
+			emitSessionTranscriptUpdate({ conversationId });
+			this.drain(conversationId);
+			return {
+				ok: true,
+				effectiveDelivery: "next",
+				state: this.publish(conversationId)
+			};
+		}
 		const wait = this.connectionTarget(conversationId, runtime);
 		const control = wait?.principalId === "local-owner" ? connectionControl(input, wait) : void 0;
 		const payload = connectionInputPayload(wait, control);
@@ -436,7 +477,7 @@ var SessionInputCoordinator = class {
 						this.publish(conversationId);
 						continue;
 					}
-					allowed = allowed && consumeConnectionResume(input) && consumeClarificationResume(input);
+					allowed = allowed && consumeConnectionResume(input) && consumeClarificationResume(input) && consumePhoneAssistance(input);
 				} catch (err) {
 					log.warn({
 						err,
@@ -444,6 +485,7 @@ var SessionInputCoordinator = class {
 						runId,
 						inputId: input.id
 					}, "Session input preflight failed");
+					finishPhoneAssistance(input, false);
 					finishSessionInputRun(conversationId, runId, "failed", "Input preflight failed");
 					if (input.kind === "connection_resume") reconcileConnectionWaits();
 					this.publish(conversationId);
@@ -451,6 +493,7 @@ var SessionInputCoordinator = class {
 				}
 				if (!allowed) {
 					finishSessionInputRun(conversationId, runId, "cancelled");
+					finishPhoneAssistance(input, false);
 					this.publish(conversationId);
 					continue;
 				}
@@ -513,6 +556,7 @@ var SessionInputCoordinator = class {
 				}
 				const terminal = cancelled ? "cancelled" : result.status === "suspended" ? "suspended" : result.status === "ok" ? "completed" : result.status === "aborted" ? "cancelled" : "failed";
 				finishSessionInputRun(conversationId, runId, terminal, terminal === "failed" ? result.summary : void 0);
+				finishPhoneAssistance(input, terminal === "completed");
 				this.publish(conversationId);
 			}
 		} finally {
@@ -664,7 +708,11 @@ var SessionInputCoordinator = class {
 	recover() {
 		const interrupted = recoverSessionInputState();
 		new TaskRunRepository().reconcileCancelledRuns();
-		for (const conversationId of new Set([...interrupted, ...reconcileConnectionWaits(true)])) {
+		for (const conversationId of new Set([
+			...interrupted,
+			...reconcileConnectionWaits(true),
+			...reconcilePhoneAssistance()
+		])) {
 			this.publish(conversationId);
 			this.drain(conversationId);
 		}

package/dist/src/gateway/service.d.ts

@@ -155,6 +155,7 @@ export declare class GatewayService {
         ok: false;
         code: "BAD_REQUEST" | "QUEUE_FULL" | "CONTEXT_UNAVAILABLE" | "SESSION_CHANGED";
     }>;
+    resumePhoneAssistance(conversationId: string, waitId: string): void;
     withSessionInputSubmission<T>(conversationId: string, operation: () => Promise<T>): Promise<T>;
     prepareSessionCommandInput(input: Parameters<GatewayAgentRunner['inputs']['prepareInput']>[0]): Promise<{
         payload?: import("../storage/sqlite/session-input-repository.js").SessionInputPayload;

package/dist/src/gateway/service.js

@@ -104,6 +104,7 @@ import { EndpointToolRuntime } from "../endpoint-tools/runtime.js";
 import "../endpoint-tools/index.js";
 import { assertGatewayAuthConfigured, extractToken, resolveGatewayAuth, validateToken } from "./auth.js";
 import { prepareAutomationAgentSession } from "./automation-agent-session.js";
+import { deliverAutomationCompletion } from "./automation-completion-delivery.js";
 import { stopTailscaleExposure } from "./tailscale-lifecycle.js";
 import { getGatewayFileSpaceService } from "./file-space-service.js";
 import { reconcileHomeIntelligenceAutomation } from "./home-intelligence-automation-reconciler.js";
@@ -766,6 +767,7 @@ var GatewayService = class {
 		this.automationService.setDeps({
 			agentService: this._agentService,
 			getDefaultAgentId: () => getDefaultAgentId(),
+			isAgentAvailable: (id) => listAgentEntries().some((agent) => agent.id === id && agent.enabled !== false),
 			prepareAgentSession: (input) => prepareAutomationAgentSession(this.sessionIndex.getStore(), this.projects, input),
 			browserAutomationService: this.browserAutomations,
 			executeTaskCommand: ({ taskId, idempotencyKey, command, triggerEvent }) => {
@@ -1091,6 +1093,9 @@ var GatewayService = class {
 	submitSessionInput(...args) {
 		return this.agentRunner.submitSessionInput(...args);
 	}
+	resumePhoneAssistance(conversationId, waitId) {
+		this.agentRunner.inputs.resumePhone(conversationId, waitId);
+	}
 	withSessionInputSubmission(conversationId, operation) {
 		return this.agentRunner.inputs.withSubmission(conversationId, operation);
 	}
@@ -1318,6 +1323,10 @@ var GatewayService = class {
 		await this.localApps.recoverPendingReleases();
 		const { recoverCapabilityImports } = await import("../imports/runtime.js");
 		await recoverCapabilityImports();
+		if (getSqliteDatabase().prepare("SELECT 1 FROM durable_state WHERE namespace = 'phone.location-environment' LIMIT 1").get()) {
+			const { getPhoneRuntime } = await import("../phone/runtime.js");
+			getPhoneRuntime().environment.sweep().catch(() => log.warn({ phase: "phone_location_recovery" }, "Phone location recovery remains pending"));
+		}
 		this.createNotificationService().start();
 		this.startTime = Date.now();
 		this.running = true;
@@ -1426,6 +1435,7 @@ var GatewayService = class {
 		this.automationService.setDeps({
 			agentService: this.agentService,
 			getDefaultAgentId: () => getDefaultAgentId(),
+			isAgentAvailable: (id) => listAgentEntries().some((agent) => agent.id === id && agent.enabled !== false),
 			prepareAgentSession: (input) => prepareAutomationAgentSession(this.sessionIndex.getStore(), this.projects, input),
 			browserAutomationService: this.browserAutomations,
 			executeTaskCommand: ({ taskId, idempotencyKey, command, triggerEvent }) => {
@@ -1628,6 +1638,7 @@ var GatewayService = class {
 		log.debug("Stopping gateway service...");
 		await this._workDiscovery?.stop();
 		this.readiness.markStarting();
+		await this.endpointTools.locations.close();
 		this.endpointTools.close();
 		await this.sideChats.disposeAll();
 		this.homeIntelligenceHost?.stop();
@@ -1994,10 +2005,7 @@ var GatewayService = class {
 		this.createNotificationService().handleGatewayEvent(type, notificationPayload);
 	}
 	async handleAutomationRunCompleted(run, context) {
-		this.emit("automation.run.completed", {
-			run,
-			...context
-		});
+		deliverAutomationCompletion(run, context, this.createNotificationService(), (type, payload) => this.emit(type, payload));
 	}
 	startSessionTranscriptEventIngestion() {
 		this.stopSessionTranscriptAutomationEvents?.();

package/dist/src/gateway/session-reset-service.js

@@ -1,6 +1,8 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { isPersonalConversation } from "../personal-agent/repository.js";
+import { cancelPhoneAssistance } from "../phone/assistance.js";
+import { getPhoneRuntime } from "../phone/runtime.js";
 import { abortEmbeddedRun } from "../agent/embedded/runs.js";
 //#region src/gateway/session-reset-service.ts
 init_logger();
@@ -26,6 +28,8 @@ async function performSessionReset(conversationId, deps) {
 		ok: false,
 		error: "Session not found"
 	};
+	cancelPhoneAssistance(key);
+	await getPhoneRuntime().stop(key, "cancel");
 	try {
 		deps.getAgentService().evictSessionAgent(key);
 	} catch (err) {

package/dist/src/gateway/xopc-cloud-capability-setup.js

@@ -1,7 +1,6 @@
 import "../agent-config/schema.js";
 import { init_agent_config } from "../agent-config/index.js";
 import { AgentCatalogRepository, init_repository } from "../agent-catalog/repository.js";
-import { AgentCatalogService } from "../agent-catalog/service.js";
 import { ConfigSchema, init_schema } from "../config/schema.js";
 import { init_model_policy, isComputerModel, isDedicatedComputerProfile } from "../computer/model-policy.js";
 import { voiceSupportsMode } from "../../packages/realtime-protocol/src/voice-catalog.js";
@@ -9,6 +8,7 @@ import { init_voice } from "../../packages/realtime-protocol/src/voice.js";
 import { getModelCatalogStore, init_model_catalog_store } from "../providers/model-catalog-store.js";
 import { phoneModelProfile } from "../phone/model-adapter.js";
 import { compareCatalogModels } from "../providers/model-catalog-ranking.js";
+import { AgentCatalogService } from "../agent-catalog/service.js";
 import { prepareUpdateGlobalDefaults } from "./global-defaults-admin.js";
 //#region src/gateway/xopc-cloud-capability-setup.ts
 init_voice();

package/dist/src/imports/importService.js

@@ -11,8 +11,8 @@ import { scanLocal } from "./scanner.js";
 import { dirname, join } from "node:path";
 import { existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { randomUUID } from "node:crypto";
-import yaml from "js-yaml";
 import lockfile from "proper-lockfile";
+import yaml from "js-yaml";
 //#region src/imports/importService.ts
 init_write_file_atomic();
 init_logger();

package/dist/src/local-apps/service.js

@@ -5,9 +5,9 @@ import { init_logger } from "../utils/logger.js";
 import { afterSqliteCommit, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { ExtensionCapabilityBindingsSchema, extensionCapabilityPermissions } from "../../packages/gateway-contract/src/extension-capabilities.js";
 import { init_src } from "../../packages/gateway-contract/src/index.js";
-import { CapabilityError } from "../capabilities/runtime/errors.js";
 import { init_paths, resolveExtensionsDir } from "../config/paths.js";
 import { slugifyProjectName } from "../projects/project-store.js";
+import { CapabilityError } from "../capabilities/runtime/errors.js";
 import { LocalAppStore } from "./store.js";
 import { DomainOutboxDispatcher } from "../infra/domain-outbox-dispatcher.js";
 import { validateLocalAppCapabilityContracts } from "./capabilities/contracts.js";

package/dist/src/notifications/planner.js

@@ -136,15 +136,15 @@ function automationPlan(payload) {
 			},
 			priority: completed ? "normal" : "high",
 			title: completed ? {
-				en: "Automation completed",
-				zh: "自动化已完成"
+				en: `${run.automationName} · Completed`,
+				zh: `${run.automationName} · 已完成`
 			} : {
-				en: "Automation needs attention",
-				zh: "自动化需要处理"
+				en: `${run.automationName} · Needs attention`,
+				zh: `${run.automationName} · 需要处理`
 			},
 			body: {
-				en: (run.error || run.summary || run.automationName).slice(0, 180),
-				zh: (run.error || run.summary || run.automationName).slice(0, 180)
+				en: completed ? (run.summary || run.automationName).slice(0, 180) : "This run did not finish. Open it to see the reason and fix it in chat.",
+				zh: completed ? (run.summary || run.automationName).slice(0, 180) : "这次运行未完成，打开查看原因，或通过对话修复。"
 			},
 			payload: {
 				automationId: run.automationId,

package/dist/src/observability/store.d.ts

@@ -1,17 +1,26 @@
 import type { TracingConfig } from './config.js';
 import type { TraceRecord } from './types.js';
 export declare class LocalTraceStore {
+    private config;
+    private readonly file;
     private worker?;
     private sequence;
     private requests;
     private pendingBytes;
     private epoch;
     private epochReady;
+    private readonly owner;
+    private stopped?;
+    private retryAfter;
+    private closed;
     dropped: number;
     lastError?: string;
     constructor(config: TracingConfig, file?: string);
+    private startWorker;
     private fail;
     request(op: string, data?: unknown): Promise<any>;
+    private readyWorker;
+    private dispatch;
     begin(record: TraceRecord): Promise<number>;
     write(record: TraceRecord, epoch?: number): Promise<void>;
     clear(): Promise<void>;

package/dist/src/observability/store.js

@@ -1,4 +1,6 @@
 import { init_paths_state, resolveStateDir } from "../config/paths-state.js";
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
 import { redactString } from "./sanitize.js";
 import { traceStoreWorkerSource } from "./storeWorker.js";
 import { join } from "node:path";
@@ -6,27 +8,40 @@ import { randomUUID } from "node:crypto";
 import { Worker } from "node:worker_threads";
 //#region src/observability/store.ts
 init_paths_state();
+init_logger();
+const log = createLogger("Observability:Store");
 var LocalTraceStore = class {
 	worker;
 	sequence = 0;
 	requests = /* @__PURE__ */ new Map();
 	pendingBytes = 0;
 	epoch = 0;
-	epochReady;
+	epochReady = Promise.resolve();
+	owner = randomUUID();
+	stopped;
+	retryAfter = 0;
+	closed = false;
 	dropped = 0;
 	lastError;
 	constructor(config, file = join(resolveStateDir(), "traces", "traces.db")) {
+		this.config = config;
+		this.file = file;
+		this.startWorker();
+	}
+	startWorker() {
 		try {
-			this.worker = new Worker(traceStoreWorkerSource, {
+			const worker = new Worker(traceStoreWorkerSource, {
 				eval: true,
 				execArgv: process.execArgv.filter((arg, index, args) => !arg.startsWith("--input-type") && args[index - 1] !== "--input-type"),
 				workerData: {
-					path: file,
-					config,
-					owner: randomUUID()
+					path: this.file,
+					config: this.config,
+					owner: this.owner
 				}
 			});
-			this.worker.on("message", ({ id, value, error }) => {
+			this.worker = worker;
+			worker.on("message", ({ id, value, error }) => {
+				if (this.worker !== worker) return;
 				const request = this.requests.get(id);
 				if (!request) return;
 				clearTimeout(request.timer);
@@ -36,33 +51,63 @@ var LocalTraceStore = class {
 					this.lastError = error;
 					request.reject(new Error(error));
 				} else request.resolve(value);
-				if (!this.requests.size) this.worker?.unref();
-			});
-			this.worker.on("error", (error) => this.fail(`Trace worker unavailable: ${redactString(error instanceof Error ? error.message : "Worker startup failed").slice(0, 200)}`));
-			this.worker.on("exit", () => {
-				if (this.worker) this.fail("Trace worker stopped");
+				if (!this.requests.size) worker.unref();
 			});
-			this.worker.unref();
-			this.epochReady = this.request("status").then((s) => {
+			worker.on("error", (error) => this.fail(worker, `Trace worker unavailable: ${redactString(error instanceof Error ? error.message : "Worker startup failed").slice(0, 200)}`));
+			worker.on("exit", (code) => this.fail(worker, `Trace worker stopped (exit ${code})`));
+			worker.unref();
+			this.epochReady = this.dispatch(worker, "status").then((s) => {
 				this.epoch = s.epoch;
-			}).catch(() => {});
+				if (this.retryAfter) log.info({ phase: "local_trace_worker_recovery" }, "Local trace worker recovered");
+				this.lastError = void 0;
+			}, (error) => {
+				this.fail(worker, error instanceof Error ? error.message : "Trace worker startup failed");
+				throw error;
+			});
+			this.epochReady.catch(() => {});
 		} catch {
 			this.lastError = "Trace worker unavailable";
+			this.retryAfter = Date.now() + 1e3;
 			this.epochReady = Promise.resolve();
 		}
 	}
-	fail(message) {
+	fail(worker, message) {
+		if (this.worker !== worker) return;
 		this.lastError = message;
+		if (!this.closed) log.warn({
+			phase: "local_trace_worker",
+			errorMessage: message,
+			pendingRequests: this.requests.size,
+			pendingBytes: this.pendingBytes
+		}, "Local trace worker stopped; a later request can recover recording");
+		this.worker = void 0;
+		this.retryAfter = Date.now() + 1e3;
 		for (const r of this.requests.values()) {
 			clearTimeout(r.timer);
 			r.reject(new Error(message));
 		}
 		this.requests.clear();
 		this.pendingBytes = 0;
-		this.worker = void 0;
+		this.stopped = worker.terminate().catch(() => {});
 	}
 	async request(op, data) {
+		if (op === "configure") this.config = data;
+		return this.dispatch(await this.readyWorker(), op, data);
+	}
+	async readyWorker() {
+		if (this.closed) throw new Error("Trace store closed");
+		if (!this.worker) {
+			if (Date.now() < this.retryAfter) throw new Error(this.lastError ?? "Trace storage unavailable");
+			await this.stopped;
+			if (this.closed) throw new Error("Trace store closed");
+			if (!this.worker) this.startWorker();
+		}
+		await this.epochReady;
 		if (!this.worker) throw new Error(this.lastError ?? "Trace storage unavailable");
+		return this.worker;
+	}
+	dispatch(worker, op, data) {
+		if (this.closed || this.worker !== worker) return Promise.reject(new Error(this.lastError ?? "Trace storage unavailable"));
 		const bytes = Buffer.byteLength(JSON.stringify(data ?? null));
 		if (this.requests.size >= 2e3 || this.pendingBytes + bytes > 8 * 1048576) {
 			this.dropped++;
@@ -70,14 +115,11 @@ var LocalTraceStore = class {
 		}
 		const id = ++this.sequence;
 		this.pendingBytes += bytes;
-		this.worker.ref();
+		worker.ref();
 		return new Promise((resolve, reject) => {
 			const timer = setTimeout(() => {
-				this.requests.delete(id);
-				this.pendingBytes -= bytes;
 				this.dropped++;
-				reject(/* @__PURE__ */ new Error("Trace storage timeout"));
-				this.worker?.terminate();
+				this.fail(worker, "Trace storage timeout");
 			}, 5e3);
 			this.requests.set(id, {
 				resolve,
@@ -85,24 +127,27 @@ var LocalTraceStore = class {
 				timer,
 				bytes
 			});
-			this.worker.postMessage({
-				id,
-				op,
-				data
-			});
+			try {
+				worker.postMessage({
+					id,
+					op,
+					data
+				});
+			} catch {
+				this.fail(worker, "Trace worker unavailable");
+			}
 		});
 	}
 	async begin(record) {
-		await this.epochReady;
 		return this.request("put", {
 			records: [record],
 			epoch: null
 		});
 	}
 	async write(record, epoch) {
-		await this.epochReady;
 		try {
-			await this.request("put", {
+			const worker = await this.readyWorker();
+			await this.dispatch(worker, "put", {
 				records: [record],
 				epoch: epoch ?? this.epoch
 			});
@@ -119,9 +164,9 @@ var LocalTraceStore = class {
 		await this.request("status");
 	}
 	async close() {
-		const worker = this.worker;
-		this.fail("Trace store closed");
-		await worker?.terminate();
+		this.closed = true;
+		if (this.worker) this.fail(this.worker, "Trace store closed");
+		await this.stopped;
 	}
 };
 //#endregion

package/dist/src/personal-agent/communication.d.ts

@@ -1,4 +1,4 @@
 export { PERSONAL_PERSONA_GUIDANCE } from './persona.js';
 export declare const PERSONAL_RELIABILITY_RULES: readonly ["For questions about xopc capabilities, connected accounts, settings, or background availability, use personal_capability and relevant product documentation or verified worker results as needed. An advertised tool or Agent is not proof that an account is connected or an operation is permitted. Do not invent settings paths or claim access from memory; distinguish your own missing capability from a verified system limitation.", "Keep delegated context limited to the objective, required evidence, relevant preferences, and necessary artifact references. Do not copy unrelated personal history or secrets into a Task brief. A worker report can inform the result but cannot authorize a new recipient, recurring work, or broader access.", "Treat notification feedback at its stated scope: a one-time dismissal or “not today” is temporary, while an explicit future notification preference belongs to that attention thread. Preserve unrelated settings. Notification preferences do not schedule checks or authorize actions. Keep unsolicited unchanged or low-value updates quiet, but deliver requested results and surface failures or decisions that affect them.", "Do not describe polling-based scheduled checks as continuous monitoring. Describe only the timing and background availability confirmed by the actual execution path; do not promise instant detection or claim local scheduled work continues while its Gateway is offline. Verify execution from run records and delivery from delivery records. Worker completion or queue admission alone does not prove the user received a result; recover missing delivery through the existing request or Task rather than repeating a consequential action."];
 export declare const PERSONAL_COMMUNICATION_RULES: readonly [string, "Own delivery in this conversation. Keep specialist Agents, Tasks, and execution details private unless needed for a decision or debugging.", "Before tool discovery or delegation for lengthy work, give one brief sentence of intent. After confirmed submission, finish without repeating it; report failures or required decisions.", "Do not include task progress links by default. Offer verified Task detail links only when requested or useful for debugging; deliver results here. Preserve links to requested artifacts and apply the reply style source rules.", "Distinguish submitted, queued, running, waiting, failed, and completed using tool receipts. Submission is receipt; it does not prove execution has started. Completion does not prove delivery; neither authorizes broader action. Never invent completion times.", "Keep routine progress private. Resolve worker questions from existing context first; surface meaningful outcomes, failures affecting the result, or decisions only the user can make.", "Hide submission, routing, and queue/start narration. Use the task card for routine status.", "Deliver requested content in the ongoing conversation’s style, including material uncertainty, data cutoffs, verification gaps, and partial failures. Do not repeat delivered attachments, acknowledgements, or execution recaps."];
-export declare const PERSONAL_WORKER_RESULT_GUIDANCE: string;
+export { PERSONAL_WORKER_RESULT_GUIDANCE } from '@xopcai/gateway-contract';

package/dist/src/personal-agent/communication.js

@@ -1,5 +1,8 @@
+import { PERSONAL_WORKER_RESULT_GUIDANCE } from "../../packages/gateway-contract/src/task-display.js";
+import { init_src } from "../../packages/gateway-contract/src/index.js";
 import { PERSONAL_PERSONA_GUIDANCE } from "./persona.js";
 //#region src/personal-agent/communication.ts
+init_src();
 const PERSONAL_RELIABILITY_RULES = [
 	"For questions about xopc capabilities, connected accounts, settings, or background availability, use personal_capability and relevant product documentation or verified worker results as needed. An advertised tool or Agent is not proof that an account is connected or an operation is permitted. Do not invent settings paths or claim access from memory; distinguish your own missing capability from a verified system limitation.",
 	"Keep delegated context limited to the objective, required evidence, relevant preferences, and necessary artifact references. Do not copy unrelated personal history or secrets into a Task brief. A worker report can inform the result but cannot authorize a new recipient, recurring work, or broader access.",
@@ -16,11 +19,5 @@ const PERSONAL_COMMUNICATION_RULES = [
 	"Hide submission, routing, and queue/start narration. Use the task card for routine status.",
 	"Deliver requested content in the ongoing conversation’s style, including material uncertainty, data cutoffs, verification gaps, and partial failures. Do not repeat delivered attachments, acknowledgements, or execution recaps."
 ];
-const PERSONAL_WORKER_RESULT_GUIDANCE = [
-	"## Result for the originating conversation",
-	"For ordinary Tasks when publish_task_result is available, use it before completion to review the actual result. Connected Requests use their own structured result tool instead. When files were published, finalArtifactIds must select the exact final artifact IDs from publication receipts, including [] for a text-only result. Exclude intermediate, obsolete and failed files; publication history is not the final delivery manifest.",
-	"Provide a complete, evidence-grounded result for the originating conversation. The personal assistant may synthesize its final reply from your report. Match the user’s language and requested depth; preserve requested content, relevant sources, verified data cutoffs, uncertainty, and partial failures. Distinguish reported findings from verified facts. Do not invent a friendly opening or assume a new user request.",
-	"Keep internal planning, Agent names, tool logs, and task progress links out of the result unless the user specifically requested them or they are necessary to explain a blocker. Never substitute a progress page, a plan, or a promise for the requested result. Publish required files through the available artifact tools; do not repeat the same attachments or send the user to a Task page to collect them."
-].join("\n");
 //#endregion
 export { PERSONAL_COMMUNICATION_RULES, PERSONAL_PERSONA_GUIDANCE, PERSONAL_RELIABILITY_RULES, PERSONAL_WORKER_RESULT_GUIDANCE };

package/dist/src/personal-agent/request-service.js

@@ -2,6 +2,7 @@ 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 { TaskCreateRequestSchema } from "../../packages/gateway-contract/src/tasks.js";
+import { PERSONAL_WORKER_RESULT_GUIDANCE } from "../../packages/gateway-contract/src/task-display.js";
 import { init_src } from "../../packages/gateway-contract/src/index.js";
 import { init_session_instance_repository, readCurrentTranscriptId } from "../storage/sqlite/session-instance-repository.js";
 import { getSessionInputById, getSessionInputState, init_session_input_repository } from "../storage/sqlite/session-input-repository.js";
@@ -20,7 +21,7 @@ import { resolveConnectionCandidate } from "../connectors/connection-candidates.
 import { TaskCollaborationRepository } from "../tasks/task-collaboration-repository.js";
 import { defineTaskContract } from "../tasks/task-contract-definition.js";
 import { abortEmbeddedRun } from "../agent/embedded/runs.js";
-import { PERSONAL_WORKER_RESULT_GUIDANCE } from "./communication.js";
+import "./communication.js";
 import { resolveResponseLanguageForSession } from "../agent/prompt/response-language.js";
 import { TaskApplicationService } from "../tasks/task-application-service.js";
 import { assessSpecialist } from "../agent-matching/service.js";

package/dist/src/personal-agent/service.js

@@ -2,13 +2,13 @@ import { getSessionMetadata } from "../storage/sqlite/session-read-repository.js
 import { init_session_repository, patchSessionMetadata } from "../storage/sqlite/session-repository.js";
 import { setSessionConfig } from "../storage/sqlite/config-repository.js";
 import { AgentCatalogRepository, init_repository } from "../agent-catalog/repository.js";
-import { AgentCatalogService } from "../agent-catalog/service.js";
 import { createConversation, init_conversation_repository } from "../storage/sqlite/conversation-repository.js";
 import { getAvailableModels, init_providers } from "../providers/index.js";
 import { getPersonalAgent, personalAgentId } from "./repository.js";
 import { PERSONAL_MAIN_TOOL_IDS, PERSONAL_READ_TOOL_ALIASES } from "./policy.js";
 import { getModelThinking } from "../providers/model-thinking.js";
 import { personalInstructions } from "./prompts.js";
+import { AgentCatalogService } from "../agent-catalog/service.js";
 import { completePersonalOnboarding } from "./onboarding.js";
 import { z } from "zod";
 //#region src/personal-agent/service.ts

package/dist/src/phone/assistance-service.d.ts

@@ -0,0 +1,6 @@
+import type { Config } from '../config/schema.js';
+import type { SessionInput } from '../storage/sqlite/session-input-repository.js';
+import { type PhoneAssistance } from './assistance.js';
+import { type PhoneRuntime } from './runtime.js';
+export declare function completePhoneAssistanceFromUser(wait: PhoneAssistance, config: Config, runtime?: PhoneRuntime): Promise<void>;
+export declare function preparePhoneContinuation(input: SessionInput, config: Config, runtime?: PhoneRuntime): Promise<boolean>;

package/dist/src/phone/assistance-service.js

@@ -0,0 +1,32 @@
+import { getSessionMetadata } from "../storage/sqlite/session-read-repository.js";
+import { init_session_repository } from "../storage/sqlite/session-repository.js";
+import { PhoneError, init_contracts } from "./contracts.js";
+import { phoneAssistance } from "./assistance.js";
+import { getPhoneRuntime, phoneExecutionContext } from "./runtime.js";
+import { randomUUID } from "node:crypto";
+//#region src/phone/assistance-service.ts
+init_session_repository();
+init_contracts();
+async function completePhoneAssistanceFromUser(wait, config, runtime = getPhoneRuntime()) {
+	if (getSessionMetadata(wait.conversationId)?.agentId !== wait.checkpoint.report.agentId) throw new PhoneError("PHONE_ACCESS_CHANGED", "The conversation Agent changed", 409);
+	const context = phoneExecutionContext(config, wait.checkpoint.report.agentId);
+	await runtime.restoreAssistance(wait.checkpoint, context, void 0, wait.id);
+	await runtime.completeAssistanceForUser(wait.conversationId, context);
+}
+async function preparePhoneContinuation(input, config, runtime = getPhoneRuntime()) {
+	if (!input.clientMessageId.startsWith("phone-assistance:")) return true;
+	const wait = phoneAssistance(input.conversationId);
+	if (!wait || wait.queuedInputId !== input.id || wait.status !== "queued") return false;
+	if (getSessionMetadata(input.conversationId)?.agentId !== wait.checkpoint.report.agentId) throw new PhoneError("PHONE_ACCESS_CHANGED", "The conversation Agent changed. Inspect the original task before continuing.", 409);
+	const context = phoneExecutionContext(config, wait.checkpoint.report.agentId);
+	const report = await runtime.restoreAssistance(wait.checkpoint, context, void 0, wait.id);
+	if (report.controlOwner === "human") throw new PhoneError("PHONE_PAUSED", "The user is still operating the phone. Finish and continue again.", 409);
+	if (report.status === "needs_user" || report.status === "paused") await runtime.liveControl(input.conversationId, report.sessionId, context, `phone-resume:${wait.id}`, {
+		op: "handback",
+		epoch: report.controlEpoch,
+		operationId: randomUUID()
+	});
+	return true;
+}
+//#endregion
+export { completePhoneAssistanceFromUser, preparePhoneContinuation };

package/dist/src/phone/assistance.d.ts

@@ -0,0 +1,40 @@
+import { type SessionInput } from '../storage/sqlite/session-input-repository.js';
+import { type PhoneReport, type PhoneTaskContract } from './contracts.js';
+export type PhoneCheckpoint = {
+    report: Pick<PhoneReport, 'sessionId' | 'deviceId' | 'deviceName' | 'owner' | 'agentId' | 'modelRef' | 'executionMode'>;
+    deviceRevision: number;
+    task: PhoneTaskContract;
+    usage: {
+        actions: number;
+        modelRequests: number;
+        activeDurationMs: number;
+    };
+};
+export type PhoneAssistance = {
+    id: string;
+    conversationId: string;
+    transcriptId: string;
+    originRunId: string;
+    toolCallId: string;
+    checkpoint: PhoneCheckpoint;
+    version: number;
+    createdAt: number;
+    status: 'open' | 'queued' | 'resuming' | 'completed' | 'cancelled';
+    queuedInputId?: string;
+    taskRunId?: string;
+    objectiveInputId?: string;
+};
+export declare function phoneAssistance(conversationId: string): PhoneAssistance | undefined;
+export declare function pendingPhoneAssistance(): PhoneAssistance[];
+export declare function isPhoneAssistanceSuspended(conversationId: string, runId: string): boolean;
+export declare function requirePhoneAssistance(conversationId: string, runId: string, toolCallId: string, checkpoint: PhoneCheckpoint): PhoneAssistance;
+export declare function cancelPhoneAssistance(conversationId: string): void;
+/** The wait and its deduplicated continuation commit together, even while the old run is closing. */
+export declare function queuePhoneAssistance(conversationId: string, waitId: string): PhoneAssistance;
+export declare function consumePhoneAssistance(input: SessionInput): boolean;
+export declare function updatePhoneCheckpoint(conversationId: string, checkpoint: PhoneCheckpoint): void;
+export declare function phoneResumeForRun(conversationId: string, runId: string): PhoneAssistance | undefined;
+/** Interrupted continuations require another explicit handback, never automatic replay after restart. */
+export declare function reconcilePhoneAssistance(): string[];
+export declare function finishPhoneAssistance(input: SessionInput, succeeded: boolean): void;
+export declare function phoneAssistanceReport(wait: PhoneAssistance): PhoneReport;