@oscharko-dev/keiko-server 0.2.0

package/dist/local-knowledge-indexing-registry.d.ts

@@ -0,0 +1,13 @@
+export declare class LocalKnowledgeIndexingRegistry {
+    private readonly runsByCapsule;
+    private readonly runsByJobId;
+    start(capsuleId: string): AbortController;
+    attachJobId(capsuleId: string, jobId: string): void;
+    cancel(capsuleId: string): boolean;
+    isActiveCapsule(capsuleId: string): boolean;
+    isActiveJob(jobId: string): boolean;
+    complete(capsuleId: string): void;
+    reset(): void;
+}
+export declare const localKnowledgeIndexingRegistry: LocalKnowledgeIndexingRegistry;
+//# sourceMappingURL=local-knowledge-indexing-registry.d.ts.map

package/dist/local-knowledge-indexing-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-knowledge-indexing-registry.d.ts","sourceRoot":"","sources":["../src/local-knowledge-indexing-registry.ts"],"names":[],"mappings":"AAMA,qBAAa,8BAA8B;IACzC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAsD;IACpF,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAsD;IAElF,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe;IAOzC,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAYnD,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IASlC,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAI3C,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAInC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAWjC,KAAK,IAAI,IAAI;CAOd;AAED,eAAO,MAAM,8BAA8B,gCAAuC,CAAC"}

package/dist/local-knowledge-indexing-registry.js

@@ -0,0 +1,53 @@
+export class LocalKnowledgeIndexingRegistry {
+    runsByCapsule = new Map();
+    runsByJobId = new Map();
+    start(capsuleId) {
+        this.complete(capsuleId);
+        const controller = new AbortController();
+        this.runsByCapsule.set(capsuleId, { capsuleId, controller });
+        return controller;
+    }
+    attachJobId(capsuleId, jobId) {
+        const run = this.runsByCapsule.get(capsuleId);
+        if (run === undefined) {
+            return;
+        }
+        if (run.jobId !== undefined) {
+            this.runsByJobId.delete(run.jobId);
+        }
+        run.jobId = jobId;
+        this.runsByJobId.set(jobId, run);
+    }
+    cancel(capsuleId) {
+        const run = this.runsByCapsule.get(capsuleId);
+        if (run === undefined) {
+            return false;
+        }
+        run.controller.abort();
+        return true;
+    }
+    isActiveCapsule(capsuleId) {
+        return this.runsByCapsule.has(capsuleId);
+    }
+    isActiveJob(jobId) {
+        return this.runsByJobId.has(jobId);
+    }
+    complete(capsuleId) {
+        const run = this.runsByCapsule.get(capsuleId);
+        if (run === undefined) {
+            return;
+        }
+        if (run.jobId !== undefined) {
+            this.runsByJobId.delete(run.jobId);
+        }
+        this.runsByCapsule.delete(capsuleId);
+    }
+    reset() {
+        for (const run of this.runsByCapsule.values()) {
+            run.controller.abort();
+        }
+        this.runsByCapsule.clear();
+        this.runsByJobId.clear();
+    }
+}
+export const localKnowledgeIndexingRegistry = new LocalKnowledgeIndexingRegistry();

package/dist/localKnowledgeKeyProvider.d.ts

@@ -0,0 +1,11 @@
+import { type LocalVaultKeychainAccess } from "@oscharko-dev/keiko-security/secret-vault";
+import type { KnowledgeStoreKeyProvider, KnowledgeStoreProtectionOptions } from "@oscharko-dev/keiko-local-knowledge";
+import type { EnvSource } from "@oscharko-dev/keiko-model-gateway";
+export declare const LOCAL_KNOWLEDGE_KEY_PROVIDER_ID = "local-knowledge-content-vault";
+export interface CreateLocalKnowledgeKeyProviderOptions {
+    readonly env: EnvSource;
+    readonly keychainAccess?: LocalVaultKeychainAccess | undefined;
+}
+export declare function createLocalKnowledgeKeyProvider(options: CreateLocalKnowledgeKeyProviderOptions): KnowledgeStoreKeyProvider;
+export declare function localKnowledgeProtectionOptions(keyProvider: KnowledgeStoreKeyProvider | undefined): KnowledgeStoreProtectionOptions | undefined;
+//# sourceMappingURL=localKnowledgeKeyProvider.d.ts.map

