@smartmemory/compose 0.3.6-beta → 0.3.7

package/lib/hooks-status.js

@@ -24,6 +24,14 @@ export const HOOK_MARKERS = {
   'pre-push': '# Compose pre-push hook —',
 };
 
+/**
+ * Current baked versions for hooks whose content contract is versioned.
+ * Post-commit remains unversioned until its template changes.
+ */
+export const HOOK_VERSIONS = {
+  'pre-push': '1',
+};
+
 /** The hook types Compose manages, in display order. */
 export const HOOK_TYPE_LIST = Object.keys(HOOK_MARKERS);
 
@@ -33,6 +41,12 @@ export function extractBakedWorkspaceId(content) {
   return m ? m[1] : null;
 }
 
+/** Pull the baked HOOK_VERSION="..." value out of hook content, or null. */
+export function extractBakedHookVersion(content) {
+  const m = content.match(/^HOOK_VERSION="([^"]*)"$/m);
+  return m ? m[1] : null;
+}
+
 /**
  * Compute the raw status facts for every managed hook type.
  *
@@ -55,15 +69,19 @@ export function computeHooksStatus({ projectRoot, expectedWsId = null, composeNo
 
 function computeOne({ type, hooksDir, expectedWsId, composeNode, composeBin }) {
   const marker = HOOK_MARKERS[type];
+  const expectedVersion = HOOK_VERSIONS[type] ?? null;
   const dest = join(hooksDir, type);
 
   const empty = {
     reason: null,
     bakedWorkspace: null,
+    bakedVersion: null,
+    expectedVersion,
     expectedWorkspace: expectedWsId ?? null,
     wsVerified: false,
     nodeMatch: false,
     binMatch: false,
+    versionMatch: false,
   };
 
   if (!existsSync(dest)) return { state: 'absent', ...empty };
@@ -75,26 +93,33 @@ function computeOne({ type, hooksDir, expectedWsId, composeNode, composeBin }) {
   const binMatch = content.includes(`COMPOSE_BIN="${composeBin}"`);
   const hasRawToken = content.includes('__COMPOSE_WORKSPACE_ID__');
   const bakedWorkspace = extractBakedWorkspaceId(content);
+  const bakedVersion = extractBakedHookVersion(content);
+  const versionMatch = expectedVersion == null || bakedVersion === expectedVersion;
   // Mirror of statusOne: raw token never matches; a known expected id must match
   // the baked value; an unknown (null) expected id is treated leniently as a match.
   const wsMatch = hasRawToken ? false : expectedWsId ? content.includes(`COMPOSE_WORKSPACE_ID="${expectedWsId}"`) : true;
 
   const base = {
     bakedWorkspace,
+    bakedVersion,
+    expectedVersion,
     expectedWorkspace: expectedWsId ?? null,
     wsVerified: expectedWsId != null,
     nodeMatch,
     binMatch,
+    versionMatch,
   };
 
-  if (nodeMatch && binMatch && wsMatch && !hasRawToken) {
+  if (nodeMatch && binMatch && wsMatch && !hasRawToken && versionMatch) {
     return { state: 'installed-current', reason: null, ...base };
   }
   const reason = hasRawToken
     ? 'MISSING_WORKSPACE_ID'
     : expectedWsId && !wsMatch
       ? 'STALE_WORKSPACE_ID'
-      : 'stale paths';
+      : !nodeMatch || !binMatch
+        ? 'stale paths'
+        : 'HOOK_VERSION_DRIFT';
   return { state: 'installed-stale', reason, ...base };
 }
 
@@ -118,6 +143,7 @@ export function formatHookStatusLines(type, s, { composeNode, composeBin }) {
   // installed-stale
   const lines = [`${type}: installed (${s.reason} — re-run install)`];
   if (s.reason === 'STALE_WORKSPACE_ID') lines.push(`  expected COMPOSE_WORKSPACE_ID="${s.expectedWorkspace}"`);
+  if (s.reason === 'HOOK_VERSION_DRIFT') lines.push(`  expected HOOK_VERSION="${s.expectedVersion}"`);
   if (!s.nodeMatch) lines.push(`  expected COMPOSE_NODE="${composeNode}"`);
   if (!s.binMatch) lines.push(`  expected COMPOSE_BIN="${composeBin}"`);
   return lines;
@@ -126,10 +152,13 @@ export function formatHookStatusLines(type, s, { composeNode, composeBin }) {
 /**
  * @typedef {object} HookStatusRaw
  * @property {'absent'|'foreign'|'installed-current'|'installed-stale'} state
- * @property {null|'MISSING_WORKSPACE_ID'|'STALE_WORKSPACE_ID'|'stale paths'} reason
+ * @property {null|'MISSING_WORKSPACE_ID'|'STALE_WORKSPACE_ID'|'stale paths'|'HOOK_VERSION_DRIFT'} reason
  * @property {string|null} bakedWorkspace
+ * @property {string|null} bakedVersion
+ * @property {string|null} expectedVersion
  * @property {string|null} expectedWorkspace
  * @property {boolean} wsVerified
  * @property {boolean} nodeMatch
  * @property {boolean} binMatch
+ * @property {boolean} versionMatch
  */

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,159 @@ 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);
+    },
+
+    derivePositionStatus(slug) {
+      const latest = adapter.latestPositionRevision(slug);
+      if (!latest) return null;
+      if (latest.retracted === true) return 'retracted';
+      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)
@@ -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;
+    }
   }
 }