@xopcai/xopc 0.0.248 → 0.0.250

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

@@ -1,113 +0,0 @@
-import { init_session_key, parseSessionKey } from "../../routing/session-key.js";
-import { consumeTurnMemoryProvenance, markTurnRecalledContext } from "./turn-provenance.js";
-import { assembleTaskContext } from "../../tasks/task-context-assembler.js";
-import { shouldPlanUserContextThisTurn } from "./memory-config.js";
-import { UserContextPlanner, prependAgentContext } from "../../user-context/planner.js";
-import { extractAgentUserPlainText } from "./user-message-text.js";
-import { planTrustedRecall } from "./trusted-recall.js";
-//#region src/agent/memory/user-context-coordinator.ts
-init_session_key();
-function isPrivateSession(sessionKey) {
-	const parsed = parseSessionKey(sessionKey);
-	return !parsed || parsed.peerKind === "direct";
-}
-var UserContextCoordinator = class {
-	userTurn = /* @__PURE__ */ new Map();
-	lastTurnId = /* @__PURE__ */ new Map();
-	planner = new UserContextPlanner();
-	constructor(options) {
-		this.options = options;
-	}
-	forgetSession(sessionKey) {
-		this.userTurn.delete(sessionKey);
-		this.lastTurnId.delete(sessionKey);
-	}
-	clear() {
-		this.userTurn.clear();
-		this.lastTurnId.clear();
-	}
-	async prepare(userMessage, sessionKey, turnId) {
-		const empty = () => ({
-			traceId: "",
-			modelMessage: userMessage,
-			items: [],
-			rejected: [],
-			consentRequests: [],
-			estimatedTokens: 0,
-			contextChars: 0,
-			contextItemCount: 0
-		});
-		if (!this.options.isEnabledForSession(sessionKey)) return empty();
-		const config = this.options.getConfig();
-		if (!isPrivateSession(sessionKey)) return empty();
-		const taskContext = assembleTaskContext(sessionKey, extractAgentUserPlainText(userMessage));
-		const query = taskContext.retrievalQuery;
-		this.lastTurnId.set(sessionKey, turnId);
-		const turn = (this.userTurn.get(sessionKey) ?? 0) + 1;
-		this.userTurn.set(sessionKey, turn);
-		if (!shouldPlanUserContextThisTurn(config, turn)) return empty();
-		const plan = this.planner.plan({
-			sessionKey,
-			channel: parseSessionKey(sessionKey)?.source,
-			workspaceId: this.options.getWorkspaceIdForSession?.(sessionKey) ?? "",
-			projectId: this.options.getProjectIdForSession?.(sessionKey),
-			turnId,
-			query,
-			userMessage,
-			allocation: taskContext.allocation
-		});
-		const totalChars = taskContext.allocation.maxChars;
-		const remainingChars = Math.max(0, totalChars - plan.contextChars);
-		const remainingResults = Math.max(0, taskContext.allocation.maxResults - plan.contextItemCount);
-		const memoryBudget = Math.min(1600, Math.floor(totalChars * .2), remainingChars);
-		const memoryManager = this.options.getMemoryManagerForSession(sessionKey);
-		const recall = planTrustedRecall(memoryBudget >= 256 ? await memoryManager.search({
-			query,
-			scope: {
-				workspaceId: this.options.getWorkspaceIdForSession?.(sessionKey),
-				projectId: this.options.getProjectIdForSession?.(sessionKey),
-				sessionKey
-			},
-			maxResults: 8,
-			minScore: .25,
-			trustedOnly: true
-		}) : [], memoryBudget, remainingResults);
-		if (plan.contextChars > 0 || recall.selected.length > 0) markTurnRecalledContext(sessionKey, turnId);
-		for (const result of recall.selected) memoryManager.recordSignal({
-			source: "context_injection",
-			recordId: result.record.id,
-			score: result.score,
-			metadata: {
-				sessionKey,
-				turnId,
-				workspaceId: this.options.getWorkspaceIdForSession?.(sessionKey),
-				budgetChars: memoryBudget,
-				injectedChars: recall.usedChars
-			}
-		});
-		return {
-			...plan,
-			modelMessage: prependAgentContext(plan.modelMessage, recall.block),
-			memoryRecordIds: recall.selected.map((result) => result.record.id),
-			contextChars: plan.contextChars + recall.usedChars,
-			contextItemCount: plan.contextItemCount + recall.selected.length,
-			estimatedTokens: Math.ceil((plan.contextChars + recall.usedChars) / 4)
-		};
-	}
-	async afterTurn(sessionKey, userPlainText) {
-		if (!this.options.isEnabledForSession(sessionKey)) return;
-		const memoryManager = this.options.getMemoryManagerForSession(sessionKey);
-		const assistantContent = this.options.getLastAssistantContent(sessionKey) ?? "";
-		if (!isPrivateSession(sessionKey)) return;
-		const turnId = this.lastTurnId.get(sessionKey);
-		const provenance = turnId ? consumeTurnMemoryProvenance(sessionKey, turnId) : void 0;
-		memoryManager.syncProvidersForTurn(userPlainText, assistantContent, {
-			sessionId: sessionKey,
-			turnId,
-			provenance
-		});
-		memoryManager.queuePrefetchAll(userPlainText, { sessionId: sessionKey });
-	}
-};
-//#endregion
-export { UserContextCoordinator };

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

