hippo-memory 1.24.0 → 1.25.0

package/dist/connectors/github/backfill.js

@@ -30,7 +30,7 @@ function readCursor(root, tenantId, repo) {
     const db = openHippoDb(root);
     try {
         const row = db
-            .prepare(`SELECT issues_hwm, issue_comments_hwm, pr_review_comments_hwm
+            .prepare(`SELECT issues_hwm, issue_comments_hwm, pr_review_comments_hwm
          FROM github_cursors WHERE tenant_id = ? AND repo_full_name = ?`)
             .get(tenantId, repo);
         return {
@@ -46,9 +46,9 @@ function readCursor(root, tenantId, repo) {
 function writeOneHwm(root, tenantId, repo, column, value) {
     const db = openHippoDb(root);
     try {
-        db.prepare(`INSERT INTO github_cursors (tenant_id, repo_full_name, ${column}, updated_at)
-       VALUES (?, ?, ?, ?)
-       ON CONFLICT(tenant_id, repo_full_name)
+        db.prepare(`INSERT INTO github_cursors (tenant_id, repo_full_name, ${column}, updated_at)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(tenant_id, repo_full_name)
        DO UPDATE SET ${column} = excluded.${column}, updated_at = excluded.updated_at`).run(tenantId, repo, value, new Date().toISOString());
     }
     finally {

package/dist/connectors/github/cli-impl.js

@@ -83,12 +83,12 @@ export async function cmdGithubBackfill(hippoRoot, flags, fetcher = realGitHubFe
     if (sinceIso) {
         const db = openHippoDb(hippoRoot);
         try {
-            db.prepare(`INSERT INTO github_cursors (tenant_id, repo_full_name, issues_hwm, issue_comments_hwm, pr_review_comments_hwm, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?)
-         ON CONFLICT(tenant_id, repo_full_name) DO UPDATE SET
-           issues_hwm = COALESCE(github_cursors.issues_hwm, excluded.issues_hwm),
-           issue_comments_hwm = COALESCE(github_cursors.issue_comments_hwm, excluded.issue_comments_hwm),
-           pr_review_comments_hwm = COALESCE(github_cursors.pr_review_comments_hwm, excluded.pr_review_comments_hwm),
+            db.prepare(`INSERT INTO github_cursors (tenant_id, repo_full_name, issues_hwm, issue_comments_hwm, pr_review_comments_hwm, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?)
+         ON CONFLICT(tenant_id, repo_full_name) DO UPDATE SET
+           issues_hwm = COALESCE(github_cursors.issues_hwm, excluded.issues_hwm),
+           issue_comments_hwm = COALESCE(github_cursors.issue_comments_hwm, excluded.issue_comments_hwm),
+           pr_review_comments_hwm = COALESCE(github_cursors.pr_review_comments_hwm, excluded.pr_review_comments_hwm),
            updated_at = excluded.updated_at`).run(tenantId, repo, sinceIso, sinceIso, sinceIso, new Date().toISOString());
         }
         finally {

package/dist/connectors/github/dlq.js

@@ -3,30 +3,30 @@ import { verifyGitHubSignature } from './signature.js';
 import { isGitHubWebhookEnvelope } from './types.js';
 export function writeToDlq(db, opts) {
     const result = db
-        .prepare(`INSERT INTO github_dlq
-        (tenant_id, raw_payload, error, event_name, delivery_id, signature,
-         installation_id, repo_full_name, received_at, bucket)
+        .prepare(`INSERT INTO github_dlq
+        (tenant_id, raw_payload, error, event_name, delivery_id, signature,
+         installation_id, repo_full_name, received_at, bucket)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
         .run(opts.tenantId ?? '__unroutable__', opts.rawPayload, opts.error, opts.eventName ?? null, opts.deliveryId ?? null, opts.signature ?? null, opts.installationId ?? null, opts.repoFullName ?? null, new Date().toISOString(), opts.bucket ?? 'parse_error');
     return Number(result.lastInsertRowid);
 }
-const SELECT_COLUMNS = `id, tenant_id, raw_payload, error, event_name, delivery_id,
-            signature, installation_id, repo_full_name, retry_count,
+const SELECT_COLUMNS = `id, tenant_id, raw_payload, error, event_name, delivery_id,
+            signature, installation_id, repo_full_name, retry_count,
             received_at, retried_at, bucket`;
 export function listDlq(db, opts) {
     const rows = db
-        .prepare(`SELECT ${SELECT_COLUMNS}
-         FROM github_dlq
-        WHERE tenant_id = ?
-        ORDER BY received_at ASC
+        .prepare(`SELECT ${SELECT_COLUMNS}
+         FROM github_dlq
+        WHERE tenant_id = ?
+        ORDER BY received_at ASC
         LIMIT ?`)
         .all(opts.tenantId, opts.limit ?? 100);
     return rows.map(rowToItem);
 }
 export function getDlqEntry(db, id) {
     const row = db
-        .prepare(`SELECT ${SELECT_COLUMNS}
-         FROM github_dlq
+        .prepare(`SELECT ${SELECT_COLUMNS}
+         FROM github_dlq
         WHERE id = ?`)
         .get(id);
     if (!row)
@@ -53,9 +53,9 @@ function rowToItem(r) {
 function bumpRetryCount(hippoRoot, id) {
     const db = openHippoDb(hippoRoot);
     try {
-        db.prepare(`UPDATE github_dlq
-          SET retry_count = retry_count + 1,
-              retried_at = ?
+        db.prepare(`UPDATE github_dlq
+          SET retry_count = retry_count + 1,
+              retried_at = ?
         WHERE id = ?`).run(new Date().toISOString(), id);
     }
     finally {

package/dist/connectors/slack/backfill.js

@@ -15,7 +15,7 @@ function readCursor(root, tenantId, channelId) {
 function writeCursor(root, tenantId, channelId, latestTs) {
     const db = openHippoDb(root);
     try {
-        db.prepare(`INSERT INTO slack_cursors (tenant_id, channel_id, latest_ts, updated_at) VALUES (?,?,?,?)
+        db.prepare(`INSERT INTO slack_cursors (tenant_id, channel_id, latest_ts, updated_at) VALUES (?,?,?,?)
        ON CONFLICT(tenant_id, channel_id) DO UPDATE SET latest_ts = excluded.latest_ts, updated_at = excluded.updated_at`).run(tenantId, channelId, latestTs, new Date().toISOString());
     }
     finally {

package/dist/connectors/slack/dlq.js

@@ -7,28 +7,28 @@ import { isSlackEventEnvelope, isSlackMessageEvent } from './types.js';
 import { handleMessageDeleted } from './deletion.js';
 export function writeToDlq(db, opts) {
     const result = db
-        .prepare(`INSERT INTO slack_dlq
-        (tenant_id, team_id, raw_payload, error, received_at, bucket, signature, slack_timestamp)
+        .prepare(`INSERT INTO slack_dlq
+        (tenant_id, team_id, raw_payload, error, received_at, bucket, signature, slack_timestamp)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
         .run(opts.tenantId ?? '__unroutable__', opts.teamId ?? null, opts.rawPayload, opts.error, new Date().toISOString(), opts.bucket ?? 'parse_error', opts.signature ?? null, opts.slackTimestamp ?? null);
     return Number(result.lastInsertRowid);
 }
 export function listDlq(db, opts) {
     const rows = db
-        .prepare(`SELECT id, tenant_id, team_id, raw_payload, error, received_at, retried_at,
-              bucket, retry_count, signature, slack_timestamp
-         FROM slack_dlq
-        WHERE tenant_id = ?
-        ORDER BY received_at ASC
+        .prepare(`SELECT id, tenant_id, team_id, raw_payload, error, received_at, retried_at,
+              bucket, retry_count, signature, slack_timestamp
+         FROM slack_dlq
+        WHERE tenant_id = ?
+        ORDER BY received_at ASC
         LIMIT ?`)
         .all(opts.tenantId, opts.limit ?? 100);
     return rows.map(rowToItem);
 }
 export function getDlqEntry(db, id) {
     const row = db
-        .prepare(`SELECT id, tenant_id, team_id, raw_payload, error, received_at, retried_at,
-              bucket, retry_count, signature, slack_timestamp
-         FROM slack_dlq
+        .prepare(`SELECT id, tenant_id, team_id, raw_payload, error, received_at, retried_at,
+              bucket, retry_count, signature, slack_timestamp
+         FROM slack_dlq
         WHERE id = ?`)
         .get(id);
     if (!row)

package/dist/connectors/slack/workspaces.js

@@ -26,10 +26,10 @@
  */
 export function addWorkspace(db, opts) {
     const addedAt = new Date().toISOString();
-    db.prepare(`INSERT INTO slack_workspaces (team_id, tenant_id, added_at)
-     VALUES (?, ?, ?)
-     ON CONFLICT(team_id) DO UPDATE SET
-       tenant_id = excluded.tenant_id,
+    db.prepare(`INSERT INTO slack_workspaces (team_id, tenant_id, added_at)
+     VALUES (?, ?, ?)
+     ON CONFLICT(team_id) DO UPDATE SET
+       tenant_id = excluded.tenant_id,
        added_at = excluded.added_at`).run(opts.teamId, opts.tenantId, addedAt);
     return { teamId: opts.teamId, tenantId: opts.tenantId, addedAt };
 }

package/dist/dag.js

@@ -31,12 +31,12 @@ export function clusterFacts(facts) {
     }
     return clusters;
 }
-const DAG_SUMMARY_PROMPT = `You are summarizing a cluster of facts about a specific topic/entity for a memory system.
-
-Topic: {label}
-Facts:
-{facts}
-
+const DAG_SUMMARY_PROMPT = `You are summarizing a cluster of facts about a specific topic/entity for a memory system.
+
+Topic: {label}
+Facts:
+{facts}
+
 Write a single concise paragraph (2-4 sentences) that captures all the key information from these facts. This summary will be used to quickly determine if this cluster is relevant to a future query, so include specific names, dates, numbers, and key details. Output ONLY the summary paragraph, no preamble.`;
 export async function generateDagSummary(label, factContents, opts) {
     const model = opts.model ?? 'claude-sonnet-4-6';

package/dist/dashboard.js

@@ -202,13 +202,13 @@ export function serveDashboard(hippoRoot, port = 3333) {
         // was removed in the hybrid-v4 revamp E1 since dist-ui/ is now the
         // sole UI surface). ---
         res.writeHead(404, { 'Content-Type': 'text/html; charset=utf-8' });
-        res.end(`<!doctype html>
-<html lang="en"><head><title>Hippo Dashboard</title><meta charset="utf-8"></head>
-<body style="font-family:Georgia,'Palatino Linotype',serif;max-width:640px;margin:60px auto;padding:24px;line-height:1.6;background:#f4efe6;color:#3a3228">
-<h1 style="color:#c45c3c">Hippo Dashboard</h1>
-<p>The React UI bundle is not built yet. Run:</p>
-<pre style="background:#faf7f2;padding:16px;border:1px solid #c4b9a8;border-radius:3px;font-family:Consolas,monospace">cd ui && npm install && npm run build</pre>
-<p>Then refresh this page. The dashboard server will serve <code>dist-ui/index.html</code> automatically once present.</p>
+        res.end(`<!doctype html>
+<html lang="en"><head><title>Hippo Dashboard</title><meta charset="utf-8"></head>
+<body style="font-family:Georgia,'Palatino Linotype',serif;max-width:640px;margin:60px auto;padding:24px;line-height:1.6;background:#f4efe6;color:#3a3228">
+<h1 style="color:#c45c3c">Hippo Dashboard</h1>
+<p>The React UI bundle is not built yet. Run:</p>
+<pre style="background:#faf7f2;padding:16px;border:1px solid #c4b9a8;border-radius:3px;font-family:Consolas,monospace">cd ui && npm install && npm run build</pre>
+<p>Then refresh this page. The dashboard server will serve <code>dist-ui/index.html</code> automatically once present.</p>
 </body></html>`);
     });
     server.listen(port, '127.0.0.1', () => {

package/dist/hooks.js

@@ -77,30 +77,30 @@ const HIPPO_OPENCODE_PLUGIN_MARKER = 'HIPPO_OPENCODE_PLUGIN_V1';
  *    marker match AND content equality, so a plugin-source revision under
  *    the same V1 marker re-writes the file on next install.
  */
-export const OPENCODE_PLUGIN_SOURCE = `// ${HIPPO_OPENCODE_PLUGIN_MARKER}
-// hippo-memory opencode plugin. DO NOT EDIT — regenerated on every
-// \`hippo hook install opencode\` from src/hooks.ts OPENCODE_PLUGIN_SOURCE
-// in https://github.com/kitfunso/hippo-memory. Local changes will be lost.
-
-export const HippoPlugin = async ({ $ }) => {
-  return {
-    event: async ({ event }) => {
-      // Defense in depth: opencode currently runs in Bun where $ is the shell
-      // template helper. A non-Bun runtime would have $ as undefined; fail
-      // closed instead of crashing the host session.
-      if (typeof $ !== "function") return;
-      try {
-        if (event.type === "session.idle") {
-          await $\`hippo session-end\`.quiet().nothrow();
-        } else if (event.type === "session.created") {
-          await $\`hippo last-sleep\`.quiet().nothrow();
-        }
-      } catch {
-        // hippo CLI not on PATH or other failure — never crash the host session.
-      }
-    },
-  };
-};
+export const OPENCODE_PLUGIN_SOURCE = `// ${HIPPO_OPENCODE_PLUGIN_MARKER}
+// hippo-memory opencode plugin. DO NOT EDIT — regenerated on every
+// \`hippo hook install opencode\` from src/hooks.ts OPENCODE_PLUGIN_SOURCE
+// in https://github.com/kitfunso/hippo-memory. Local changes will be lost.
+
+export const HippoPlugin = async ({ $ }) => {
+  return {
+    event: async ({ event }) => {
+      // Defense in depth: opencode currently runs in Bun where $ is the shell
+      // template helper. A non-Bun runtime would have $ as undefined; fail
+      // closed instead of crashing the host session.
+      if (typeof $ !== "function") return;
+      try {
+        if (event.type === "session.idle") {
+          await $\`hippo session-end\`.quiet().nothrow();
+        } else if (event.type === "session.created") {
+          await $\`hippo last-sleep\`.quiet().nothrow();
+        }
+      } catch {
+        // hippo CLI not on PATH or other failure — never crash the host session.
+      }
+    },
+  };
+};
 `;
 export { HIPPO_OPENCODE_PLUGIN_MARKER };
 function homeDir() {

package/dist/predictions.js

@@ -86,20 +86,20 @@ export function savePrediction(hippoRoot, tenantId, opts, actor = 'cli') {
     writeEntry(hippoRoot, mem, {
         actor,
         afterWrite: (db, memoryId) => {
-            const result = db.prepare(`
-        INSERT INTO predictions(
-          memory_id, tenant_id, class_tag, claim_text,
-          estimate_value, estimate_unit, target_date,
-          actual_value, closure_state, closed_at, closure_note, created_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'open', NULL, NULL, ?)
+            const result = db.prepare(`
+        INSERT INTO predictions(
+          memory_id, tenant_id, class_tag, claim_text,
+          estimate_value, estimate_unit, target_date,
+          actual_value, closure_state, closed_at, closure_note, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'open', NULL, NULL, ?)
       `).run(memoryId, tenantId, opts.classTag, opts.claimText, opts.estimateValue ?? null, opts.estimateUnit ?? null, opts.targetDate ?? null, null, // actual_value — null until close
             now);
             const predictionId = Number(result.lastInsertRowid ?? 0);
-            const row = db.prepare(`
-        SELECT id, memory_id, tenant_id, class_tag, claim_text,
-               estimate_value, estimate_unit, target_date,
-               actual_value, closure_state, closed_at, closure_note, created_at
-        FROM predictions WHERE id = ?
+            const row = db.prepare(`
+        SELECT id, memory_id, tenant_id, class_tag, claim_text,
+               estimate_value, estimate_unit, target_date,
+               actual_value, closure_state, closed_at, closure_note, created_at
+        FROM predictions WHERE id = ?
       `).get(predictionId);
             if (!row) {
                 throw new Error('Failed to reload saved prediction row');
@@ -150,16 +150,16 @@ export function closePrediction(hippoRoot, tenantId, id, opts, actor = 'cli') {
             // predict_close audit row. Zero changed rows → caller decides
             // whether it's a "not found" or "already closed" case based on the
             // load-then-close pattern.
-            const updateResult = db.prepare(`
-        UPDATE predictions
-        SET actual_value = ?, closure_state = ?, closed_at = ?, closure_note = ?
-        WHERE id = ? AND tenant_id = ? AND closure_state = 'open'
+            const updateResult = db.prepare(`
+        UPDATE predictions
+        SET actual_value = ?, closure_state = ?, closed_at = ?, closure_note = ?
+        WHERE id = ? AND tenant_id = ? AND closure_state = 'open'
       `).run(opts.actualValue ?? null, opts.closureState, now, opts.closureNote ?? null, id, tenantId);
             if (updateResult.changes === 0) {
                 // Distinguish "not found" from "already closed" so callers (CLI, HTTP)
                 // can surface the right error to the user.
-                const existing = db.prepare(`
-          SELECT closure_state FROM predictions WHERE id = ? AND tenant_id = ?
+                const existing = db.prepare(`
+          SELECT closure_state FROM predictions WHERE id = ? AND tenant_id = ?
         `).get(id, tenantId);
                 if (!existing) {
                     throw new Error(`closePrediction: prediction ${id} not found for tenant ${tenantId}`);
@@ -167,11 +167,11 @@ export function closePrediction(hippoRoot, tenantId, id, opts, actor = 'cli') {
                 throw new Error(`closePrediction: prediction ${id} is already closed (state='${existing.closure_state}'); ` +
                     `cannot re-close. Open predictions only.`);
             }
-            const row = db.prepare(`
-        SELECT id, memory_id, tenant_id, class_tag, claim_text,
-               estimate_value, estimate_unit, target_date,
-               actual_value, closure_state, closed_at, closure_note, created_at
-        FROM predictions WHERE id = ? AND tenant_id = ?
+            const row = db.prepare(`
+        SELECT id, memory_id, tenant_id, class_tag, claim_text,
+               estimate_value, estimate_unit, target_date,
+               actual_value, closure_state, closed_at, closure_note, created_at
+        FROM predictions WHERE id = ? AND tenant_id = ?
       `).get(id, tenantId);
             if (!row) {
                 throw new Error(`closePrediction: prediction ${id} not found after UPDATE`);
@@ -208,11 +208,11 @@ export function loadPredictionById(hippoRoot, tenantId, id) {
     assertTenantId('loadPredictionById', tenantId);
     const db = openHippoDb(hippoRoot);
     try {
-        const row = db.prepare(`
-      SELECT id, memory_id, tenant_id, class_tag, claim_text,
-             estimate_value, estimate_unit, target_date,
-             actual_value, closure_state, closed_at, closure_note, created_at
-      FROM predictions WHERE id = ? AND tenant_id = ?
+        const row = db.prepare(`
+      SELECT id, memory_id, tenant_id, class_tag, claim_text,
+             estimate_value, estimate_unit, target_date,
+             actual_value, closure_state, closed_at, closure_note, created_at
+      FROM predictions WHERE id = ? AND tenant_id = ?
     `).get(id, tenantId);
         return row ? rowToPrediction(row) : null;
     }
@@ -230,25 +230,25 @@ export function loadPredictionsByClass(hippoRoot, tenantId, classTag, opts = {})
             if (!VALID_CLOSURE_STATES.has(opts.closureState)) {
                 throw new Error(`loadPredictionsByClass: closureState must be one of ${Array.from(VALID_CLOSURE_STATES).join('|')}; got ${opts.closureState}`);
             }
-            rows = db.prepare(`
-        SELECT id, memory_id, tenant_id, class_tag, claim_text,
-               estimate_value, estimate_unit, target_date,
-               actual_value, closure_state, closed_at, closure_note, created_at
-        FROM predictions
-        WHERE tenant_id = ? AND class_tag = ? AND closure_state = ?
-        ORDER BY created_at DESC, id DESC
-        LIMIT ?
+            rows = db.prepare(`
+        SELECT id, memory_id, tenant_id, class_tag, claim_text,
+               estimate_value, estimate_unit, target_date,
+               actual_value, closure_state, closed_at, closure_note, created_at
+        FROM predictions
+        WHERE tenant_id = ? AND class_tag = ? AND closure_state = ?
+        ORDER BY created_at DESC, id DESC
+        LIMIT ?
       `).all(tenantId, classTag, opts.closureState, limit);
         }
         else {
-            rows = db.prepare(`
-        SELECT id, memory_id, tenant_id, class_tag, claim_text,
-               estimate_value, estimate_unit, target_date,
-               actual_value, closure_state, closed_at, closure_note, created_at
-        FROM predictions
-        WHERE tenant_id = ? AND class_tag = ?
-        ORDER BY created_at DESC, id DESC
-        LIMIT ?
+            rows = db.prepare(`
+        SELECT id, memory_id, tenant_id, class_tag, claim_text,
+               estimate_value, estimate_unit, target_date,
+               actual_value, closure_state, closed_at, closure_note, created_at
+        FROM predictions
+        WHERE tenant_id = ? AND class_tag = ?
+        ORDER BY created_at DESC, id DESC
+        LIMIT ?
       `).all(tenantId, classTag, limit);
         }
         return rows.map(rowToPrediction);
@@ -286,14 +286,14 @@ emitAudit = true) {
         throw new Error('computePredictionBaserate: classTag is required');
     const db = openHippoDb(hippoRoot);
     try {
-        const rows = db.prepare(`
-      SELECT estimate_value, actual_value
-      FROM predictions
-      WHERE tenant_id = ?
-        AND class_tag = ?
-        AND closure_state = 'closed'
-        AND estimate_value IS NOT NULL
-        AND actual_value IS NOT NULL
+        const rows = db.prepare(`
+      SELECT estimate_value, actual_value
+      FROM predictions
+      WHERE tenant_id = ?
+        AND class_tag = ?
+        AND closure_state = 'closed'
+        AND estimate_value IS NOT NULL
+        AND actual_value IS NOT NULL
     `).all(tenantId, classTag);
         const nClosed = rows.length;
         if (nClosed === 0) {
@@ -373,25 +373,25 @@ export function loadOpenPredictions(hippoRoot, tenantId, opts = {}) {
     try {
         let rows;
         if (opts.classTag) {
-            rows = db.prepare(`
-        SELECT id, memory_id, tenant_id, class_tag, claim_text,
-               estimate_value, estimate_unit, target_date,
-               actual_value, closure_state, closed_at, closure_note, created_at
-        FROM predictions
-        WHERE tenant_id = ? AND class_tag = ? AND closure_state = 'open'
-        ORDER BY created_at DESC, id DESC
-        LIMIT ?
+            rows = db.prepare(`
+        SELECT id, memory_id, tenant_id, class_tag, claim_text,
+               estimate_value, estimate_unit, target_date,
+               actual_value, closure_state, closed_at, closure_note, created_at
+        FROM predictions
+        WHERE tenant_id = ? AND class_tag = ? AND closure_state = 'open'
+        ORDER BY created_at DESC, id DESC
+        LIMIT ?
       `).all(tenantId, opts.classTag, limit);
         }
         else {
-            rows = db.prepare(`
-        SELECT id, memory_id, tenant_id, class_tag, claim_text,
-               estimate_value, estimate_unit, target_date,
-               actual_value, closure_state, closed_at, closure_note, created_at
-        FROM predictions
-        WHERE tenant_id = ? AND closure_state = 'open'
-        ORDER BY created_at DESC, id DESC
-        LIMIT ?
+            rows = db.prepare(`
+        SELECT id, memory_id, tenant_id, class_tag, claim_text,
+               estimate_value, estimate_unit, target_date,
+               actual_value, closure_state, closed_at, closure_note, created_at
+        FROM predictions
+        WHERE tenant_id = ? AND closure_state = 'open'
+        ORDER BY created_at DESC, id DESC
+        LIMIT ?
       `).all(tenantId, limit);
         }
         return rows.map(rowToPrediction);

package/dist/recall-scope.d.ts

@@ -0,0 +1,60 @@
+/**
+ * v1.25.0 — recall-side scope predicates, extracted from api.ts into a leaf
+ * module so shared.ts (which api.ts imports) can apply the same default-deny
+ * rule to searchBothHybrid's internal candidate loads without an import
+ * cycle. Mirrors the v39 `project-identity.ts` precedent. api.ts imports
+ * these for its own call sites AND re-exports them for back-compat
+ * (`api.isPrivateScope`, test imports of `passesScopeFilterForRecall`).
+ */
+/**
+ * v1.2.1: source-agnostic private-scope detector. A scope string is treated
+ * as private when it has the shape `<lowercase-source>:private:<rest>`.
+ *
+ * Examples that match:
+ *   slack:private:Cabc, github:private:owner/repo, jira:private:PROJ-1
+ * Examples that DO NOT match:
+ *   slack:public:Cgeneral, acme:public:my-private-channel, null, '',
+ *   'unknown:legacy', 'private' (alone), 'private:foo' (no source prefix).
+ *
+ * Used by api.recall, mcp/server.ts (hippo_recall + hippo_context),
+ * cli.ts (cmdRecall + cmdExplain + continuity), shared.ts (searchBothHybrid
+ * recall mode). Keep these in sync — the export is the single source of
+ * truth so connector work cannot drift.
+ */
+export declare const PRIVATE_SCOPE_RE: RegExp;
+/** True when `scope` matches the `<source>:private:*` shape. */
+export declare function isPrivateScope(scope: string | null | undefined): boolean;
+/**
+ * Recall-side scope filter — the canonical JS half of the recall default-deny
+ * rule (the SQL half lives in `loadSearchRows` via `loadRecallSearchEntries`).
+ *
+ * - When `requested` is set and non-empty: exact match required.
+ * - When `requested` is undefined/empty: default-deny on any
+ *   `<source>:private:*` scope and on the `RECALL_DEFAULT_DENY_SCOPES`
+ *   quarantine buckets. `null` and public scopes pass.
+ *
+ * @internal v1.7.2 — exported for test parity with
+ * `RECALL_DEFAULT_DENY_SCOPES` (single-source-of-truth verification). NOT part
+ * of the public API surface; not re-exported from `src/index.ts`. Subject to
+ * change without semver bump.
+ */
+export declare function passesScopeFilterForRecall(scope: string | null, requested: string | undefined): boolean;
+/**
+ * v1.25.0 — the CLI `--scope` variant of the recall filter (JS half of the
+ * SQL 'default-deny-or-exact' mode in loadSearchRows).
+ *
+ * The CLI flag predates the envelope column as a TAG-boost ranking hint
+ * (`scope:<v>` tags, HIPPO_SCOPE, detectScope()), so an explicit `--scope X`
+ * UNLOCKS envelope scope X in addition to the default-admitted set — it does
+ * NOT narrow the result to X (that would return zero rows for every
+ * tag-scoped workflow, whose envelope scope is NULL). api.recall keeps the
+ * narrowing 'exact' semantics via `passesScopeFilterForRecall`.
+ *
+ * Note the unlock applies to whatever scope was explicitly named — including
+ * a private scope or a quarantine bucket (`--scope unknown:legacy`). That is
+ * deliberate owner access, identical in reach to api.recall's exact-match
+ * for the same input; only NON-requested private/quarantine scopes stay
+ * denied.
+ */
+export declare function passesCliRecallScopeFilter(scope: string | null, requested: string | undefined): boolean;
+//# sourceMappingURL=recall-scope.d.ts.map

package/dist/recall-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recall-scope.d.ts","sourceRoot":"","sources":["../src/recall-scope.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,QAA+B,CAAC;AAE7D,gEAAgE;AAChE,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAExE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,MAAM,GAAG,IAAI,EACpB,SAAS,EAAE,MAAM,GAAG,SAAS,GAC5B,OAAO,CAaT;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,MAAM,GAAG,IAAI,EACpB,SAAS,EAAE,MAAM,GAAG,SAAS,GAC5B,OAAO,CAKT"}

package/dist/recall-scope.js

@@ -0,0 +1,84 @@
+/**
+ * v1.25.0 — recall-side scope predicates, extracted from api.ts into a leaf
+ * module so shared.ts (which api.ts imports) can apply the same default-deny
+ * rule to searchBothHybrid's internal candidate loads without an import
+ * cycle. Mirrors the v39 `project-identity.ts` precedent. api.ts imports
+ * these for its own call sites AND re-exports them for back-compat
+ * (`api.isPrivateScope`, test imports of `passesScopeFilterForRecall`).
+ */
+import { RECALL_DEFAULT_DENY_SCOPES } from './store.js';
+/**
+ * v1.2.1: source-agnostic private-scope detector. A scope string is treated
+ * as private when it has the shape `<lowercase-source>:private:<rest>`.
+ *
+ * Examples that match:
+ *   slack:private:Cabc, github:private:owner/repo, jira:private:PROJ-1
+ * Examples that DO NOT match:
+ *   slack:public:Cgeneral, acme:public:my-private-channel, null, '',
+ *   'unknown:legacy', 'private' (alone), 'private:foo' (no source prefix).
+ *
+ * Used by api.recall, mcp/server.ts (hippo_recall + hippo_context),
+ * cli.ts (cmdRecall + cmdExplain + continuity), shared.ts (searchBothHybrid
+ * recall mode). Keep these in sync — the export is the single source of
+ * truth so connector work cannot drift.
+ */
+export const PRIVATE_SCOPE_RE = /^[a-z][a-z0-9_-]*:private:/;
+/** True when `scope` matches the `<source>:private:*` shape. */
+export function isPrivateScope(scope) {
+    return typeof scope === 'string' && PRIVATE_SCOPE_RE.test(scope);
+}
+/**
+ * Recall-side scope filter — the canonical JS half of the recall default-deny
+ * rule (the SQL half lives in `loadSearchRows` via `loadRecallSearchEntries`).
+ *
+ * - When `requested` is set and non-empty: exact match required.
+ * - When `requested` is undefined/empty: default-deny on any
+ *   `<source>:private:*` scope and on the `RECALL_DEFAULT_DENY_SCOPES`
+ *   quarantine buckets. `null` and public scopes pass.
+ *
+ * @internal v1.7.2 — exported for test parity with
+ * `RECALL_DEFAULT_DENY_SCOPES` (single-source-of-truth verification). NOT part
+ * of the public API surface; not re-exported from `src/index.ts`. Subject to
+ * change without semver bump.
+ */
+export function passesScopeFilterForRecall(scope, requested) {
+    if (requested !== undefined && requested !== '') {
+        return scope === requested;
+    }
+    if (scope === null)
+        return true;
+    if (isPrivateScope(scope))
+        return false;
+    // v1.7.2 — read from RECALL_DEFAULT_DENY_SCOPES (single source of truth
+    // shared with the SQL clause in loadSearchRows). Cast the array to
+    // readonly string[] so .includes() accepts arbitrary string scopes
+    // without a cast on the input (codex P0-2: casting `scope` would defeat
+    // the constant's safety).
+    if (RECALL_DEFAULT_DENY_SCOPES.includes(scope))
+        return false;
+    return true;
+}
+/**
+ * v1.25.0 — the CLI `--scope` variant of the recall filter (JS half of the
+ * SQL 'default-deny-or-exact' mode in loadSearchRows).
+ *
+ * The CLI flag predates the envelope column as a TAG-boost ranking hint
+ * (`scope:<v>` tags, HIPPO_SCOPE, detectScope()), so an explicit `--scope X`
+ * UNLOCKS envelope scope X in addition to the default-admitted set — it does
+ * NOT narrow the result to X (that would return zero rows for every
+ * tag-scoped workflow, whose envelope scope is NULL). api.recall keeps the
+ * narrowing 'exact' semantics via `passesScopeFilterForRecall`.
+ *
+ * Note the unlock applies to whatever scope was explicitly named — including
+ * a private scope or a quarantine bucket (`--scope unknown:legacy`). That is
+ * deliberate owner access, identical in reach to api.recall's exact-match
+ * for the same input; only NON-requested private/quarantine scopes stay
+ * denied.
+ */
+export function passesCliRecallScopeFilter(scope, requested) {
+    if (requested !== undefined && requested !== '' && scope === requested) {
+        return true;
+    }
+    return passesScopeFilterForRecall(scope, undefined);
+}
+//# sourceMappingURL=recall-scope.js.map

package/dist/recall-scope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recall-scope.js","sourceRoot":"","sources":["../src/recall-scope.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AAExD;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,4BAA4B,CAAC;AAE7D,gEAAgE;AAChE,MAAM,UAAU,cAAc,CAAC,KAAgC;IAC7D,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACnE,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,0BAA0B,CACxC,KAAoB,EACpB,SAA6B;IAE7B,IAAI,SAAS,KAAK,SAAS,IAAI,SAAS,KAAK,EAAE,EAAE,CAAC;QAChD,OAAO,KAAK,KAAK,SAAS,CAAC;IAC7B,CAAC;IACD,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAChC,IAAI,cAAc,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACxC,wEAAwE;IACxE,mEAAmE;IACnE,mEAAmE;IACnE,wEAAwE;IACxE,0BAA0B;IAC1B,IAAK,0BAAgD,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACpF,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,0BAA0B,CACxC,KAAoB,EACpB,SAA6B;IAE7B,IAAI,SAAS,KAAK,SAAS,IAAI,SAAS,KAAK,EAAE,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACvE,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,0BAA0B,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;AACtD,CAAC"}

package/dist/refine-llm.js

@@ -31,19 +31,19 @@ export async function refineSemanticMemory(merged, sources, opts) {
         .slice(0, 8)
         .map((s, i) => `[source ${i + 1}] ${s.content.slice(0, 400)}`)
         .join('\n\n');
-    const prompt = `You are refining a semantic memory in an agent's memory store. The rule-based consolidator merged several related episodic memories into one, but the output is clumsy. Produce a single coherent semantic memory that captures the underlying principle.
-
-Rules:
-- Output ONLY the refined content — no preamble, no quote marks, no "Here is...".
-- Keep it concise: one paragraph, no headers, no bullet lists unless the sources are inherently a list.
-- Preserve specific facts (names, numbers, paths, IDs) from the sources.
-- Generalize: state the pattern, not each instance.
-- Do NOT include the "[Consolidated from N ...]" marker.
-
-Current merged content:
-${merged}
-
-Source memories (up to 8 shown):
+    const prompt = `You are refining a semantic memory in an agent's memory store. The rule-based consolidator merged several related episodic memories into one, but the output is clumsy. Produce a single coherent semantic memory that captures the underlying principle.
+
+Rules:
+- Output ONLY the refined content — no preamble, no quote marks, no "Here is...".
+- Keep it concise: one paragraph, no headers, no bullet lists unless the sources are inherently a list.
+- Preserve specific facts (names, numbers, paths, IDs) from the sources.
+- Generalize: state the pattern, not each instance.
+- Do NOT include the "[Consolidated from N ...]" marker.
+
+Current merged content:
+${merged}
+
+Source memories (up to 8 shown):
 ${sourceBlock}`;
     let res;
     try {