agenr 0.8.0 → 0.8.2

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [0.8.2] - 2026-02-22
+
+### Added
+- Per-platform extraction prompt addenda for codex/claude-code (code session rules with inline confidence caps) and plaud (meeting transcript rules)
+- plaud added to KNOWLEDGE_PLATFORMS and normalizeKnowledgePlatform
+- applyConfidenceCap now enforces importance cap for codex and claude-code platforms
+- All CLI --platform help text updated to include plaud
+
+## [0.8.1] - 2026-02-22
+
+### Fixed
+- fix(openclaw-plugin): sync plugin version in openclaw.plugin.json to match npm package (was stale at 0.7.21, now 0.8.1)
+
 ## [0.8.0] - 2026-02-22
 
 ### Added

package/dist/chunk-JSPUNQPG.js

@@ -0,0 +1,608 @@
+// src/version.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var APP_VERSION = (() => {
+  try {
+    const raw = require2("../package.json");
+    if (typeof raw.version === "string" && raw.version.trim().length > 0) {
+      return raw.version.trim();
+    }
+  } catch {
+  }
+  const fromEnv = process.env.npm_package_version;
+  if (typeof fromEnv === "string" && fromEnv.trim().length > 0) {
+    return fromEnv.trim();
+  }
+  return "0.0.0";
+})();
+
+// src/db/client.ts
+import { createClient } from "@libsql/client";
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+
+// src/db/schema.ts
+var CREATE_IDX_ENTRIES_EMBEDDING_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_entries_embedding ON entries (
+    libsql_vector_idx(embedding, 'metric=cosine', 'compress_neighbors=float8', 'max_neighbors=50')
+  )
+`;
+var CREATE_ENTRIES_FTS_TABLE_SQL = `
+  CREATE VIRTUAL TABLE IF NOT EXISTS entries_fts USING fts5(
+    content, subject, content=entries, content_rowid=rowid
+  )
+`;
+var CREATE_ENTRIES_FTS_TRIGGER_AI_SQL = `
+  CREATE TRIGGER IF NOT EXISTS entries_ai AFTER INSERT ON entries BEGIN
+    INSERT INTO entries_fts(rowid, content, subject) VALUES (new.rowid, new.content, new.subject);
+  END
+`;
+var CREATE_ENTRIES_FTS_TRIGGER_AD_SQL = `
+  CREATE TRIGGER IF NOT EXISTS entries_ad AFTER DELETE ON entries BEGIN
+    INSERT INTO entries_fts(entries_fts, rowid, content, subject) VALUES ('delete', old.rowid, old.content, old.subject);
+  END
+`;
+var CREATE_ENTRIES_FTS_TRIGGER_AU_SQL = `
+  CREATE TRIGGER IF NOT EXISTS entries_au AFTER UPDATE ON entries BEGIN
+    INSERT INTO entries_fts(entries_fts, rowid, content, subject) VALUES ('delete', old.rowid, old.content, old.subject);
+    INSERT INTO entries_fts(rowid, content, subject) VALUES (new.rowid, new.content, new.subject);
+  END
+`;
+var REBUILD_ENTRIES_FTS_SQL = "INSERT INTO entries_fts(entries_fts) VALUES ('rebuild')";
+var LEGACY_IMPORTANCE_BACKFILL_META_KEY = "legacy_importance_backfill_from_confidence_v1";
+var CREATE_TABLE_AND_TRIGGER_STATEMENTS = [
+  `
+  CREATE TABLE IF NOT EXISTS _meta (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  )
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS entries (
+    id TEXT PRIMARY KEY,
+    type TEXT NOT NULL,
+    subject TEXT NOT NULL,
+    canonical_key TEXT,
+    content TEXT NOT NULL,
+    importance INTEGER NOT NULL,
+    expiry TEXT NOT NULL,
+    scope TEXT DEFAULT 'private',
+    platform TEXT DEFAULT NULL,
+    project TEXT DEFAULT NULL,
+    source_file TEXT,
+    source_context TEXT,
+    embedding F32_BLOB(1024),
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    last_recalled_at TEXT,
+    recall_count INTEGER DEFAULT 0,
+    confirmations INTEGER DEFAULT 0,
+    contradictions INTEGER DEFAULT 0,
+    superseded_by TEXT,
+    content_hash TEXT,
+    merged_from INTEGER DEFAULT 0,
+    consolidated_at TEXT,
+    retired INTEGER NOT NULL DEFAULT 0,
+    retired_at TEXT,
+    retired_reason TEXT,
+    suppressed_contexts TEXT,
+    FOREIGN KEY (superseded_by) REFERENCES entries(id)
+  )
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS tags (
+    entry_id TEXT NOT NULL,
+    tag TEXT NOT NULL,
+    PRIMARY KEY (entry_id, tag),
+    FOREIGN KEY (entry_id) REFERENCES entries(id) ON DELETE CASCADE
+  )
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS relations (
+    id TEXT PRIMARY KEY,
+    source_id TEXT NOT NULL,
+    target_id TEXT NOT NULL,
+    relation_type TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    FOREIGN KEY (source_id) REFERENCES entries(id) ON DELETE CASCADE,
+    FOREIGN KEY (target_id) REFERENCES entries(id) ON DELETE CASCADE
+  )
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS ingest_log (
+    id TEXT PRIMARY KEY,
+    file_path TEXT NOT NULL,
+    ingested_at TEXT NOT NULL,
+    entries_added INTEGER NOT NULL,
+    entries_updated INTEGER NOT NULL,
+    entries_skipped INTEGER NOT NULL,
+    duration_ms INTEGER NOT NULL,
+    content_hash TEXT,
+    entries_superseded INTEGER NOT NULL DEFAULT 0,
+    dedup_llm_calls INTEGER NOT NULL DEFAULT 0
+  )
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS entry_sources (
+    merged_entry_id TEXT NOT NULL REFERENCES entries(id),
+    source_entry_id TEXT NOT NULL REFERENCES entries(id),
+    original_confirmations INTEGER NOT NULL DEFAULT 0,
+    original_recall_count INTEGER NOT NULL DEFAULT 0,
+    original_created_at TEXT,
+    PRIMARY KEY (merged_entry_id, source_entry_id)
+  )
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS signal_watermarks (
+    consumer_id TEXT PRIMARY KEY,
+    last_received_seq INTEGER NOT NULL DEFAULT 0,
+    updated_at TEXT NOT NULL
+  )
+  `,
+  CREATE_ENTRIES_FTS_TABLE_SQL,
+  CREATE_ENTRIES_FTS_TRIGGER_AI_SQL,
+  CREATE_ENTRIES_FTS_TRIGGER_AD_SQL,
+  CREATE_ENTRIES_FTS_TRIGGER_AU_SQL
+];
+var CREATE_INDEX_STATEMENTS = [
+  CREATE_IDX_ENTRIES_EMBEDDING_SQL,
+  "CREATE INDEX IF NOT EXISTS idx_entries_type ON entries(type)",
+  "CREATE INDEX IF NOT EXISTS idx_entries_type_canonical_key ON entries(type, canonical_key)",
+  "CREATE INDEX IF NOT EXISTS idx_entries_expiry ON entries(expiry)",
+  "CREATE INDEX IF NOT EXISTS idx_entries_scope ON entries(scope)",
+  "CREATE INDEX IF NOT EXISTS idx_entries_platform ON entries(platform)",
+  "CREATE INDEX IF NOT EXISTS idx_entries_project ON entries(project)",
+  "CREATE INDEX IF NOT EXISTS idx_entries_created ON entries(created_at)",
+  "CREATE INDEX IF NOT EXISTS idx_entries_superseded ON entries(superseded_by)",
+  "CREATE INDEX IF NOT EXISTS idx_entries_content_hash ON entries(content_hash)",
+  "CREATE INDEX IF NOT EXISTS idx_tags_tag ON tags(tag)",
+  "CREATE INDEX IF NOT EXISTS idx_relations_source ON relations(source_id)",
+  "CREATE INDEX IF NOT EXISTS idx_relations_target ON relations(target_id)",
+  "CREATE UNIQUE INDEX IF NOT EXISTS idx_ingest_log_file_hash ON ingest_log(file_path, content_hash)"
+];
+var COLUMN_MIGRATIONS = [
+  {
+    table: "entries",
+    column: "importance",
+    sql: "ALTER TABLE entries ADD COLUMN importance INTEGER NOT NULL DEFAULT 5"
+  },
+  {
+    table: "entries",
+    column: "canonical_key",
+    sql: "ALTER TABLE entries ADD COLUMN canonical_key TEXT"
+  },
+  {
+    table: "entries",
+    column: "scope",
+    sql: "ALTER TABLE entries ADD COLUMN scope TEXT DEFAULT 'private'"
+  },
+  {
+    table: "entries",
+    column: "content_hash",
+    sql: "ALTER TABLE entries ADD COLUMN content_hash TEXT"
+  },
+  {
+    table: "entries",
+    column: "merged_from",
+    sql: "ALTER TABLE entries ADD COLUMN merged_from INTEGER DEFAULT 0"
+  },
+  {
+    table: "entries",
+    column: "consolidated_at",
+    sql: "ALTER TABLE entries ADD COLUMN consolidated_at TEXT"
+  },
+  {
+    table: "entries",
+    column: "platform",
+    sql: "ALTER TABLE entries ADD COLUMN platform TEXT DEFAULT NULL"
+  },
+  {
+    table: "entries",
+    column: "project",
+    sql: "ALTER TABLE entries ADD COLUMN project TEXT DEFAULT NULL"
+  },
+  {
+    table: "entries",
+    column: "retired",
+    sql: "ALTER TABLE entries ADD COLUMN retired INTEGER NOT NULL DEFAULT 0"
+  },
+  {
+    table: "entries",
+    column: "idx_entries_retired",
+    sql: "CREATE INDEX IF NOT EXISTS idx_entries_retired ON entries (retired) WHERE retired = 0",
+    isIndex: true
+  },
+  {
+    table: "entries",
+    column: "retired_at",
+    sql: "ALTER TABLE entries ADD COLUMN retired_at TEXT"
+  },
+  {
+    table: "entries",
+    column: "retired_reason",
+    sql: "ALTER TABLE entries ADD COLUMN retired_reason TEXT"
+  },
+  {
+    table: "entries",
+    column: "suppressed_contexts",
+    sql: "ALTER TABLE entries ADD COLUMN suppressed_contexts TEXT"
+  },
+  {
+    table: "ingest_log",
+    column: "content_hash",
+    sql: "ALTER TABLE ingest_log ADD COLUMN content_hash TEXT"
+  },
+  {
+    table: "ingest_log",
+    column: "entries_superseded",
+    sql: "ALTER TABLE ingest_log ADD COLUMN entries_superseded INTEGER NOT NULL DEFAULT 0"
+  },
+  {
+    table: "ingest_log",
+    column: "dedup_llm_calls",
+    sql: "ALTER TABLE ingest_log ADD COLUMN dedup_llm_calls INTEGER NOT NULL DEFAULT 0"
+  },
+  {
+    table: "entry_sources",
+    column: "original_created_at",
+    sql: "ALTER TABLE entry_sources ADD COLUMN original_created_at TEXT"
+  },
+  {
+    table: "entries",
+    column: "recall_intervals",
+    sql: "ALTER TABLE entries ADD COLUMN recall_intervals TEXT DEFAULT NULL"
+  }
+];
+async function initSchema(client) {
+  for (const statement of CREATE_TABLE_AND_TRIGGER_STATEMENTS) {
+    await client.execute(statement);
+  }
+  let willRunLegacyBackfill = false;
+  try {
+    const earlyEntriesInfo = await client.execute("PRAGMA table_info(entries)");
+    const earlyColumns = new Set(earlyEntriesInfo.rows.map((row) => String(row.name)));
+    if (earlyColumns.has("confidence")) {
+      const sentinel = await client.execute({
+        sql: "SELECT 1 AS found FROM _meta WHERE key = ? LIMIT 1",
+        args: [LEGACY_IMPORTANCE_BACKFILL_META_KEY]
+      });
+      const alreadyBackfilled = sentinel.rows.length > 0;
+      willRunLegacyBackfill = !alreadyBackfilled;
+    }
+  } catch {
+  }
+  try {
+    const entriesCountResult = await client.execute("SELECT COUNT(*) AS count FROM entries");
+    const entriesCount = Number(entriesCountResult.rows[0]?.count ?? 0);
+    const ftsCountResult = await client.execute("SELECT COUNT(*) AS count FROM entries_fts");
+    const ftsCount = Number(ftsCountResult.rows[0]?.count ?? 0);
+    if (entriesCount > 0 && ftsCount === 0 && !willRunLegacyBackfill) {
+      await client.execute(REBUILD_ENTRIES_FTS_SQL);
+    }
+  } catch {
+  }
+  for (const migration of COLUMN_MIGRATIONS) {
+    if (migration.isIndex) {
+      const existingIndex = await client.execute({
+        sql: "SELECT name FROM sqlite_master WHERE type='index' AND name=?",
+        args: [migration.column]
+      });
+      if (existingIndex.rows.length > 0) {
+        continue;
+      }
+      await client.execute(migration.sql);
+      continue;
+    }
+    const info = await client.execute(`PRAGMA table_info(${migration.table})`);
+    const hasColumn = info.rows.some((row) => String(row.name) === migration.column);
+    if (!hasColumn) {
+      await client.execute(migration.sql);
+    }
+  }
+  const entriesInfo = await client.execute("PRAGMA table_info(entries)");
+  const entryColumns = new Set(entriesInfo.rows.map((row) => String(row.name)));
+  const backfillSentinel = await client.execute({
+    sql: "SELECT 1 AS found FROM _meta WHERE key = ? LIMIT 1",
+    args: [LEGACY_IMPORTANCE_BACKFILL_META_KEY]
+  });
+  const legacyBackfillDone = backfillSentinel.rows.length > 0;
+  if (entryColumns.has("confidence") && entryColumns.has("importance") && !legacyBackfillDone) {
+    try {
+      await client.execute("DROP TRIGGER IF EXISTS entries_ai");
+      await client.execute("DROP TRIGGER IF EXISTS entries_ad");
+      await client.execute("DROP TRIGGER IF EXISTS entries_au");
+      await client.execute("DROP TABLE IF EXISTS entries_fts");
+    } catch {
+    }
+    await client.execute(`
+      UPDATE entries
+      SET importance = CASE lower(trim(confidence))
+        WHEN 'low' THEN 3
+        WHEN 'medium' THEN 6
+        WHEN 'high' THEN 8
+        ELSE
+          CASE
+            WHEN CAST(confidence AS INTEGER) BETWEEN 1 AND 10 THEN CAST(confidence AS INTEGER)
+            ELSE 5
+          END
+      END
+      WHERE importance = 5
+    `);
+    try {
+      await client.execute(CREATE_ENTRIES_FTS_TABLE_SQL);
+      await client.execute(CREATE_ENTRIES_FTS_TRIGGER_AI_SQL);
+      await client.execute(CREATE_ENTRIES_FTS_TRIGGER_AD_SQL);
+      await client.execute(CREATE_ENTRIES_FTS_TRIGGER_AU_SQL);
+      await client.execute(REBUILD_ENTRIES_FTS_SQL);
+    } catch {
+    }
+    try {
+      await client.execute({
+        sql: `
+          INSERT INTO _meta (key, value, updated_at)
+          VALUES (?, datetime('now'), datetime('now'))
+          ON CONFLICT(key) DO NOTHING
+        `,
+        args: [LEGACY_IMPORTANCE_BACKFILL_META_KEY]
+      });
+    } catch {
+    }
+  }
+  for (const statement of CREATE_INDEX_STATEMENTS) {
+    await client.execute(statement);
+  }
+  await client.execute({
+    sql: `
+      INSERT INTO _meta (key, value, updated_at)
+      VALUES ('db_created_at', datetime('now'), datetime('now'))
+      ON CONFLICT(key) DO NOTHING
+    `,
+    args: []
+  });
+  await client.execute({
+    sql: `
+      INSERT INTO _meta (key, value, updated_at)
+      VALUES ('schema_version', ?, datetime('now'))
+      ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
+    `,
+    args: [APP_VERSION]
+  });
+}
+async function resetDb(db) {
+  const foreignKeysResult = await db.execute("PRAGMA foreign_keys");
+  const foreignKeysRow = foreignKeysResult.rows[0];
+  const previousForeignKeys = Number(foreignKeysRow?.foreign_keys ?? (foreignKeysRow ? Object.values(foreignKeysRow)[0] : 1)) === 0 ? 0 : 1;
+  await db.execute("PRAGMA foreign_keys=OFF");
+  try {
+    const schemaObjects = await db.execute(`
+      SELECT type, name
+      FROM sqlite_master
+      WHERE name NOT LIKE 'sqlite_%'
+      ORDER BY
+        CASE type
+          WHEN 'trigger' THEN 1
+          WHEN 'index' THEN 2
+          WHEN 'table' THEN 3
+          ELSE 4
+        END,
+        name
+    `);
+    for (const row of schemaObjects.rows) {
+      const type = String(row.type ?? "");
+      const name = String(row.name ?? "");
+      if (!type || !name) {
+        continue;
+      }
+      const safeName = name.replace(/"/g, '""');
+      if (type === "trigger") {
+        await db.execute(`DROP TRIGGER IF EXISTS "${safeName}"`);
+        continue;
+      }
+      if (type === "index") {
+        await db.execute(`DROP INDEX IF EXISTS "${safeName}"`);
+        continue;
+      }
+      if (type === "table") {
+        await db.execute(`DROP TABLE IF EXISTS "${safeName}"`);
+      }
+    }
+    await initSchema(db);
+  } finally {
+    await db.execute(`PRAGMA foreign_keys=${previousForeignKeys === 0 ? "OFF" : "ON"}`);
+  }
+}
+
+// src/db/client.ts
+var DEFAULT_DB_PATH = path.join(os.homedir(), ".agenr", "knowledge.db");
+var walInitByClient = /* @__PURE__ */ new WeakMap();
+var didWarnVectorIndexCorruption = false;
+var WAL_CHECKPOINT_MAX_ATTEMPTS = 5;
+var WAL_CHECKPOINT_RETRY_MS = 50;
+function resolveUserPath(inputPath) {
+  if (!inputPath.startsWith("~")) {
+    return inputPath;
+  }
+  return path.join(os.homedir(), inputPath.slice(1));
+}
+function resolveDbPath(dbPath) {
+  if (dbPath === ":memory:") {
+    return dbPath;
+  }
+  return resolveUserPath(dbPath);
+}
+function normalizeBackupSourcePath(dbPath) {
+  const strippedDbPath = dbPath.startsWith("file:") ? dbPath.slice("file:".length) : dbPath;
+  return path.resolve(resolveDbPath(strippedDbPath));
+}
+function isErrnoCode(error, code) {
+  return error?.code === code;
+}
+async function copySidecarIfPresent(sourcePath, targetPath) {
+  try {
+    await fs.copyFile(sourcePath, targetPath);
+  } catch (error) {
+    if (isErrnoCode(error, "ENOENT")) {
+      return;
+    }
+    throw error;
+  }
+}
+function buildBackupPath(dbPath) {
+  const resolvedDbPath = normalizeBackupSourcePath(dbPath);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").replace(/Z$/, "");
+  return path.join(
+    path.dirname(resolvedDbPath),
+    `${path.basename(resolvedDbPath)}.backup-pre-reset-${timestamp}Z`
+  );
+}
+function getDb(dbPath) {
+  const rawPath = dbPath?.trim() ? dbPath.trim() : DEFAULT_DB_PATH;
+  if (rawPath === ":memory:") {
+    return createClient({ url: ":memory:" });
+  }
+  if (rawPath.startsWith("file:")) {
+    const client2 = createClient({ url: rawPath });
+    walInitByClient.set(
+      client2,
+      client2.execute("PRAGMA journal_mode=WAL").then(() => client2.execute("PRAGMA busy_timeout=3000")).then(() => void 0)
+    );
+    return client2;
+  }
+  const resolvedPath = resolveDbPath(rawPath);
+  const client = createClient({ url: `file:${resolvedPath}` });
+  walInitByClient.set(
+    client,
+    client.execute("PRAGMA journal_mode=WAL").then(() => client.execute("PRAGMA busy_timeout=3000")).then(() => void 0)
+  );
+  return client;
+}
+async function initDb(client) {
+  const walInit = walInitByClient.get(client);
+  if (walInit) {
+    await walInit;
+    await client.execute("PRAGMA wal_autocheckpoint=1000");
+  }
+  await initSchema(client);
+  try {
+    const hasEntries = await client.execute(
+      "SELECT 1 FROM entries WHERE embedding IS NOT NULL LIMIT 1"
+    );
+    if (hasEntries.rows.length > 0) {
+      await client.execute(`
+        SELECT count(*) FROM vector_top_k(
+          'idx_entries_embedding',
+          (SELECT embedding FROM entries WHERE embedding IS NOT NULL LIMIT 1),
+          1
+        )
+      `);
+    }
+  } catch {
+    if (!didWarnVectorIndexCorruption) {
+      didWarnVectorIndexCorruption = true;
+      process.stderr.write(
+        "\n\u26A0\uFE0F  Vector index may be corrupted. Run `agenr db rebuild-index` to fix.\n\n"
+      );
+    }
+  }
+}
+function toFiniteNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return Number(value);
+  }
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function extractBusyFromCheckpointRow(row) {
+  if (!row || typeof row !== "object") {
+    return null;
+  }
+  const record = row;
+  const busyValue = record.busy ?? Object.values(record)[0];
+  return toFiniteNumber(busyValue);
+}
+async function validatedWalCheckpoint(client) {
+  for (let attempt = 1; attempt <= WAL_CHECKPOINT_MAX_ATTEMPTS; attempt += 1) {
+    const result = await client.execute("PRAGMA wal_checkpoint(TRUNCATE)");
+    const busy = extractBusyFromCheckpointRow(result.rows[0]);
+    if (busy === null) {
+      throw new Error("WAL checkpoint returned an unexpected result and could not be validated.");
+    }
+    if (busy === 0) {
+      return;
+    }
+    if (attempt < WAL_CHECKPOINT_MAX_ATTEMPTS) {
+      await new Promise((resolve) => setTimeout(resolve, WAL_CHECKPOINT_RETRY_MS * attempt));
+      continue;
+    }
+    throw new Error(
+      `WAL checkpoint did not finish (busy=${busy}). Active readers are blocking backup safety.`
+    );
+  }
+}
+async function walCheckpoint(client) {
+  await validatedWalCheckpoint(client);
+}
+async function backupDb(dbPath) {
+  if (dbPath === ":memory:") {
+    throw new Error("Cannot back up in-memory databases.");
+  }
+  const checkpointClient = getDb(dbPath);
+  try {
+    await walCheckpoint(checkpointClient);
+  } finally {
+    closeDb(checkpointClient);
+  }
+  const resolvedDbPath = normalizeBackupSourcePath(dbPath);
+  const backupPath = buildBackupPath(dbPath);
+  await fs.copyFile(resolvedDbPath, backupPath);
+  await copySidecarIfPresent(`${resolvedDbPath}-wal`, `${backupPath}-wal`);
+  await copySidecarIfPresent(`${resolvedDbPath}-shm`, `${backupPath}-shm`);
+  return backupPath;
+}
+function closeDb(client) {
+  client.close();
+}
+
+// src/types.ts
+var KNOWLEDGE_TYPES = [
+  "fact",
+  "decision",
+  "preference",
+  "todo",
+  "relationship",
+  "event",
+  "lesson"
+];
+var IMPORTANCE_MIN = 1;
+var IMPORTANCE_MAX = 10;
+var EXPIRY_LEVELS = ["core", "permanent", "temporary"];
+var SCOPE_LEVELS = ["private", "personal", "public"];
+var KNOWLEDGE_PLATFORMS = ["openclaw", "claude-code", "codex", "plaud"];
+
+export {
+  APP_VERSION,
+  CREATE_IDX_ENTRIES_EMBEDDING_SQL,
+  initSchema,
+  resetDb,
+  DEFAULT_DB_PATH,
+  buildBackupPath,
+  getDb,
+  initDb,
+  walCheckpoint,
+  backupDb,
+  closeDb,
+  KNOWLEDGE_TYPES,
+  IMPORTANCE_MIN,
+  IMPORTANCE_MAX,
+  EXPIRY_LEVELS,
+  SCOPE_LEVELS,
+  KNOWLEDGE_PLATFORMS
+};

package/dist/cli-main.d.ts

@@ -5,7 +5,7 @@ import { Client } from '@libsql/client';
 declare const KNOWLEDGE_TYPES: readonly ["fact", "decision", "preference", "todo", "relationship", "event", "lesson"];
 declare const EXPIRY_LEVELS: readonly ["core", "permanent", "temporary"];
 declare const SCOPE_LEVELS: readonly ["private", "personal", "public"];
-declare const KNOWLEDGE_PLATFORMS: readonly ["openclaw", "claude-code", "codex"];
+declare const KNOWLEDGE_PLATFORMS: readonly ["openclaw", "claude-code", "codex", "plaud"];
 type KnowledgeType = (typeof KNOWLEDGE_TYPES)[number];
 type Expiry = (typeof EXPIRY_LEVELS)[number];
 type Scope = (typeof SCOPE_LEVELS)[number];

package/dist/cli-main.js

@@ -16,7 +16,7 @@ import {
   initSchema,
   resetDb,
   walCheckpoint
-} from "./chunk-VJ2WB7JG.js";
+} from "./chunk-JSPUNQPG.js";
 
 // src/cli-main.ts
 import fs36 from "fs/promises";
@@ -1064,7 +1064,8 @@ function normalizeKnowledgePlatform(value) {
   if (!value) {
     return null;
   }
-  const normalized = value.trim().toLowerCase();
+  const trimmed = value.trim();
+  const normalized = trimmed.toLowerCase();
   if (normalized === "openclaw") {
     return "openclaw";
   }
@@ -1074,6 +1075,9 @@ function normalizeKnowledgePlatform(value) {
   if (normalized === "codex") {
     return "codex";
   }
+  if (normalized === "plaud") {
+    return "plaud";
+  }
   return null;
 }
 
@@ -11475,7 +11479,7 @@ PREFERENCE:
   "source_context": "User mentioned scheduling preference during calendar discussion -- scored 6 not 8 because no parallel session needs to act on this immediately; it is a low-urgency convenience preference"
 }
 
-// NOTE: These examples are drawn from OpenClaw transcripts (agent role labels, tool-verified claims). They provide soft cross-platform guidance for hedged-claim handling; mechanical enforcement (importance cap + unverified tag) is only applied for the openclaw platform via applyConfidenceCap().
+// NOTE: These examples are drawn from OpenClaw transcripts (agent role labels, tool-verified claims). They provide soft cross-platform guidance for hedged-claim handling; mechanical enforcement (importance cap + unverified tag) is applied for openclaw, codex, and claude-code via applyConfidenceCap().
 Example: hedged agent claim (correct handling):
 {
   "type": "fact",
@@ -11613,6 +11617,187 @@ RECOMMENDATION - not a factual claim, never capped:
   [m00050][assistant] I think we should switch to pnpm for consistency.
   Result: this is a suggestion, not a fact - do not apply the cap
 `;
