@remnic/core 9.26.0 → 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/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);