@xopcai/xopc 0.0.377 → 0.0.380

package/dist/packages/realtime-protocol/src/voice-catalog.js

@@ -1,6 +1,10 @@
 import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
 import { z } from "zod";
 //#region packages/realtime-protocol/src/voice-catalog.ts
+/** Older catalogs apply each voice to every mode published by its model. */
+function voiceSupportsMode(voice, mode) {
+	return voice.modes === void 0 || voice.modes.includes(mode);
+}
 var voiceDisplayNamesSchema, voiceModeCapabilitySchema, voiceManifestSchema, voiceSelectionSchema;
 var init_voice_catalog = __esmMin((() => {
 	voiceDisplayNamesSchema = z.strictObject({
@@ -40,7 +44,8 @@ var init_voice_catalog = __esmMin((() => {
 			languages: z.array(z.string()),
 			gender: z.enum(["female", "male"]).optional(),
 			style: z.string().optional(),
-			description: z.string().optional()
+			description: z.string().optional(),
+			modes: z.array(voiceModeCapabilitySchema).optional()
 		})),
 		defaultVoice: z.string().min(1).optional(),
 		limits: z.strictObject({
@@ -67,4 +72,4 @@ var init_voice_catalog = __esmMin((() => {
 }));
 //#endregion
 init_voice_catalog();
-export { init_voice_catalog, voiceManifestSchema, voiceModeCapabilitySchema, voiceSelectionSchema };
+export { init_voice_catalog, voiceManifestSchema, voiceModeCapabilitySchema, voiceSelectionSchema, voiceSupportsMode };

package/dist/src/agent/embedded/execution-tool-policy.d.ts

@@ -0,0 +1,14 @@
+import type { AgentTool } from '@earendil-works/pi-agent-core';
+export declare const PERSONAL_REQUEST_TOOL_IDS: readonly ["xopc_tool_search", "xopc_tool_describe", "xopc_tool_execute", "personal_request_result", "personal_request_connection"];
+export type ExecutionToolPolicy = Readonly<{
+    surface: 'agent' | 'personal_main' | 'personal_request_worker';
+    nativeMcp: boolean;
+    externalMaterialization: boolean;
+    discovery: boolean;
+    codemode: boolean;
+    revision: string;
+}>;
+/** Resolve from persisted execution identity, never from tool names or model input. */
+export declare function resolveExecutionToolPolicy(conversationId: string): ExecutionToolPolicy;
+export declare function allowsExecutionTool(policy: ExecutionToolPolicy, name: string): boolean;
+export declare function filterExecutionTools(policy: ExecutionToolPolicy, tools: readonly AgentTool[]): AgentTool[];

package/dist/src/agent/embedded/execution-tool-policy.js

@@ -0,0 +1,41 @@
+import { init_connection, isXopcDatabaseOpen } from "../../storage/sqlite/connection.js";
+import { init_request_repository, personalRequestForExecution } from "../../personal-agent/request-repository.js";
+import { getSessionMetadata } from "../../storage/sqlite/session-read-repository.js";
+import { init_session_repository } from "../../storage/sqlite/session-repository.js";
+import { isPersonalConversation } from "../../personal-agent/repository.js";
+import { PERSONAL_MAIN_TOOL_IDS } from "../../personal-agent/policy.js";
+//#region src/agent/embedded/execution-tool-policy.ts
+init_request_repository();
+init_connection();
+init_session_repository();
+const PERSONAL_REQUEST_TOOL_IDS = [
+	"xopc_tool_search",
+	"xopc_tool_describe",
+	"xopc_tool_execute",
+	"personal_request_result",
+	"personal_request_connection"
+];
+/** Resolve from persisted execution identity, never from tool names or model input. */
+function resolveExecutionToolPolicy(conversationId) {
+	let surface = "agent";
+	if (isPersonalConversation(conversationId)) surface = "personal_main";
+	else if (personalRequestForExecution(conversationId) || isXopcDatabaseOpen() && getSessionMetadata(conversationId)?.customData?.personalReadRequestId) surface = "personal_request_worker";
+	const configured = surface === "agent";
+	return {
+		surface,
+		nativeMcp: configured,
+		externalMaterialization: configured,
+		discovery: configured,
+		codemode: configured,
+		revision: "personal-tool-boundaries-v1"
+	};
+}
+function allowsExecutionTool(policy, name) {
+	if (policy.surface === "agent") return true;
+	return (policy.surface === "personal_main" ? PERSONAL_MAIN_TOOL_IDS : PERSONAL_REQUEST_TOOL_IDS).includes(name);
+}
+function filterExecutionTools(policy, tools) {
+	return tools.filter((tool) => allowsExecutionTool(policy, tool.name));
+}
+//#endregion
+export { PERSONAL_REQUEST_TOOL_IDS, allowsExecutionTool, filterExecutionTools, resolveExecutionToolPolicy };

package/dist/src/agent/embedded/run-for-session.js

@@ -8,6 +8,7 @@ import { appendDynamicPromptSection } from "../prompt/cache-boundary.js";
 import { setTraceIdentity, startObservation, traceOperation, traceRun } from "../../observability/runtime.js";
 import { resolveAgentTurnTimeoutMs } from "../orchestration/run-agent-turn-with-timeout.js";
 import { isPersonalConversation } from "../../personal-agent/repository.js";
+import { filterExecutionTools, resolveExecutionToolPolicy } from "./execution-tool-policy.js";
 import { runWithEmbeddedExecutionSession } from "./execution-context.js";
 import { resolvePromptCachePolicy } from "../../providers/prompt-cache-plan.js";
 import { prepareNativeMcpConfig } from "../mcp/native-mcp.js";
@@ -126,7 +127,8 @@ async function runEmbeddedTurnForSessionInner(params) {
 		if (typeof mm.applyResolvedModel === "function") mm.applyResolvedModel(agent, model, modelRef);
 		else await mm.applyModelForSession(agent, conversationId);
 		agentManager.setModelForSession(conversationId, modelRef);
-		const tools = [...agent.state.tools];
+		const executionToolPolicy = resolveExecutionToolPolicy(conversationId);
+		const tools = filterExecutionTools(executionToolPolicy, agent.state.tools);
 		const turnPolicy = agentManager.createAgentTurnPolicy(conversationId);
 		const systemPrompt = appendDynamicPromptSection([agent.state.systemPrompt ?? "", params.presentation === "voice" ? voicePresentationPrompt : ""].filter(Boolean).join("\n\n"), params.dynamicSystemContext ?? "");
 		const idlePolicy = resolveCompactionPolicy(config);
@@ -166,11 +168,11 @@ async function runEmbeddedTurnForSessionInner(params) {
 		};
 		const thinkingLevel = params.thinkingOverride ?? agent.state.thinkingLevel;
 		const workspaceDir = agentManager.getResolvedWorkspaceForSession(conversationId);
-		tools.push(...await materializeNativeExternalTools({
+		if (executionToolPolicy.externalMaterialization) tools.push(...await materializeNativeExternalTools({
 			conversationId,
 			tools
 		}));
-		const mcp = config ? await prepareNativeMcpConfig(config, workspaceDir) : void 0;
+		const mcp = config && executionToolPolicy.nativeMcp ? await prepareNativeMcpConfig(config, workspaceDir) : void 0;
 		const promptCachePolicy = resolvePromptCachePolicy(config ? resolveEffectiveAgentProfileForSession(conversationId).config.runtime.promptCache : void 0);
 		let userMessageForTurn = userMessage;
 		if (params.applyStartupContext !== false) {
@@ -270,7 +272,7 @@ async function runEmbeddedTurnForSessionInner(params) {
 					tools,
 					systemPrompt,
 					thinkingLevel,
-					codemode: config ? resolveEffectiveAgentProfileForSession(conversationId).config.runtime.codemode : void 0,
+					codemode: config && executionToolPolicy.codemode ? resolveEffectiveAgentProfileForSession(conversationId).config.runtime.codemode : void 0,
 					mcp,
 					promptCachePolicy,
 					compactionPolicy: resolveCompactionPolicy(config),

package/dist/src/agent/embedded/run-turn.js

@@ -13,6 +13,7 @@ import { cloudCreditBudgetStopMessage, isCloudCreditBudgetExhausted, reportCloud
 import { isAgentTurnUnsettledError, resolveAgentTurnTimeoutMs, runAgentTurnWithTimeout } from "../orchestration/run-agent-turn-with-timeout.js";
 import { isContextOverflowError } from "../orchestration/context-overflow.js";
 import { getAssistantTurnErrorMessage, isAssistantTurnAborted, isAssistantTurnFailed, maybeRetryTurnAfterTransientLlmFailure, stripTrailingErrorAssistantMessages } from "../orchestration/llm-turn-retry.js";
+import { allowsExecutionTool, filterExecutionTools, resolveExecutionToolPolicy } from "./execution-tool-policy.js";
 import { runWithEmbeddedExecutionSession } from "./execution-context.js";
 import { externalPolicyContext } from "./tool-metadata.js";
 import { isComputerControlActive, isComputerLeaseTool, stopComputerControl } from "../../computer/control-guard.js";
@@ -284,8 +285,17 @@ async function runXopcEmbeddedTurn(params) {
 	});
 }
 async function runXopcEmbeddedTurnInner(params) {
+	const preparationStartedAt = performance.now();
+	let firstModelRequestAt;
+	let currentModelRequestAt;
+	let modelRequestNumber = 0;
+	let firstModelTextSeen = false;
+	let latencyModelRef;
+	let latencyReasoning;
 	const { conversationId, runId, userMessage, model, tools: rawTools, systemPrompt, thinkingLevel, workspaceDir, sessionStore, onEvent } = params;
-	const tools = traceTools(rawTools);
+	const toolPolicyConversationId = params.toolPolicyConversationId ?? conversationId;
+	const executionToolPolicy = resolveExecutionToolPolicy(toolPolicyConversationId);
+	const tools = traceTools(filterExecutionTools(executionToolPolicy, rawTools));
 	const timeoutMs = params.timeoutMs || resolveAgentTurnTimeoutMs();
 	const resolvedModel = requireEmbeddedModel(model, params.modelRef);
 	const configuredThinking = isXopcDatabaseOpen() && getSessionMetadata(conversationId) ? resolveEffectiveAgentConfigForSession(conversationId).config.runtime.thinkingLevel : void 0;
@@ -319,6 +329,7 @@ async function runXopcEmbeddedTurnInner(params) {
 			model: resolvedModel,
 			modelRef: params.modelRef,
 			tools,
+			executionToolPolicy,
 			codemode: params.codemode,
 			mcp: params.mcp,
 			systemPrompt: [systemPrompt, rootInstructions].filter(Boolean).join("\n\n"),
@@ -522,6 +533,24 @@ async function runXopcEmbeddedTurnInner(params) {
 					tools: effectiveTools
 				} } : {}
 			}, "Sending messages to AI");
+			currentModelRequestAt = performance.now();
+			modelRequestNumber += 1;
+			latencyModelRef = `${streamModel.provider}/${streamModel.id}`;
+			latencyReasoning = options?.reasoning;
+			if (firstModelRequestAt === void 0) {
+				firstModelRequestAt = currentModelRequestAt;
+				log.info({
+					conversationId,
+					runId,
+					modelRef: latencyModelRef,
+					thinking: latencyReasoning ?? "off",
+					phase: "first_model_request",
+					preparationMs: firstModelRequestAt - preparationStartedAt,
+					messageCount: effectiveContext.messages.length,
+					systemPromptLength: effectiveSystemPrompt.length,
+					toolCount: effectiveTools.length
+				}, "Embedded first model request ready");
+			}
 			return trackAiUsageStream(streamModel, {
 				operation: continuesAfterTool(effectiveContext.messages) ? "agent.continue_after_tool" : "agent.answer",
 				conversationId,
@@ -551,6 +580,19 @@ async function runXopcEmbeddedTurnInner(params) {
 		let sentVisibleMessage = false;
 		params.turnPolicy?.reset();
 		session.agent.beforeToolCall = async (context, signal) => {
+			if (!allowsExecutionTool(executionToolPolicy, context.toolCall.name)) return {
+				block: true,
+				reason: "Tool is outside this execution scope."
+			};
+			if (executionToolPolicy.surface !== "agent" && resolveExecutionToolPolicy(toolPolicyConversationId).surface !== executionToolPolicy.surface) {
+				policyStopped = true;
+				quarantineRunner = true;
+				return {
+					block: true,
+					terminate: true,
+					reason: "Execution identity changed. Start a new turn with the current tool policy."
+				};
+			}
 			const resume = getClarificationResumeInput(conversationId, runId);
 			const wait = resume?.payload?.waitId ? getClarification(resume.payload.waitId) : void 0;
 			if (wait?.approvalKey?.startsWith("computer:") && wait.answer !== "已在桌面端处理，继续") await stopComputerControl(conversationId);
@@ -624,6 +666,19 @@ async function runXopcEmbeddedTurnInner(params) {
 			if (baseDecision && baseDecision.action === "continue") return { action: "continue" };
 		};
 		unsubscribe = subscribeEmbeddedSessionEvents(session, (event) => {
+			if (!firstModelTextSeen && firstModelRequestAt !== void 0 && currentModelRequestAt !== void 0 && event.type === "message_update" && event.assistantMessageEvent?.type === "text_delta" && event.assistantMessageEvent.delta.trim()) {
+				firstModelTextSeen = true;
+				log.info({
+					conversationId,
+					runId,
+					modelRef: latencyModelRef,
+					thinking: latencyReasoning ?? "off",
+					phase: "first_model_text",
+					modelFirstTextMs: performance.now() - currentModelRequestAt,
+					firstRequestToTextMs: performance.now() - firstModelRequestAt,
+					modelRequestNumber
+				}, "Embedded first response text ready");
+			}
 			if (event.type === "message_end" && event.message.role === "assistant") recordPromptCacheTouch(conversationId, resolvedModel, event.message.usage);
 			if (event.type === "tool_execution_end") {
 				markTurnToolResult(conversationId, runId, event.toolName);

package/dist/src/agent/embedded/session-runner.d.ts

@@ -5,6 +5,7 @@ import type { Model, Api } from '@earendil-works/pi-ai';
 import { type GuardedPiTranscriptManager } from './session-tool-result-guard.js';
 import type { EmbeddedTranscriptRuntime } from './transcript-runtime.js';
 import { type CodemodePolicy } from './codemode-extension.js';
+import { type ExecutionToolPolicy } from './execution-tool-policy.js';
 export type EmbeddedRunnerFingerprintInput = {
     transcriptId: string;
     workspaceDir: string;
@@ -16,6 +17,7 @@ export type EmbeddedRunnerFingerprintInput = {
     credentialRevision: string;
     codemode?: CodemodePolicy;
     mcp?: LoadedMcpConfig;
+    executionToolPolicy?: ExecutionToolPolicy;
 };
 export declare function buildEmbeddedRunnerFingerprint(input: EmbeddedRunnerFingerprintInput): string;
 export type AcquireEmbeddedSessionRunnerParams = {
@@ -30,6 +32,7 @@ export type AcquireEmbeddedSessionRunnerParams = {
     transcriptRuntime: EmbeddedTranscriptRuntime;
     codemode?: CodemodePolicy;
     mcp?: LoadedMcpConfig;
+    executionToolPolicy?: ExecutionToolPolicy;
 };
 export type AcquiredEmbeddedSessionRunner = {
     session: AgentSession;

package/dist/src/agent/embedded/session-runner.js

@@ -1,6 +1,7 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { isCodemodeCoreRead } from "../tools/codemode-permissions.js";
+import { filterExecutionTools, resolveExecutionToolPolicy } from "./execution-tool-policy.js";
 import { deferredToolContract, getXopcToolMetadata } from "./tool-metadata.js";
 import { abortEmbeddedRun } from "./runs.js";
 import { guardSessionManager } from "./session-tool-result-guard.js";
@@ -41,7 +42,8 @@ function buildEmbeddedRunnerFingerprint(input) {
 		input.thinkingLevel,
 		input.credentialRevision,
 		JSON.stringify(input.codemode ?? null),
-		JSON.stringify(input.mcp ?? null)
+		JSON.stringify(input.mcp ?? null),
+		JSON.stringify(input.executionToolPolicy ?? null)
 	].join("\0")).digest("base64url");
 }
 function isEmbeddedSessionRunnerEnabled() {
@@ -109,6 +111,14 @@ var EmbeddedSessionRunnerPool = class {
 	}
 	async acquire(params) {
 		this.stats.acquires += 1;
+		const executionToolPolicy = params.executionToolPolicy ?? resolveExecutionToolPolicy(params.runtimeId);
+		params = {
+			...params,
+			executionToolPolicy,
+			tools: filterExecutionTools(executionToolPolicy, params.tools),
+			mcp: executionToolPolicy.nativeMcp ? params.mcp : void 0,
+			codemode: executionToolPolicy.codemode ? params.codemode : void 0
+		};
 		const fingerprint = buildEmbeddedRunnerFingerprint({
 			transcriptId: params.transcriptId,
 			workspaceDir: params.workspaceDir,
@@ -119,7 +129,8 @@ var EmbeddedSessionRunnerPool = class {
 			thinkingLevel: params.thinkingLevel ?? "medium",
 			credentialRevision: providerCredentialRevision(params.model.provider),
 			codemode: params.codemode,
-			mcp: params.mcp
+			mcp: params.mcp,
+			executionToolPolicy
 		});
 		const reuseEnabled = this.isEnabledFn();
 		const existing = this.pool.get(params.runtimeId);
@@ -132,13 +143,21 @@ var EmbeddedSessionRunnerPool = class {
 			reused = true;
 			this.stats.reuses += 1;
 			entry.session.agent.streamFunction = entry.baseStreamFn;
-			log.debug({ runtimeId: params.runtimeId }, "Reusing pooled embedded session runner");
+			log.debug({
+				runtimeId: params.runtimeId,
+				surface: executionToolPolicy.surface,
+				policyRevision: executionToolPolicy.revision
+			}, "Reusing pooled embedded session runner");
 		} else {
 			if (existing) this.disposePooledRunner(params.runtimeId, existing, "fingerprint_mismatch");
 			entry = await this.createPooledRunner(params);
 			this.pool.set(params.runtimeId, entry);
 			this.stats.creates += 1;
-			log.debug({ runtimeId: params.runtimeId }, "Created embedded session runner");
+			log.debug({
+				runtimeId: params.runtimeId,
+				surface: executionToolPolicy.surface,
+				policyRevision: executionToolPolicy.revision
+			}, "Created embedded session runner");
 		}
 		return {
 			session: entry.session,
@@ -216,12 +235,12 @@ var EmbeddedSessionRunnerPool = class {
 		const discoveryState = piSm.getBranch().findLast((entry) => entry.type === "custom" && entry.customType === "xopc-tool-discovery");
 		const saved = discoveryState?.type === "custom" ? discoveryState.data : void 0;
 		const restored = new Map((saved?.loaded ?? []).map((tool) => [tool.name, tool.contract]));
-		toolNames.push(...tools.filter((tool) => getXopcToolMetadata(tool)?.exposure === "deferred" && restored.get(tool.name) === deferredToolContract(tool)).map((tool) => tool.name));
+		toolNames.push(...tools.filter((tool) => params.executionToolPolicy?.discovery !== false && getXopcToolMetadata(tool)?.exposure === "deferred" && restored.get(tool.name) === deferredToolContract(tool)).map((tool) => tool.name));
 		let boundSession;
 		const mcp = params.mcp;
 		const hasMcp = Boolean(mcp?.servers.length);
 		const usesMcpCodemode = mcp?.servers.some((server) => server.config.enabled !== false && [server.config.exposure ?? "codemode", ...Object.values(server.config.toolExposure ?? {})].includes("codemode"));
-		const codemode = params.codemode?.enabled ? params.codemode : usesMcpCodemode ? {
+		const codemode = params.executionToolPolicy?.codemode === false ? void 0 : params.codemode?.enabled ? params.codemode : usesMcpCodemode ? {
 			enabled: true,
 			timeoutMs: 6e4,
 			maxConcurrentCalls: 4,
@@ -229,7 +248,7 @@ var EmbeddedSessionRunnerPool = class {
 			maxOutputTokens: 4e3
 		} : void 0;
 		if (codemode) toolNames.push("codemode");
-		const discovery = hasMcp || tools.some((tool) => getXopcToolMetadata(tool)?.exposure === "deferred");
+		const discovery = params.executionToolPolicy?.discovery !== false && (hasMcp || tools.some((tool) => getXopcToolMetadata(tool)?.exposure === "deferred"));
 		if (discovery) toolNames.push("tool_search");
 		const modelRuntime = await createEmbeddedModelRuntime(model.provider);
 		const resourceLoader = new DefaultResourceLoader({
@@ -258,6 +277,7 @@ var EmbeddedSessionRunnerPool = class {
 			modelRuntime,
 			resourceLoader,
 			noTools: "builtin",
+			...params.executionToolPolicy?.surface !== "agent" ? { tools: toolNames } : {},
 			customTools: toolDefs
 		});
 		boundSession = session;
@@ -277,7 +297,8 @@ var EmbeddedSessionRunnerPool = class {
 				thinkingLevel: thinkingLevel ?? "medium",
 				credentialRevision: providerCredentialRevision(model.provider),
 				codemode: params.codemode,
-				mcp: params.mcp
+				mcp: params.mcp,
+				executionToolPolicy: params.executionToolPolicy
 			}),
 			session,
 			piSm,

package/dist/src/agent/embedded/types.d.ts

@@ -71,6 +71,8 @@ export type EmbeddedStreamEvent = {
 };
 export type RunXopcEmbeddedTurnParams = {
     conversationId: string;
+    /** Host-owned parent identity for ephemeral runs that inherit its tools. */
+    toolPolicyConversationId?: string;
     runId: string;
     userMessage: AgentMessage;
     model: Model<Api>;

package/dist/src/agent/prompt/response-language.js

@@ -1,12 +1,20 @@
 import { isXopcDatabaseOpen } from "../../storage/sqlite/connection.js";
+import { TaskRepository, init_task_repository } from "../../tasks/task-repository.js";
 import { getSessionConfig } from "../../storage/sqlite/config-repository.js";
 import { init_sqlite } from "../../storage/sqlite/index.js";
 import { init_response_language, resolveResponseLanguage } from "../../i18n/response-language.js";
+import { TaskConversationRepository } from "../../tasks/task-conversation-repository.js";
+import { resolveTaskLocale } from "../../tasks/task-language.js";
 //#region src/agent/prompt/response-language.ts
 init_response_language();
 init_sqlite();
+init_task_repository();
 function resolveResponseLanguageForSession(config, conversationId) {
-	return resolveResponseLanguage(config?.userContext?.preferences?.responseLanguage ?? "auto", conversationId && isXopcDatabaseOpen() ? getSessionConfig(conversationId)?.responseLanguage : void 0);
+	const language = resolveResponseLanguage(config?.userContext?.preferences?.responseLanguage ?? "auto", conversationId && isXopcDatabaseOpen() ? getSessionConfig(conversationId)?.responseLanguage : void 0);
+	if (language !== "auto" || !conversationId || !isXopcDatabaseOpen()) return language;
+	const taskId = new TaskConversationRepository().resolveActiveExecutionSession(conversationId)?.taskId;
+	const task = taskId ? new TaskRepository().get(taskId) : void 0;
+	return task ? resolveTaskLocale(task) === "zh" ? "zh-CN" : "en" : language;
 }
 //#endregion
 export { resolveResponseLanguageForSession };

package/dist/src/agent/service.js

@@ -614,6 +614,7 @@ var AgentService = class {
 		});
 		return runWithEmbeddedExecutionSession(params.executionConversationId, () => runXopcEmbeddedTurn({
 			conversationId: params.executionConversationId,
+			toolPolicyConversationId: params.parentConversationId,
 			verifyChanges: resolveAgentIdFromConversationId(params.parentConversationId) === "coder",
 			runId: params.runId,
 			userMessage,

package/dist/src/agent/session/session-config-service.js

@@ -74,19 +74,6 @@ var SessionConfigService = class {
 					fixedModel: partial.fixedModel ?? existing?.fixedModel ?? false
 				});
 				this.opts.modelManager.restoreSessionModel(conversationId, modelRef, updated.fixedModel === true);
-				try {
-					if (this.opts.agentManager.getAgent(conversationId)) {
-						this.opts.agentManager.setModelForSession(conversationId, modelRef);
-						this.opts.agentManager.setThinkingLevel(conversationId, thinkingLevel);
-					}
-				} catch (err) {
-					this.opts.agentManager.removeAgent(conversationId);
-					log.warn({
-						err,
-						conversationId,
-						modelRef
-					}, "Saved model configuration; runtime will reload before the next turn");
-				}
 			}
 		}
 		const activityDetailLevel = partial.activityDetailLevel !== void 0 ? partial.activityDetailLevel : partial.reasoningLevel;

package/dist/src/agent/tasks/task-judge-service.d.ts

@@ -19,8 +19,8 @@ export interface TaskJudgeDecision {
     nextAction?: string;
     judgment: TaskJudgment;
 }
-export declare function parseTaskJudgeDecision(raw: string, criteriaCount: number): TaskJudgeDecision;
-export declare function requestTaskJudgeDecision(complete: (attempt: number) => Promise<string>, criteriaCount: number): Promise<TaskJudgeDecision>;
+export declare function parseTaskJudgeDecision(raw: string, criteriaCount: number, locale?: 'en' | 'zh'): TaskJudgeDecision;
+export declare function requestTaskJudgeDecision(complete: (attempt: number) => Promise<string>, criteriaCount: number, locale?: 'en' | 'zh'): Promise<TaskJudgeDecision>;
 export declare function codingCompletionEvidence(rows: readonly TranscriptStoredRow[]): {
     allowed: boolean;
     workspace?: string;

package/dist/src/agent/tasks/task-judge-service.js

@@ -8,7 +8,10 @@ import { getApiKey, init_providers, resolveModel } from "../../providers/index.j
 import { completeWithResolvedCredentials } from "../../providers/model-call.js";
 import { extractAssistantText, getAssistantMessageErrorReason, stripCodeFences } from "../../providers/model-response.js";
 import { TaskConversationRepository } from "../../tasks/task-conversation-repository.js";
+import { resolveTaskLocale } from "../../tasks/task-language.js";
 import { readWorkspaceRevision } from "../coding/workspace-revision.js";
+import { buildResponseLanguageSection } from "../prompt/sections/response-language.js";
+import { resolveResponseLanguageForSession } from "../prompt/response-language.js";
 import { TaskApplicationService } from "../../tasks/task-application-service.js";
 //#region src/agent/tasks/task-judge-service.ts
 init_schema();
@@ -22,7 +25,7 @@ function compactHistory(messages) {
 	const text = JSON.stringify(messages);
 	return text.length <= MAX_HISTORY_CHARS ? text : text.slice(-MAX_HISTORY_CHARS);
 }
-function parseTaskJudgeDecision(raw, criteriaCount) {
+function parseTaskJudgeDecision(raw, criteriaCount, locale = "en") {
 	const text = stripCodeFences(raw);
 	const start = text.indexOf("{");
 	const end = text.lastIndexOf("}");
@@ -42,7 +45,7 @@ function parseTaskJudgeDecision(raw, criteriaCount) {
 		}] : [];
 	}).slice(0, 5) : [];
 	const nextAction = typeof decision.nextAction === "string" && decision.nextAction.trim() ? decision.nextAction.trim() : void 0;
-	const recommendation = typeof decision.recommendation === "string" && decision.recommendation.trim() ? decision.recommendation.trim() : nextAction ?? "Continue gathering verifiable evidence.";
+	const recommendation = typeof decision.recommendation === "string" && decision.recommendation.trim() ? decision.recommendation.trim() : nextAction ?? (locale === "zh" ? "继续收集可验证的证据。" : "Continue gathering verifiable evidence.");
 	const confidence = typeof decision.confidence === "number" && Number.isFinite(decision.confidence) ? Math.max(0, Math.min(1, decision.confidence)) : .5;
 	return {
 		completedCriteria,
@@ -50,19 +53,19 @@ function parseTaskJudgeDecision(raw, criteriaCount) {
 		...nextAction ? { nextAction } : {},
 		judgment: {
 			recommendation,
-			reasons: reasons.length > 0 ? reasons : ["No verified completion evidence was found."],
+			reasons: reasons.length > 0 ? reasons : [locale === "zh" ? "尚未找到已验证的完成证据。" : "No verified completion evidence was found."],
 			rejectedAlternatives,
 			...typeof decision.uncertainty === "string" && decision.uncertainty.trim() ? { uncertainty: decision.uncertainty.trim() } : {},
 			confidence
 		}
 	};
 }
-async function requestTaskJudgeDecision(complete, criteriaCount) {
+async function requestTaskJudgeDecision(complete, criteriaCount, locale = "en") {
 	let parseError;
 	for (let attempt = 0; attempt < 2; attempt += 1) {
 		const raw = await complete(attempt);
 		try {
-			return parseTaskJudgeDecision(raw, criteriaCount);
+			return parseTaskJudgeDecision(raw, criteriaCount, locale);
 		} catch (error) {
 			parseError = error;
 		}
@@ -129,8 +132,12 @@ var TaskJudgeService = class {
 		const history = compactHistory(await this.options.sessionStore.loadMessages(payload.conversationId));
 		const proof = codingCompletionEvidence(await this.options.sessionStore.loadTranscriptRows(payload.conversationId));
 		const criteria = task.contract.acceptanceCriteria;
+		const responseLanguage = resolveResponseLanguageForSession(this.options.getConfig(), payload.conversationId);
+		const locale = responseLanguage === "auto" ? resolveTaskLocale(task) : responseLanguage === "zh-CN" ? "zh" : "en";
 		const prompt = [
 			"You are an independent task verifier. Be strict and evidence-driven.",
+			buildResponseLanguageSection(locale === "zh" ? "zh-CN" : "en"),
+			"The recommendation, nextAction, reasons, rejectedAlternatives and uncertainty are displayed directly to the user. Apply the response language to every prose value. Keep JSON keys, criterion indexes, identifiers and proper nouns unchanged.",
 			"Mark a criterion complete only when observed tool results or user-provided facts prove it. An assistant completion claim is not verification evidence.",
 			`Runtime coding evidence: ${JSON.stringify(proof)}`,
 			"needsUser is true only when a specific decision, permission, credential, or missing fact must come from the user.",
@@ -165,15 +172,15 @@ var TaskJudgeService = class {
 				const modelError = getAssistantMessageErrorReason(response);
 				if (modelError) throw new Error(modelError);
 				return extractAssistantText(response.content);
-			}, criteria.length);
+			}, criteria.length, locale);
 			if (!proof.allowed || proof.workspace && (!proof.revision || await readWorkspaceRevision(proof.workspace) !== proof.revision)) {
 				decision.completedCriteria = [];
-				decision.judgment.reasons.unshift("Current workspace verification is missing, failed or stale.");
+				decision.judgment.reasons.unshift(locale === "zh" ? "当前工作区验证缺失、失败或已过期。" : "Current workspace verification is missing, failed or stale.");
 			}
 			const now = Date.now();
 			const evidence = decision.completedCriteria.map((index) => ({
 				kind: "state",
-				title: `Independently verified: ${criteria[index]}`,
+				title: locale === "zh" ? `已独立验证：${criteria[index]}` : `Independently verified: ${criteria[index]}`,
 				summary: decision.judgment.reasons[0],
 				verifies: [criteria[index]],
 				provenance: "judge",
@@ -207,7 +214,7 @@ var TaskJudgeService = class {
 				expectedRunVersion: run.version,
 				receipt: {
 					status: "succeeded",
-					summary: payload.assistantPlainText || "Agent run completed",
+					summary: payload.assistantPlainText || (locale === "zh" ? "助手执行完成" : "Agent run completed"),
 					changes: [],
 					evidence,
 					verification: {

package/dist/src/agent/tools/factory.js

@@ -13,8 +13,10 @@ import { resolveUserContextSessionAccess } from "../../user-context/access-polic
 import { resolveEffectiveAgentConfigForAgent, resolveEffectiveAgentConfigForSession } from "../../config/agent-profile.js";
 import { createPersonalAttentionTool } from "./personal-attention-tool.js";
 import { markCodemodeCoreRead } from "./codemode-permissions.js";
-import "../../../packages/browser-control-contract/src/index.js";
+import { LOCAL_READ_MAX_CHARS } from "./local-read-budget.js";
 import { PERSONAL_TOOL_DESCRIPTIONS } from "../../personal-agent/policy.js";
+import { PERSONAL_REQUEST_TOOL_IDS, filterExecutionTools, resolveExecutionToolPolicy } from "../embedded/execution-tool-policy.js";
+import "../../../packages/browser-control-contract/src/index.js";
 import { getEmbeddedExecutionRunId, getEmbeddedExecutionSession } from "../embedded/execution-context.js";
 import { wrapToolsWithProtection } from "./executor.js";
 import { EXTERNAL_TOOL_NAMES } from "../external-tools/gateway-tools.js";
@@ -221,7 +223,10 @@ var AgentToolsFactory = class AgentToolsFactory {
 		const getSkillMgr = options?.getSkillManager;
 		const disabled = options?.disabledTools;
 		let allowed = options?.toolAllowlist ? new Set(options.toolAllowlist) : void 0;
-		const personalToolsConfigured = Boolean(allowed?.has("personal_task") || allowed?.has("personal_preference"));
+		const currentConversationId = () => options?.conversationId ?? this.deps.getCurrentContext?.()?.conversationId;
+		const executionConversationId = currentConversationId();
+		const executionToolPolicy = executionConversationId ? resolveExecutionToolPolicy(executionConversationId) : void 0;
+		const personalToolsConfigured = executionToolPolicy?.surface === "personal_main" || Boolean(allowed?.has("personal_task") || allowed?.has("personal_preference"));
 		const primary = getPrimary?.();
 		const modelHasVision = primary?.input?.includes("image") ?? false;
 		const cfg = this.deps.getConfig?.();
@@ -239,8 +244,6 @@ var AgentToolsFactory = class AgentToolsFactory {
 		});
 		const agentId = options?.agentId;
 		const resolvedAgentId = agentId ?? (cfg ? resolveDefaultAgentId() : "main");
-		const currentConversationId = () => options?.conversationId ?? this.deps.getCurrentContext?.()?.conversationId;
-		const executionConversationId = currentConversationId();
 		const personalExecution = executionConversationId ? personalRequestForExecution(executionConversationId) : void 0;
 		const personalExecutionMarker = executionConversationId && isXopcDatabaseOpen() ? getSessionMetadata(executionConversationId)?.customData?.personalReadRequestId : void 0;
 		if (personalExecution && executionConversationId && personalExecutionMarker !== personalExecution.requestId) patchSessionMetadata(executionConversationId, { customData: {
@@ -248,11 +251,7 @@ var AgentToolsFactory = class AgentToolsFactory {
 			personalReadRequestId: personalExecution.requestId
 		} });
 		if (personalExecution || personalExecutionMarker) {
-			allowed = new Set([
-				"xopc_tool_search",
-				"xopc_tool_describe",
-				"xopc_tool_execute"
-			].filter((name) => !allowed || allowed.has(name)));
+			allowed = new Set(PERSONAL_REQUEST_TOOL_IDS.slice(0, 3).filter((name) => !allowed || allowed.has(name)));
 			allowed.add("personal_request_result");
 			allowed.add("personal_request_connection");
 		}
@@ -287,7 +286,7 @@ var AgentToolsFactory = class AgentToolsFactory {
 			profileMarkdownRoot: options?.profileMarkdownRoot,
 			...personalToolsConfigured ? {
 				defaultMaxLines: 150,
-				maxOutputBytes: 8e3,
+				maxOutputBytes: LOCAL_READ_MAX_CHARS,
 				maxReadBytes: 12e3
 			} : {}
 		});
@@ -409,7 +408,7 @@ var AgentToolsFactory = class AgentToolsFactory {
 			createPublishArtifactsTool(workspace),
 			createReadMediaTool(personalToolsConfigured ? {
 				textOnly: true,
-				maxChars: 8e3,
+				maxChars: LOCAL_READ_MAX_CHARS,
 				maxReadBytes: 12e3
 			} : void 0),
 			...isShareToolAvailable(cfg) ? [createCreateShareTool({
@@ -491,7 +490,8 @@ var AgentToolsFactory = class AgentToolsFactory {
 			}),
 			...this.deps.getSessionStore ? [createSessionRecallTool({
 				getSessionStore: this.deps.getSessionStore,
-				getCurrentConversationId: () => this.deps.getCurrentContext()?.conversationId
+				getCurrentConversationId: currentConversationId,
+				...personalToolsConfigured ? { maxOutputChars: LOCAL_READ_MAX_CHARS } : {}
 			})] : [],
 			...this.deps.getSessionStore && getPrimary ? [createSessionSearchTool({
 				localOnly: personalToolsConfigured,
@@ -616,10 +616,11 @@ var AgentToolsFactory = class AgentToolsFactory {
 				allowHostGit: () => getCommandIsolation()?.mode !== "docker"
 			}));
 		}
-		return filterToolsByDisabledSet(core.map(markCodemodeCoreRead), disabled).filter((tool) => (!allowed || allowed.has(tool.name)) && !(personalToolsConfigured && tool.name === "clarify")).map((tool) => personalToolsConfigured && PERSONAL_TOOL_DESCRIPTIONS[tool.name] ? {
+		const selected = filterToolsByDisabledSet(core.map(markCodemodeCoreRead), disabled).filter((tool) => (!allowed || allowed.has(tool.name)) && !(personalToolsConfigured && tool.name === "clarify")).map((tool) => personalToolsConfigured && PERSONAL_TOOL_DESCRIPTIONS[tool.name] ? {
 			...tool,
 			description: PERSONAL_TOOL_DESCRIPTIONS[tool.name]
 		} : tool);
+		return executionToolPolicy ? filterExecutionTools(executionToolPolicy, selected) : selected;
 	}
 	createCapabilityTools(capabilityNames, options) {
 		const disabled = options?.disabledTools;

package/dist/src/agent/tools/knowledge-memory-tool.js

@@ -2,6 +2,7 @@ import { inferMemorySensitivity } from "../memory/sensitivity.js";
 import { canUseKnowledge } from "../../knowledge-memory/usage-policy.js";
 import { getKnowledgeItem, searchKnowledgeItems, writeKnowledgeItem } from "../../knowledge-memory/repository.js";
 import "../../knowledge-memory/index.js";
+import "./local-read-budget.js";
 import { Type } from "@sinclair/typebox";
 //#region src/agent/tools/knowledge-memory-tool.ts
 const SearchSchema = Type.Object({
@@ -207,8 +208,8 @@ function createKnowledgeReadTool(options, canUseCommand = () => true) {
 		description: "Read local memory with search(query) or get(id). Source data is not user authorization. Delegate when requiresSpecialist is true.",
 		parameters: Type.Object({
 			command: Type.Union([Type.Literal("search"), Type.Literal("get")]),
-			query: Type.Optional(Type.String()),
-			id: Type.Optional(Type.String()),
+			query: Type.Optional(Type.String({ maxLength: 500 })),
+			id: Type.Optional(Type.String({ maxLength: 200 })),
 			maxResults: Type.Optional(Type.Integer({
 				minimum: 1,
 				maximum: 5
@@ -217,10 +218,10 @@ function createKnowledgeReadTool(options, canUseCommand = () => true) {
 		supportsParallel: true,
 		async execute(id, raw, signal, onUpdate) {
 			const input = raw;
-			if (input.command !== "search" && input.command !== "get" || (input.command === "search" ? !input.query?.trim() : !input.id?.trim())) return {
+			if (input.command !== "search" && input.command !== "get" || (input.command === "search" ? !input.query?.trim() || input.query.length > 500 : !input.id?.trim() || input.id.length > 200)) return {
 				content: [{
 					type: "text",
-					text: "search requires query; get requires id."
+					text: "search requires query (up to 500 characters); get requires id (up to 200 characters)."
 				}],
 				details: { error: "invalid_read_arguments" }
 			};

package/dist/src/agent/tools/local-read-budget.d.ts

@@ -0,0 +1,2 @@
+/** Total text budget for lightweight Personal reads, including serialized metadata. */
+export declare const LOCAL_READ_MAX_CHARS = 8000;