+var CODE_PLATFORM_ADDENDUM = `
+## Code Session Rules (codex / claude-code)
+
+You are extracting from a coding agent session. These rules take precedence over the base extraction rules where they conflict.
+
+### What to capture with elevated importance
+
+Code audit FINDINGS (confirmed bugs, security issues, correctness flaws):
+- Importance: 8 minimum. Set expiry field to "permanent" (not "temporary").
+- Content MUST include: file path, line number or function name, exact nature of the flaw.
+- Example: "Bug in src/db/recall.ts fetchSessionCandidates(): missing AND retired = 0
+  filter causes retired entries to appear in recall results."
+- If evidence is missing (no file/line), drop importance to 7.
+
+Architectural decisions made during exploration:
+- Importance: 8. Set expiry to "permanent".
+- Include the specific files or modules involved and the rationale.
+
+Breaking changes discovered in dependencies or APIs:
+- Importance: 9 if cross-session impact. Include affected callers.
+
+Feature implementations completed with tests passing:
+- Importance: 7 event. Include branch name and what was shipped.
+
+### What to skip entirely
+
+Navigation and exploration events:
+- "I explored N files", "I read X", "I looked at Y", "I checked the codebase"
+- These are execution noise. Skip unless a specific finding resulted.
+
+Build or test status alone:
+- "Tests pass" or "build succeeded" with no new behavioral change = skip or 6 max.
+- Only store if it signals a resolved blocker or confirmed fix.
+
+Routine file reads without findings:
+- "I found that file X exists" or "I opened Y to understand Z" = skip.
+
+### Evidence requirement for importance >= 8
+
+If you assign importance 8 or higher to a code finding, the content MUST contain
+at least one of:
+- A file path
+- A line number or function name
+- A quoted snippet of the problematic code
+
+Without that evidence, cap at 7.
+
+### Role labels and confidence caps in code sessions
+
+Transcript lines are prefixed with [user] or [assistant] role labels.
+[user] messages are task descriptions or steering from the developer.
+[assistant] messages are the coding agent findings, reasoning, and actions.
+
+Apply confidence-cap rules to [assistant] statements only.
+Never apply this logic to [user] messages.
+
+An [assistant] statement is verified when it meets ANY of these conditions:
+- It immediately follows a line matching the pattern [called X: ...] such as
+  [called exec: ...], [called Read: ...], or any [called ...: ...] marker
+- It uses explicit verification language: "I confirmed", "I verified", "the output shows",
+  "the test shows", "confirmed via", "the file shows", "I ran", "the result shows"
+
+An [assistant] statement is hedged when it uses speculative language WITHOUT
+any of the verification signals above:
+- "I think", "I believe", "I assume", "I'm not sure", "probably", "likely",
+  "it might be", "it could be", "possibly", "maybe", "I recall that"
+
+Note: The importance cap threshold (5) and the "unverified" tag name must match
+the rules in applyConfidenceCap() in extractor.ts. If you change one, change both.
+
+When an [assistant] factual claim is hedged and unverified:
+- Set importance to min(your assigned importance, 5)
+- Add the tag "unverified"
+
+EXCEPTION: Do NOT cap recommendations or opinions. "I think we should refactor X"
+is a recommendation, not a factual claim. Only cap FACTUAL CLAIMS made with hedging language.
+`;
+var PLAUD_PLATFORM_ADDENDUM = `
+## Meeting Transcript Rules (plaud)
+
+You are extracting from a Plaud meeting transcript. These rules take precedence
+over the base extraction rules where they conflict.
+
+### Transcript format
+
+Plaud transcripts use the format:
+  [HH:MM] Speaker Name: spoken text
+
+Speaker names appear inline - use them directly for attribution. There are no
+[user] or [assistant] role labels. Do not apply confidence-cap logic based on
+role labels. Apply normal human epistemic judgment: uncertain language ("I think",
+"I assume", "probably") lowers confidence; direct statements and confirmed facts do not.
+
+Transcripts are generated by speech-to-text and will contain filler words (uh, um,
+gonna, you know), incomplete sentences, and lowercase runs. Extract the substance
+beneath these artifacts. Do not penalize transcript quality when deciding what to store.
+
+### Calibration for meeting chunks
+
+Meeting transcript chunks are dense by default. Unlike agent session chunks where
+most content is tool output and status updates, meeting chunks contain human
+speech with a high density of decisions, commitments, and action items.
+
+Override the base calibration for plaud: typical meeting chunk 3-8 entries.
+Do not suppress legitimate extractions because the base calibration says most
+chunks should be 0. Extract every action item, commitment, and decision you find.
+
+### What to capture with elevated importance
+
+Action items - explicit OR implicit:
+- Importance: 8, type TODO. Set expiry to "permanent".
+- Explicit: a speaker directly states "action item: X will do Y by Z."
+- Implicit: speaker says "I'll..." or "we need to..." followed by a concrete deliverable.
+  Use the speaker name from the transcript label as the owner.
+- Content MUST include: speaker name as owner, the action, and deadline if stated.
+- If no clear owner can be inferred, store as importance 7 TODO anyway.
+- Example: "Action item: Jordan to create two tracking tickets for the system migration
+  work by end of week."
+
+Decisions with cross-functional or product impact:
+- Importance: 8+ if the decision affects multiple teams or external stakeholders.
+- Importance: 7 if scoped to a single team.
+- Include who drove the decision and any stated rationale.
+- Example: "Decision: proceed with data extraction from System A immediately.
+  Hold System B extraction until post-cutover data completeness can be verified.
+  Rationale: System B new instance confirmed to have incomplete historical records
+  (Alex, Sam, Morgan)."
+
+Commitments made by named speakers:
+- Importance: 8 if binding (deadline, deliverable, or external party involved).
+- Importance: 7 if informal.
+- Use the speaker label from the transcript as the person name.
+
+Key facts about systems, timelines, or risks surfaced in the meeting:
+- Importance: 7-8 depending on cross-session impact.
+- Example: "System B EMR cutover to separate instance on [cutover date]. After
+  cutover, shared warehouse instance goes read-only for System B tenant. New
+  instance may have incomplete historical data due to minimal migration scope,
+  not a full data reload."
+
+Meeting summary as an event:
+- Importance: 7 event.
+- Include: meeting name, date if available (often in filename), attendees by name,
+  top 2-3 outcomes.
+
+### What to skip entirely
+
+Pure filler and crosstalk:
+- "Hello?", "Oh, sorry.", "Yeah.", "Okay." alone with no content = skip.
+- Greetings, scheduling, "how was your weekend" = skip.
+
+Vague mentions without commitment or decision:
+- "we should think about X someday" = skip.
+- "that would be interesting" without follow-through = skip.
+
+Pure status with no decision or action:
+- "Team A is still working on the integration" alone = skip.
+
+### Confidence tag rule
+
+Do NOT apply the "unverified" tag to meeting transcript entries. The "unverified"
+tag is for agent sessions where claims can be verified against tool output.
+Meeting transcripts have no such verification signal. Apply normal epistemic
+judgment to importance scoring instead.
+
+### Speaker name guidance
+
+Use the name exactly as it appears in the transcript label.
+If only a first name is available, use it - do not guess the last name.
+If a full name is available, use it.
+
+Sometimes Plaud cannot identify a speaker and labels them "Speaker 1", "Speaker 2", etc.
+When this happens:
+- If the speaker is later identified by name elsewhere in the transcript (someone
+  addresses them directly, or they introduce themselves), use that real name instead.
+- If the speaker remains unidentified, use the label as-is: "Speaker 1 committed to..."
+- For action items or decisions where the owner is only "Speaker X" with no real name
+  ever surfacing, downgrade importance to 7 regardless of content significance.
+  Unknown attribution weakens the reliability of the entry.
+- Do NOT guess or infer real names from context clues alone.
+`;
 var CHUNKED_CALIBRATION_BLOCK = `Calibration:
 - Typical chunk: 0-3 entries. Most chunks: 0.
 - Score 9 or 10: very rare, at most 1 per significant session, often 0
@@ -11650,6 +11835,16 @@ function buildExtractionSystemPrompt(platform, wholeFile = false) {
     return `${prompt}
 
 ${OPENCLAW_CONFIDENCE_ADDENDUM}`;
+  }
+  if (platform === "codex" || platform === "claude-code") {
+    return `${prompt}
+
+${CODE_PLATFORM_ADDENDUM}`;
+  }
+  if (platform === "plaud") {
+    return `${prompt}
+
+${PLAUD_PLATFORM_ADDENDUM}`;
   }
   return prompt;
 }
@@ -11917,7 +12112,7 @@ function validateEntry(entry) {
   return null;
 }
 function applyConfidenceCap(entry, platform) {
-  if (platform === "openclaw" && entry.tags.includes("unverified") && entry.importance > 5) {
+  if ((platform === "openclaw" || platform === "codex" || platform === "claude-code") && entry.tags.includes("unverified") && entry.importance > 5) {
     return { ...entry, importance: 5 };
   }
   return entry;
@@ -18412,13 +18607,13 @@ function createProgram() {
     });
     process.exitCode = result.exitCode;
   });
-  program.command("store").description("Store extracted knowledge entries in the local database").argument("[files...]", "One or more extraction JSON files").option("--db <path>", "Database path override").option("--dry-run", "Show what would be stored without writing", false).option("--verbose", "Show per-entry dedup decisions", false).option("--force", "Skip dedup and store all entries as new", false).option("--aggressive", "Enable aggressive dedup (lower similarity threshold)", false).option("--platform <name>", "Platform tag: openclaw, claude-code, codex").option("--project <name>", "Project tag (lowercase).", (val, prev) => [...prev, val], []).option("--online-dedup", "Enable online LLM dedup at write time", true).option("--no-online-dedup", "Disable online LLM dedup at write time").option("--dedup-threshold <n>", "Similarity threshold for online dedup (0.0-1.0)").action(
+  program.command("store").description("Store extracted knowledge entries in the local database").argument("[files...]", "One or more extraction JSON files").option("--db <path>", "Database path override").option("--dry-run", "Show what would be stored without writing", false).option("--verbose", "Show per-entry dedup decisions", false).option("--force", "Skip dedup and store all entries as new", false).option("--aggressive", "Enable aggressive dedup (lower similarity threshold)", false).option("--platform <name>", "Platform tag: openclaw, claude-code, codex, plaud").option("--project <name>", "Project tag (lowercase).", (val, prev) => [...prev, val], []).option("--online-dedup", "Enable online LLM dedup at write time", true).option("--no-online-dedup", "Disable online LLM dedup at write time").option("--dedup-threshold <n>", "Similarity threshold for online dedup (0.0-1.0)").action(
     async (files, opts) => {
       const result = await runStoreCommand(files ?? [], opts);
       process.exitCode = result.exitCode;
     }
   );
-  program.command("recall").description("Recall knowledge from the local database").argument("[query]", "Natural language query").option("--limit <n>", "Maximum number of results", parseIntOption, 10).option("--type <types>", "Filter by comma-separated entry types").option("--tags <tags>", "Filter by comma-separated tags").option("--min-importance <n>", "Minimum importance: 1-10").option("--since <duration>", "Filter by recency (1h, 7d, 30d, 1y) or ISO timestamp").option("--until <date>", "Only entries at or before this time (ISO date or relative, e.g. 7d, 1m)").option("--expiry <level>", "Filter by expiry: core|permanent|temporary").option("--platform <name>", "Filter by platform: openclaw, claude-code, codex").option("--project <name>", "Filter by project (repeatable)", (val, prev) => [...prev, val], []).option("--exclude-project <name>", "Exclude entries from project (repeatable)", (val, prev) => [...prev, val], []).option("--strict", "Exclude NULL-project entries from results", false).option("--json", "Output JSON", false).option("--db <path>", "Database path override").option("--budget <tokens>", "Approximate token budget", parseIntOption).option("--context <mode>", "Context mode: default|session-start|topic:<query>", "default").option("--scope <level>", "Visibility scope: private|personal|public", "private").option("--no-boost", "Disable scoring boosts and use raw vector similarity", false).option("--no-update", "Do not increment recall metadata", false).action(async (query, opts) => {
+  program.command("recall").description("Recall knowledge from the local database").argument("[query]", "Natural language query").option("--limit <n>", "Maximum number of results", parseIntOption, 10).option("--type <types>", "Filter by comma-separated entry types").option("--tags <tags>", "Filter by comma-separated tags").option("--min-importance <n>", "Minimum importance: 1-10").option("--since <duration>", "Filter by recency (1h, 7d, 30d, 1y) or ISO timestamp").option("--until <date>", "Only entries at or before this time (ISO date or relative, e.g. 7d, 1m)").option("--expiry <level>", "Filter by expiry: core|permanent|temporary").option("--platform <name>", "Filter by platform: openclaw, claude-code, codex, plaud").option("--project <name>", "Filter by project (repeatable)", (val, prev) => [...prev, val], []).option("--exclude-project <name>", "Exclude entries from project (repeatable)", (val, prev) => [...prev, val], []).option("--strict", "Exclude NULL-project entries from results", false).option("--json", "Output JSON", false).option("--db <path>", "Database path override").option("--budget <tokens>", "Approximate token budget", parseIntOption).option("--context <mode>", "Context mode: default|session-start|topic:<query>", "default").option("--scope <level>", "Visibility scope: private|personal|public", "private").option("--no-boost", "Disable scoring boosts and use raw vector similarity", false).option("--no-update", "Do not increment recall metadata", false).action(async (query, opts) => {
     const result = await runRecallCommand(query, {
       limit: opts.limit,
       type: opts.type,
@@ -18476,7 +18671,7 @@ function createProgram() {
   });
   program.command("context").description(
     "Generate a context file for AI tool integration (session-start recall runs locally; no embedding API calls)."
-  ).option("--output <path>", "Output file path", "~/.agenr/CONTEXT.md").option("--budget <tokens>", "Approximate token budget", parseIntOption, 2e3).option("--limit <n>", "Max entries per category", parseIntOption, 10).option("--db <path>", "Database path override").option("--platform <name>", "Filter by platform: openclaw, claude-code, codex").option("--project <name>", "Filter by project (repeatable)", (val, prev) => [...prev, val], []).option("--exclude-project <name>", "Exclude entries from project (repeatable)", (val, prev) => [...prev, val], []).option("--strict", "Exclude NULL-project entries from results", false).option("--json", "Output JSON", false).option("--quiet", "Suppress stderr output", false).action(
+  ).option("--output <path>", "Output file path", "~/.agenr/CONTEXT.md").option("--budget <tokens>", "Approximate token budget", parseIntOption, 2e3).option("--limit <n>", "Max entries per category", parseIntOption, 10).option("--db <path>", "Database path override").option("--platform <name>", "Filter by platform: openclaw, claude-code, codex, plaud").option("--project <name>", "Filter by project (repeatable)", (val, prev) => [...prev, val], []).option("--exclude-project <name>", "Exclude entries from project (repeatable)", (val, prev) => [...prev, val], []).option("--strict", "Exclude NULL-project entries from results", false).option("--json", "Output JSON", false).option("--quiet", "Suppress stderr output", false).action(
     async (opts) => {
       const result = await runContextCommand({
         output: opts.output,
@@ -18493,7 +18688,7 @@ function createProgram() {
       process.exitCode = result.exitCode;
     }
   );
-  program.command("watch").description("Watch a transcript file and auto-extract knowledge as it grows").argument("[file]", "Transcript file to watch (.jsonl, .md, .txt)").option("--dir <path>", "Sessions directory to watch (resolver picks active file)").option("--platform <name>", "Session platform: openclaw, claude-code, codex, mtime").option("--auto", "Deprecated: use --platform <name> instead", false).option("--interval <seconds>", "Polling interval in seconds", parseIntOption, 300).option("--min-chunk <chars>", "Minimum new chars before extraction", parseIntOption, 2e3).option("--context <path>", "Regenerate context file after each cycle").option("--db <path>", "Database path override").option("--model <model>", "LLM model to use").option("--provider <name>", "LLM provider: anthropic, openai, openai-codex").option("--raw", "Bypass adapter filtering (pass transcripts through unmodified)", false).option("--no-pre-fetch", "Disable elaborative encoding pre-fetch").option("--verbose", "Show extraction progress", false).option("--dry-run", "Extract without storing", false).option("--once", "Run one cycle and exit", false).option("--json", "Output JSON results", false).action(async (file, opts) => {
+  program.command("watch").description("Watch a transcript file and auto-extract knowledge as it grows").argument("[file]", "Transcript file to watch (.jsonl, .md, .txt)").option("--dir <path>", "Sessions directory to watch (resolver picks active file)").option("--platform <name>", "Session platform: openclaw, claude-code, codex, plaud, mtime").option("--auto", "Deprecated: use --platform <name> instead", false).option("--interval <seconds>", "Polling interval in seconds", parseIntOption, 300).option("--min-chunk <chars>", "Minimum new chars before extraction", parseIntOption, 2e3).option("--context <path>", "Regenerate context file after each cycle").option("--db <path>", "Database path override").option("--model <model>", "LLM model to use").option("--provider <name>", "LLM provider: anthropic, openai, openai-codex").option("--raw", "Bypass adapter filtering (pass transcripts through unmodified)", false).option("--no-pre-fetch", "Disable elaborative encoding pre-fetch").option("--verbose", "Show extraction progress", false).option("--dry-run", "Extract without storing", false).option("--once", "Run one cycle and exit", false).option("--json", "Output JSON results", false).action(async (file, opts) => {
     const result = await runWatchCommand(file, {
       ...opts,
       noPreFetch: opts.noPreFetch === true
@@ -18504,7 +18699,7 @@ function createProgram() {
     const result = await runTodoCommand(subcommand, subject, { db: opts.db });
     process.exitCode = result.exitCode;
   });
-  program.command("ingest").description("Bulk-ingest knowledge from files and directories").argument("<paths...>", "Files or directories to process").option("--glob <pattern>", "File filter glob", "**/*.{jsonl,md,txt}").option("--db <path>", "Database path override").option("--model <model>", "LLM model to use").option("--provider <name>", "LLM provider: anthropic, openai, openai-codex").option("--platform <name>", "Platform tag: openclaw, claude-code, codex").option("--project <name>", "Project tag (lowercase).", (val, prev) => [...prev, val], []).option("--verbose", "Show per-file details", false).option("--raw", "Bypass adapter filtering (pass transcripts through unmodified)", false).option("--dry-run", "Extract without storing", false).option("--json", "Output JSON results", false).option("--concurrency <n>", "Parallel chunk extractions", parseIntOption, 5).option(
+  program.command("ingest").description("Bulk-ingest knowledge from files and directories").argument("<paths...>", "Files or directories to process").option("--glob <pattern>", "File filter glob", "**/*.{jsonl,md,txt}").option("--db <path>", "Database path override").option("--model <model>", "LLM model to use").option("--provider <name>", "LLM provider: anthropic, openai, openai-codex").option("--platform <name>", "Platform tag: openclaw, claude-code, codex, plaud").option("--project <name>", "Project tag (lowercase).", (val, prev) => [...prev, val], []).option("--verbose", "Show per-file details", false).option("--raw", "Bypass adapter filtering (pass transcripts through unmodified)", false).option("--dry-run", "Extract without storing", false).option("--json", "Output JSON results", false).option("--concurrency <n>", "Parallel chunk extractions", parseIntOption, 5).option(
     "--workers <n>",
     "Number of files to process in parallel (default: 10). Each worker uses --concurrency chunk parallelism. Total concurrent LLM calls = workers x concurrency. Reduce if hitting rate limits. Writes retry once per sub-batch unless --no-retry is set.",
     parseIntOption,
@@ -18540,7 +18735,7 @@ function createProgram() {
     });
     process.exitCode = result.exitCode;
   });
-  program.command("consolidate").description("Consolidate and clean up the knowledge database").option("--rules-only", "Only run rule-based cleanup (no LLM)", false).option("--dry-run", "Show what would happen without making changes", false).option("--forget", "Delete forgetting candidates after consolidation", false).option("--report", "Print pre-run stats report (with --dry-run: report only)", false).option("--platform <name>", "Scope consolidation to platform: openclaw, claude-code, codex").option("--project <name>", "Scope consolidation to project (repeatable)", (val, prev) => [...prev, val], []).option("--exclude-project <name>", "Exclude entries from project (repeatable)", (val, prev) => [...prev, val], []).option(
+  program.command("consolidate").description("Consolidate and clean up the knowledge database").option("--rules-only", "Only run rule-based cleanup (no LLM)", false).option("--dry-run", "Show what would happen without making changes", false).option("--forget", "Delete forgetting candidates after consolidation", false).option("--report", "Print pre-run stats report (with --dry-run: report only)", false).option("--platform <name>", "Scope consolidation to platform: openclaw, claude-code, codex, plaud").option("--project <name>", "Scope consolidation to project (repeatable)", (val, prev) => [...prev, val], []).option("--exclude-project <name>", "Exclude entries from project (repeatable)", (val, prev) => [...prev, val], []).option(
     "--min-cluster <n>",
     "Minimum cluster size for merge (default: 2)",
     (value) => Number.parseInt(value, 10)
@@ -18580,7 +18775,7 @@ function createProgram() {
     await runMcpCommand(opts);
   });
   const daemonCommand = program.command("daemon").description("Manage the agenr watch daemon");
-  daemonCommand.command("install").description("Install and start the watch daemon (macOS launchd)").option("--force", "Overwrite existing launchd plist", false).option("--interval <seconds>", "Watch interval for daemon mode", parseIntOption, 120).option("--dir <path>", "Sessions directory to watch (overrides auto-detection)").option("--platform <name>", "Platform name (openclaw, codex, claude-code)").option("--node-path <path>", "Node binary path override for launchd").option("--context <path>", "Regenerate context file after each cycle").action(async (opts) => {
+  daemonCommand.command("install").description("Install and start the watch daemon (macOS launchd)").option("--force", "Overwrite existing launchd plist", false).option("--interval <seconds>", "Watch interval for daemon mode", parseIntOption, 120).option("--dir <path>", "Sessions directory to watch (overrides auto-detection)").option("--platform <name>", "Platform name (openclaw, claude-code, codex, plaud)").option("--node-path <path>", "Node binary path override for launchd").option("--context <path>", "Regenerate context file after each cycle").action(async (opts) => {
     const result = await runDaemonInstallCommand(opts);
     process.exitCode = result.exitCode;
   });
@@ -18617,7 +18812,7 @@ function createProgram() {
     await runDbVersionCommand({ db: opts.db });
     process.exitCode = 0;
   });
-  dbCommand.command("export").description("Export all non-superseded entries").option("--json", "Export JSON", false).option("--md", "Export markdown", false).option("--db <path>", "Database path override").option("--platform <name>", "Filter by platform: openclaw, claude-code, codex").option("--project <name>", "Filter by project (repeatable)", (val, prev) => [...prev, val], []).option("--exclude-project <name>", "Exclude entries from project (repeatable)", (val, prev) => [...prev, val], []).action(async (opts) => {
+  dbCommand.command("export").description("Export all non-superseded entries").option("--json", "Export JSON", false).option("--md", "Export markdown", false).option("--db <path>", "Database path override").option("--platform <name>", "Filter by platform: openclaw, claude-code, codex, plaud").option("--project <name>", "Filter by project (repeatable)", (val, prev) => [...prev, val], []).option("--exclude-project <name>", "Exclude entries from project (repeatable)", (val, prev) => [...prev, val], []).action(async (opts) => {
     await runDbExportCommand({
       db: opts.db,
       json: opts.json,

package/dist/openclaw-plugin/index.js

@@ -4,7 +4,7 @@ import {
   closeDb,
   getDb,
   initDb
-} from "../chunk-VJ2WB7JG.js";
+} from "../chunk-JSPUNQPG.js";
 
 // src/openclaw-plugin/index.ts
 import { Type } from "@sinclair/typebox";

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "agenr",
   "name": "agenr Memory",
   "description": "Local memory layer - injects agenr context at session start",
-  "version": "0.7.21",
+  "version": "0.8.2",
   "skills": [
     "skills"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agenr",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "openclaw": {
     "extensions": [
       "dist/openclaw-plugin/index.js"