@xopcai/xopc 0.0.412 → 0.0.414

package/dist/src/gateway/hono/routes/phone.js

@@ -0,0 +1,466 @@
+import { createLogger } from "../../../utils/logger/index.js";
+import { init_logger } from "../../../utils/logger.js";
+import { MOCK_PHONE_MODEL, PhoneActionSchema, PhoneConfigSchema, PhoneDeviceSchema, PhoneError, PhoneInputSchema, init_contracts } from "../../../phone/contracts.js";
+import { getDefaultAgentId, init_resolve_route } from "../../../routing/resolve-route.js";
+import { getModelRegistry, init_model_registry } from "../../../providers/model-registry.js";
+import { init_providers, isProviderConfiguredSync } from "../../../providers/index.js";
+import { normalizePhoneAppAccess, phoneAppAccess } from "../../../phone/app-access.js";
+import { createPhoneModel, phoneModelProfile } from "../../../phone/model-adapter.js";
+import { getPhoneRuntime, phoneExecutionContext } from "../../../phone/runtime.js";
+import { getGatewayPrincipal } from "../../security/gateway-principal.js";
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { Hono } from "hono";
+import { bodyLimit } from "hono/body-limit";
+//#region src/gateway/hono/routes/phone.ts
+init_resolve_route();
+init_model_registry();
+init_providers();
+init_contracts();
+init_logger();
+const log = createLogger("Hono:Phone");
+const deviceInput = PhoneDeviceSchema.omit({
+	id: true,
+	createdAt: true,
+	revision: true,
+	connection: true
+});
+function registerPhoneRoutes(parent, deps, runtime = getPhoneRuntime()) {
+	const app = new Hono();
+	app.onError((error, c) => {
+		const code = error instanceof PhoneError ? error.code : error instanceof z.ZodError ? "PHONE_INVALID_INPUT" : "PHONE_OPERATION_FAILED";
+		if (!(error instanceof PhoneError) && !(error instanceof z.ZodError)) log.warn({
+			phase: "phone_route",
+			errorCode: code
+		}, "Phone operation failed");
+		return c.json({
+			ok: false,
+			error: {
+				code,
+				message: error instanceof PhoneError ? error.message : error instanceof z.ZodError ? "Invalid phone request" : "Phone operation failed. Check device diagnostics."
+			}
+		}, error instanceof PhoneError ? error.status : error instanceof z.ZodError ? 400 : 500);
+	});
+	const { service, strictRateLimitMiddleware } = deps;
+	app.use("/api/phone/*", async (c, next) => {
+		const principal = getGatewayPrincipal(c);
+		if (principal.kind !== "owner" && principal.kind !== "trusted-proxy" || !principal.scopes.includes("gateway.admin")) return c.json({
+			ok: false,
+			error: {
+				code: "PHONE_ADMIN_REQUIRED",
+				message: "Phone settings require Gateway administrator access"
+			}
+		}, 403);
+		return next();
+	});
+	app.use("/api/phone/cloud/aliyun/*", bodyLimit({
+		maxSize: 24 * 1024,
+		onError: (c) => c.json({
+			ok: false,
+			error: {
+				code: "PHONE_UPLOAD_TOO_LARGE",
+				message: "Phone key upload exceeds 24 KB"
+			}
+		}, 413)
+	}));
+	app.post("/api/phone/cloud/aliyun/test", strictRateLimitMiddleware, async (c) => {
+		const input = z.object({
+			endpoint: z.string().max(200),
+			privateKey: z.string().max(16384)
+		}).strict().parse(await c.req.json());
+		const payload = await runtime.cloud.test(getGatewayPrincipal(c).principalId, input.endpoint, input.privateKey, c.req.raw.signal);
+		c.header("Cache-Control", "no-store");
+		return c.json({
+			ok: true,
+			payload
+		});
+	});
+	app.post("/api/phone/cloud/aliyun/add", strictRateLimitMiddleware, async (c) => {
+		const input = z.object({
+			token: z.string().uuid(),
+			name: z.string().trim().min(1).max(100),
+			makeDefault: z.boolean().default(false)
+		}).strict().parse(await c.req.json());
+		const payload = await runtime.cloud.add(getGatewayPrincipal(c).principalId, input.token, input.name, input.makeDefault);
+		c.header("Cache-Control", "no-store");
+		return c.json({
+			ok: true,
+			payload
+		}, 201);
+	});
+	app.delete("/api/phone/cloud/aliyun/tests/:token", (c) => {
+		runtime.cloud.cancel(getGatewayPrincipal(c).principalId, z.string().uuid().parse(c.req.param("token")));
+		return c.json({ ok: true });
+	});
+	app.get("/api/phone/settings", (c) => c.json({
+		ok: true,
+		payload: {
+			config: service.currentConfig.phone,
+			defaultDeviceId: runtime.repository.defaultDevice(),
+			runner: "gateway-local",
+			agentId: getDefaultAgentId()
+		}
+	}));
+	app.patch("/api/phone/settings", strictRateLimitMiddleware, async (c) => {
+		const config = PhoneConfigSchema.parse(await c.req.json());
+		await runtime.shutdown();
+		const next = structuredClone(service.currentConfig);
+		next.phone = config;
+		if (!(await service.saveConfig(next)).saved) throw new PhoneError("PHONE_CONFIG_SAVE_FAILED", "Unable to save Phone Use settings");
+		return c.json({
+			ok: true,
+			payload: { config }
+		});
+	});
+	app.get("/api/phone/devices", async (c) => {
+		let discovery = [];
+		let diagnostic;
+		try {
+			discovery = await runtime.discover(service.currentConfig, c.req.raw.signal);
+		} catch (error) {
+			diagnostic = error instanceof PhoneError ? error.code : "PHONE_ADB_UNAVAILABLE";
+		}
+		return c.json({
+			ok: true,
+			payload: {
+				devices: runtime.repository.list(),
+				discovery,
+				diagnostic,
+				defaultDeviceId: runtime.repository.defaultDevice()
+			}
+		});
+	});
+	app.get("/api/phone/apps", async (c) => {
+		const input = z.object({ serial: z.string().min(1).max(200) }).strict().parse(c.req.query());
+		const applications = await runtime.applications(input, service.currentConfig, c.req.raw.signal);
+		c.header("Cache-Control", "no-store");
+		return c.json({
+			ok: true,
+			payload: { applications }
+		});
+	});
+	app.get("/api/phone/devices/:id/apps", async (c) => {
+		const applications = await runtime.applications({ deviceId: c.req.param("id") }, service.currentConfig, c.req.raw.signal);
+		c.header("Cache-Control", "no-store");
+		return c.json({
+			ok: true,
+			payload: { applications }
+		});
+	});
+	app.post("/api/phone/devices", strictRateLimitMiddleware, async (c) => {
+		const input = deviceInput.parse(await c.req.json());
+		if (!(await runtime.discover(service.currentConfig, c.req.raw.signal)).some((device) => device.serial === input.serial && device.state === "device")) throw new PhoneError("PHONE_DEVICE_OFFLINE", "Choose a connected and authorized ADB device");
+		const device = runtime.repository.save(input);
+		if (!runtime.repository.defaultDevice()) runtime.repository.setDefault(device.id);
+		return c.json({
+			ok: true,
+			payload: device
+		}, 201);
+	});
+	app.patch("/api/phone/devices/:id", strictRateLimitMiddleware, async (c) => {
+		const id = c.req.param("id");
+		const previous = runtime.repository.get(id);
+		const patch = deviceInput.omit({ serial: true }).partial().parse(await c.req.json());
+		const next = normalizePhoneAppAccess({
+			...previous,
+			...patch,
+			...patch.allowedApps && patch.appAccess === void 0 ? { appAccess: "selected" } : {}
+		});
+		await runtime.stopDevice(id);
+		return c.json({
+			ok: true,
+			payload: runtime.repository.save(next, id)
+		});
+	});
+	app.delete("/api/phone/devices/:id", strictRateLimitMiddleware, async (c) => {
+		const id = c.req.param("id");
+		const device = runtime.repository.get(id);
+		await runtime.stopDevice(id);
+		await runtime.cloud.remove(device);
+		runtime.repository.remove(id);
+		return c.json({ ok: true });
+	});
+	app.post("/api/phone/devices/:id/default", strictRateLimitMiddleware, (c) => {
+		runtime.repository.setDefault(c.req.param("id"));
+		return c.json({ ok: true });
+	});
+	app.post("/api/phone/devices/:id/diagnostics", strictRateLimitMiddleware, async (c) => {
+		const device = runtime.repository.get(c.req.param("id"));
+		const found = (await (await runtime.driverFor(device, service.currentConfig)).discover(c.req.raw.signal)).find((item) => item.serial === device.serial);
+		return c.json({
+			ok: true,
+			payload: {
+				state: found?.state ?? "disconnected",
+				emulator: found?.emulator ?? false,
+				runner: "gateway-local",
+				appAccess: phoneAppAccess(device),
+				allowedApps: device.allowedApps
+			}
+		});
+	});
+	app.get("/api/phone/devices/:id/screen", async (c) => {
+		const observation = await runtime.preview(c.req.param("id"), service.currentConfig, c.req.raw.signal);
+		const bytes = Uint8Array.from(observation.frame);
+		observation.frame.fill(0);
+		c.header("Cache-Control", "no-store");
+		c.header("Content-Type", "image/png");
+		c.header("X-Content-Type-Options", "nosniff");
+		return c.body(bytes);
+	});
+	app.get("/api/phone/models", (c) => c.json({
+		ok: true,
+		payload: { models: [{
+			id: MOCK_PHONE_MODEL,
+			name: "Mock · Android Settings test",
+			profile: "mock-settings-about",
+			mock: true,
+			configured: true
+		}, ...getModelRegistry().getAll().flatMap((model) => {
+			const profile = phoneModelProfile(model);
+			return profile ? [{
+				id: `${model.provider}/${model.id}`,
+				name: model.name,
+				profile,
+				mock: false,
+				configured: isProviderConfiguredSync(model.provider)
+			}] : [];
+		})] }
+	}));
+	app.post("/api/phone/models/diagnostics", strictRateLimitMiddleware, async (c) => {
+		const body = z.object({
+			modelRef: z.string().min(1),
+			agentId: z.string().optional()
+		}).strict().parse(await c.req.json());
+		const adapter = await createPhoneModel(body.modelRef, service.currentConfig, body.agentId ?? getDefaultAgentId());
+		const { default: sharp } = await import("sharp");
+		const frame = await sharp(Buffer.from("<svg width=\"600\" height=\"1000\" xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"600\" height=\"1000\" fill=\"white\"/><text x=\"60\" y=\"100\" font-size=\"26\">Phone Use connection test</text><rect x=\"100\" y=\"400\" width=\"400\" height=\"160\" fill=\"#2563eb\"/><text x=\"200\" y=\"495\" font-size=\"36\" fill=\"white\">Continue</text></svg>")).png().toBuffer();
+		try {
+			const decision = await adapter.predict({
+				goal: "Tap the blue Continue button. This is a synthetic test image; no phone action will be executed.",
+				allowedApps: ["com.android.settings"],
+				history: [],
+				scenario: body.modelRef === "phone-mock/settings-about" ? "settings-about" : void 0,
+				observation: {
+					frameId: randomUUID(),
+					capturedAt: Date.now(),
+					width: 600,
+					height: 1e3,
+					rotation: 0,
+					package: "com.android.settings",
+					frame,
+					elements: []
+				}
+			}, c.req.raw.signal);
+			const grounded = decision.kind === "action" && decision.action.type === "tap" && decision.action.point[0] >= 167 && decision.action.point[0] <= 833 && decision.action.point[1] >= 400 && decision.action.point[1] <= 560;
+			return c.json({
+				ok: true,
+				payload: {
+					protocolValid: true,
+					groundingVerified: grounded,
+					mock: body.modelRef === MOCK_PHONE_MODEL,
+					deviceActions: 0
+				}
+			});
+		} finally {
+			frame.fill(0);
+		}
+	});
+	const liveClient = z.string().uuid();
+	const liveControlInput = z.object({
+		clientId: liveClient,
+		operationId: z.string().uuid(),
+		epoch: z.number().int().positive(),
+		op: z.enum([
+			"takeover",
+			"release",
+			"handback",
+			"pause",
+			"cancel",
+			"heartbeat",
+			"input",
+			"recover"
+		]),
+		frameSeq: z.number().int().positive().optional(),
+		geometry: z.number().int().positive().optional(),
+		action: PhoneActionSchema.optional()
+	}).strict();
+	async function conversationPhone(conversationId, requestedSessionId) {
+		z.string().uuid().parse(conversationId);
+		const conversation = await service.sessions.getSession(conversationId);
+		if (!conversation) throw new PhoneError("PHONE_CONVERSATION_NOT_FOUND", "Conversation not found", 404);
+		const report = runtime.status(conversationId);
+		if (requestedSessionId && report?.sessionId !== requestedSessionId) throw new PhoneError("PHONE_SESSION_NOT_FOUND", "Phone session not found", 404);
+		if (report && report.agentId !== conversation.agentId) throw new PhoneError("PHONE_ACCESS_CHANGED", "Conversation Agent changed", 403);
+		return {
+			report,
+			transcriptId: conversation.transcriptId,
+			context: phoneExecutionContext(service.currentConfig, conversation.agentId)
+		};
+	}
+	app.get("/api/phone/conversations/:conversationId", async (c) => {
+		const owner = c.req.param("conversationId");
+		const client = liveClient.parse(c.req.query("clientId"));
+		const { report, context } = await conversationPhone(owner);
+		c.header("Cache-Control", "no-store");
+		return c.json({
+			ok: true,
+			payload: report ? runtime.liveStatus(owner, report.sessionId, context, `${getGatewayPrincipal(c).principalId}:${client}`) : null
+		});
+	});
+	app.get("/api/phone/conversations/:conversationId/:sessionId/frame", async (c) => {
+		const owner = c.req.param("conversationId");
+		const id = c.req.param("sessionId");
+		const { context } = await conversationPhone(owner, id);
+		const frame = await runtime.liveFrame(owner, id, context, c.req.raw.signal);
+		c.header("Cache-Control", "no-store");
+		c.header("Content-Type", "image/png");
+		c.header("X-Content-Type-Options", "nosniff");
+		c.header("X-Phone-Frame-Seq", String(frame.seq));
+		c.header("X-Phone-Captured-At", String(frame.capturedAt));
+		c.header("X-Phone-Width", String(frame.width));
+		c.header("X-Phone-Height", String(frame.height));
+		c.header("X-Phone-Rotation", String(frame.rotation));
+		const bytes = Uint8Array.from(frame.frame);
+		frame.frame.fill(0);
+		return c.body(bytes);
+	});
+	app.post("/api/phone/conversations/:conversationId/:sessionId/video-ticket", strictRateLimitMiddleware, async (c) => {
+		const owner = c.req.param("conversationId");
+		const id = c.req.param("sessionId");
+		const { clientId } = z.object({ clientId: liveClient }).strict().parse(await c.req.json());
+		await conversationPhone(owner, id);
+		const principal = getGatewayPrincipal(c);
+		const client = `${principal.principalId}:${clientId}`;
+		const validate = async () => {
+			const { context } = await conversationPhone(owner, id);
+			runtime.liveStatus(owner, id, context, client);
+		};
+		const issued = service.phoneStreams.issue({
+			origin: new URL(c.req.url).origin,
+			principal: principal.principalId,
+			client,
+			validate,
+			connect: async () => {
+				const { context } = await conversationPhone(owner, id);
+				return runtime.liveVideo(owner, id, context);
+			},
+			disconnect: () => runtime.disconnectVideo(owner, id, client)
+		});
+		c.header("Cache-Control", "no-store");
+		return c.json({
+			ok: true,
+			payload: {
+				...issued,
+				transport: "scrcpy-h264",
+				protocolVersion: 1
+			}
+		});
+	});
+	app.post("/api/phone/conversations/:conversationId/:sessionId/control", async (c) => {
+		const owner = c.req.param("conversationId");
+		const id = c.req.param("sessionId");
+		const { context, transcriptId } = await conversationPhone(owner, id);
+		const { clientId, ...input } = liveControlInput.parse(await c.req.json());
+		const result = await runtime.liveControl(owner, id, context, `${getGatewayPrincipal(c).principalId}:${clientId}`, input);
+		if (input.op === "handback" && result.resumeTurnRequired && !service.sessions.getActiveRun(owner).active) {
+			if (!(await service.submitSessionInput({
+				conversationId: owner,
+				expectedTranscriptId: transcriptId,
+				clientMessageId: input.operationId,
+				delivery: "next",
+				content: "手机已交还，请先确认当前页面，继续未完成的任务；已完成的步骤不要重复，结束后关闭手机会话。",
+				origin: {
+					type: "system",
+					source: "internal"
+				}
+			})).ok) throw new PhoneError("PHONE_RESUME_FAILED", "Phone control returned. Send Continue in chat to resume the task.", 409);
+		}
+		c.header("Cache-Control", "no-store");
+		return c.json({
+			ok: true,
+			payload: result
+		});
+	});
+	const ownerFor = (principalId, id) => `phone-settings:${principalId}:${id}`;
+	app.get("/api/phone/sessions", (c) => c.json({
+		ok: true,
+		payload: {
+			sessions: runtime.reports(),
+			history: runtime.repository.history()
+		}
+	}));
+	app.post("/api/phone/sessions", strictRateLimitMiddleware, async (c) => {
+		const body = z.object({
+			deviceId: z.string().uuid().optional(),
+			agentId: z.string().optional(),
+			mode: z.enum(["observe", "control"]),
+			appPackage: z.string().optional()
+		}).strict().parse(await c.req.json());
+		const id = randomUUID();
+		const owner = ownerFor(getGatewayPrincipal(c).principalId, id);
+		const { agentId = getDefaultAgentId(), ...input } = body;
+		const report = await runtime.execute(owner, {
+			op: "open",
+			...input
+		}, phoneExecutionContext(service.currentConfig, agentId), c.req.raw.signal);
+		return c.json({
+			ok: true,
+			payload: {
+				id,
+				report
+			}
+		}, 201);
+	});
+	app.get("/api/phone/sessions/:id", (c) => {
+		const owner = ownerFor(getGatewayPrincipal(c).principalId, c.req.param("id"));
+		const report = runtime.status(owner);
+		if (!report) throw new PhoneError("PHONE_SESSION_NOT_FOUND", "Phone session not found", 404);
+		return c.json({
+			ok: true,
+			payload: report
+		});
+	});
+	app.get("/api/phone/sessions/:id/screen", async (c) => {
+		const owner = ownerFor(getGatewayPrincipal(c).principalId, c.req.param("id"));
+		const report = runtime.status(owner);
+		if (!report) throw new PhoneError("PHONE_SESSION_NOT_FOUND", "Phone session not found", 404);
+		const observation = await runtime.previewSession(owner, phoneExecutionContext(service.currentConfig, report.agentId), c.req.raw.signal);
+		const bytes = Uint8Array.from(observation.frame);
+		observation.frame.fill(0);
+		c.header("Cache-Control", "no-store");
+		c.header("Content-Type", "image/png");
+		c.header("X-Content-Type-Options", "nosniff");
+		return c.body(bytes);
+	});
+	app.post("/api/phone/sessions/:id/execute", strictRateLimitMiddleware, async (c) => {
+		const owner = ownerFor(getGatewayPrincipal(c).principalId, c.req.param("id"));
+		const report = runtime.status(owner);
+		if (!report) throw new PhoneError("PHONE_SESSION_NOT_FOUND", "Phone session not found", 404);
+		const input = PhoneInputSchema.parse(await c.req.json());
+		if (["open", "discover"].includes(input.op)) throw new PhoneError("PHONE_INVALID_OPERATION", "Use the phone discovery and session creation endpoints");
+		const operation = runtime.execute(owner, input, phoneExecutionContext(service.currentConfig, report.agentId));
+		if (input.op === "run" || input.op === "step") {
+			let immediateError;
+			operation.catch((error) => {
+				immediateError = error;
+				log.info({
+					sessionId: report.sessionId,
+					errorCode: error instanceof PhoneError ? error.code : "PHONE_OPERATION_FAILED"
+				}, "Phone execution stopped");
+			});
+			await Promise.resolve();
+			if (immediateError) throw immediateError;
+			return c.json({
+				ok: true,
+				payload: runtime.status(owner)
+			}, 202);
+		}
+		return c.json({
+			ok: true,
+			payload: await operation
+		});
+	});
+	parent.route("/", app);
+}
+//#endregion
+export { registerPhoneRoutes };

