@xopcai/xopc 0.0.384 → 0.0.385

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

@@ -9,9 +9,9 @@ import { parseSlashCommand } from "../../chat-commands/command-parse.js";
 import { personalCommandRejection } from "../../chat-commands/personal-command-policy.js";
 import { commandRegistry } from "../../chat-commands/registry.js";
 import "../../chat-commands/index.js";
+import { getTaskContinuation } from "../../tasks/task-continuation.js";
 import { runEmbeddedTurnForSession } from "../embedded/run-for-session.js";
 import { injectSourceContextsIntoUserMessage } from "../source-context/injector.js";
-import { prependAgentContext } from "../context/prepend.js";
 import crypto from "node:crypto";
 //#region src/agent/service/direct-turn-helpers.ts
 /**
@@ -113,10 +113,11 @@ async function runDirectAgentTurn(deps, input) {
 	const turnId = input.runId ?? crypto.randomUUID();
 	const isConnectionResume = Boolean(getConnectionResumeInput(input.conversationId, turnId));
 	const isClarificationResume = Boolean(getClarificationResumeInput(input.conversationId, turnId));
-	const isResume = isConnectionResume || isClarificationResume;
+	const isResume = isConnectionResume || isClarificationResume || Boolean(getTaskContinuation(input.conversationId, turnId));
 	const userContext = await deps.agentManager.prepareUserTurnContext(input.userMessage, input.conversationId, turnId);
 	const sourceContexts = input.sourceContexts ?? [];
-	const userMessageForModel = prependAgentContext(injectSourceContextsIntoUserMessage(input.userMessage, sourceContexts), [buildTaskExecutionDirective(input.conversationId), buildDelegatedTaskDirective(input.conversationId)].filter(Boolean).join("\n"));
+	const sourceEnrichedMessage = injectSourceContextsIntoUserMessage(input.userMessage, sourceContexts);
+	const taskContext = [buildTaskExecutionDirective(input.conversationId), buildDelegatedTaskDirective(input.conversationId)].filter(Boolean).join("\n");
 	const modelRef = deps.modelManager.getModelForSession(input.conversationId);
 	const llmTurn = await hydrateUserTurnForLlm({
 		message: input.userMessage,
@@ -128,8 +129,8 @@ async function runDirectAgentTurn(deps, input) {
 	const result = await runEmbeddedTurnForSession({
 		conversationId: input.conversationId,
 		runId: turnId,
-		userMessage: userMessageForModel,
-		dynamicSystemContext: userContext.dynamicSystemContext,
+		userMessage: sourceEnrichedMessage,
+		dynamicSystemContext: [userContext.dynamicSystemContext, taskContext].filter(Boolean).join("\n\n"),
 		llmImages,
 		presentation: input.presentation,
 		requireVisibleReply: input.requireVisibleReply,

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

@@ -14,6 +14,7 @@ import { formatAgentRunErrorForClient } from "../client-error-format.js";
 import { resolveConfiguredActivityDetailDefault, resolveEffectiveReasoningLevel } from "../../session/thinking-resolve.js";
 import { initSessionTurn } from "../../session/init-session-turn.js";
 import "../../session/index.js";
+import { getTaskContinuation } from "../../tasks/task-continuation.js";
 import { stripEnvelopeTimestampPrefix } from "../../channels/envelope-timestamp.js";
 import { isVoiceLikeAttachment, mergeVoiceTranscriptsIntoUserText, requestsOriginalVoiceInspection } from "../../channels/attachments/voice-stt-webchat.js";
 import { applyReasoningVisibility } from "../streaming/reasoning-visibility.js";
@@ -141,7 +142,7 @@ async function* runProcessDirectStreaming(deps, input) {
 	deps.sessionStore?.idleCompaction?.interrupt(conversationId);
 	const isConnectionResume = Boolean(input.runId && getConnectionResumeInput(conversationId, input.runId));
 	const isClarificationResume = Boolean(input.runId && getClarificationResumeInput(conversationId, input.runId));
-	const isInternalResume = isConnectionResume || isClarificationResume;
+	const isInternalResume = isConnectionResume || isClarificationResume || Boolean(input.runId && getTaskContinuation(conversationId, input.runId));
 	const isTaskUpdate = input.origin.type === "system" && input.origin.source === "task_update";
 	const { channel, chatId } = await deps.resolveSessionEndpoint(conversationId);
 	const context = deps.initDirectStreamingSession(conversationId, channel, chatId, input.origin);
@@ -402,6 +403,11 @@ async function* runProcessDirectStreaming(deps, input) {
 	try {
 		for await (const event of queue) yield event;
 		await taskPromise;
+		if (streamOverflowed) yield {
+			type: "error",
+			runId: input.runId,
+			content: formatStreamError("Agent stream stopped because its critical event buffer overflowed")
+		};
 		if (channel === "webchat" && ranSlashCommand) try {
 			const userMsg = {
 				role: "user",

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

@@ -6,12 +6,14 @@ import { resolveEffectiveAgentProfileForSession } from "../../config/agent-profi
 import { getAgentDefaultModelRef, init_schema } from "../../config/schema.js";
 import { getApiKey, init_providers, resolveModel } from "../../providers/index.js";
 import { completeWithResolvedCredentials } from "../../providers/model-call.js";
-import { extractAssistantText, getAssistantMessageErrorReason, stripCodeFences } from "../../providers/model-response.js";
+import { extractAssistantText, getAssistantMessageErrorReason, isTransientProviderErrorMessage, stripCodeFences } from "../../providers/model-response.js";
+import { canResumeAfterModelFailure } from "../orchestration/turn-recovery.js";
 import { resolveTaskLocale } from "../../tasks/task-language.js";
 import { TaskConversationRepository } from "../../tasks/task-conversation-repository.js";
 import { readWorkspaceRevision } from "../coding/workspace-revision.js";
 import { buildResponseLanguageSection } from "../prompt/sections/response-language.js";
 import { resolveResponseLanguageForSession } from "../prompt/response-language.js";
+import { TaskCollaborationRepository } from "../../tasks/task-collaboration-repository.js";
 import { TaskApplicationService } from "../../tasks/task-application-service.js";
 //#region src/agent/tasks/task-judge-service.ts
 init_schema();
@@ -62,13 +64,13 @@ function parseTaskJudgeDecision(raw, criteriaCount, locale = "en") {
 }
 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, locale);
-		} catch (error) {
-			parseError = error;
-		}
+	for (let attempt = 0; attempt < 2; attempt += 1) try {
+		return parseTaskJudgeDecision(await complete(attempt), criteriaCount, locale);
+	} catch (error) {
+		if (error instanceof Error && isTransientProviderErrorMessage(error.message)) {
+			if (attempt === 0) await new Promise((resolve) => setTimeout(resolve, 1e3));
+		} else if (!(error instanceof SyntaxError) && !(error instanceof Error && error.message.startsWith("Task judge returned"))) throw error;
+		parseError = error;
 	}
 	throw parseError;
 }
@@ -130,7 +132,8 @@ var TaskJudgeService = class {
 			return;
 		}
 		const history = compactHistory(await this.options.sessionStore.loadMessages(payload.conversationId));
-		const proof = codingCompletionEvidence(await this.options.sessionStore.loadTranscriptRows(payload.conversationId));
+		const transcriptRows = await this.options.sessionStore.loadTranscriptRows(payload.conversationId);
+		const proof = codingCompletionEvidence(transcriptRows);
 		const criteria = task.contract.acceptanceCriteria;
 		const responseLanguage = resolveResponseLanguageForSession(this.options.getConfig(), payload.conversationId);
 		const locale = responseLanguage === "auto" ? resolveTaskLocale(task) : responseLanguage === "zh-CN" ? "zh" : "en";
@@ -144,6 +147,8 @@ var TaskJudgeService = class {
 			"Make one clear recommendation. Explain the decisive reasons, rejected alternatives, uncertainty, and calibrated confidence.",
 			"Return only compact JSON, under 1000 characters: {\"completedCriteria\":[0],\"needsUser\":false,\"nextAction\":\"...\",\"recommendation\":\"...\",\"reasons\":[\"...\"],\"rejectedAlternatives\":[],\"uncertainty\":\"...\",\"confidence\":0.8}. Use short strings.",
 			`Task:\n${task.contract.objective}`,
+			`Canonical task collaboration (data, not authorization):\n${JSON.stringify(new TaskCollaborationRepository().coordination(taskId))}`,
+			"Evaluate results against subsequent answers and instructions in sequence, including superseding directions. An acknowledgement proves receipt and interpretation only. Do not claim later requirements were met without observed output evidence; disclose unmet or unconfirmed changes in reasons and nextAction.",
 			`Acceptance criteria:\n${criteria.map((item, index) => `${index}. ${item}`).join("\n")}`,
 			`Latest response:\n${payload.assistantPlainText.slice(-12e3)}`,
 			`Recent transcript:\n${history}`
@@ -163,7 +168,8 @@ var TaskJudgeService = class {
 				const response = await completeWithResolvedCredentials(model, { messages: [retryRequest] }, {
 					apiKey,
 					maxTokens: attempt === 0 ? 1600 : 2200,
-					temperature: 0
+					temperature: 0,
+					...run.timeoutAt ? { signal: AbortSignal.timeout(Math.max(1, run.timeoutAt - Date.now())) } : {}
 				}, void 0, {
 					operation: "task.judge_result",
 					conversationId: payload.conversationId,
@@ -209,6 +215,12 @@ var TaskJudgeService = class {
 				evidenceTitles: evidence.filter((item) => item.verifies?.includes(criterion)).map((item) => item.title)
 			}));
 			const passed = checks.every((check) => check.status === "passed");
+			if (!passed && canResumeAfterModelFailure(transcriptRows) && this.#runs.scheduleContinuation({
+				runId: run.id,
+				expectedVersion: run.version,
+				reason: "acceptance_incomplete",
+				message: `Continue the existing task from its recorded progress. Do not repeat completed operations.\nRemaining acceptance criteria:\n${checks.filter((check) => check.status !== "passed").map((check) => check.criterion).join("\n")}\n${decision.nextAction ?? ""}`
+			})) return;
 			this.#application.completeRun({
 				runId: run.id,
 				expectedRunVersion: run.version,
@@ -234,6 +246,12 @@ var TaskJudgeService = class {
 				taskId,
 				conversationId: payload.conversationId
 			}, "Task review failed");
+			if (isTransientProviderErrorMessage(error instanceof Error ? error.message : String(error)) && canResumeAfterModelFailure(transcriptRows)) this.#runs.scheduleContinuation({
+				runId: run.id,
+				expectedVersion: run.version,
+				reason: "acceptance_check_failed",
+				message: "The independent acceptance check failed because of a temporary model error. Continue from the recorded results and verify the remaining acceptance criteria. Do not repeat completed operations."
+			});
 		}
 	}
 };

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

@@ -69,6 +69,7 @@ import { createManagedJobTool } from "./managed-job-tool.js";
 import { createImageTool } from "./image-tool.js";
 import { createImageGenerateTool } from "./image-generate-tool.js";
 import { createPersonalReadTool } from "./personal-read-tool.js";
+import { createTaskCollaborationTool } from "./task-collaboration-tool.js";
 import "./index.js";
 import { createPersonalTaskTool } from "./personal-task-tool.js";
 import { createPersonalRequestTools } from "./personal-request-tool.js";
@@ -272,6 +273,7 @@ var AgentToolsFactory = class AgentToolsFactory {
 			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");
+			allowed.add("task_collaboration");
 		}
 		const deliveryContext = () => {
 			if (currentConversationId() && getSessionMetadata(currentConversationId())?.sessionType === "heartbeat") throw new Error("Heartbeat notifications must be returned in the final response for policy-controlled delivery.");
@@ -612,7 +614,14 @@ var AgentToolsFactory = class AgentToolsFactory {
 				}
 			})] : [],
 			...optionalTools,
-			...personalExecution ? [createPersonalRequestResultTool(currentConversationId), createPersonalRequestConnectionTool(currentConversationId)] : []
+			...personalExecution ? [
+				createPersonalRequestResultTool(currentConversationId),
+				createPersonalRequestConnectionTool(currentConversationId),
+				createTaskCollaborationTool({
+					...productToolDeps,
+					getCurrentConversationId: currentConversationId
+				})
+			] : []
 		];
 		if ([
 			"read_file",

package/dist/src/agent/tools/index.d.ts

@@ -43,3 +43,4 @@ export { createImageGenerateTool, resolveImageGenerationModelConfigForTool } fro
 export { truncateHead, truncateTail, truncateLine, formatSize, type TruncationResult, type TruncationOptions, DEFAULT_MAX_LINES, DEFAULT_MAX_BYTES, GREP_MAX_LINE_LENGTH, } from './truncate.js';
 export { normalizeToLF, restoreLineEndings, normalizeForFuzzyMatch, fuzzyFindText, stripBom, generateDiffString, type FuzzyMatchResult, } from './edit-diff.js';
 export { createPersonalReadTool } from './personal-read-tool.js';
+export { createTaskCollaborationTool } from './task-collaboration-tool.js';

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

@@ -46,4 +46,5 @@ import { createManagedJobTool } from "./managed-job-tool.js";
 import { createImageTool } from "./image-tool.js";
 import { createImageGenerateTool, resolveImageGenerationModelConfigForTool } from "./image-generate-tool.js";
 import { createPersonalReadTool } from "./personal-read-tool.js";
-export { BrowserRuntime, DEFAULT_DELEGATE_TOOLS, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, DEFAULT_TOOL_METADATA, DEFAULT_WEB_EXTRACT_MAX_LENGTH, DELEGATE_BLOCKED_TOOLS, GREP_MAX_LINE_LENGTH, MAX_RAW_HTML_CHARS_FOR_WEB_EXTRACT, TodoStore, ToolConcurrencyController, assertBrowserUrlAllowed, createApplyPatchTool, createAutomationTool, createBrowserAutomationTool, createClarifyTool, createCreateShareTool, createDataBatchTool, createDelegateTool, createDesktopPetTool, createExecCommandTool, createFindTool, createGrepTool, createImageGenerateTool, createImageTool, createKnowledgeGetTool, createKnowledgeReadTool, createKnowledgeSearchTool, createKnowledgeWriteTool, createListDirTool, createManagedJobTool, createMemoryMaintenanceTool, createMessageTool, createPersonalReadTool, createPublishArtifactsTool, createReadFileTool, createReadMediaTool, createSendMediaTool, createSessionRecallTool, createSessionSearchTool, createSessionStatusTool, createSkillInstallTool, createSkillManageTool, createSkillViewTool, createSkillsListTool, createSkillsMarketplaceSearchTool, createTodoTool, createToolManualTool, createUpdatePlanTool, createUserContextGetTool, createUserContextReadTool, createUserContextSearchTool, createUserContextUpdateTool, createWebExtractTool, createWebFetchTool, createWebSearchTool, createWorkflowManageTool, createWorkflowTool, createWriteFileTool, createXopcUseTool, findTool, formatSize, fuzzyFindText, generateDiffString, getToolMetadata, grepTool, isShareToolAvailable, listDirTool, normalizeForFuzzyMatch, normalizeToLF, resolveImageGenerationModelConfigForTool, resolveImageModelConfigForTool, resolveToolLockMode, restoreLineEndings, stripBom, stripHtmlBoilerplate, truncateHead, truncateLine, truncateTail, writeFileTool };
+import { createTaskCollaborationTool } from "./task-collaboration-tool.js";
+export { BrowserRuntime, DEFAULT_DELEGATE_TOOLS, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, DEFAULT_TOOL_METADATA, DEFAULT_WEB_EXTRACT_MAX_LENGTH, DELEGATE_BLOCKED_TOOLS, GREP_MAX_LINE_LENGTH, MAX_RAW_HTML_CHARS_FOR_WEB_EXTRACT, TodoStore, ToolConcurrencyController, assertBrowserUrlAllowed, createApplyPatchTool, createAutomationTool, createBrowserAutomationTool, createClarifyTool, createCreateShareTool, createDataBatchTool, createDelegateTool, createDesktopPetTool, createExecCommandTool, createFindTool, createGrepTool, createImageGenerateTool, createImageTool, createKnowledgeGetTool, createKnowledgeReadTool, createKnowledgeSearchTool, createKnowledgeWriteTool, createListDirTool, createManagedJobTool, createMemoryMaintenanceTool, createMessageTool, createPersonalReadTool, createPublishArtifactsTool, createReadFileTool, createReadMediaTool, createSendMediaTool, createSessionRecallTool, createSessionSearchTool, createSessionStatusTool, createSkillInstallTool, createSkillManageTool, createSkillViewTool, createSkillsListTool, createSkillsMarketplaceSearchTool, createTaskCollaborationTool, createTodoTool, createToolManualTool, createUpdatePlanTool, createUserContextGetTool, createUserContextReadTool, createUserContextSearchTool, createUserContextUpdateTool, createWebExtractTool, createWebFetchTool, createWebSearchTool, createWorkflowManageTool, createWorkflowTool, createWriteFileTool, createXopcUseTool, findTool, formatSize, fuzzyFindText, generateDiffString, getToolMetadata, grepTool, isShareToolAvailable, listDirTool, normalizeForFuzzyMatch, normalizeToLF, resolveImageGenerationModelConfigForTool, resolveImageModelConfigForTool, resolveToolLockMode, restoreLineEndings, stripBom, stripHtmlBoilerplate, truncateHead, truncateLine, truncateTail, writeFileTool };

package/dist/src/agent/tools/personal-request-result-tool.js

@@ -1,6 +1,9 @@
-import { getSqliteDatabase, init_transaction } from "../../storage/sqlite/transaction.js";
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
 import { TaskRunRepository, init_task_run_repository } from "../../tasks/task-run-repository.js";
 import { init_request_repository, personalRequestForExecution } from "../../personal-agent/request-repository.js";
+import { assertPersonalRequestAccountAccess } from "../../personal-agent/request-access.js";
+import { TaskCollaborationRepository } from "../../tasks/task-collaboration-repository.js";
+import { selectionRequestHash } from "../../agent-matching/selection-repository.js";
 import { PersonalRequestResultSchema } from "../../personal-agent/request-result.js";
 import { Type } from "@sinclair/typebox";
 //#region src/agent/tools/personal-request-result-tool.ts
@@ -47,8 +50,22 @@ function createPersonalRequestResultTool(conversationId) {
 			if (result.coverage && Date.parse(result.coverage.from) >= Date.parse(result.coverage.to)) throw new Error("Invalid coverage range");
 			if (result.coverage && request.parameters.timeRange && (Date.parse(result.coverage.from) > Date.parse(request.parameters.timeRange.from) || Date.parse(result.coverage.to) < Date.parse(request.parameters.timeRange.to))) result.coverage.partial = true;
 			const run = request.taskId ? new TaskRunRepository().getActiveRoot(request.taskId) : void 0;
-			if (!run || run.conversationId !== id) throw new Error("Task execution changed");
-			getSqliteDatabase().prepare("UPDATE personal_requests SET result_json = ?, result_run_id = ?, updated_at = ? WHERE request_id = ?").run(JSON.stringify(result), run.id, Date.now(), request.requestId);
+			if (!run || run.conversationId !== id || !["running", "verifying"].includes(run.status)) throw new Error("Task execution changed");
+			assertPersonalRequestAccountAccess(request);
+			runSqliteWriteTransaction(() => {
+				const board = new TaskCollaborationRepository();
+				const direction = board.coordination(run.taskId).filter((entry) => ["main_agent", "user"].includes(entry.authorKind) && ["answer", "instruction"].includes(entry.kind)).at(-1)?.sequence ?? 0;
+				board.append({
+					taskId: run.taskId,
+					taskRunId: run.id,
+					authorKind: "worker_agent",
+					authorId: request.executorAgentId,
+					kind: "result",
+					body: result.summary,
+					idempotencyKey: `personal-request-result:${request.requestId}:${run.id}:${direction}:${selectionRequestHash(result)}`
+				});
+				getSqliteDatabase().prepare("UPDATE personal_requests SET result_json = ?, result_run_id = ?, updated_at = ? WHERE request_id = ?").run(JSON.stringify(result), run.id, Date.now(), request.requestId);
+			});
 			return {
 				content: [{
 					type: "text",

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

@@ -1,13 +1,24 @@
-import { getSqliteDatabase, init_transaction } from "../../storage/sqlite/transaction.js";
-import { getPersonalRequest, init_request_repository, listPersonalRequests } from "../../personal-agent/request-repository.js";
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { init_session_instance_repository, readCurrentTranscriptId } from "../../storage/sqlite/session-instance-repository.js";
+import { getSessionInputState, init_session_input_repository } from "../../storage/sqlite/session-input-repository.js";
+import { getPersonalRequest, init_request_repository, listPersonalRequests, updatePersonalRequest } from "../../personal-agent/request-repository.js";
+import { getActiveConnectionWait, init_connection_wait_repository, reviseCurrentConnectionObjective, updateConnectionWait } 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 { isPersonalConversation } from "../../personal-agent/repository.js";
 import { TaskAllocationRepository } from "../../tasks/task-allocation-repository.js";
 import { boundedPersonalResult } from "./personal-result-budget.js";
+import { selectionRequestHash } from "../../agent-matching/selection-repository.js";
 import { cancelPersonalTask } from "../../personal-agent/task-cancel.js";
+import { createPersonalTaskTool } from "./personal-task-tool.js";
 import { personalCapabilities } from "../../personal-agent/capability-service.js";
-import { cancelPersonalRequest, personalRequestSnapshot, publishPersonalRequest, submitPersonalRequest } from "../../personal-agent/request-service.js";
+import { assertPersonalRequestTimeRange, cancelPersonalRequest, personalRequestSnapshot, publishPersonalRequest, submitPersonalRequest } from "../../personal-agent/request-service.js";
 import { Type } from "@sinclair/typebox";
 //#region src/agent/tools/personal-request-tool.ts
+init_session_input_repository();
+init_session_repository();
+init_session_instance_repository();
+init_connection_wait_repository();
 init_request_repository();
 init_transaction();
 const CapabilitySchema = Type.Object({
@@ -22,8 +33,20 @@ const RequestSchema = Type.Object({
 		"submit",
 		"get",
 		"list",
-		"cancel"
+		"cancel",
+		"answer",
+		"instruct",
+		"collaboration",
+		"entry"
 	].map((command) => Type.Literal(command))),
+	instruction: Type.Optional(Type.String({
+		minLength: 1,
+		maxLength: 8e3
+	})),
+	questionId: Type.Optional(Type.String({ minLength: 1 })),
+	entryId: Type.Optional(Type.String({ minLength: 1 })),
+	afterSequence: Type.Optional(Type.Integer({ minimum: 0 })),
+	bodyOffset: Type.Optional(Type.Integer({ minimum: 0 })),
 	requestId: Type.Optional(Type.String()),
 	offset: Type.Optional(Type.Integer({ minimum: 0 })),
 	limit: Type.Optional(Type.Integer({
@@ -32,6 +55,11 @@ const RequestSchema = Type.Object({
 	})),
 	connectorId: Type.Optional(Type.String()),
 	accountId: Type.Optional(Type.String()),
+	description: Type.Optional(Type.String({
+		minLength: 1,
+		maxLength: 16e3,
+		description: "Complete task brief preserving all user requirements, stages, inputs, outputs and constraints. Do not replace exact specifications with a short objective or a reference to an unspecified process."
+	})),
 	objective: Type.Optional(Type.String({
 		minLength: 1,
 		maxLength: 4e3
@@ -51,12 +79,36 @@ const RequestSchema = Type.Object({
 	anyOf: [
 		{
 			properties: { command: { const: "submit" } },
-			required: ["objective", "connectorId"]
+			required: [
+				"objective",
+				"connectorId",
+				"description"
+			]
 		},
 		{ properties: { command: { const: "list" } } },
 		{
-			properties: { command: { enum: ["get", "cancel"] } },
+			properties: { command: { enum: [
+				"get",
+				"cancel",
+				"collaboration"
+			] } },
 			required: ["requestId"]
+		},
+		{
+			properties: { command: { const: "entry" } },
+			required: ["requestId", "entryId"]
+		},
+		{
+			properties: { command: { const: "instruct" } },
+			required: ["requestId", "instruction"]
+		},
+		{
+			properties: { command: { const: "answer" } },
+			required: [
+				"requestId",
+				"questionId",
+				"instruction"
+			]
 		}
 	]
 });
@@ -74,6 +126,20 @@ function createPersonalRequestTools(deps) {
 			...value.taskId ? { allocation: new TaskAllocationRepository().summary(value.taskId) } : {}
 		};
 	};
+	const compactSnapshot = (request) => {
+		const value = snapshot(request);
+		return {
+			requestId: value.requestId,
+			taskId: value.taskId,
+			state: value.state,
+			version: value.version,
+			connectorId: value.connectorId,
+			accountId: value.accountId,
+			executorAgentId: value.executorAgentId,
+			..."allocation" in value ? { allocation: value.allocation } : {},
+			parameters: { timeRange: value.parameters.timeRange }
+		};
+	};
 	const result = (value) => ({
 		content: [{
 			type: "text",
@@ -97,14 +163,18 @@ function createPersonalRequestTools(deps) {
 		name: "personal_request",
 		label: "Connected app request",
 		parameters: RequestSchema,
-		description: "Submit a read-only connected-app request using the exact connectorId from personal_capability. The background Task Router chooses an executor after account authorization. Preserves the objective, displays connection or account selection in this main chat, and starts a specialist Task automatically once connected. Return quickly after submission. Never claim data was read until the Task result arrives. Resolve absolute query dates and include timeRange. If mail has no user-specified range, the host returns an explicit last-7-days default; mention that range in your confirmation. Use paginated get/list for status without polling; preserve idempotencyKey on uncertain retries; cancel only when the user requests it.",
+		description: "Submit a read-only connected-app request with a short objective and complete description using the exact connectorId from personal_capability. The background Task Router chooses an executor after account authorization. Preserves the objective, displays connection or account selection in this main chat, and starts a specialist Task automatically once connected. Return quickly after submission. Never claim data was read until the Task result arrives. Resolve absolute query dates and include timeRange. If mail has no user-specified range, the host returns an explicit last-7-days default; mention that range in your confirmation. get includes complete Task coordination state; collaboration/entry read the same board and full questions. answer forwards the exact questionId; instruct forwards new requirements to the existing Task. Answers and instructions cannot change the connector/account, grant access or allow writes; reconnection stays in the existing connection UI. Saved, delivered, executor-confirmed and verified are distinct states. Use get/list for status without polling; preserve idempotencyKey on uncertain retries; cancel only when the user requests it.",
 		async execute(toolCallId, input) {
 			const conversationId = conversation();
 			if (input.command === "list") {
 				const offset = input.offset ?? 0;
 				const items = listPersonalRequests(conversationId, input.limit ?? 10, offset).map((request) => {
-					const { result: _result, ...summary } = snapshot(request);
-					return summary;
+					const { result: _result, parameters, ...summary } = snapshot(request);
+					const { brief: _brief, ...queryParameters } = parameters;
+					return {
+						...summary,
+						parameters: queryParameters
+					};
 				});
 				const total = getSqliteDatabase().prepare("SELECT count(*) AS count FROM personal_requests WHERE conversation_id = ?").get(conversationId).count;
 				return result(boundedPersonalResult({
@@ -120,21 +190,29 @@ function createPersonalRequestTools(deps) {
 					connectorId: input.connectorId,
 					accountId: input.accountId,
 					objective: input.objective.trim(),
+					description: input.description?.trim(),
 					timeRange: input.timeRange,
-					idempotencyKey: input.idempotencyKey ?? toolCallId
+					idempotencyKey: input.idempotencyKey ?? `personal-request-submit:${selectionRequestHash({
+						inputId: getSessionInputState(conversationId).activeInputId ?? toolCallId,
+						objective: input.objective.trim(),
+						description: input.description?.trim(),
+						connectorId: input.connectorId,
+						accountId: input.accountId,
+						timeRange: input.timeRange
+					})}`
 				});
 				publishPersonalRequest(request);
 				deps.dispatchTaskRuns?.();
-				return result(boundedPersonalResult(snapshot(request)));
+				return result(compactSnapshot(request));
 			}
 			const request = input.requestId ? getPersonalRequest(input.requestId) : void 0;
 			if (!request || request.conversationId !== conversationId) throw new Error("Request does not belong to this conversation");
 			if (input.command === "cancel") {
-				if (["completed", "failed"].includes(personalRequestSnapshot(request).state)) return result(boundedPersonalResult(snapshot(request)));
+				if (["completed", "failed"].includes(personalRequestSnapshot(request).state)) return result(compactSnapshot(request));
 				if (request.state === "cancelled") {
 					const stop = request.taskId ? await cancelPersonalTask(request.taskId, conversationId, input.idempotencyKey ?? toolCallId) : { executionStopConfirmed: true };
 					return result({
-						...snapshot(request),
+						...compactSnapshot(request),
 						executionStopConfirmed: stop.executionStopConfirmed
 					});
 				}
@@ -142,11 +220,80 @@ function createPersonalRequestTools(deps) {
 				const cancelled = cancelPersonalRequest(request);
 				publishPersonalRequest(cancelled);
 				return result({
-					...cancelled,
+					...compactSnapshot(cancelled),
 					executionStopConfirmed: stop.executionStopConfirmed
 				});
 			}
-			return result(boundedPersonalResult(snapshot(request)));
+			const taskTool = createPersonalTaskTool({
+				...deps,
+				getCurrentAgentId: () => deps.getCurrentAgentId?.() ?? getSessionMetadata(conversationId)?.agentId
+			});
+			if (input.command === "instruct" && input.timeRange) assertPersonalRequestTimeRange(input.timeRange);
+			const instruction = input.command === "instruct" && input.timeRange ? `${input.instruction}\n\nUpdated absolute query range: ${JSON.stringify(input.timeRange)}` : input.instruction;
+			if (input.command === "answer" || input.command === "instruct") {
+				if ([
+					"completed",
+					"failed",
+					"cancelled"
+				].includes(personalRequestSnapshot(request).state)) throw new Error("Request is no longer active");
+				if (readCurrentTranscriptId(getSqliteDatabase(), conversationId) !== request.transcriptId) throw new Error("SESSION_CHANGED");
+				if (!request.taskId && input.command === "instruct" && request.state === "waiting_connection") {
+					const addition = `\n\nSupplemental requirement:\n${instruction.trim()}`;
+					if (!request.objective.endsWith(addition)) runSqliteWriteTransaction(() => {
+						if (getActiveConnectionWait(conversationId)?.id !== request.connectionWaitId) throw new Error("Connection objective changed");
+						reviseCurrentConnectionObjective(conversationId, request.objective + addition);
+						const revised = getActiveConnectionWait(conversationId);
+						updateConnectionWait({
+							...revised,
+							checkpoint: {
+								...revised.checkpoint,
+								timeRange: input.timeRange ?? request.parameters.timeRange
+							}
+						}, revised.version);
+						updatePersonalRequest(request, {
+							objective: request.objective + addition,
+							parameters: {
+								...request.parameters,
+								...input.timeRange ? { timeRange: input.timeRange } : {}
+							}
+						});
+					});
+					return result({
+						...snapshot(getPersonalRequest(request.requestId)),
+						instructionStatus: "saved",
+						guidance: "Account authorization is still required. The existing Request will create its Task with this requirement after authorization."
+					});
+				}
+			}
+			if (input.command !== "get" || request.taskId) {
+				if (!request.taskId) throw new Error("No Task yet; complete account authorization in the main connection UI");
+				const coordinated = await taskTool.execute(toolCallId, {
+					...input,
+					instruction,
+					taskId: request.taskId
+				});
+				if (input.command === "instruct" && input.timeRange && JSON.parse(coordinated.content[0].text).ok === true) runSqliteWriteTransaction(() => {
+					const current = getPersonalRequest(request.requestId);
+					updatePersonalRequest(current, { parameters: {
+						...current.parameters,
+						timeRange: input.timeRange
+					} });
+					const wait = getActiveConnectionWait(conversationId);
+					if (wait && wait.id === current.connectionWaitId) updateConnectionWait({
+						...wait,
+						checkpoint: {
+							...wait.checkpoint,
+							timeRange: input.timeRange
+						}
+					}, wait.version);
+				});
+				if (input.command !== "get") return coordinated;
+				return result({
+					...snapshot(request),
+					coordination: JSON.parse(coordinated.content[0].text)
+				});
+			}
+			return result(snapshot(request));
 		}
 	}];
 }

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

@@ -12,7 +12,7 @@ declare const PersonalTaskModelSchema: import("@sinclair/typebox").TObject<{
         taskType: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
         requestedAgentId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     }>>;
-    command: import("@sinclair/typebox").TUnion<import("@sinclair/typebox").TLiteral<"get" | "answer" | "retry_allocation" | "selection" | "list" | "cancel" | "submit" | "instruct">[]>;
+    command: import("@sinclair/typebox").TUnion<import("@sinclair/typebox").TLiteral<"get" | "answer" | "retry_allocation" | "selection" | "list" | "cancel" | "entry" | "submit" | "instruct" | "collaboration">[]>;
     requestId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     title: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     taskId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
@@ -26,6 +26,10 @@ declare const PersonalTaskModelSchema: import("@sinclair/typebox").TObject<{
     limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
     offset: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
     instruction: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    section: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<import("@sinclair/typebox").TLiteral<string>[]>>;
+    entryId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    afterSequence: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    bodyOffset: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
     questionId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
 }>;
 export interface PersonalTaskToolDeps extends XopcUseToolDeps {