@xopcai/xopc 0.0.228 → 0.0.230

package/dist/src/agent/memory/manager.d.ts

@@ -39,17 +39,6 @@ export declare class MemoryManager {
     queuePrefetchAll(query: string, options?: {
         sessionId?: string;
     }): void;
-    syncAll(userContent: string, assistantContent: string, options?: {
-        sessionId?: string;
-    }): Promise<void>;
-    captureTurnUnderstanding(userContent: string, assistantContent: string, options?: {
-        agentId?: string;
-        sessionId?: string;
-        turnId?: string;
-        workspaceId?: string;
-        projectId?: string;
-        correctionTargetRecordIds?: string[];
-    }): Promise<import('./understanding/types.js').UnderstandingReviewResult>;
     syncProvidersForTurn(userContent: string, assistantContent: string, options?: {
         sessionId?: string;
         turnId?: string;
@@ -67,6 +56,7 @@ export declare class MemoryManager {
         source?: MemoryRecord['source'];
         reviewSource?: 'turn' | 'background';
         extractionRunId?: string;
+        supersedesRecordIds?: string[];
     }): Promise<import('./understanding/types.js').UnderstandingReviewResult>;
     getExternalToolEntries(): Array<{
         providerId: string;

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

@@ -81,22 +81,6 @@ var MemoryManager = class {
 			}, "queuePrefetch failed (non-fatal)");
 		}
 	}
