@xopcai/xopc 0.0.409 → 0.0.410

package/dist/src/agent/background-review/run-background-review.js

@@ -7,8 +7,11 @@ import { loadCompactionSourceSnapshot } from "../../storage/sqlite/transcript-re
 import { init_sqlite } from "../../storage/sqlite/index.js";
 import { extractTextContent } from "../context/workspace.js";
 import { init_model_usage, withModelUsageOrigin } from "../../providers/model-usage.js";
+import { canUseKnowledge } from "../../knowledge-memory/usage-policy.js";
+import { listKnowledgeItems } from "../../knowledge-memory/repository.js";
 import { resolveUserContextSessionAccess } from "../../user-context/access-policy.js";
 import { failLearningJob, finishLearningJob, learningPolicyHash } from "../../memory-learning/repository.js";
+import "../../knowledge-memory/index.js";
 import { extractProfileAgentId } from "../../config/agent-profile.js";
 import { resolveModelIntentRef, resolveModelSelector } from "../../config/agent-model-intents.js";
 import { init_sync_provider_auth, resolveProviderApiKeySync } from "../../auth/sync-provider-auth.js";
@@ -19,6 +22,7 @@ import { isLoopbackModel } from "../../providers/local-model.js";
 import { claimRegisteredExtraction } from "../../user-context/extraction/registry.js";
 import { applyWorkCandidates } from "../../memory-learning/work-capture.js";
 import { stripRuntimeContextFromUserMessage } from "../../session/user-message-display.js";
+import { applyKnowledgeDeletions } from "../../memory-learning/forget-capture.js";
 import { getAssertionSlot, listUserAssertions } from "../../user-model/repository.js";
 import { emptyUserModelCaptureResult, executeUserModelInterpretation } from "../../user-model/capture/executor.js";
 import { parseUserModelInterpretation } from "../../user-model/capture/semantic.js";