package/dist/localKnowledgeKeyProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localKnowledgeKeyProvider.d.ts","sourceRoot":"","sources":["../src/localKnowledgeKeyProvider.ts"],"names":[],"mappings":"AAiBA,OAAO,EAEL,KAAK,wBAAwB,EAC9B,MAAM,2CAA2C,CAAC;AACnD,OAAO,KAAK,EACV,yBAAyB,EAEzB,+BAA+B,EAChC,MAAM,qCAAqC,CAAC;AAC7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAMnE,eAAO,MAAM,+BAA+B,kCAAkC,CAAC;AAE/E,MAAM,WAAW,sCAAsC;IACrD,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IAGxB,QAAQ,CAAC,cAAc,CAAC,EAAE,wBAAwB,GAAG,SAAS,CAAC;CAChE;AAKD,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,sCAAsC,GAC9C,yBAAyB,CAe3B;AAKD,wBAAgB,+BAA+B,CAC7C,WAAW,EAAE,yBAAyB,GAAG,SAAS,GACjD,+BAA+B,GAAG,SAAS,CAG7C"}

package/dist/localKnowledgeKeyProvider.js

@@ -0,0 +1,48 @@
+// Local Knowledge store-key policy (Issue #1322, Epic #1319; ADR-0047 D2).
+//
+// The local, dependency-light glue between the generalized AES-256-GCM key-resolution seam
+// (@oscharko-dev/keiko-security/secret-vault) and the Local Knowledge capsule store. It owns the
+// env -> macOS Keychain -> 0600-keyfile key namespace that protects extracted text and vector
+// content at rest, and adapts it to the store's `KnowledgeStoreKeyProvider` contract.
+//
+// The namespace is DISTINCT from the credential vault (Issue #1320) and the memory vault
+// (ADR-0035): a separate env var, keychain service, and keyfile name. Key separation — not the
+// shared AAD — is what prevents a ciphertext sealed for one store from opening with another's key.
+//
+// The keyfile, when that weakest tier is used, is co-located with the capsule store it protects
+// (`dirname(capsules.db)`), so a copied or synced state directory carries only separately-keyed
+// ciphertext. The store directory is created and hardened to 0700 by the store before the key is
+// resolved; resolveLocalVaultKey additionally hardens it and writes the keyfile at 0600.
+import { dirname } from "node:path";
+import { resolveLocalVaultKey, } from "@oscharko-dev/keiko-security/secret-vault";
+const LOCAL_KNOWLEDGE_KEY_ENV = "KEIKO_LOCAL_KNOWLEDGE_KEY";
+const LOCAL_KNOWLEDGE_KEYCHAIN_SERVICE = "keiko-local-knowledge-vault";
+const LOCAL_KNOWLEDGE_KEYFILE = "local-knowledge-vault.key";
+export const LOCAL_KNOWLEDGE_KEY_PROVIDER_ID = "local-knowledge-content-vault";
+// Builds the key provider keiko-server injects into openKnowledgeStore so production capsule stores
+// open encrypted. The key is resolved per store-open from the store's own directory, so different
+// namespaces resolve independent keyfiles while sharing the env/keychain tiers.
+export function createLocalKnowledgeKeyProvider(options) {
+    return {
+        providerId: LOCAL_KNOWLEDGE_KEY_PROVIDER_ID,
+        resolveKey: (context) => {
+            const { key } = resolveLocalVaultKey({
+                env: options.env,
+                vaultDir: dirname(context.dbPath),
+                envVarName: LOCAL_KNOWLEDGE_KEY_ENV,
+                keychainService: LOCAL_KNOWLEDGE_KEYCHAIN_SERVICE,
+                keyfileName: LOCAL_KNOWLEDGE_KEYFILE,
+                ...(options.keychainAccess !== undefined ? { keychainAccess: options.keychainAccess } : {}),
+            });
+            return key;
+        },
+    };
+}
+// Builds the store protection options for a store-open call. Returns undefined when no key provider is
+// configured (legacy/manual deps) so the store opens plaintext, exactly as before. Keeps the three
+// keiko-server store-open sites consistent without each re-deriving the protection shape.
+export function localKnowledgeProtectionOptions(keyProvider) {
+    if (keyProvider === undefined)
+        return undefined;
+    return { mode: "encrypted-key-provider", keyProvider };
+}

package/dist/memory-audit-event-builders.d.ts

