@xopcai/xopc 0.0.248 → 0.0.250

package/dist/src/agent/tools/knowledge-memory-tool.js

@@ -0,0 +1,184 @@
+import { getKnowledgeItem, knowledgeSourceAllowed, searchKnowledgeItems, writeKnowledgeItem } from "../../knowledge-memory/repository.js";
+import "../../knowledge-memory/index.js";
+import { Type } from "@sinclair/typebox";
+//#region src/agent/tools/knowledge-memory-tool.ts
+const SearchSchema = Type.Object({
+	query: Type.String(),
+	maxResults: Type.Optional(Type.Integer({
+		minimum: 1,
+		maximum: 50
+	}))
+});
+const GetSchema = Type.Object({ id: Type.String() });
+const WriteSchema = Type.Object({
+	kind: Type.Union([
+		Type.Literal("project_fact"),
+		Type.Literal("workspace_fact"),
+		Type.Literal("decision"),
+		Type.Literal("task_lesson"),
+		Type.Literal("commitment"),
+		Type.Literal("open_question"),
+		Type.Literal("episode"),
+		Type.Literal("note")
+	]),
+	content: Type.String(),
+	canonicalKey: Type.String(),
+	scope: Type.Union([
+		Type.Literal("workspace"),
+		Type.Literal("project"),
+		Type.Literal("session")
+	]),
+	importance: Type.Optional(Type.Number({
+		minimum: 0,
+		maximum: 1
+	}))
+});
+function visibility(options) {
+	const projectId = options.getProjectId?.();
+	return {
+		agentId: options.agentId,
+		workspaceId: options.workspaceId,
+		sessionId: options.getSessionId() ?? "",
+		...projectId ? { projectId } : {}
+	};
+}
+function createKnowledgeSearchTool(options) {
+	return {
+		name: "knowledge_search",
+		label: "Knowledge Search",
+		description: "Search project, workspace, and session knowledge for prior decisions, facts, lessons, and commitments.",
+		parameters: SearchSchema,
+		async execute(_toolCallId, raw) {
+			if (!options.canRead()) return {
+				content: [{
+					type: "text",
+					text: "Knowledge memory is disabled for this session."
+				}],
+				details: { error: "knowledge_memory_disabled" }
+			};
+			const input = raw;
+			const results = searchKnowledgeItems({
+				query: input.query,
+				context: visibility(options),
+				sources: options.getSources(),
+				limit: input.maxResults ?? 12
+			});
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({ results }, null, 2)
+				}],
+				details: { results }
+			};
+		}
+	};
+}
+function visibleItem(options, item) {
+	return item.scope.type === "global" || item.scope.type === "agent" && item.scope.id === options.agentId || item.scope.type === "workspace" && item.scope.id === options.workspaceId || item.scope.type === "project" && item.scope.id === options.getProjectId?.() || item.scope.type === "session" && item.scope.id === options.getSessionId();
+}
+function createKnowledgeGetTool(options) {
+	return {
+		name: "knowledge_get",
+		label: "Knowledge Get",
+		description: "Read one knowledge item returned by knowledge_search.",
+		parameters: GetSchema,
+		async execute(_toolCallId, raw) {
+			if (!options.canRead()) return {
+				content: [{
+					type: "text",
+					text: "Knowledge memory is disabled for this session."
+				}],
+				details: { error: "knowledge_memory_disabled" }
+			};
+			const id = raw.id;
+			const item = getKnowledgeItem(id);
+			return item && visibleItem(options, item) && knowledgeSourceAllowed(item, options.getSources()) ? {
+				content: [{
+					type: "text",
+					text: JSON.stringify(item, null, 2)
+				}],
+				details: { item }
+			} : {
+				content: [{
+					type: "text",
+					text: `Knowledge item not found: ${id}`
+				}],
+				details: { id }
+			};
+		}
+	};
+}
+function createKnowledgeWriteTool(options) {
+	return {
+		name: "knowledge_write",
+		label: "Knowledge Write",
+		description: "Store scoped knowledge with provenance, subject to the configured write policy.",
+		parameters: WriteSchema,
+		async execute(_toolCallId, raw) {
+			if (!options.canWrite()) return {
+				content: [{
+					type: "text",
+					text: "Knowledge memory writes are disabled for this session."
+				}],
+				details: { error: "knowledge_memory_disabled" }
+			};
+			const writePolicy = options.getWritePolicy();
+			if (writePolicy === "deny") return {
+				content: [{
+					type: "text",
+					text: "Knowledge memory writes are denied by policy."
+				}],
+				details: { error: "knowledge_write_denied" }
+			};
+			const input = raw;
+			if (!options.getSources().includes(input.scope)) return {
+				content: [{
+					type: "text",
+					text: `Knowledge source is disabled: ${input.scope}`
+				}],
+				details: {
+					error: "knowledge_source_disabled",
+					source: input.scope
+				}
+			};
+			const sessionId = options.getSessionId();
+			if (input.scope === "session" && !sessionId) throw new Error("A current session is required for session knowledge.");
+			const projectId = options.getProjectId?.();
+			if (input.scope === "project" && !projectId) throw new Error("A current project is required for project knowledge.");
+			const details = {
+				...writeKnowledgeItem({
+					kind: input.kind,
+					scope: input.scope === "workspace" ? {
+						type: "workspace",
+						id: options.workspaceId
+					} : input.scope === "project" ? {
+						type: "project",
+						id: projectId
+					} : {
+						type: "session",
+						id: sessionId
+					},
+					content: input.content,
+					canonicalKey: input.canonicalKey,
+					status: writePolicy === "allow" ? "active" : "candidate",
+					confidence: .7,
+					importance: input.importance ?? .5,
+					originClass: "agent",
+					sourceAgentId: options.agentId,
+					...sessionId ? { sourceSessionId: sessionId } : {},
+					source: { tool: "knowledge_write" }
+				}),
+				writePolicy
+			};
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(details, null, 2)
+				}],
+				details
+			};
+		}
+	};
+}
+//#endregion
+export { createKnowledgeGetTool, createKnowledgeSearchTool, createKnowledgeWriteTool };

