@gamaze/hicortex 0.20.9 → 0.21.0

package/dist/storage.js

@@ -39,11 +39,13 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FTS_MATCH_MAX_TOKENS = void 0;
 exports.embedToBlob = embedToBlob;
+exports.sanitizeSourceMachine = sanitizeSourceMachine;
 exports.insertMemory = insertMemory;
 exports.resolveMemoryId = resolveMemoryId;
 exports.getMemory = getMemory;
 exports.updateMemory = updateMemory;
 exports.strengthenMemory = strengthenMemory;
+exports.enrichMemory = enrichMemory;
 exports.touchMemoriesShown = touchMemoriesShown;
 exports.deleteMemory = deleteMemory;
 exports.memoryRowid = memoryRowid;
@@ -90,6 +92,18 @@ function rowToMemory(row) {
 // ---------------------------------------------------------------------------
 // Single memory CRUD
 // ---------------------------------------------------------------------------
+/**
+ * #421 machine × harness identity: optional capture-machine provenance on
+ * /ingest + /distill. A string, trimmed, capped at 128 chars; anything else
+ * (absent, wrong type, blank) becomes NULL — a wrong machine name is worse
+ * than none. Never filtered; presentation grouping only.
+ */
+function sanitizeSourceMachine(v) {
+    if (typeof v !== "string")
+        return null;
+    const t = v.trim();
+    return t.length > 0 ? t.slice(0, 128) : null;
+}
 /**
  * Insert a memory and its vector embedding. Returns the memory's UUID.
  *
@@ -108,9 +122,9 @@ function insertMemory(db, content, embedding, opts = {}) {
         .prepare(`INSERT OR IGNORE INTO memories
        (id, content, base_strength, last_accessed, access_count,
         created_at, ingested_at, source_agent, source_agent_id, source_session,
-        source_domain, project, privacy, memory_type)
-       VALUES (?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-        .run(id, content, opts.baseStrength ?? 0.5, ts, ts, ingestedTs, opts.sourceAgent ?? "default", opts.sourceAgentId ?? null, sourceSession, opts.sourceDomain ?? null, opts.project ?? null, opts.privacy ?? null, opts.memoryType ?? "experience");
+        source_domain, project, privacy, memory_type, source_machine)
+       VALUES (?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+        .run(id, content, opts.baseStrength ?? 0.5, ts, ts, ingestedTs, opts.sourceAgent ?? "default", opts.sourceAgentId ?? null, sourceSession, opts.sourceDomain ?? null, opts.project ?? null, opts.privacy ?? null, opts.memoryType ?? "experience", opts.sourceMachine ?? null);
     if (result.changes > 0) {
         // New row — store its vector.
         db.prepare("INSERT INTO memory_vectors (id, embedding) VALUES (?, ?)").run(id, embedToBlob(embedding));
@@ -172,6 +186,10 @@ const ALLOWED_UPDATE_FIELDS = new Set([
     // reconsolidation stage, explicit ingest marks, and history rollback.
     // Code-defined vocabulary — see Memory.status.
     "status",
+    // Importance scored-at watermark (#425, migration v19): written by
+    // stageImportance, the enrich path, and the rescore-importance backfill —
+    // the moment a row's base_strength is settled under some rubric.
+    "importance_scored_at",
 ]);
 /**
  * Update specific fields on a memory.
@@ -198,6 +216,42 @@ function strengthenMemory(db, memoryId, nowIsoStr) {
      SET access_count = access_count + 1, last_accessed = ?
      WHERE id = ?`).run(nowIsoStr, memoryId);
 }
+/**
+ * Record an owner corroboration (#423 phase 3): one UPDATE that bumps
+ * corroboration_count, nudges base_strength up by the calibration delta
+ * (MIN-capped at the importance ceiling, #425; COALESCE keeps NULL bases
+ * honest — the unscored default), stamps the importance watermark, and
+ * refreshes last_accessed (the console's "last confirmed" cell reads it: an
+ * enrich IS a confirmation, and it keeps the stage fading gate honest).
+ * EVIDENCE ABOUT IMPORTANCE ONLY — never access_count (reserved for real
+ * recall use) nor shown_count (index exposure): faking either corrupts the
+ * uses-per-showing adoption metric.
+ *
+ * Nightly interaction: the importance pool keys on importance_scored_at IS
+ * NULL (#425), so the watermark stamp here keeps the pre-#425 contract — an
+ * enriched memory leaves the pool and the owner's mark stands in for (and is
+ * never stomped by) the first LLM score. Dedup merges take
+ * max(base_strength), so a merge never loses the mark. Returns the fresh row
+ * values (re-read after the update); null when the id matches nothing.
+ */
+function enrichMemory(db, memoryId, nowIsoStr) {
+    const result = db
+        .prepare(`UPDATE memories
+       SET corroboration_count = corroboration_count + 1,
+           base_strength = MIN(?, COALESCE(base_strength, 0.5) + ?),
+           importance_scored_at = COALESCE(importance_scored_at, ?),
+           last_accessed = ?
+       WHERE id = ?`)
+        .run(CALIBRATION.IMPORTANCE_CEILING, CALIBRATION.ENRICH_STRENGTH_DELTA, nowIsoStr, nowIsoStr, memoryId);
+    if (result.changes === 0)
+        return null;
+    const row = db
+        .prepare("SELECT corroboration_count, base_strength FROM memories WHERE id = ?")
+        .get(memoryId);
+    return row
+        ? { corroborationCount: row.corroboration_count, baseStrength: row.base_strength }
+        : null;
+}
 /**
  * Record that memories appeared in a pushed recall index (#192): bump
  * shown_count and refresh last_accessed (a mild strengthen — the decay clock
@@ -679,14 +733,17 @@ function getAllLinkCounts(db) {
     return counts;
 }
 /**
- * Get all memories with default base_strength (never scored).
- * Absorbed memories are excluded (#384): they are invisible to recall, so
+ * Get all never-scored memories — the nightly importance pool, keyed on the
+ * importance_scored_at watermark (#425, migration v19). The pre-v19 sentinel
+ * (`base_strength = 0.5`) re-rolled every row the model genuinely scored
+ * 0.5, every night; NULL watermark = never scored under ANY rubric. Absorbed
+ * memories are excluded (#384): they are invisible to recall, so
  * importance-scoring one would spend an LLM call on dead evidence.
  */
 function getUnscoredMemories(db) {
     const rows = db
         .prepare(`SELECT * FROM memories
-       WHERE base_strength = 0.5 AND COALESCE(status, '') != 'absorbed'
+       WHERE importance_scored_at IS NULL AND COALESCE(status, '') != 'absorbed'
        ORDER BY ingested_at ASC`)
         .all();
     return rows.map(rowToMemory);

package/dist/types.d.ts

@@ -42,6 +42,26 @@ export interface Memory {
      * kept as evidence and rollback reference).
      */
     status?: string | null;
+    /**
+     * Explicit owner corroboration count (#423 phase 3, migration v17). Each
+     * POST /enrich bumps it together with base_strength (+the calibration
+     * delta, capped at the importance ceiling) — EVIDENCE ABOUT IMPORTANCE,
+     * never access (access_count) nor index exposure (shown_count). Optional
+     * because rowToMemory is a cast over SELECT * rows; 0 (the column default)
+     * on all pre-v17 rows and until first enriched.
+     */
+    corroboration_count?: number;
+    /**
+     * Importance scored-at watermark (#425, migration v19). NULL = never
+     * scored (the nightly's unscored pool); a timestamp = this row's
+     * base_strength is settled under some rubric and the nightly will not
+     * re-roll it. Written by stageImportance, the enrich path (the owner's
+     * mark stands in for the first LLM score), and the rescore-importance
+     * backfill. Optional because rowToMemory is a cast over SELECT * rows;
+     * pre-v19 rows were stamped by the migration backfill (except sentinel
+     * rows, which stay NULL for exactly one scoring under the new rubric).
+     */
+    importance_scored_at?: string | null;
 }
 /** A link between two memories. */
 export interface MemoryLink {
@@ -282,6 +302,30 @@ export interface ConsolidationReport {
             explicit_divergent: number;
             /** reconsolidationCursor after this run (unchanged in dry-run). */
             cursor: number;
+            /**
+             * #439: verdict calls on pairs whose candidate rowid was at/below the
+             * run-start scan high-water (state.reconsolidationScannedRowid) —
+             * re-judgments of work a prior run already judged but could not apply
+             * (the cursor held below it). Convergence evidence: this number must
+             * fall to 0 once the backlog drains. pairs_evaluated =
+             * pairs_reevaluated + pairs_new.
+             */
+            pairs_reevaluated: number;
+            /** #439: verdict calls on candidates ABOVE the high-water — first-time judgments. */
+            pairs_new: number;
+            /**
+             * #439: snapshot candidates skipped because a mid-scan absorb (a merge
+             * loser or rewrite trigger absorbed at an earlier candidate's boundary)
+             * had already absorbed them — the scan-stability guard.
+             */
+            skipped_absorbed: number;
+            /**
+             * #439: confirmed merge pairs still un-applied at run end — deadline
+             * deferrals at a boundary, a failed pre-merge backup, and lock-busy
+             * survivors of the final drain. Each holds the cursor below its
+             * candidate and re-detects next run.
+             */
+            merge_pairs_deferred: number;
             /**
              * #392: the deterministic merge zone's own report (pairs >= the
              * ceiling, union-find merged, zero LLM). Present on every run —
@@ -746,6 +790,10 @@ export interface InsertMemoryOptions {
     sourceAgentId?: string | null;
     /** Client-declared topic/domain of the capturing agent. Provenance only. */
     sourceDomain?: string | null;
+    /** Machine the capture ran on (#421 machine × harness identity). Provenance
+     *  only — stamped by the nightly (config `machineName` ?? os.hostname()),
+     *  accepted optionally from /distill + /ingest. Null on pre-v15 rows. */
+    sourceMachine?: string | null;
     project?: string | null;
     /** 0.16.x: vestigial — stored but never filtered. null (or absent) when the
      *  caller doesn't declare one; an explicit value is honored as-is. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamaze/hicortex",
-  "version": "0.20.9",
+  "version": "0.21.0",
   "description": "Persistent agent identity for AI agents \u2014 a hand-edited identity layer, nightly-distilled experience, and lessons injected every session, shared across your whole fleet. Works with Hermes, OpenClaw, Claude Code, Pi, and opencode.",
   "main": "dist/index.js",
   "bin": {
@@ -43,6 +43,8 @@
     "test:watch": "vitest",
     "eval": "node dist/eval/run-eval.js",
     "eval:planted": "node dist/eval/planted-eval.js",
+    "eval:ranking": "node dist/eval/ranking-eval.js",
+    "eval:importance": "node dist/eval/importance-eval.js",
     "eval:recall-sweep": "node dist/eval/recall-sweep.js",
     "eval:relevance": "node dist/eval/relevance-eval.js",
     "prepack": "npm run build && rm -rf ./hermes-plugin && mkdir -p ./hermes-plugin && cp -r ../../hermes-plugin/hicortex ./hermes-plugin/ && find ./hermes-plugin -name __pycache__ -type d -exec rm -rf {} + 2>/dev/null || true && rm -rf ./pi-extension && mkdir -p ./pi-extension && cp -r ../../pi-extension/hicortex ./pi-extension/ && rm -rf ./opencode-plugin && mkdir -p ./opencode-plugin && cp -r ../../opencode-plugin/hicortex ./opencode-plugin/",