@@ -1,37 +0,0 @@
-import { listContextConsolidationRuns } from "../../storage/sqlite/context-consolidation-repository.js";
-import "../../storage/sqlite/index.js";
-import { resolveContextConsolidationConfig } from "../../user-context/consolidation.js";
-import { Type } from "@sinclair/typebox";
-//#region src/agent/tools/dreaming-tool.ts
-const DreamingSchema = Type.Object({ action: Type.Literal("status") });
-function createDreamingTool(deps) {
-	return {
-		name: "dreaming",
-		label: "💤 Dreaming",
-		description: "Show structured user-context review configuration and recent activity.",
-		parameters: DreamingSchema,
-		async execute() {
-			const config = deps.getConfig();
-			const resolved = config ? resolveContextConsolidationConfig(config) : null;
-			const runs = listContextConsolidationRuns(20);
-			return {
-				content: [{
-					type: "text",
-					text: JSON.stringify({
-						enabled: resolved?.enabled ?? false,
-						schedule: resolved ? {
-							time: resolved.time,
-							timezone: resolved.timezone
-						} : null,
-						policy: "review_only",
-						storage: "sqlite://user_understandings",
-						lastRun: runs[0] ?? null
-					}, null, 2)
-				}],
-				details: {}
-			};
-		}
-	};
-}
-//#endregion
-export { createDreamingTool };

package/dist/src/agent/tools/memory-tool.d.ts

@@ -1,9 +0,0 @@
-import type { AgentTool } from '@earendil-works/pi-agent-core';
-import type { MemoryManager } from '../memory/manager.js';
-import type { MemoryScope } from '../memory/types.js';
-export interface MemoryToolOptions {
-    getMemoryManager: () => MemoryManager;
-    getScope?: () => Partial<MemoryScope>;
-}
-export declare function createMemorySearchTool(options: MemoryToolOptions): AgentTool;
-export declare function createMemoryGetTool(options: MemoryToolOptions): AgentTool;

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