@@ -0,0 +1,21 @@
+import type { MemoryAuditEvent, MemoryAuditInitiatorSurface, MemoryId, MemoryRecord, MemoryScope, MemoryStatus } from "@oscharko-dev/keiko-contracts";
+import type { MemoryTombstone } from "@oscharko-dev/keiko-memory-vault";
+export declare const VAULT_DERIVED_SURFACE: MemoryAuditInitiatorSurface;
+export interface BuildContext {
+    readonly occurredAt: number;
+    readonly newEventId: () => string;
+    readonly redactString: (input: string) => string;
+}
+export declare function safeSummary(input: string, redactString: (s: string) => string): string;
+export type SingleRecordKind = "memory:accepted" | "memory:rejected" | "memory:archived" | "memory:pinned" | "memory:unpinned" | "memory:updated";
+export interface UpdateClassification {
+    readonly kind: SingleRecordKind;
+    readonly label: string;
+}
+export declare function classifyUpdate(previousStatus: MemoryStatus | undefined, previousPinned: boolean | undefined, record: MemoryRecord): UpdateClassification;
+export declare function buildProposedEvent(record: MemoryRecord, ctx: BuildContext): MemoryAuditEvent;
+export declare function buildInsertedEvent(record: MemoryRecord, ctx: BuildContext): MemoryAuditEvent | undefined;
+export declare function buildUpdatedEvent(record: MemoryRecord, previousStatus: MemoryStatus | undefined, previousPinned: boolean | undefined, ctx: BuildContext): MemoryAuditEvent;
+export declare function buildTombstonedEvent(tombstone: MemoryTombstone, ctx: BuildContext): MemoryAuditEvent;
+export declare function buildDeletedEvent(memoryId: MemoryId, scope: MemoryScope, ctx: BuildContext): MemoryAuditEvent;
+//# sourceMappingURL=memory-audit-event-builders.d.ts.map

package/dist/memory-audit-event-builders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-audit-event-builders.d.ts","sourceRoot":"","sources":["../src/memory-audit-event-builders.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,gBAAgB,EAChB,2BAA2B,EAC3B,QAAQ,EACR,YAAY,EACZ,WAAW,EACX,YAAY,EACb,MAAM,+BAA+B,CAAC;AAEvC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAMxE,eAAO,MAAM,qBAAqB,EAAE,2BAAsC,CAAC;AAI3E,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,MAAM,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;CAClD;AAMD,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM,CAMtF;AAOD,MAAM,MAAM,gBAAgB,GACxB,iBAAiB,GACjB,iBAAiB,GACjB,iBAAiB,GACjB,eAAe,GACf,iBAAiB,GACjB,gBAAgB,CAAC;AAErB,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAsCD,wBAAgB,cAAc,CAC5B,cAAc,EAAE,YAAY,GAAG,SAAS,EACxC,cAAc,EAAE,OAAO,GAAG,SAAS,EACnC,MAAM,EAAE,YAAY,GACnB,oBAAoB,CAWtB;AAuCD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,EAAE,YAAY,GAAG,gBAAgB,CAW5F;AAED,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,YAAY,EACpB,GAAG,EAAE,YAAY,GAChB,gBAAgB,GAAG,SAAS,CA8B9B;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,YAAY,EACpB,cAAc,EAAE,YAAY,GAAG,SAAS,EACxC,cAAc,EAAE,OAAO,GAAG,SAAS,EACnC,GAAG,EAAE,YAAY,GAChB,gBAAgB,CAIlB;AA2CD,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,eAAe,EAC1B,GAAG,EAAE,YAAY,GAChB,gBAAgB,CAelB;AAED,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,YAAY,GAChB,gBAAgB,CAYlB"}

package/dist/memory-audit-event-builders.js