-	async syncAll(userContent, assistantContent, options) {
-		await this.captureTurnUnderstanding(userContent, assistantContent, options);
-		await this.syncProvidersForTurn(userContent, assistantContent, options);
-	}
-	async captureTurnUnderstanding(userContent, assistantContent, options) {
-		const sessionContext = options?.sessionId ? this.sessionContexts.get(options.sessionId) : void 0;
-		return await this.understanding.reviewTurn({
-			userContent,
-			assistantContent,
-			sessionKey: options?.sessionId,
-			turnId: options?.turnId,
-			workspaceId: options?.workspaceId ?? sessionContext?.workspace ?? sessionContext?.agentWorkspace,
-			projectId: options?.projectId,
-			correctionTargetRecordIds: options?.correctionTargetRecordIds
-		});
-	}
 	async syncProvidersForTurn(userContent, assistantContent, options) {
 		const provenance = options?.provenance;
 		const event = {

package/dist/src/agent/memory/understanding/service.d.ts

@@ -1,16 +1,5 @@
 import type { UnderstandingCandidate, UnderstandingReviewResult } from './types.js';
-export declare function extractExplicitUnderstandingCandidates(userContent: string): UnderstandingCandidate[];
-export declare function extractHighSignalUnderstandingCandidates(userContent: string): UnderstandingCandidate[];
 export declare class UserUnderstandingService {
-    reviewTurn(params: {
-        userContent: string;
-        assistantContent: string;
-        sessionKey?: string;
-        turnId?: string;
-        workspaceId?: string;
-        projectId?: string;
-        correctionTargetRecordIds?: string[];
-    }): Promise<UnderstandingReviewResult>;
     applyCandidates(candidates: UnderstandingCandidate[], context: {
         sessionKey?: string;
         workspaceId?: string;

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/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/service/process-direct-streaming.js

@@ -13,6 +13,7 @@ import { isSessionSourceBinding, summarizeSourceContext } from "../source-contex
 import { injectSourceContextsIntoUserMessage } from "../source-context/injector.js";
 import { AsyncQueue, AsyncQueueOverflowError } from "./async-queue.js";
 import { hydratePerTurnState, runDirectAgentTurn, tryRunSlashCommand } from "./direct-turn-helpers.js";
+import { isSuccessfulWebchatTtsToolEvent } from "./webchat-tts.js";
 //#region src/agent/service/process-direct-streaming.ts
 const MAX_BUFFERED_STREAM_EVENTS = 512;
 const LOSSY_STREAM_EVENT_TYPES = new Set([
@@ -151,6 +152,7 @@ async function* runProcessDirectStreaming(deps, input) {
 	let userAborted = false;
 	let abortHandled = false;
 	let inboundVoice = false;
+	let explicitTtsEmitted = false;
 	let ranSlashCommand = false;
 	let mergedUserText = input.content;
 	let webchatSlashReceipt;
@@ -299,6 +301,7 @@ async function* runProcessDirectStreaming(deps, input) {
 					runId: input.runId,
 					onEvent: (embeddedEvent) => {
 						const event = { ...embeddedEvent };
+						if (isSuccessfulWebchatTtsToolEvent(event)) explicitTtsEmitted = true;
 						if (event.type === "error" && typeof event.content === "string") event.content = formatStreamError(event.content);
 						pushVisible(event);
 					}
@@ -329,7 +332,7 @@ async function* runProcessDirectStreaming(deps, input) {
 				sessionKey,
 				droppedEvents: queue.droppedCount
 			}, "Coalesced stream progress events because the consumer fell behind");
-			if (!userAborted && !streamOverflowed && channel === "webchat") try {
+			if (!userAborted && !streamOverflowed && channel === "webchat" && !explicitTtsEmitted) try {
 				const ttsAudioEvent = await deps.maybeEmitWebchatTts(sessionKey, inboundVoice);
 				if (ttsAudioEvent) queue.push(ttsAudioEvent);
 			} catch (ttsErr) {

package/dist/src/agent/service/webchat-tts.d.ts

@@ -15,6 +15,8 @@ export type WebchatTtsDeps = {
         warn: (obj: Record<string, unknown>, msg: string) => void;
     };
 };
+/** True when the explicit TTS tool already produced durable Webchat audio. */
+export declare function isSuccessfulWebchatTtsToolEvent(event: unknown): boolean;
 /**
  * Generate TTS for webchat when config allows; persist under `{stateDir}/media/tts/`.
  */

package/dist/src/agent/service/webchat-tts.js

@@ -3,9 +3,22 @@ import { speak } from "../../voice/tts/speak-core.js";
 import { mergeTtsConfigFromAppConfig } from "../../voice/tts/merge-config.js";
 import { getChannelOutputFormat, shouldUseTTS } from "../../voice/tts/service.js";
 import { compressAudio } from "../../voice/tts/audio.js";
-import "../../voice/tts/index.js";
 import { persistOutboundTtsAudio } from "../../channels/attachments/outbound-tts-persist.js";
+import "../../voice/tts/index.js";
 //#region src/agent/service/webchat-tts.ts
+/** True when the explicit TTS tool already produced durable Webchat audio. */
+function isSuccessfulWebchatTtsToolEvent(event) {
+	if (!event || typeof event !== "object" || Array.isArray(event)) return false;
+	const row = event;
+	if (row.type !== "tool_execution_end" || row.toolName !== "text_to_speech" || row.isError === true) return false;
+	const result = row.result && typeof row.result === "object" && !Array.isArray(row.result) ? row.result : null;
+	const details = result?.details && typeof result.details === "object" && !Array.isArray(result.details) ? result.details : null;
+	return Array.isArray(details?.media) && details.media.some((item) => {
+		if (!item || typeof item !== "object" || Array.isArray(item)) return false;
+		const media = item;
+		return typeof media.uri === "string" && media.uri.trim().length > 0;
+	});
+}
 /**
 * Generate TTS for webchat when config allows; persist under `{stateDir}/media/tts/`.
 */
@@ -57,4 +70,4 @@ async function appendMediaToLastAssistant(sessionStore, sessionKey, ref) {
 	}
 }
 //#endregion
-export { appendMediaToLastAssistant, maybeEmitWebchatTts };
+export { appendMediaToLastAssistant, isSuccessfulWebchatTtsToolEvent, maybeEmitWebchatTts };

package/dist/src/agent/tools/tts-tool.js

@@ -4,6 +4,7 @@ import { speak } from "../../voice/tts/speak-core.js";
 import { mergeTtsConfigFromAppConfig } from "../../voice/tts/merge-config.js";
 import { getChannelOutputFormat } from "../../voice/tts/service.js";
 import { compressAudio } from "../../voice/tts/audio.js";
+import { persistOutboundTtsAudio } from "../../channels/attachments/outbound-tts-persist.js";
 import { Type } from "@sinclair/typebox";
 //#region src/agent/tools/tts-tool.ts
 init_logger();
@@ -72,30 +73,35 @@ function createTextToSpeechTool(deps) {
 				});
 				const wavTarget = outFmt.format === "mp3" ? "mp3" : "opus";
 				const { buffer: compressedAudio, format: compressedFormat } = await compressAudio(Buffer.from(result.audio), result.format, wavTarget);
-				const dataUrl = `data:${compressedFormat === "opus" ? "audio/ogg" : compressedFormat === "mp3" || compressedFormat === "mpeg" ? "audio/mpeg" : `audio/${compressedFormat}`};base64,${compressedAudio.toString("base64")}`;
-				const msg = {
-					channel: ctx.channel,
-					chat_id: ctx.chatId,
-					content: "",
-					mediaUrl: dataUrl,
-					mediaType: "audio",
-					audioAsVoice: outFmt.voiceCompatible
-				};
-				await deps.bus.publishOutbound(msg);
+				const mimeType = compressedFormat === "opus" ? "audio/ogg" : compressedFormat === "mp3" || compressedFormat === "mpeg" ? "audio/mpeg" : `audio/${compressedFormat}`;
+				const media = ctx.channel === "webchat" ? await persistOutboundTtsAudio(compressedAudio, compressedFormat) : void 0;
+				if (!media) {
+					const msg = {
+						channel: ctx.channel,
+						chat_id: ctx.chatId,
+						content: "",
+						mediaUrl: `data:${mimeType};base64,${compressedAudio.toString("base64")}`,
+						mediaType: "audio",
+						audioAsVoice: outFmt.voiceCompatible
+					};
+					await deps.bus.publishOutbound(msg);
+				}
 				log.info({
 					provider: result.provider,
 					format: compressedFormat,
+					channel: ctx.channel,
 					textLength: params.text.length,
 					audioSize: compressedAudio.length
-				}, "TTS tool sent audio");
+				}, ctx.channel === "webchat" ? "TTS tool attached audio" : "TTS tool sent audio");
 				return {
 					content: [{
 						type: "text",
-						text: `✅ Sent voice message (${result.provider}, ${compressedFormat}).`
+						text: ctx.channel === "webchat" ? `✅ Attached voice message (${result.provider}, ${compressedFormat}).` : `✅ Sent voice message (${result.provider}, ${compressedFormat}).`
 					}],
 					details: {
 						provider: result.provider,
-						format: compressedFormat
+						format: compressedFormat,
+						...media ? { media: [media] } : {}
 					}
 				};
 			} catch (error) {

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 v136).`,
+		message: `SQLite schema v${status.dbVersion} (current release v137).`,
 		hints: []
 	};
 }

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,