@xopcai/xopc 0.0.180 → 0.0.188

package/dist/src/agent/memory/dreaming/last-run.js

@@ -1,96 +0,0 @@
-import { DREAMING_LAST_RUN_RELATIVE } from "./constants.js";
-import path from "node:path";
-import fs from "node:fs/promises";
-//#region src/agent/memory/dreaming/last-run.ts
-const DREAMING_LAST_RUN_FORMAT_VERSION = 2;
-function isRecord(v) {
-	return v !== null && typeof v === "object" && !Array.isArray(v);
-}
-function asNonNegInt(v) {
-	if (typeof v === "number" && Number.isFinite(v)) return Math.max(0, Math.floor(v));
-	if (typeof v === "string" && v.trim() && Number.isFinite(Number(v))) return Math.max(0, Math.floor(Number(v)));
-	return 0;
-}
-function asDreamingDeepConfig(v) {
-	if (!isRecord(v)) return null;
-	return {
-		enabled: v.enabled === true,
-		cron: typeof v.cron === "string" ? v.cron : "0 3 * * *",
-		minScore: typeof v.minScore === "number" && Number.isFinite(v.minScore) ? v.minScore : 0,
-		minRecallCount: asNonNegInt(v.minRecallCount) || 1,
-		minUniqueQueries: asNonNegInt(v.minUniqueQueries) || 3,
-		limit: asNonNegInt(v.limit),
-		recencyHalfLifeDays: asNonNegInt(v.recencyHalfLifeDays) || 14,
-		maxAgeDays: asNonNegInt(v.maxAgeDays) || 30
-	};
-}
-const EMPTY_SKIPPED = {
-	alreadyPromotedKey: 0,
-	rehydrateFailed: 0,
-	contaminated: 0,
-	hashDuplicate: 0
-};
-function parseSkippedStrict(raw) {
-	if (!isRecord(raw)) return null;
-	if (typeof raw.alreadyPromotedKey !== "number" || !Number.isFinite(raw.alreadyPromotedKey) || typeof raw.rehydrateFailed !== "number" || !Number.isFinite(raw.rehydrateFailed) || typeof raw.contaminated !== "number" || !Number.isFinite(raw.contaminated) || typeof raw.hashDuplicate !== "number" || !Number.isFinite(raw.hashDuplicate)) return null;
-	return {
-		alreadyPromotedKey: Math.max(0, Math.floor(raw.alreadyPromotedKey)),
-		rehydrateFailed: Math.max(0, Math.floor(raw.rehydrateFailed)),
-		contaminated: Math.max(0, Math.floor(raw.contaminated)),
-		hashDuplicate: Math.max(0, Math.floor(raw.hashDuplicate))
-	};
-}
-/**
-* Parse `last-run.json`. Only the current on-disk format (`version: 2`, `phase: 'deep'`) is accepted.
-*/
-function parseDreamingLastRunFile(raw) {
-	if (!isRecord(raw)) return null;
-	if (raw.version !== 2 || raw.phase !== "deep") return null;
-	if (typeof raw.runId !== "string" || !raw.runId.trim()) return null;
-	if (typeof raw.startedAt !== "string" || typeof raw.finishedAt !== "string") return null;
-	if (!raw.startedAt.trim() || !raw.finishedAt.trim()) return null;
-	if (typeof raw.durationMs !== "number" || !Number.isFinite(raw.durationMs) || raw.durationMs < 0) return null;
-	if (raw.ok !== true && raw.ok !== false) return null;
-	if (typeof raw.reason !== "string") return null;
-	const config = asDreamingDeepConfig(raw.config);
-	if (!config) return null;
-	if (typeof raw.memoryPath !== "string" || !raw.memoryPath.trim()) return null;
-	const deepRaw = raw.deep;
-	if (!isRecord(deepRaw)) return null;
-	if (typeof deepRaw.candidatesRanked !== "number" || !Number.isFinite(deepRaw.candidatesRanked)) return null;
-	if (typeof deepRaw.applied !== "number" || !Number.isFinite(deepRaw.applied)) return null;
-	const skipped = parseSkippedStrict(deepRaw.skipped);
-	if (!skipped) return null;
-	const err = raw.errorMessage;
-	const errMsg = typeof err === "string" && err.trim() ? err.trim() : void 0;
-	return {
-		version: 2,
-		phase: "deep",
-		runId: raw.runId.trim(),
-		startedAt: raw.startedAt,
-		finishedAt: raw.finishedAt,
-		durationMs: Math.max(0, Math.floor(raw.durationMs)),
-		ok: raw.ok === true,
-		reason: raw.reason,
-		config,
-		memoryPath: raw.memoryPath,
-		...errMsg ? { errorMessage: errMsg } : {},
-		deep: {
-			candidatesRanked: Math.max(0, Math.floor(deepRaw.candidatesRanked)),
-			applied: Math.max(0, Math.floor(deepRaw.applied)),
-			skipped
-		}
-	};
-}
-function emptyDeepPhaseSkipped() {
-	return { ...EMPTY_SKIPPED };
-}
-async function writeDreamingDeepLastRun(params) {
-	const fullPath = path.join(params.dreamingRoot, DREAMING_LAST_RUN_RELATIVE);
-	await fs.mkdir(path.dirname(fullPath), { recursive: true });
-	const tmp = `${fullPath}.${process.pid}.${Date.now()}.tmp`;
-	await fs.writeFile(tmp, `${JSON.stringify(params.lastRun, null, 2)}\n`, "utf-8");
-	await fs.rename(tmp, fullPath);
-}
-//#endregion
-export { DREAMING_LAST_RUN_FORMAT_VERSION, emptyDeepPhaseSkipped, parseDreamingLastRunFile, writeDreamingDeepLastRun };

