@smartmemory/compose 0.3.6-beta → 0.3.8

package/lib/judgment/store/index.js

@@ -14,6 +14,8 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { RecordsStore } from './records.js';
 
+const EFFECTIVE_STORES = new WeakSet();
+
 function configuredProvider(cwd) {
   try {
     const config = JSON.parse(readFileSync(join(cwd, '.compose', 'compose.json'), 'utf8'));
@@ -47,3 +49,167 @@ export function createJudgmentStore(cwd) {
       throw new Error(`Unknown judgment provider '${provider}'. Valid ids: records, smartmemory.`);
   }
 }
+
+/**
+ * Construct a read-only view that excludes whole artifacts attributed to an
+ * intent which was pending when the view was created.
+ *
+ * The intent set is deliberately snapshotted once. Record files and ledger
+ * lines are filtered only by top-level provenance; nested intent attribution
+ * belongs to the containing record and is not recursively hidden.
+ *
+ * @param {RecordsStore} rawStore
+ */
+export function effectiveStore(rawStore) {
+  if (EFFECTIVE_STORES.has(rawStore)) return rawStore;
+
+  const pendingIntents = rawStore.readIntents();
+  const pendingIds = new Set(pendingIntents.map((intent) => intent.id));
+  const isVisible = (record) => (
+    record != null && !pendingIds.has(record.provenance?.intent_id)
+  );
+  const visibleOrNull = (record) => (isVisible(record) ? record : null);
+
+  const adapter = {
+    capabilities() {
+      return rawStore.capabilities();
+    },
+
+    readPositionRevision(slug, rev) {
+      return visibleOrNull(rawStore.readPositionRevision(slug, rev));
+    },
+
+    readPositionChain(slug) {
+      return rawStore.readPositionChain(slug)
+        .map((record) => adapter.readPositionRevision(slug, record.rev))
+        .filter(Boolean);
+    },
+
+    latestPositionRevision(slug) {
+      const chain = adapter.readPositionChain(slug);
+      return chain.length === 0 ? null : chain[chain.length - 1];
+    },
+
+    listPositionSlugs() {
+      return rawStore.listPositionSlugs()
+        .filter((slug) => adapter.readPositionChain(slug).length > 0);
+    },
+
+    /**
+     * @param {string} slug
+     * @param {Map} [index]  optional supersession index (lib/judgment/trace.js
+     *   buildSupersessionIndex). Callers looping over every slug should pass one:
+     *   without it this rescans all other slugs' chains per call, so a whole-store
+     *   status pass is O(n^2). Result is identical either way.
+     */
+    derivePositionStatus(slug, index) {
+      const latest = adapter.latestPositionRevision(slug);
+      if (!latest) return null;
+      if (latest.retracted === true) return 'retracted';
+      if (index) return index.get(slug)?.status ?? 'live';
+      for (const other of adapter.listPositionSlugs()) {
+        if (other === slug) continue;
+        const otherLatest = adapter.latestPositionRevision(other);
+        if (!otherLatest || otherLatest.retracted === true) continue;
+        const ref = otherLatest.supersedes;
+        if (typeof ref === 'string' && ref.startsWith(`${slug}#r`)) {
+          return 'superseded';
+        }
+      }
+      return 'live';
+    },
+
+    readJoint(slug) {
+      return visibleOrNull(rawStore.readJoint(slug));
+    },
+
+    listJoints() {
+      return rawStore.listJoints()
+        .map((record) => adapter.readJoint(record.slug))
+        .filter(Boolean);
+    },
+
+    readPrediction(id) {
+      return visibleOrNull(rawStore.readPrediction(id));
+    },
+
+    listPredictions({ status } = {}) {
+      return rawStore.listPredictions()
+        .map((record) => adapter.readPrediction(record.id))
+        .filter(Boolean)
+        .filter((record) => (status ? record.status === status : true));
+    },
+
+    readLedgerEvents() {
+      return rawStore.readLedgerEvents().filter(isVisible);
+    },
+
+    readPerson(slug) {
+      return visibleOrNull(rawStore.readPerson(slug));
+    },
+
+    listPeople() {
+      return rawStore.listPeople()
+        .map((record) => adapter.readPerson(record.slug))
+        .filter(Boolean);
+    },
+
+    readSituationEntity(slug) {
+      return visibleOrNull(rawStore.readSituationEntity(slug));
+    },
+
+    listSituationEntities() {
+      return rawStore.listSituationEntities()
+        .map((record) => adapter.readSituationEntity(record.slug))
+        .filter(Boolean);
+    },
+
+    readGoalVersion(version) {
+      return visibleOrNull(rawStore.readGoalVersion(version));
+    },
+
+    readGoalChain() {
+      return rawStore.readGoalChain()
+        .map((record) => adapter.readGoalVersion(record.version))
+        .filter(Boolean);
+    },
+
+    latestGoalVersion() {
+      const chain = adapter.readGoalChain();
+      return chain.length === 0 ? null : chain[chain.length - 1];
+    },
+
+    readGoalState() {
+      const raw = rawStore.readGoalState();
+      // Records-atomic guarantee (C3): while a goal migration is pending, a
+      // state.json the migration already wrote (attributed to that intent)
+      // must read back as the captured PREIMAGE, not as absence. Every other
+      // family hides an attributed record as null; goal state instead
+      // substitutes the pre-migration bytes the intent carries.
+      const migration = pendingIntents.find((intent) => intent.kind === 'goal_migration');
+      if (migration && raw?.provenance?.intent_id === migration.id) {
+        return migration.payload?.goal_state_preimage?.record ?? null;
+      }
+      return visibleOrNull(raw);
+    },
+
+    hasPendingIntentKind(kind) {
+      return pendingIntents.some((intent) => intent.kind === kind);
+    },
+  };
+
+  EFFECTIVE_STORES.add(adapter);
+  return Object.freeze(adapter);
+}
+
+/**
+ * True once a published goal chain exists and no goal migration is pending.
+ * Accepts either a raw RecordsStore or an already-effective view.
+ */
+export function goalCutoverComplete(store) {
+  const effective = EFFECTIVE_STORES.has(store) ? store : effectiveStore(store);
+  return (
+    effective.readGoalChain().length > 0
+    && !effective.hasPendingIntentKind('goal_migration')
+  );
+}

package/lib/judgment/store/records.js

@@ -5,6 +5,10 @@
  * (the feature.json precedent — NOT the gitignored vision store):
  *
  *   positions/<slug>/r<N>.json   append-only revision chain; highest N is current
+ *   people/<slug>.json           mutable person aggregate
+ *   situation/<slug>.json        mutable situation aggregate
+ *   goal/v<N>.json               append-only goal meaning chain
+ *   goal/state.json              mutable goal associations sidecar
  *   joints/<slug>.json           one file per joint; state lives here
  *   predictions/<id>.json        spawned by CONSTRUCT/commit events
  *   intents/<id>.json            pending-intent records (intent-first transitions)
@@ -25,7 +29,7 @@ import {
 } from 'node:fs';
 import { join } from 'node:path';
 
-function atomicWrite(path, content) {
+export function atomicWrite(path, content) {
   const tmp = `${path}.tmp.${process.pid}`;
   try {
     writeFileSync(tmp, content);
@@ -44,8 +48,6 @@ function readJson(path) {
   }
 }
 
-const REV_FILE_RE = /^r([1-9][0-9]*)\.json$/;
-
 export class RecordsStore {
   /** @param {string} cwd project root */
   constructor(cwd) {
@@ -60,18 +62,77 @@ export class RecordsStore {
 
   // ── positions ────────────────────────────────────────────────────────────
 
+  _chainNumbers({ dir, prefix }) {
+    if (!existsSync(dir)) return [];
+    const fileRe = new RegExp(`^${prefix}([1-9][0-9]*)\\.json$`);
+    return readdirSync(dir)
+      .map((file) => fileRe.exec(file))
+      .filter(Boolean)
+      .map((match) => Number(match[1]))
+      .sort((a, b) => a - b);
+  }
+
+  _appendChainRecord(config, record) {
+    mkdirSync(config.dir, { recursive: true });
+    const numbers = this._chainNumbers(config);
+    const number = (numbers.length ? numbers[numbers.length - 1] : 0) + 1;
+    const path = join(config.dir, `${config.prefix}${number}.json`);
+    atomicWrite(
+      path,
+      JSON.stringify({ ...record, [config.numberField]: number }, null, 2) + '\n',
+    );
+    return {
+      [config.numberField]: number,
+      ref: config.ref(number),
+      path,
+    };
+  }
+
+  _readChainRecord(config, number) {
+    return readJson(join(config.dir, `${config.prefix}${number}.json`));
+  }
+
+  _readChain(config) {
+    return this._chainNumbers(config)
+      .map((number) => this._readChainRecord(config, number))
+      .filter(Boolean);
+  }
+
+  _latestChainRecord(config) {
+    const numbers = this._chainNumbers(config);
+    if (numbers.length === 0) return null;
+    return this._readChainRecord(config, numbers[numbers.length - 1]);
+  }
+
+  _replaceChainRecord(config, number, record) {
+    mkdirSync(config.dir, { recursive: true });
+    const path = join(config.dir, `${config.prefix}${number}.json`);
+    atomicWrite(
+      path,
+      JSON.stringify({ ...record, [config.numberField]: number }, null, 2) + '\n',
+    );
+    return {
+      [config.numberField]: number,
+      ref: config.ref(number),
+      path,
+    };
+  }
+
   _positionDir(slug) {
     return join(this.root, 'positions', slug);
   }
 
+  _positionChain(slug) {
+    return {
+      dir: this._positionDir(slug),
+      prefix: 'r',
+      numberField: 'rev',
+      ref: (rev) => `${slug}#r${rev}`,
+    };
+  }
+
   _revNumbers(slug) {
-    const dir = this._positionDir(slug);
-    if (!existsSync(dir)) return [];
-    return readdirSync(dir)
-      .map((f) => REV_FILE_RE.exec(f))
-      .filter(Boolean)
-      .map((m) => Number(m[1]))
-      .sort((a, b) => a - b);
+    return this._chainNumbers(this._positionChain(slug));
   }
 
   /**
@@ -80,24 +141,16 @@ export class RecordsStore {
    * @returns {{ rev: number, ref: string, path: string }}
    */
   writePositionRevision(record) {
-    const dir = this._positionDir(record.slug);
-    mkdirSync(dir, { recursive: true });
-    const revs = this._revNumbers(record.slug);
-    const rev = (revs.length ? revs[revs.length - 1] : 0) + 1;
-    const path = join(dir, `r${rev}.json`);
-    atomicWrite(path, JSON.stringify({ ...record, rev }, null, 2) + '\n');
-    return { rev, ref: `${record.slug}#r${rev}`, path };
+    return this._appendChainRecord(this._positionChain(record.slug), record);
   }
 
   /** Full chain, ascending by rev. */
   readPositionChain(slug) {
-    return this._revNumbers(slug)
-      .map((n) => readJson(join(this._positionDir(slug), `r${n}.json`)))
-      .filter(Boolean);
+    return this._readChain(this._positionChain(slug));
   }
 
   readPositionRevision(slug, rev) {
-    return readJson(join(this._positionDir(slug), `r${rev}.json`));
+    return this._readChainRecord(this._positionChain(slug), rev);
   }
 
   listPositionSlugs() {
@@ -111,9 +164,7 @@ export class RecordsStore {
 
   /** Latest revision of a chain, or null. */
   latestPositionRevision(slug) {
-    const revs = this._revNumbers(slug);
-    if (revs.length === 0) return null;
-    return this.readPositionRevision(slug, revs[revs.length - 1]);
+    return this._latestChainRecord(this._positionChain(slug));
   }
 
   /**
@@ -134,6 +185,110 @@ export class RecordsStore {
     return 'live';
   }
 
+  // ── goal ─────────────────────────────────────────────────────────────────
+
+  _goalDir() {
+    return join(this.root, 'goal');
+  }
+
+  _goalChain() {
+    return {
+      dir: this._goalDir(),
+      prefix: 'v',
+      numberField: 'version',
+      ref: (version) => `goal:v${version}`,
+    };
+  }
+
+  writeGoalVersion(record) {
+    return this._appendChainRecord(this._goalChain(), record);
+  }
+
+  readGoalVersion(version) {
+    return this._readChainRecord(this._goalChain(), version);
+  }
+
+  readGoalChain() {
+    return this._readChain(this._goalChain());
+  }
+
+  latestGoalVersion() {
+    return this._latestChainRecord(this._goalChain());
+  }
+
+  replaceGoalVersion(version, record) {
+    return this._replaceChainRecord(this._goalChain(), version, record);
+  }
+
+  _goalStatePath() {
+    return join(this._goalDir(), 'state.json');
+  }
+
+  writeGoalState(record) {
+    mkdirSync(this._goalDir(), { recursive: true });
+    atomicWrite(this._goalStatePath(), JSON.stringify(record, null, 2) + '\n');
+    return { path: this._goalStatePath() };
+  }
+
+  readGoalState() {
+    return readJson(this._goalStatePath());
+  }
+
+  // ── people ───────────────────────────────────────────────────────────────
+
+  _personPath(slug) {
+    return join(this.root, 'people', `${slug}.json`);
+  }
+
+  writePerson(record) {
+    mkdirSync(join(this.root, 'people'), { recursive: true });
+    atomicWrite(this._personPath(record.slug), JSON.stringify(record, null, 2) + '\n');
+    return { slug: record.slug };
+  }
+
+  readPerson(slug) {
+    return readJson(this._personPath(slug));
+  }
+
+  listPeople() {
+    const dir = join(this.root, 'people');
+    if (!existsSync(dir)) return [];
+    return readdirSync(dir)
+      .filter((file) => file.endsWith('.json'))
+      .sort()
+      .map((file) => readJson(join(dir, file)))
+      .filter(Boolean);
+  }
+
+  // ── situation ────────────────────────────────────────────────────────────
+
+  _situationEntityPath(slug) {
+    return join(this.root, 'situation', `${slug}.json`);
+  }
+
+  writeSituationEntity(record) {
+    mkdirSync(join(this.root, 'situation'), { recursive: true });
+    atomicWrite(
+      this._situationEntityPath(record.slug),
+      JSON.stringify(record, null, 2) + '\n',
+    );
+    return { slug: record.slug };
+  }
+
+  readSituationEntity(slug) {
+    return readJson(this._situationEntityPath(slug));
+  }
+
+  listSituationEntities() {
+    const dir = join(this.root, 'situation');
+    if (!existsSync(dir)) return [];
+    return readdirSync(dir)
+      .filter((file) => file.endsWith('.json'))
+      .sort()
+      .map((file) => readJson(join(dir, file)))
+      .filter(Boolean);
+  }
+
   // ── joints ───────────────────────────────────────────────────────────────
 
   _jointPath(slug) {
@@ -241,6 +396,10 @@ export class RecordsStore {
   }
 
   clearIntent(id) {
-    try { unlinkSync(this._intentPath(id)); } catch { /* already cleared */ }
+    try {
+      unlinkSync(this._intentPath(id));
+    } catch (err) {
+      if (err?.code !== 'ENOENT') throw err;
+    }
   }
 }