@xopcai/xopc 0.0.227 → 0.0.229

package/dist/src/agent/memory/understanding/service.js

@@ -1,27 +1,12 @@
-import { finishContextExtractionRun, getContextExtractionRun, listContextExtractionOutputs } from "../../../storage/sqlite/context-extraction-repository.js";
+import { getContextExtractionRun } from "../../../storage/sqlite/context-extraction-repository.js";
 import { closeTemporalAssertions, createTemporalAssertion, linkContextObjects } from "../../../storage/sqlite/context-relation-repository.js";
 import { closeUnderstandingValidity, createContextEvidence, createUnderstanding, getUnderstanding, isUnderstandingSuppressed, linkUnderstandingEvidence, listUnderstandings, setUnderstandingStatus } from "../../../storage/sqlite/user-context-repository.js";
 import "../../../storage/sqlite/index.js";
-import { extractExplicitUnderstandingCorrectionContent } from "./correction.js";
-import { claimRegisteredExtraction, extractionInputHash, getRegisteredExtractorDefinition } from "../../../user-context/extraction/registry.js";
+import { getRegisteredExtractorDefinition } from "../../../user-context/extraction/registry.js";
 import { canonicalUnderstandingKey, findContradictoryUnderstanding, findDuplicateUnderstanding } from "../../../user-context/understanding.js";
 import { inferMemorySensitivity, redactSensitiveMemoryText } from "../sensitivity.js";
 //#region src/agent/memory/understanding/service.ts
 const MAX_CANDIDATE_CHARS = 600;
