@remnic/core 9.25.7 → 9.27.0

package/src/storage.ts

@@ -20,6 +20,7 @@ import path from "node:path";
 import { log } from "./logger.js";
 import { assertMemoryFrontmatterId, warnProjectionFallback } from "./storage-guards.js";
 import { MemoryReadStore } from "./storage/memory-read-store.js";
+import { renderProfileWithLastUpdated } from "./storage/profile-header.js";
 import { readMaybeEncryptedLines, readMemoryActionEventRowsFromLines } from "./storage/secure-line-reader.js";
 import {
   appendLifecycleEventsSerialized,
@@ -4251,15 +4252,13 @@ export class StorageManager {
   }
 
   async writeProfile(content: string): Promise<void> {
+    const stampedContent = renderProfileWithLastUpdated(content, new Date().toISOString());
     await this.ensureDirectories();
     await this.snapshotBeforeWrite(this.profilePath, "consolidation");
-    await this.writeStorageSecureFile(this.profilePath, content);
+    await this.writeStorageSecureFile(this.profilePath, stampedContent);
     log.debug("updated profile.md");
   }
 
-  /**
-   * Normalize a string for fuzzy profile dedup: lowercase, strip punctuation, collapse whitespace.
-   */
   private static normalizeForDedup(s: string): string {
     if (typeof s !== "string") return "";
     return s
@@ -4308,15 +4307,13 @@ export class StorageManager {
       const content = [
         "# Behavioral Profile",
         "",
-        `*Last updated: ${new Date().toISOString()}*`,
-        "",
         ...newBullets.map((b) => `- ${b}`),
         "",
       ].join("\n");
       await this.writeProfile(content);
     } else {
-      const updatedTimestamp = existing.replace(/\*Last updated:.*\*/, `*Last updated: ${new Date().toISOString()}*`);
-      const withBullets = updatedTimestamp.trimEnd() + "\n" + newBullets.map((b) => `- ${b}`).join("\n") + "\n";
+      const withBullets =
+        existing.trimEnd() + "\n" + newBullets.map((b) => `- ${b}`).join("\n") + "\n";
       await this.writeProfile(withBullets);
     }
   }

package/src/testing/lifecycle-matrix.ts

@@ -15,13 +15,13 @@
  * `MATRIX_ROWS` entry. Adding a row here is a one-file change that
  * automatically extends every adopter — the whole point of the harness.
  *
- * Test-support only: this file lives under `src/testing/` (a subdirectory, so
- * tsup — which entry-points only top-level `src/*.ts` and the public exports —
- * never bundles it) and is intentionally absent from package.json `exports`.
- * It imports `node:test` and must NEVER be imported by runtime code.
+ * Test-support only: this file lives under `src/testing/` and is exported solely
+ * so adapter test subjects can share the canonical matrix across packages.
+ * The registrar loads `node:test` through `createRequire` so the built artifact
+ * keeps the builtin specifier, and runtime code must never import this module.
  */
 
-import test from "node:test";
+import { createRequire } from "node:module";
 
 /** The nine canonical AGENTS.md session/retrieval/cache matrix rows. */
 export type MatrixRowId =
@@ -215,13 +215,23 @@ export interface RunLifecycleMatrixOptions {
 export function lifecycleTestName(subjectName: string, row: MatrixRow): string {
   return `lifecycle-matrix[${subjectName}] :: ${row.id} — ${row.title}`;
 }
+type NodeTestRegistrar = {
+  (name: string, fn: () => void | Promise<void>): void;
+  (name: string, options: { skip: string }, fn: () => void): void;
+};
+
+const requiredNodeTest = createRequire(import.meta.url)("node:test") as
+  | NodeTestRegistrar
+  | { test: NodeTestRegistrar };
+const nodeTest: NodeTestRegistrar =
+  typeof requiredNodeTest === "function" ? requiredNodeTest : requiredNodeTest.test;
 
 const defaultRegister: MatrixTestRegistrar = (name, fn) => {
-  test(name, fn);
+  nodeTest(name, fn);
 };
 
 const defaultRegisterSkipped: MatrixSkipRegistrar = (name, reason) => {
-  test(name, { skip: reason }, () => {});
+  nodeTest(name, { skip: reason }, () => {});
 };
 
 /**

package/src/testing/subjects/profile-header-write.test.ts

@@ -0,0 +1,71 @@
+/**
+ * Profile-header write-boundary subject for the lifecycle scenario matrix.
+ * Profile content is not session state, so only the session-end mutation row
+ * applies; the remaining canonical rows are explicit skips rather than false
+ * extraction-lifecycle coverage.
+ */
+
+import assert from "node:assert/strict";
+
+import { StorageManager } from "../../storage.js";
+import { type LifecycleSubject, type MatrixRow, runLifecycleMatrix } from "../lifecycle-matrix.js";
+import { cleanupDir, mkTempMemoryDir } from "../orchestrator-lite.js";
+
+interface ProfileHeaderState {
+  dir: string;
+  storage: StorageManager;
+  writeStartedAt?: number;
+}
+
+const STALE_PROFILE = [
+  "# Behavioral Profile",
+  "",
+  "*Last updated: 2024-01-02T03:04:05.000Z*",
+  "",
+  "- Profile content survives the write boundary.",
+  "",
+].join("\n");
+
+const subject: LifecycleSubject<ProfileHeaderState> = {
+  appliesTo(row: MatrixRow): boolean | string {
+    return row.id === "session-end"
+      ? true
+      : "profile writes have no provider, restart, or replay variants; direct profile tests cover those boundaries";
+  },
+
+  async setup(row: MatrixRow): Promise<ProfileHeaderState> {
+    const dir = await mkTempMemoryDir(`profile-header-${row.id}`);
+    try {
+      return { dir, storage: new StorageManager(dir) };
+    } catch (error) {
+      await cleanupDir(dir);
+      throw error;
+    }
+  },
+
+  async exercise(state: ProfileHeaderState): Promise<void> {
+    state.writeStartedAt = Date.now();
+    await state.storage.writeProfile(STALE_PROFILE);
+  },
+
+  async invariants(state: ProfileHeaderState): Promise<void> {
+    const profile = await state.storage.readProfile();
+    const headers = profile.match(/^\*Last updated: .*\*$/gm) ?? [];
+    assert.equal(headers.length, 1, "profile writes leave one canonical Last updated header");
+    assert.notEqual(headers[0], "*Last updated: 2024-01-02T03:04:05.000Z*");
+    assert.match(profile, /^# Behavioral Profile$/m);
+
+    const timestamp = headers[0]?.match(/^\*Last updated: ([^*]+)\*$/)?.[1];
+    assert.ok(timestamp, "the canonical header contains an ISO timestamp");
+    const updatedAt = Date.parse(timestamp);
+    assert.ok(Number.isFinite(updatedAt), "the profile header timestamp is parseable");
+    assert.ok(updatedAt >= (state.writeStartedAt ?? 0), "the header advances at the write boundary");
+    assert.ok(updatedAt <= Date.now(), "the header is not in the future");
+  },
+
+  async teardown(state: ProfileHeaderState): Promise<void> {
+    await cleanupDir(state.dir);
+  },
+};
+
+runLifecycleMatrix("profile-header-write", subject);