@@ -1,119 +0,0 @@
-import { Type } from "@sinclair/typebox";
-//#region src/agent/tools/memory-tool.ts
-const MemorySearchSchema = Type.Object({
-	query: Type.String(),
-	maxResults: Type.Optional(Type.Number()),
-	minScore: Type.Optional(Type.Number())
-});
-function createMemorySearchTool(options) {
-	const { getMemoryManager } = options;
-	return {
-		name: "memory_search",
-		label: "🔍 Memory Search",
-		description: "Search workspace and connected-source memory records for prior work, decisions, dates, people, or todos; returns ranked snippets with stable record ids.",
-		parameters: MemorySearchSchema,
-		async execute(_toolCallId, params, _signal) {
-			const { query, maxResults, minScore } = params;
-			try {
-				const results = await getMemoryManager().search({
-					query,
-					maxResults,
-					minScore,
-					scope: options.getScope?.()
-				});
-				for (const result of results) getMemoryManager().recordSignal({
-					source: "search_recall",
-					recordId: result.record.id,
-					score: result.score,
-					content: result.snippet,
-					metadata: {
-						providerId: result.citation.providerId,
-						query
-					}
-				});
-				const withCitations = results.map((entry) => ({
-					id: entry.record.id,
-					ownerAgentId: entry.record.provenance?.sourceAgentId,
-					originClass: entry.record.provenance?.originClass ?? "untrusted",
-					sessionKind: entry.record.provenance?.sessionKind ?? "unknown",
-					derivedFromRecalledContext: entry.record.provenance?.derivedFromRecalledContext ?? true,
-					trustedForAutomaticRecall: (entry.record.provenance?.originClass === "owner" || entry.record.provenance?.originClass === "agent") && entry.record.provenance?.derivedFromRecalledContext === false,
-					kind: entry.record.kind,
-					content: entry.snippet,
-					score: entry.score,
-					citation: entry.record.id,
-					snippet: `${entry.snippet.trim()}\n\nMemory record: ${entry.record.id}`
-				}));
-				return {
-					content: [{
-						type: "text",
-						text: JSON.stringify({
-							results: withCitations,
-							provider: "memory-manager"
-						}, null, 2)
-					}],
-					details: { results: withCitations }
-				};
-			} catch (err) {
-				const message = err instanceof Error ? err.message : String(err);
-				return {
-					content: [{
-						type: "text",
-						text: `Search error: ${message}`
-					}],
-					details: { error: message }
-				};
-			}
-		}
-	};
-}
-const MemoryGetSchema = Type.Object({ id: Type.String() });
-function createMemoryGetTool(options) {
-	const { getMemoryManager } = options;
-	return {
-		name: "memory_get",
-		label: "📄 Memory Get",
-		description: "Read one structured memory record by an id returned from memory_search.",
-		parameters: MemoryGetSchema,
-		async execute(_toolCallId, params, _signal) {
-			const { id } = params;
-			try {
-				const result = await getMemoryManager().read({
-					id,
-					scope: options.getScope?.()
-				});
-				if (!result) return {
-					content: [{
-						type: "text",
-						text: `Memory record not found: ${id}`
-					}],
-					details: {
-						id,
-						text: ""
-					}
-				};
-				return {
-					content: [{
-						type: "text",
-						text: result.record.content
-					}],
-					details: {
-						id,
-						record: result.record
-					}
-				};
-			} catch (err) {
-				const message = err instanceof Error ? err.message : String(err);
-				return {
-					content: [{
-						type: "text",
-						text: `Read error: ${message}`
-					}],
-					details: { error: message }
-				};
-			}
-		}
-	};
-}
-//#endregion
-export { createMemoryGetTool, createMemorySearchTool };

package/dist/src/gateway/dreaming-automation-reconciler.d.ts

@@ -1,11 +0,0 @@
-import type { Config } from '../config/schema.js';
-import type { AutomationService } from '../automations/index.js';
-export type DreamingAutomationReconcileResult = {
-    created: boolean;
-    updated: boolean;
-    disabled: boolean;
-};
-export declare function reconcileDreamingAutomations(params: {
-    config: Config;
-    automationService: AutomationService;
-}): Promise<DreamingAutomationReconcileResult>;

package/dist/src/gateway/dreaming-automation-reconciler.js

