@oortmem/core 0.5.0 → 0.5.2

package/dist/model.d.ts

@@ -1,5 +1,13 @@
 import type { Address, Author, Provenance } from './address.js';
-export type MemoryType = 'semantic' | 'episodic' | 'procedural' | 'preference';
+import type { Judgment } from './judgment.js';
+/**
+ * `judgment` (CON-71) is an expert's recorded decision: written only through the explicit
+ * judgment path (`recordJudgment`), never by the write path's gate or writer, and always with a
+ * `judgment` record next to the text.
+ */
+export type MemoryType = 'semantic' | 'episodic' | 'procedural' | 'preference' | 'judgment';
+/** The types the write path (gate and writer) can give a memory: every type but `judgment`. */
+export type ObservedMemoryType = Exclude<MemoryType, 'judgment'>;
 export type Tier = 'hot' | 'warm' | 'cold';
 /**
  * The pre-level view of where a memory lives. For a Planet memory (every
@@ -73,6 +81,11 @@ export interface Memory {
     supersedes: string | null;
     supersededBy: string | null;
     source: MemorySource;
+    /**
+     * The expert's decision, verbatim, on a `judgment` memory (CON-71); absent on every other type.
+     * `text` is a rendering of it for recall; this record is what judging reads.
+     */
+    judgment?: Judgment;
     embedding?: Int8Array;
     createdAt: string;
     updatedAt: string;

package/dist/observe.js

@@ -84,7 +84,9 @@ async function candidatesFor(store, text, v, grant, now) {
     const out = [];
     for (const id of ids) {
         const m = await store.get(grant, id);
-        if (m !== null && isLive(m, now))
+        // A judgment (CON-71) is the expert's own words: the write path never refines, supersedes or
+        // corrects one. Only the judgment commands change it.
+        if (m !== null && isLive(m, now) && m.type !== 'judgment')
             out.push(m);
         if (out.length === CANDIDATES)
             break;

package/dist/recall.d.ts

@@ -31,6 +31,8 @@ export interface RecallQuery {
      * or `knownAt`, the mode is read from the query ("on 2 April", "how has … changed").
      */
     mode?: RecallMode;
+    /** Also return withdrawn judgments (CON-71), in any mode. Default false. */
+    includeWithdrawn?: boolean;
 }
 /** The temporal view a recall used, and whether it was read from the query. */
 export interface RecallTemporal {

package/dist/recall.js

@@ -31,6 +31,8 @@ export async function recall(q, deps) {
     // Scrub once: the query text reaches embedders and rerankers, which may be remote. Temporal
     // words ("on 2 April", "changed over time") pick the view and are not searched for.
     const { view, temporal, text } = viewFor(q, scrub(q.text).text, now);
+    if (q.includeWithdrawn === true)
+        view.includeWithdrawn = true;
     const t0 = clock();
     const degraded = [];
     const timings = {

package/dist/store-conformance.js

@@ -727,6 +727,35 @@ function levelConformance(name, make) {
             });
             expect(authorOf(got)).toEqual({ agentId: 'claude-code' });
         });
+        it('levels.judgment-roundtrips', async () => {
+            // CON-71: a judgment memory keeps its `judgment` record exactly, cold copy included.
+            const m = makeMemory({
+                id: 'judgment-1',
+                scope: localScope(undefined),
+                type: 'judgment',
+                pinned: true,
+                embedding: vec(4, 3, 2, 1),
+                judgment: {
+                    subject: { summary: 'Post claims a cure', ref: 'https://example.test/p/1' },
+                    verdict: 'rejected',
+                    verdicts: ['approved', 'rejected'],
+                    reason: 'No cited source.\nSecond line, verbatim.',
+                    criteria: ['no-source'],
+                    domain: 'content',
+                    by: 'ada',
+                    decidedAt: '2026-01-01T00:00:00.000Z',
+                    via: 'cli',
+                    withdrawn: { at: '2026-02-01T00:00:00.000Z', by: 'ada' },
+                },
+            });
+            await store.upsert(TG, m);
+            expect(await store.get(TG, 'judgment-1')).toEqual(m);
+            const plain = makeMemory({ id: 'plain-1', scope: localScope(undefined) });
+            await store.upsert(TG, plain);
+            expect('judgment' in (await store.get(TG, 'plain-1'))).toBe(false);
+            expect((await store.coldPut(TG, m)).skipped).toEqual([]);
+            expect(await store.coldGet(TG, 'judgment-1')).toEqual(m);
+        });
         it('levels.every-level-roundtrips', async () => {
             for (const c of cases()) {
                 await store.upsert(c.g, c.m);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oortmem/core",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Oort core: the tiered hot, warm and cold memory engine for AI agents (types, scoring, recall, consolidation).",
   "keywords": [
     "oort",