@@ -0,0 +1,187 @@
+// Pure helpers for the memory audit handler (#214). Split from memory-audit-handler.ts to
+// keep each file under the 400-LOC budget. No IO, no clock reads, no randomness — every
+// effect is injected via `BuildContext`. The handler in `memory-audit-handler.ts` owns
+// the impure surface (persistence, clock, id generation).
+import { MEMORY_AUDIT_EVENT_SUMMARY_MAX_CHARS } from "@oscharko-dev/keiko-contracts";
+// ─── Constants ────────────────────────────────────────────────────────────────
+// Default initiator for vault-derived events. Retrieval/workflow direct emissions use
+// their own surface ("memory-center" / "conversation-center" / "workflow").
+export const VAULT_DERIVED_SURFACE = "system";
+// ─── Summary boundary ─────────────────────────────────────────────────────────
+// Truncates and redacts the summary at the audit boundary. Bound mirrors the
+// MEMORY_AUDIT_EVENT_SUMMARY_MAX_CHARS contract constant.
+export function safeSummary(input, redactString) {
+    const redacted = redactString(input);
+    if (redacted.length <= MEMORY_AUDIT_EVENT_SUMMARY_MAX_CHARS) {
+        return redacted;
+    }
+    return redacted.slice(0, MEMORY_AUDIT_EVENT_SUMMARY_MAX_CHARS);
+}
+function classifyStatusTransition(previous, next) {
+    if (previous === next) {
+        return undefined;
+    }
+    if (next === "accepted") {
+        return { kind: "memory:accepted", label: "status -> accepted" };
+    }
+    if (next === "rejected") {
+        return { kind: "memory:rejected", label: "status -> rejected" };
+    }
+    if (next === "archived") {
+        return { kind: "memory:archived", label: "status -> archived" };
+    }
+    // A vault-bridge `memory:updated` with new status="superseded" doesn't know the
+    // supersedor's id; the supersession envelope requires both old + new. Direct emitters
+    // (consolidation #208) that know both ids should call `recordMemoryAudit` with kind
+    // "memory:superseded" explicitly. From the bridge we fall through to a plain
+    // `memory:updated` so the audit trail still records the state change.
+    return undefined;
+}
+function classifyPinTransition(previousPinned, nextPinned) {
+    if (previousPinned === nextPinned) {
+        return undefined;
+    }
+    return nextPinned
+        ? { kind: "memory:pinned", label: "pinned -> true" }
+        : { kind: "memory:unpinned", label: "pinned -> false" };
+}
+export function classifyUpdate(previousStatus, previousPinned, record) {
+    const statusClass = classifyStatusTransition(previousStatus, record.status);
+    if (statusClass !== undefined) {
+        return statusClass;
+    }
+    const pinClass = classifyPinTransition(previousPinned, record.pinned);
+    if (pinClass !== undefined) {
+        return pinClass;
+    }
+    // No status / pin transition detected: this is a plain content/metadata update.
+    return { kind: "memory:updated", label: "metadata updated" };
+}
+// ─── Event builders ───────────────────────────────────────────────────────────
+function buildSingleRecordEvent(kind, record, summary, ctx) {
+    const envelope = {
+        schemaVersion: "1",
+        eventId: ctx.newEventId(),
+        occurredAt: ctx.occurredAt,
+        initiatorSurface: VAULT_DERIVED_SURFACE,
+        summary,
+        memoryId: record.id,
+        scope: record.scope,
+    };
+    switch (kind) {
+        case "memory:accepted":
+            return { ...envelope, kind: "memory:accepted" };
+        case "memory:rejected":
+            return { ...envelope, kind: "memory:rejected" };
+        case "memory:archived":
+            return { ...envelope, kind: "memory:archived" };
+        case "memory:pinned":
+            return { ...envelope, kind: "memory:pinned" };
+        case "memory:unpinned":
+            return { ...envelope, kind: "memory:unpinned" };
+        case "memory:updated":
+            return { ...envelope, kind: "memory:updated" };
+        default: {
+            const never = kind;
+            return never;
+        }
+    }
+}
+export function buildProposedEvent(record, ctx) {
+    return {
+        schemaVersion: "1",
+        kind: "memory:proposed",
+        eventId: ctx.newEventId(),
+        occurredAt: ctx.occurredAt,
+        initiatorSurface: VAULT_DERIVED_SURFACE,
+        summary: safeSummary(`memory ${record.id} proposed (type=${record.type})`, ctx.redactString),
+        memoryId: record.id,
+        scope: record.scope,
+    };
+}
+export function buildInsertedEvent(record, ctx) {
+    // The vault emits `memory:inserted` for any new record, but capture (#207) typically
+    // inserts at status="proposed". Acceptance flows insert at status="accepted" only when
+    // the bypass-review path is taken (rare). We map the initial status to the closest
+    // semantic kind; any inserted-at-terminal status (rejected/forgotten/etc.) is dropped
+    // because the audit trail for those flows runs through the operation that produced
+    // them, not through the vault insert.
+    switch (record.status) {
+        case "proposed":
+            return buildProposedEvent(record, ctx);
+        case "accepted":
+            return buildSingleRecordEvent("memory:accepted", record, safeSummary(`memory ${record.id} inserted as accepted (type=${record.type})`, ctx.redactString), ctx);
+        case "rejected":
+        case "superseded":
+        case "archived":
+        case "forgotten":
+        case "conflicted":
+        case "expired":
+            return undefined;
+        default:
+            return undefined;
+    }
+}
+export function buildUpdatedEvent(record, previousStatus, previousPinned, ctx) {
+    const cls = classifyUpdate(previousStatus, previousPinned, record);
+    const summary = safeSummary(`memory ${record.id} ${cls.label}`, ctx.redactString);
+    return buildSingleRecordEvent(cls.kind, record, summary, ctx);
+}
+// Reconstructs the scope object from the tombstone's flat scope-kind + scope-coordinate
+// pair. The vault flattens the discriminated union on persist; the audit boundary
+// requires the structured shape. The coordinate string IS already the realpath of the
+// branded ID (memory-vault writes them this way), so we re-cast at the audit boundary.
+function scopeFromTombstone(tombstone) {
+    switch (tombstone.scopeKind) {
+        case "user":
+            return {
+                kind: "user",
+                userId: tombstone.scopeCoordinate,
+            };
+        case "workspace":
+            return {
+                kind: "workspace",
+                workspaceId: tombstone.scopeCoordinate,
+            };
+        case "project":
+            return {
+                kind: "project",
+                projectId: tombstone.scopeCoordinate,
+            };
+        case "workflow":
+            return {
+                kind: "workflow",
+                workflowDefinitionId: tombstone.scopeCoordinate,
+            };
+        case "global":
+            return { kind: "global" };
+        default:
+            return { kind: "global" };
+    }
+}
+export function buildTombstonedEvent(tombstone, ctx) {
+    return {
+        schemaVersion: "1",
+        kind: "memory:forgotten",
+        eventId: ctx.newEventId(),
+        occurredAt: ctx.occurredAt,
+        initiatorSurface: VAULT_DERIVED_SURFACE,
+        summary: safeSummary(`memory ${tombstone.memoryId} forgotten (surface=${tombstone.forgetterSurface})`, ctx.redactString),
+        memoryId: tombstone.memoryId,
+        scope: scopeFromTombstone(tombstone),
+        tombstoned: true,
+    };
+}
+export function buildDeletedEvent(memoryId, scope, ctx) {
+    return {
+        schemaVersion: "1",
+        kind: "memory:forgotten",
+        eventId: ctx.newEventId(),
+        occurredAt: ctx.occurredAt,
+        initiatorSurface: VAULT_DERIVED_SURFACE,
+        summary: safeSummary(`memory ${memoryId} deleted without tombstone`, ctx.redactString),
+        memoryId,
+        scope,
+        tombstoned: false,
+    };
+}