@@ -1,63 +0,0 @@
-import { init_agent_scope, normalizeAgentId, resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../agent/agent-scope.js";
-import { USER_CONTEXT_CONSOLIDATION_AUTOMATION_ID, USER_CONTEXT_CONSOLIDATION_TOKEN, compileContextConsolidationCron, resolveContextConsolidationConfig } from "../user-context/consolidation.js";
-//#region src/gateway/dreaming-automation-reconciler.ts
-init_agent_scope();
-async function reconcileDreamingAutomations(params) {
-	const result = {
-		created: false,
-		updated: false,
-		disabled: false
-	};
-	const resolved = resolveContextConsolidationConfig(params.config);
-	const agentId = normalizeAgentId(resolveDefaultAgentId(params.config));
-	const workingDirectory = resolveAgentWorkspaceDir(params.config, agentId);
-	const trigger = {
-		kind: "schedule",
-		schedule: {
-			kind: "cron",
-			expr: compileContextConsolidationCron(resolved.time),
-			tz: resolved.timezone
-		}
-	};
-	const action = {
-		kind: "agent",
-		agentId,
-		instruction: USER_CONTEXT_CONSOLIDATION_TOKEN,
-		workingDirectory,
-		timeoutSeconds: 300
-	};
-	const current = await params.automationService.get(USER_CONTEXT_CONSOLIDATION_AUTOMATION_ID);
-	if (!resolved.enabled) {
-		if (current?.enabled) {
-			await params.automationService.update(USER_CONTEXT_CONSOLIDATION_AUTOMATION_ID, { enabled: false });
-			result.disabled = true;
-		}
-		return result;
-	}
-	const next = {
-		name: "User context review",
-		description: "Deterministically review structured user understanding for expiry and sufficient evidence.",
-		enabled: true,
-		trigger,
-		action,
-		safety: { mode: "auto_apply" },
-		conversationMode: "continuous",
-		notificationPolicy: "none",
-		reliability: { disableAfterConsecutiveFailures: 3 }
-	};
-	if (!current) {
-		await params.automationService.create({
-			id: USER_CONTEXT_CONSOLIDATION_AUTOMATION_ID,
-			...next
-		});
-		result.created = true;
-		return result;
-	}
-	if (current.name !== next.name || current.description !== next.description || !current.enabled || JSON.stringify(current.trigger) !== JSON.stringify(trigger) || JSON.stringify(current.action) !== JSON.stringify(action) || current.safety?.mode !== "auto_apply" || current.conversationMode !== "continuous" || current.notificationPolicy !== "none" || current.reliability?.disableAfterConsecutiveFailures !== 3) {
-		await params.automationService.update(USER_CONTEXT_CONSOLIDATION_AUTOMATION_ID, next);
-		result.updated = true;
-	}
-	return result;
-}
-//#endregion
-export { reconcileDreamingAutomations };

package/dist/src/gateway/hono/routes/understanding-sources.d.ts

@@ -1,21 +0,0 @@
-import type { Hono } from 'hono';
-import type { AuthenticatedRouteDeps } from './deps.js';
-export declare function sourceRevocationImpact(grantId: string): {
-    grant: import("../../../user-context/sources/types.js").UnderstandingSourceGrant;
-    sourceInstanceId: string;
-    understandingIds: string[];
-    focusIds: string[];
-    derivedCount: number;
-    understandingCount: number;
-    focusCount: number;
-    memoryRecordCount: number;
-    boundedRawCount: number;
-};
-export declare function applySourceRevocationChoices(impact: NonNullable<ReturnType<typeof sourceRevocationImpact>>, options: {
-    derived: 'delete' | 'retain';
-    raw: 'delete' | 'retain';
-}): {
-    derivedDeleted: number;
-    rawDeleted: number;
-};
-export declare function registerUnderstandingSourceRoutes(authenticated: Hono, deps: AuthenticatedRouteDeps): void;