package/dist/src/agent/tools/{dreaming-tool.d.ts → memory-maintenance-tool.d.ts}

@@ -1,6 +1,6 @@
 import type { AgentTool } from '@earendil-works/pi-agent-core';
 import type { Config } from '../../config/schema.js';
-export interface DreamingToolDeps {
+export interface MemoryMaintenanceToolDeps {
     getConfig: () => Config | undefined;
 }
-export declare function createDreamingTool(deps: DreamingToolDeps): AgentTool;
+export declare function createMemoryMaintenanceTool(deps: MemoryMaintenanceToolDeps): AgentTool;

package/dist/src/agent/tools/memory-maintenance-tool.js

@@ -0,0 +1,31 @@
+import { resolveMemoryMaintenanceSchedules } from "../../memory-maintenance/schedule.js";
+import { listMemoryMaintenanceRuns } from "../../memory-maintenance/service.js";
+import "../../memory-maintenance/index.js";
+import { Type } from "@sinclair/typebox";
+//#region src/agent/tools/memory-maintenance-tool.ts
+const StatusSchema = Type.Object({ action: Type.Literal("status") });
+function createMemoryMaintenanceTool(deps) {
+	return {
+		name: "memory_maintenance",
+		label: "Memory maintenance",
+		description: "Show deterministic user-model and knowledge-memory maintenance schedules and runs.",
+		parameters: StatusSchema,
+		async execute() {
+			const config = deps.getConfig();
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						enabled: Boolean(config && resolveMemoryMaintenanceSchedules(config).length),
+						schedules: config ? resolveMemoryMaintenanceSchedules(config) : [],
+						policy: "deterministic",
+						recentRuns: listMemoryMaintenanceRuns(20)
+					}, null, 2)
+				}],
+				details: {}
+			};
+		}
+	};
+}
+//#endregion
+export { createMemoryMaintenanceTool };

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

