@chendpoc/pi-memory 0.2.3 → 0.3.1

package/dist/cli/status.js

@@ -1,234 +1,10 @@
-import { readPiMemoryEnv, resolveEmbedDim } from "../config/env.js";
-import { DEFAULT_HASH_EMBED_DIM } from "../constants/env.js";
-import { createEmbedder } from "../adapters/embed/factory.js";
-import { fetchIndexStats, ping } from "../sidecar/client.js";
-import { resolveSidecarPaths } from "../sidecar/paths.js";
-import { getVecStore } from "../sidecar/server/vec/store.js";
-import { createMemoryStore } from "../store/index.js";
-import { pathExists } from "../utils/fs.js";
-import { theme } from "./theme.js";
-const plainPalette = {
-    dim: (text) => text,
-    ok: (text) => text,
-    bad: (text) => text,
-    warn: (text) => text,
-};
-export function cliStatusPalette() {
-    return {
-        dim: theme.dim,
-        ok: theme.ok,
-        bad: theme.bad,
-        warn: theme.warn,
-    };
-}
-export function piStatusPalette(theme) {
-    return {
-        dim: (text) => theme.fg("dim", text),
-        ok: (text) => theme.fg("success", text),
-        bad: (text) => theme.fg("error", text),
-        warn: (text) => theme.fg("warning", text),
-    };
-}
-function applyLocalVecStats(report, dbPath) {
-    const vec = getVecStore(dbPath);
-    report.vectorIndex.generation = vec.getIndexGeneration();
-    report.vectorIndex.chunkCount = vec.getChunkCount();
-    const meta = vec.getStoredEmbeddingMeta();
-    if (meta) {
-        report.vectorIndex.embeddingProvider = meta.provider;
-        report.vectorIndex.embeddingModel = meta.model;
-        report.vectorIndex.embeddingDim = meta.dim;
-    }
-}
-function applySidecarVecStats(report, stats) {
-    report.vectorIndex.fromSidecar = true;
-    report.vectorIndex.generation = stats.index_generation;
-    report.vectorIndex.chunkCount = stats.chunk_count;
-    if (stats.embedding_provider && stats.embedding_model && stats.embedding_dim !== undefined) {
-        report.vectorIndex.embeddingProvider = stats.embedding_provider;
-        report.vectorIndex.embeddingModel = stats.embedding_model;
-        report.vectorIndex.embeddingDim = stats.embedding_dim;
-    }
-}
-function embedderMatchesIndex(report) {
-    const { embeddingProvider, embeddingModel, embeddingDim } = report.vectorIndex;
-    if (!embeddingProvider || !embeddingModel || embeddingDim === undefined)
-        return true;
-    return (embeddingProvider === report.embedder.provider &&
-        embeddingModel === report.embedder.model &&
-        embeddingDim === report.embedder.dim);
-}
-function resolveConfiguredEmbedder(env) {
-    try {
-        const embedder = createEmbedder(env);
-        return { provider: embedder.provider, model: embedder.model, dim: embedder.dim };
-    }
-    catch {
-        const embedModel = env.embedder === "openai"
-            ? env.openaiEmbedModel
-            : env.embedder === "ollama"
-                ? env.ollamaEmbedModel
-                : "hash/dev";
-        const dim = env.embedder === "hash"
-            ? (env.embedDimOverride ?? DEFAULT_HASH_EMBED_DIM)
-            : resolveEmbedDim(embedModel, env.embedDimOverride);
-        return { provider: env.embedder, model: embedModel, dim };
-    }
-}
-export async function gatherMemoryStatus(agentDir) {
-    const store = createMemoryStore({ agentDir });
-    await store.ensureInitialized();
-    const sidecar = resolveSidecarPaths(agentDir);
-    const env = readPiMemoryEnv();
-    const sidecarRunning = await ping(sidecar.socketPath);
-    const report = {
-        agentDir,
-        memory: await store.getStats(),
-        sidecar: {
-            socketPath: sidecar.socketPath,
-            running: sidecarRunning,
-        },
-        vectorIndex: {
-            dbPath: sidecar.dbPath,
-            exists: pathExists(sidecar.dbPath),
-        },
-        embedder: resolveConfiguredEmbedder(env),
-    };
-    if (!report.vectorIndex.exists)
-        return report;
-    if (sidecarRunning) {
-        const result = await fetchIndexStats(sidecar.socketPath);
-        if ("stats" in result) {
-            applySidecarVecStats(report, result.stats);
-            return report;
-        }
-        const hint = result.error.includes("unknown frame type")
-            ? "restart sidecar (reload Pi session or pi-memory)"
-            : result.error;
-        report.vectorIndex.readError = hint;
-        return report;
-    }
-    try {
-        applyLocalVecStats(report, sidecar.dbPath);
-    }
-    catch (error) {
-        report.vectorIndex.readError =
-            error instanceof Error ? error.message : "unable to open vector index (start sidecar)";
-    }
-    return report;
-}
-function formatVectorIndexLine(report) {
-    const { generation, chunkCount, readError } = report.vectorIndex;
-    if (readError) {
-        return `(unreadable: ${readError})`;
-    }
-    if (generation === undefined || chunkCount === undefined) {
-        return "(unknown — start sidecar or run pi-memory status again)";
-    }
-    return `gen=${generation} chunks=${chunkCount}`;
-}
-function formatIndexEmbedderLine(report, palette) {
-    const { embeddingProvider, embeddingModel, embeddingDim, chunkCount, readError } = report.vectorIndex;
-    if (readError) {
-        return palette.dim("(unavailable)");
-    }
-    if (!embeddingProvider || !embeddingModel || embeddingDim === undefined) {
-        if (chunkCount === 0) {
-            return palette.dim("(empty — reindex pending)");
-        }
-        return palette.dim("(no embedding meta — run reindex)");
-    }
-    const label = `${embeddingProvider}/${embeddingModel} (${embeddingDim}d)`;
-    if (embedderMatchesIndex(report)) {
-        return label;
-    }
-    return palette.warn(`${label} ≠ configured`);
-}
-function memoryStatusRows(report, palette = plainPalette) {
-    const lastConsolidated = report.memory.lastConsolidatedAt ?? "(never)";
-    const sidecarState = report.sidecar.running ? "running" : "not reachable";
-    const sidecarDetail = `${sidecarState} (${report.sidecar.socketPath})`;
-    const rows = [
-        { label: "agent dir", value: () => report.agentDir },
-        { label: "MEMORY lines", value: () => String(report.memory.lineCount) },
-        { label: "entries", value: () => String(report.memory.entryCount) },
-        { label: "overflow files", value: () => String(report.memory.overflowFileCount) },
-        {
-            label: "last consolidate",
-            value: () => !report.memory.lastConsolidatedAt ? palette.dim(lastConsolidated) : lastConsolidated,
-        },
-        {
-            label: "sidecar",
-            value: () => {
-                const state = report.sidecar.running ? palette.ok(sidecarState) : palette.bad(sidecarState);
-                return `${state} ${palette.dim(`(${report.sidecar.socketPath})`)}`;
-            },
-        },
-    ];
-    if (!report.vectorIndex.exists) {
-        rows.push({
-            label: "vector index",
-            value: () => palette.dim("(missing — write MEMORY or start session)"),
-        });
-    }
-    else {
-        rows.push({
-            label: "vector index",
-            value: () => {
-                const line = formatVectorIndexLine(report);
-                if (report.vectorIndex.readError)
-                    return palette.bad(line);
-                if (report.vectorIndex.generation === undefined || report.vectorIndex.chunkCount === undefined) {
-                    return palette.dim(line);
-                }
-                return line;
-            },
-        });
-        rows.push({
-            label: "index embedder",
-            value: () => formatIndexEmbedderLine(report, palette),
-        });
-    }
-    rows.push({
-        label: "configured embedder",
-        value: () => `${report.embedder.provider}/${report.embedder.model} (${report.embedder.dim}d)`,
-    });
-    return rows;
-}
-export function formatMemoryStatusSummary(report, palette, accent) {
-    const parts = [
-        accent("pi-memory"),
-        palette.dim(`entries=${report.memory.entryCount}`),
-        report.sidecar.running ? palette.ok("sidecar up") : palette.bad("sidecar down"),
-    ];
-    if (!report.vectorIndex.exists) {
-        parts.push(palette.dim("no index"));
-    }
-    else {
-        const vec = formatVectorIndexLine(report);
-        if (report.vectorIndex.readError) {
-            parts.push(palette.bad(vec));
-        }
-        else if (report.vectorIndex.generation === undefined || report.vectorIndex.chunkCount === undefined) {
-            parts.push(palette.dim(vec));
-        }
-        else {
-            parts.push(vec);
-        }
-    }
-    return parts.join(palette.dim(" · "));
-}
-export function formatMemoryStatusLines(report) {
-    return memoryStatusRows(report).map(({ label, value }) => `${label.padEnd(16)} ${value()}`);
-}
-export function formatMemoryStatusTuiLines(report, palette, theme) {
-    return memoryStatusRows(report, palette).map(({ label, value }) => `${theme.fg("muted", label.padEnd(16))} ${value()}`);
-}
+import { cliStatusPalette } from "./theme.js";
+import { printMemoryStatusRows } from "../status/format.js";
+import { gatherMemoryStatus } from "../status/gather.js";
+export { gatherMemoryStatus } from "../status/gather.js";
+export { formatMemoryStatusLines, formatMemoryStatusSummary, formatMemoryStatusTuiLines, piStatusPalette, } from "../status/format.js";
 export function printMemoryStatus(report, log) {
-    const palette = cliStatusPalette();
-    for (const { label, value } of memoryStatusRows(report, palette)) {
-        log.line(label, value());
-    }
+    printMemoryStatusRows(report, cliStatusPalette(), (label, value) => log.line(label, value));
 }
 export async function runStatusCommand(agentDir, log) {
     const report = await gatherMemoryStatus(agentDir);

package/dist/cli/theme.d.ts

@@ -1,3 +1,4 @@
+import type { StatusPalette } from "../status/types.js";
 export declare function paint(fn: (text: string) => string, text: string, stream?: NodeJS.WriteStream): string;
 export declare const theme: {
     prefix: (stream?: NodeJS.WriteStream) => string;
@@ -11,3 +12,4 @@ export declare const theme: {
     ok: (text: string, stream?: NodeJS.WriteStream) => string;
     bad: (text: string, stream?: NodeJS.WriteStream) => string;
 };
+export declare function cliStatusPalette(): StatusPalette;

package/dist/cli/theme.js

@@ -17,3 +17,11 @@ export const theme = {
     ok: (text, stream) => paint(chalk.green, text, stream),
     bad: (text, stream) => paint(chalk.red, text, stream),
 };
+export function cliStatusPalette() {
+    return {
+        dim: theme.dim,
+        ok: theme.ok,
+        bad: theme.bad,
+        warn: theme.warn,
+    };
+}

package/dist/cli.js

@@ -6,6 +6,7 @@ import { runConsolidateCommand, runDrainShutdownQueueCommand, runMaintenanceComm
 import { createCliLog } from "./cli/log.js";
 import { CLI_HELP, parseCliArgs } from "./cli/parseArgs.js";
 import { runInitCommand } from "./cli/init.js";
+import { runSchedulerSyncCommand } from "./cli/schedulerSync.js";
 import { runStatusCommand } from "./cli/status.js";
 import { theme } from "./cli/theme.js";
 import { createMemoryStore } from "./store/index.js";
@@ -24,6 +25,10 @@ async function main() {
         const log = createCliLog({ verbose: true, debug: parsed.options.verbose });
         return runInitCommand(agentDir, log);
     }
+    if (parsed.command === "scheduler-sync") {
+        const log = createCliLog({ verbose: true, debug: parsed.options.verbose });
+        return runSchedulerSyncCommand(agentDir, log);
+    }
     if (parsed.command === "status") {
         const log = createCliLog({ verbose: true, debug: parsed.options.verbose });
         return runStatusCommand(agentDir, log);

package/dist/commands/status.js

@@ -1,4 +1,4 @@
-import { formatMemoryStatusLines, gatherMemoryStatus, } from "../cli/status.js";
+import { formatMemoryStatusLines, gatherMemoryStatus, } from "../status/index.js";
 import { resolveMemoryAgentDir } from "../config/agentDir.js";
 import { createMemoryStatusWidget } from "../ui/memoryStatusWidget.js";
 import { parseMemoryStatusArgs } from "./parseMemoryStatusArgs.js";
@@ -7,7 +7,7 @@ export function resetMemoryStatusWidgetState() {
     memoryStatusWidgetState = null;
 }
 function renderMemoryStatusWidget(ctx, state) {
-    ctx.ui.setWidget("pi-memory-status", (tui, theme) => createMemoryStatusWidget(tui, theme, state), {
+    ctx.ui.setWidget("pi-memory-status", (_tui, theme) => createMemoryStatusWidget(theme, state), {
         placement: "aboveEditor",
     });
 }

package/dist/compact/parseMemoryExport.js

@@ -1,4 +1,5 @@
 import { parseMemoryMarkdown } from "../store/markdown/parse.js";
+import { entryDedupeKey } from "../utils/memory/index.js";
 import { MEMORY_SECTIONS } from "../store/types.js";
 const MEMORY_EXPORT_HEADER_RE = /^##\s+Memory Export\s*$/im;
 function extractMemoryExportBlock(summary) {
@@ -46,7 +47,7 @@ export function parseMemoryExport(summary) {
     const entries = parseExportBullets(exportBody);
     const seen = new Set();
     return entries.filter((entry) => {
-        const key = `${entry.section}\0${entry.content.trim()}`;
+        const key = entryDedupeKey(entry);
         if (seen.has(key))
             return false;
         seen.add(key);

package/dist/compact/register.js

@@ -1,4 +1,4 @@
-import { isSubagentSession } from "../preflight/session.js";
+import { isSubagentSession } from "../utils/session/index.js";
 import { runDualPurposeCompactionSummary } from "./runSummary.js";
 export function registerCompactHandlers(pi, deps) {
     pi.on("session_before_compact", async (event, ctx) => {

package/dist/compact/runSummary.js

@@ -1,21 +1,6 @@
 import { convertToLlm, serializeConversation } from "@earendil-works/pi-coding-agent";
-import { stripPrivateMemory } from "../preflight/strip.js";
+import { stripPrivateMemoryFromMessages } from "../utils/memory/index.js";
 import { buildCompactionSummaryPrompt } from "./summaryPrompt.js";
-function stripPrivateMemoryFromMessages(messages) {
-    return messages.map((message) => {
-        if (message.role !== "user")
-            return message;
-        if (typeof message.content === "string") {
-            return { ...message, content: stripPrivateMemory(message.content) };
-        }
-        return {
-            ...message,
-            content: message.content.map((block) => block.type === "text"
-                ? { ...block, text: stripPrivateMemory(block.text) }
-                : block),
-        };
-    });
-}
 export async function runDualPurposeCompactionSummary(preparation, llm, signal) {
     const allMessages = stripPrivateMemoryFromMessages([
         ...preparation.messagesToSummarize,

package/dist/compact/subagentDelta.js

@@ -1,10 +1,8 @@
-function entryKey(entry) {
-    return `${entry.section}\0${entry.content.trim()}`;
-}
+import { entryDedupeKey } from "../utils/memory/index.js";
 /** Keep only Memory Export facts not already present in MEMORY (parent/root dedup). */
 export function filterCompactionDelta(entries, existing) {
-    const known = new Set(existing.map(entryKey));
-    return entries.filter((entry) => !known.has(entryKey(entry)));
+    const known = new Set(existing.map(entryDedupeKey));
+    return entries.filter((entry) => !known.has(entryDedupeKey(entry)));
 }
 /** Subagent clone: summary had export bullets but nothing new vs parent memory. */
 export function shouldSkipSubagentCompactionIngest(parsed, delta) {

package/dist/consolidate/index.d.ts

@@ -1,4 +1,5 @@
 export { dedupeEntries } from "./mergeEntries.js";
 export { mergeEntriesWithLlm } from "./mergeWithLlm.js";
+export { mergeMemoryEntries, scheduleMergeMemoryEntriesInBackground, } from "./mergeMemoryEntries.js";
 export { runConsolidateJob, type RunConsolidateJobOptions, type RunConsolidateJobResult } from "./runJob.js";
 export { createConsolidateScheduler, startConsolidateInterval, type ConsolidateScheduler } from "./scheduler.js";

package/dist/consolidate/index.js

@@ -1,4 +1,5 @@
 export { dedupeEntries } from "./mergeEntries.js";
 export { mergeEntriesWithLlm } from "./mergeWithLlm.js";
+export { mergeMemoryEntries, scheduleMergeMemoryEntriesInBackground, } from "./mergeMemoryEntries.js";
 export { runConsolidateJob } from "./runJob.js";
 export { createConsolidateScheduler, startConsolidateInterval } from "./scheduler.js";

package/dist/consolidate/mergeEntries.js

@@ -1,5 +1,5 @@
-import orderBy from "lodash/orderBy.js";
-import { entryDedupeKey } from "./entryKey.js";
+import { orderBy } from "es-toolkit";
+import { entryDedupeKey } from "../utils/memory/index.js";
 import { MEMORY_SECTIONS } from "../store/types.js";
 const SECTION_RANK = new Map(MEMORY_SECTIONS.map((section, index) => [section, index]));
 /** Rule-based dedupe before optional LLM merge. Prefer user-authored on conflict. */
@@ -12,5 +12,5 @@ export function dedupeEntries(entries) {
             byKey.set(key, entry);
         }
     }
-    return orderBy([...byKey.values()], [(entry) => SECTION_RANK.get(entry.section) ?? MEMORY_SECTIONS.length]);
+    return orderBy([...byKey.values()], [(entry) => SECTION_RANK.get(entry.section) ?? MEMORY_SECTIONS.length], ["asc"]);
 }

package/dist/consolidate/mergeMemoryEntries.d.ts

@@ -0,0 +1,8 @@
+import type { LlmClient } from "../adapters/llm/types.js";
+import type { ConsolidateStoreAccess } from "../store/consolidatePort.js";
+/** Dedupe and optionally LLM-merge MEMORY entries, then rewrite Ground Truth under lock. */
+export declare function mergeMemoryEntries(store: ConsolidateStoreAccess, llm: LlmClient): Promise<void>;
+/** Fire-and-forget wrapper around {@link mergeMemoryEntries}. */
+export declare function scheduleMergeMemoryEntriesInBackground(store: ConsolidateStoreAccess, llm: LlmClient, opts?: {
+    onComplete?: () => void | Promise<void>;
+}): void;

package/dist/consolidate/mergeMemoryEntries.js

@@ -0,0 +1,23 @@
+import { dedupeEntries } from "./mergeEntries.js";
+import { mergeEntriesWithLlm } from "./mergeWithLlm.js";
+/** Dedupe and optionally LLM-merge MEMORY entries, then rewrite Ground Truth under lock. */
+export async function mergeMemoryEntries(store, llm) {
+    if (store.isConsolidating())
+        return;
+    await store.rewriteMemoryUnderLock(async (entries) => {
+        let merged = dedupeEntries(entries);
+        try {
+            merged = await mergeEntriesWithLlm(merged, llm);
+        }
+        catch {
+            // rule-based dedupe only
+        }
+        return merged;
+    });
+}
+/** Fire-and-forget wrapper around {@link mergeMemoryEntries}. */
+export function scheduleMergeMemoryEntriesInBackground(store, llm, opts = {}) {
+    void mergeMemoryEntries(store, llm)
+        .then(() => opts.onComplete?.())
+        .catch(() => { });
+}

package/dist/consolidate/mergePrompt.js

@@ -1,8 +1,8 @@
-import groupBy from "lodash/groupBy.js";
+import { groupBy } from "es-toolkit";
 import { formatEntryLine, formatSectionHeader } from "../store/markdown/format.js";
 import { MEMORY_SECTIONS } from "../store/types.js";
 export function formatEntriesForConsolidation(entries) {
-    const grouped = groupBy(entries, "section");
+    const grouped = groupBy(entries, (entry) => entry.section);
     const lines = [];
     for (const section of MEMORY_SECTIONS) {
         const sectionEntries = grouped[section] ?? [];

package/dist/consolidate/mergeWithLlm.js

@@ -1,6 +1,6 @@
-import keyBy from "lodash/keyBy.js";
+import { keyBy } from "es-toolkit";
 import { parseMemoryMarkdown } from "../store/markdown/parse.js";
-import { entryDedupeKey } from "./entryKey.js";
+import { entryDedupeKey } from "../utils/memory/index.js";
 import { buildConsolidateMergePrompt, formatEntriesForConsolidation } from "./mergePrompt.js";
 import { dedupeEntries } from "./mergeEntries.js";
 function preserveUserAuthored(original, merged) {

package/dist/consolidate/runJob.d.ts

@@ -1,5 +1,5 @@
 import type { LlmClient } from "../adapters/llm/types.js";
-import type { MemoryStore } from "../store/memoryStore.js";
+import type { ConsolidateStoreAccess } from "../store/consolidatePort.js";
 export type ConsolidateJobStats = {
     entriesBefore: number;
     entriesAfter: number;
@@ -8,7 +8,7 @@ export type ConsolidateJobStats = {
     indexGeneration?: number;
 };
 export type RunConsolidateJobOptions = {
-    store: MemoryStore;
+    store: ConsolidateStoreAccess;
     agentDir: string;
     llm?: LlmClient | null;
     cronFired?: boolean;

package/dist/consolidate/runJob.js

@@ -1,7 +1,5 @@
-import { sidecarQueryCache } from "../preflight/queryCache.js";
-import { ensureSidecarRunning } from "../sidecar/sidecarManager.js";
-import { reindex } from "../sidecar/client.js";
-import { resolveSidecarPaths } from "../sidecar/paths.js";
+import { syncSidecarIndex } from "../sidecar/syncIndex.js";
+import { mergeMemoryEntries } from "./mergeMemoryEntries.js";
 const NOOP_LLM = {
     async complete() {
         throw new Error("LLM unavailable");
@@ -9,12 +7,15 @@ const NOOP_LLM = {
 };
 export async function runConsolidateJob(opts) {
     const llm = opts.llm ?? NOOP_LLM;
+    if (opts.store.isConsolidating()) {
+        return { status: "skipped", reason: "already_consolidating" };
+    }
     if (!opts.force && !(await opts.store.shouldConsolidate(undefined, opts.cronFired))) {
         return { status: "skipped", reason: "conditions_not_met" };
     }
     const before = await opts.store.getStats();
     try {
-        await opts.store.consolidate(llm);
+        await mergeMemoryEntries(opts.store, llm);
         let indexGeneration;
         if (opts.reindex !== false) {
             indexGeneration = await syncSidecarIndex(opts.agentDir, opts.store);
@@ -38,10 +39,3 @@ export async function runConsolidateJob(opts) {
         };
     }
 }
-async function syncSidecarIndex(agentDir, store) {
-    const sidecar = resolveSidecarPaths(agentDir);
-    await ensureSidecarRunning(sidecar);
-    const result = await reindex(sidecar.socketPath, await store.exportForIndex());
-    sidecarQueryCache.onReindexComplete(agentDir, result.index_generation);
-    return result.index_generation;
-}

package/dist/consolidate/scheduler.d.ts

@@ -1,5 +1,5 @@
 import type { LlmClient } from "../adapters/llm/types.js";
-import type { MemoryStore } from "../store/memoryStore.js";
+import type { ConsolidateStoreAccess } from "../store/consolidatePort.js";
 export type ConsolidateScheduler = {
     schedule(): void;
     runNow(opts?: {
@@ -7,7 +7,7 @@ export type ConsolidateScheduler = {
     }): Promise<void>;
 };
 export declare function createConsolidateScheduler(opts: {
-    getStore(): MemoryStore | null;
+    getStore(): ConsolidateStoreAccess | null;
     getAgentDir(): string | null;
     getLlm(): LlmClient | null;
     debounceMs?: number;

package/dist/consolidate/scheduler.js

@@ -1,4 +1,4 @@
-import debounce from "lodash/debounce.js";
+import { debounce } from "es-toolkit";
 import { DEFAULT_CONSOLIDATE_CHECK_INTERVAL_MS, DEFAULT_CONSOLIDATE_DEBOUNCE_MS } from "../constants/timing.js";
 import { runConsolidateJob } from "./runJob.js";
 export function createConsolidateScheduler(opts) {

package/dist/constants/env.d.ts

@@ -30,6 +30,7 @@ export declare const ENV_KEYS: {
     readonly AGENT_DIR: "PI_MEMORY_AGENT_DIR";
     readonly ENV_FILE: "PI_MEMORY_ENV_FILE";
     readonly DEBUG: "PI_MEMORY_DEBUG";
+    readonly SKIP_SCHEDULER_SYNC: "PI_MEMORY_SKIP_SCHEDULER_SYNC";
 };
 /** Fallback OPENAI_API_KEY when PI_MEMORY_OPENAI_API_KEY unset. */
 export declare const FALLBACK_OPENAI_API_KEY_ENV = "OPENAI_API_KEY";

package/dist/constants/env.js

@@ -29,6 +29,7 @@ export const ENV_KEYS = {
     AGENT_DIR: "PI_MEMORY_AGENT_DIR",
     ENV_FILE: "PI_MEMORY_ENV_FILE",
     DEBUG: "PI_MEMORY_DEBUG",
+    SKIP_SCHEDULER_SYNC: "PI_MEMORY_SKIP_SCHEDULER_SYNC",
 };
 /** Fallback OPENAI_API_KEY when PI_MEMORY_OPENAI_API_KEY unset. */
 export const FALLBACK_OPENAI_API_KEY_ENV = "OPENAI_API_KEY";

package/dist/constants/paths.d.ts

@@ -8,11 +8,13 @@ export declare const SIDECAR_SOCKET_FILE = "memory.sock";
 export declare const SIDECAR_DB_FILE = "memory.vec.sqlite";
 export declare const SIDECAR_PID_SUFFIX = ".pid";
 export declare const SIDECAR_SPAWN_LOCK_FILE = "sidecar.spawn.lock";
-/** Consolidate / maintenance scheduler log basenames (under ~/.pi/logs). */
+/** Consolidate / maintenance scheduler log basenames (under `<agentDir>/logs`). */
 export declare const CONSOLIDATE_LOG_FILE = "maintenance.log";
 export declare const CONSOLIDATE_ERR_LOG_FILE = "maintenance.err.log";
 /** OS scheduler identifiers. */
 export declare const LAUNCHD_LABEL = "com.pi.memory.maintenance";
+/** Pre-0.3.x / dev labels removed during scheduler sync. */
+export declare const LEGACY_LAUNCHD_LABELS: readonly ["dev.pi.memory-consolidate", "com.pi.memory.consolidate"];
 export declare const SCHTASKS_TASK_NAME = "PiMemoryMaintenance";
 export declare const SCHEDULER_TEMPLATE_FILES: {
     readonly launchd: "com.pi.memory.consolidate.plist.example";

package/dist/constants/paths.js

@@ -8,11 +8,16 @@ export const SIDECAR_SOCKET_FILE = "memory.sock";
 export const SIDECAR_DB_FILE = "memory.vec.sqlite";
 export const SIDECAR_PID_SUFFIX = ".pid";
 export const SIDECAR_SPAWN_LOCK_FILE = "sidecar.spawn.lock";
-/** Consolidate / maintenance scheduler log basenames (under ~/.pi/logs). */
+/** Consolidate / maintenance scheduler log basenames (under `<agentDir>/logs`). */
 export const CONSOLIDATE_LOG_FILE = "maintenance.log";
 export const CONSOLIDATE_ERR_LOG_FILE = "maintenance.err.log";
 /** OS scheduler identifiers. */
 export const LAUNCHD_LABEL = "com.pi.memory.maintenance";
+/** Pre-0.3.x / dev labels removed during scheduler sync. */
+export const LEGACY_LAUNCHD_LABELS = [
+    "dev.pi.memory-consolidate",
+    "com.pi.memory.consolidate",
+];
 export const SCHTASKS_TASK_NAME = "PiMemoryMaintenance";
 export const SCHEDULER_TEMPLATE_FILES = {
     launchd: "com.pi.memory.consolidate.plist.example",

package/dist/extension/createMemoryRuntime.d.ts

@@ -0,0 +1,3 @@
+import type { CreateMemoryRuntimeOptions, MemoryRuntime } from "./types.js";
+export declare function createMemoryRuntime(opts: CreateMemoryRuntimeOptions): MemoryRuntime;
+export type { CreateMemoryRuntimeOptions, MemoryRuntime, TurnPreflight } from "./types.js";