package/dist/src/agent/memory/dreaming/short-term-store.d.ts

@@ -1,75 +0,0 @@
-import type { MemorySearchOptions } from '../../prompt/memory/index.js';
-export type DreamingStoreEntry = {
-    key: string;
-    path: string;
-    startLine: number;
-    endLine: number;
-    snippet: string;
-    /** Number of times this snippet was returned by a memory recall query. */
-    recallCount: number;
-    /** Number of times recorded from source-side sweep phases. */
-    sourceCount: number;
-    /** Number of times replayed from grounded context (agent-initiated). */
-    groundedCount: number;
-    /** Number of times the light phase touched this entry. */
-    lightHits: number;
-    /** Number of times the REM phase touched this entry. */
-    remHits: number;
-    /** Cross-phase hit count (light + deep + rem combined touches). */
-    phaseHitCount: number;
-    /** Weighted aggregate of all signal dimensions. */
-    totalSignalCount: number;
-    totalScore: number;
-    maxScore: number;
-    queryHashes: string[];
-    recallDays: string[];
-    firstRecalledAt: string;
-    lastRecalledAt: string;
-    lastObservedAt?: string;
-    promotedAt?: string;
-};
-export type DreamingStore = {
-    version: 1;
-    updatedAt: string;
-    entries: Record<string, DreamingStoreEntry>;
-};
-type MemoryMatch = Awaited<ReturnType<typeof import('../../prompt/memory/index.js').memorySearch>>[number];
-export declare function recordDreamingRecalls(params: {
-    dreamingRoot: string;
-    query: string;
-    matches: MemoryMatch[];
-    options?: MemorySearchOptions;
-    now?: Date;
-}): Promise<{
-    recorded: number;
-    skipped: number;
-    storePath: string;
-}>;
-/** Serialize all read-modify-write operations against the shared Dreaming store. */
-export declare function withDreamingStoreLock<T>(dreamingRoot: string, task: () => Promise<T>): Promise<T>;
-/** @deprecated Use the store-level name; retained for callers outside this module. */
-export declare function withDreamingPromotionLock<T>(dreamingRoot: string, task: () => Promise<T>): Promise<T>;
-export declare function loadDreamingStore(params: {
-    dreamingRoot: string;
-}): Promise<{
-    store: DreamingStore;
-    storePath: string;
-}>;
-export declare function saveDreamingStore(params: {
-    dreamingRoot: string;
-    store: DreamingStore;
-}): Promise<void>;
-export declare function resetDreamingStore(params: {
-    dreamingRoot: string;
-    now?: Date;
-}): Promise<number>;
-/** Remove only a stale lock whose owning process is no longer alive. */
-export declare function clearStaleDreamingLock(dreamingRoot: string): Promise<boolean>;
-type PhaseSignalField = 'sourceCount' | 'groundedCount' | 'lightHits' | 'remHits';
-/**
- * Increment a phase-specific signal counter on an existing store entry.
- * Also bumps `phaseHitCount` and `totalSignalCount`.
- * Returns `true` if the entry existed and was updated.
- */
-export declare function bumpEntryPhaseSignal(entry: DreamingStoreEntry, field: PhaseSignalField, increment?: number): void;
-export {};