@@ -129,6 +133,17 @@ function resolveInterpreterRuntime(params) {
 	};
 }
 async function interpret(params) {
+	const context = {
+		conversationId: params.conversationId,
+		agentId: extractProfileAgentId(params.conversationId),
+		workspaceId: params.workspaceId ?? "",
+		projectId: getSessionMetadata(params.conversationId)?.projectId
+	};
+	const access = params.getConfig() ? resolveUserContextSessionAccess(params.getConfig(), params.conversationId) : void 0;
+	const availableKnowledge = access?.knowledge ? listKnowledgeItems({
+		recordClass: "memory",
+		limit: 200
+	}).filter((item) => canUseKnowledge(item, context, access.knowledgePolicy)).slice(0, 80) : [];
 	const providerStreamFn = createExtensionAwareStreamFn();
 	const reviewAgent = new Agent({
 		initialState: {
@@ -159,6 +174,11 @@ async function interpret(params) {
 				content: buildUserModelInterpreterPrompt({
 					mode: params.mode,
 					availableAssertions: params.availableAssertions,
+					availableKnowledge: availableKnowledge.map(({ id, content, scope }) => ({
+						id,
+						content,
+						scope
+					})),
 					evidenceTimestamp: new Date(params.evidence.at(-1)?.createdAt ?? Date.now()).toISOString(),
 					timezone,
 					scopeContext: {
@@ -184,7 +204,7 @@ async function interpret(params) {
 				let failure;
 				interpretation = parseUserModelInterpretation(raw, params.evidence, params.availableAssertions.map((item) => item.id), (value) => {
 					failure = value;
-				});
+				}, availableKnowledge.map((item) => item.id));
 				if (interpretation) return;
 				const fields = {
 					...diagnostics,
@@ -261,6 +281,24 @@ async function executeReviewInner(params) {
 			},
 			...params.turnId ? { turnId: params.turnId } : {}
 		});
+		if (config) {
+			const access = resolveUserContextSessionAccess(config, params.conversationId);
+			const context = {
+				conversationId: params.conversationId,
+				agentId,
+				workspaceId: params.workspaceId,
+				projectId: getSessionMetadata(params.conversationId)?.projectId
+			};
+			if (access.knowledge) applyKnowledgeDeletions({
+				interpretation,
+				evidence: params.evidence,
+				context,
+				allowedTargetIds: listKnowledgeItems({
+					recordClass: "memory",
+					limit: 200
+				}).filter((item) => canUseKnowledge(item, context, access.knowledgePolicy)).map((item) => item.id)
+			});
+		}
 		finishContextExtractionRun({
 			runId: extraction.run.id,
 			status: "completed",
@@ -346,7 +384,12 @@ async function runPersistentLearningJobInner(job, getConfig) {
 			"assistant",
 			"toolResult"
 		].includes(row.role)) continue;
-		if (Array.isArray(message.metadata?.sourceContexts) && message.metadata.sourceContexts.length > 0) continue;
+		const sourceContexts = message.metadata?.sourceContexts;
+		if (Array.isArray(sourceContexts) && sourceContexts.length > 0) {
+			const raw = messageText(message);
+			const wrapped = /<source_contexts>[\s\S]*<\/source_contexts>\s*<user_message>\r?\n[\s\S]*\r?\n<\/user_message>\s*$/u.test(raw);
+			if (row.role !== "user" || !wrapped || raw === text || /<source_contexts>|<\/?user_message>/u.test(text)) continue;
+		}
 		if (row.role === "toolResult" && /(?:memory|user_context|knowledge|session|history|recall)/i.test(message.toolName ?? "")) continue;
 		if (text.length > maxChars || /<xopc_user_context>|<xopc_task_execution>|<user-context>/.test(text)) continue;
 		chars += text.length;
@@ -439,7 +482,22 @@ async function runPersistentLearningJobInner(job, getConfig) {
 					processing: runtime.processingPolicy
 				}
 			}) : emptyUserModelCaptureResult();
-			const work = access.knowledge && current.userContext.knowledgeMemory.writePolicy === "allow" && access.knowledgePolicy.contentSources.includes("memory") ? applyWorkCandidates({
+			const deletionContext = {
+				conversationId: job.conversation_id,
+				agentId,
+				workspaceId: job.workspace_id,
+				projectId
+			};
+			const deletions = access.knowledge ? applyKnowledgeDeletions({
+				interpretation,
+				evidence,
+				context: deletionContext,
+				allowedTargetIds: listKnowledgeItems({
+					recordClass: "memory",
+					limit: 200
+				}).filter((item) => canUseKnowledge(item, deletionContext, access.knowledgePolicy)).map((item) => item.id)
+			}) : [];
+			const work = interpretation.intent !== "forget" && !interpretation.knowledgeDeletions?.length && access.knowledge && current.userContext.knowledgeMemory.writePolicy === "allow" && access.knowledgePolicy.contentSources.includes("memory") ? applyWorkCandidates({
 				candidates: (interpretation.knowledge ?? []).filter((candidate) => access.knowledgePolicy.scopes.includes(candidate.scope)),
 				evidence,
 				conversationId: job.conversation_id,
@@ -452,14 +510,18 @@ async function runPersistentLearningJobInner(job, getConfig) {
 			finishContextExtractionRun({
 				runId: extraction.run.id,
 				status: "completed",
-				outputs: [...result.outputs.map((output) => ({
-					candidateKey: output.candidateKey,
-					...output.assertionId ? {
-						objectType: "assertion",
-						objectId: output.assertionId
-					} : {},
-					outcome: output.outcome === "rejected" ? "rejected" : output.outcome === "deduplicated" ? "deduplicated" : "created"
-				})), ...work]
+				outputs: [
+					...result.outputs.map((output) => ({
+						candidateKey: output.candidateKey,
+						...output.assertionId ? {
+							objectType: "assertion",
+							objectId: output.assertionId
+						} : {},
+						outcome: output.outcome === "rejected" ? "rejected" : output.outcome === "deduplicated" ? "deduplicated" : "created"
+					})),
+					...deletions,
+					...work
+				]
 			});
 		}, through);
 	} catch (err) {

package/dist/src/agent/inbound/attachment-pipeline.d.ts

@@ -34,6 +34,8 @@ export declare function hydrateUserTurnForLlm(opts: {
 }): Promise<LlmUserTurn>;
 export declare function setPendingTranscriptUserMessage(conversationId: string, message: TranscriptUserMessage): void;
 export declare function getPendingTranscriptUserText(conversationId: string): string | undefined;
+/** The active owner's utterance remains available after its persistence receipt is consumed. */
+export declare function getActiveTranscriptUserText(conversationId: string): string | undefined;
 export declare function takePendingTranscriptUserMessage(conversationId: string): TranscriptUserMessage | undefined;
 export declare function clearPendingTranscriptUserMessage(conversationId: string, message?: TranscriptUserMessage): void;
 export declare function pendingTranscriptReferencesMediaUri(conversationId: string, uri: string): boolean;

package/dist/src/agent/inbound/attachment-pipeline.js

@@ -143,6 +143,7 @@ async function hydrateUserTurnForLlm(opts) {
 	};
 }
 const pendingTranscriptBySession = /* @__PURE__ */ new Map();
+const activeTranscriptUserBySession = /* @__PURE__ */ new Map();
 function messageTextForPendingCompare(message) {
 	return joinTextBlocks(textBlocksFromContent(readAgentMessageContent(message)));
 }
@@ -159,22 +160,26 @@ function pendingMatchesMessage(pending, message) {
 function setPendingTranscriptUserMessage(conversationId, message) {
 	assertTranscriptUserMessage(message);
 	pendingTranscriptBySession.set(conversationId, message);
+	activeTranscriptUserBySession.set(conversationId, message);
 }
 function getPendingTranscriptUserText(conversationId) {
 	const message = pendingTranscriptBySession.get(conversationId);
 	if (!message) return void 0;
 	return stripRuntimeUserMessageEnvelope(messageTextForPendingCompare(message)).trim();
 }
+/** The active owner's utterance remains available after its persistence receipt is consumed. */
+function getActiveTranscriptUserText(conversationId) {
+	const message = activeTranscriptUserBySession.get(conversationId);
+	return message ? stripRuntimeUserMessageEnvelope(messageTextForPendingCompare(message)).trim() : void 0;
+}
 function takePendingTranscriptUserMessage(conversationId) {
 	const msg = pendingTranscriptBySession.get(conversationId);
 	pendingTranscriptBySession.delete(conversationId);
 	return msg;
 }
 function clearPendingTranscriptUserMessage(conversationId, message) {
-	const existing = pendingTranscriptBySession.get(conversationId);
-	if (!existing) return;
-	if (message && existing !== message) return;
-	pendingTranscriptBySession.delete(conversationId);
+	if (!message || pendingTranscriptBySession.get(conversationId) === message) pendingTranscriptBySession.delete(conversationId);
+	if (!message || activeTranscriptUserBySession.get(conversationId) === message) activeTranscriptUserBySession.delete(conversationId);
 }
 function pendingTranscriptReferencesMediaUri(conversationId, uri) {
 	return pendingTranscriptBySession.get(conversationId)?.media?.some((ref) => ref.uri === uri.trim()) === true;
@@ -192,4 +197,4 @@ function transformUserMessageForPersistence(conversationId, message) {
 	return message;
 }
 //#endregion
-export { assertTranscriptUserMessage, buildTranscriptUserMessage, clearPendingTranscriptUserMessage, getPendingTranscriptUserText, hydrateUserTurnForLlm, pendingTranscriptReferencesMediaUri, setPendingTranscriptUserMessage, takePendingTranscriptUserMessage, transformUserMessageForPersistence };
+export { assertTranscriptUserMessage, buildTranscriptUserMessage, clearPendingTranscriptUserMessage, getActiveTranscriptUserText, getPendingTranscriptUserText, hydrateUserTurnForLlm, pendingTranscriptReferencesMediaUri, setPendingTranscriptUserMessage, takePendingTranscriptUserMessage, transformUserMessageForPersistence };

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

@@ -53,7 +53,7 @@ import { BrowserRuntime } from "../../browser/runtime/browser-runtime.js";
 import { createBrowserDriver } from "../../browser/drivers/create-driver.js";
 import { checkBrowserReadiness } from "../../browser/readiness.js";
 import "../../browser/index.js";
-import { getPendingTranscriptUserText } from "../inbound/attachment-pipeline.js";
+import { getActiveTranscriptUserText, getPendingTranscriptUserText } from "../inbound/attachment-pipeline.js";
 import { createDelegateTool } from "./delegate-tool.js";
 import { createWorkflowTool } from "./workflow-tool.js";
 import { createWorkflowCatalog } from "../workflow/catalog.js";
@@ -521,10 +521,24 @@ var AgentToolsFactory = class AgentToolsFactory {
 			...this.deps.getSessionStore ? [createSessionRecallTool({
 				getSessionStore: this.deps.getSessionStore,
 				getCurrentConversationId: currentConversationId,
+				getHistoryContext: () => ({
+					agentId: resolvedAgentId,
+					workspaceId: workspace,
+					conversationId: currentConversationId() ?? "",
+					projectId: currentProjectId()
+				}),
+				getCurrentUserText: () => currentConversationId() ? getActiveTranscriptUserText(currentConversationId()) : void 0,
 				...personalToolsConfigured ? { maxOutputChars: LOCAL_READ_MAX_CHARS } : {}
 			})] : [],
 			...this.deps.getSessionStore && getPrimary ? [createSessionSearchTool({
 				localOnly: personalToolsConfigured,
+				getHistoryContext: () => ({
+					agentId: resolvedAgentId,
+					workspaceId: workspace,
+					conversationId: currentConversationId() ?? "",
+					projectId: currentProjectId()
+				}),
+				getCurrentUserText: () => currentConversationId() ? getActiveTranscriptUserText(currentConversationId()) : void 0,
 				getSessionStore: this.deps.getSessionStore,
 				getPrimaryModel: getPrimary,
 				getCurrentConversationId: () => this.deps.getCurrentContext()?.conversationId,

package/dist/src/agent/tools/session-recall-tool.d.ts

@@ -1,8 +1,11 @@
 import type { AgentTool } from '@earendil-works/pi-agent-core';
+import type { CaptureScopeContext } from '../../user-model/capture/executor.js';
 import type { SessionStore } from '../../session/store.js';
 export interface SessionRecallToolDeps {
     getSessionStore: () => SessionStore;
     getCurrentConversationId: () => string | undefined;
     maxOutputChars?: number;
+    getHistoryContext?: () => CaptureScopeContext;
+    getCurrentUserText?: () => string | undefined;
 }
 export declare function createSessionRecallTool(deps: SessionRecallToolDeps): AgentTool;

package/dist/src/agent/tools/session-recall-tool.js

@@ -1,3 +1,4 @@
+import { FORGOTTEN_HISTORY_EXCERPT, forgottenHistoryEntries } from "../../memory-learning/forgotten-history.js";
 import { Type } from "@sinclair/typebox";
 //#region src/agent/tools/session-recall-tool.ts
 const SessionRecallSchema = Type.Object({
@@ -55,6 +56,8 @@ function createSessionRecallTool(deps) {
 				...input.beforeSeq ? { beforeSeq: input.beforeSeq } : {},
 				...deps.maxOutputChars ? { orderBySeq: true } : {}
 			});
+			const protectedEntries = deps.getHistoryContext ? forgottenHistoryEntries(deps.getHistoryContext(), deps.getCurrentUserText?.()) : /* @__PURE__ */ new Set();
+			for (const match of matches) if (protectedEntries.has(`${conversationId}:*`) || protectedEntries.has(`${conversationId}:${match.entryId}`)) match.content = FORGOTTEN_HISTORY_EXCERPT;
 			if (deps.maxOutputChars) matches.sort((a, b) => b.seq - a.seq);
 			const results = matches.map((match) => ({
 				seq: match.seq,

package/dist/src/agent/tools/session-search-tool.d.ts

@@ -1,11 +1,14 @@
 import type { AgentTool } from '@earendil-works/pi-agent-core';
 import { type Api, type Model } from '@earendil-works/pi-ai/compat';
 import type { SessionStore } from '../../session/store.js';
+import type { CaptureScopeContext } from '../../user-model/capture/executor.js';
 export interface SessionSearchToolDeps {
     getSessionStore: () => SessionStore;
     getPrimaryModel: () => Model<Api>;
     getCurrentConversationId?: () => string | undefined;
     canAccess?: () => boolean;
     localOnly?: boolean;
+    getHistoryContext?: () => CaptureScopeContext;
+    getCurrentUserText?: () => string | undefined;
 }
 export declare function createSessionSearchTool(deps: SessionSearchToolDeps): AgentTool;

package/dist/src/agent/tools/session-search-tool.js

@@ -1,13 +1,16 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
+import { init_fts, sessionSearchTerms } from "../../storage/sqlite/fts.js";
 import { init_providers, resolveModel } from "../../providers/index.js";
 import { completeWithResolvedCredentials } from "../../providers/model-call.js";
 import { readAgentMessageContent } from "../memory/agent-message-access.js";
 import "./local-read-budget.js";
+import { FORGOTTEN_HISTORY_EXCERPT, forgottenHistoryEntries } from "../../memory-learning/forgotten-history.js";
 import { Type } from "@sinclair/typebox";
 //#region src/agent/tools/session-search-tool.ts
 init_providers();
 init_logger();
+init_fts();
 const log = createLogger("Agent:SessionSearch");
 const MAX_SUMMARY_CHARS = 2e4;
 function resolveSummaryModel(deps) {
@@ -164,18 +167,26 @@ function createSessionSearchTool(deps) {
 				const exclude = p.excludeConversationId?.trim() || deps.getCurrentConversationId?.() || "";
 				if (exclude) matches = matches.filter((m) => m.key !== exclude);
 				const top = matches.slice(0, limit);
+				const protectedEntries = deps.getHistoryContext ? forgottenHistoryEntries(deps.getHistoryContext(), deps.getCurrentUserText?.()) : /* @__PURE__ */ new Set();
 				if (deps.localOnly) {
 					const results = top.map(({ key }) => ({
 						conversationId: key,
 						name: listed.items.find((item) => item.key === key)?.name?.slice(0, 200),
-						excerpts: store.recallSession(key, query, { limit: 2 }).filter((match) => !p.roleFilter || match.role === p.roleFilter).map((match) => {
-							const at = match.content.toLowerCase().indexOf(query.toLowerCase());
+						excerpts: store.recallSession(key, query, {
+							limit: 2,
+							matchMode: "keyword"
+						}).filter((match) => !p.roleFilter || match.role === p.roleFilter).map((match) => {
+							const content = protectedEntries.has(`${key}:*`) || protectedEntries.has(`${key}:${match.entryId}`) ? FORGOTTEN_HISTORY_EXCERPT : match.content;
+							const positions = sessionSearchTerms(query).map((term) => content.toLowerCase().indexOf(term.toLowerCase())).filter((at) => at >= 0);
+							const at = positions.length ? Math.min(...positions) : 0;
 							const start = Math.max(0, at - 200);
 							return {
+								entryId: match.entryId,
+								createdAt: match.createdAt,
 								seq: match.seq,
 								role: match.role,
-								content: match.content.slice(start, start + 800),
-								truncated: start > 0 || match.content.length > start + 800
+								content: content.slice(start, start + 800),
+								truncated: start > 0 || content.length > start + 800
 							};
 						})
 					}));
@@ -208,6 +219,11 @@ function createSessionSearchTool(deps) {
 					};
 				}
 				const summaries = await Promise.all(top.map(async ({ key, score }) => {
+					if ([...protectedEntries].some((entry) => entry.startsWith(`${key}:`))) return {
+						conversationId: key,
+						score,
+						summary: FORGOTTEN_HISTORY_EXCERPT
+					};
 					let messages = await store.load(key);
 					if (p.roleFilter) messages = messages.filter((m) => m.role === p.roleFilter);
 					return {

package/dist/src/gateway/service.js

@@ -88,6 +88,13 @@ import { ChatPreviewService } from "../chat-previews/service.js";
 import "../chat-previews/index.js";
 import { configureGatewayHttpProxy } from "../infra/http-proxy-env.js";
 import "../config/index.js";
+import { ManagedComposioEventPoller } from "../connectors/composio-managed-events.js";
+import { startConnectedKnowledgeCoordinator } from "../knowledge/coordinator.js";
+import "../knowledge/index.js";
+import { PersonalReplyComposer } from "../personal-agent/reply-composer.js";
+import { ConnectionRecoveryService } from "../connectors/connection-recovery-service.js";
+import { startConnectorLearningCoordinator } from "../connectors/learning-coordinator.js";
+import { startConnectorSupervisor } from "../connectors/supervisor.js";
 import { DiscussionService } from "../discussions/service.js";
 import { DiscussionOrganizer } from "../discussions/organizer.js";
 import { DiscussionLiveWorker } from "../discussions/live-worker.js";
@@ -96,13 +103,10 @@ import { DiscussionSealer } from "../discussions/sealer.js";
 import "../discussions/index.js";
 import { EndpointToolRuntime } from "../endpoint-tools/runtime.js";
 import "../endpoint-tools/index.js";
-import { ManagedComposioEventPoller } from "../connectors/composio-managed-events.js";
-import { startConnectedKnowledgeCoordinator } from "../knowledge/coordinator.js";
-import "../knowledge/index.js";
-import { PersonalReplyComposer } from "../personal-agent/reply-composer.js";
-import { ConnectionRecoveryService } from "../connectors/connection-recovery-service.js";
-import { startConnectorLearningCoordinator } from "../connectors/learning-coordinator.js";
-import { startConnectorSupervisor } from "../connectors/supervisor.js";
+import { HomeCapabilityPreflightService } from "../home-intelligence/capability-preflight.js";
+import { HomeAdviceGenerator } from "../home-intelligence/generator.js";
+import { HomeIntelligenceHost } from "../home-intelligence/host.js";
+import { HomeSnapshotBuilder } from "../home-intelligence/snapshot.js";
 import { assertGatewayAuthConfigured, extractToken, resolveGatewayAuth, validateToken } from "./auth.js";
 import { prepareAutomationAgentSession } from "./automation-agent-session.js";
 import { stopTailscaleExposure } from "./tailscale-lifecycle.js";
@@ -163,10 +167,6 @@ import { TaskMainUpdateDecisionService } from "../tasks/task-main-update-decisio
 import { selectTaskMainUpdateAttempt, submitAndConfirmTaskMainUpdate } from "../tasks/task-main-update-input.js";
 import { checkAppContextAccess, prepareAppContext } from "./service/app-context-access.js";
 import { applyAutomaticVoiceLanguage, inferProductLanguageFromEnvironment, initializeVoiceDefaults } from "../voice/language-profile.js";
-import { HomeAdviceGenerator } from "../home-intelligence/generator.js";
-import { HomeIntelligenceHost } from "../home-intelligence/host.js";
-import { HomeSnapshotBuilder } from "../home-intelligence/snapshot.js";
-import { HomeCapabilityPreflightService } from "../home-intelligence/capability-preflight.js";
 import crypto from "node:crypto";
 //#region src/gateway/service.ts
 init_session_repository();

package/dist/src/home-intelligence/host.js

@@ -1,10 +1,10 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { HomeAdviceBudgetExceededError, isHomeProseLocalized } from "./generator.js";
 import { homePatternKey } from "./strategy.js";
-import { HomeAdvicePolicy } from "./policy.js";
 import { HomeIntelligenceRepository } from "./repository.js";
 import { HomeOpportunityApplicationService } from "./application-service.js";
+import { HomeAdvicePolicy } from "./policy.js";
+import { HomeAdviceBudgetExceededError, isHomeProseLocalized } from "./generator.js";
 import { buildHomeOpportunityNotification } from "./notification.js";
 import { createHash } from "node:crypto";
 //#region src/home-intelligence/host.ts

package/dist/src/knowledge-memory/repository.d.ts

@@ -83,5 +83,7 @@ export declare function searchKnowledgeItems(input: {
 }): KnowledgeItem[];
 export declare function classifyKnowledgeContentSource(item: KnowledgeItem): KnowledgeContentSource;
 export declare function knowledgeItemAllowed(item: KnowledgeItem, policy: KnowledgeReadPolicy): boolean;
-export declare function deleteKnowledgeItem(id: string, now?: number): boolean;
+export declare function deleteKnowledgeItem(id: string, now?: number, options?: {
+    includeRelated?: boolean;
+}): boolean;
 export declare function isKnowledgeCurrent(item: KnowledgeItem, asOf?: number): boolean;

package/dist/src/knowledge-memory/repository.js

@@ -350,7 +350,7 @@ function knowledgeFingerprints(input) {
 		input.content
 	])];
 }
-function deleteKnowledgeItem(id, now = Date.now()) {
+function deleteKnowledgeItem(id, now = Date.now(), options = {}) {
 	return runSqliteWriteTransaction((db) => {
 		const rows = db.prepare(`WITH RECURSIVE deleted(id) AS (
       SELECT knowledge_id FROM knowledge_items WHERE knowledge_id = ?
@@ -358,7 +358,8 @@ function deleteKnowledgeItem(id, now = Date.now()) {
         ON json_extract(k.source_json, '$.episodeKnowledgeId') = d.id
         OR k.knowledge_id = (SELECT json_extract(source_json, '$.episodeKnowledgeId')
           FROM knowledge_items WHERE knowledge_id = d.id)
-    ) SELECT * FROM knowledge_items WHERE knowledge_id IN (SELECT id FROM deleted)`).all(id);
+      WHERE ?
+    ) SELECT * FROM knowledge_items WHERE knowledge_id IN (SELECT id FROM deleted)`).all(id, options.includeRelated === false ? 0 : 1);
 		for (const row of rows) {
 			const item = fromRow(row);
 			suppressMemory(db, knowledgeFingerprints(item), now);
@@ -375,7 +376,13 @@ function isKnowledgeCurrent(item, asOf = Date.now()) {
 function writeEvidence(db, id, input) {
 	db.prepare("UPDATE knowledge_items SET claim_mode = ?, verification = ?, sensitivity = ? WHERE knowledge_id = ?").run(input.claimMode ?? (input.originClass === "owner" ? "explicit" : input.originClass === "untrusted" ? "reported" : "observed"), input.verification ?? (input.originClass === "untrusted" && (input.recordClass ?? "memory") === "memory" ? "tentative" : "supported"), input.sensitivity ?? inferMemorySensitivity(input.content), id);
 	db.prepare("DELETE FROM knowledge_evidence_links WHERE knowledge_id = ?").run(id);
-	for (const evidence of input.evidence ?? []) db.prepare("INSERT INTO knowledge_evidence_links(knowledge_id, evidence_id, content_hash, consent_receipt_id) VALUES (?, ?, ?, ?)").run(id, evidence.id, evidence.contentHash ?? null, evidence.consentReceiptId ?? null);
+	const links = /* @__PURE__ */ new Map();
+	for (const evidence of input.evidence ?? []) {
+		const existing = links.get(evidence.id);
+		if (existing && (existing.contentHash !== evidence.contentHash || existing.consentReceiptId !== evidence.consentReceiptId)) throw new Error("Conflicting provenance for the same knowledge evidence.");
+		links.set(evidence.id, evidence);
+	}
+	for (const evidence of links.values()) db.prepare("INSERT INTO knowledge_evidence_links(knowledge_id, evidence_id, content_hash, consent_receipt_id) VALUES (?, ?, ?, ?)").run(id, evidence.id, evidence.contentHash ?? null, evidence.consentReceiptId ?? null);
 }
 //#endregion
 export { KnowledgeReviewConflictError, classifyKnowledgeContentSource, deleteKnowledgeItem, getKnowledgeItem, isKnowledgeCurrent, knowledgeItemAllowed, listKnowledgeItems, listKnowledgeStatusEvents, reviewKnowledgeItem, searchKnowledgeItems, transitionKnowledgeStatus, writeKnowledgeItem };

package/dist/src/memory-learning/forget-capture.d.ts

@@ -0,0 +1,14 @@
+import type { CaptureScopeContext } from '../user-model/capture/executor.js';
+import type { CaptureEvidence, UserModelInterpretation } from '../user-model/capture/semantic.js';
+/** Only grounded owner requests can forget derived knowledge visible in this scope. */
+export declare function applyKnowledgeDeletions(input: {
+    interpretation: UserModelInterpretation;
+    evidence: CaptureEvidence[];
+    context: CaptureScopeContext;
+    allowedTargetIds: string[];
+}): Array<{
+    candidateKey: string;
+    objectType: 'knowledge';
+    objectId: string;
+    outcome: 'created' | 'rejected';
+}>;

package/dist/src/memory-learning/forget-capture.js

@@ -0,0 +1,100 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { createCollaborationRule, init_collaboration_rule_repository, listCollaborationRules } from "../storage/sqlite/collaboration-rule-repository.js";
+import { canUseKnowledge } from "../knowledge-memory/usage-policy.js";
+import { deleteKnowledgeItem, getKnowledgeItem, writeKnowledgeItem } from "../knowledge-memory/repository.js";
+import "../knowledge-memory/index.js";
+import { createHash } from "node:crypto";
+//#region src/memory-learning/forget-capture.ts
+init_logger();
+init_transaction();
+init_collaboration_rule_repository();
+const log = createLogger("MemoryLearning:Forget");
+/** Only grounded owner requests can forget derived knowledge visible in this scope. */
+function applyKnowledgeDeletions(input) {
+	return runSqliteWriteTransaction((db) => {
+		const outputs = [];
+		for (const operation of input.interpretation.knowledgeDeletions ?? []) {
+			if (!operation.evidenceRefs.length || operation.evidenceRefs.some((ref) => !input.evidence.some((entry) => entry.ref === ref && entry.role === "user"))) continue;
+			if (!operation.evidence?.length || operation.evidence.some((claim) => !input.evidence.some((entry) => entry.ref === claim.ref && entry.role === "user" && entry.text.normalize("NFKC").toLowerCase().includes(claim.quote.normalize("NFKC").toLowerCase())))) continue;
+			let targets = operation.targetKnowledgeIds.flatMap((id) => {
+				const item = input.allowedTargetIds.includes(id) ? getKnowledgeItem(id) : void 0;
+				return item && item.recordClass === "memory" && canUseKnowledge(item, input.context) ? [item] : [];
+			});
+			const requestedRetention = operation.retained ?? [];
+			const invalidTargets = new Set(requestedRetention.filter((part) => {
+				const item = targets.find((target) => target.id === part.targetKnowledgeId);
+				return !item || !part.spans.length || part.spans.some((span) => !span.trim() || !item.content.includes(span));
+			}).map((part) => part.targetKnowledgeId));
+			if (invalidTargets.size) log.warn({
+				phase: "forget_retention",
+				count: invalidTargets.size,
+				conversationId: input.context.conversationId
+			}, "Ungrounded retained spans rejected; affected knowledge was preserved");
+			targets = targets.filter((item) => !invalidTargets.has(item.id));
+			const retained = requestedRetention.filter((part) => targets.some((item) => item.id === part.targetKnowledgeId));
+			for (const part of retained) {
+				const item = targets.find((target) => target.id === part.targetKnowledgeId);
+				const content = [...new Set(part.spans)].join("；");
+				const links = db.prepare(`SELECT evidence_id, content_hash, consent_receipt_id FROM knowledge_evidence_links
+          WHERE knowledge_id = ?`).all(item.id);
+				const saved = writeKnowledgeItem({
+					...item,
+					content,
+					canonicalKey: `${item.canonicalKey}:retained:${createHash("sha256").update(content).digest("hex").slice(0, 16)}`,
+					evidence: links.map((link) => ({
+						id: link.evidence_id,
+						contentHash: link.content_hash ?? void 0,
+						consentReceiptId: link.consent_receipt_id ?? void 0
+					})),
+					source: {
+						...item.source,
+						evidenceQuotes: void 0,
+						retainedFromKnowledgeId: item.id
+					},
+					replaceExisting: false
+				});
+				if (!saved.item) throw new Error("Unable to retain unforgotten knowledge; deletion was rolled back.");
+				outputs.push({
+					candidateKey: saved.item.canonicalKey,
+					objectType: "knowledge",
+					objectId: saved.item.id,
+					outcome: "created"
+				});
+			}
+			const forgottenEntries = targets.flatMap((item) => db.prepare(`SELECT DISTINCT e.conversation_id, e.message_id
+        FROM context_evidence e WHERE e.conversation_id IS NOT NULL AND e.message_id IS NOT NULL
+          AND (e.evidence_id IN (SELECT evidence_id FROM knowledge_evidence_links WHERE knowledge_id=?)
+            OR e.message_id IN (SELECT value FROM knowledge_revisions r, json_each(r.source_json, '$.evidenceRefs')
+              WHERE r.knowledge_id=?))`).all(item.id, item.id).flatMap((entry) => [`${entry.conversation_id}:${entry.message_id}`, `${entry.conversation_id}:*`]));
+			for (const item of targets) {
+				deleteKnowledgeItem(item.id, Date.now(), { includeRelated: false });
+				outputs.push({
+					candidateKey: item.id,
+					objectType: "knowledge",
+					objectId: item.id,
+					outcome: "rejected"
+				});
+			}
+			for (const scope of new Map(targets.map((item) => [JSON.stringify(item.scope), item.scope])).values()) {
+				if (scope.type === "agent") continue;
+				if (!listCollaborationRules().some((rule) => rule.category === "boundary" && rule.status === "active" && JSON.stringify(rule.scope) === JSON.stringify(scope) && rule.statement === operation.boundary && forgottenEntries.every((entry) => Array.isArray(rule.conditions.forgottenHistoryEntries) && rule.conditions.forgottenHistoryEntries.includes(entry)))) createCollaborationRule({
+					category: "boundary",
+					priority: 0,
+					scope,
+					conditions: {
+						enforcementLevel: "prompt",
+						forgottenHistoryEntries: [...new Set(forgottenEntries)],
+						reread: operation.reread
+					},
+					statement: operation.boundary,
+					status: "active"
+				});
+			}
+		}
+		return outputs;
+	});
+}
+//#endregion
+export { applyKnowledgeDeletions };

package/dist/src/memory-learning/forgotten-history.d.ts

@@ -0,0 +1,5 @@
+import type { CaptureScopeContext } from '../user-model/capture/executor.js';
+/** A later source-specific read request does not authorize saving forgotten facts again. */
+export declare function explicitlyReadsOriginalHistory(text: string): boolean;
+export declare function forgottenHistoryEntries(context: CaptureScopeContext, userText?: string): Set<string>;
+export declare const FORGOTTEN_HISTORY_EXCERPT = "[This entry supported information the user asked to forget. Automatic recall is withheld. A later explicit request to re-read original records is required; do not infer the hidden values.]";

package/dist/src/memory-learning/forgotten-history.js

@@ -0,0 +1,33 @@
+import { isXopcDatabaseOpen } from "../storage/sqlite/connection.js";
+import { init_collaboration_rule_repository, listCollaborationRules } from "../storage/sqlite/collaboration-rule-repository.js";
+import { init_sqlite } from "../storage/sqlite/index.js";
+//#region src/memory-learning/forgotten-history.ts
+init_sqlite();
+init_collaboration_rule_repository();
+/** A later source-specific read request does not authorize saving forgotten facts again. */
+function explicitlyReadsOriginalHistory(text) {
+	if (/(?:引文|引用|改写|措辞|不是要|quoted|rephrase)/iu.test(text)) return false;
+	if (/(?:不要|别|不必|禁止)\s*(?:再|去)?(?:恢复|查阅|查出|读取|找回|查)|(?:do not|don't)\s+(?:read|look|recover|retrieve|restore)/iu.test(text)) return false;
+	return /(?:原始|旧|先前|过去).{0,8}(?:记录|对话|原文)|(?:original|old|previous|past).{0,20}(?:record|conversation|transcript|history)/iu.test(text) && /(?:^|\n)\s*(?:(?:请|麻烦|本次|这次|现在|please|this time)[，,\s]*){0,3}[^。\n！？]{0,150}(?:恢复|查阅|查出|读取|找回|read|look up|retrieve|recover|restore)/iu.test(text);
+}
+function forgottenHistoryEntries(context, userText = "") {
+	if (!isXopcDatabaseOpen()) return /* @__PURE__ */ new Set();
+	const entries = /* @__PURE__ */ new Set();
+	for (const rule of listCollaborationRules()) {
+		if (rule.status !== "active" || rule.category !== "boundary") continue;
+		if (!(rule.scope.type === "global" || rule.scope.id === {
+			agent: context.agentId,
+			workspace: context.workspaceId,
+			project: context.projectId,
+			session: context.conversationId
+		}[rule.scope.type]) || !Array.isArray(rule.conditions.forgottenHistoryEntries)) continue;
+		const binding = rule.conditions.reread;
+		const property = binding?.property === "date_time" ? /日期|时间|哪天|哪日|几点|日程|\b(?:date|time|when|schedule)\b/iu : binding?.property === "price" ? /票价|报价|价格|总价|金额|费用|花费|价钱|\b(?:price|cost|amount)\b/iu : void 0;
+		if (typeof binding?.subject === "string" && binding.subject.length > 0 && property && userText.split(/[。；;，,!?！？\n]/u).some((clause) => explicitlyReadsOriginalHistory(clause) && clause.normalize("NFKC").toLowerCase().includes(binding.subject.normalize("NFKC").toLowerCase()) && property.test(clause))) continue;
+		for (const entry of rule.conditions.forgottenHistoryEntries) if (typeof entry === "string") entries.add(entry);
+	}
+	return entries;
+}
+const FORGOTTEN_HISTORY_EXCERPT = "[This entry supported information the user asked to forget. Automatic recall is withheld. A later explicit request to re-read original records is required; do not infer the hidden values.]";
+//#endregion
+export { FORGOTTEN_HISTORY_EXCERPT, explicitlyReadsOriginalHistory, forgottenHistoryEntries };

package/dist/src/memory-learning/work-capture.js

@@ -112,7 +112,8 @@ function applyWorkCandidates(input) {
 			replaceExisting: true,
 			source: {
 				extractor: "work-synthesis",
-				evidenceRefs: candidate.evidence.map((claim) => claim.ref),
+				evidenceRefs: [...new Set(candidate.evidence.map((claim) => claim.ref))],
+				evidenceQuotes: candidate.evidence,
 				...input.source ? {
 					sourceInstanceId: input.source.instanceId,
 					sourceItemId: input.source.itemId,

package/dist/src/session/store.d.ts

@@ -209,6 +209,7 @@ export declare class SessionStore {
         limit?: number;
         beforeSeq?: number;
         orderBySeq?: boolean;
+        matchMode?: 'keyword' | 'phrase';
     }): import("../storage/sqlite/transcript-repository.js").SessionTranscriptRecallMatch[];
     exportSession(key: string, format: ExportFormat): Promise<string>;
     importSessionExport(targetKey: string, jsonContent: string): Promise<{

package/dist/src/storage/sqlite/fts.d.ts

@@ -1,6 +1,10 @@
 /** Quote a user query for FTS5 phrase/prefix-safe matching. */
 export declare function escapeFts5Query(raw: string): string;
 /** Build a syntax-safe, recall-oriented query for natural-language memory search. */
+export declare function sessionSearchTerms(raw: string): string[];
 export declare function buildFts5SearchQuery(raw: string): string;
+/** unicode61 does not split Han words; use literal substrings for those terms. */
+export declare function sessionHanSearchTerms(raw: string): string[];
+export declare function escapeSqlLike(raw: string): string;
 /** Normalize FTS5 BM25 ranks, where a more-negative rank is a better match. */
 export declare function fts5RankToScore(rank: number, bestRank: number, worstRank: number): number;