@@ -5,5 +5,6 @@ export interface SessionSearchToolDeps {
     getSessionStore: () => SessionStore;
     getPrimaryModel: () => Model<Api>;
     getCurrentSessionKey?: () => string | undefined;
+    canAccess?: () => boolean;
 }
 export declare function createSessionSearchTool(deps: SessionSearchToolDeps): AgentTool;

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

@@ -94,6 +94,13 @@ function createSessionSearchTool(deps) {
 		description: "Search other chat sessions by keywords and get short summaries, or omit `query` to list recent sessions (no LLM cost). Uses the same session store as the gateway. Narrow with roleFilter if needed.",
 		parameters: SessionSearchSchema,
 		async execute(_toolCallId, params, signal) {
+			if (deps.canAccess && !deps.canAccess()) return {
+				content: [{
+					type: "text",
+					text: "Cross-session history is disabled for this session."
+				}],
+				details: { error: "cross_session_history_disabled" }
+			};
 			const p = params;
 			const store = deps.getSessionStore();
 			const limit = Math.min(15, Math.max(1, p.limit ?? 5));

package/dist/src/agent/tools/user-context-tool.d.ts

@@ -0,0 +1,10 @@
+import type { AgentTool } from '@earendil-works/pi-agent-core';
+export interface UserContextToolOptions {
+    agentId: string;
+    workspaceId: string;
+    getSessionId: () => string | undefined;
+    getProjectId?: () => string | undefined;
+    canRead: () => boolean;
+}
+export declare function createUserContextSearchTool(options: UserContextToolOptions): AgentTool;
+export declare function createUserContextGetTool(options: UserContextToolOptions): AgentTool;

package/dist/src/agent/tools/user-context-tool.js

@@ -0,0 +1,98 @@
+import { retrievalLexicalSimilarity } from "../../retrieval/textFeatures.js";
+import { getAssertionSlot, getUserAssertion, listUserAssertions } from "../../user-model/repository.js";
+import "../../user-model/index.js";
+import { Type } from "@sinclair/typebox";
+//#region src/agent/tools/user-context-tool.ts
+const SearchSchema = Type.Object({
+	query: Type.String(),
+	maxResults: Type.Optional(Type.Integer({
+		minimum: 1,
+		maximum: 50
+	}))
+});
+const GetSchema = Type.Object({ id: Type.String() });
+function visible(options, slotId) {
+	const scope = getAssertionSlot(slotId)?.scope;
+	return scope?.type === "global" || scope?.type === "agent" && scope.id === options.agentId || scope?.type === "workspace" && scope.id === options.workspaceId || scope?.type === "project" && scope.id === options.getProjectId?.() || scope?.type === "session" && scope.id === options.getSessionId();
+}
+function referenceable(assertion) {
+	return assertion.status === "active" && assertion.authority !== "external_untrusted" && assertion.sensitivity !== "secret" && assertion.sensitivity !== "regulated" && assertion.disclosurePolicy !== "ask_before_reference";
+}
+function createUserContextSearchTool(options) {
+	return {
+		name: "user_context_search",
+		label: "User Context Search",
+		description: "Search typed user assertions such as identity, preferences, routines, and current state.",
+		parameters: SearchSchema,
+		async execute(_toolCallId, raw) {
+			if (!options.canRead()) return {
+				content: [{
+					type: "text",
+					text: "User context is disabled for this session."
+				}],
+				details: { error: "user_context_disabled" }
+			};
+			const input = raw;
+			const results = listUserAssertions({
+				statuses: ["active"],
+				limit: 1e3
+			}).filter((assertion) => visible(options, assertion.slotId)).filter(referenceable).map((assertion) => ({
+				assertion,
+				score: retrievalLexicalSimilarity(input.query, `${assertion.statement} ${assertion.normalizedValue}`)
+			})).filter((item) => item.score > 0).sort((left, right) => right.score - left.score).slice(0, input.maxResults ?? 12).map(({ assertion, score }) => ({
+				id: assertion.id,
+				kind: assertion.kind,
+				statement: assertion.statement,
+				status: assertion.status,
+				authority: assertion.authority,
+				score
+			}));
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({ results }, null, 2)
+				}],
+				details: { results }
+			};
+		}
+	};
+}
+function createUserContextGetTool(options) {
+	return {
+		name: "user_context_get",
+		label: "User Context Get",
+		description: "Read one typed user assertion and its subject, predicate, and scope.",
+		parameters: GetSchema,
+		async execute(_toolCallId, raw) {
+			if (!options.canRead()) return {
+				content: [{
+					type: "text",
+					text: "User context is disabled for this session."
+				}],
+				details: { error: "user_context_disabled" }
+			};
+			const id = raw.id;
+			const assertion = getUserAssertion(id);
+			if (!assertion || !visible(options, assertion.slotId) || !referenceable(assertion)) return {
+				content: [{
+					type: "text",
+					text: `User assertion not found: ${id}`
+				}],
+				details: { id }
+			};
+			const result = {
+				assertion,
+				slot: getAssertionSlot(assertion.slotId)
+			};
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(result, null, 2)
+				}],
+				details: result
+			};
+		}
+	};
+}
+//#endregion
+export { createUserContextGetTool, createUserContextSearchTool };

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