package/dist/memory-audit-handler.d.ts

@@ -0,0 +1,23 @@
+import type { MemoryAuditEvent } from "@oscharko-dev/keiko-contracts";
+import type { EvidenceStore } from "@oscharko-dev/keiko-evidence";
+import type { MemoryEvent } from "@oscharko-dev/keiko-memory-vault";
+export interface MemoryAuditHandlerOptions {
+    readonly evidenceStore: EvidenceStore;
+    readonly redactString: (input: string) => string;
+    readonly now?: () => number;
+    readonly newEventId?: () => string;
+    readonly onPersistError?: (error: unknown) => void;
+}
+export type MemoryAuditHandler = (event: MemoryEvent) => void;
+export declare function auditRunIdFor(nowMs: number): string;
+export declare function createMemoryAuditHandler(options: MemoryAuditHandlerOptions): MemoryAuditHandler;
+export interface RecordMemoryAuditOptions {
+    readonly evidenceStore: EvidenceStore;
+    readonly now?: () => number;
+    readonly redactString?: (input: string) => string;
+    readonly onPersistError?: (error: unknown) => void;
+}
+export declare function recordMemoryAudit(options: RecordMemoryAuditOptions, event: MemoryAuditEvent): void;
+export declare function recordMemoryAudits(options: RecordMemoryAuditOptions, events: readonly MemoryAuditEvent[]): void;
+export declare function createNoopMemoryAuditHandler(): MemoryAuditHandler;
+//# sourceMappingURL=memory-audit-handler.d.ts.map

