@mono-agent/agent-app 0.6.2 → 0.9.0

package/dist/memory-command.js

@@ -1,16 +1,37 @@
-import { readdir, readFile, stat } from "node:fs/promises";
+import { readdir, readFile, realpath, stat } from "node:fs/promises";
 import { basename, isAbsolute, join, relative, resolve } from "node:path";
 import { resolveSupermemoryContainer } from "@mono-agent/config";
-import { openMemoryDb } from "@mono-agent/memory/store";
-import { parseDailyFile } from "@mono-agent/memory/bujo";
-import { isAppCoreConfigError, loadAppCoreConfig } from "./app-config.js";
-import { createRecallStore, resolveMemoryRecallSettings, } from "./memory-recall.js";
+import { listTraceSources } from "@mono-agent/observability";
+import { isAppCoreConfigError, loadAppCoreConfig, resolveAppTraceRegistryDir, resolveGlobalTraceRegistryDir, } from "./app-config.js";
 import * as ui from "./ui.js";
 const DEFAULT_SEARCH_LIMIT = 8;
 const DEFAULT_TOP_LIMIT = 10;
 const DEFAULT_ENTITY_LIMIT = 8;
 const DATE_RE = /^\d{4}-\d{2}-\d{2}$/u;
+const INTAKE_ID_RE = /^[a-f0-9]{64}$/u;
+const INTAKE_REASON_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/u;
+const MEMORY_HEALTH_SCHEMA_VERSION = 1;
+const REPLAY_ADOPTION_SCHEMA_VERSION = 1;
+const EMPTY_HEALTH_COUNTS = Object.freeze({
+    pending: 0,
+    due: 0,
+    dead: 0,
+    outbox: 0,
+    temporary: 0,
+    memories: 0,
+    vectors: 0,
+    missingVectors: 0,
+});
 export async function runMemoryCommand(input) {
+    const usageError = memoryCommandUsageError(input);
+    if (usageError !== undefined) {
+        if (input.positionals[0] === "adopt-replay") {
+            writeReplayAdoptionCliFailure(input.json, "replay_adoption_usage");
+            return 2;
+        }
+        process.stderr.write(ui.errorLine(usageError));
+        return 2;
+    }
     const context = await loadMemoryCommandContext(input);
     if ("code" in context) {
         return context.code;
@@ -18,6 +39,15 @@ export async function runMemoryCommand(input) {
     const [rawSubcommand, ...rest] = input.positionals;
     const subcommand = rawSubcommand ?? "stats";
     if (context.config.memory === undefined) {
+        if (subcommand === "audit" && input.strict) {
+            const result = notConfiguredHealthReport();
+            write(input.json, result, () => renderStrictAudit(result));
+            return strictHealthExitCode(result.status);
+        }
+        if (subcommand === "adopt-replay") {
+            writeReplayAdoptionCliFailure(input.json, "replay_adoption_requires_bujo");
+            return 1;
+        }
         writeNoMemory(context.configPath, input.json);
         return 0;
     }
@@ -44,23 +74,503 @@ export async function runMemoryCommand(input) {
         }
         case "top":
             return await runTop(context, input);
+        case "audit":
+            return input.strict
+                ? await runStrictAudit(context, input.json)
+                : await runAudit(context, input.json);
+        case "inspect":
+            return await runIntakeInspect(context, rest[0], input.json);
+        case "retry":
+            return await runIntakeMutation(context, "retry", rest[0], undefined, input.json);
+        case "resolve":
+            return await runIntakeMutation(context, "resolve", rest[0], rest[1], input.json);
+        case "rebuild":
+            return await runIndexTransition(context, "rebuild", input.json);
+        case "rollback":
+            return await runIndexTransition(context, "rollback", input.json);
+        case "adopt-replay":
+            return await runReplayAdoption(context, input.json);
         default:
             process.stderr.write(ui.errorLine(`Unknown memory subcommand \`${subcommand}\`.`));
-            process.stderr.write(ui.hint("Expected stats, today, show <date>, search <query>, or top."));
+            process.stderr.write(ui.hint("Expected stats, today, show <date>, search <query>, top, audit, inspect [id], retry [id], resolve <id> <reason>, rebuild, rollback, or adopt-replay."));
             return 2;
     }
 }
+function memoryCommandUsageError(input) {
+    const [rawSubcommand, ...rest] = input.positionals;
+    const subcommand = rawSubcommand ?? "stats";
+    if (input.strict && subcommand !== "audit") {
+        return "--strict is only supported for `mono-agent memory audit`.";
+    }
+    if (input.limit !== undefined && subcommand !== "stats" && subcommand !== "search" && subcommand !== "top") {
+        return "--limit is only supported for memory stats, search, and top.";
+    }
+    switch (subcommand) {
+        case "stats":
+        case "today":
+        case "top":
+        case "audit":
+        case "rebuild":
+        case "rollback":
+        case "adopt-replay":
+            return rest.length === 0 ? undefined : `Usage: mono-agent memory ${subcommand}.`;
+        case "show":
+            return rest.length === 1 && DATE_RE.test(rest[0] ?? "")
+                ? undefined
+                : "Usage: mono-agent memory show <YYYY-MM-DD>.";
+        case "search":
+            return rest.join(" ").trim().length > 0
+                ? undefined
+                : "Usage: mono-agent memory search <query>.";
+        case "inspect":
+            return rest.length <= 1 && (rest[0] === undefined || INTAKE_ID_RE.test(rest[0]))
+                ? undefined
+                : "Usage: mono-agent memory inspect [<64-character-id>].";
+        case "retry":
+            return rest.length <= 1 && (rest[0] === undefined || INTAKE_ID_RE.test(rest[0]))
+                ? undefined
+                : "Usage: mono-agent memory retry [<64-character-id>].";
+        case "resolve":
+            if (rest.length !== 2 || !INTAKE_ID_RE.test(rest[0] ?? "")) {
+                return "Usage: mono-agent memory resolve <64-character-id> <reason-slug>.";
+            }
+            return INTAKE_REASON_RE.test(rest[1] ?? "")
+                ? undefined
+                : "memory resolve reason must be a 1-64 character lowercase slug.";
+        default:
+            return undefined;
+    }
+}
+async function runReplayAdoption(context, json) {
+    const memory = context.config.memory;
+    if (memory === undefined || (memory.backend ?? "bujo") === "supermemory"
+        || memory.mode !== "bujo" || memory.embeddings === undefined) {
+        writeReplayAdoptionCliFailure(json, "replay_adoption_requires_bujo");
+        return 1;
+    }
+    try {
+        const registryDirs = await memoryRegistryDirs(context);
+        if (await hasLiveConfiguredAgent(context.configPath, registryDirs)) {
+            writeReplayAdoptionCliFailure(json, "replay_adoption_agent_running");
+            return 1;
+        }
+        const { adoptLegacyReplayProjection } = await loadBujoModule();
+        // Re-check after the lazy module load so a configured process cannot race
+        // the SSH-only stopped-store precondition during setup. The package also
+        // takes the memory-root writer lease and SQLite writer fence.
+        if (await hasLiveConfiguredAgent(context.configPath, registryDirs)) {
+            writeReplayAdoptionCliFailure(json, "replay_adoption_agent_running");
+            return 1;
+        }
+        const adopted = await adoptLegacyReplayProjection({
+            root: memory.path,
+            mode: "bujo",
+            embeddingModel: `${memory.embeddings.provider}:${memory.embeddings.model}`,
+            dimension: memory.embeddings.dim ?? 768,
+        });
+        const result = publicReplayAdoptionResult(adopted);
+        write(json, result, () => renderReplayAdoption(result));
+        return 0;
+    }
+    catch {
+        // Adoption is a privacy boundary. Do not classify or interpolate the
+        // package/native error: it may contain paths, record ids, marker bytes, or
+        // model-owned text. Operators get a stable remediation contract instead.
+        writeReplayAdoptionCliFailure(json, "replay_adoption_failed");
+        return 1;
+    }
+}
+const REPLAY_ADOPTION_FAILURE_MESSAGES = Object.freeze({
+    replay_adoption_usage: "Usage: mono-agent memory adopt-replay [--json] [--config <path>] [--env-file <path>].",
+    replay_adoption_config_invalid: "Replay adoption requires a valid mono-agent configuration.",
+    replay_adoption_requires_bujo: "Replay adoption requires a configured built-in BuJo memory store with embeddings.",
+    replay_adoption_agent_running: "Replay adoption requires the configured agent to be stopped. Stop it and retry.",
+    replay_adoption_failed: "Replay adoption failed. Keep the agent stopped, inspect strict memory health, resolve the reported condition, and retry.",
+});
+export function writeReplayAdoptionCliFailure(json, code) {
+    const result = {
+        schemaVersion: REPLAY_ADOPTION_SCHEMA_VERSION,
+        operation: "adopt-replay",
+        status: "failed",
+        code,
+        message: REPLAY_ADOPTION_FAILURE_MESSAGES[code],
+    };
+    if (json) {
+        write(true, result, () => "");
+        return;
+    }
+    process.stderr.write(ui.errorLine(`[${result.code}] ${result.message}`));
+}
+function publicReplayAdoptionResult(result) {
+    const counts = result.counts;
+    if (result.backend !== "bujo" || result.mode !== "bujo" || result.status !== "adopted"
+        || result.rebuildRequired !== true || !/^[a-f0-9]{64}$/u.test(result.authorityDigest)
+        || !isSafeAggregateCount(counts.terminals)
+        || !isSafeAggregateCount(counts.supersedes)
+        || !isSafeAggregateCount(counts.threads)) {
+        throw new Error("invalid private adoption result");
+    }
+    return {
+        backend: "bujo",
+        mode: "bujo",
+        status: "adopted",
+        counts: {
+            terminals: counts.terminals,
+            supersedes: counts.supersedes,
+            threads: counts.threads,
+        },
+        authorityDigest: result.authorityDigest,
+        rebuildRequired: true,
+    };
+}
+function isSafeAggregateCount(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+function notConfiguredHealthReport(now = new Date()) {
+    return {
+        schemaVersion: MEMORY_HEALTH_SCHEMA_VERSION,
+        backend: "none",
+        status: "not_configured",
+        checkedAt: now.toISOString(),
+        issues: [],
+        counts: EMPTY_HEALTH_COUNTS,
+    };
+}
+async function runStrictAudit(context, json) {
+    const memory = context.config.memory;
+    if (memory === undefined) {
+        const result = notConfiguredHealthReport();
+        write(json, result, () => renderStrictAudit(result));
+        return 0;
+    }
+    if ((memory.backend ?? "bujo") === "supermemory") {
+        const result = {
+            schemaVersion: MEMORY_HEALTH_SCHEMA_VERSION,
+            backend: "supermemory",
+            status: "unknown",
+            checkedAt: new Date().toISOString(),
+            issues: [],
+            counts: EMPTY_HEALTH_COUNTS,
+        };
+        write(json, result, () => renderStrictAudit(result));
+        return 1;
+    }
+    let result;
+    try {
+        const { auditBujoMemoryHealth } = await loadBujoModule();
+        result = auditBujoMemoryHealth({
+            root: memory.path,
+            mode: memory.mode,
+            ...(memory.embeddings === undefined
+                ? {}
+                : {
+                    configuredEmbeddingModel: `${memory.embeddings.provider}:${memory.embeddings.model}`,
+                    configuredDimension: memory.embeddings.dim ?? 768,
+                }),
+        });
+    }
+    catch (error) {
+        result = {
+            schemaVersion: MEMORY_HEALTH_SCHEMA_VERSION,
+            backend: "bujo",
+            mode: memory.mode,
+            status: "unknown",
+            checkedAt: new Date().toISOString(),
+            issues: isNativeModuleFailure(error) ? ["native_module_unavailable"] : ["health_check_failed"],
+            counts: EMPTY_HEALTH_COUNTS,
+        };
+    }
+    write(json, result, () => renderStrictAudit(result));
+    return strictHealthExitCode(result.status);
+}
+function strictHealthExitCode(status) {
+    switch (status) {
+        case "healthy":
+        case "in_progress":
+        case "not_configured":
+            return 0;
+        case "degraded":
+        case "unhealthy":
+        case "unknown":
+            return 1;
+    }
+}
+async function runIntakeInspect(context, id, json) {
+    const memory = context.config.memory;
+    if (memory === undefined) {
+        writeNoMemory(context.configPath, json);
+        return 0;
+    }
+    if ((memory.backend ?? "bujo") === "supermemory") {
+        process.stderr.write(ui.errorLine("memory inspect is available only for the built-in memory intake."));
+        return 1;
+    }
+    try {
+        const { inspectCompletedTurnIntake } = await loadBujoModule();
+        const inspection = inspectCompletedTurnIntake(memory.path);
+        const result = intakeInspectionResult(inspection, id);
+        write(json, result, () => renderIntakeInspection(result));
+        return 0;
+    }
+    catch {
+        process.stderr.write(ui.errorLine("memory inspect failed; the intake metadata is unavailable or invalid."));
+        return 1;
+    }
+}
+async function runIntakeMutation(context, operation, id, reason, json) {
+    const memory = context.config.memory;
+    if (memory === undefined) {
+        writeNoMemory(context.configPath, json);
+        return 0;
+    }
+    if ((memory.backend ?? "bujo") === "supermemory") {
+        process.stderr.write(ui.errorLine(`memory ${operation} is available only for the built-in memory intake.`));
+        return 1;
+    }
+    try {
+        await assertNoLiveConfiguredAgent(context.configPath, await memoryRegistryDirs(context));
+        const bujo = await loadBujoModule();
+        if (operation === "retry") {
+            const mutation = bujo.retryCompletedTurnIntake(memory.path, id === undefined ? {} : { id });
+            const result = {
+                schemaVersion: MEMORY_HEALTH_SCHEMA_VERSION,
+                operation,
+                changed: mutation.retried > 0,
+                retried: mutation.retried,
+            };
+            write(json, result, () => renderIntakeMutation(result));
+            return 0;
+        }
+        const mutation = bujo.resolveCompletedTurnIntake(memory.path, id, reason);
+        const result = {
+            schemaVersion: MEMORY_HEALTH_SCHEMA_VERSION,
+            operation,
+            changed: mutation.resolved,
+            resolved: mutation.resolved,
+        };
+        write(json, result, () => renderIntakeMutation(result));
+        return 0;
+    }
+    catch (error) {
+        const retainedPlan = /retained semantic-plan recovery/iu.test(reasonOf(error));
+        process.stderr.write(ui.errorLine(retainedPlan
+            ? "memory resolve refused: retained semantic-plan recovery must complete first."
+            : `memory ${operation} failed: ${reasonOf(error)}`));
+        return 1;
+    }
+}
+function intakeInspectionResult(inspection, id) {
+    const items = id === undefined ? inspection.items : inspection.items.filter((item) => item.id === id);
+    return {
+        schemaVersion: inspection.schemaVersion,
+        operation: "inspect",
+        matched: items.length,
+        temporary: inspection.temporary,
+        snapshot: inspection.snapshot,
+        items,
+    };
+}
+async function memoryRegistryDirs(context) {
+    return await dedupeRegistryDirs([
+        await resolveAppTraceRegistryDir({
+            env: context.env,
+            cwd: context.cwd,
+            configPath: context.configPath,
+        }),
+        resolveGlobalTraceRegistryDir(context.env),
+    ]);
+}
+async function runIndexTransition(context, operation, json) {
+    const memory = context.config.memory;
+    if (memory === undefined) {
+        writeNoMemory(context.configPath, json);
+        return 0;
+    }
+    if ((memory.backend ?? "bujo") === "supermemory") {
+        process.stderr.write(ui.errorLine(`mono-agent memory ${operation} is available only for the built-in Lite, Journal, and BuJo stores; Supermemory manages its remote index.`));
+        return 1;
+    }
+    const settings = previewRecallSettings(context.config);
+    if (settings === undefined || "supermemory" in settings) {
+        process.stderr.write(ui.errorLine(`Unable to resolve the configured built-in memory store for ${operation}.`));
+        return 1;
+    }
+    try {
+        const registryDirs = await memoryRegistryDirs(context);
+        await assertNoLiveConfiguredAgent(context.configPath, registryDirs);
+        const { resolveActiveMemoryDbPath, rollbackMemoryIndex, safeRebuildMemoryIndex, } = await loadBujoModule();
+        const { createMemoryEmbeddingProvider } = await loadMemoryRecallModule();
+        const embeddings = settings.embeddings === undefined
+            ? undefined
+            : await createMemoryEmbeddingProvider(settings.embeddings);
+        const options = {
+            root: memory.path,
+            tier: memory.mode,
+            ...(embeddings === undefined ? {} : { embeddings, dim: settings.embeddings?.dim ?? 768 }),
+        };
+        // Re-check after provider construction so a legacy writer that started
+        // during setup cannot be raced by the destructive transition.
+        await assertNoLiveConfiguredAgent(context.configPath, registryDirs);
+        const details = operation === "rebuild"
+            ? await safeRebuildMemoryIndex(options)
+            : await rollbackMemoryIndex(options);
+        const activeDatabase = await resolveActiveMemoryDbPath(memory.path);
+        const result = {
+            configured: true,
+            backend: "bujo",
+            operation,
+            activeDatabase,
+            details,
+        };
+        write(json, result, () => renderIndexTransition(result));
+        return 0;
+    }
+    catch (error) {
+        process.stderr.write(ui.errorLine(`memory ${operation} failed: ${reasonOf(error)}`));
+        return 1;
+    }
+}
+async function runAudit(context, json) {
+    const memory = context.config.memory;
+    if (memory === undefined) {
+        writeNoMemory(context.configPath, json);
+        return 0;
+    }
+    if ((memory.backend ?? "bujo") === "supermemory") {
+        const result = {
+            configured: true,
+            backend: "supermemory",
+            metadataOnly: true,
+            counts: null,
+            bytes: null,
+            duplicates: null,
+            vectorCoverage: null,
+            accessConcentration: null,
+            backlog: { known: false, captureQueue: null, vectorIndex: null },
+            latency: { known: false, searchP50Ms: null, searchP95Ms: null, indexingMs: null },
+            cost: { known: false, totalUsd: null, embeddingCalls: null, llmCalls: null, tokens: null },
+            notes: ["Remote backend health metadata is not exposed by the configured client."],
+        };
+        write(json, result, () => renderAudit(result));
+        return 0;
+    }
+    const root = memory.path;
+    const { readBujoRuntimeSnapshot, resolveActiveMemoryDbPath } = await loadBujoModule();
+    const { openMemoryDb } = await loadMemoryStoreModule();
+    const runtime = readBujoRuntimeSnapshot(root);
+    const dbPath = await resolveActiveMemoryDbPath(root);
+    const rootExists = await exists(root);
+    const size = rootExists ? await collectStoreSize(root) : emptySize();
+    let audit;
+    let generation;
+    let metadataQueryMs = null;
+    if (await exists(dbPath)) {
+        const db = openMemoryDb({ path: dbPath, readOnly: true });
+        try {
+            const started = performance.now();
+            audit = db.audit();
+            generation = db.indexMetadata();
+            metadataQueryMs = performance.now() - started;
+        }
+        finally {
+            db.close();
+        }
+    }
+    const live = audit?.counts.live ?? 0;
+    const liveIndexed = audit?.vectors.liveIndexed ?? 0;
+    const semanticExpected = memory.embeddings !== undefined;
+    const runtimeQueues = runtime.snapshot?.queues;
+    const captureQueue = runtime.stale ? undefined : runtimeQueues?.capture;
+    const runtimeVectorBacklog = runtime.stale ? undefined : runtimeQueues?.index?.remainingBacklog;
+    const result = {
+        configured: true,
+        backend: "bujo",
+        mode: memory.mode,
+        ...(generation === undefined ? {} : { generation }),
+        metadataOnly: true,
+        counts: audit?.counts ?? { total: 0, live: 0, entities: 0, entityRelations: 0 },
+        bytes: size,
+        duplicates: audit?.duplicates ?? { groups: 0, redundantRecords: 0, ratio: 0 },
+        vectorCoverage: audit?.vectors ?? { indexed: 0, liveIndexed: 0, liveCoverage: live === 0 ? 1 : 0 },
+        accessConcentration: audit?.access ?? { totalCount: 0, accessedMemories: 0, topOnePercentShare: 0 },
+        backlog: {
+            known: true,
+            captureQueue: captureQueue === undefined ? null : captureQueue.queued + captureQueue.inFlight,
+            vectorIndex: runtimeVectorBacklog ?? (semanticExpected ? Math.max(0, live - liveIndexed) : 0),
+        },
+        runtime: {
+            available: runtime.available,
+            stale: runtime.stale,
+            ...(runtime.reason === undefined ? {} : { reason: runtime.reason }),
+            ...(runtime.ageMs === undefined ? {} : { ageMs: runtime.ageMs }),
+            ...(runtime.processAlive === undefined ? {} : { processAlive: runtime.processAlive }),
+            ...(runtime.snapshot === undefined ? {} : {
+                pid: runtime.snapshot.pid,
+                tier: runtime.snapshot.tier,
+                state: runtime.snapshot.state,
+                startedAt: runtime.snapshot.startedAt,
+                updatedAt: runtime.snapshot.updatedAt,
+                queues: runtime.snapshot.queues,
+            }),
+        },
+        latency: {
+            known: metadataQueryMs !== null,
+            metadataQueryMs,
+            searchP50Ms: null,
+            searchP95Ms: null,
+            indexingMs: null,
+        },
+        cost: {
+            known: runtime.snapshot !== undefined,
+            totalUsd: null,
+            embeddingCalls: runtime.snapshot?.counters.embeddingCalls ?? null,
+            embeddingTexts: runtime.snapshot?.counters.embeddingTexts ?? null,
+            llmCalls: runtime.snapshot?.counters.llmCalls ?? null,
+            llmInputChars: runtime.snapshot?.counters.llmInputChars ?? null,
+            tokens: null,
+        },
+        notes: [
+            ...(audit === undefined ? [`No SQLite index found at ${dbPath}.`] : []),
+            ...(generation === undefined ? [] : [
+                `Generation ${generation.generation}: skipped raw summaries ${generation.skippedRawRecords ?? 0}, `
+                    + `unstructured source lines ${generation.skippedUnstructuredRecords ?? 0}, `
+                    + `missing-identity source lines ${generation.skippedMissingIdentityRecords ?? 0} `
+                    + `(${generation.missingIdentityLocations?.join(", ") || "none"}), `
+                    + `legacy-source lines ${generation.skippedLegacySourceRecords ?? 0} `
+                    + `(${generation.legacySourceLocations?.join(", ") || "none"}), `
+                    + `Journal duplicate lines ${generation.skippedJournalDuplicateRecords ?? 0}, `
+                    + `parsed source items ${generation.parsedSourceItems ?? 0}, `
+                    + `derived legacy associations ${generation.derivedLegacyAssociations ?? 0}.`,
+            ]),
+            "Search latency and model cost require benchmark/run telemetry and are not inferred from memory content.",
+            ...(!runtime.available ? [
+                `Runtime queue/call telemetry is ${runtime.reason === "invalid" ? "invalid" : "not available until the configured store starts"}.`,
+            ] : runtime.stale ? [
+                `Runtime queue/call telemetry is stale (${runtime.snapshot?.state ?? "unknown"} snapshot; last update ${runtime.snapshot?.updatedAt ?? "unknown"}).`,
+            ] : []),
+        ],
+    };
+    write(json, result, () => renderAudit(result));
+    return 0;
+}
 async function loadMemoryCommandContext(input) {
     const cwd = input.cwd;
     const configPath = resolve(cwd, input.configPath ?? "mono-agent.config.json");
     try {
         return {
             cwd,
+            env: input.env,
             configPath,
             config: await loadAppCoreConfig({ env: input.env, cwd, configPath }),
         };
     }
     catch (error) {
+        if (input.positionals[0] === "adopt-replay") {
+            // Config/native failures can contain the config path or invalid private
+            // values. Adoption always exposes the same closed error contract.
+            writeReplayAdoptionCliFailure(input.json, "replay_adoption_config_invalid");
+            return { code: 1 };
+        }
         if (isAppCoreConfigError(error)) {
             process.stderr.write(ui.errorLine(error.message));
             process.stderr.write(ui.hint(`Fix ${configPath}, then re-run \`mono-agent memory\`.`));
@@ -69,6 +579,78 @@ async function loadMemoryCommandContext(input) {
         throw error;
     }
 }
+async function assertNoLiveConfiguredAgent(configPath, registryDirs) {
+    const live = await findLiveConfiguredAgent(configPath, registryDirs);
+    if (live === undefined)
+        return;
+    const canonicalConfig = await canonicalPath(configPath);
+    throw new Error(`agent process ${live.pid} (${live.sourceId}) is still alive for this config (trace health: ${live.health}); ` +
+        `stop it first with: mono-agent stop --config ${canonicalConfig}`);
+}
+async function hasLiveConfiguredAgent(configPath, registryDirs) {
+    return await findLiveConfiguredAgent(configPath, registryDirs) !== undefined;
+}
+async function findLiveConfiguredAgent(configPath, registryDirs) {
+    const canonicalConfig = await canonicalPath(configPath);
+    const listings = await Promise.all(registryDirs.map(async (registryDir) => await listTraceSources({ registryDir })));
+    const sources = dedupeTraceSources(listings.flatMap((listing) => listing.sources));
+    let live;
+    for (const source of sources) {
+        if (source.configPath === undefined || source.pid === undefined || !pidIsAlive(source.pid))
+            continue;
+        if (await canonicalPath(source.configPath) === canonicalConfig) {
+            live = source;
+            break;
+        }
+    }
+    return live;
+}
+async function dedupeRegistryDirs(registryDirs) {
+    const seen = new Set();
+    const deduped = [];
+    for (const registryDir of registryDirs) {
+        const canonical = await canonicalPath(registryDir);
+        if (seen.has(canonical))
+            continue;
+        seen.add(canonical);
+        deduped.push(registryDir);
+    }
+    return deduped;
+}
+function dedupeTraceSources(sources) {
+    const seen = new Set();
+    const deduped = [];
+    for (const source of sources) {
+        // Primary and global registries mirror the same source/PID pair. Preserve
+        // a reused source ID with a different PID so either live process blocks.
+        const key = `${source.sourceId}\0${source.pid ?? "unknown"}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(source);
+    }
+    return deduped;
+}
+async function canonicalPath(path) {
+    const absolute = resolve(path);
+    try {
+        return await realpath(absolute);
+    }
+    catch {
+        return absolute;
+    }
+}
+function pidIsAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
 async function runStats(context, input) {
     const memory = context.config.memory;
     if (memory === undefined) {
@@ -81,7 +663,9 @@ async function runStats(context, input) {
         return 0;
     }
     const root = memory.path;
-    const dbPath = join(root, "memory.db");
+    const { resolveActiveMemoryDbPath } = await loadBujoModule();
+    const { openMemoryDb } = await loadMemoryStoreModule();
+    const dbPath = await resolveActiveMemoryDbPath(root);
     const rootExists = await exists(root);
     const dbExists = await exists(dbPath);
     const size = rootExists ? await collectStoreSize(root) : emptySize();
@@ -91,7 +675,7 @@ async function runStats(context, input) {
     let entityCount = 0;
     let topMemories = [];
     if (dbExists) {
-        const db = openMemoryDb({ path: dbPath });
+        const db = openMemoryDb({ path: dbPath, readOnly: true });
         try {
             stats = readLocalStats(db, input.limit ?? DEFAULT_ENTITY_LIMIT);
             entityCount = db.countEntities();
@@ -164,6 +748,7 @@ async function runShow(context, date, json) {
         return 0;
     }
     const content = await readFile(found, "utf8");
+    const { parseDailyFile } = await loadBujoModule();
     const parsed = parseDailyFile(content);
     const result = {
         configured: true,
@@ -185,18 +770,24 @@ async function runShow(context, date, json) {
     return 0;
 }
 async function runSearch(context, query, input) {
-    const settings = previewRecallSettings(context.config);
+    let settings = previewRecallSettings(context.config);
     if (settings === undefined) {
         writeNoMemory(context.configPath, input.json);
         return 0;
     }
-    if (!("supermemory" in settings) && !(await exists(join(settings.root, "memory.db")))) {
+    if (!("supermemory" in settings)) {
+        const { resolveActiveMemoryDbPath } = await loadBujoModule();
+        const dbPath = await resolveActiveMemoryDbPath(settings.root);
+        settings = { ...settings, dbPath };
+    }
+    if (!("supermemory" in settings) && !(await exists(settings.dbPath ?? join(settings.root, "memory.db")))) {
+        const dbPath = settings.dbPath ?? join(settings.root, "memory.db");
         const result = {
             configured: true,
             backend: "bujo",
             query,
             hits: [],
-            notes: [`No SQLite index found at ${join(settings.root, "memory.db")}; run memory-bujo rebuild or wait for capture.`],
+            notes: [`No SQLite index found at ${dbPath}; run mono-agent memory rebuild or wait for capture.`],
         };
         write(input.json, result, () => renderSearch(result));
         return 0;
@@ -248,18 +839,20 @@ async function runTop(context, input) {
         write(input.json, result, () => `${ui.banner("mono-agent memory", "top")}\n${result.message}\n`);
         return 0;
     }
-    const dbPath = join(memory.path, "memory.db");
+    const { resolveActiveMemoryDbPath } = await loadBujoModule();
+    const { openMemoryDb } = await loadMemoryStoreModule();
+    const dbPath = await resolveActiveMemoryDbPath(memory.path);
     if (!(await exists(dbPath))) {
         const result = {
             configured: true,
             backend: "bujo",
             hits: [],
-            notes: [`No SQLite index found at ${dbPath}; run memory-bujo rebuild or wait for capture.`],
+            notes: [`No SQLite index found at ${dbPath}; run mono-agent memory rebuild or wait for capture.`],
         };
         write(input.json, result, () => renderTop(result));
         return 0;
     }
-    const db = openMemoryDb({ path: dbPath });
+    const db = openMemoryDb({ path: dbPath, readOnly: true });
     try {
         const hits = db.topSalient(input.limit ?? DEFAULT_TOP_LIMIT).map((record) => ({
             id: record.id,
@@ -279,10 +872,6 @@ async function runTop(context, input) {
     return 0;
 }
 function previewRecallSettings(config) {
-    const fromTool = resolveMemoryRecallSettings(config);
-    if (fromTool !== undefined) {
-        return fromTool;
-    }
     const memory = config.memory;
     if (memory === undefined) {
         return undefined;
@@ -303,10 +892,11 @@ function previewRecallSettings(config) {
     }
     const embeddings = memory.embeddings;
     if (embeddings === undefined) {
-        return { root: memory.path };
+        return { root: memory.path, tier: memory.mode };
     }
     return {
         root: memory.path,
+        tier: memory.mode,
         embeddings: {
             provider: embeddings.provider,
             model: embeddings.model,
@@ -320,6 +910,7 @@ function previewRecallSettings(config) {
     };
 }
 async function recallWithFtsFallback(settings, query, limit) {
+    const { createRecallStore } = await loadMemoryRecallModule();
     const store = await createRecallStore(settings);
     try {
         return { hits: await store.recall(query, { topK: limit, trackAccess: false }) };
@@ -329,7 +920,12 @@ async function recallWithFtsFallback(settings, query, limit) {
             throw error;
         }
         await store.close().catch(() => undefined);
-        const fallback = { root: settings.root };
+        const fallback = {
+            root: settings.root,
+            ...(settings.tier === undefined ? {} : { tier: settings.tier }),
+            ...(settings.dbPath === undefined ? {} : { dbPath: settings.dbPath }),
+            ftsOnlyFallback: true,
+        };
         const ftsStore = await createRecallStore(fallback);
         try {
             return {
@@ -367,13 +963,7 @@ function readLocalStats(db, topEntitiesLimit) {
     return db.stats({ topEntitiesLimit });
 }
 function effectiveLocalTier(memory) {
-    if (memory.mode === "lite") {
-        return "lite";
-    }
-    if (memory.mode === "journal") {
-        return "journal";
-    }
-    return memory.llm === undefined ? "journal" : "bujo";
+    return memory.mode;
 }
 function supermemoryStats(config) {
     return {
@@ -540,6 +1130,81 @@ function renderSupermemoryStats(stats) {
         ...stats.unavailable.map((item) => `  - ${item}\n`),
     ].join("");
 }
+function renderAudit(result) {
+    let out = ui.banner("mono-agent memory", "metadata audit") + "\n";
+    out += ui.keyValue([
+        ["backend", result.backend],
+        ["memories", result.counts === null ? "unknown" : `${result.counts.total} total, ${result.counts.live} live`],
+        ["bytes", result.bytes === null ? "unknown" : formatBytes(result.bytes.rootBytes)],
+        ["duplicate ratio", result.duplicates === null ? "unknown" : formatRatio(result.duplicates.ratio)],
+        ["vector coverage", result.vectorCoverage === null ? "unknown" : formatRatio(result.vectorCoverage.liveCoverage)],
+        ["top 1% access share", result.accessConcentration === null ? "unknown" : formatRatio(result.accessConcentration.topOnePercentShare)],
+        ["vector backlog", result.backlog.vectorIndex === null ? "unknown" : String(result.backlog.vectorIndex)],
+        ["capture queue", result.backlog.captureQueue === null ? "not live/available" : String(result.backlog.captureQueue)],
+        ["runtime telemetry", result.runtime === undefined || !result.runtime.available
+                ? "unavailable"
+                : `${result.runtime.state ?? "unknown"}${result.runtime.stale ? " (stale)" : " (live)"}`],
+        ["metadata query", result.latency.metadataQueryMs == null ? "unknown" : `${result.latency.metadataQueryMs.toFixed(3)} ms`],
+        ["embedding calls", result.cost.embeddingCalls === null ? "unknown" : String(result.cost.embeddingCalls)],
+        ["memory LLM calls", result.cost.llmCalls === null ? "unknown" : String(result.cost.llmCalls)],
+        ["recorded cost", result.cost.totalUsd === null ? "unknown" : `$${result.cost.totalUsd.toFixed(6)}`],
+    ], 2);
+    for (const note of result.notes)
+        out += ui.style.yellow(`[WARN] ${note}`) + "\n";
+    return out;
+}
+function renderStrictAudit(result) {
+    return [
+        ui.banner("mono-agent memory", "strict health"),
+        "\n",
+        ui.keyValue([
+            ["schema", String(result.schemaVersion)],
+            ["backend", result.backend],
+            ["mode", "mode" in result ? result.mode : "none"],
+            ["status", result.status],
+            ["checked", result.checkedAt],
+            ["issues", result.issues.length === 0 ? "none" : result.issues.join(", ")],
+            ["pending", String(result.counts.pending)],
+            ["due", String(result.counts.due)],
+            ["dead", String(result.counts.dead)],
+            ["outbox", String(result.counts.outbox)],
+            ["temporary", String(result.counts.temporary)],
+            ["memories", String(result.counts.memories)],
+            ["vectors", String(result.counts.vectors)],
+            ["missing vectors", String(result.counts.missingVectors)],
+        ], 2),
+    ].join("");
+}
+function renderIntakeInspection(result) {
+    let out = ui.banner("mono-agent memory", "intake inspection") + "\n";
+    out += ui.keyValue([
+        ["matched", String(result.matched)],
+        ["pending", String(result.snapshot.pending)],
+        ["due", String(result.snapshot.due)],
+        ["dead", String(result.snapshot.dead)],
+        ["resolved", String(result.snapshot.resolved)],
+        ["transitioning", String(result.snapshot.transitioning)],
+        ["temporary", String(result.temporary)],
+    ], 2);
+    for (const item of result.items) {
+        out += `  ${item.id}  state=${item.state} attempt=${item.attempt} revision=${item.revision} due=${item.due ? "yes" : "no"}`;
+        if (item.lastError !== undefined)
+            out += ` lastError=${item.lastError}`;
+        out += "\n";
+    }
+    return out;
+}
+function renderIntakeMutation(result) {
+    return [
+        ui.banner("mono-agent memory", `intake ${result.operation}`),
+        "\n",
+        ui.keyValue([
+            ["changed", result.changed ? "yes" : "no"],
+            ...(result.retried === undefined ? [] : [["retried", String(result.retried)]]),
+            ...(result.resolved === undefined ? [] : [["resolved", result.resolved ? "yes" : "no"]]),
+        ], 2),
+    ].join("");
+}
 function renderLocalStats(stats) {
     let out = ui.banner("mono-agent memory", "stats") + "\n";
     out += ui.keyValue([
@@ -584,6 +1249,41 @@ function renderDaily(result) {
         result.content.endsWith("\n") ? result.content : `${result.content}\n`,
     ].join("");
 }
+function renderIndexTransition(result) {
+    return [
+        ui.banner("mono-agent memory", result.operation),
+        "\n",
+        ui.keyValue([
+            ["status", "complete"],
+            ["active database", result.activeDatabase],
+            ["generation", result.details.generation],
+            ["indexed memories", String(result.details.indexed)],
+            ["skipped raw summaries", String(result.details.skippedRawRecords)],
+            ["skipped unstructured lines", String(result.details.skippedUnstructuredRecords)],
+            ["skipped missing-identity lines", String(result.details.skippedMissingIdentityRecords)],
+            ["missing-identity locations", result.details.missingIdentityLocations.join(", ") || "none"],
+            ["skipped legacy-source lines", String(result.details.skippedLegacySourceRecords)],
+            ["legacy-source locations", result.details.legacySourceLocations.join(", ") || "none"],
+            ["skipped Journal duplicates", String(result.details.skippedJournalDuplicateRecords)],
+            ["parsed source items", String(result.details.parsedSourceItems)],
+            ["derived legacy associations", String(result.details.derivedLegacyAssociations)],
+        ], 2),
+    ].join("");
+}
+function renderReplayAdoption(result) {
+    return [
+        ui.banner("mono-agent memory", "adopt replay"),
+        "\n",
+        ui.keyValue([
+            ["status", result.status],
+            ["terminal lifecycles", String(result.counts.terminals)],
+            ["supersedes", String(result.counts.supersedes)],
+            ["threads", String(result.counts.threads)],
+            ["authority digest", result.authorityDigest],
+            ["rebuild required", result.rebuildRequired ? "yes" : "no"],
+        ], 2),
+    ].join("");
+}
 function renderSearch(result) {
     let out = ui.banner("mono-agent memory", `search: ${result.query}`) + "\n";
     if (result.degraded !== undefined) {
@@ -643,7 +1343,31 @@ function formatBytes(bytes) {
     }
     return `${value >= 10 ? value.toFixed(1) : value.toFixed(2)} ${unit}`;
 }
+function formatRatio(value) {
+    return `${(value * 100).toFixed(2)}%`;
+}
 function reasonOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
+async function loadBujoModule() {
+    return await import("@mono-agent/memory/bujo");
+}
+async function loadMemoryStoreModule() {
+    return await import("@mono-agent/memory/store");
+}
+async function loadMemoryRecallModule() {
+    return await import("./memory-recall.js");
+}
+function isNativeModuleFailure(error) {
+    try {
+        const message = error instanceof Error ? error.message : "";
+        const code = typeof error === "object" && error !== null && "code" in error
+            ? String(error.code ?? "")
+            : "";
+        return /better[-_ ]?sqlite|sqlite[-_ ]?vec|node_module_version|native module|dlopen|\.node\b/iu.test(`${code} ${message}`);
+    }
+    catch {
+        return false;
+    }
+}
 //# sourceMappingURL=memory-command.js.map