-const EXPLICIT_PATTERNS = [
-	/\b(?:please\s+)?remember(?:\s+that)?\s+(.+)/i,
-	/\bkeep\s+in\s+mind(?:\s+that)?\s+(.+)/i,
-	/(?:请)?记住[：:\s]*(.+)/
-];
-const HIGH_SIGNAL_PATTERNS = [
-	/(?:从现在起|今后|以后)(?:都)?(?:请)?[：:\s]*(.+)/,
-	/下次(?:请)?[：:\s]*(.+)/,
-	/(?:默认|每次|每回)(?:都)?(?:请)?[：:\s]*(.+)/,
-	/((?:我|本人)(?:一直|通常|一般|更)?(?:喜欢|偏好|习惯|希望|不希望|不喜欢).+)/,
-	/\b(?:from now on|going forward|next time|by default|whenever)\b[,:\s]*(.+)/i,
-	/(\bi\s+(?:always|usually|generally)\s+(?:prefer|like|want|need|avoid)\b.+)/i,
-	/(\bi\s+(?:prefer|like|want|need)\s+.+\s+(?:every time|by default|going forward)\b.*)/i
-];
 const SENSITIVITY_RANK = {
 	normal: 0,
 	personal: 1,
@@ -40,50 +25,6 @@ function candidateTime(value) {
 	const parsed = Date.parse(value);
 	return Number.isFinite(parsed) ? parsed : void 0;
 }
-function inferKind(content) {
-	if (/\b(don't|do not|never|avoid)\b/i.test(content) || /不要|不用|无需|别再|禁止|底线/.test(content)) return "boundary";
-	if (/\b(prefer|preference|like)\b/i.test(content) || /喜欢|偏好|习惯/.test(content)) return "preference";
-	if (/\b(project|repo|codebase|workspace)\b/i.test(content) || /项目|仓库|代码库/.test(content)) return "project_context";
-	if (/\b(goal|plan|deadline)\b/i.test(content) || /目标|计划|截止/.test(content)) return "long_term_goal";
-	if (/\b(next time|lesson|failed|error)\b/i.test(content) || /教训|失败|错误/.test(content)) return "task_lesson";
-	if (/习惯|每周|每天|usually|routine/i.test(content)) return "routine";
-	return "current_state";
-}
-function extractExplicitUnderstandingCandidates(userContent) {
-	const correction = extractExplicitUnderstandingCorrectionContent(userContent);
-	const matched = correction ?? userContent.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).flatMap((line) => EXPLICIT_PATTERNS.map((pattern) => pattern.exec(line)?.[1] ?? "")).map(normalizeContent).find((content) => content.length >= 8);
-	if (!matched) return [];
-	const content = normalizeContent(matched);
-	const kind = inferKind(content);
-	return [{
-		kind,
-		content,
-		canonicalKey: canonicalUnderstandingKey(kind, content),
-		confidence: correction ? .98 : .95,
-		importance: kind === "boundary" ? .9 : .8,
-		explicitness: "explicit",
-		durability: "durable",
-		sensitivity: inferMemorySensitivity(content),
-		disclosurePolicy: kind === "boundary" ? "silent" : "referenceable"
-	}];
-}
-function extractHighSignalUnderstandingCandidates(userContent) {
-	if (extractExplicitUnderstandingCorrectionContent(userContent)) return [];
-	const matched = userContent.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).flatMap((line) => HIGH_SIGNAL_PATTERNS.map((pattern) => pattern.exec(line)?.[1] ?? "")).map(normalizeContent).find((content) => content.length >= 6);
-	if (!matched) return [];
-	const kind = inferKind(matched);
-	return [{
-		kind,
-		content: matched,
-		canonicalKey: canonicalUnderstandingKey(kind, matched),
-		confidence: .85,
-		importance: kind === "boundary" ? .9 : .75,
-		explicitness: "observed",
-		durability: "durable",
-		sensitivity: inferMemorySensitivity(matched),
-		disclosurePolicy: kind === "boundary" ? "silent" : "referenceable"
-	}];
-}
 function scopeForCandidate(candidate, context) {
 	if (candidate.durability === "ephemeral" && context.sessionKey) return {
 		type: "session",
@@ -100,116 +41,6 @@ function scopeForCandidate(candidate, context) {
 	return { type: "global" };
 }
 var UserUnderstandingService = class {
-	async reviewTurn(params) {
-		params.assistantContent;
-		const explicitCandidates = extractExplicitUnderstandingCandidates(params.userContent);
-		const candidates = explicitCandidates.length > 0 ? explicitCandidates : extractHighSignalUnderstandingCandidates(params.userContent);
-		const turnRef = params.turnId ?? `untracked-${extractionInputHash(params.userContent).slice(0, 16)}`;
-		const extraction = claimRegisteredExtraction({
-			extractorId: explicitCandidates.length > 0 ? "explicit-command" : "deterministic-signal",
-			sourceRef: params.sessionKey ? `session:${params.sessionKey}:turn:${turnRef}` : `turn:${turnRef}`,
-			contentForHash: params.userContent,
-			processingPolicy: "local_only",
-			destination: "deterministic"
-		});
-		if (!extraction.shouldExecute) {
-			const previous = listContextExtractionOutputs(extraction.run.id);
-			return {
-				proposed: candidates.length,
-				created: 0,
-				deduplicated: previous.filter((output) => output.outcome !== "rejected").length,
-				rejected: previous.filter((output) => output.outcome === "rejected").length,
-				createdRecords: []
-			};
-		}
-		if (candidates.length === 0) {
-			finishContextExtractionRun({
-				runId: extraction.run.id,
-				status: "completed",
-				outputs: []
-			});
-			return {
-				proposed: 0,
-				created: 0,
-				deduplicated: 0,
-				rejected: 0,
-				createdRecords: []
-			};
-		}
-		const safeCandidates = candidates.filter((candidate) => {
-			const content = normalizeContent(candidate.content);
-			const sensitivity = effectiveSensitivity(candidate.sensitivity, content);
-			return sensitivity !== "secret" && sensitivity !== "regulated";
-		});
-		if (!safeCandidates.length) {
-			finishContextExtractionRun({
-				runId: extraction.run.id,
-				status: "completed",
-				outputs: candidates.map((candidate) => ({
-					candidateKey: candidate.canonicalKey ?? canonicalUnderstandingKey(candidate.kind, candidate.content),
-					outcome: "rejected"
-				}))
-			});
-			return {
-				proposed: candidates.length,
-				created: 0,
-				deduplicated: 0,
-				rejected: candidates.length,
-				createdRecords: []
-			};
-		}
-		const evidence = createContextEvidence({
-			sourceType: "conversation",
-			sourceRef: params.sessionKey ? `session:${params.sessionKey}:turn:${turnRef}` : `turn:${turnRef}`,
-			sourceRunId: extraction.run.id,
-			...params.sessionKey ? { sessionId: params.sessionKey } : {},
-			turnId: turnRef,
-			contentHash: extractionInputHash(params.userContent),
-			retentionPolicy: "derived_only",
-			processingPolicy: "local_only",
-			extractorId: extraction.run.extractorId,
-			extractorVersion: extraction.run.extractorVersion,
-			redactedExcerpt: redactSensitiveMemoryText(safeCandidates.map((candidate) => candidate.content).join("\n")).slice(0, MAX_CANDIDATE_CHARS),
-			trustLevel: "owner",
-			observedAt: Date.now()
-		});
-		let result;
-		try {
-			result = await this.applyCandidates(safeCandidates, {
-				sessionKey: params.sessionKey,
-				workspaceId: params.workspaceId,
-				projectId: params.projectId,
-				evidenceIds: [evidence.id],
-				reviewSource: "turn",
-				supersedesRecordIds: params.correctionTargetRecordIds,
-				extractionRunId: extraction.run.id
-			});
-		} catch (error) {
-			finishContextExtractionRun({
-				runId: extraction.run.id,
-				status: "failed",
-				errorCode: "write_failed"
-			});
-			throw error;
-		}
-		finishContextExtractionRun({
-			runId: extraction.run.id,
-			status: "completed",
-			outputs: result.writeOutputs?.map((output) => ({
-				candidateKey: output.candidateKey,
-				objectType: output.objectId ? "understanding" : void 0,
-				objectId: output.objectId,
-				versionId: output.versionId,
-				outcome: output.outcome
-			})) ?? []
-		});
-		return {
-			...result,
-			proposed: candidates.length,
-			rejected: result.rejected + candidates.length - safeCandidates.length,
-			sourceItemId: evidence.id
-		};
-	}
 	async applyCandidates(candidates, context) {
 		let created = 0;
 		let deduplicated = 0;
@@ -332,7 +163,10 @@ var UserUnderstandingService = class {
 					objectId: supersededId,
 					validTo: closedAt
 				});
-				setUnderstandingStatus(supersededId, "archived");
+				setUnderstandingStatus(supersededId, "archived", {
+					actorType: "user",
+					source: "semantic-memory-superseded"
+				});
 			}
 			const assertionType = record.kind === "current_state" ? "current_state" : record.kind === "routine" ? "routine" : record.kind === "relationship" ? "relationship" : record.kind === "project_context" ? "project_status" : void 0;
 			if (assertionType) createTemporalAssertion({
@@ -372,4 +206,4 @@ var UserUnderstandingService = class {
 	}
 };
 //#endregion
-export { UserUnderstandingService, extractExplicitUnderstandingCandidates, extractHighSignalUnderstandingCandidates };
+export { UserUnderstandingService };

package/dist/src/agent/memory/user-context-coordinator.d.ts

@@ -5,7 +5,6 @@ import type { MemoryManager } from './manager.js';
 export interface UserContextCoordinatorOptions {
     getConfig: () => Config | undefined;
     isEnabledForSession: (sessionKey: string) => boolean;
-    getAgentIdForSession: (sessionKey: string) => string;
     getWorkspaceIdForSession?: (sessionKey: string) => string;
     getProjectIdForSession?: (sessionKey: string) => string | undefined;
     getMemoryManagerForSession: (sessionKey: string) => MemoryManager;
@@ -15,11 +14,10 @@ export declare class UserContextCoordinator {
     private readonly options;
     private readonly userTurn;
     private readonly lastTurnId;
-    private readonly correctionTargets;
     private readonly planner;
     constructor(options: UserContextCoordinatorOptions);
     forgetSession(sessionKey: string): void;
     clear(): void;
     prepare(userMessage: AgentMessage, sessionKey: string, turnId: string): Promise<UserContextPlan>;
-    afterTurn(sessionKey: string, userPlainText: string): Promise<import('./understanding/types.js').UnderstandingReviewResult | undefined>;
+    afterTurn(sessionKey: string, userPlainText: string): Promise<void>;
 }

package/dist/src/agent/memory/user-context-coordinator.js

@@ -1,19 +1,12 @@
-import { createLogger } from "../../utils/logger/index.js";
-import { init_logger } from "../../utils/logger.js";
-import { getTurnPersonalization, recordContextFeedback, setUnderstandingStatus } from "../../storage/sqlite/user-context-repository.js";
-import "../../storage/sqlite/index.js";
 import { init_session_key, parseSessionKey } from "../../routing/session-key.js";
 import { assembleTaskContext } from "../../tasks/task-context-assembler.js";
 import { shouldPlanUserContextThisTurn } from "./memory-config.js";
 import { UserContextPlanner, prependAgentContext } from "../../user-context/planner.js";
-import { isExplicitUnderstandingCorrection } from "./understanding/correction.js";
 import { extractAgentUserPlainText } from "./user-message-text.js";
 import { consumeTurnMemoryProvenance, markTurnRecalledContext } from "./turn-provenance.js";
 import { planTrustedRecall } from "./trusted-recall.js";
 //#region src/agent/memory/user-context-coordinator.ts
 init_session_key();
-init_logger();
-const log = createLogger("UserContextCoordinator");
 function isPrivateSession(sessionKey) {
 	const parsed = parseSessionKey(sessionKey);
 	return !parsed || parsed.peerKind === "direct";
@@ -21,7 +14,6 @@ function isPrivateSession(sessionKey) {
 var UserContextCoordinator = class {
 	userTurn = /* @__PURE__ */ new Map();
 	lastTurnId = /* @__PURE__ */ new Map();
-	correctionTargets = /* @__PURE__ */ new Map();
 	planner = new UserContextPlanner();
 	constructor(options) {
 		this.options = options;
@@ -29,12 +21,10 @@ var UserContextCoordinator = class {
 	forgetSession(sessionKey) {
 		this.userTurn.delete(sessionKey);
 		this.lastTurnId.delete(sessionKey);
-		this.correctionTargets.delete(sessionKey);
 	}
 	clear() {
 		this.userTurn.clear();
 		this.lastTurnId.clear();
-		this.correctionTargets.clear();
 	}
 	async prepare(userMessage, sessionKey, turnId) {
 		const empty = () => ({
@@ -50,37 +40,9 @@ var UserContextCoordinator = class {
 		if (!this.options.isEnabledForSession(sessionKey)) return empty();
 		const config = this.options.getConfig();
 		if (!isPrivateSession(sessionKey)) return empty();
-		const userQuery = extractAgentUserPlainText(userMessage);
-		const taskContext = assembleTaskContext(sessionKey, userQuery);
+		const taskContext = assembleTaskContext(sessionKey, extractAgentUserPlainText(userMessage));
 		const query = taskContext.retrievalQuery;
-		const previousTurnId = this.lastTurnId.get(sessionKey);
 		this.lastTurnId.set(sessionKey, turnId);
-		this.correctionTargets.delete(sessionKey);
-		let excludedRecordIds;
-		if (previousTurnId && isExplicitUnderstandingCorrection(userQuery)) try {
-			const personalization = getTurnPersonalization(previousTurnId);
-			const selectedIds = personalization?.items.filter((item) => item.objectType === "understanding" && item.decision === "selected").map((item) => item.objectId) ?? [];
-			if (personalization && selectedIds.length) {
-				for (const recordId of selectedIds) {
-					recordContextFeedback({
-						turnId: previousTurnId,
-						runId: personalization.runId,
-						objectType: "understanding",
-						objectId: recordId,
-						rating: "wrong",
-						reason: "detected_explicit_user_correction"
-					});
-					setUnderstandingStatus(recordId, "needs_review");
-				}
-				this.correctionTargets.set(sessionKey, selectedIds);
-				excludedRecordIds = selectedIds;
-			}
-		} catch (err) {
-			log.debug({
-				err,
-				sessionKey
-			}, "Understanding correction feedback was not persisted");
-		}
 		const turn = (this.userTurn.get(sessionKey) ?? 0) + 1;
 		this.userTurn.set(sessionKey, turn);
 		if (!shouldPlanUserContextThisTurn(config, turn)) return empty();
@@ -92,7 +54,6 @@ var UserContextCoordinator = class {
 			turnId,
 			query,
 			userMessage,
-			excludedRecordIds,
 			allocation: taskContext.allocation
 		});
 		const totalChars = taskContext.allocation.maxChars;
@@ -134,36 +95,12 @@ var UserContextCoordinator = class {
 		};
 	}
 	async afterTurn(sessionKey, userPlainText) {
-		if (!this.options.isEnabledForSession(sessionKey)) return void 0;
+		if (!this.options.isEnabledForSession(sessionKey)) return;
 		const memoryManager = this.options.getMemoryManagerForSession(sessionKey);
 		const assistantContent = this.options.getLastAssistantContent(sessionKey) ?? "";
-		if (!isPrivateSession(sessionKey)) return void 0;
-		const correctionTargetRecordIds = this.correctionTargets.get(sessionKey);
+		if (!isPrivateSession(sessionKey)) return;
 		const turnId = this.lastTurnId.get(sessionKey);
 		const provenance = turnId ? consumeTurnMemoryProvenance(sessionKey, turnId) : void 0;
-		this.correctionTargets.delete(sessionKey);
-		try {
-			const review = await memoryManager.captureTurnUnderstanding(userPlainText, assistantContent, {
-				agentId: this.options.getAgentIdForSession(sessionKey),
-				sessionId: sessionKey,
-				turnId,
-				workspaceId: this.options.getWorkspaceIdForSession?.(sessionKey),
-				projectId: this.options.getProjectIdForSession?.(sessionKey),
-				correctionTargetRecordIds
-			});
-			memoryManager.syncProvidersForTurn(userPlainText, assistantContent, {
-				sessionId: sessionKey,
-				turnId,
-				provenance
-			});
-			memoryManager.queuePrefetchAll(userPlainText, { sessionId: sessionKey });
-			return review;
-		} catch (err) {
-			log.warn({
-				err,
-				sessionKey
-			}, "Turn understanding capture failed");
-		}
 		memoryManager.syncProvidersForTurn(userPlainText, assistantContent, {
 			sessionId: sessionKey,
 			turnId,

package/dist/src/agent/orchestration/agent-orchestrator.js

@@ -110,7 +110,7 @@ var AgentOrchestrator = class {
 					clearPendingTranscriptUserMessage(sessionKey, userMessage);
 				}
 			})();
-			const understandingReview = await this.agentManager.afterAgentTurn(sessionKey, userPlainForMemory);
+			const understandingReview = await this.agentManager.afterAgentTurn(sessionKey, userPlainForMemory, turnId);
 			if (understandingReview?.createdRecords.length) {
 				const captured = understandingReview.createdRecords.filter((record) => record.status === "active");
 				const candidates = understandingReview.createdRecords.filter((record) => record.status === "candidate");

package/dist/src/agent/orchestration/run-agent-turn-with-timeout.d.ts

@@ -6,9 +6,9 @@ import type { Agent } from '@earendil-works/pi-agent-core';
 import type { Config } from '../../config/schema.js';
 /** Minimum per-turn timeout (1 minute). */
 export declare const MIN_AGENT_TURN_TIMEOUT_MS = 60000;
-/** Maximum per-turn timeout (4 hours), aligned with `maxTaskDurationMs` schema cap. */
+/** Maximum configurable per-turn timeout (24 hours). */
 export declare const MAX_AGENT_TURN_TIMEOUT_MS: number;
-/** Default per-turn timeout (30 minutes). */
+/** Default per-turn timeout (4 hours). */
 export declare const DEFAULT_AGENT_TURN_TIMEOUT_MS: number;
 export declare const DEFAULT_AGENT_ABORT_GRACE_MS = 5000;
 export declare class AgentTurnUnsettledError extends Error {

package/dist/src/agent/orchestration/run-agent-turn-with-timeout.js

@@ -2,10 +2,10 @@ import { resolveEffectiveAgentManifestForSession } from "../../config/agent-prof
 //#region src/agent/orchestration/run-agent-turn-with-timeout.ts
 /** Minimum per-turn timeout (1 minute). */
 const MIN_AGENT_TURN_TIMEOUT_MS = 6e4;
-/** Maximum per-turn timeout (4 hours), aligned with `maxTaskDurationMs` schema cap. */
-const MAX_AGENT_TURN_TIMEOUT_MS = 14400 * 1e3;
-/** Default per-turn timeout (30 minutes). */
-const DEFAULT_AGENT_TURN_TIMEOUT_MS = 1800 * 1e3;
+/** Maximum configurable per-turn timeout (24 hours). */
+const MAX_AGENT_TURN_TIMEOUT_MS = 1440 * 60 * 1e3;
+/** Default per-turn timeout (4 hours). */
+const DEFAULT_AGENT_TURN_TIMEOUT_MS = 14400 * 1e3;
 const DEFAULT_AGENT_ABORT_GRACE_MS = 5e3;
 var AgentTurnUnsettledError = class extends Error {
 	constructor(timeoutMs, abortGraceMs) {

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

@@ -116,7 +116,7 @@ async function runDirectAgentTurn(deps, input) {
 		beforeTurn: () => deps.agentManager.beginBackgroundReviewUserTurn(input.sessionKey),
 		onEvent: input.onEvent
 	});
-	const understandingReview = await deps.agentManager.afterAgentTurn(input.sessionKey, userPlain);
+	const understandingReview = await deps.agentManager.afterAgentTurn(input.sessionKey, userPlain, turnId);
 	if (understandingReview?.createdRecords.length) {
 		const captured = understandingReview.createdRecords.filter((record) => record.status === "active");
 		const candidates = understandingReview.createdRecords.filter((record) => record.status === "candidate");

package/dist/src/agent/tools/create-share-tool.js

@@ -226,7 +226,20 @@ function successResult(locale, payload) {
 				isPublic: payload.reachability === "public"
 			}).filter(Boolean).join("\n")
 		}],
-		details: payload
+		details: {
+			...payload,
+			artifacts: [{
+				artifactId: `share:${String(payload.shareUrl ?? "")}`,
+				title: String(payload.title ?? "Shared result"),
+				kind: payload.kind === "site" ? "site" : payload.kind === "zip" ? "archive" : "file",
+				availability: "available",
+				location: "artifact_store",
+				capabilities: payload.kind === "site" ? ["preview", "share"] : ["download", "share"],
+				shareUrl: String(payload.shareUrl ?? ""),
+				...typeof payload.thumbnailUrl === "string" ? { thumbnailUrl: payload.thumbnailUrl } : {},
+				...typeof payload.expiresAt === "string" ? { expiresAt: payload.expiresAt } : {}
+			}]
+		}
 	};
 }
 function errorResult(locale, message) {

package/dist/src/agent/tools/exec-command.js

@@ -4,14 +4,14 @@ import { resolve } from "node:path";
 import { spawn } from "node:child_process";
 import { Type } from "@sinclair/typebox";
 //#region src/agent/tools/exec-command.ts
-const MAX_COMMAND_TIMEOUT_MS = 3e5;
-const DEFAULT_TIMEOUT_MS = 12e4;
+const MAX_COMMAND_TIMEOUT_MS = 14400 * 1e3;
+const DEFAULT_TIMEOUT_MS = 1800 * 1e3;
 const DEFAULT_MAX_OUTPUT_CHARS = 5e4;
 const STREAM_DELTA_MAX_CHARS = 16e3;
 const ExecCommandSchema = Type.Object({
 	cmd: Type.String({ description: "Shell command to execute." }),
 	cwd: Type.Optional(Type.String({ description: "Working directory. Relative paths are resolved under the agent workspace." })),
-	timeoutMs: Type.Optional(Type.Number({ description: "Command timeout in milliseconds. Defaults to 120000 and is capped at 300000." })),
+	timeoutMs: Type.Optional(Type.Number({ description: "Command timeout in milliseconds. Defaults to 1800000 (30m) and is capped at 14400000 (4h)." })),
 	maxOutputChars: Type.Optional(Type.Number({ description: "Maximum characters returned to the model. UI streaming still receives output deltas." }))
 });
 function clampTimeoutMs(raw) {

package/dist/src/agent/tools/execute-code-tool.js

@@ -12,7 +12,7 @@ const MAX_TIMEOUT_SEC = 14400;
 const ExecuteCodeSchema = Type.Object({
 	code: Type.String({ description: "JavaScript to run. Exposed as `tools` (async functions) and `console`:\n  await tools.web_search(query, count?)\n  await tools.web_fetch(url, maxChars?)\n  await tools.read_file(path, limit?)\n  await tools.write_file(path, content)\n  await tools.grep(pattern, { path?, glob?, ignoreCase?, literal?, context?, limit? })\n  await tools.find(pattern, { path?, limit? })\n  await tools.exec_command(cmd, cwd?)\n\nUse console.log() for output; combined stdout/stderr is returned." }),
 	timeout: Type.Optional(Type.Number({
-		description: "Execution timeout in seconds (default: 3600 = 60m, max: 14400 = 4h)",
+		description: "Execution timeout in seconds (default: 1800 = 30m, max: 14400 = 4h)",
 		default: DEFAULT_TIMEOUT_SEC
 	}))
 });

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

@@ -1,13 +1,13 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { TimeoutError, executeWithTimeout } from "../lifecycle/timeout-wrapper.js";
+import { DEFAULT_TOOL_EXECUTION_TIMEOUT_MS, TimeoutError, executeWithTimeout } from "../lifecycle/timeout-wrapper.js";
 import { withRetry } from "../../infra/retry.js";
 import { ToolConcurrencyController, resolveToolLockMode } from "./concurrency.js";
 //#region src/agent/tools/executor.ts
 init_logger();
 const log = createLogger("ToolExecutor");
 const DEFAULT_CONFIG = {
-	defaultTimeoutMs: 300 * 1e3,
+	defaultTimeoutMs: DEFAULT_TOOL_EXECUTION_TIMEOUT_MS,
 	maxRetries: 2,
 	retryDelayMs: 1e3,
 	enableTimeout: true,

package/dist/src/agent/tools/image-generate-tool.js

@@ -296,6 +296,18 @@ function createImageGenerateTool(options) {
 						paths,
 						workspaceRelativePaths,
 						media,
+						artifacts: media.map((item, index) => ({
+							artifactId: item.id,
+							title: item.name,
+							kind: "image",
+							mimeType: item.mimeType,
+							sizeBytes: item.size,
+							availability: "available",
+							location: "artifact_store",
+							capabilities: ["preview", "download"],
+							uri: item.uri,
+							workspaceRelativePath: workspaceRelativePaths[index]
+						})),
 						attempts: result.attempts,
 						...result.normalization ? { normalization: result.normalization } : {},
 						...result.ignoredOverrides.length > 0 ? { ignoredOverrides: result.ignoredOverrides } : {},

package/dist/src/agent/tools/send-media.js

@@ -64,6 +64,17 @@ function createSendMediaTool(workspace, bus, getContext) {
 					}],
 					details: {
 						media: [media],
+						artifacts: [{
+							artifactId: media.id,
+							title: media.name,
+							kind: media.type === "photo" ? "image" : media.type === "video" ? "video" : media.type === "audio" ? "audio" : media.mimeType === "application/pdf" ? "pdf" : "file",
+							mimeType: media.mimeType,
+							sizeBytes: media.size,
+							availability: "available",
+							location: "artifact_store",
+							capabilities: ["preview", "download"],
+							uri: media.uri
+						}],
 						...p.caption ? { caption: p.caption } : {}
 					}
 				};

package/dist/src/agent/tools/xopc-use-tool.js

@@ -6,6 +6,7 @@ import { ObjectLinkService } from "../../activity/service.js";
 import "../../activity/index.js";
 import { getDefaultAgentId, init_resolve_route } from "../../routing/resolve-route.js";
 import { TaskRepository } from "../../tasks/task-repository.js";
+import { enqueueTaskChangedEvent } from "../../tasks/task-change-events.js";
 import { TaskRunRepository } from "../../tasks/task-run-repository.js";
 import { TaskReadModelProjector } from "../../tasks/task-read-model-projector.js";
 import { TaskCommandSchema, TaskContextInputSchema } from "../../../packages/gateway-contract/src/tasks.js";
@@ -15,7 +16,6 @@ import "../../automations/index.js";
 import { isValidProjectAgentId, normalizeProjectAgentId, resolveProjectAgentId } from "../../projects/project-agent.js";
 import "../../projects/index.js";
 import { TaskContextRepository } from "../../tasks/task-context-repository.js";
-import { enqueueTaskChangedEvent } from "../../tasks/task-change-events.js";
 import { TaskDependencyError, TaskDependencyService } from "../../tasks/task-dependency-service.js";
 import { TaskApplicationService } from "../../tasks/task-application-service.js";
 import { defineTaskContract } from "../../tasks/task-contract-definition.js";

package/dist/src/cli/command-loaders.js

@@ -11,6 +11,7 @@ const REGISTRY_COMMAND_MODULES = {
 	tui: () => import("./commands/tui.js"),
 	resume: () => import("./commands/resume.js"),
 	gateway: () => import("./commands/gateway.js"),
+	history: () => import("./commands/history.js"),
 	session: () => import("./commands/session.js"),
 	project: () => import("./commands/project.js"),
 	config: () => import("./commands/config.js"),

package/dist/src/cli/command-manifest.js

@@ -67,6 +67,10 @@ const ROOT_HELP_COMMANDS = [
 		name: "gateway [options]",
 		description: "Start the xopc gateway server"
 	},
+	{
+		name: "history",
+		description: "Export XOPC session history for external tools"
+	},
 	{
 		name: "session",
 		description: "Session management commands"

package/dist/src/cli/commands/doctor/checks/database-schema.js

@@ -52,7 +52,7 @@ async function checkDatabaseSchema(ctx) {
 		id: "database-schema",
 		label: "Database schema",
 		status: "pass",
-		message: `SQLite schema v${status.dbVersion} (current release v135).`,
+		message: `SQLite schema v${status.dbVersion} (current release v137).`,
 		hints: []
 	};
 }

package/dist/src/cli/commands/history.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/cli/commands/history.js

@@ -0,0 +1,50 @@
+import { requireXopcDatabase } from "../../storage/sqlite/connection.js";
+import "../../storage/sqlite/index.js";
+import { formatExamples, register } from "../registry.js";
+import { exportCtxHistory } from "../../history/ctx/exporter.js";
+import { Command } from "commander";
+//#region src/cli/commands/history.ts
+async function runCtxExport(options) {
+	try {
+		const { db } = requireXopcDatabase();
+		const result = await exportCtxHistory(db, { outputDir: options.outputDir });
+		const importCommand = `ctx import --history-source-manifest ${result.manifestPath}`;
+		if (options.json) {
+			console.log(JSON.stringify({
+				...result,
+				importCommand
+			}, null, 2));
+			return;
+		}
+		const action = result.changed ? "Exported" : "Already up to date";
+		console.log(`${action}: ${result.sessionCount} sessions, ${result.eventCount} events`);
+		console.log(`History: ${result.historyPath}`);
+		console.log(`Manifest: ${result.manifestPath}`);
+		console.log(`\nRegister or refresh it in ctx:\n  ${importCommand}`);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		console.error(`Failed to export history for ctx: ${message}`);
+		process.exit(1);
+	}
+}
+function createHistoryCommand(_ctx) {
+	const command = new Command("history").description("Export XOPC session history for external tools").addHelpText("after", formatExamples([
+		"xopc history export ctx",
+		"xopc history export ctx --output-dir ./xopc-ctx-history",
+		"xopc history export ctx --json"
+	]));
+	command.command("export").description("Export session history").command("ctx").description("Export a provider-owned ctx-history-jsonl-v2 source").option("--output-dir <path>", "Output directory (default: <xopc-state>/exports/ctx)").option("--json", "Output the result as JSON").action(runCtxExport);
+	return command;
+}
+register({
+	id: "history",
+	name: "history",
+	description: "Export XOPC session history for external tools",
+	factory: createHistoryCommand,
+	metadata: {
+		category: "utility",
+		examples: ["xopc history export ctx"]
+	}
+});
+//#endregion
+export {};

package/dist/src/config/agent-profile.js

@@ -1,6 +1,6 @@
+import { init_agent_scope, normalizeAgentId, resolveAgentWorkspaceDir } from "../agent/agent-scope.js";
 import { resolveEffectiveAgentManifest } from "../agent-manifest/resolver.js";
 import "../agent-manifest/index.js";
-import { init_agent_scope, normalizeAgentId, resolveAgentWorkspaceDir } from "../agent/agent-scope.js";
 import { init_session_key, parseSessionKey } from "../routing/session-key.js";
 import { agentExists, getDefaultAgentId, init_resolve_route } from "../routing/resolve-route.js";
 //#region src/config/agent-profile.ts

package/dist/src/config/schema.d.ts

@@ -1572,6 +1572,10 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
         }, z.core.$strict>>;
         understanding: z.ZodDefault<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
+            processingPolicy: z.ZodDefault<z.ZodEnum<{
+                local_only: "local_only";
+                remote_allowed: "remote_allowed";
+            }>>;
             adaptiveCadence: z.ZodDefault<z.ZodBoolean>;
             reviewIntervalTurns: z.ZodDefault<z.ZodNumber>;
             maxHistoryMessages: z.ZodDefault<z.ZodNumber>;

package/dist/src/config/schema.js

@@ -1059,6 +1059,7 @@ workDiscoveryOnboarding: z.boolean().default(true) }).strict().default({ workDis
 			},
 			understanding: {
 				enabled: true,
+				processingPolicy: "remote_allowed",
 				adaptiveCadence: true,
 				reviewIntervalTurns: 10,
 				maxHistoryMessages: 80,