feat(memory): add local quality cleanup audit logs

src/extractors.ts

@@ -1,7 +1,10 @@
 import { createHash } from "crypto";
+import { appendFile, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
 import type { ActiveFile, LongTermMemoryEntry, LongTermType, OpenError } from "./types.ts";
 import { LONG_TERM_LIMITS } from "./types.ts";
 import { assessMemoryQuality } from "./memory-quality.ts";
+import { extractionRejectionLogPath } from "./paths.ts";
 
 function id(prefix: string): string {
   return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
@@ -227,6 +230,24 @@ function extractFirstPath(text: string): string | undefined {
  * Acceptance gate for workspace memory candidates.
  * Keeps extraction-specific checks local and delegates memory quality rules to memory-quality.ts.
  */
+type ExtractionRejectionLogEntry = {
+  timestamp: string;
+  type: LongTermType;
+  text: string;
+  reasons: string[];
+  source: "compaction";
+};
+
+async function logExtractionRejection(entry: ExtractionRejectionLogEntry): Promise<void> {
+  try {
+    const path = extractionRejectionLogPath();
+    await mkdir(dirname(path), { recursive: true });
+    await appendFile(path, JSON.stringify(entry) + "\n", "utf8");
+  } catch (error) {
+    console.error("[memory] failed to write extraction rejection log:", error);
+  }
+}
+
 function shouldAcceptWorkspaceMemoryCandidate(
   entry: {
     type: LongTermType;
@@ -253,7 +274,16 @@ function shouldAcceptWorkspaceMemoryCandidate(
   if (/\b(ignore|instruction|overwrite)\b/i.test(text) && /\b(previous|all|rules|behavior|prompt|system)\b/i.test(text)) return false;
 
   const quality = assessMemoryQuality({ type: entry.type, text, source: "compaction" });
-  if (!quality.accepted) return false;
+  if (!quality.accepted) {
+    void logExtractionRejection({
+      timestamp: new Date().toISOString(),
+      type: entry.type,
+      text,
+      reasons: quality.reasons,
+      source: "compaction",
+    });
+    return false;
+  }
 
   return true;
 }

src/paths.ts

@@ -28,3 +28,11 @@ export async function sessionStatePath(root: string, sessionID: string): Promise
   const safeSessionID = createHash("sha256").update(sessionID).digest("hex").slice(0, 32);
   return join(await memoryRoot(root), "sessions", `${safeSessionID}.json`);
 }
+
+export function migrationLogPath(migrationId: string): string {
+  return join(dataHome(), "opencode-working-memory", "migration-logs", `${migrationId}.jsonl`);
+}
+
+export function extractionRejectionLogPath(): string {
+  return join(dataHome(), "opencode-working-memory", "extraction-rejections.jsonl");
+}

src/workspace-memory.ts

@@ -1,6 +1,8 @@
+import { appendFile, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
 import type { LongTermMemoryEntry, WorkspaceMemoryStore } from "./types.ts";
 import { LONG_TERM_LIMITS } from "./types.ts";
-import { workspaceKey, workspaceMemoryPath } from "./paths.ts";
+import { migrationLogPath, workspaceKey, workspaceMemoryPath } from "./paths.ts";
 import { atomicWriteJSON, readJSON, updateJSON } from "./storage.ts";
 import { assessMemoryQuality, isHardQualityReason, isProgressSnapshotViolation } from "./memory-quality.ts";
 
@@ -50,6 +52,21 @@ export type WorkspaceMemoryNormalizationResult = LongTermLimitResult & {
   events: MemoryConsolidationEvent[];
 };
 
+export type QualityCleanupMigrationLogEntry = {
+  migrationId: string;
+  timestamp: string;
+  workspaceKey: string;
+  workspaceRoot: string;
+  entryId: string;
+  type: LongTermMemoryEntry["type"];
+  source: LongTermMemoryEntry["source"];
+  text: string;
+  reasons: string[];
+  hardReasons: string[];
+  beforeStatus: "active";
+  afterStatus: "superseded";
+};
+
 export async function emptyWorkspaceMemory(root: string): Promise<WorkspaceMemoryStore> {
   return {
     version: 1,
@@ -191,7 +208,13 @@ export async function normalizeWorkspaceMemoryWithAccounting(
   // One-time migrations for legacy/low-quality snapshot violations.
   // Run quality cleanup first so hard violations receive quality audit tags
   // before the older P0 project-only cleanup marks progress snapshots.
-  result = runMigrationQualityCleanup(result, nowIso);
+  const qualityCleanup = runMigrationQualityCleanup(result, nowIso);
+  result = qualityCleanup.store;
+  if (qualityCleanup.events.length > 0) {
+    await appendQualityCleanupMigrationLog(qualityCleanup.events).catch(error => {
+      console.error("[memory] failed to write quality cleanup migration log:", error);
+    });
+  }
   result = runMigrationP0Cleanup(result, nowIso);
 
   // P0 accounting only considers active entries. Entries that were already
@@ -287,14 +310,22 @@ export function runMigrationP0Cleanup(
   };
 }
 
+async function appendQualityCleanupMigrationLog(events: QualityCleanupMigrationLogEntry[]): Promise<void> {
+  if (events.length === 0) return;
+  const path = migrationLogPath(QUALITY_CLEANUP_MIGRATION_ID);
+  await mkdir(dirname(path), { recursive: true });
+  await appendFile(path, events.map(event => JSON.stringify(event)).join("\n") + "\n", "utf8");
+}
+
 export function runMigrationQualityCleanup(
   store: WorkspaceMemoryStore,
   nowIso: string,
-): WorkspaceMemoryStore {
+): { store: WorkspaceMemoryStore; events: QualityCleanupMigrationLogEntry[] } {
   if (store.migrations?.includes(QUALITY_CLEANUP_MIGRATION_ID)) {
-    return store;
+    return { store, events: [] };
   }
 
+  const events: QualityCleanupMigrationLogEntry[] = [];
   let changed = false;
   const entries = store.entries.map(entry => {
     if (entry.source !== "compaction") return entry;
@@ -307,6 +338,21 @@ export function runMigrationQualityCleanup(
     if (hardReasons.length === 0) return entry;
 
     changed = true;
+    events.push({
+      migrationId: QUALITY_CLEANUP_MIGRATION_ID,
+      timestamp: nowIso,
+      workspaceKey: store.workspace.key,
+      workspaceRoot: store.workspace.root,
+      entryId: entry.id,
+      type: entry.type,
+      source: entry.source,
+      text: entry.text,
+      reasons: quality.reasons,
+      hardReasons,
+      beforeStatus: "active",
+      afterStatus: "superseded",
+    });
+
     const tags = new Set([
       ...(entry.tags ?? []),
       "quality_cleanup",
@@ -322,10 +368,13 @@ export function runMigrationQualityCleanup(
   });
 
   return {
-    ...store,
-    entries,
-    migrations: [...(store.migrations ?? []), QUALITY_CLEANUP_MIGRATION_ID],
-    updatedAt: changed ? nowIso : store.updatedAt,
+    store: {
+      ...store,
+      entries,
+      migrations: [...(store.migrations ?? []), QUALITY_CLEANUP_MIGRATION_ID],
+      updatedAt: changed ? nowIso : store.updatedAt,
+    },
+    events,
   };
 }