package/dist/src/gateway/hono/routes/runtime-tools.js

@@ -4,6 +4,7 @@ import { normalizeRuntimeVersionRequest } from "../../../runtime-tools/probe.js"
 import { ManagedRuntimeManager } from "../../../runtime-tools/manager.js";
 import { createGatewayRouteLogger } from "../lib/route-logger.js";
 import { pruneRuntimeTools } from "../../../runtime-tools/prune.js";
+import { registerPhoneDependencyRoutes } from "./phone-dependencies.js";
 import { streamSSE } from "hono/streaming";
 //#region src/gateway/hono/routes/runtime-tools.ts
 init_paths_state();
@@ -32,6 +33,7 @@ async function readJson(c) {
 }
 function registerRuntimeToolsRoutes(authenticated, deps) {
 	const { service, strictRateLimitMiddleware } = deps;
+	registerPhoneDependencyRoutes(authenticated, deps);
 	authenticated.get("/api/runtime-tools", async (c) => {
 		const statuses = await runtimeManager(service.currentConfig).statusAll();
 		return c.json({

package/dist/src/gateway/server.js

@@ -69,6 +69,7 @@ var GatewayServer = class {
 			inner.on("upgrade", (req, socket, head) => {
 				try {
 					if (this.service.voiceRealtime.handleUpgrade(req, socket, head)) return;
+					if (this.service.phoneStreams.handleUpgrade(req, socket, head)) return;
 					if (this.service.realtime.handleUpgrade(req, socket, head)) return;
 					if (handleSiteShareUpgrade(this.service, req, socket, head)) return;
 					socket.destroy();

package/dist/src/gateway/service/config-coordinator.d.ts

@@ -323,6 +323,14 @@ export declare class GatewayConfigCoordinator {
             maxSessionDurationMs: number;
             idleGrantTtlMs: number;
         };
+        phone: {
+            enabled: boolean;
+            maxActionsPerSession: number;
+            maxModelRequests: number;
+            maxOperationDurationMs: number;
+            maxSessionDurationMs: number;
+            adbPath?: string;
+        };
         tools: {
             web?: {
                 region?: "global" | "cn";

package/dist/src/gateway/service/config-coordinator.js

@@ -8,8 +8,8 @@ import { reloadImageGenerationProviders } from "../../agent/image/generation/pro
 import { loadConfig, saveConfig } from "../../config/loader.js";
 import { ConfigHotReloader } from "../../config/reload.js";
 import "../../config/index.js";
-import { computeExtensionActivationPatch } from "../../extensions/bundled-extension-activation.js";
 import { sanitizeTunnelConfig } from "../../tunnel/tunnel-config.js";
+import { computeExtensionActivationPatch } from "../../extensions/bundled-extension-activation.js";
 import { isDeepStrictEqual } from "node:util";
 //#region src/gateway/service/config-coordinator.ts
 /**

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

@@ -1,4 +1,5 @@
 import type { ClarificationSubmission } from '@xopcai/gateway-contract';
+import { PhoneStreamGateway } from '../phone/stream-gateway.js';
 import { WorkDiscoveryService } from '../work-discovery/service.js';
 import { ConnectionRecoveryService } from '../connectors/connection-recovery-service.js';
 import { AgentService } from '../agent/service.js';
@@ -55,6 +56,7 @@ export declare class GatewayService {
     readonly endpointTools: EndpointToolRuntime;
     private isRealtimePrincipalActive;
     readonly realtime: RealtimeRuntime;
+    readonly phoneStreams: PhoneStreamGateway;
     readonly voiceRealtime: VoiceRealtimeRuntime;
     getConfig(): Config;
     getModelCatalogSync(): ModelCatalogSyncService;

package/dist/src/gateway/service.js

@@ -32,8 +32,8 @@ import { getDefaultAgentId, init_resolve_route } from "../routing/resolve-route.
 import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
 import { prewarmModelRegistry } from "../providers/model-registry.js";
 import { init_providers, providers_exports } from "../providers/index.js";
-import { flushTracing } from "../observability/runtime.js";
 import { AI_USAGE_RETENTION_MS, markStaleAiUsageEventsUnknown, pruneAiUsageEvents } from "../storage/sqlite/ai-usage-repository.js";
+import { flushTracing } from "../observability/runtime.js";
 import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import { getPersonalAgentByConversation } from "../personal-agent/repository.js";
 import { onSessionTranscriptUpdate } from "../session/transcript-events.js";
@@ -87,6 +87,12 @@ import { ChatPreviewService } from "../chat-previews/service.js";
 import "../chat-previews/index.js";
 import { configureGatewayHttpProxy } from "../infra/http-proxy-env.js";
 import "../config/index.js";
+import { DiscussionService } from "../discussions/service.js";
+import { DiscussionOrganizer } from "../discussions/organizer.js";
+import { DiscussionLiveWorker } from "../discussions/live-worker.js";
+import { DiscussionOrganizerWorker } from "../discussions/organizer-worker.js";
+import { DiscussionSealer } from "../discussions/sealer.js";
+import "../discussions/index.js";
 import { ManagedComposioEventPoller } from "../connectors/composio-managed-events.js";
 import { startConnectedKnowledgeCoordinator } from "../knowledge/coordinator.js";
 import "../knowledge/index.js";
@@ -94,12 +100,6 @@ import { PersonalReplyComposer } from "../personal-agent/reply-composer.js";
 import { ConnectionRecoveryService } from "../connectors/connection-recovery-service.js";
 import { startConnectorLearningCoordinator } from "../connectors/learning-coordinator.js";
 import { startConnectorSupervisor } from "../connectors/supervisor.js";
-import { DiscussionService } from "../discussions/service.js";
-import { DiscussionOrganizer } from "../discussions/organizer.js";
-import { DiscussionLiveWorker } from "../discussions/live-worker.js";
-import { DiscussionOrganizerWorker } from "../discussions/organizer-worker.js";
-import { DiscussionSealer } from "../discussions/sealer.js";
-import "../discussions/index.js";
 import { EndpointToolRuntime } from "../endpoint-tools/runtime.js";
 import "../endpoint-tools/index.js";
 import { HomeCapabilityPreflightService } from "../home-intelligence/capability-preflight.js";
@@ -111,6 +111,7 @@ import { prepareAutomationAgentSession } from "./automation-agent-session.js";
 import { stopTailscaleExposure } from "./tailscale-lifecycle.js";
 import { getGatewayFileSpaceService } from "./file-space-service.js";
 import { reconcileHomeIntelligenceAutomation } from "./home-intelligence-automation-reconciler.js";
+import { PhoneStreamGateway } from "../phone/stream-gateway.js";
 import { PersonalProactivityService } from "../personal-agent/proactivity/service.js";
 import { reconcilePersonalProactivityAutomation } from "../personal-agent/proactivity/automation.js";
 import { createBackgroundTask } from "../infra/background-task.js";
@@ -220,6 +221,7 @@ var GatewayService = class {
 		}
 	};
 	realtime = new RealtimeRuntime(this.endpointTools, this.isRealtimePrincipalActive);
+	phoneStreams = new PhoneStreamGateway(this.isRealtimePrincipalActive);
 	voiceRealtime = new VoiceRealtimeRuntime({
 		isPrincipalActive: this.isRealtimePrincipalActive,
 		getConversationContext: async (conversationId, expectedTranscriptId) => {
@@ -1565,6 +1567,9 @@ var GatewayService = class {
 		await flushTracing();
 		if (!this.running) return;
 		this.stopping = true;
+		const { getPhoneRuntime } = await import("../phone/runtime.js");
+		await getPhoneRuntime().shutdown();
+		this.phoneStreams.close();
 		const { cancelAllPluginCliAuthorizations } = await import("../extensions/agent-plugins/cli-authorization.js");
 		cancelAllPluginCliAuthorizations();
 		this.taskAllocationDispatcher?.stop();

package/dist/src/infra/update-runner.js

@@ -1,5 +1,4 @@
 import { PACKAGE_VERSION, init_package_version } from "../package-version.js";
-import { runPostUpdateExtensionSync } from "../extensions/update.js";
 import "./update-channels.js";
 import { compareSemver, resolveNpmChannelTag } from "./update-check.js";
 import { readPackageName, readPackageVersion } from "./package-json.js";
@@ -9,6 +8,7 @@ import { runGlobalPackageUpdateSteps } from "./package-update-steps.js";
 import { resolveStableNodePath } from "./stable-node-path.js";
 import { trimLogTail } from "./update-log.js";
 import { maybeRestartGatewayAfterUpdate, prepareGatewayRestart } from "./update-restart.js";
+import { runPostUpdateExtensionSync } from "../extensions/update.js";
 import path from "node:path";
 import fs from "node:fs/promises";
 //#region src/infra/update-runner.ts

package/dist/src/knowledge-memory/repository.js

@@ -362,6 +362,11 @@ function deleteKnowledgeItem(id, now = Date.now(), options = {}) {
     ) SELECT * FROM knowledge_items WHERE knowledge_id IN (SELECT id FROM deleted)`).all(id, options.includeRelated === false ? 0 : 1);
 		for (const row of rows) {
 			const item = fromRow(row);
+			const revisions = db.prepare("SELECT content FROM knowledge_revisions WHERE knowledge_id = ?").all(item.id);
+			for (const revision of revisions) suppressMemory(db, knowledgeFingerprints({
+				...item,
+				content: revision.content
+			}), now);
 			suppressMemory(db, knowledgeFingerprints(item), now);
 			clearMemoryAudit(db, "knowledge", item.id);
 			if (item.recordClass === "source_index" && typeof item.source.sourceItemId === "string") db.prepare("DELETE FROM knowledge_source_chunks WHERE source_item_id = ?").run(item.source.sourceItemId);

package/dist/src/memory-learning/forget-capture.js

@@ -68,7 +68,7 @@ function applyKnowledgeDeletions(input) {
         FROM context_evidence e WHERE e.conversation_id IS NOT NULL AND e.message_id IS NOT NULL
           AND (e.evidence_id IN (SELECT evidence_id FROM knowledge_evidence_links WHERE knowledge_id=?)
             OR e.message_id IN (SELECT value FROM knowledge_revisions r, json_each(r.source_json, '$.evidenceRefs')
-              WHERE r.knowledge_id=?))`).all(item.id, item.id).flatMap((entry) => [`${entry.conversation_id}:${entry.message_id}`, `${entry.conversation_id}:*`])).concat(targets.length && input.context.conversationId ? [`${input.context.conversationId}:*`] : []);
+              WHERE r.knowledge_id=?))`).all(item.id, item.id).flatMap((entry) => [`${entry.conversation_id}:${entry.message_id}`, `${entry.conversation_id}:*`])).concat((targets.length || !operation.targetKnowledgeIds.length && operation.reread) && input.context.conversationId ? [`${input.context.conversationId}:*`] : []);
 			for (const item of targets) {
 				deleteKnowledgeItem(item.id, Date.now(), { includeRelated: false });
 				outputs.push({
@@ -78,7 +78,15 @@ function applyKnowledgeDeletions(input) {
 					outcome: "rejected"
 				});
 			}
-			for (const scope of new Map(targets.map((item) => [JSON.stringify(item.scope), item.scope])).values()) {
+			const scopes = targets.map((item) => item.scope);
+			if (!operation.targetKnowledgeIds.length && operation.reread && input.context.workspaceId) scopes.push(input.context.projectId ? {
+				type: "project",
+				id: input.context.projectId
+			} : {
+				type: "workspace",
+				id: input.context.workspaceId
+			});
+			for (const scope of new Map(scopes.map((scope) => [JSON.stringify(scope), scope])).values()) {
 				if (scope.type === "agent") continue;
 				if (!listCollaborationRules().some((rule) => rule.category === "boundary" && rule.status === "active" && JSON.stringify(rule.scope) === JSON.stringify(scope) && rule.statement === operation.boundary && forgottenEntries.every((entry) => Array.isArray(rule.conditions.forgottenHistoryEntries) && rule.conditions.forgottenHistoryEntries.includes(entry)))) createCollaborationRule({
 					category: "boundary",
@@ -87,7 +95,8 @@ function applyKnowledgeDeletions(input) {
 					conditions: {
 						enforcementLevel: "prompt",
 						forgottenHistoryEntries: [...new Set(forgottenEntries)],
-						reread: operation.reread
+						reread: operation.reread,
+						...operation.reread ? { unadmittedFieldCoverage: true } : {}
 					},
 					statement: operation.boundary,
 					status: "active"

package/dist/src/memory-learning/forgotten-history.d.ts

@@ -4,6 +4,10 @@ export declare function explicitlyReadsOriginalHistory(text: string): boolean;
 /** A value-free, per-request notice makes legitimate original reads distinguishable from automatic recall. */
 export declare function originalReadAuthorizationNotice(context: CaptureScopeContext, userText?: string): string;
 export declare function forgottenHistoryEntries(context: CaptureScopeContext, userText?: string): Set<string>;
+/** Apply value-free scoped field boundaries even when a source fact was never admitted.
+ * Ambiguous mixed sentences are conservative: all values of that field are withheld.
+ */
+export declare function projectUnadmittedForgottenFields<T>(value: T, context: CaptureScopeContext, userText?: string): T;
 /** Project provenance for model consumption without changing the retained audit source. */
 export declare function projectForgottenEvidence<T>(source: T, context: CaptureScopeContext, userText?: string, provenanceRefs?: string[]): T;
 /** Remove earlier materialized reads from active history, retaining this turn and system context. */