@xopcai/xopc 0.0.353 → 0.0.355

package/dist/packages/gateway-contract/src/tasks.js

@@ -8,7 +8,7 @@ function verifiedTaskCriteria(receipt) {
 	const evidence = new Set(receipt?.evidence.filter((item) => item.strength === "verified").map((item) => item.title));
 	return new Set(receipt?.verification.checks.filter((check) => check.status === "passed" && check.evidenceTitles.some((title) => evidence.has(title))).map((check) => check.criterion));
 }
-var TaskPrioritySchema, TaskChangedFieldSchema, TaskAcceptancePolicySchema, ActorRefSchema, TaskContractSchema, TaskSchema, TaskContextRoleSchema, TaskContextEdgeSchema, TaskAuthorityGrantSchema, TaskDependencySummarySchema, TaskEvidenceSchema, TaskJudgmentSchema, TaskRunReceiptSchema, TaskExecutorSelectionSchema, TaskContractInputSchema, TaskContextInputSchema, TaskCreateRequestSchema, TaskPatchRequestSchema, TaskWaitInputSchema, TaskCommandSchema, TaskCommandRequestSchema, TaskDependencyUpdateRequestSchema, TaskBoardPositionRequestSchema, TaskListResponseSchema, TaskConversationStateSchema, TaskSessionLinkSchema, TaskHandoffRequestSchema, TaskDetailResponseSchema;
+var TaskPrioritySchema, TaskChangedFieldSchema, TaskAcceptancePolicySchema, ActorRefSchema, TaskContractSchema, TaskSchema, TaskContextRoleSchema, TaskContextEdgeSchema, TaskAuthorityGrantSchema, TaskDependencySummarySchema, TaskEvidenceSchema, TaskJudgmentSchema, TaskRunReceiptSchema, TaskCriterionReviewSchema, TaskCriterionReviewInputSchema, TaskExecutorSelectionSchema, TaskContractInputSchema, TaskContextInputSchema, TaskCreateRequestSchema, TaskPatchRequestSchema, TaskWaitInputSchema, TaskCommandSchema, TaskCommandRequestSchema, TaskDependencyUpdateRequestSchema, TaskBoardPositionRequestSchema, TaskListResponseSchema, TaskConversationStateSchema, TaskSessionLinkSchema, TaskHandoffRequestSchema, TaskDetailResponseSchema;
 var init_tasks = __esmMin((() => {
 	init_task_lifecycle();
 	init_task_runs();
@@ -36,6 +36,7 @@ var init_tasks = __esmMin((() => {
 		"context",
 		"runs",
 		"receipts",
+		"acceptance",
 		"feedback",
 		"attention",
 		"conversation"
@@ -236,6 +237,21 @@ var init_tasks = __esmMin((() => {
 		contextTraceId: z.string().optional(),
 		finalizedAt: z.number().int().nonnegative()
 	});
+	TaskCriterionReviewSchema = z.object({
+		contractVersion: z.number().int().positive(),
+		criterionIndex: z.number().int().nonnegative(),
+		criterionText: z.string(),
+		status: z.enum(["passed", "failed"]),
+		note: z.string().optional(),
+		reviewedBy: ActorRefSchema,
+		reviewedAt: z.number().int().nonnegative()
+	});
+	TaskCriterionReviewInputSchema = z.object({
+		expectedVersion: z.number().int().positive(),
+		contractVersion: z.number().int().positive(),
+		status: z.enum(["passed", "failed"]),
+		note: z.string().trim().max(2e3).optional()
+	}).strict();
 	TaskExecutorSelectionSchema = z.discriminatedUnion("kind", [
 		z.object({
 			kind: z.literal("agent"),
@@ -448,6 +464,7 @@ var init_tasks = __esmMin((() => {
 		waits: z.array(TaskWaitSchema),
 		runs: z.array(TaskRunSchema),
 		receipts: z.array(TaskRunReceiptSchema),
+		criterionReviews: z.array(TaskCriterionReviewSchema),
 		context: z.array(TaskContextEdgeSchema),
 		conversation: TaskConversationStateSchema,
 		sessions: z.array(TaskSessionLinkSchema),
@@ -463,4 +480,4 @@ var init_tasks = __esmMin((() => {
 }));
 //#endregion
 init_tasks();
-export { ActorRefSchema, TaskAcceptancePolicySchema, TaskAuthorityGrantSchema, TaskBoardPositionRequestSchema, TaskChangedFieldSchema, TaskCommandRequestSchema, TaskCommandSchema, TaskContextEdgeSchema, TaskContextInputSchema, TaskContextRoleSchema, TaskContractInputSchema, TaskContractSchema, TaskConversationStateSchema, TaskCreateRequestSchema, TaskDependencySummarySchema, TaskDependencyUpdateRequestSchema, TaskDetailResponseSchema, TaskEvidenceSchema, TaskExecutorSelectionSchema, TaskHandoffRequestSchema, TaskJudgmentSchema, TaskListResponseSchema, TaskPatchRequestSchema, TaskPrioritySchema, TaskRunReceiptSchema, TaskSchema, TaskSessionLinkSchema, init_tasks, verifiedTaskCriteria };
+export { ActorRefSchema, TaskAcceptancePolicySchema, TaskAuthorityGrantSchema, TaskBoardPositionRequestSchema, TaskChangedFieldSchema, TaskCommandRequestSchema, TaskCommandSchema, TaskContextEdgeSchema, TaskContextInputSchema, TaskContextRoleSchema, TaskContractInputSchema, TaskContractSchema, TaskConversationStateSchema, TaskCreateRequestSchema, TaskCriterionReviewInputSchema, TaskCriterionReviewSchema, TaskDependencySummarySchema, TaskDependencyUpdateRequestSchema, TaskDetailResponseSchema, TaskEvidenceSchema, TaskExecutorSelectionSchema, TaskHandoffRequestSchema, TaskJudgmentSchema, TaskListResponseSchema, TaskPatchRequestSchema, TaskPrioritySchema, TaskRunReceiptSchema, TaskSchema, TaskSessionLinkSchema, init_tasks, verifiedTaskCriteria };

package/dist/src/agent/agent-manager.js

@@ -686,7 +686,7 @@ var AgentManager = class {
 				conversationId: instance.conversationId,
 				modelRef: instance.effectiveProfile.primaryModelRef?.trim() || this.defaultModel,
 				agentId: instance.effectiveProfile.agentId,
-				thinkingLevel: this.config.thinkingLevel ?? "medium",
+				thinkingLevel: instance.effectiveProfile.config.runtime.thinkingLevel ?? this.config.thinkingLevel ?? "medium",
 				activeProjectContext: instance.activeProjectContext
 			});
 			replaceAgentSystemPrompt(instance.agent, newPrompt);
@@ -761,7 +761,7 @@ var AgentManager = class {
 				conversationId: instance.conversationId,
 				modelRef: instance.effectiveProfile.primaryModelRef?.trim() || this.defaultModel,
 				agentId: instance.effectiveProfile.agentId,
-				thinkingLevel: this.config.thinkingLevel ?? "medium",
+				thinkingLevel: instance.effectiveProfile.config.runtime.thinkingLevel ?? this.config.thinkingLevel ?? "medium",
 				activeProjectContext: instance.activeProjectContext
 			});
 			replaceAgentSystemPrompt(instance.agent, newPrompt);
@@ -887,7 +887,7 @@ var AgentManager = class {
 		const rt = this.workspaceRuntimes.getOrCreate(resolvedWorkspacePath, instance.effectiveProfile.agentId);
 		const contextFiles = this.resolveContextFilesForSession(conversationId, instance.effectiveProfile);
 		const modelRef = instance.effectiveProfile.primaryModelRef?.trim() || this.defaultModel;
-		const thinkingLevel = this.config.thinkingLevel ?? "medium";
+		const thinkingLevel = instance.effectiveProfile.config.runtime.thinkingLevel ?? this.config.thinkingLevel ?? "medium";
 		const activeProjectContext = this.buildExecutionScopeContext(conversationId);
 		replaceAgentSystemPrompt(instance.agent, rt.systemPromptBuilder.build(contextFiles, {
 			externalMemoryInstructions: this.buildExternalMemoryInstructions(conversationId, rt),
@@ -1006,7 +1006,7 @@ var AgentManager = class {
 			getSkillManager: () => rt.skillManager
 		});
 		const registeredToolNames = tools.map((t) => t.name);
-		const thinkingLevel = this.config.thinkingLevel ?? "medium";
+		const thinkingLevel = profile.config.runtime.thinkingLevel ?? this.config.thinkingLevel ?? "medium";
 		const turnPolicy = this.buildAgentTurnPolicy(conversationId, profile);
 		const providerStreamFn = createExtensionAwareStreamFn();
 		agent = new Agent({

package/dist/src/agent/embedded/run-for-session.d.ts

@@ -15,6 +15,7 @@ export type RunEmbeddedForSessionParams = {
     modelManager: ModelManager;
     thinkingOverride?: string | null;
     presentation?: 'voice';
+    requireVisibleReply?: boolean;
     abortSignal?: AbortSignal;
     /** Absolute parent deadline. The turn's own timeout is capped to the remaining budget. */
     deadlineAtMs?: number;

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

@@ -209,7 +209,8 @@ async function runEmbeddedTurnForSession(params) {
 					abortSignal: supervisor.signal,
 					onEvent: params.onEvent,
 					onAgentEvent: (event) => agentManager.emitRuntimeEvent(conversationId, event),
-					resumeLastUserMessage
+					resumeLastUserMessage,
+					requireVisibleReply: params.requireVisibleReply
 				}), runId);
 				if (turnResult.ok) {
 					if (isFallbackAttempt) log.info({

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

@@ -1,7 +1,12 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
+import { isXopcDatabaseOpen } from "../../storage/sqlite/connection.js";
 import { getClarification, getClarificationResumeInput, init_clarification_wait_repository, isClarificationSuspended } from "../../storage/sqlite/clarification-wait-repository.js";
 import { getConnectionResumeInput, init_connection_wait_repository, isConnectionSuspended } from "../../storage/sqlite/connection-wait-repository.js";
+import { getSessionMetadata } from "../../storage/sqlite/session-read-repository.js";
+import { init_session_repository } from "../../storage/sqlite/session-repository.js";
+import { init_sqlite } from "../../storage/sqlite/index.js";
+import { resolveEffectiveAgentConfigForSession } from "../../config/agent-profile.js";
 import { continuesAfterTool, trackAiUsageStream } from "../../usage/recorder.js";
 import { runWithEmbeddedExecutionSession } from "./execution-context.js";
 import { isComputerControlActive, isComputerLeaseTool, stopComputerControl } from "../../computer/control-guard.js";
@@ -26,11 +31,15 @@ import { markTurnToolResult } from "../memory/turn-provenance.js";
 import { RepositoryInstructions } from "../coding/repository-instructions.js";
 import { RunVerification } from "../coding/run-verification.js";
 import { withDelegationScope } from "../orchestration/delegation-scope.js";
+import { getModelThinking } from "../../providers/model-thinking.js";
+import "../messaging/no-reply.js";
 import { createAssistantMessageEventStream, getCurrentSystemPrompt, getCurrentTools, isRecoverableLength } from "@earendil-works/pi-ai";
 //#region src/agent/embedded/run-turn.ts
 init_connection_wait_repository();
 init_clarification_wait_repository();
 init_logger();
+init_sqlite();
+init_session_repository();
 const log = createLogger("EmbeddedRun");
 const LOG_PREVIEW_MAX_CHARS = 300;
 function truncateForLog(value, maxChars = LOG_PREVIEW_MAX_CHARS) {
@@ -234,6 +243,8 @@ async function runXopcEmbeddedTurn(params) {
 	const { conversationId, runId, userMessage, model, tools, systemPrompt, thinkingLevel, workspaceDir, sessionStore, onEvent } = params;
 	const timeoutMs = params.timeoutMs || resolveAgentTurnTimeoutMs();
 	const resolvedModel = requireEmbeddedModel(model, params.modelRef);
+	const configuredThinking = isXopcDatabaseOpen() && getSessionMetadata(conversationId) ? resolveEffectiveAgentConfigForSession(conversationId).config.runtime.thinkingLevel : void 0;
+	if (configuredThinking && !getModelThinking(resolvedModel).options.includes(configuredThinking)) throw new Error(`Agent requires a model that supports thinking ${configuredThinking}`);
 	const promptCachePolicy = resolvePromptCachePolicy(params.promptCachePolicy);
 	const compactionPolicy = params.compactionPolicy ?? resolveCompactionPolicy();
 	const transcriptRuntime = params.transcriptRuntime ?? (sessionStore ? await createSqliteTranscriptRuntime({
@@ -263,7 +274,7 @@ async function runXopcEmbeddedTurn(params) {
 			modelRef: params.modelRef,
 			tools,
 			systemPrompt: [systemPrompt, rootInstructions].filter(Boolean).join("\n\n"),
-			thinkingLevel: thinkingLevel ?? "medium",
+			thinkingLevel: configuredThinking ?? thinkingLevel ?? "medium",
 			transcriptRuntime
 		});
 		const { session, reused } = runner;
@@ -486,6 +497,7 @@ async function runXopcEmbeddedTurn(params) {
 		let policyStopped = false;
 		let connectionStopped = false;
 		let clarificationStopped = false;
+		let sentVisibleMessage = false;
 		params.turnPolicy?.reset();
 		session.agent.beforeToolCall = async (context, signal) => {
 			const resume = getClarificationResumeInput(conversationId, runId);
@@ -559,7 +571,10 @@ async function runXopcEmbeddedTurn(params) {
 		};
 		unsubscribe = subscribeEmbeddedSessionEvents(session, (event) => {
 			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);
+			if (event.type === "tool_execution_end") {
+				markTurnToolResult(conversationId, runId, event.toolName);
+				if (event.toolName === "send_message" && !event.isError) sentVisibleMessage = true;
+			}
 			onEvent?.({
 				...event,
 				runId
@@ -614,6 +629,14 @@ async function runXopcEmbeddedTurn(params) {
 						useAuthoritativeProjection = true;
 					}
 				});
+				if (params.requireVisibleReply && !sentVisibleMessage && !policyStopped && !runAbortSignal.aborted && !isAssistantTurnFailed(session.agent) && !isAssistantTurnAborted(session.agent) && lastAssistantPlainText(session).trim() === "NO_REPLY") {
+					await session.sendCustomMessage({
+						customType: "visible_reply_required",
+						content: "The direct user message still needs a visible response in this conversation. Answer it now. If it is unclear, ask one short clarifying question. Do not output NO_REPLY.",
+						display: false
+					}, { triggerTurn: true });
+					await session.agent.waitForIdle();
+				}
 				const pending = await verification.pendingContext();
 				if ((params.verifyChanges ?? false) && pending && !policyStopped && !runAbortSignal.aborted && !isAssistantTurnFailed(session.agent) && !isAssistantTurnAborted(session.agent)) {
 					await session.sendCustomMessage({
@@ -651,6 +674,11 @@ async function runXopcEmbeddedTurn(params) {
 				errorMessage: getAssistantTurnErrorMessage(session.agent) ?? "Assistant turn failed",
 				lastAssistantText: lastAssistantPlainText(session)
 			};
+			if (params.requireVisibleReply && !sentVisibleMessage && lastAssistantPlainText(session).trim() === "NO_REPLY") return {
+				ok: false,
+				retryable: false,
+				errorMessage: "Assistant did not produce a visible reply"
+			};
 			runner.piSm.appendCustomEntry("xopc.model-selection", {
 				runId,
 				model: `${session.agent.state.model?.provider ?? resolvedModel.provider}/${session.agent.state.model?.id ?? resolvedModel.id}`,

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

@@ -87,6 +87,7 @@ export type RunXopcEmbeddedTurnParams = {
     /** Continue from the persisted trailing user row instead of appending it again. */
     resumeLastUserMessage?: boolean;
     verifyChanges?: boolean;
+    requireVisibleReply?: boolean;
 };
 export type RunXopcEmbeddedTurnResult = {
     ok: boolean;

package/dist/src/agent/prompt/sections/messaging-runtime.js

@@ -15,7 +15,8 @@ function buildSilentRepliesSection(params) {
 	if (params.isMinimal || params.silentReplyPromptMode === "none") return "";
 	return [
 		"## Silent Replies",
-		`When you have nothing to say, respond with ONLY: ${NO_REPLY}`,
+		`Use ${NO_REPLY} only for background or system-generated events that need no user-facing update, or after you have already delivered the reply with send_message.`,
+		"Always answer a direct message from a person in the current conversation, even if it is brief, unclear, repeated, or looks like a test. Acknowledge it or ask a short clarifying question.",
 		"",
 		"Rules:",
 		"- It must be your ENTIRE message — nothing else",

package/dist/src/agent/service/direct-turn-helpers.d.ts

@@ -70,6 +70,7 @@ export interface RunDirectAgentTurnInput {
     sourceImages?: ImageContent[];
     sourceContexts?: AgentSourceContext[];
     presentation?: 'voice';
+    requireVisibleReply?: boolean;
     onEvent?: (event: EmbeddedStreamEvent) => void;
 }
 export interface RunDirectAgentTurnResult {

package/dist/src/agent/service/direct-turn-helpers.js

@@ -116,6 +116,7 @@ async function runDirectAgentTurn(deps, input) {
 		dynamicSystemContext: userContext.dynamicSystemContext,
 		llmImages,
 		presentation: input.presentation,
+		requireVisibleReply: input.requireVisibleReply,
 		sessionStore: deps.sessionStore,
 		agentManager: deps.agentManager,
 		modelManager: deps.modelManager,

package/dist/src/agent/service/process-direct-streaming.js

@@ -342,6 +342,7 @@ async function* runProcessDirectStreaming(deps, input) {
 					abortSignal: signal,
 					sourceContexts,
 					presentation: input.presentation,
+					requireVisibleReply: input.origin.type === "endpoint",
 					runId: input.runId,
 					onEvent: (embeddedEvent) => {
 						const event = { ...embeddedEvent };

package/dist/src/agent/service.js

@@ -6,7 +6,7 @@ import { extractTextContent } from "./context/workspace.js";
 import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
 import { applyConfigOverrides } from "../config/runtime-overrides.js";
 import { init_agent_session_key, resolveAgentIdFromConversationId } from "../routing/agent-session-key.js";
-import { extractProfileAgentId } from "../config/agent-profile.js";
+import { extractProfileAgentId, resolveEffectiveAgentConfigForSession } from "../config/agent-profile.js";
 import { init_providers, resolveModel } from "../providers/index.js";
 import { effectiveWorkspacePathForSession } from "../session/session-workspace.js";
 import { getProjectForSession } from "../projects/workspace.js";
@@ -22,6 +22,7 @@ import { onSessionTranscriptUpdate } from "../session/transcript-events.js";
 import { persistInboundAttachments } from "../channels/attachments/inbound-persist.js";
 import { buildTranscriptUserMessage, hydrateUserTurnForLlm } from "./inbound/attachment-pipeline.js";
 import { resolveCompactionPolicy } from "./memory/compaction-policy.js";
+import { getModelThinking } from "../providers/model-thinking.js";
 import { runXopcEmbeddedTurn } from "./embedded/run-turn.js";
 import { resolveResponseLanguageForSession } from "./prompt/response-language.js";
 import { normalizeSkillInstallTarget } from "./skills/install-target.js";
@@ -629,6 +630,8 @@ var AgentService = class {
 		}), params.runId);
 	}
 	async switchModelForSession(conversationId, modelId) {
+		const configuredThinking = resolveEffectiveAgentConfigForSession(conversationId).config.runtime.thinkingLevel;
+		if (configuredThinking && !getModelThinking(resolveModel(modelId)).options.includes(configuredThinking)) return false;
 		if (!await this.modelManager.switchModelForSession(conversationId, modelId)) return false;
 		await this.sessionConfigStore.update(conversationId, { modelOverride: modelId });
 		if (this.agentManager.setModelForSession(conversationId, modelId)) this.sessionTracker.touchSession(conversationId);

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

@@ -3,11 +3,12 @@ import { init_logger } from "../../utils/logger.js";
 import { chooseModelThinking } from "../../../packages/gateway-contract/src/model-selection.js";
 import { init_src } from "../../../packages/gateway-contract/src/index.js";
 import { ResponseLanguageSchema, init_response_language } from "../../i18n/response-language.js";
+import { resolveEffectiveAgentConfigForSession } from "../../config/agent-profile.js";
 import { normalizeWorkingDirectoryInput } from "../../session/session-workspace.js";
 import { getProjectWorkspacePathForSession } from "../../projects/workspace.js";
+import { getModelThinking } from "../../providers/model-thinking.js";
 import { normalizeReasoningLevel, normalizeThinkLevel, normalizeVerboseLevel } from "../transcript/thinking-types.js";
 import "../../session/index.js";
-import { getModelThinking } from "../../providers/model-thinking.js";
 import { mkdir } from "node:fs/promises";
 //#region src/agent/session/session-config-service.ts
 init_src();
@@ -25,6 +26,16 @@ var SessionConfigService = class {
 	* invalid field. Model and thinking are validated together and committed in one write.
 	*/
 	async patch(conversationId, partial) {
+		const configuredThinking = resolveEffectiveAgentConfigForSession(conversationId).config.runtime.thinkingLevel;
+		if (configuredThinking && partial.thinkingLevel !== void 0 && partial.thinkingLevel !== configuredThinking) return {
+			ok: false,
+			code: "INVALID_THINKING",
+			error: `This agent uses thinking ${configuredThinking}`
+		};
+		if (configuredThinking && (partial.model !== void 0 || partial.thinkingLevel !== void 0)) partial = {
+			...partial,
+			thinkingLevel: configuredThinking
+		};
 		if (partial.model !== void 0 || partial.thinkingLevel !== void 0 || partial.fixedModel) {
 			const existing = await this.opts.sessionConfigStore.get(conversationId);
 			if (partial.configVersion !== void 0 && partial.configVersion !== (existing?.updatedAt ?? 0)) return {
@@ -134,6 +145,13 @@ var SessionConfigService = class {
 	}
 	/** Materialize a restored/new chat choice; unavailable identities stay visible for repair. */
 	async initializeModelSelection(conversationId, modelRef, thinkingLevel, configVersion) {
+		const configuredThinking = resolveEffectiveAgentConfigForSession(conversationId).config.runtime.thinkingLevel;
+		if (configuredThinking && thinkingLevel !== void 0 && thinkingLevel !== configuredThinking) return {
+			ok: false,
+			code: "INVALID_THINKING",
+			error: `This agent uses thinking ${configuredThinking}`
+		};
+		if (configuredThinking) thinkingLevel = configuredThinking;
 		const existing = await this.opts.sessionConfigStore.get(conversationId);
 		if (configVersion !== void 0 && configVersion !== (existing?.updatedAt ?? 0)) return {
 			ok: false,
@@ -147,6 +165,11 @@ var SessionConfigService = class {
 			fixedModel: true,
 			configVersion
 		});
+		if (configuredThinking) return {
+			ok: false,
+			code: "INVALID_MODEL",
+			error: `Select an available model that supports thinking ${configuredThinking}`
+		};
 		if (!modelRef.trim() || !modelRef.includes("/")) return {
 			ok: false,
 			code: "INVALID_MODEL",
@@ -192,6 +215,9 @@ var SessionConfigService = class {
 	*/
 	async applyAutomationModelOverride(conversationId, model) {
 		const raw = model?.trim();
+		const configuredThinking = resolveEffectiveAgentConfigForSession(conversationId).config.runtime.thinkingLevel;
+		const selectedModel = raw ? this.opts.modelManager.findByRef(raw) : void 0;
+		if (configuredThinking && (!selectedModel || !getModelThinking(selectedModel).options.includes(configuredThinking))) return false;
 		if (!raw) {
 			await this.clearModelOverride(conversationId);
 			return true;

package/dist/src/agent/session/session-hydrator.js

@@ -3,9 +3,9 @@ import { init_logger } from "../../utils/logger.js";
 import { getExecutionEnvironmentForSession } from "../../execution-environments/subject.js";
 import { effectiveWorkspacePathForSession, normalizeWorkingDirectoryInput, projectWorkspacePath } from "../../session/session-workspace.js";
 import { getProjectForSession } from "../../projects/workspace.js";
+import { getModelThinking } from "../../providers/model-thinking.js";
 import { resolveEffectiveThinkingLevel } from "../../session/thinking-resolve.js";
 import "../../session/index.js";
-import { getModelThinking } from "../../providers/model-thinking.js";
 import { mkdir, stat } from "node:fs/promises";
 //#region src/agent/session/session-hydrator.ts
 /**

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

@@ -61,6 +61,8 @@ import { createManagedJobTool } from "./managed-job-tool.js";
 import { createImageTool } from "./image-tool.js";
 import { createImageGenerateTool } from "./image-generate-tool.js";
 import "./index.js";
+import { createPersonalTaskTool } from "./personal-task-tool.js";
+import { createPersonalPreferenceTool } from "./personal-preference-tool.js";
 import { resolveUserContextSessionAccess } from "../../user-context/access-policy.js";
 import { createBrowserUseTool } from "./browser/tool/browser-use-tool.js";
 import { ComputerRuntime } from "../../computer/runtime.js";
@@ -210,6 +212,7 @@ var AgentToolsFactory = class AgentToolsFactory {
 		const getSkillMgr = options?.getSkillManager;
 		const disabled = options?.disabledTools;
 		const allowed = options?.toolAllowlist ? new Set(options.toolAllowlist) : void 0;
+		const personalToolsConfigured = Boolean(allowed?.has("personal_task") || allowed?.has("personal_preference"));
 		const primary = getPrimary?.();
 		const modelHasVision = primary?.input?.includes("image") ?? false;
 		const cfg = this.deps.getConfig?.();
@@ -261,6 +264,22 @@ var AgentToolsFactory = class AgentToolsFactory {
 		const listDir = createListDirTool(workspace);
 		const grep = createGrepTool(workspace);
 		const find = createFindTool(workspace);
+		const productToolDeps = {
+			getWorkspace: () => this.deps.workspace,
+			getConfig: () => this.deps.getConfig?.(),
+			getCurrentAgentId: () => options?.agentId,
+			getCurrentConversationId: () => this.deps.getCurrentContext()?.conversationId,
+			getAutomationService: this.deps.getAutomationService,
+			getSceneAccess: this.deps.getSceneAccess,
+			getNotesService: this.deps.getNotesService,
+			getProjectService: this.deps.getProjectService,
+			getWorkDiscovery: this.deps.getWorkDiscovery,
+			getLocalAppService: this.deps.getLocalAppService,
+			getChatPreviewService: this.deps.getChatPreviewService,
+			dispatchTaskEvents: this.deps.dispatchTaskEvents,
+			dispatchTaskRuns: this.deps.dispatchTaskRuns,
+			onAgentCatalogMutate: this.deps.onAgentCatalogMutate
+		};
 		const core = [
 			createSessionStatusTool(),
 			createMemoryMaintenanceTool({ getConfig: () => this.deps.getConfig?.() }),
@@ -432,22 +451,10 @@ var AgentToolsFactory = class AgentToolsFactory {
 				getProjectService: this.deps.getProjectService
 			})] : [],
 			...browserEnabled && this.deps.getBrowserAutomationService ? [createBrowserAutomationTool({ getBrowserAutomationService: this.deps.getBrowserAutomationService })] : [],
-			...this.deps.getAutomationService || this.deps.getSceneAccess || this.deps.getProjectService || this.deps.getNotesService || this.deps.getLocalAppService || this.deps.getChatPreviewService || this.deps.dispatchTaskEvents || this.deps.dispatchTaskRuns ? [createXopcUseTool({
-				getWorkspace: () => this.deps.workspace,
-				getConfig: () => this.deps.getConfig?.(),
-				getCurrentAgentId: () => options.agentId,
+			...this.deps.getAutomationService || this.deps.getSceneAccess || this.deps.getProjectService || this.deps.getNotesService || this.deps.getLocalAppService || this.deps.getChatPreviewService || this.deps.dispatchTaskEvents || this.deps.dispatchTaskRuns ? [createXopcUseTool(productToolDeps), ...personalToolsConfigured ? [createPersonalTaskTool(productToolDeps), createPersonalPreferenceTool({
 				getCurrentConversationId: () => this.deps.getCurrentContext()?.conversationId,
-				getAutomationService: this.deps.getAutomationService,
-				getSceneAccess: this.deps.getSceneAccess,
-				getNotesService: this.deps.getNotesService,
-				getProjectService: this.deps.getProjectService,
-				getWorkDiscovery: this.deps.getWorkDiscovery,
-				getLocalAppService: this.deps.getLocalAppService,
-				getChatPreviewService: this.deps.getChatPreviewService,
-				dispatchTaskEvents: this.deps.dispatchTaskEvents,
-				dispatchTaskRuns: this.deps.dispatchTaskRuns,
 				onAgentCatalogMutate: this.deps.onAgentCatalogMutate
-			})] : [],
+			})] : []] : [],
 			...cfg?.computer.enabled && this.deps.endpointTools ? [createComputerUseTool({
 				runtime: this.ensureComputerRuntime(),
 				context: () => {

package/dist/src/agent/tools/personal-preference-tool.d.ts

@@ -0,0 +1,10 @@
+import type { AgentTool } from '@earendil-works/pi-agent-core';
+declare const PreferenceSchema: import("@sinclair/typebox").TObject<{
+    field: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"addressAs">, import("@sinclair/typebox").TLiteral<"warmth">, import("@sinclair/typebox").TLiteral<"humor">, import("@sinclair/typebox").TLiteral<"supportMode">, import("@sinclair/typebox").TLiteral<"detailLevel">, import("@sinclair/typebox").TLiteral<"proactivity">, import("@sinclair/typebox").TLiteral<"guidance">]>;
+    value: import("@sinclair/typebox").TString;
+}>;
+export declare function createPersonalPreferenceTool(deps: {
+    getCurrentConversationId: () => string | undefined;
+    onAgentCatalogMutate?: () => void;
+}): AgentTool<typeof PreferenceSchema, Record<string, never>>;
+export {};

package/dist/src/agent/tools/personal-preference-tool.js

@@ -0,0 +1,44 @@
+import { getPersonalAgentByConversation } from "../../personal-agent/repository.js";
+import { PersonalPreferencesSchema, updatePersonalProfileRecord } from "../../personal-agent/service.js";
+import { Type } from "@sinclair/typebox";
+//#region src/agent/tools/personal-preference-tool.ts
+const PreferenceSchema = Type.Object({
+	field: Type.Union([
+		Type.Literal("addressAs"),
+		Type.Literal("warmth"),
+		Type.Literal("humor"),
+		Type.Literal("supportMode"),
+		Type.Literal("detailLevel"),
+		Type.Literal("proactivity"),
+		Type.Literal("guidance")
+	]),
+	value: Type.String({ description: "Use the exact enum for warmth, humor, supportMode, detailLevel, or proactivity. addressAs is a name. guidance is free text for the user’s precise, explicitly requested lasting response preference; preserve their meaning. Do not store temporary mood or guesswork." })
+});
+function createPersonalPreferenceTool(deps) {
+	return {
+		name: "personal_preference",
+		label: "Personal Preference",
+		description: "Save how the user explicitly wants you to respond in future conversations. Do not save guesses, a temporary mood, or a one-time instruction.",
+		parameters: PreferenceSchema,
+		async execute(_toolCallId, input) {
+			const conversationId = deps.getCurrentConversationId();
+			const personal = conversationId ? getPersonalAgentByConversation(conversationId) : null;
+			if (!personal || personal.state !== "ready") throw new Error("Personal AI conversation is unavailable");
+			const next = PersonalPreferencesSchema.parse({
+				...personal.preferences,
+				[input.field]: input.value.trim()
+			});
+			if (!await updatePersonalProfileRecord(personal.ownerId, personal.revision, personal.displayName, next, personal.appearance)) throw new Error("Preference changed concurrently; read the current profile and try again");
+			deps.onAgentCatalogMutate?.();
+			return {
+				content: [{
+					type: "text",
+					text: `Saved ${input.field} as an explicit preference. It takes effect on the next reply.`
+				}],
+				details: {}
+			};
+		}
+	};
+}
+//#endregion
+export { createPersonalPreferenceTool };

package/dist/src/agent/tools/personal-task-tool.d.ts

@@ -0,0 +1,29 @@
+import type { AgentTool } from '@earendil-works/pi-agent-core';
+import { type XopcUseToolDeps } from './xopc-use-tool.js';
+declare const PersonalTaskSchema: import("@sinclair/typebox").TObject<{
+    command: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"agents">, import("@sinclair/typebox").TLiteral<"create">, import("@sinclair/typebox").TLiteral<"list">, import("@sinclair/typebox").TLiteral<"get">, import("@sinclair/typebox").TLiteral<"instruct">, import("@sinclair/typebox").TLiteral<"answer">]>;
+    title: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    objective: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    agentId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    taskId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    instruction: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    questionId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    expectedOutputs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    acceptanceCriteria: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    constraints: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    requiredTools: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    idempotencyKey: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export declare function buildPersonalTaskBrief(input: {
+    title?: string;
+    objective: string;
+    description?: string;
+}): {
+    title: string;
+    objective: string;
+    body?: string;
+};
+/** A narrow Task surface for the fast personal conversation. */
+export declare function createPersonalTaskTool(deps: XopcUseToolDeps): AgentTool<typeof PersonalTaskSchema, Record<string, never>>;
+export {};