package/dist/memory-audit-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-audit-handler.d.ts","sourceRoot":"","sources":["../src/memory-audit-handler.ts"],"names":[],"mappings":"AAqCA,OAAO,KAAK,EAAE,gBAAgB,EAA0B,MAAM,+BAA+B,CAAC;AAC9F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAYpE,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,QAAQ,CAAC,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IAEjD,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IAE5B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,MAAM,CAAC;IAEnC,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACpD;AAED,MAAM,MAAM,kBAAkB,GAAG,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;AAW9D,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAInD;AAgDD,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,yBAAyB,GAAG,kBAAkB,CA+B/F;AAgED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IAC5B,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IAClD,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACpD;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,wBAAwB,EACjC,KAAK,EAAE,gBAAgB,GACtB,IAAI,CAEN;AAED,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,wBAAwB,EACjC,MAAM,EAAE,SAAS,gBAAgB,EAAE,GAClC,IAAI,CA4BN;AAMD,wBAAgB,4BAA4B,IAAI,kBAAkB,CAEjE"}

package/dist/memory-audit-handler.js

@@ -0,0 +1,191 @@
+// Memory audit handler (Epic #204, Issue #214).
+//
+// Bridges the vault's structural `MemoryEvent` (memory:inserted / memory:updated /
+// memory:deleted / memory:tombstoned / edge:* / embedding:upserted) into the SEMANTIC
+// `MemoryAuditEvent` surface defined in @oscharko-dev/keiko-contracts. The handler:
+//
+//   1. Maps each structural event to one or more semantic kinds by reading the new
+//      record's status, pinned flag, and comparing against an in-memory
+//      `previousStatus: Map<MemoryId, MemoryStatus>` for transition derivation.
+//   2. Builds a redacted summary string (via the BFF redactString closure).
+//   3. Appends the audit event to a date-bucketed JSON manifest in the existing
+//      keiko-evidence ledger (runId = `memory-audit-YYYY-MM-DD`).
+//
+// Persistence shape: ONE manifest per UTC date. Stores that expose `EvidenceStore.update()`
+// serialize the read-append-write step so concurrent audit appenders do not drop events.
+// Custom stores without that optional method still work through get+put, but the built-in
+// Node and in-memory stores use the safer update path.
+//
+// Failure mode: persistence errors are caught and logged to console.error; the handler
+// never throws. An audit-persistence failure must NEVER break the user's memory mutation.
+// Corrupt audit manifests are never reset or overwritten; append attempts fail closed and
+// preserve the existing artifact for operator investigation.
+//
+// Known limitation: the `previousStatus` map is in-memory only. After a server restart the
+// first `memory:updated` for any record lacks transition context and is classified as a
+// plain `memory:updated` (not promoted to `memory:accepted` / `memory:archived` / etc.).
+// The downstream record is captured fully — only the kind classification is degraded.
+//
+// Edge and embedding events are NOT bridged (out of audit scope per the audit invariant
+// in @oscharko-dev/keiko-contracts/memory: audit records carry no body or payload, and
+// edges + embeddings encode structural derivations the body-level audit already covers
+// via the related record mutations).
+//
+// Retrieval/workflow-specific kinds are NOT vault-derived. The `recordMemoryAudit()`
+// helper exported below is the single emission point for those direct audit signals.
+import { randomUUID } from "node:crypto";
+import { buildDeletedEvent, buildInsertedEvent, buildTombstonedEvent, buildUpdatedEvent, } from "./memory-audit-event-builders.js";
+import { sanitizeAuditEvent } from "./memory-scope-sanitizer.js";
+// ─── Constants ────────────────────────────────────────────────────────────────
+const RUNID_PREFIX = "memory-audit-";
+// ─── Pure helpers ─────────────────────────────────────────────────────────────
+// UTC date-bucket key. Stable across timezones; the audit ledger is local-only so a single
+// UTC bucket is unambiguous. Always 10 chars (`YYYY-MM-DD`), which combined with the
+// 13-char prefix yields a 23-char runId well under MAX_RUN_ID_LENGTH (256).
+export function auditRunIdFor(nowMs) {
+    const iso = new Date(nowMs).toISOString();
+    // ISO format is `YYYY-MM-DDTHH:mm:ss.sssZ`; slice [0,10] is the date.
+    return `${RUNID_PREFIX}${iso.slice(0, 10)}`;
+}
+// ─── Persistence ──────────────────────────────────────────────────────────────
+// Appends audit events to the date-bucketed manifest. The built-in evidence stores expose an
+// atomic update path; fallback stores still get parse-safe get+put behavior. Batch callers should
+// pass every event for one operation at once so the daily JSON manifest is parsed and rewritten once.
+function appendAuditEvents(store, runId, events) {
+    if (events.length === 0) {
+        return;
+    }
+    const append = (existingJson) => JSON.stringify([...parseExistingEvents(existingJson), ...events]);
+    if (store.update !== undefined) {
+        store.update(runId, append);
+        return;
+    }
+    store.put(runId, append(store.get(runId)));
+}
+function parseExistingEvents(json) {
+    if (json === undefined) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(json);
+        if (!Array.isArray(parsed)) {
+            throw new Error("memory audit manifest has unexpected shape");
+        }
+        return parsed;
+    }
+    catch (error) {
+        throw new Error(`memory audit manifest is corrupt; refusing to overwrite existing audit evidence: ${error instanceof Error ? error.message : "unknown"}`, { cause: error });
+    }
+}
+// ─── Public factory ───────────────────────────────────────────────────────────
+export function createMemoryAuditHandler(options) {
+    const now = options.now ?? (() => Date.now());
+    const newEventId = options.newEventId ?? (() => randomUUID());
+    const onPersistError = options.onPersistError ??
+        ((error) => {
+            // eslint-disable-next-line no-console
+            console.error("memory-audit-handler: persistence failed", error);
+        });
+    const previousStatus = new Map();
+    const previousPinned = new Map();
+    return (event) => {
+        const ctx = {
+            occurredAt: now(),
+            newEventId,
+            redactString: options.redactString,
+        };
+        const auditEvent = mapVaultEvent(event, previousStatus, previousPinned, ctx);
+        updateStateCache(event, previousStatus, previousPinned);
+        if (auditEvent === undefined) {
+            return;
+        }
+        try {
+            appendAuditEvents(options.evidenceStore, auditRunIdFor(auditEvent.occurredAt), [
+                sanitizeAuditEvent(auditEvent, options.redactString),
+            ]);
+        }
+        catch (error) {
+            onPersistError(error);
+        }
+    };
+}
+function mapVaultEvent(event, previousStatus, previousPinned, ctx) {
+    switch (event.kind) {
+        case "memory:inserted":
+            return buildInsertedEvent(event.record, ctx);
+        case "memory:updated":
+            return buildUpdatedEvent(event.record, previousStatus.get(event.record.id), previousPinned.get(event.record.id), ctx);
+        case "memory:tombstoned":
+            return buildTombstonedEvent(event.tombstone, ctx);
+        case "memory:deleted":
+            if (event.tombstoned) {
+                return undefined;
+            }
+            return buildDeletedEvent(event.memoryId, event.scope, ctx);
+        case "edge:inserted":
+        case "edge:deleted":
+        case "embedding:upserted":
+            // Edge and embedding events are out of audit scope.
+            return undefined;
+        default:
+            return undefined;
+    }
+}
+function updateStateCache(event, previousStatus, previousPinned) {
+    switch (event.kind) {
+        case "memory:inserted":
+        case "memory:updated":
+            previousStatus.set(event.record.id, event.record.status);
+            previousPinned.set(event.record.id, event.record.pinned);
+            return;
+        case "memory:deleted":
+            previousStatus.delete(event.memoryId);
+            previousPinned.delete(event.memoryId);
+            return;
+        case "memory:tombstoned":
+            previousStatus.delete(event.tombstone.memoryId);
+            previousPinned.delete(event.tombstone.memoryId);
+            return;
+        default:
+            return;
+    }
+}
+export function recordMemoryAudit(options, event) {
+    recordMemoryAudits(options, [event]);
+}
+export function recordMemoryAudits(options, events) {
+    if (events.length === 0) {
+        return;
+    }
+    const redactString = options.redactString ?? ((input) => input);
+    const onPersistError = options.onPersistError ??
+        ((error) => {
+            // eslint-disable-next-line no-console
+            console.error("memory-audit-handler: direct emission failed", error);
+        });
+    const eventsByRunId = new Map();
+    for (const event of events) {
+        const runId = auditRunIdFor(event.occurredAt);
+        const bucket = eventsByRunId.get(runId);
+        if (bucket === undefined) {
+            eventsByRunId.set(runId, [sanitizeAuditEvent(event, redactString)]);
+        }
+        else {
+            bucket.push(sanitizeAuditEvent(event, redactString));
+        }
+    }
+    for (const [runId, bucket] of eventsByRunId) {
+        try {
+            appendAuditEvents(options.evidenceStore, runId, bucket);
+        }
+        catch (error) {
+            onPersistError(error);
+        }
+    }
+}
+// ─── No-op handler ────────────────────────────────────────────────────────────
+// Used when no evidence store is configured (legacy tests, tooling). Keeps the
+// `onMemoryEvent` port wired so the vault doesn't have to special-case undefined.
+export function createNoopMemoryAuditHandler() {
+    return () => undefined;
+}

