@xopcai/xopc 0.0.180 → 0.0.187

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/curated-memory-tool.d.ts

@@ -1,3 +0,0 @@
-import type { AgentTool } from '@earendil-works/pi-agent-core';
-import type { MemoryManager } from '../memory/manager.js';
-export declare function createCuratedMemoryTool(getMemoryManager: () => MemoryManager): AgentTool;

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

@@ -1,174 +0,0 @@
-import { Type } from "@sinclair/typebox";
-//#region src/agent/tools/curated-memory-tool.ts
-const CuratedMemorySchema = Type.Object({
-	action: Type.Union([
-		Type.Literal("add"),
-		Type.Literal("propose"),
-		Type.Literal("replace"),
-		Type.Literal("remove"),
-		Type.Literal("read")
-	]),
-	target: Type.Union([Type.Literal("memory"), Type.Literal("user")]),
-	kind: Type.Optional(Type.Union([
-		Type.Literal("user_profile"),
-		Type.Literal("curated_note"),
-		Type.Literal("workspace_fact"),
-		Type.Literal("daily_note"),
-		Type.Literal("session_summary"),
-		Type.Literal("derived_insight"),
-		Type.Literal("task_lesson"),
-		Type.Literal("tool_preference"),
-		Type.Literal("long_term_goal")
-	])),
-	sensitivity: Type.Optional(Type.Union([
-		Type.Literal("normal"),
-		Type.Literal("personal"),
-		Type.Literal("secret"),
-		Type.Literal("regulated")
-	])),
-	confidence: Type.Optional(Type.Number({
-		minimum: 0,
-		maximum: 1
-	})),
-	source_text: Type.Optional(Type.String({ description: "Short evidence excerpt supporting a proposed memory." })),
-	content: Type.Optional(Type.String({ description: "Required for add; new text for replace." })),
-	old_text: Type.Optional(Type.String({ description: "Substring to match one entry for replace/remove." }))
-});
-function createCuratedMemoryTool(getMemoryManager) {
-	return {
-		name: "curated_memory",
-		label: "Curated memory",
-		description: "Read, edit, or propose bounded memory in the shared user store (user/memories/MEMORY.md for curated notes and user/MEMORY.md for the user profile). Use propose when a memory should be reviewed by the user before it becomes active recall context. Entries are separated by a section-sign delimiter (see store format). System prompt shows a frozen snapshot from session start; this tool reads/writes live state on disk. Use add/replace/remove for structured updates; use read to inspect current entries.",
-		parameters: CuratedMemorySchema,
-		async execute(_toolCallId, params, _signal) {
-			const memoryManager = getMemoryManager();
-			const { action, target } = params;
-			try {
-				if (action === "read") {
-					const entries = (await memoryManager.list({ target })).map((record) => record.content);
-					return {
-						content: [{
-							type: "text",
-							text: JSON.stringify({
-								target,
-								entries,
-								count: entries.length
-							}, null, 2)
-						}],
-						details: { entries }
-					};
-				}
-				if (action === "add") {
-					const content = params.content?.trim() ?? "";
-					const result = await memoryManager.write({
-						kind: target === "user" ? "user_profile" : "curated_note",
-						target,
-						content
-					});
-					if (!result.success) return {
-						content: [{
-							type: "text",
-							text: result.error ?? "Unknown error"
-						}],
-						details: { error: result.error }
-					};
-					memoryManager.onMemoryWrite("add", target, content);
-					return {
-						content: [{
-							type: "text",
-							text: result.message ?? "OK"
-						}],
-						details: { success: true }
-					};
-				}
-				if (action === "propose") {
-					const p = params;
-					const content = p.content?.trim() ?? "";
-					const sourceText = p.source_text?.trim();
-					const result = await memoryManager.write({
-						kind: p.kind ?? (target === "user" ? "user_profile" : "curated_note"),
-						target,
-						content,
-						status: "candidate",
-						sensitivity: p.sensitivity ?? (target === "user" ? "personal" : "normal"),
-						confidence: p.confidence,
-						evidence: sourceText ? [{ sourceText }] : void 0
-					});
-					if (!result.success) return {
-						content: [{
-							type: "text",
-							text: result.error ?? "Unknown error"
-						}],
-						details: { error: result.error }
-					};
-					return {
-						content: [{
-							type: "text",
-							text: result.message ?? "Memory candidate added to inbox"
-						}],
-						details: {
-							success: true,
-							recordId: result.record?.id,
-							status: result.record?.status
-						}
-					};
-				}
-				if (action === "replace") {
-					const oldText = params.old_text?.trim() ?? "";
-					const newContent = params.content?.trim() ?? "";
-					const result = await memoryManager.update({
-						target,
-						matchText: oldText,
-						content: newContent
-					});
-					if (!result.success) return {
-						content: [{
-							type: "text",
-							text: result.error ?? "Unknown error"
-						}],
-						details: { error: result.error }
-					};
-					memoryManager.onMemoryWrite("replace", target, newContent);
-					return {
-						content: [{
-							type: "text",
-							text: result.message ?? "OK"
-						}],
-						details: { success: true }
-					};
-				}
-				const oldText = params.old_text?.trim() ?? "";
-				const result = await memoryManager.delete({
-					target,
-					matchText: oldText
-				});
-				if (!result.success) return {
-					content: [{
-						type: "text",
-						text: result.error ?? "Unknown error"
-					}],
-					details: { error: result.error }
-				};
-				memoryManager.onMemoryWrite("remove", target, oldText);
-				return {
-					content: [{
-						type: "text",
-						text: result.message ?? "OK"
-					}],
-					details: { success: true }
-				};
-			} catch (err) {
-				const message = err instanceof Error ? err.message : String(err);
-				return {
-					content: [{
-						type: "text",
-						text: `curated_memory error: ${message}`
-					}],
-					details: { error: message }
-				};
-			}
-		}
-	};
-}
-//#endregion
-export { createCuratedMemoryTool };