@@ -2,14 +2,14 @@ import { runWithActivityContext } from "../../activity/context.js";
 import { runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
 import { TaskCommandSchema, TaskContextInputSchema } from "../../../packages/gateway-contract/src/tasks.js";
 import { appendProductDeliveryText } from "../../../packages/gateway-contract/src/product-delivery.js";
+import { enqueueTaskChangedEvent } from "../../tasks/task-change-events.js";
+import { TaskRunRepository } from "../../tasks/task-run-repository.js";
 import { getSessionMetadata } from "../../storage/sqlite/session-repository.js";
 import "../../storage/sqlite/index.js";
 import { ObjectLinkService } from "../../activity/service.js";
 import "../../activity/index.js";
 import { getDefaultAgentId, init_resolve_route } from "../../routing/resolve-route.js";
 import { TaskRepository } from "../../tasks/task-repository.js";
-import { enqueueTaskChangedEvent } from "../../tasks/task-change-events.js";
-import { TaskRunRepository } from "../../tasks/task-run-repository.js";
 import { TaskReadModelProjector } from "../../tasks/task-read-model-projector.js";
 import { isValidProjectAgentId, normalizeProjectAgentId, resolveProjectAgentId } from "../../projects/project-agent.js";
 import "../../projects/index.js";

package/dist/src/automations/service/automation-service.d.ts

@@ -8,6 +8,7 @@ export declare class AutomationAlreadyRunningError extends Error {
 }
 export declare class AutomationService {
     private readonly signals?;
+    private readonly workspaceId;
     private readonly executor;
     private timer;
     private stopped;
@@ -17,7 +18,7 @@ export declare class AutomationService {
     private readonly activeRuns;
     private readonly heartbeatTimers;
     private readonly leaseOwner;
-    constructor(signals?: ProactiveSignalPublisher);
+    constructor(signals?: ProactiveSignalPublisher, workspaceId?: string);
     setDeps(deps: AutomationDeps): void;
     initialize(options?: {
         maxConcurrentRuns?: number;

package/dist/src/automations/service/automation-service.js

@@ -34,8 +34,9 @@ var AutomationService = class {
 	activeRuns = /* @__PURE__ */ new Map();
 	heartbeatTimers = /* @__PURE__ */ new Map();
 	leaseOwner = `automation-service:${process.pid}:${randomUUID()}`;
-	constructor(signals) {
+	constructor(signals, workspaceId = "default") {
 		this.signals = signals;
+		this.workspaceId = workspaceId;
 	}
 	setDeps(deps) {
 		this.deps = {
@@ -462,7 +463,10 @@ var AutomationService = class {
 						id: run.id
 					},
 					actor: { kind: "system" },
-					scope: { workspaceId: "default" },
+					scope: {
+						workspaceId: this.workspaceId,
+						...automation.projectId ? { projectId: automation.projectId } : {}
+					},
 					occurredAt: new Date(endedAtMs).toISOString(),
 					dedupeKey: `automation_run:${run.id}:failed`,
 					sensitivity: "personal",

package/dist/src/chat-commands/builtins/understanding.js

@@ -1,5 +1,7 @@
+import { reconcileAssertion } from "../../user-model/repository.js";
+import "../../user-model/index.js";
 import { commandRegistry } from "../registry.js";
-import { createManualUnderstanding } from "../../user-context/manual-understanding.js";
+import { createHash } from "node:crypto";
 //#region src/chat-commands/builtins/understanding.ts
 function parseRememberArgs(args) {
 	const trimmed = args.trim();
@@ -30,20 +32,36 @@ const rememberCommand = {
 			content: "Usage: /remember [--session] <what xopc should know> (max 5000 characters)",
 			success: false
 		};
-		const result = createManualUnderstanding({
-			content,
+		const result = reconcileAssertion({
+			subject: {
+				type: "user",
+				id: "self"
+			},
+			predicate: `remembered.${createHash("sha256").update(content.toLocaleLowerCase()).digest("hex").slice(0, 20)}`,
+			cardinality: "single",
+			value: content,
+			normalizedValue: content.toLocaleLowerCase(),
+			statement: content,
 			kind: "derived_insight",
 			scope: sessionOnly ? {
 				type: "session",
 				id: ctx.sessionKey
 			} : { type: "global" },
+			authority: "user_explicit",
+			confidence: 1,
+			declaredImportance: .8,
+			inferredImportance: .8,
+			consequence: "medium",
+			actionability: .7,
+			volatility: sessionOnly ? "dynamic" : "stable",
 			sensitivity: "normal",
-			durability: sessionOnly ? "ephemeral" : "durable",
-			disclosurePolicy: "referenceable"
+			disclosurePolicy: "referenceable",
+			observedAt: Date.now(),
+			createdBy: "user"
 		});
 		const scopeLabel = sessionOnly ? "this conversation" : "all conversations";
 		return {
-			content: result.created ? `Remembered for ${scopeLabel}. You can review or remove it in About You.` : `This is already remembered for ${scopeLabel}.`,
+			content: result.action === "created" ? `Remembered for ${scopeLabel}. You can review or remove it in User Model.` : `This is already remembered for ${scopeLabel}.`,
 			success: true
 		};
 	}

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

@@ -1,6 +1,6 @@
 import { init_loader, loadConfig, saveConfig } from "../../config/loader.js";
-import { register } from "../registry.js";
 import { getStoreConnectorInstallPlan, installStoreConnector, listStoreConnectors } from "../../capabilities/store-connector.js";
+import { register } from "../registry.js";
 import { confirm } from "@inquirer/prompts";
 import { Command } from "commander";
 //#region src/cli/commands/connectors.ts

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

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

@@ -1322,8 +1322,8 @@ export declare const UpdateAutoConfigSchema: z.ZodOptional<z.ZodObject<{
 export declare const UpdateConfigSchema: z.ZodOptional<z.ZodObject<{
     checkOnStart: z.ZodDefault<z.ZodBoolean>;
     channel: z.ZodDefault<z.ZodEnum<{
-        beta: "beta";
         stable: "stable";
+        beta: "beta";
         dev: "dev";
     }>>;
     auto: z.ZodOptional<z.ZodObject<{
@@ -1428,79 +1428,60 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
                 "zh-CN": "zh-CN";
             }>>;
         }, z.core.$strict>>;
-        memory: z.ZodDefault<z.ZodObject<{
-            mode: z.ZodDefault<z.ZodEnum<{
-                off: "off";
-                auto: "auto";
-                readOnly: "readOnly";
-                confirmWrite: "confirmWrite";
-            }>>;
-            sources: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-                session: "session";
-                workspace: "workspace";
-                understanding: "understanding";
-                agentProfile: "agentProfile";
-            }>>>;
-            writePolicy: z.ZodOptional<z.ZodObject<{
-                agentProfile: z.ZodOptional<z.ZodEnum<{
-                    allow: "allow";
-                    confirm: "confirm";
-                    deny: "deny";
-                }>>;
-                understanding: z.ZodOptional<z.ZodEnum<{
-                    allow: "allow";
-                    confirm: "confirm";
-                    deny: "deny";
-                }>>;
-                workspace: z.ZodOptional<z.ZodEnum<{
-                    allow: "allow";
-                    confirm: "confirm";
-                    deny: "deny";
-                }>>;
-            }, z.core.$strict>>;
-            retention: z.ZodOptional<z.ZodObject<{
-                compaction: z.ZodDefault<z.ZodObject<{
-                    enabled: z.ZodDefault<z.ZodBoolean>;
-                    triggerThreshold: z.ZodDefault<z.ZodNumber>;
-                    reserveTokens: z.ZodDefault<z.ZodNumber>;
-                    minMessagesBeforeCompact: z.ZodDefault<z.ZodNumber>;
-                    keepRecentTokens: z.ZodDefault<z.ZodNumber>;
-                    recentTurnsPreserve: z.ZodDefault<z.ZodNumber>;
-                    summaryMaxTokens: z.ZodDefault<z.ZodNumber>;
-                    summaryChunkTokens: z.ZodDefault<z.ZodNumber>;
-                    summaryTimeoutMs: z.ZodDefault<z.ZodNumber>;
-                    summaryRetries: z.ZodDefault<z.ZodNumber>;
-                    qualityGuard: z.ZodDefault<z.ZodBoolean>;
-                    gapAudit: z.ZodDefault<z.ZodBoolean>;
-                    model: z.ZodOptional<z.ZodString>;
-                    minToolResultKeepChars: z.ZodDefault<z.ZodNumber>;
-                    maxActiveTranscriptBytes: z.ZodDefault<z.ZodNumber>;
-                    postCompactionSections: z.ZodDefault<z.ZodArray<z.ZodString>>;
-                }, z.core.$strict>>;
-                maxAgeDays: z.ZodOptional<z.ZodNumber>;
-                maxItems: z.ZodOptional<z.ZodNumber>;
-                maxChars: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>>;
-        understanding: z.ZodDefault<z.ZodObject<{
+        userModel: z.ZodDefault<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
+            writePolicy: z.ZodDefault<z.ZodEnum<{
+                allow: "allow";
+                confirm: "confirm";
+                deny: "deny";
+            }>>;
+            sensitiveWritePolicy: z.ZodDefault<z.ZodEnum<{
+                allow: "allow";
+                confirm: "confirm";
+                deny: "deny";
+            }>>;
             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>;
-            maxDurationMs: z.ZodDefault<z.ZodNumber>;
+            extraction: z.ZodDefault<z.ZodObject<{
+                reviewIntervalTurns: z.ZodDefault<z.ZodNumber>;
+                maxHistoryMessages: z.ZodDefault<z.ZodNumber>;
+                maxDurationMs: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>;
+            maintenance: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                timezone: z.ZodOptional<z.ZodString>;
+                temporalSweepMinutes: z.ZodDefault<z.ZodNumber>;
+                dailyTime: z.ZodDefault<z.ZodString>;
+                weeklyDay: z.ZodDefault<z.ZodEnum<{
+                    sun: "sun";
+                    mon: "mon";
+                    tue: "tue";
+                    wed: "wed";
+                    thu: "thu";
+                    fri: "fri";
+                    sat: "sat";
+                }>>;
+                weeklyTime: z.ZodDefault<z.ZodString>;
+                evidenceThreshold: z.ZodDefault<z.ZodNumber>;
+                limit: z.ZodDefault<z.ZodNumber>;
+                staleRetentionDays: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>;
         }, z.core.$strict>>;
-        privacy: z.ZodDefault<z.ZodObject<{
-            sensitiveWritePolicy: z.ZodDefault<z.ZodEnum<{
+        knowledgeMemory: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            writePolicy: z.ZodDefault<z.ZodEnum<{
                 allow: "allow";
                 confirm: "confirm";
                 deny: "deny";
             }>>;
-        }, z.core.$strict>>;
-        providerRouting: z.ZodDefault<z.ZodObject<{
+            sources: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                project: "project";
+                session: "session";
+                workspace: "workspace";
+                connector: "connector";
+            }>>>;
             searchStrategy: z.ZodDefault<z.ZodEnum<{
                 "local-first": "local-first";
                 "external-first": "external-first";
@@ -1519,17 +1500,29 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
             allowedProviderIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
             autoWriteKinds: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strict>>;
-        dreaming: z.ZodDefault<z.ZodObject<{
-            mode: z.ZodDefault<z.ZodEnum<{
-                off: "off";
-                review: "review";
-            }>>;
-            timezone: z.ZodOptional<z.ZodString>;
-            schedule: z.ZodDefault<z.ZodObject<{
-                time: z.ZodDefault<z.ZodString>;
+        contextPlanning: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            maxAssertions: z.ZodDefault<z.ZodNumber>;
+            maxKnowledge: z.ZodDefault<z.ZodNumber>;
+            maxChars: z.ZodDefault<z.ZodNumber>;
+            compaction: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                triggerThreshold: z.ZodDefault<z.ZodNumber>;
+                reserveTokens: z.ZodDefault<z.ZodNumber>;
+                minMessagesBeforeCompact: z.ZodDefault<z.ZodNumber>;
+                keepRecentTokens: z.ZodDefault<z.ZodNumber>;
+                recentTurnsPreserve: z.ZodDefault<z.ZodNumber>;
+                summaryMaxTokens: z.ZodDefault<z.ZodNumber>;
+                summaryChunkTokens: z.ZodDefault<z.ZodNumber>;
+                summaryTimeoutMs: z.ZodDefault<z.ZodNumber>;
+                summaryRetries: z.ZodDefault<z.ZodNumber>;
+                qualityGuard: z.ZodDefault<z.ZodBoolean>;
+                gapAudit: z.ZodDefault<z.ZodBoolean>;
+                model: z.ZodOptional<z.ZodString>;
+                minToolResultKeepChars: z.ZodDefault<z.ZodNumber>;
+                maxActiveTranscriptBytes: z.ZodDefault<z.ZodNumber>;
+                postCompactionSections: z.ZodDefault<z.ZodArray<z.ZodString>>;
             }, z.core.$strict>>;
-            minEvidenceSources: z.ZodDefault<z.ZodNumber>;
-            limit: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
     agents: z.ZodDefault<z.ZodObject<{
@@ -2275,8 +2268,8 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
     update: z.ZodOptional<z.ZodObject<{
         checkOnStart: z.ZodDefault<z.ZodBoolean>;
         channel: z.ZodDefault<z.ZodEnum<{
-            beta: "beta";
             stable: "stable";
+            beta: "beta";
             dev: "dev";
         }>>;
         auto: z.ZodOptional<z.ZodObject<{