package/dist/memory-capture-policy.d.ts

@@ -0,0 +1,10 @@
+import type { CaptureOutcome, CapturePolicyOptions, RejectionReason } from "@oscharko-dev/keiko-memory-capture";
+import type { UiHandlerDeps } from "./deps.js";
+export declare const SENSITIVE_MEMORY_REJECTION_REASON: RejectionReason;
+export declare function memoryCaptureCustomerMatchers(deps: UiHandlerDeps): readonly RegExp[];
+export declare function memoryCapturePolicyForDeps(deps: UiHandlerDeps, base?: CapturePolicyOptions): CapturePolicyOptions;
+export declare function isPersistableMemoryCandidate(outcome: CaptureOutcome): outcome is Extract<CaptureOutcome, {
+    readonly kind: "candidate";
+}>;
+export declare function enforcePersistableMemoryOutcome(outcome: CaptureOutcome): CaptureOutcome;
+//# sourceMappingURL=memory-capture-policy.d.ts.map

package/dist/memory-capture-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-capture-policy.d.ts","sourceRoot":"","sources":["../src/memory-capture-policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,oBAAoB,EACpB,eAAe,EAChB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAG/C,eAAO,MAAM,iCAAiC,EAAE,eACV,CAAC;AAcvC,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,MAAM,EAAE,CAapF;AAED,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,aAAa,EACnB,IAAI,GAAE,oBAAyB,GAC9B,oBAAoB,CAMtB;AAED,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,cAAc,GACtB,OAAO,IAAI,OAAO,CAAC,cAAc,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;CAAE,CAAC,CAMpE;AAED,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,cAAc,GAAG,cAAc,CAKvF"}