package/dist/src/agent/tools/goal-evidence-recorder.d.ts

@@ -1,6 +0,0 @@
-import { type GoalEvidence } from '../../goals/index.js';
-export type GoalEvidenceRecordInput = Pick<GoalEvidence, 'kind' | 'title' | 'summary' | 'uri' | 'data'>;
-export interface GoalEvidenceRecorderOptions {
-    getSessionKey: () => string | undefined;
-}
-export declare function createGoalEvidenceRecorder(options: GoalEvidenceRecorderOptions): (input: GoalEvidenceRecordInput) => Promise<void>;

package/dist/src/agent/tools/goal-evidence-recorder.js

@@ -1,32 +0,0 @@
-import { createLogger } from "../../utils/logger/index.js";
-import { init_logger } from "../../utils/logger.js";
-import { GoalService } from "../../goals/goal-service.js";
-import "../../goals/index.js";
-//#region src/agent/tools/goal-evidence-recorder.ts
-init_logger();
-const log = createLogger("GoalEvidence");
-function createGoalEvidenceRecorder(options) {
-	const goals = new GoalService();
-	return async (input) => {
-		const sessionKey = options.getSessionKey()?.trim();
-		if (!sessionKey) return;
-		const goal = goals.getActiveForSession(sessionKey);
-		if (!goal || goal.status !== "active") return;
-		try {
-			goals.addEvidence({
-				goalId: goal.id,
-				runId: goal.currentRunId,
-				...input
-			});
-		} catch (err) {
-			log.warn({
-				err,
-				sessionKey,
-				goalId: goal.id,
-				kind: input.kind
-			}, `Goal evidence record failed: ${err instanceof Error ? err.message : String(err)}`);
-		}
-	};
-}
-//#endregion
-export { createGoalEvidenceRecorder };