package/dist/src/agent/memory/dreaming/short-term-store.js

@@ -1,273 +0,0 @@
-import { createLogger } from "../../../utils/logger/index.js";
-import { init_logger } from "../../../utils/logger.js";
-import { SHORT_TERM_PROMOTION_LOCK_RELATIVE, SHORT_TERM_RECALL_STORE_RELATIVE } from "./constants.js";
-import { buildEntryKey, clamp01, isoDay, normalizeMemoryPath } from "./utils.js";
-import path from "node:path";
-import { createHash, randomUUID } from "node:crypto";
-import fs from "node:fs/promises";
-//#region src/agent/memory/dreaming/short-term-store.ts
-init_logger();
-const log = createLogger("Dreaming:Store");
-const STORE_MAX_ENTRIES = 2e3;
-const STORE_MAX_AGE_MS = 2160 * 60 * 60 * 1e3;
-const PROMOTED_MAX_AGE_MS = 720 * 60 * 60 * 1e3;
-const LOCK_STALE_MS = 6e4;
-function isRecordableMemoryPath(rel) {
-	const p = normalizeMemoryPath(rel);
-	return p.length > 0 && !p.startsWith("../") && !path.isAbsolute(p);
-}
-function hashQuery(query) {
-	return createHash("sha1").update(query.trim().toLowerCase()).digest("hex").slice(0, 12);
-}
-function mergeRecentDistinct(existing, nextValue, limit) {
-	const seen = /* @__PURE__ */ new Set();
-	const normalized = existing.filter((v) => typeof v === "string").map((v) => v.trim()).filter((v) => v.length > 0 && !seen.has(v) && (seen.add(v), true));
-	if (nextValue && !normalized.includes(nextValue)) normalized.push(nextValue);
-	return normalized.length <= limit ? normalized : normalized.slice(-limit);
-}
-function mergeQueryHashes(existing, nextHash) {
-	return mergeRecentDistinct(existing, nextHash, 32);
-}
-function emptyStore(nowIso) {
-	return {
-		version: 1,
-		updatedAt: nowIso,
-		entries: {}
-	};
-}
-async function ensureDreamDir(dreamingRoot) {
-	const dir = path.join(dreamingRoot, path.dirname(SHORT_TERM_RECALL_STORE_RELATIVE));
-	await fs.mkdir(dir, { recursive: true });
-	return dir;
-}
-async function readStore(dreamingRoot, nowIso) {
-	const storePath = path.join(dreamingRoot, SHORT_TERM_RECALL_STORE_RELATIVE);
-	try {
-		const raw = await fs.readFile(storePath, "utf-8");
-		const parsed = JSON.parse(raw);
-		if (!parsed || typeof parsed !== "object") throw new Error("Dreaming store root must be an object");
-		const rec = parsed;
-		if (rec.version !== 1 || !rec.entries || typeof rec.entries !== "object") throw new Error("Dreaming store has an unsupported or invalid shape");
-		return {
-			version: 1,
-			updatedAt: typeof rec.updatedAt === "string" ? rec.updatedAt : nowIso,
-			entries: rec.entries
-		};
-	} catch (err) {
-		if (err?.code === "ENOENT") return emptyStore(nowIso);
-		const quarantinePath = `${storePath}.corrupt-${Date.now()}`;
-		await fs.rename(storePath, quarantinePath).catch(() => void 0);
-		log.warn({
-			err,
-			dreamingRoot,
-			quarantinePath
-		}, "Failed to read dreaming store; quarantined corrupt data");
-		return emptyStore(nowIso);
-	}
-}
-function pruneStore(store, nowMs = Date.now()) {
-	for (const [key, entry] of Object.entries(store.entries)) {
-		const lastSeenMs = Math.max(Date.parse(entry.lastRecalledAt || entry.firstRecalledAt), entry.lastObservedAt ? Date.parse(entry.lastObservedAt) : 0);
-		const promotedMs = entry.promotedAt ? Date.parse(entry.promotedAt) : NaN;
-		if (Number.isFinite(promotedMs) && nowMs - promotedMs > PROMOTED_MAX_AGE_MS || Number.isFinite(lastSeenMs) && nowMs - lastSeenMs > STORE_MAX_AGE_MS) delete store.entries[key];
-	}
-	const entries = Object.values(store.entries);
-	if (entries.length <= STORE_MAX_ENTRIES) return;
-	entries.sort((left, right) => {
-		if (Boolean(left.promotedAt) !== Boolean(right.promotedAt)) return left.promotedAt ? 1 : -1;
-		const signalDelta = (right.totalSignalCount ?? 0) - (left.totalSignalCount ?? 0);
-		if (signalDelta !== 0) return signalDelta;
-		return Date.parse(right.lastRecalledAt) - Date.parse(left.lastRecalledAt);
-	});
-	const keep = new Set(entries.slice(0, STORE_MAX_ENTRIES).map((entry) => entry.key));
-	for (const key of Object.keys(store.entries)) if (!keep.has(key)) delete store.entries[key];
-}
-async function writeStore(dreamingRoot, store) {
-	pruneStore(store);
-	await ensureDreamDir(dreamingRoot);
-	const storePath = path.join(dreamingRoot, SHORT_TERM_RECALL_STORE_RELATIVE);
-	const tmp = `${storePath}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
-	await fs.writeFile(tmp, `${JSON.stringify(store, null, 2)}\n`, "utf-8");
-	await fs.rename(tmp, storePath);
-}
-async function recordDreamingRecalls(params) {
-	const dreamingRoot = params.dreamingRoot.trim();
-	const query = params.query.trim();
-	if (!dreamingRoot || !query) return {
-		recorded: 0,
-		skipped: params.matches.length,
-		storePath: SHORT_TERM_RECALL_STORE_RELATIVE
-	};
-	return withDreamingStoreLock(dreamingRoot, async () => {
-		const now = params.now ?? /* @__PURE__ */ new Date();
-		const nowIso = now.toISOString();
-		const dayBucket = isoDay(now);
-		const qHash = hashQuery(query);
-		const store = await readStore(dreamingRoot, nowIso);
-		let recorded = 0;
-		let skipped = 0;
-		for (const match of params.matches) {
-			const file = typeof match?.file === "string" ? match.file : "";
-			if (!file || !isRecordableMemoryPath(file)) {
-				skipped += 1;
-				continue;
-			}
-			const lines = typeof match?.lines === "string" ? match.lines.trim() : "";
-			const lineNumbers = Array.isArray(match?.lineNumbers) ? match.lineNumbers : [];
-			const startLine = Math.max(1, Math.min(...lineNumbers.filter((n) => Number.isFinite(n) && n > 0)));
-			const endLine = Math.max(startLine, Math.max(...lineNumbers.filter((n) => Number.isFinite(n) && n > 0)));
-			if (!Number.isFinite(startLine) || !Number.isFinite(endLine)) {
-				skipped += 1;
-				continue;
-			}
-			const score = clamp01(Number(match.score));
-			const key = buildEntryKey({
-				path: file,
-				startLine,
-				endLine
-			});
-			const existing = store.entries[key];
-			const snippet = lines.length > 0 ? lines.slice(0, 360) : file;
-			const next = existing ? {
-				...existing,
-				snippet,
-				recallCount: Math.max(0, Math.floor(existing.recallCount + 1)),
-				sourceCount: existing.sourceCount ?? 0,
-				groundedCount: existing.groundedCount ?? 0,
-				lightHits: existing.lightHits ?? 0,
-				remHits: existing.remHits ?? 0,
-				phaseHitCount: existing.phaseHitCount ?? 0,
-				totalSignalCount: Math.max(0, (existing.totalSignalCount ?? existing.recallCount ?? 0) + 1),
-				totalScore: Math.max(0, existing.totalScore + score),
-				maxScore: Math.max(existing.maxScore, score),
-				queryHashes: mergeQueryHashes(existing.queryHashes ?? [], qHash),
-				recallDays: mergeRecentDistinct(existing.recallDays ?? [], dayBucket, 16),
-				lastRecalledAt: nowIso
-			} : {
-				key,
-				path: normalizeMemoryPath(file),
-				startLine,
-				endLine,
-				snippet,
-				recallCount: 1,
-				sourceCount: 0,
-				groundedCount: 0,
-				lightHits: 0,
-				remHits: 0,
-				phaseHitCount: 0,
-				totalSignalCount: 1,
-				totalScore: score,
-				maxScore: score,
-				queryHashes: [qHash],
-				recallDays: [dayBucket],
-				firstRecalledAt: nowIso,
-				lastRecalledAt: nowIso
-			};
-			store.entries[key] = next;
-			recorded += 1;
-		}
-		if (recorded > 0) {
-			store.updatedAt = nowIso;
-			await writeStore(dreamingRoot, store);
-		}
-		return {
-			recorded,
-			skipped,
-			storePath: SHORT_TERM_RECALL_STORE_RELATIVE
-		};
-	});
-}
-/** Serialize all read-modify-write operations against the shared Dreaming store. */
-async function withDreamingStoreLock(dreamingRoot, task) {
-	const lockPath = path.join(dreamingRoot, SHORT_TERM_PROMOTION_LOCK_RELATIVE);
-	await ensureDreamDir(dreamingRoot);
-	const startedAt = Date.now();
-	const timeoutMs = 1e4;
-	const retryDelayMs = 50;
-	while (true) try {
-		const handle = await fs.open(lockPath, "wx");
-		await handle.writeFile(`${process.pid}:${Date.now()}\n`, "utf-8").catch(() => void 0);
-		try {
-			return await task();
-		} finally {
-			await handle.close().catch(() => void 0);
-			await fs.unlink(lockPath).catch(() => void 0);
-		}
-	} catch (err) {
-		if (err?.code !== "EEXIST") throw err;
-		const lockStat = await fs.stat(lockPath).catch(() => null);
-		if (lockStat && Date.now() - lockStat.mtimeMs > LOCK_STALE_MS && await lockOwnerIsDead(lockPath)) {
-			await fs.unlink(lockPath).catch(() => void 0);
-			log.warn({
-				lockPath,
-				ageMs: Date.now() - lockStat.mtimeMs
-			}, "Removed stale dreaming lock");
-			continue;
-		}
-		if (Date.now() - startedAt >= timeoutMs) throw new Error(`Timed out waiting for dreaming promotion lock at ${lockPath}`);
-		await new Promise((r) => setTimeout(r, retryDelayMs));
-	}
-}
-/** @deprecated Use the store-level name; retained for callers outside this module. */
-async function withDreamingPromotionLock(dreamingRoot, task) {
-	return withDreamingStoreLock(dreamingRoot, task);
-}
-async function lockOwnerIsDead(lockPath) {
-	const raw = await fs.readFile(lockPath, "utf-8").catch(() => "");
-	const pid = Number.parseInt(raw.split(":", 1)[0] ?? "", 10);
-	if (!Number.isFinite(pid) || pid <= 0) return true;
-	try {
-		process.kill(pid, 0);
-		return false;
-	} catch (error) {
-		return error?.code === "ESRCH";
-	}
-}
-async function loadDreamingStore(params) {
-	const nowIso = (/* @__PURE__ */ new Date()).toISOString();
-	return {
-		store: await readStore(params.dreamingRoot, nowIso),
-		storePath: SHORT_TERM_RECALL_STORE_RELATIVE
-	};
-}
-async function saveDreamingStore(params) {
-	await writeStore(params.dreamingRoot, params.store);
-}
-async function resetDreamingStore(params) {
-	return withDreamingStoreLock(params.dreamingRoot, async () => {
-		const nowIso = (params.now ?? /* @__PURE__ */ new Date()).toISOString();
-		const store = await readStore(params.dreamingRoot, nowIso);
-		const removed = Object.keys(store.entries).length;
-		await writeStore(params.dreamingRoot, emptyStore(nowIso));
-		return removed;
-	});
-}
-/** Remove only a stale lock whose owning process is no longer alive. */
-async function clearStaleDreamingLock(dreamingRoot) {
-	const lockPath = path.join(dreamingRoot, SHORT_TERM_PROMOTION_LOCK_RELATIVE);
-	const lockStat = await fs.stat(lockPath).catch((error) => {
-		if (error?.code === "ENOENT") return null;
-		throw error;
-	});
-	if (!lockStat) return false;
-	const ageMs = Date.now() - lockStat.mtimeMs;
-	if (ageMs <= LOCK_STALE_MS || !await lockOwnerIsDead(lockPath)) throw new Error(`Dreaming lock is active and cannot be cleared: ${lockPath}`);
-	await fs.unlink(lockPath);
-	log.warn({
-		lockPath,
-		ageMs
-	}, "Cleared stale dreaming lock");
-	return true;
-}
-/**
-* Increment a phase-specific signal counter on an existing store entry.
-* Also bumps `phaseHitCount` and `totalSignalCount`.
-* Returns `true` if the entry existed and was updated.
-*/
-function bumpEntryPhaseSignal(entry, field, increment = 1) {
-	entry[field] = (entry[field] ?? 0) + increment;
-	entry.phaseHitCount = (entry.phaseHitCount ?? 0) + increment;
-	entry.totalSignalCount = (entry.totalSignalCount ?? 0) + increment;
-}
-//#endregion
-export { bumpEntryPhaseSignal, clearStaleDreamingLock, loadDreamingStore, recordDreamingRecalls, resetDreamingStore, saveDreamingStore, withDreamingPromotionLock, withDreamingStoreLock };

package/dist/src/agent/outcomes/execution-evaluation.d.ts

@@ -1,20 +0,0 @@
-import type { ExecutionReceipt } from '../../storage/sqlite/execution-receipt-repository.js';
-export interface ExecutionEvaluationReplay {
-    total: number;
-    falseCompletions: number;
-    verificationDrift: number;
-    supportMismatches: number;
-    channelConsistencyGap: number;
-    byChannel: Record<string, {
-        total: number;
-        verified: number;
-        helpful: number;
-        rated: number;
-    }>;
-    cases: Array<{
-        runId: string;
-        storedVerification: string;
-        replayedVerification: string;
-    }>;
-}
-export declare function replayExecutionEvaluation(outcomes: ExecutionReceipt[]): ExecutionEvaluationReplay;

package/dist/src/agent/outcomes/execution-evaluation.js

@@ -1,48 +0,0 @@
-import { verifyExecutionCompletion } from "./execution-verifier.js";
-//#region src/agent/outcomes/execution-evaluation.ts
-function replayExecutionEvaluation(outcomes) {
-	const completed = outcomes.filter((outcome) => outcome.status !== "running");
-	const byChannel = {};
-	const cases = [];
-	let falseCompletions = 0;
-	let supportMismatches = 0;
-	for (const outcome of completed) {
-		const replayed = verifyExecutionCompletion({
-			status: outcome.status,
-			acceptanceCriteria: outcome.contract?.acceptanceCriteria ?? [],
-			evidence: outcome.evidence
-		});
-		if (replayed.status !== outcome.verification.status) cases.push({
-			runId: outcome.runId,
-			storedVerification: outcome.verification.status,
-			replayedVerification: replayed.status
-		});
-		if (outcome.status === "succeeded" && replayed.status !== "passed") falseCompletions += 1;
-		if (outcome.feedback?.supportFit === false) supportMismatches += 1;
-		const channel = byChannel[outcome.channel] ?? {
-			total: 0,
-			verified: 0,
-			helpful: 0,
-			rated: 0
-		};
-		channel.total += 1;
-		if (replayed.status === "passed") channel.verified += 1;
-		if (outcome.feedback) {
-			channel.rated += 1;
-			if (outcome.feedback.outcome === "helpful") channel.helpful += 1;
-		}
-		byChannel[outcome.channel] = channel;
-	}
-	const verificationRates = Object.values(byChannel).filter((item) => item.total > 0).map((item) => item.verified / item.total);
-	return {
-		total: completed.length,
-		falseCompletions,
-		verificationDrift: cases.length,
-		supportMismatches,
-		channelConsistencyGap: verificationRates.length > 1 ? Math.max(...verificationRates) - Math.min(...verificationRates) : 0,
-		byChannel,
-		cases
-	};
-}
-//#endregion
-export { replayExecutionEvaluation };

package/dist/src/agent/prompt/memory/index.d.ts

@@ -1,23 +0,0 @@
-interface MemoryMatch {
-    file: string;
-    lines: string;
-    score: number;
-    lineNumbers: number[];
-}
-export interface MemorySearchOptions {
-    maxResults?: number;
-    minScore?: number;
-    /** Absolute path to the shared curated memories dir (MEMORY.md). */
-    memoriesDir?: string;
-    /** Absolute path to global user memory (`~/.xopc/user/MEMORY.md`). */
-    userMemoryPath?: string;
-}
-export declare function memorySearch(baseDir: string, query: string, options?: MemorySearchOptions): Promise<MemoryMatch[]>;
-export declare function memoryGet(baseDir: string, path: string, from?: number, lines?: number, memoriesDir?: string, userMemoryPath?: string): {
-    content: string;
-    lineNumbers: {
-        start: number;
-        end: number;
-    };
-} | null;
-export {};

package/dist/src/agent/prompt/memory/index.js

@@ -1,101 +0,0 @@
-import { createLogger } from "../../../utils/logger/index.js";
-import { init_logger } from "../../../utils/logger.js";
-import { requireXopcDatabase } from "../../../storage/sqlite/connection.js";
-import { LOCAL_USER_ID } from "../../../user-context/owner.js";
-import { searchMemoryIndex, syncMemoryIndex } from "../../../storage/sqlite/memory-index-repository.js";
-import "../../../storage/sqlite/index.js";
-import { join, relative } from "path";
-import { existsSync, readFileSync } from "fs";
-//#region src/agent/prompt/memory/index.ts
-init_logger();
-const log = createLogger("MemorySearch");
-const AGENT_MEMORY_FILENAME = "MEMORY.md";
-const USER_MEMORY_DISPLAY_PATH = "user/MEMORY.md";
-function ensureMemoryDatabase() {
-	requireXopcDatabase();
-}
-function fallbackMemorySearch(baseDir, query, options) {
-	const normalizedQuery = query.trim().toLowerCase();
-	if (!normalizedQuery) return [];
-	const memoriesDir = options.memoriesDir;
-	const candidatePaths = [...[...memoriesDir ? [join(memoriesDir, AGENT_MEMORY_FILENAME)].filter((path) => existsSync(path)) : [], ...options.userMemoryPath && existsSync(options.userMemoryPath) ? [options.userMemoryPath] : []], join(baseDir, "MEMORY.md")].filter((path) => existsSync(path));
-	const matches = [];
-	for (const path of candidatePaths) {
-		const lines = readFileSync(path, "utf-8").split("\n");
-		for (let i = 0; i < lines.length; i++) {
-			const line = lines[i];
-			if (!line.toLowerCase().includes(normalizedQuery)) continue;
-			const score = 1;
-			if (score < options.minScore) continue;
-			const file = options.userMemoryPath && path === options.userMemoryPath ? USER_MEMORY_DISPLAY_PATH : memoriesDir && path.startsWith(memoriesDir) ? path.slice(memoriesDir.length).replace(/^[/\\]/, "") : relative(baseDir, path).replace(/\\/g, "/");
-			matches.push({
-				file,
-				lines: line,
-				score,
-				lineNumbers: [i + 1]
-			});
-		}
-	}
-	return matches.slice(0, options.maxResults);
-}
-async function memorySearch(baseDir, query, options = {}) {
-	const { maxResults = 5, minScore = .3, memoriesDir, userMemoryPath } = options;
-	try {
-		ensureMemoryDatabase();
-		syncMemoryIndex({
-			userId: LOCAL_USER_ID,
-			workspaceDir: baseDir,
-			memoriesDir,
-			userMemoryPath
-		});
-		return searchMemoryIndex({
-			userId: LOCAL_USER_ID,
-			query,
-			maxResults,
-			minScore
-		}).map((hit) => ({
-			file: hit.path,
-			lines: hit.lines,
-			score: hit.score,
-			lineNumbers: hit.lineNumbers
-		}));
-	} catch (err) {
-		const em = err instanceof Error ? err.message : String(err);
-		log.warn({
-			err,
-			errorMessage: em
-		}, `Memory FTS search failed: ${em}`);
-		return fallbackMemorySearch(baseDir, query, {
-			maxResults,
-			minScore,
-			memoriesDir,
-			userMemoryPath
-		});
-	}
-}
-function memoryGet(baseDir, path, from, lines, memoriesDir, userMemoryPath) {
-	let fullPath = path.startsWith("/") ? path : join(baseDir, path);
-	if (!existsSync(fullPath)) {
-		const normalized = path.replace(/\\/g, "/");
-		if (normalized === USER_MEMORY_DISPLAY_PATH && userMemoryPath && existsSync(userMemoryPath)) fullPath = userMemoryPath;
-		else if (memoriesDir) {
-			if ((normalized.split("/").pop() ?? normalized) === AGENT_MEMORY_FILENAME) {
-				const candidatePath = join(memoriesDir, AGENT_MEMORY_FILENAME);
-				if (existsSync(candidatePath)) fullPath = candidatePath;
-			}
-		}
-	}
-	if (!existsSync(fullPath)) return null;
-	const allLines = readFileSync(fullPath, "utf-8").split("\n");
-	const start = from || 1;
-	const end = Math.min(start + (lines || 10) - 1, allLines.length);
-	return {
-		content: allLines.slice(start - 1, end).join("\n"),
-		lineNumbers: {
-			start,
-			end
-		}
-	};
-}
-//#endregion
-export { memoryGet, memorySearch };

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

@@ -1,21 +0,0 @@
-import type { AgentTool } from '@earendil-works/pi-agent-core';
-import type { Config } from '../../config/schema.js';
-import { ComposioSessionsAdapter } from '../../connectors/composio-sessions.js';
-type CurrentContext = {
-    channel: string;
-    chatId: string;
-    sessionKey: string;
-} | null;
-export type ComposioToolDeps = {
-    getConfig: () => Config | undefined;
-    getCurrentContext: () => CurrentContext;
-    agentId?: string;
-    adapter?: ComposioSessionsAdapter;
-};
-export declare function connectorPrincipalForSession(sessionKey: string | undefined): {
-    principalId: string;
-    agentId?: string;
-    isLocalOwner: boolean;
-};
-export declare function createComposioTools(deps: ComposioToolDeps): AgentTool[];
-export {};