package/dist/memory-capture-policy.js

@@ -0,0 +1,44 @@
+import { currentRedactionSecrets } from "./deps.js";
+export const SENSITIVE_MEMORY_REJECTION_REASON = "sensitive-memory-requires-approval";
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function exactMatcherFor(value) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        return null;
+    }
+    return new RegExp(escapeRegExp(trimmed));
+}
+export function memoryCaptureCustomerMatchers(deps) {
+    const literals = new Set([
+        ...(deps.redactionSecrets ?? []),
+        ...currentRedactionSecrets(deps),
+    ]);
+    const matchers = [];
+    for (const literal of literals) {
+        const matcher = exactMatcherFor(literal);
+        if (matcher !== null) {
+            matchers.push(matcher);
+        }
+    }
+    return matchers;
+}
+export function memoryCapturePolicyForDeps(deps, base = {}) {
+    const matchers = [
+        ...(base.customerIdentifierMatchers ?? []),
+        ...memoryCaptureCustomerMatchers(deps),
+    ];
+    return matchers.length === 0 ? base : { ...base, customerIdentifierMatchers: matchers };
+}
+export function isPersistableMemoryCandidate(outcome) {
+    return (outcome.kind === "candidate" &&
+        !outcome.requiresApproval &&
+        outcome.proposal.provenance.sensitivity === "public");
+}
+export function enforcePersistableMemoryOutcome(outcome) {
+    if (outcome.kind !== "candidate" || isPersistableMemoryCandidate(outcome)) {
+        return outcome;
+    }
+    return { kind: "rejected", reason: SENSITIVE_MEMORY_REJECTION_REASON };
+}

package/dist/memory-consolidation-handlers.d.ts

@@ -0,0 +1,6 @@
+import type { UiHandlerDeps } from "./deps.js";
+import type { RouteContext, RouteResult } from "./routes.js";
+export declare function handleCreateConsolidationJob(ctx: RouteContext, deps: UiHandlerDeps): Promise<RouteResult>;
+export declare function handleGetConsolidationJob(ctx: RouteContext, deps: UiHandlerDeps): RouteResult;
+export declare function handleCancelConsolidationJob(ctx: RouteContext, deps: UiHandlerDeps): RouteResult;
+//# sourceMappingURL=memory-consolidation-handlers.d.ts.map

package/dist/memory-consolidation-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-consolidation-handlers.d.ts","sourceRoot":"","sources":["../src/memory-consolidation-handlers.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAigB7D,wBAAsB,4BAA4B,CAChD,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,WAAW,CAAC,CA0BtB;AAED,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,GAAG,WAAW,CAe7F;AAED,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,GAAG,WAAW,CAoBhG"}