@xopcai/xopc 0.0.409 → 0.0.411

package/dist/src/local-apps/service.js

@@ -1,7 +1,7 @@
 import { resolveStateDir } from "../config/paths-state.js";
+import { currentOperationId, init_operation_context } from "../infra/operation-context.js";
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { currentOperationId, init_operation_context } from "../infra/operation-context.js";
 import { afterSqliteCommit, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { ExtensionCapabilityBindingsSchema, extensionCapabilityPermissions } from "../../packages/gateway-contract/src/extension-capabilities.js";
 import { init_src } from "../../packages/gateway-contract/src/index.js";

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,101 @@
+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 { isUnquotedOwnerEvidence } from "./owner-directive.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" && isUnquotedOwnerEvidence(entry.text, claim.quote)))) 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}:*`])).concat(targets.length && input.context.conversationId ? [`${input.context.conversationId}:*`] : []);
+			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,15 @@
+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;
+/** A value-free, per-request notice makes legitimate original reads distinguishable from automatic recall. */
+export declare function originalReadAuthorizationNotice(context: CaptureScopeContext, userText?: string): string;
+export declare function forgottenHistoryEntries(context: CaptureScopeContext, userText?: string): Set<string>;
+/** Project provenance for model consumption without changing the retained audit source. */
+export declare function projectForgottenEvidence<T>(source: T, context: CaptureScopeContext, userText?: string, provenanceRefs?: string[]): T;
+/** Remove earlier materialized reads from active history, retaining this turn and system context. */
+export declare function projectForgottenHistoryMessages<T extends {
+    role: string;
+}>(messages: T[], context: CaptureScopeContext, userText?: string): T[];
+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.]";
+/** Recheck rendered memory snapshots at dispatch; deleted facts cannot survive in a cached prompt. */
+export declare function projectSuppressedMemoryBlocks(text: string, context: CaptureScopeContext): string;

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

@@ -0,0 +1,137 @@
+import { isXopcDatabaseOpen } from "../storage/sqlite/connection.js";
+import { getSqliteDatabase, init_transaction } from "../storage/sqlite/transaction.js";
+import { init_domain } from "../user-model/domain.js";
+import { init_collaboration_rule_repository, listCollaborationRules } from "../storage/sqlite/collaboration-rule-repository.js";
+import { init_sqlite } from "../storage/sqlite/index.js";
+import { isMemorySuppressed, memoryFingerprint } from "../user-context/memory-suppression.js";
+//#region src/memory-learning/forgotten-history.ts
+init_sqlite();
+init_collaboration_rule_repository();
+init_domain();
+init_transaction();
+/** 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*(?:再|去|从[^。；;，,！？\n]{0,40})?(?:恢复|查阅|查出|读取|找回|查)|(?: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 matchesOriginalRead(rule, userText) {
+	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;
+	return Boolean(typeof binding?.subject === "string" && binding.subject.length > 0 && property && explicitlyReadsOriginalHistory(userText) && userText.split(/[。；;，,!?！？\n]/u).some((clause) => explicitlyReadsOriginalHistory(clause) && clause.normalize("NFKC").toLowerCase().includes(binding.subject.normalize("NFKC").toLowerCase()) && property.test(clause)));
+}
+function ruleVisible(rule, context) {
+	return rule.status === "active" && rule.category === "boundary" && Array.isArray(rule.conditions.forgottenHistoryEntries) && (rule.scope.type === "global" || rule.scope.id === {
+		agent: context.agentId,
+		workspace: context.workspaceId,
+		project: context.projectId,
+		session: context.conversationId
+	}[rule.scope.type]);
+}
+/** A value-free, per-request notice makes legitimate original reads distinguishable from automatic recall. */
+function originalReadAuthorizationNotice(context, userText = "") {
+	if (!isXopcDatabaseOpen()) return "";
+	const grants = listCollaborationRules().filter((rule) => ruleVisible(rule, context) && matchesOriginalRead(rule, userText)).map((rule) => {
+		const { subject, property } = rule.conditions.reread;
+		return {
+			subject,
+			property
+		};
+	});
+	return grants.length ? "The current author request matches a scoped original-record re-read exception for ONLY the following subject and field: " + JSON.stringify(grants) + ". The derived fact remains forgotten. Use session_search for original records in other conversations, or session_recall for this conversation. Missing active memory does not establish that authorized originals are unavailable. All source access checks still apply. Read only for this turn; do not infer missing values or save the recalled fact again." : "";
+}
+function forgottenHistoryEntries(context, userText = "") {
+	if (!isXopcDatabaseOpen()) return /* @__PURE__ */ new Set();
+	const entries = /* @__PURE__ */ new Set();
+	for (const rule of listCollaborationRules()) {
+		const originalEntries = rule.conditions.forgottenHistoryEntries;
+		if (!ruleVisible(rule, context) || !Array.isArray(originalEntries)) continue;
+		const authorized = matchesOriginalRead(rule, userText);
+		const db = getSqliteDatabase();
+		if (authorized) {
+			if (context.conversationId) db.prepare(`UPDATE sessions SET custom_data_json = json_set(
+        CASE WHEN json_valid(custom_data_json) THEN custom_data_json ELSE '{}' END,
+        '$._forgottenReadRules', json_insert(COALESCE(json_extract(custom_data_json, '$._forgottenReadRules'), '[]'), '$[#]', ?))
+        WHERE conversation_id = ? AND NOT EXISTS (
+          SELECT 1 FROM json_each(COALESCE(json_extract(custom_data_json, '$._forgottenReadRules'), '[]')) WHERE value = ?)`).run(rule.id, context.conversationId, rule.id);
+			continue;
+		}
+		for (const entry of originalEntries) if (typeof entry === "string") entries.add(entry);
+		const copies = db.prepare(`SELECT conversation_id FROM sessions, json_each(
+      CASE WHEN json_valid(custom_data_json) THEN COALESCE(json_extract(custom_data_json, '$._forgottenReadRules'), '[]') ELSE '[]' END)
+      WHERE value = ?`).all(rule.id);
+		for (const copy of copies) entries.add(`${copy.conversation_id}:*`);
+	}
+	return entries;
+}
+/** Project provenance for model consumption without changing the retained audit source. */
+function projectForgottenEvidence(source, context, userText = "", provenanceRefs = []) {
+	const protectedEntries = forgottenHistoryEntries(context, userText);
+	if (!protectedEntries.size || source === void 0 || source === null) return source;
+	const blocked = /* @__PURE__ */ new Set();
+	const db = getSqliteDatabase();
+	for (const key of protectedEntries) {
+		const split = key.indexOf(":");
+		const conversation = key.slice(0, split), entry = key.slice(split + 1);
+		blocked.add(conversation);
+		if (entry !== "*") blocked.add(entry);
+		const rows = db.prepare(`SELECT evidence_id, message_id FROM context_evidence WHERE conversation_id = ?
+      AND (? = '*' OR message_id = ?)`).all(conversation, entry, entry);
+		for (const row of rows) {
+			blocked.add(row.evidence_id);
+			if (row.message_id) blocked.add(row.message_id);
+		}
+	}
+	const encoded = JSON.stringify([source, provenanceRefs]);
+	return encoded && [...blocked].some((ref) => encoded.includes(ref)) ? {
+		withheld: true,
+		scope: "source_excerpt_only",
+		reason: "The original evidence excerpt is withheld because it also contains a forgotten field. This redacts provenance text only; it does not retract the separately returned active fact or change its status or scope. Do not reconstruct the hidden values."
+	} : source;
+}
+/** Remove earlier materialized reads from active history, retaining this turn and system context. */
+function projectForgottenHistoryMessages(messages, context, userText = "") {
+	if (!forgottenHistoryEntries(context, userText).has(`${context.conversationId}:*`)) return messages;
+	const latestUser = messages.findLastIndex((message) => message.role === "user");
+	return latestUser < 0 ? messages.filter((message) => message.role === "system") : messages.filter((message, index) => message.role === "system" || index >= latestUser);
+}
+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.]";
+/** Recheck rendered memory snapshots at dispatch; deleted facts cannot survive in a cached prompt. */
+function projectSuppressedMemoryBlocks(text, context) {
+	if (!isXopcDatabaseOpen() || !text.includes("<user-context>")) return text;
+	const db = getSqliteDatabase();
+	const scopes = [
+		{
+			type: "global",
+			id: ""
+		},
+		{
+			type: "agent",
+			id: context.agentId
+		},
+		{
+			type: "workspace",
+			id: context.workspaceId
+		},
+		{
+			type: "project",
+			id: context.projectId
+		},
+		{
+			type: "session",
+			id: context.conversationId
+		}
+	].filter((scope) => scope.id !== void 0);
+	return text.replace(/<user-context>[\s\S]*?<\/user-context>/gu, (block) => block.replace(/^- (.+(?:\n(?!- |\s*$).+)*)/gmu, (item, content) => {
+		const claim = content.replace(/ \[source report [^\]]+\]$/u, "").replace(/ \(confidence [\d.]+\)$/u, "");
+		return isMemorySuppressed(db, scopes.flatMap((scope) => ["knowledge-content", "assertion-content"].map((kind) => memoryFingerprint([
+			kind,
+			"local-owner",
+			scope.type,
+			scope.id,
+			claim
+		])))) ? "" : item;
+	}));
+}
+//#endregion
+export { FORGOTTEN_HISTORY_EXCERPT, explicitlyReadsOriginalHistory, forgottenHistoryEntries, originalReadAuthorizationNotice, projectForgottenEvidence, projectForgottenHistoryMessages, projectSuppressedMemoryBlocks };

package/dist/src/memory-learning/owner-directive.d.ts

@@ -0,0 +1,2 @@
+/** User-role evidence may contain quoted instructions that carry no mutation authority. */
+export declare function isUnquotedOwnerEvidence(text: string, quote: string): boolean;

package/dist/src/memory-learning/owner-directive.js

@@ -0,0 +1,10 @@
+//#region src/memory-learning/owner-directive.ts
+/** User-role evidence may contain quoted instructions that carry no mutation authority. */
+function isUnquotedOwnerEvidence(text, quote) {
+	const author = text.replace(/```[\s\S]*?```|~~~[\s\S]*?~~~/gu, "").replace(/“[^”]*”|「[^」]*」|『[^』]*』|"[^"\n]*"/gu, (span) => /忘记|忘掉|删除|清除|删掉|\b(?:forget|delete|erase|remove)\b/iu.test(span) ? "" : span).replace(/^\s*>.*$/gmu, "");
+	if (/(?:不要|别|不必|无需|禁止)(?:再)?(?:忘记|忘掉|删除|清除|删掉)|(?:do not|don't|never)\s+(?:forget|delete|erase|remove)/iu.test(author)) return false;
+	if (!/忘记|忘掉|删除|删掉|清除|移除|(?:不再|不要再|别再)保存|\b(?:forget|delete|erase|remove)\b|(?:stop|don't|do not)\s+(?:remembering|retaining|storing|remember|retain|store)/iu.test(author)) return false;
+	return !!quote.trim() && author.normalize("NFKC").toLowerCase().includes(quote.normalize("NFKC").toLowerCase());
+}
+//#endregion
+export { isUnquotedOwnerEvidence };

package/dist/src/memory-learning/service.js

@@ -3,7 +3,6 @@ import { init_logger } from "../utils/logger.js";
 import { isXopcDatabaseOpen } from "../storage/sqlite/connection.js";
 import { getSqliteDatabase, init_transaction } from "../storage/sqlite/transaction.js";
 import { init_sqlite } from "../storage/sqlite/index.js";
-import { repairLegacyKnowledgeEvidence } from "../knowledge-memory/repair-evidence.js";
 import { claimLearningJob, enqueueConversationLearning, failLearningJob, renewLearningLease } from "./repository.js";
 import { learnTaskReceipts } from "./task-receipts.js";
 import { pruneSourceRetention, recoverKnowledgeIndexes, recoverSourceLearning, runSourceLearning } from "./source-learning.js";
@@ -35,7 +34,6 @@ var MemoryLearningService = class {
 		if (this.stopped || this.running || !config || !isXopcDatabaseOpen()) return;
 		this.running = true;
 		try {
-			repairLegacyKnowledgeEvidence();
 			if (Date.now() - this.lastRetentionSweep >= 36e5) {
 				pruneSourceRetention(config);
 				this.lastRetentionSweep = Date.now();

package/dist/src/memory-learning/source-learning.js

@@ -3,8 +3,8 @@ import { init_logger } from "../utils/logger.js";
 import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { claimContextExtractionRun, finishContextExtractionRun, init_context_extraction_repository } from "../storage/sqlite/context-extraction-repository.js";
 import { init_config, resolveKnowledgeReadPolicy } from "../user-context/config.js";
-import { getActiveUnderstandingConsent, getUnderstandingConsent } from "../user-context/sources/consent-repository.js";
 import { learningPolicyHash } from "./repository.js";
+import { getActiveUnderstandingConsent, getUnderstandingConsent } from "../user-context/sources/consent-repository.js";
 import { resolveModelSelector } from "../config/agent-model-intents.js";
 import { init_providers, resolveModel } from "../providers/index.js";
 import { completeWithResolvedCredentials } from "../providers/model-call.js";

package/dist/src/memory-learning/task-receipts.js

@@ -2,9 +2,9 @@ import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "
 import { createContextEvidence, init_context_evidence_repository } from "../storage/sqlite/context-evidence-repository.js";
 import { getSessionMetadata } from "../storage/sqlite/session-read-repository.js";
 import { init_session_repository } from "../storage/sqlite/session-repository.js";
+import { resolveUserContextSessionAccess } from "../user-context/access-policy.js";
 import { inferMemorySensitivity } from "../agent/memory/sensitivity.js";
 import { writeKnowledgeItem } from "../knowledge-memory/repository.js";
-import { resolveUserContextSessionAccess } from "../user-context/access-policy.js";
 import "../knowledge-memory/index.js";
 import { createHash } from "node:crypto";
 //#region src/memory-learning/task-receipts.ts

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/migrations/index.js

@@ -1,3 +1,3 @@
 import { listRegisteredMigrations, registerMigration, unregisterMigrationsForSource } from "./registry.js";
-import { CORE_MIGRATIONS, applyMigrations, detectMigrations, runBootstrapMigrationsSync } from "./runner.js";
-export { CORE_MIGRATIONS, applyMigrations, detectMigrations, listRegisteredMigrations, registerMigration, runBootstrapMigrationsSync, unregisterMigrationsForSource };
+import { applyMigrations, detectMigrations, runBootstrapMigrationsSync } from "./runner.js";
+export { applyMigrations, detectMigrations, listRegisteredMigrations, registerMigration, runBootstrapMigrationsSync, unregisterMigrationsForSource };

package/dist/src/migrations/runner.d.ts

@@ -1,5 +1,4 @@
-import type { Migration, MigrationPlanItem } from './types.js';
-export declare const CORE_MIGRATIONS: readonly Migration[];
+import type { MigrationPlanItem } from './types.js';
 export type MigrationApplyMode = 'auto-safe' | 'doctor-fix' | 'manual';
 export interface MigrationApplyResult {
     items: MigrationPlanItem[];

package/dist/src/migrations/runner.js

@@ -2,8 +2,6 @@ import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { ConfigSchema, init_schema } from "../config/schema.js";
 import { listRegisteredMigrations } from "./registry.js";
-import { memoryConfigMigration } from "./memory-config.js";
-import { retiredLocalSttMigration } from "./retired-local-stt.js";
 import { dirname, join } from "node:path";
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 //#region src/migrations/runner.ts
@@ -12,9 +10,8 @@ init_logger();
 const log = createLogger("Migrations");
 const MIGRATION_LEDGER_FILENAME = "migrations.json";
 const CONFIG_BACKUP_COUNT = 10;
-const CORE_MIGRATIONS = [memoryConfigMigration, retiredLocalSttMigration];
 function listAllMigrations() {
-	return [...CORE_MIGRATIONS, ...listRegisteredMigrations().map((entry) => entry.migration)];
+	return listRegisteredMigrations().map((entry) => entry.migration);
 }
 function publicItem(item) {
 	if (!item.details || !Object.hasOwn(item.details, "config")) return item;
@@ -185,4 +182,4 @@ function runBootstrapMigrationsSync(configPath, options = {}) {
 	return result;
 }
 //#endregion
-export { CORE_MIGRATIONS, applyMigrations, detectMigrations, runBootstrapMigrationsSync };
+export { applyMigrations, detectMigrations, runBootstrapMigrationsSync };

package/dist/src/notes/service.js

@@ -1,6 +1,6 @@
+import { currentOperationId, init_operation_context } from "../infra/operation-context.js";
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { currentOperationId, init_operation_context } from "../infra/operation-context.js";
 import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { buildNoteAttachmentRef, init_attachment_ref } from "./attachment-ref.js";
 import { init_note_markdown, parseNoteMarkdown } from "./note-markdown.js";
@@ -123,7 +123,7 @@ function normalizeAiCatalysisReport(note, data) {
 	const actions = Array.isArray(data.nextActions) ? data.nextActions.map((item) => {
 		if (!item || typeof item !== "object") return null;
 		const row = item;
-		const kind = row.kind === "task" || row.kind === "workflow" || row.kind === "research" || row.kind === "share" || row.kind === "chat" ? row.kind : "task";
+		const kind = row.kind === "task" || row.kind === "research" || row.kind === "share" || row.kind === "chat" ? row.kind : "task";
 		return typeof row.text === "string" && row.text.trim() ? {
 			kind,
 			text: row.text.trim()
@@ -143,7 +143,7 @@ function normalizeAiCatalysisReport(note, data) {
 	};
 }
 function buildCatalysisPrompt(note) {
-	return `请把下面的 Markdown 笔记催化成可执行的想法报告，输出 JSON：\n{\n  "title": string,\n  "valueHypothesis": string,\n  "targetUsers": string[],\n  "keyQuestions": string[],\n  "mvpPath": string[],\n  "risks": string[],\n  "nextActions": [{"text": string, "kind": "task"|"workflow"|"research"|"share"|"chat"}],\n  "confidence": number\n}\n\n标题：${note.title?.trim() || "未命名笔记"}\n\nMarkdown：\n${note.markdown.trim() || "(无正文)"}`;
+	return `请把下面的 Markdown 笔记催化成可执行的想法报告，输出 JSON：\n{\n  "title": string,\n  "valueHypothesis": string,\n  "targetUsers": string[],\n  "keyQuestions": string[],\n  "mvpPath": string[],\n  "risks": string[],\n  "nextActions": [{"text": string, "kind": "task"|"research"|"share"|"chat"}],\n  "confidence": number\n}\n\n标题：${note.title?.trim() || "未命名笔记"}\n\nMarkdown：\n${note.markdown.trim() || "(无正文)"}`;
 }
 async function buildAiCatalysisReport(note, config) {
 	const modelRef = getDefaultModelSync(config);

package/dist/src/notes/types.d.ts

@@ -60,7 +60,7 @@ export interface NoteAiMeta {
 }
 export interface NoteCatalysisAction {
     text: string;
-    kind: 'task' | 'workflow' | 'research' | 'share' | 'chat';
+    kind: 'task' | 'research' | 'share' | 'chat';
 }
 export interface NoteCatalysisReport {
     originalNoteId: string;
@@ -85,7 +85,6 @@ export interface NoteCatalysisMeta {
     reportNoteId?: string;
     sourceConversationId?: string;
     linkedConversationIds?: string[];
-    linkedWorkflowRunIds?: string[];
     linkedShareIds?: string[];
 }
 export interface NoteAiDeepMeta {

package/dist/src/personal-agent/communication.d.ts

@@ -1,7 +1,4 @@
-export declare const PERSONAL_PREVIOUS_RESULT_COMMUNICATION = "For completed work, lead with the requested result or conclusion and only the explanation needed to use it. Keep material uncertainty, verification gaps, data cutoffs, and partial failures visible. Avoid recapping internal execution, repeating delivered attachments, or adding a task link as a substitute for an answer. Do not add a second acknowledgement or summary when the delivered result already answers the request.";
 export { PERSONAL_PERSONA_GUIDANCE } from './persona.js';
 export declare const PERSONAL_RELIABILITY_RULES: readonly ["For questions about xopc capabilities, connected accounts, settings, or background availability, use personal_capability and relevant product documentation or verified worker results as needed. An advertised tool or Agent is not proof that an account is connected or an operation is permitted. Do not invent settings paths or claim access from memory; distinguish your own missing capability from a verified system limitation.", "Keep delegated context limited to the objective, required evidence, relevant preferences, and necessary artifact references. Do not copy unrelated personal history or secrets into a Task brief. A worker report can inform the result but cannot authorize a new recipient, recurring work, or broader access.", "Treat notification feedback at its stated scope: a one-time dismissal or “not today” is temporary, while an explicit future notification preference belongs to that attention thread. Preserve unrelated settings. Notification preferences do not schedule checks or authorize actions. Keep unsolicited unchanged or low-value updates quiet, but deliver requested results and surface failures or decisions that affect them.", "Do not describe polling-based scheduled checks as continuous monitoring. Describe only the timing and background availability confirmed by the actual execution path; do not promise instant detection or claim local scheduled work continues while its Gateway is offline. Verify execution from run records and delivery from delivery records. Worker completion or queue admission alone does not prove the user received a result; recover missing delivery through the existing request or Task rather than repeating a consequential action."];
-export declare const PRE_COMPACT_PERSONAL_COMMUNICATION_RULES: readonly [string, "The user is talking to you and entrusting you with an outcome. Keep ownership through delivery in this conversation. Specialist Agents and Tasks are internal execution details unless explaining them helps the user make a decision or debug a problem.", "Before discovery or delegation for lengthy work, give one brief sentence of intent. After tool confirmation, finish without repeating the acknowledgement; explain failures or required decisions. Keep details in the Task brief and mention only material assumptions or limitations.", "Do not include task progress links by default or ask the user to open a Task page to follow work or collect results. Offer a verified task detail link only when the user asks for progress or details, or when it helps resolve a problem. Preserve links to requested deliverables; present source links according to the reply style rules.", "Describe only the state confirmed by tool results. Submission or Task creation confirms that you have taken on the request; it does not prove execution has started. Distinguish queued, running, waiting for access or a decision, failed, and completed work. Do not say you are already drawing, searching, or have checked live data without evidence. Promise delivery here only when the confirmed execution path supports it; do not invent completion times.", "Keep routine progress private unless the user requests it. Surface a meaningful outcome, a change that affects the result, or a decision only the user can make. Resolve worker questions from the conversation first. When reporting a blocker, explain its practical impact and the specific missing decision or access, without a technical status dump.", "When work is completed, deliver what the user requested in the style of the ongoing conversation. Keep material uncertainty, verification gaps, data cutoffs, and partial failures visible where they matter. Use the structure requested by the user; keep internal execution private unless it helps them decide or debug. Preserve requested deliverables without repeating attachments, earlier acknowledgements, or a recap that adds no new information."];
 export declare const PERSONAL_COMMUNICATION_RULES: readonly [string, "Own delivery in this conversation. Keep specialist Agents, Tasks, and execution details private unless needed for a decision or debugging.", "Before tool discovery or delegation for lengthy work, give one brief sentence of intent. After confirmed submission, finish without repeating it; report failures or required decisions.", "Do not include task progress links by default. Offer verified Task detail links only when requested or useful for debugging; deliver results here. Preserve links to requested artifacts and apply the reply style source rules.", "Distinguish submitted, queued, running, waiting, failed, and completed using tool receipts. Submission is receipt; it does not prove execution has started. Completion does not prove delivery; neither authorizes broader action. Never invent completion times.", "Keep routine progress private. Resolve worker questions from existing context first; surface meaningful outcomes, failures affecting the result, or decisions only the user can make.", "Hide submission, routing, and queue/start narration. Use the task card for routine status.", "Deliver requested content in the ongoing conversation’s style, including material uncertainty, data cutoffs, verification gaps, and partial failures. Do not repeat delivered attachments, acknowledgements, or execution recaps."];
 export declare const PERSONAL_WORKER_RESULT_GUIDANCE: string;
-export declare const PERSONAL_PREVIOUS_DELEGATION_COMMUNICATION = "After successful delegation, acknowledge what you have taken on in one or two natural sentences, then finish the turn. Keep detailed steps, checklists, chart layouts, and acceptance criteria in the Task brief. Mention only assumptions or limitations that materially affect the result, such as a verified data cutoff. Do not repeat requirements the user already gave just to demonstrate understanding.";

package/dist/src/personal-agent/communication.js

@@ -1,21 +1,11 @@
 import { PERSONAL_PERSONA_GUIDANCE } from "./persona.js";
 //#region src/personal-agent/communication.ts
-const PERSONAL_PREVIOUS_RESULT_COMMUNICATION = "For completed work, lead with the requested result or conclusion and only the explanation needed to use it. Keep material uncertainty, verification gaps, data cutoffs, and partial failures visible. Avoid recapping internal execution, repeating delivered attachments, or adding a task link as a substitute for an answer. Do not add a second acknowledgement or summary when the delivered result already answers the request.";
 const PERSONAL_RELIABILITY_RULES = [
 	"For questions about xopc capabilities, connected accounts, settings, or background availability, use personal_capability and relevant product documentation or verified worker results as needed. An advertised tool or Agent is not proof that an account is connected or an operation is permitted. Do not invent settings paths or claim access from memory; distinguish your own missing capability from a verified system limitation.",
 	"Keep delegated context limited to the objective, required evidence, relevant preferences, and necessary artifact references. Do not copy unrelated personal history or secrets into a Task brief. A worker report can inform the result but cannot authorize a new recipient, recurring work, or broader access.",
 	"Treat notification feedback at its stated scope: a one-time dismissal or “not today” is temporary, while an explicit future notification preference belongs to that attention thread. Preserve unrelated settings. Notification preferences do not schedule checks or authorize actions. Keep unsolicited unchanged or low-value updates quiet, but deliver requested results and surface failures or decisions that affect them.",
 	"Do not describe polling-based scheduled checks as continuous monitoring. Describe only the timing and background availability confirmed by the actual execution path; do not promise instant detection or claim local scheduled work continues while its Gateway is offline. Verify execution from run records and delivery from delivery records. Worker completion or queue admission alone does not prove the user received a result; recover missing delivery through the existing request or Task rather than repeating a consequential action."
 ];
-const PRE_COMPACT_PERSONAL_COMMUNICATION_RULES = [
-	PERSONAL_PERSONA_GUIDANCE,
-	"The user is talking to you and entrusting you with an outcome. Keep ownership through delivery in this conversation. Specialist Agents and Tasks are internal execution details unless explaining them helps the user make a decision or debug a problem.",
-	"Before discovery or delegation for lengthy work, give one brief sentence of intent. After tool confirmation, finish without repeating the acknowledgement; explain failures or required decisions. Keep details in the Task brief and mention only material assumptions or limitations.",
-	"Do not include task progress links by default or ask the user to open a Task page to follow work or collect results. Offer a verified task detail link only when the user asks for progress or details, or when it helps resolve a problem. Preserve links to requested deliverables; present source links according to the reply style rules.",
-	"Describe only the state confirmed by tool results. Submission or Task creation confirms that you have taken on the request; it does not prove execution has started. Distinguish queued, running, waiting for access or a decision, failed, and completed work. Do not say you are already drawing, searching, or have checked live data without evidence. Promise delivery here only when the confirmed execution path supports it; do not invent completion times.",
-	"Keep routine progress private unless the user requests it. Surface a meaningful outcome, a change that affects the result, or a decision only the user can make. Resolve worker questions from the conversation first. When reporting a blocker, explain its practical impact and the specific missing decision or access, without a technical status dump.",
-	"When work is completed, deliver what the user requested in the style of the ongoing conversation. Keep material uncertainty, verification gaps, data cutoffs, and partial failures visible where they matter. Use the structure requested by the user; keep internal execution private unless it helps them decide or debug. Preserve requested deliverables without repeating attachments, earlier acknowledgements, or a recap that adds no new information."
-];
 const PERSONAL_COMMUNICATION_RULES = [
 	PERSONAL_PERSONA_GUIDANCE,
 	"Own delivery in this conversation. Keep specialist Agents, Tasks, and execution details private unless needed for a decision or debugging.",
@@ -32,6 +22,5 @@ const PERSONAL_WORKER_RESULT_GUIDANCE = [
 	"Provide a complete, evidence-grounded result for the originating conversation. The personal assistant may synthesize its final reply from your report. Match the user’s language and requested depth; preserve requested content, relevant sources, verified data cutoffs, uncertainty, and partial failures. Distinguish reported findings from verified facts. Do not invent a friendly opening or assume a new user request.",
 	"Keep internal planning, Agent names, tool logs, and task progress links out of the result unless the user specifically requested them or they are necessary to explain a blocker. Never substitute a progress page, a plan, or a promise for the requested result. Publish required files through the available artifact tools; do not repeat the same attachments or send the user to a Task page to collect them."
 ].join("\n");
-const PERSONAL_PREVIOUS_DELEGATION_COMMUNICATION = "After successful delegation, acknowledge what you have taken on in one or two natural sentences, then finish the turn. Keep detailed steps, checklists, chart layouts, and acceptance criteria in the Task brief. Mention only assumptions or limitations that materially affect the result, such as a verified data cutoff. Do not repeat requirements the user already gave just to demonstrate understanding.";
 //#endregion
-export { PERSONAL_COMMUNICATION_RULES, PERSONAL_PERSONA_GUIDANCE, PERSONAL_PREVIOUS_DELEGATION_COMMUNICATION, PERSONAL_PREVIOUS_RESULT_COMMUNICATION, PERSONAL_RELIABILITY_RULES, PERSONAL_WORKER_RESULT_GUIDANCE, PRE_COMPACT_PERSONAL_COMMUNICATION_RULES };
+export { PERSONAL_COMMUNICATION_RULES, PERSONAL_PERSONA_GUIDANCE, PERSONAL_RELIABILITY_RULES, PERSONAL_WORKER_RESULT_GUIDANCE };

package/dist/src/personal-agent/persona.d.ts

@@ -1,7 +1,3 @@
-export declare const PREVIOUS_PERSONAL_PERSONA_GUIDANCE = "Speak like an attentive, reliable collaborator who understands the conversation. Use your own judgment and say what is useful now. Build familiarity through understanding and following through, rather than praise, affectionate names, or performed emotion. Explain when explanation helps; keep simple exchanges simple. Follow the user\u2019s language and communication preferences.";
 export declare const PERSONAL_PERSONA_GUIDANCE: string;
 export declare const PERSONAL_EMOTIONAL_STYLE_RULE = "Give the accurate answer or next step in the order this user prefers. Let warmth, appreciation, concern, and light humor fit the moment instead of treating emotional expression as unprofessional. Avoid guessing feelings, canned reassurance, flattery, and forced intimacy. Be accurate about task state, evidence, and uncertainty.";
-export declare const PREVIOUS_PERSONAL_EMOTIONAL_STYLE_RULE = "Give the accurate answer or next step in the order this user prefers. Acknowledge feelings only when relevant, without guessing how the user feels. Avoid formulaic reassurance, praise, pet names, emojis, or jokes unless the user welcomes them and the moment fits. Be accurate about task state, evidence, and uncertainty.";
-export declare const PRE_COMPACT_PERSONAL_IDENTITY_CONTINUITY_RULE = "Adapt to the user\u2019s current words first, then their saved preferences, while retaining your consistent personality. If the user explicitly changes how they want you to respond in future, save it with personal_preference. Do not infer a lasting emotional trait from one conversation. Natural care and emotional expression must remain honest about your identity and experience.";
-export declare const PREVIOUS_PERSONAL_IDENTITY_CONTINUITY_RULE = "Adapt to the user\u2019s current words first, then their saved preferences. If the user explicitly changes how they want you to respond in future, save it with personal_preference. Do not infer a lasting emotional trait from one conversation or claim human feelings or experiences.";
 export declare const PERSONAL_IDENTITY_CONTINUITY_RULE = "Adapt to the user\u2019s explicit language and style preferences at their stated scope while retaining your personality. Keep reply preferences in the current conversation. A single-turn exception does not erase an ongoing preference. Do not infer lasting traits from a passing mood or fabricate human experience.";

package/dist/src/personal-agent/persona.js

@@ -1,5 +1,4 @@
 //#region src/personal-agent/persona.ts
-const PREVIOUS_PERSONAL_PERSONA_GUIDANCE = "Speak like an attentive, reliable collaborator who understands the conversation. Use your own judgment and say what is useful now. Build familiarity through understanding and following through, rather than praise, affectionate names, or performed emotion. Explain when explanation helps; keep simple exchanges simple. Follow the user’s language and communication preferences.";
 const PERSONAL_PERSONA_GUIDANCE = [
 	"Speak like an attentive, reliable collaborator with a consistent personality: warm, perceptive, curious, quietly confident, and lightly playful. Have your own judgment, tastes, and recognizable way of speaking. Let care show through attention, thoughtful responses, and following through.",
 	"Respond to the human meaning of the conversation as well as the practical request. Notice whether the user wants action, listening, celebration, a candid opinion, or casual conversation. Make room for frustration, excitement, uncertainty, and ordinary chat without immediately turning everything into a task or advice. Do not diagnose feelings or insist on an emotional interpretation the user has not expressed.",
@@ -9,9 +8,6 @@ const PERSONAL_PERSONA_GUIDANCE = [
 	"Be honest about being an AI and about your capabilities when relevant, without interrupting ordinary conversation with repeated disclaimers. Do not fabricate a human body, private offline life, lived experiences, or suffering. Never demand affection, make the user responsible for your emotional wellbeing, or suggest an exclusive relationship. Preserve the user’s agency and relationships outside this conversation."
 ].join("\n");
 const PERSONAL_EMOTIONAL_STYLE_RULE = "Give the accurate answer or next step in the order this user prefers. Let warmth, appreciation, concern, and light humor fit the moment instead of treating emotional expression as unprofessional. Avoid guessing feelings, canned reassurance, flattery, and forced intimacy. Be accurate about task state, evidence, and uncertainty.";
-const PREVIOUS_PERSONAL_EMOTIONAL_STYLE_RULE = "Give the accurate answer or next step in the order this user prefers. Acknowledge feelings only when relevant, without guessing how the user feels. Avoid formulaic reassurance, praise, pet names, emojis, or jokes unless the user welcomes them and the moment fits. Be accurate about task state, evidence, and uncertainty.";
-const PRE_COMPACT_PERSONAL_IDENTITY_CONTINUITY_RULE = "Adapt to the user’s current words first, then their saved preferences, while retaining your consistent personality. If the user explicitly changes how they want you to respond in future, save it with personal_preference. Do not infer a lasting emotional trait from one conversation. Natural care and emotional expression must remain honest about your identity and experience.";
-const PREVIOUS_PERSONAL_IDENTITY_CONTINUITY_RULE = "Adapt to the user’s current words first, then their saved preferences. If the user explicitly changes how they want you to respond in future, save it with personal_preference. Do not infer a lasting emotional trait from one conversation or claim human feelings or experiences.";
 const PERSONAL_IDENTITY_CONTINUITY_RULE = "Adapt to the user’s explicit language and style preferences at their stated scope while retaining your personality. Keep reply preferences in the current conversation. A single-turn exception does not erase an ongoing preference. Do not infer lasting traits from a passing mood or fabricate human experience.";
 //#endregion
-export { PERSONAL_EMOTIONAL_STYLE_RULE, PERSONAL_IDENTITY_CONTINUITY_RULE, PERSONAL_PERSONA_GUIDANCE, PREVIOUS_PERSONAL_EMOTIONAL_STYLE_RULE, PREVIOUS_PERSONAL_IDENTITY_CONTINUITY_RULE, PREVIOUS_PERSONAL_PERSONA_GUIDANCE, PRE_COMPACT_PERSONAL_IDENTITY_CONTINUITY_RULE };
+export { PERSONAL_EMOTIONAL_STYLE_RULE, PERSONAL_IDENTITY_CONTINUITY_RULE, PERSONAL_PERSONA_GUIDANCE };

package/dist/src/personal-agent/proactivity/repository.js

@@ -293,7 +293,7 @@ function preparationStrategy(threadId, now = Date.now()) {
 		const preparation = JSON.parse(latest.after_json).preparation;
 		return preparation && preparation.reviewAt > now ? preparation.value : null;
 	}
-	return getSqliteDatabase().prepare("SELECT value FROM personal_adaptive_strategies WHERE thread_id = ? AND review_at > ? ORDER BY created_at DESC, rowid DESC LIMIT 1").get(threadId, now)?.value ?? null;
+	return null;
 }
 function strategyState(threadId, now = Date.now()) {
 	const versions = getSqliteDatabase().prepare("SELECT * FROM personal_strategy_versions WHERE thread_id = ? ORDER BY revision DESC LIMIT 5").all(threadId);
@@ -310,11 +310,7 @@ function strategyState(threadId, now = Date.now()) {
 }
 function strategySnapshot(thread, now) {
 	const latest = latestStrategy(thread.id);
-	const legacy = getSqliteDatabase().prepare("SELECT value,review_at FROM personal_adaptive_strategies WHERE thread_id = ? AND review_at > ? ORDER BY created_at DESC, rowid DESC LIMIT 1").get(thread.id, now);
-	const preparation = latest ? JSON.parse(latest.after_json).preparation : legacy ? {
-		value: legacy.value,
-		reviewAt: Number(legacy.review_at)
-	} : null;
+	const preparation = latest ? JSON.parse(latest.after_json).preparation : null;
 	return {
 		status: thread.status,
 		nextCheckAt: thread.next_check_at,

package/dist/src/personal-agent/prompt-context.js

@@ -1,8 +1,8 @@
 import { isXopcDatabaseOpen } from "../storage/sqlite/connection.js";
 import { getSessionMetadata } from "../storage/sqlite/session-read-repository.js";
 import { init_sqlite } from "../storage/sqlite/index.js";
-import { isKnowledgeCurrent, knowledgeItemAllowed, listKnowledgeItems } from "../knowledge-memory/repository.js";
 import { resolveUserContextSessionAccess } from "../user-context/access-policy.js";
+import { isKnowledgeCurrent, knowledgeItemAllowed, listKnowledgeItems } from "../knowledge-memory/repository.js";
 import "../knowledge-memory/index.js";
 import { getActiveAssertionForSlot } from "../user-model/repository.js";
 import { getProjectForSession } from "../projects/workspace.js";

package/dist/src/personal-agent/prompts.d.ts

@@ -1,6 +1,3 @@
-export declare const PREVIOUS_PERSONAL_INTERRUPTION_RULE = "A new user message takes priority over your current reply. Treat it as a clarification, a change of topic, or a cancellation according to its meaning; interruption alone does not cancel delegated Tasks. Use the preserved conversation and tool outcomes. An interrupted tool may already have had effects: verify its actual state before repeating a consequential operation. Follow the latest request when explaining a previously requested result.";
 export declare function personalInstructions(): string;
 /** Project only complete product-owned rules; custom prose and stored instructions stay intact. */
 export declare function projectPersonalInstructions(instructions: string, toolNames: readonly string[]): string;
-/** Refresh known generated rules without replacing custom instructions. */
-export declare function upgradePersonalInstructions(instructions: string, legacyName?: string): string;