@oscharko-dev/keiko 0.2.0-beta.5 → 0.2.0-beta.6

package/node_modules/@oscharko-dev/keiko-server/dist/memory-maintenance-handlers.d.ts

@@ -1,3 +1,4 @@
+import { type ReviewItem } from "@oscharko-dev/keiko-memory-consolidation";
 import type { MemoryVaultStore } from "@oscharko-dev/keiko-memory-vault";
 import type { EvidenceStore } from "@oscharko-dev/keiko-evidence";
 import type { UiHandlerDeps } from "./deps.js";
@@ -11,7 +12,11 @@ export interface MaintenanceCounts {
     superseded: number;
     edgesCreated: number;
     clustersInspected: number;
+    reviewItemsCreated: number;
 }
-export declare function runMemoryMaintenance(vault: MemoryVaultStore, evidenceStore?: EvidenceStore): MaintenanceCounts;
+export interface MaintenanceResult extends MaintenanceCounts {
+    readonly reviewItems: readonly ReviewItem[];
+}
+export declare function runMemoryMaintenance(vault: MemoryVaultStore, evidenceStore?: EvidenceStore): MaintenanceResult;
 export declare function handleRunMaintenance(ctx: RouteContext, deps: UiHandlerDeps): RouteResult;
 //# sourceMappingURL=memory-maintenance-handlers.d.ts.map

