synomem 0.4.0 → 0.5.0

package/src/projections.ts

@@ -749,6 +749,14 @@ export class ProjectionManager implements ProjectionWriter {
     return { generated: generated.sort(), removed: removed.sort() };
   }
 
+  /*
+   * The paths a rebuild would produce, for comparison against the manifest.
+   *
+   * Directories are named by HANDLE, matching what the writers above create,
+   * while the record filters match on the canonical agent ID, which is what
+   * stored events carry. Mixing the two up makes the comparison never agree,
+   * and `doctor` then reports every workspace's projections as stale forever.
+   */
   expectedPaths(): string[] {
     const profiles = this.storage.listAgents();
     const events = this.storage.getReadableEvents();
@@ -757,10 +765,12 @@ export class ProjectionManager implements ProjectionWriter {
     const tasks = taskRecordsFromEvents(events);
     const paths: string[] = [];
     for (const profile of profiles) {
-      paths.push(`${profile.id}/profile.json`);
-      if (this.storage.config.projection.writeWinsMarkdown) paths.push(`${profile.id}/WINS.md`);
-      if (this.storage.config.projection.writeMemoryMarkdown) paths.push(`${profile.id}/MEMORY.md`);
-      if (this.storage.config.projection.writeTasksMarkdown) paths.push(`${profile.id}/TASKS.md`);
+      paths.push(`${profile.handle}/profile.json`);
+      if (this.storage.config.projection.writeWinsMarkdown) paths.push(`${profile.handle}/WINS.md`);
+      if (this.storage.config.projection.writeMemoryMarkdown)
+        paths.push(`${profile.handle}/MEMORY.md`);
+      if (this.storage.config.projection.writeTasksMarkdown)
+        paths.push(`${profile.handle}/TASKS.md`);
       if (this.storage.config.projection.writeInboxEntries) {
         for (const record of records.filter(
           (item) =>
@@ -768,19 +778,19 @@ export class ProjectionManager implements ProjectionWriter {
             item.status === 'unacknowledged' &&
             item.revocationStatus === 'active',
         )) {
-          paths.push(`${profile.id}/inbox/kudos/${record.event.id}.md`);
+          paths.push(`${profile.handle}/inbox/kudos/${record.event.id}.md`);
         }
         for (const record of memos.filter(
           (item) => item.event.recipientAgentId === profile.id && item.status === 'unread',
         )) {
-          paths.push(`${profile.id}/inbox/memos/${record.event.id}.md`);
+          paths.push(`${profile.handle}/inbox/memos/${record.event.id}.md`);
         }
         for (const record of tasks.filter(
           (item) =>
             item.event.assigneeAgentId === profile.id &&
             (item.status === 'open' || item.status === 'assigned'),
         )) {
-          paths.push(`${profile.id}/inbox/tasks/${record.event.id}.md`);
+          paths.push(`${profile.handle}/inbox/tasks/${record.event.id}.md`);
         }
       }
     }

package/src/service.ts

@@ -19,6 +19,7 @@ import type {
   CreateTodoResult,
   CreateTaskResult,
   DoctorResult,
+  ProjectionStatus,
   GiveKudosInput,
   GiveKudosResult,
   ItemListInput,
@@ -213,6 +214,13 @@ export interface SynomemService extends SynomemDomainService {
   doctor(): Promise<DoctorResult>;
   export(format: 'json' | 'jsonl' | 'markdown'): Promise<string>;
   backup?(destination: string): Promise<string>;
+  /*
+   * Optional, because only a backend that writes projected files can report on
+   * them. The remote backend keeps no filesystem projections at all, and
+   * inventing an empty answer there would read as "nothing is stale" rather
+   * than "there is nothing to be stale".
+   */
+  projectionStatus?(): Promise<ProjectionStatus>;
   rebuild(): Promise<ProjectionRebuildResult>;
   capabilities(): Promise<SynomemServiceCapabilities>;
   info(): Promise<SynomemServiceInfo>;

package/src/storage.ts

@@ -2041,6 +2041,15 @@ export class SynomemStorage implements SynomemRepository {
     ).map((row) => row.path);
   }
 
+  /** The manifest with the time each path was written, newest first. */
+  projectionManifestEntries(): { path: string; generatedAt: string }[] {
+    return (
+      this.db()
+        .prepare('SELECT path, generated_at FROM projection_manifest ORDER BY generated_at DESC')
+        .all() as unknown as { path: string; generated_at: string }[]
+    ).map((row) => ({ path: row.path, generatedAt: row.generated_at }));
+  }
+
   integrityCheck(): string[] {
     const rows = this.db().prepare('PRAGMA integrity_check').all() as unknown as Record<
       string,

package/src/types.ts

@@ -737,6 +737,27 @@ export interface DoctorResult {
   healthy: boolean;
   diagnostics: Diagnostic[];
 }
+/**
+ * What the projected files on disk look like next to what they should be.
+ *
+ * Projections are derived, never canonical, so this reports drift rather than
+ * damage: `missing` and `unexpected` are both repaired by a rebuild, and
+ * neither means an event was lost.
+ */
+export interface ProjectionStatus {
+  /** Where projected files live. Absent on a backend that projects nothing. */
+  directory?: string;
+  settings: SynomemConfig['projection'];
+  /** True when the manifest matches what a rebuild would produce. */
+  current: boolean;
+  /** Recorded by the manifest, not the filesystem; absent before any rebuild. */
+  lastRebuiltAt?: string;
+  counts: { expected: number; manifest: number; missing: number; unexpected: number };
+  /** Expected but not on disk. Capped, because a large workspace has many. */
+  missing: string[];
+  /** On disk and in the manifest, but no longer expected. Capped likewise. */
+  unexpected: string[];
+}
 
 export type SynomemBackendConfig =
   { kind: 'local' } | { kind: 'remote'; baseUrl: string; workspaceId: string };