package/node_modules/@oscharko-dev/keiko-server/dist/memory-maintenance-handlers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory-maintenance-handlers.d.ts","sourceRoot":"","sources":["../src/memory-maintenance-handlers.ts"],"names":[],"mappings":"AAoCA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAI7D,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAwPD,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,gBAAgB,EACvB,aAAa,CAAC,EAAE,aAAa,GAC5B,iBAAiB,CAuBnB;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,GAAG,WAAW,CAWxF"}
+{"version":3,"file":"memory-maintenance-handlers.d.ts","sourceRoot":"","sources":["../src/memory-maintenance-handlers.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,0CAA0C,CAAC;AAc7F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAI7D,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,iBAAkB,SAAQ,iBAAiB;IAC1D,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;CAC7C;AAkND,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,gBAAgB,EACvB,aAAa,CAAC,EAAE,aAAa,GAC5B,iBAAiB,CAuBnB;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,GAAG,WAAW,CAWxF"}

package/node_modules/@oscharko-dev/keiko-server/dist/memory-maintenance-handlers.js

@@ -3,10 +3,9 @@
 //
 // POST /api/memory/maintenance runs a bounded, synchronous pass:
 //   1. Load every memory (all scopes) + the access stats.
-//   2. Run consolidation on the accepted subset; persist proposed edges; AUTO-APPLY pairwise
-//      supersede review items (a correction superseding one older conflicting memory) by demoting
-//      the loser to `superseded`. Multi-way merges are NOT auto-resolved — they stay as review
-//      items for the Memory Center.
+//   2. Run consolidation on the accepted subset; persist auto-applicable relationship edges and
+//      return unresolved review items for MemoriaViva or CLI operators. Conflict and merge review
+//      items are NEVER auto-applied here.
 //   3. Compute the maintenance plan and apply it: promote (-> accepted), reinforce / decay
 //      (confidence patch), archive (-> archived), forget (vault delete + tombstone + reason).
 //   4. Emit one audit event per applied effect and return the counts.
@@ -15,7 +14,7 @@
 // any per-handler check. External faults (a vault write that throws) are wrapped into a typed 500
 // rather than crashing the loopback server.
 import { randomUUID } from "node:crypto";
-import { runConsolidation, } from "@oscharko-dev/keiko-memory-consolidation";
+import { runConsolidation } from "@oscharko-dev/keiko-memory-consolidation";
 import { planMemoryMaintenance, } from "@oscharko-dev/keiko-memory-governance";
 import { errorBody } from "./routes.js";
 import { recordMemoryAudit } from "./memory-audit-handler.js";
@@ -29,6 +28,8 @@ function emptyCounts() {
         superseded: 0,
         edgesCreated: 0,
         clustersInspected: 0,
+        reviewItemsCreated: 0,
+        reviewItems: [],
     };
 }
 function isRouteResult(value) {
@@ -68,43 +69,20 @@ function recordsById(records) {
     return map;
 }
 // ─── Consolidation effects ───────────────────────────────────────────────────
+function isAutoApplicableConsolidationEdge(edge) {
+    return (edge.kind === "derived-from" || edge.kind === "related" || edge.kind === "temporal-precedes");
+}
 function applyEdges(vault, edges) {
     let created = 0;
     for (const edge of edges) {
+        if (!isAutoApplicableConsolidationEdge(edge))
+            continue;
         vault.insertEdge(edge);
         created += 1;
     }
     return created;
 }
-// A pairwise supersede picks the OLDER memory as the loser: the newer correction wins, the older
-// conflicting fact is demoted to `superseded` so retrieval suppresses it. Multi-way merges carry a
-// `merge` action and are intentionally left untouched for human review.
-function pairwiseSupersede(action) {
-    return action?.kind === "supersede" ? action : null;
-}
-function applySupersessions(vault, evidenceStore, reviewItems, byId) {
-    let superseded = 0;
-    for (const item of reviewItems) {
-        const action = pairwiseSupersede(item.proposedAction);
-        if (action === null)
-            continue;
-        const loser = byId.get(action.older);
-        if (loser?.status !== "accepted")
-            continue;
-        vault.updateMemory(action.older, { status: "superseded" }, Date.now());
-        superseded += 1;
-        emitSupersedeAudit(evidenceStore, action, loser.scope);
-    }
-    return superseded;
-}
-function emitSupersedeAudit(evidenceStore, action, scope) {
-    emitAudit(evidenceStore, "memory:superseded", "consolidation", "Auto-superseded an older conflicting memory.", {
-        oldMemoryId: action.older,
-        newMemoryId: action.newer,
-        scope,
-    });
-}
-function runConsolidationPass(vault, evidenceStore, records, counts) {
+function runConsolidationPass(vault, records, counts) {
     const result = runConsolidation(records, {
         nowMs: Date.now(),
         newEdgeId: () => randomUUID(),
@@ -112,7 +90,8 @@ function runConsolidationPass(vault, evidenceStore, records, counts) {
     });
     counts.edgesCreated += applyEdges(vault, result.edgesProposed);
     counts.clustersInspected += result.clustersInspected;
-    counts.superseded += applySupersessions(vault, evidenceStore, result.reviewItems, recordsById(records));
+    counts.reviewItemsCreated += result.reviewItems.length;
+    counts.reviewItems.push(...result.reviewItems);
 }
 // ─── Plan application ──────────────────────────────────────────────────────────
 // Applies the reinforce / decay / archive / forget effects on the post-consolidation snapshot.
@@ -188,12 +167,12 @@ export function runMemoryMaintenance(vault, evidenceStore) {
     const promoteStats = vault.getAccessStats();
     const promotePlan = planMemoryMaintenance(beforePromote, promoteStats, { nowMs: Date.now() });
     applyPromotions(vault, evidenceStore, promotePlan.promote, recordsById(beforePromote), counts);
-    // Phase 2 — consolidate the now-accepted set: link near-duplicates and auto-supersede pairwise
-    // correction conflicts (the older conflicting fact -> `superseded`).
+    // Phase 2 — consolidate the now-accepted set: link safe near-duplicate metadata and surface
+    // conflicts / merges as explicit review items. Status mutations require a later governed review.
     const accepted = vault
         .listMemories({ includeExpired: true })
         .filter((record) => record.status === "accepted");
-    runConsolidationPass(vault, evidenceStore, accepted, counts);
+    runConsolidationPass(vault, accepted, counts);
     // Phase 3 — reinforce / decay / archive / forget on the post-consolidation snapshot. The access
     // stats feed the strength model.
     const all = vault.listMemories({ includeExpired: true });

package/node_modules/@oscharko-dev/keiko-server/dist/memory-retention.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory-retention.d.ts","sourceRoot":"","sources":["../src/memory-retention.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EACV,QAAQ,EAER,WAAW,EACX,YAAY,EACb,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAKzE,MAAM,WAAW,qBAAqB;IAGpC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAI3B,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAIrC,QAAQ,CAAC,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAIzC,QAAQ,CAAC,qBAAqB,CAAC,EAAE,MAAM,CAAC;CACzC;AAED,MAAM,MAAM,qBAAqB,GAAG,YAAY,GAAG,iBAAiB,GAAG,gBAAgB,CAAC;AAExF,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC;IACvC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;CAC/B;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,SAAS,uBAAuB,EAAE,CAAC;IACvD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC,CAAC;IAGnE,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAC;CACxC;AAwGD,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC;IACvC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,2BAA2B,GAAG,qBAAqB,CA8BhG"}
+{"version":3,"file":"memory-retention.d.ts","sourceRoot":"","sources":["../src/memory-retention.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EACV,QAAQ,EAER,WAAW,EACX,YAAY,EACb,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAKzE,MAAM,WAAW,qBAAqB;IAGpC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAI3B,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAIrC,QAAQ,CAAC,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAGzC,QAAQ,CAAC,qBAAqB,CAAC,EAAE,MAAM,CAAC;CACzC;AAED,MAAM,MAAM,qBAAqB,GAAG,YAAY,GAAG,iBAAiB,GAAG,gBAAgB,CAAC;AAExF,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC;IACvC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;CAC/B;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,SAAS,uBAAuB,EAAE,CAAC;IACvD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC,CAAC;IAGnE,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAC;CACxC;AA2GD,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC;IACvC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,2BAA2B,GAAG,qBAAqB,CA8BhG"}

package/node_modules/@oscharko-dev/keiko-server/dist/memory-retention.js

@@ -14,11 +14,9 @@
 //   - Retention iterates the scopes the caller passes. The public MemoryVaultStore has no
 //     `listAllScopes()` capability, so a global enumeration would require an internal
 //     port extension. Out of scope here.
-//   - Forgotten-purge (purgeForgottenAfterMs) is a no-op in this PR: the public port
-//     exposes `listTombstonesByScope` for read but no API to delete tombstones, so we
-//     cannot purge them through the public seam. The field is accepted for forward
-//     compatibility and the result reports the count of tombstones THAT WOULD be purged,
-//     but no destructive call is issued. A future PR can extend the port.
+//   - Forgotten-purge (purgeForgottenAfterMs) uses the public vault port to delete only
+//     tombstones in the caller-supplied scopes whose forgottenAt is older than the
+//     deterministic cutoff.
 //
 // Why the operations are issued in a sequence of one-by-one deletes: the vault's delete
 // is already wrapped in a SQLite transaction (#206), and emitting a batch API here would
@@ -50,8 +48,9 @@ function selectOverflowEvictions(records, policy) {
     if (nonPinned.length <= policy.maxRecordsPerScope) {
         return [];
     }
-    // Oldest-first by updatedAt; truncate to (count - cap) entries.
-    const sorted = [...nonPinned].sort((a, b) => a.updatedAt - b.updatedAt);
+    // Oldest-first by updatedAt, then by id so same-timestamp retention is deterministic
+    // across vault implementations and insertion orders.
+    const sorted = [...nonPinned].sort((a, b) => a.updatedAt - b.updatedAt || String(a.id).localeCompare(String(b.id)));
     const overflowCount = nonPinned.length - policy.maxRecordsPerScope;
     return sorted.slice(0, overflowCount);
 }
@@ -148,12 +147,5 @@ function countPurgeBacklog(vault, scope, policy, nowMs) {
     if (policy.purgeForgottenAfterMs === undefined) {
         return 0;
     }
-    const tombstones = vault.listTombstonesByScope(scope);
-    let count = 0;
-    for (const t of tombstones) {
-        if (nowMs - t.forgottenAt > policy.purgeForgottenAfterMs) {
-            count += 1;
-        }
-    }
-    return count;
+    return vault.purgeTombstonesByScopeBefore(scope, nowMs - policy.purgeForgottenAfterMs);
 }

package/node_modules/@oscharko-dev/keiko-server/dist/memory-salience.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory-salience.d.ts","sourceRoot":"","sources":["../src/memory-salience.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,wCAAwC,CAAC;AAQ3F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAEL,KAAK,gCAAgC,EACtC,MAAM,kCAAkC,CAAC;AAwG1C,UAAU,mBAAmB;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS,CAAC;CAC5D;AAID,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,gCAAgC,EACzC,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,SAAS,4BAA4B,EAAE,CAAC,CAsClD"}
+{"version":3,"file":"memory-salience.d.ts","sourceRoot":"","sources":["../src/memory-salience.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,wCAAwC,CAAC;AAU3F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE/C,OAAO,EAEL,KAAK,gCAAgC,EACtC,MAAM,kCAAkC,CAAC;AAqH1C,UAAU,mBAAmB;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS,CAAC;CAC5D;AAID,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,gCAAgC,EACzC,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,SAAS,4BAA4B,EAAE,CAAC,CA2ClD"}

package/node_modules/@oscharko-dev/keiko-server/dist/memory-salience.js

@@ -8,10 +8,13 @@
 // This is the model/IO boundary: the WHOLE body runs inside one try/catch so a model error, a
 // vault hiccup, or any other failure can NEVER throw into the chat path — it logs and returns [].
 import { randomUUID } from "node:crypto";
-import { extractSalientMemories, } from "@oscharko-dev/keiko-memory-capture";
+import { redact } from "@oscharko-dev/keiko-security";
+import { extractSalientMemories, memoryTextEgressRejectionReason, } from "@oscharko-dev/keiko-memory-capture";
+import { currentRedactionSecrets } from "./deps.js";
 import { conversationMemoryScopes, } from "./memory-conversation-context.js";
 import { buildMemoryRecordFromProposal } from "./memory-record-builders.js";
 import { embedAndStoreMemory } from "./memory-embedding.js";
+import { isPersistableMemoryCandidate, memoryCapturePolicyForDeps, SENSITIVE_MEMORY_REJECTION_REASON, } from "./memory-capture-policy.js";
 // Mirror of chat-handlers' private scopeLabel (decision 3 — mirrored rather than exported to keep
 // the modules decoupled). Pure and trivial.
 function scopeLabel(scope) {
@@ -70,6 +73,10 @@ function buildCallModel(deps, modelId) {
         return response.content;
     };
 }
+function redactedErrorMessage(error, deps) {
+    const message = error instanceof Error ? error.message : String(error);
+    return redact(message, currentRedactionSecrets(deps));
+}
 // Persists one salience candidate and returns its wire action, or null when the outcome is not a
 // candidate or no record could be built. Best-effort embed-on-capture (#204): the inserted memory
 // is embedded and the vector stored when an embedding model is configured; failure is swallowed by
@@ -78,6 +85,9 @@ async function persistCandidate(deps, outcome, vault) {
     if (outcome.kind !== "candidate") {
         return null;
     }
+    if (!isPersistableMemoryCandidate(outcome)) {
+        return { kind: "rejected", reason: SENSITIVE_MEMORY_REJECTION_REASON };
+    }
     const proposalId = outcome.proposal.proposalId;
     const record = buildMemoryRecordFromProposal(proposalId, outcome);
     if (record === null) {
@@ -105,11 +115,16 @@ export async function captureSalientFromTurn(deps, request, context, modelId, as
         if (callModel === null) {
             return [];
         }
+        const policy = memoryCapturePolicyForDeps(deps);
+        if (memoryTextEgressRejectionReason(request.content, policy) !== null) {
+            return [];
+        }
         const outcomes = await extractSalientMemories({
             userText: request.content,
             assistantText,
             existingBodies: gatherExistingBodies(vault, context),
             context: buildSalienceContext(context),
+            policy,
         }, {
             callModel,
             now: () => Date.now(),
@@ -128,7 +143,7 @@ export async function captureSalientFromTurn(deps, request, context, modelId, as
     catch (error) {
         // Boundary: salience must never break the chat path. Log and continue.
         // eslint-disable-next-line no-console
-        console.error("salience capture failed", error);
+        console.error("salience capture failed", redactedErrorMessage(error, deps));
         return [];
     }
 }

package/node_modules/@oscharko-dev/keiko-server/dist/memory-scope-sanitizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory-scope-sanitizer.d.ts","sourceRoot":"","sources":["../src/memory-scope-sanitizer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAYnF,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,WAAW,EAClB,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GACtC,WAAW,CAgCb;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAiBzD;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,gBAAgB,EACvB,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GACtC,gBAAgB,CAkBlB;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,gBAAgB,EACvB,gBAAgB,EAAE,WAAW,CAAC,MAAM,CAAC,GACpC,OAAO,CAST"}
+{"version":3,"file":"memory-scope-sanitizer.d.ts","sourceRoot":"","sources":["../src/memory-scope-sanitizer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAenF,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,WAAW,EAClB,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GACtC,WAAW,CAgCb;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAiBzD;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,gBAAgB,EACvB,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GACtC,gBAAgB,CA+BlB;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,gBAAgB,EACvB,gBAAgB,EAAE,WAAW,CAAC,MAAM,CAAC,GACpC,OAAO,CAYT"}

package/node_modules/@oscharko-dev/keiko-server/dist/memory-scope-sanitizer.js

@@ -1,6 +1,9 @@
 import { createHash } from "node:crypto";
 import { safeSummary } from "./memory-audit-event-builders.js";
 function maskedCoordinate(value, redactString) {
+    if (value.startsWith("[redacted:") && value.endsWith("]")) {
+        return value;
+    }
     const redacted = redactString(value);
     if (redacted !== value) {
         return redacted;
@@ -67,6 +70,19 @@ export function sanitizeAuditEvent(event, redactString) {
             };
         case "memory:workflow-used":
             return { ...event, summary: redactedSummary };
+        case "memory:workflow-omitted":
+            return {
+                ...event,
+                summary: redactedSummary,
+                reason: safeSummary(event.reason, redactString),
+                scopes: event.scopes.map((scope) => sanitizeMemoryScope(scope, redactString)),
+            };
+        case "memory:workflow-write-candidate":
+            return {
+                ...event,
+                summary: redactedSummary,
+                scope: sanitizeMemoryScope(event.scope, redactString),
+            };
         default:
             return {
                 ...event,
@@ -78,9 +94,12 @@ export function sanitizeAuditEvent(event, redactString) {
 export function auditEventTouchesScope(event, allowedScopeKeys) {
     switch (event.kind) {
         case "memory:retrieved":
+        case "memory:workflow-omitted":
             return event.scopes.some((scope) => allowedScopeKeys.has(memoryScopeKey(scope)));
         case "memory:workflow-used":
             return false;
+        case "memory:workflow-write-candidate":
+            return allowedScopeKeys.has(memoryScopeKey(event.scope));
         default:
             return allowedScopeKeys.has(memoryScopeKey(event.scope));
     }

package/node_modules/@oscharko-dev/keiko-server/dist/memory-target-resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory-target-resolver.d.ts","sourceRoot":"","sources":["../src/memory-target-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAEhF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AA0EzE,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,gBAAgB,GAAG,qBAAqB,CASzF"}
+{"version":3,"file":"memory-target-resolver.d.ts","sourceRoot":"","sources":["../src/memory-target-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAEhF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AA+EzE,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,gBAAgB,GAAG,qBAAqB,CASzF"}

package/node_modules/@oscharko-dev/keiko-server/dist/memory-target-resolver.js

@@ -25,7 +25,10 @@ const STOP_WORDS = new Set([
     "we",
 ]);
 function normalizePhrase(value) {
-    return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, " ")
+        .trim();
 }
 function stemToken(token) {
     const strippedPossessive = token.endsWith("'s") ? token.slice(0, -2) : token;

package/node_modules/@oscharko-dev/keiko-server/dist/memory-workflow-port.d.ts

@@ -6,6 +6,7 @@ interface WorkflowMemoryPortOptions {
     readonly evidenceStore: EvidenceStore;
     readonly runId: string;
     readonly redactString: (input: string) => string;
+    readonly customerIdentifierMatchers?: readonly RegExp[] | undefined;
     readonly now?: (() => number) | undefined;
 }
 export declare function createWorkflowMemoryPort(options: WorkflowMemoryPortOptions): MemoryWorkflowPort;

package/node_modules/@oscharko-dev/keiko-server/dist/memory-workflow-port.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory-workflow-port.d.ts","sourceRoot":"","sources":["../src/memory-workflow-port.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAKV,kBAAkB,EAEnB,MAAM,+BAA+B,CAAC;AAEvC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAMlE,UAAU,yBAAyB;IACjC,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;IACjC,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IACjD,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;CAC3C;AAwGD,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,yBAAyB,GACjC,kBAAkB,CAqCpB"}
+{"version":3,"file":"memory-workflow-port.d.ts","sourceRoot":"","sources":["../src/memory-workflow-port.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAMV,kBAAkB,EAEnB,MAAM,+BAA+B,CAAC;AAEvC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAOlE,UAAU,yBAAyB;IACjC,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;IACjC,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IACjD,QAAQ,CAAC,0BAA0B,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;IACpE,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;CAC3C;AAoPD,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,yBAAyB,GAAG,kBAAkB,CAsB/F"}

package/node_modules/@oscharko-dev/keiko-server/dist/memory-workflow-port.js

@@ -1,30 +1,68 @@
 import { randomUUID } from "node:crypto";
 import { extractCandidatesFromWorkflowOutcome, } from "@oscharko-dev/keiko-memory-capture";
 import { retrieveMemoryContext } from "@oscharko-dev/keiko-memory-retrieval";
-import { recordMemoryAudit } from "./memory-audit-handler.js";
+import { recordMemoryAudit, recordMemoryAudits } from "./memory-audit-handler.js";
 import { vaultAsQueryPort } from "./memory-conv-handlers.js";
 import { LOCAL_CONVERSATION_MEMORY_USER_ID } from "./memory-conversation-context.js";
 import { buildMemoryRecordFromProposal } from "./memory-record-builders.js";
-function recordRetrievedAudit(options, now, scopes, matchedMemoryIds) {
+import { isPersistableMemoryCandidate } from "./memory-capture-policy.js";
+function buildRetrievedAudit(occurredAt, scopes, matchedMemoryIds) {
     if (matchedMemoryIds.length === 0) {
-        return;
+        return undefined;
     }
-    recordMemoryAudit({
-        evidenceStore: options.evidenceStore,
-        redactString: options.redactString,
-        now,
-    }, {
+    return {
         schemaVersion: "1",
         kind: "memory:retrieved",
         eventId: randomUUID(),
-        occurredAt: now(),
+        occurredAt,
         initiatorSurface: "workflow",
         summary: matchedMemoryIds.length === 1
             ? "Retrieved 1 memory for workflow context."
             : `Retrieved ${String(matchedMemoryIds.length)} memories for workflow context.`,
         scopes,
         matchedMemoryIds,
-    });
+    };
+}
+function buildWorkflowOmittedAudit(options, occurredAt, event) {
+    return {
+        schemaVersion: "1",
+        kind: "memory:workflow-omitted",
+        eventId: randomUUID(),
+        occurredAt,
+        initiatorSurface: "workflow",
+        summary: `Workflow omitted memory (${event.reason}).`,
+        workflowRunId: options.runId,
+        scopes: event.scopes,
+        omittedMemoryId: event.memoryId,
+        reason: event.reason,
+    };
+}
+function recordWorkflowOmittedAudit(options, now, event) {
+    recordMemoryAudit({
+        evidenceStore: options.evidenceStore,
+        redactString: options.redactString,
+        now,
+    }, buildWorkflowOmittedAudit(options, now(), event));
+}
+function recordWorkflowRetrievalAudits(options, now, scopes, matchedMemoryIds, omittedMemories) {
+    const occurredAt = now();
+    const events = [];
+    const retrievedEvent = buildRetrievedAudit(occurredAt, scopes, matchedMemoryIds);
+    if (retrievedEvent !== undefined) {
+        events.push(retrievedEvent);
+    }
+    for (const omitted of omittedMemories) {
+        events.push(buildWorkflowOmittedAudit(options, occurredAt, {
+            memoryId: omitted.memoryId,
+            reason: omitted.reason,
+            scopes,
+        }));
+    }
+    recordMemoryAudits({
+        evidenceStore: options.evidenceStore,
+        redactString: options.redactString,
+        now,
+    }, events);
 }
 function recordWorkflowUsedAudit(options, now, event) {
     recordMemoryAudit({
@@ -44,33 +82,64 @@ function recordWorkflowUsedAudit(options, now, event) {
         usedMemoryIds: event.memoryIds,
     });
 }
+function recordWorkflowWriteCandidateAudit(options, now, event, proposedMemoryIds) {
+    const auditEvent = {
+        schemaVersion: "1",
+        kind: "memory:workflow-write-candidate",
+        eventId: randomUUID(),
+        occurredAt: now(),
+        initiatorSurface: "workflow",
+        summary: proposedMemoryIds.length === 0
+            ? `Workflow produced a memory write candidate that was not eligible for review (${event.source}).`
+            : proposedMemoryIds.length === 1
+                ? `Workflow produced 1 governed memory write candidate (${event.source}).`
+                : `Workflow produced ${String(proposedMemoryIds.length)} governed memory write candidates (${event.source}).`,
+        workflowRunId: options.runId,
+        source: event.source,
+        scope: event.scope,
+        proposedMemoryIds,
+    };
+    recordMemoryAudit({
+        evidenceStore: options.evidenceStore,
+        redactString: options.redactString,
+        now,
+    }, auditEvent);
+}
 function persistWorkflowCandidates(options, event, capturedAt) {
     const outcomes = extractCandidatesFromWorkflowOutcome({
         runId: options.runId,
         outcomeKind: event.source === "workflow-correction" ? "corrected" : "success",
         structuredReport: event.proposalSummary,
         capturedAt,
-    }, captureContextFor(event.scope, capturedAt, options.runId), { scopeKind: event.scope.kind });
+    }, captureContextFor(event.scope, capturedAt, options.runId), {
+        scopeKind: event.scope.kind,
+        ...(options.customerIdentifierMatchers === undefined
+            ? {}
+            : { customerIdentifierMatchers: options.customerIdentifierMatchers }),
+    });
+    const proposedMemoryIds = [];
     for (const outcome of outcomes) {
-        if (outcome.kind !== "candidate") {
+        if (!isPersistableMemoryCandidate(outcome)) {
             continue;
         }
         const proposalId = outcome.proposal.proposalId;
         const record = buildMemoryRecordFromProposal(proposalId, outcome);
         if (record !== null) {
             options.vault.insertMemory(record);
+            proposedMemoryIds.push(record.id);
         }
     }
+    return proposedMemoryIds;
 }
 function captureContextFor(scope, nowMs, runId) {
     return {
         userId: LOCAL_CONVERSATION_MEMORY_USER_ID,
         ...(scope.kind === "workspace" ? { workspaceId: scope.workspaceId } : {}),
         ...(scope.kind === "project" ? { projectId: scope.projectId } : {}),
+        sourceWorkflowRunId: runId,
         ...(scope.kind === "workflow"
             ? {
                 workflowDefinitionId: scope.workflowDefinitionId,
-                sourceWorkflowRunId: runId,
             }
             : {}),
         nowMs,
@@ -78,28 +147,40 @@ function captureContextFor(scope, nowMs, runId) {
         newProposalId: () => randomUUID(),
     };
 }
+function createWorkflowContextGetter(options, now, queryPort) {
+    return (scopes, queryText, budgetTokens) => {
+        const result = retrieveMemoryContext({
+            scopes,
+            nowMs: now(),
+            ...(queryText === undefined ? {} : { queryText }),
+            ...(budgetTokens === undefined ? {} : { budgetTokens }),
+        }, queryPort);
+        recordWorkflowRetrievalAudits(options, now, scopes, result.included.map((item) => item.memoryId), result.omitted);
+        return Promise.resolve({
+            text: result.contextBlock.text,
+            includedMemoryIds: result.contextBlock.memories.map((item) => item.memoryId),
+        });
+    };
+}
 export function createWorkflowMemoryPort(options) {
     const now = options.now ?? Date.now;
     const queryPort = vaultAsQueryPort(options.vault);
     return {
-        getContextForWorkflow(scopes, queryText, budgetTokens) {
-            const result = retrieveMemoryContext({
-                scopes,
-                nowMs: now(),
-                ...(queryText === undefined ? {} : { queryText }),
-                ...(budgetTokens === undefined ? {} : { budgetTokens }),
-            }, queryPort);
-            recordRetrievedAudit(options, now, scopes, result.included.map((item) => item.memoryId));
-            return Promise.resolve({
-                text: result.contextBlock.text,
-                includedMemoryIds: result.contextBlock.memories.map((item) => item.memoryId),
-            });
-        },
+        getContextForWorkflow: createWorkflowContextGetter(options, now, queryPort),
         onMemoryUsed(event) {
             recordWorkflowUsedAudit(options, now, event);
         },
+        onMemoryOmitted(event) {
+            recordWorkflowOmittedAudit(options, now, {
+                memoryId: event.memoryId,
+                reason: event.reason,
+                scopes: [],
+            });
+        },
         onMemoryWriteCandidate(event) {
-            persistWorkflowCandidates(options, event, now());
+            const capturedAt = now();
+            const proposedMemoryIds = persistWorkflowCandidates(options, event, capturedAt);
+            recordWorkflowWriteCandidateAudit(options, () => capturedAt, event, proposedMemoryIds);
         },
     };
 }

package/node_modules/@oscharko-dev/keiko-server/dist/qualityIntelligence/capsuleAdapter.d.ts

@@ -9,10 +9,14 @@ export interface CapsuleDocumentText {
  * capsule; `capsuleSet` fans out over a capsule-set's members. Both share one lazily-opened store
  * handle and return `[]` on any failure (unknown id, store-open error) so the ingestion layer maps
  * the empty result to a coded, user-actionable QI_CAPSULE_UNAVAILABLE error.
+ *
+ * `close` releases the underlying SQLite handle; must be called once per resolver lifetime (e.g. in
+ * the finally block of executeQiRun) to prevent a handle leak per QI run.
  */
 export interface CapsuleResolver {
     readonly capsule: (capsuleId: string) => readonly CapsuleDocumentText[];
     readonly capsuleSet: (capsuleSetId: string) => readonly CapsuleDocumentText[];
+    readonly close: () => void;
 }
 /**
  * Builds a CapsuleResolver that opens the LK store ONCE (per resolver) and returns the full corpus

package/node_modules/@oscharko-dev/keiko-server/dist/qualityIntelligence/capsuleAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"capsuleAdapter.d.ts","sourceRoot":"","sources":["../../src/qualityIntelligence/capsuleAdapter.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,6FAA6F;AAC7F,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,SAAS,mBAAmB,EAAE,CAAC;IACxE,QAAQ,CAAC,UAAU,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,SAAS,mBAAmB,EAAE,CAAC;CAC/E;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,aAAa,GAAG,eAAe,GAAG,SAAS,CAyCpF"}
+{"version":3,"file":"capsuleAdapter.d.ts","sourceRoot":"","sources":["../../src/qualityIntelligence/capsuleAdapter.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,6FAA6F;AAC7F,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,SAAS,mBAAmB,EAAE,CAAC;IACxE,QAAQ,CAAC,UAAU,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,SAAS,mBAAmB,EAAE,CAAC;IAC9E,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC;CAC5B;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,aAAa,GAAG,eAAe,GAAG,SAAS,CA4CpF"}

package/node_modules/@oscharko-dev/keiko-server/dist/qualityIntelligence/capsuleAdapter.js

@@ -48,5 +48,8 @@ export function makeCapsuleResolver(deps) {
     return {
         capsule: (capsuleId) => read(capsuleId, QualityIntelligenceHandoff.listCapsuleDocumentTexts),
         capsuleSet: (capsuleSetId) => read(capsuleSetId, QualityIntelligenceHandoff.listCapsuleSetDocumentTexts),
+        close: () => {
+            store?.close();
+        },
     };
 }

package/node_modules/@oscharko-dev/keiko-server/dist/qualityIntelligence/editRoutes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"editRoutes.d.ts","sourceRoot":"","sources":["../../src/qualityIntelligence/editRoutes.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAgQhD,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,WAAW,CAAC,CAmBtB;AAED,eAAO,MAAM,mBAAmB,EAAE,SAAS,eAAe,EAMzD,CAAC"}
+{"version":3,"file":"editRoutes.d.ts","sourceRoot":"","sources":["../../src/qualityIntelligence/editRoutes.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAwThD,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,WAAW,CAAC,CAmBtB;AAED,eAAO,MAAM,mBAAmB,EAAE,SAAS,eAAe,EAMzD,CAAC"}