dsh-memory-gate 0.2.0

package/lib/index.js

@@ -0,0 +1,44 @@
+import { registerUnavailableMemoryCommand } from './commands.js';
+import { Config, validateConfig } from './config.js';
+import { attachHarness } from './harness.js';
+import { MemoryRepository } from './repository.js';
+import { MemoryService } from './service.js';
+export const name = 'dsh-memory-gate';
+export const inject = ['commands'];
+export { Config };
+export function apply(ctx, config) {
+    const resolved = validateConfig(config);
+    let repository;
+    try {
+        repository = new MemoryRepository(resolved.databasePath);
+    }
+    catch (cause) {
+        ctx.logger('memory-gate').error('memory store unavailable; continuing without memory: %s', cause instanceof Error ? cause.message : String(cause));
+        ctx.effect(() => registerUnavailableMemoryCommand(ctx.commands), 'memory-gate: unavailable command');
+        return;
+    }
+    try {
+        repository.pruneAudit(resolved.auditRetentionRuns);
+    }
+    catch (cause) {
+        ctx.logger('memory-gate').warn('memory audit pruning omitted: %s', cause instanceof Error ? cause.message : String(cause));
+    }
+    const service = new MemoryService(repository, resolved);
+    ctx.effect(() => () => {
+        try {
+            repository.close();
+        }
+        catch (cause) {
+            ctx.logger('memory-gate').warn('memory database close failed: %s', cause instanceof Error ? cause.message : String(cause));
+        }
+    }, 'memory-gate: database');
+    attachHarness(ctx, service);
+}
+export { decideAuthority } from './authority.js';
+export { extractDurableClaims } from './extractor.js';
+export { injectRecall, observeSessionEvent } from './harness.js';
+export { inspectForSecrets, redactForLog } from './redaction.js';
+export { MemoryRepository } from './repository.js';
+export { sessionScopeKey, workspaceScopeKey } from './scope.js';
+export { MemoryService } from './service.js';
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gCAAgC,EAAE,MAAM,eAAe,CAAA;AAChE,OAAO,EAAE,MAAM,EAA+B,cAAc,EAAE,MAAM,aAAa,CAAA;AACjF,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAE5C,MAAM,CAAC,MAAM,IAAI,GAAG,iBAAiB,CAAA;AACrC,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,UAAU,CAAC,CAAA;AAClC,OAAO,EAAE,MAAM,EAAE,CAAA;AAEjB,MAAM,UAAU,KAAK,CAAC,GAAY,EAAE,MAAoB;IACtD,MAAM,QAAQ,GAAG,cAAc,CAAC,MAAM,CAAC,CAAA;IACvC,IAAI,UAA4B,CAAA;IAChC,IAAI,CAAC;QACH,UAAU,GAAG,IAAI,gBAAgB,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAA;IAC1D,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,KAAK,CAC7B,yDAAyD,EACzD,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CACvD,CAAA;QACD,GAAG,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,gCAAgC,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,kCAAkC,CAAC,CAAA;QACpG,OAAM;IACR,CAAC;IACD,IAAI,CAAC;QACH,UAAU,CAAC,UAAU,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAA;IACpD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,IAAI,CAC5B,kCAAkC,EAClC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CACvD,CAAA;IACH,CAAC;IACD,MAAM,OAAO,GAAG,IAAI,aAAa,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAA;IACvD,GAAG,CAAC,MAAM,CACR,GAAG,EAAE,CAAC,GAAG,EAAE;QACT,IAAI,CAAC;YACH,UAAU,CAAC,KAAK,EAAE,CAAA;QACpB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,kCAAkC,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;QAC5H,CAAC;IACH,CAAC,EACD,uBAAuB,CACxB,CAAA;IACD,aAAa,CAAC,GAAG,EAAE,OAAO,CAAC,CAAA;AAC7B,CAAC;AAGD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AACrD,OAAO,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAChE,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAClD,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA"}

package/lib/message-text.d.ts

@@ -0,0 +1,3 @@
+export declare function messageText(message: unknown): string;
+export declare function isHumanUserMessage(message: unknown): boolean;
+//# sourceMappingURL=message-text.d.ts.map

package/lib/message-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-text.d.ts","sourceRoot":"","sources":["../src/message-text.ts"],"names":[],"mappings":"AAUA,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAUpD;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAI5D"}

package/lib/message-text.js

@@ -0,0 +1,21 @@
+export function messageText(message) {
+    if (!message || typeof message !== 'object')
+        return '';
+    const content = message.content;
+    if (typeof content === 'string')
+        return content.trim();
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .map((part) => (part?.type === 'text' && typeof part.text === 'string' ? part.text : ''))
+        .filter(Boolean)
+        .join('\n')
+        .trim();
+}
+export function isHumanUserMessage(message) {
+    if (!message || typeof message !== 'object')
+        return false;
+    const source = message.source;
+    return source?.kind === 'user';
+}
+//# sourceMappingURL=message-text.js.map

package/lib/message-text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-text.js","sourceRoot":"","sources":["../src/message-text.ts"],"names":[],"mappings":"AAUA,MAAM,UAAU,WAAW,CAAC,OAAgB;IAC1C,IAAI,CAAC,OAAO,IAAI,OAAO,OAAO,KAAK,QAAQ;QAAE,OAAO,EAAE,CAAA;IACtD,MAAM,OAAO,GAAI,OAAuB,CAAC,OAAO,CAAA;IAChD,IAAI,OAAO,OAAO,KAAK,QAAQ;QAAE,OAAO,OAAO,CAAC,IAAI,EAAE,CAAA;IACtD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;QAAE,OAAO,EAAE,CAAA;IACtC,OAAO,OAAO;SACX,GAAG,CAAC,CAAC,IAAc,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,IAAI,KAAK,MAAM,IAAI,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;SAClG,MAAM,CAAC,OAAO,CAAC;SACf,IAAI,CAAC,IAAI,CAAC;SACV,IAAI,EAAE,CAAA;AACX,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,OAAgB;IACjD,IAAI,CAAC,OAAO,IAAI,OAAO,OAAO,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAA;IACzD,MAAM,MAAM,GAAI,OAAuB,CAAC,MAAM,CAAA;IAC9C,OAAO,MAAM,EAAE,IAAI,KAAK,MAAM,CAAA;AAChC,CAAC"}

package/lib/redaction.d.ts

@@ -0,0 +1,7 @@
+export interface SecretInspection {
+    secret: boolean;
+    labels: string[];
+}
+export declare function inspectForSecrets(text: string): SecretInspection;
+export declare function redactForLog(text: string, maxLength?: number): string;
+//# sourceMappingURL=redaction.d.ts.map

package/lib/redaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redaction.d.ts","sourceRoot":"","sources":["../src/redaction.ts"],"names":[],"mappings":"AAYA,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,OAAO,CAAA;IACf,MAAM,EAAE,MAAM,EAAE,CAAA;CACjB;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,CAGhE;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,SAAM,GAAG,MAAM,CAMlE"}

package/lib/redaction.js

@@ -0,0 +1,23 @@
+const SECRET_PATTERNS = [
+    { label: 'OpenAI-style API key', pattern: /\bsk-[A-Za-z0-9_-]{16,}\b/ },
+    { label: 'GitHub token', pattern: /\bgh[opsu]_[A-Za-z0-9]{20,}\b/ },
+    { label: 'AWS access key', pattern: /\bAKIA[0-9A-Z]{16}\b/ },
+    { label: 'Bearer token', pattern: /\bBearer\s+[A-Za-z0-9._~+/=-]{16,}/i },
+    {
+        label: 'credential assignment',
+        pattern: /\b(?:api[_-]?key|access[_-]?token|secret|password|passwd)\s*[:=]\s*["']?[^\s"']{8,}/i,
+    },
+    { label: 'private key', pattern: /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/ },
+];
+export function inspectForSecrets(text) {
+    const labels = SECRET_PATTERNS.filter(({ pattern }) => pattern.test(text)).map(({ label }) => label);
+    return { secret: labels.length > 0, labels };
+}
+export function redactForLog(text, maxLength = 160) {
+    let value = text;
+    for (const { pattern } of SECRET_PATTERNS) {
+        value = value.replace(new RegExp(pattern.source, pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`), '[REDACTED]');
+    }
+    return value.length > maxLength ? `${value.slice(0, maxLength - 1)}…` : value;
+}
+//# sourceMappingURL=redaction.js.map

package/lib/redaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redaction.js","sourceRoot":"","sources":["../src/redaction.ts"],"names":[],"mappings":"AAAA,MAAM,eAAe,GAA8C;IACjE,EAAE,KAAK,EAAE,sBAAsB,EAAE,OAAO,EAAE,2BAA2B,EAAE;IACvE,EAAE,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,+BAA+B,EAAE;IACnE,EAAE,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,sBAAsB,EAAE;IAC5D,EAAE,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,qCAAqC,EAAE;IACzE;QACE,KAAK,EAAE,uBAAuB;QAC9B,OAAO,EAAE,sFAAsF;KAChG;IACD,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,mDAAmD,EAAE;CACvF,CAAA;AAOD,MAAM,UAAU,iBAAiB,CAAC,IAAY;IAC5C,MAAM,MAAM,GAAG,eAAe,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,CAAA;IACpG,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,MAAM,EAAE,CAAA;AAC9C,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,IAAY,EAAE,SAAS,GAAG,GAAG;IACxD,IAAI,KAAK,GAAG,IAAI,CAAA;IAChB,KAAK,MAAM,EAAE,OAAO,EAAE,IAAI,eAAe,EAAE,CAAC;QAC1C,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,GAAG,CAAC,EAAE,YAAY,CAAC,CAAA;IACpI,CAAC;IACD,OAAO,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAA;AAC/E,CAAC"}

package/lib/repository.d.ts

@@ -0,0 +1,39 @@
+import type { AuthorityDecision, Belief, Claim, ConsumptionOutcome, Evidence, MemoryStats, NewClaim, SearchCandidate } from './contracts.js';
+export declare class MemoryRepository {
+    readonly databasePath: string;
+    private readonly db;
+    private ftsAvailable;
+    constructor(databasePath: string);
+    close(): void;
+    health(): {
+        ok: boolean;
+        schemaVersion: number;
+        ftsAvailable: boolean;
+    };
+    remember(input: NewClaim): {
+        claim: Claim;
+        created: boolean;
+    };
+    tombstone(claimId: string, scopeKeys: string[]): boolean;
+    getClaim(claimId: string, scopeKeys?: string[]): Claim | undefined;
+    getBelief(claimId: string): Belief | undefined;
+    getEvidence(claimId: string): Evidence[];
+    search(query: string, scopeKeys: string[], limit: number): SearchCandidate[];
+    capsule(scopeKeys: string[], limit: number): SearchCandidate[];
+    listActive(scopeKeys: string[], limit: number): SearchCandidate[];
+    recordRetrieval(query: string, sessionId: string, workspaceKey: string, candidateCount: number): string;
+    recordDecisions(runId: string, decisions: AuthorityDecision[]): void;
+    recordInjection(runId: string, sessionId: string, mode: string, claimIds: string[], messageId: string): string;
+    recordConsumption(claimId: string, outcome: ConsumptionOutcome, sessionId: string, detail?: string): Belief;
+    pruneAudit(maxRuns: number): number;
+    stats(): MemoryStats;
+    private count;
+    private countRows;
+    private searchFtsIds;
+    private indexClaim;
+    private migrate;
+    private transaction;
+}
+export declare function normalizeContent(value: string): string;
+export declare function hashContent(value: string): string;
+//# sourceMappingURL=repository.d.ts.map

package/lib/repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../src/repository.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,iBAAiB,EACjB,MAAM,EACN,KAAK,EACL,kBAAkB,EAClB,QAAQ,EACR,WAAW,EACX,QAAQ,EACR,eAAe,EAChB,MAAM,gBAAgB,CAAA;AAOvB,qBAAa,gBAAgB;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAc;IACjC,OAAO,CAAC,YAAY,CAAQ;gBAEhB,YAAY,EAAE,MAAM;IAShC,KAAK,IAAI,IAAI;IAIb,MAAM,IAAI;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,OAAO,CAAA;KAAE;IASvE,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG;QAAE,KAAK,EAAE,KAAK,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE;IA0E7D,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,OAAO;IAcxD,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,KAAK,GAAG,SAAS;IAalE,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAK9C,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,EAAE;IAOxC,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,eAAe,EAAE;IA4B5E,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,eAAe,EAAE;IAwB9D,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,eAAe,EAAE;IAIjE,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM;IAUvG,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,iBAAiB,EAAE,GAAG,IAAI;IAyBpE,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM;IAU9G,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM;IAgC3G,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAoBnC,KAAK,IAAI,WAAW;IAYpB,OAAO,CAAC,KAAK;IAIb,OAAO,CAAC,SAAS;IAKjB,OAAO,CAAC,YAAY;IAmBpB,OAAO,CAAC,UAAU;IAKlB,OAAO,CAAC,OAAO;IAkGf,OAAO,CAAC,WAAW;CAWpB;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEjD"}

package/lib/repository.js

@@ -0,0 +1,492 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdirSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+const SCHEMA_VERSION = 1;
+export class MemoryRepository {
+    databasePath;
+    db;
+    ftsAvailable = false;
+    constructor(databasePath) {
+        this.databasePath = databasePath === ':memory:' ? databasePath : resolve(databasePath);
+        if (this.databasePath !== ':memory:')
+            mkdirSync(dirname(this.databasePath), { recursive: true, mode: 0o700 });
+        this.db = new DatabaseSync(this.databasePath);
+        this.db.exec('PRAGMA foreign_keys = ON; PRAGMA busy_timeout = 3000;');
+        if (this.databasePath !== ':memory:')
+            this.db.exec('PRAGMA journal_mode = WAL;');
+        this.migrate();
+    }
+    close() {
+        this.db.close();
+    }
+    health() {
+        const row = this.db.prepare('PRAGMA user_version').get();
+        return {
+            ok: Number(row.user_version) === SCHEMA_VERSION,
+            schemaVersion: Number(row.user_version),
+            ftsAvailable: this.ftsAvailable,
+        };
+    }
+    remember(input) {
+        const content = normalizeContent(input.content);
+        if (!content)
+            throw new Error('Memory content cannot be empty');
+        const contentHash = hashContent(content);
+        const existing = this.db
+            .prepare(`SELECT * FROM claims
+         WHERE scope_key = ? AND content_hash = ? AND state = 'active'
+         ORDER BY updated_at DESC LIMIT 1`)
+            .get(input.scopeKey, contentHash);
+        if (existing)
+            return { claim: rowToClaim(existing), created: false };
+        const now = Date.now();
+        const claim = {
+            id: `mem_${randomUUID()}`,
+            scope: input.scope,
+            scopeKey: input.scopeKey,
+            kind: input.kind,
+            content,
+            tags: uniqueTags(input.tags ?? []),
+            state: 'active',
+            origin: input.origin,
+            sensitivity: input.sensitivity ?? 'normal',
+            contentHash,
+            ...(input.sourceSessionId === undefined ? {} : { sourceSessionId: input.sourceSessionId }),
+            ...(input.sourceEventSeq === undefined ? {} : { sourceEventSeq: input.sourceEventSeq }),
+            validFrom: input.validFrom ?? now,
+            ...(input.validUntil === undefined ? {} : { validUntil: input.validUntil }),
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.transaction(() => {
+            this.db
+                .prepare(`INSERT INTO claims (
+             id, scope, scope_key, kind, content, tags_json, state, origin,
+             sensitivity, content_hash, source_session_id, source_event_seq,
+             valid_from, valid_until, created_at, updated_at
+           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(claim.id, claim.scope, claim.scopeKey, claim.kind, claim.content, JSON.stringify(claim.tags), claim.state, claim.origin, claim.sensitivity, claim.contentHash, claim.sourceSessionId ?? null, claim.sourceEventSeq ?? null, claim.validFrom, claim.validUntil ?? null, claim.createdAt, claim.updatedAt);
+            const alpha = claim.origin === 'explicit' ? 6 : 4;
+            const beta = claim.origin === 'explicit' ? 1 : 2;
+            this.db
+                .prepare('INSERT INTO beliefs (claim_id, alpha, beta, harmful_count, updated_at) VALUES (?, ?, ?, 0, ?)')
+                .run(claim.id, alpha, beta, now);
+            this.db
+                .prepare('INSERT INTO evidence (id, claim_id, kind, weight, detail, session_id, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)')
+                .run(`ev_${randomUUID()}`, claim.id, 'asserted', 1, claim.origin, claim.sourceSessionId ?? null, now);
+            this.indexClaim(claim);
+        });
+        return { claim, created: true };
+    }
+    tombstone(claimId, scopeKeys) {
+        const placeholders = scopeKeys.map(() => '?').join(', ');
+        if (!placeholders)
+            return false;
+        let changed = false;
+        this.transaction(() => {
+            const result = this.db
+                .prepare(`UPDATE claims SET state = 'tombstoned', updated_at = ? WHERE id = ? AND scope_key IN (${placeholders}) AND state = 'active'`)
+                .run(Date.now(), claimId, ...scopeKeys);
+            changed = Number(result.changes) > 0;
+            if (changed && this.ftsAvailable)
+                this.db.prepare('DELETE FROM claim_fts WHERE claim_id = ?').run(claimId);
+        });
+        return changed;
+    }
+    getClaim(claimId, scopeKeys) {
+        let row;
+        if (scopeKeys?.length) {
+            const placeholders = scopeKeys.map(() => '?').join(', ');
+            row = this.db
+                .prepare(`SELECT * FROM claims WHERE id = ? AND scope_key IN (${placeholders}) LIMIT 1`)
+                .get(claimId, ...scopeKeys);
+        }
+        else {
+            row = this.db.prepare('SELECT * FROM claims WHERE id = ? LIMIT 1').get(claimId);
+        }
+        return row ? rowToClaim(row) : undefined;
+    }
+    getBelief(claimId) {
+        const row = this.db.prepare('SELECT * FROM beliefs WHERE claim_id = ?').get(claimId);
+        return row ? rowToBelief(row) : undefined;
+    }
+    getEvidence(claimId) {
+        const rows = this.db
+            .prepare('SELECT * FROM evidence WHERE claim_id = ? ORDER BY created_at DESC')
+            .all(claimId);
+        return rows.map(rowToEvidence);
+    }
+    search(query, scopeKeys, limit) {
+        if (!scopeKeys.length || limit < 1)
+            return [];
+        const placeholders = scopeKeys.map(() => '?').join(', ');
+        const scanLimit = Math.min(Math.max(limit * 20, 100), 500);
+        const rows = this.db
+            .prepare(`SELECT c.*, b.alpha, b.beta, b.harmful_count, b.updated_at AS belief_updated_at
+         FROM claims c JOIN beliefs b ON b.claim_id = c.id
+         WHERE c.state = 'active' AND c.scope_key IN (${placeholders})
+           AND c.valid_from <= ? AND (c.valid_until IS NULL OR c.valid_until > ?)
+         ORDER BY c.updated_at DESC LIMIT ?`)
+            .all(...scopeKeys, Date.now(), Date.now(), scanLimit);
+        const ftsIds = this.searchFtsIds(query, scopeKeys, scanLimit);
+        const queryTerms = terms(query);
+        return rows
+            .map((row) => {
+            const claim = rowToClaim(row);
+            const lexicalScore = lexicalSimilarity(queryTerms, claim.content, claim.tags, ftsIds.has(claim.id));
+            const belief = rowToBelief(row);
+            return { claim, belief, recallChannel: 'trigger', lexicalScore, freshnessScore: 0, rankScore: lexicalScore };
+        })
+            .filter((candidate) => queryTerms.length === 0 || candidate.lexicalScore > 0)
+            .sort((a, b) => b.rankScore - a.rankScore || b.claim.updatedAt - a.claim.updatedAt)
+            .slice(0, limit);
+    }
+    capsule(scopeKeys, limit) {
+        if (!scopeKeys.includes('global') || limit < 1)
+            return [];
+        const now = Date.now();
+        const rows = this.db
+            .prepare(`SELECT c.*, b.alpha, b.beta, b.harmful_count, b.updated_at AS belief_updated_at
+         FROM claims c JOIN beliefs b ON b.claim_id = c.id
+         WHERE c.state = 'active' AND c.scope = 'global' AND c.scope_key = 'global'
+           AND c.origin = 'explicit' AND c.kind IN ('preference', 'constraint')
+           AND c.valid_from <= ? AND (c.valid_until IS NULL OR c.valid_until > ?)
+         ORDER BY (b.alpha / (b.alpha + b.beta)) DESC, c.updated_at DESC
+         LIMIT ?`)
+            .all(now, now, limit);
+        return rows.map((row) => ({
+            claim: rowToClaim(row),
+            belief: rowToBelief(row),
+            recallChannel: 'capsule',
+            lexicalScore: 0.35,
+            freshnessScore: 0,
+            rankScore: 0.35,
+        }));
+    }
+    listActive(scopeKeys, limit) {
+        return this.search('', scopeKeys, limit);
+    }
+    recordRetrieval(query, sessionId, workspaceKey, candidateCount) {
+        const id = `run_${randomUUID()}`;
+        this.db
+            .prepare('INSERT INTO retrieval_runs (id, query_hash, session_id, workspace_key, candidate_count, created_at) VALUES (?, ?, ?, ?, ?, ?)')
+            .run(id, hashContent(query), sessionId, workspaceKey, candidateCount, Date.now());
+        return id;
+    }
+    recordDecisions(runId, decisions) {
+        this.transaction(() => {
+            const statement = this.db.prepare(`INSERT INTO authority_decisions
+         (id, run_id, claim_id, action, reason_codes_json, belief_score, relevance_score, freshness_score, risk_score, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+            const now = Date.now();
+            for (const decision of decisions) {
+                statement.run(`dec_${randomUUID()}`, runId, decision.claimId, decision.action, JSON.stringify(decision.reasonCodes), decision.beliefScore, decision.relevanceScore, decision.freshnessScore, decision.riskScore, now);
+            }
+        });
+    }
+    recordInjection(runId, sessionId, mode, claimIds, messageId) {
+        const id = `inj_${randomUUID()}`;
+        this.db
+            .prepare('INSERT INTO injections (id, run_id, session_id, mode, claim_ids_json, message_id, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)')
+            .run(id, runId, sessionId, mode, JSON.stringify(claimIds), messageId, Date.now());
+        return id;
+    }
+    recordConsumption(claimId, outcome, sessionId, detail) {
+        const claim = this.getClaim(claimId);
+        if (!claim || claim.state !== 'active')
+            throw new Error('Active memory claim not found');
+        const weights = {
+            helped: { alpha: 1, beta: 0, harmful: 0 },
+            harmful: { alpha: 0, beta: 5, harmful: 1 },
+            stale: { alpha: 0, beta: 2, harmful: 0 },
+            conflict: { alpha: 0, beta: 4, harmful: 0 },
+            unknown: { alpha: 0, beta: 0, harmful: 0 },
+        };
+        const delta = weights[outcome];
+        const now = Date.now();
+        this.transaction(() => {
+            this.db
+                .prepare('INSERT INTO consumption (id, claim_id, session_id, outcome, detail, created_at) VALUES (?, ?, ?, ?, ?, ?)')
+                .run(`con_${randomUUID()}`, claimId, sessionId, outcome, detail ?? null, now);
+            if (outcome !== 'unknown') {
+                this.db
+                    .prepare('UPDATE beliefs SET alpha = alpha + ?, beta = beta + ?, harmful_count = harmful_count + ?, updated_at = ? WHERE claim_id = ?')
+                    .run(delta.alpha, delta.beta, delta.harmful, now, claimId);
+                this.db
+                    .prepare('INSERT INTO evidence (id, claim_id, kind, weight, detail, session_id, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)')
+                    .run(`ev_${randomUUID()}`, claimId, outcome, delta.alpha || delta.beta, detail ?? null, sessionId, now);
+            }
+        });
+        const belief = this.getBelief(claimId);
+        if (!belief)
+            throw new Error('Memory belief update failed');
+        return belief;
+    }
+    pruneAudit(maxRuns) {
+        const excess = Math.max(0, this.countRows('retrieval_runs') - Math.max(1, Math.floor(maxRuns)));
+        if (!excess)
+            return 0;
+        this.transaction(() => {
+            this.db.exec('CREATE TEMP TABLE IF NOT EXISTS memory_prune_runs (id TEXT PRIMARY KEY)');
+            this.db.exec('DELETE FROM memory_prune_runs');
+            this.db
+                .prepare(`INSERT INTO memory_prune_runs (id)
+           SELECT id FROM retrieval_runs ORDER BY created_at ASC, id ASC LIMIT ?`)
+                .run(excess);
+            this.db.exec('DELETE FROM injections WHERE run_id IN (SELECT id FROM memory_prune_runs)');
+            this.db.exec('DELETE FROM authority_decisions WHERE run_id IN (SELECT id FROM memory_prune_runs)');
+            this.db.exec('DELETE FROM retrieval_runs WHERE id IN (SELECT id FROM memory_prune_runs)');
+            this.db.exec('DELETE FROM memory_prune_runs');
+        });
+        return excess;
+    }
+    stats() {
+        const claimRows = this.db.prepare('SELECT state, COUNT(*) AS count FROM claims GROUP BY state').all();
+        const byState = new Map(claimRows.map((row) => [String(row.state), Number(row.count)]));
+        return {
+            activeClaims: byState.get('active') ?? 0,
+            tombstonedClaims: byState.get('tombstoned') ?? 0,
+            decisions: this.count('authority_decisions'),
+            injections: this.count('injections'),
+            consumptions: this.count('consumption'),
+        };
+    }
+    count(table) {
+        return this.countRows(table);
+    }
+    countRows(table) {
+        const row = this.db.prepare(`SELECT COUNT(*) AS count FROM ${table}`).get();
+        return Number(row.count);
+    }
+    searchFtsIds(query, scopeKeys, limit) {
+        if (!this.ftsAvailable)
+            return new Set();
+        const ftsQuery = buildFtsQuery(query);
+        if (!ftsQuery)
+            return new Set();
+        try {
+            const placeholders = scopeKeys.map(() => '?').join(', ');
+            const rows = this.db
+                .prepare(`SELECT f.claim_id FROM claim_fts f JOIN claims c ON c.id = f.claim_id
+           WHERE claim_fts MATCH ? AND c.scope_key IN (${placeholders}) AND c.state = 'active'
+           ORDER BY bm25(claim_fts) LIMIT ?`)
+                .all(ftsQuery, ...scopeKeys, limit);
+            return new Set(rows.map((row) => String(row.claim_id)));
+        }
+        catch {
+            return new Set();
+        }
+    }
+    indexClaim(claim) {
+        if (!this.ftsAvailable)
+            return;
+        this.db.prepare('INSERT INTO claim_fts (claim_id, content, tags) VALUES (?, ?, ?)').run(claim.id, claim.content, claim.tags.join(' '));
+    }
+    migrate() {
+        const versionRow = this.db.prepare('PRAGMA user_version').get();
+        const version = Number(versionRow.user_version);
+        if (version > SCHEMA_VERSION)
+            throw new Error(`Unsupported memory schema version ${version}`);
+        if (version < 1) {
+            this.transaction(() => {
+                this.db.exec(`
+          CREATE TABLE claims (
+            id TEXT PRIMARY KEY,
+            scope TEXT NOT NULL CHECK (scope IN ('session', 'workspace', 'global')),
+            scope_key TEXT NOT NULL,
+            kind TEXT NOT NULL CHECK (kind IN ('preference', 'constraint', 'fact', 'procedure', 'warning')),
+            content TEXT NOT NULL,
+            tags_json TEXT NOT NULL DEFAULT '[]',
+            state TEXT NOT NULL CHECK (state IN ('active', 'superseded', 'tombstoned')),
+            origin TEXT NOT NULL CHECK (origin IN ('explicit', 'heuristic')),
+            sensitivity TEXT NOT NULL CHECK (sensitivity IN ('normal', 'private')),
+            content_hash TEXT NOT NULL,
+            source_session_id TEXT,
+            source_event_seq INTEGER,
+            valid_from INTEGER NOT NULL,
+            valid_until INTEGER,
+            created_at INTEGER NOT NULL,
+            updated_at INTEGER NOT NULL
+          );
+          CREATE INDEX claims_scope_state_updated ON claims(scope_key, state, updated_at DESC);
+          CREATE INDEX claims_dedupe ON claims(scope_key, content_hash, state);
+          CREATE TABLE beliefs (
+            claim_id TEXT PRIMARY KEY REFERENCES claims(id) ON DELETE CASCADE,
+            alpha REAL NOT NULL,
+            beta REAL NOT NULL,
+            harmful_count INTEGER NOT NULL DEFAULT 0,
+            updated_at INTEGER NOT NULL
+          );
+          CREATE TABLE evidence (
+            id TEXT PRIMARY KEY,
+            claim_id TEXT NOT NULL REFERENCES claims(id) ON DELETE CASCADE,
+            kind TEXT NOT NULL,
+            weight REAL NOT NULL,
+            detail TEXT,
+            session_id TEXT,
+            created_at INTEGER NOT NULL
+          );
+          CREATE INDEX evidence_claim_created ON evidence(claim_id, created_at DESC);
+          CREATE TABLE retrieval_runs (
+            id TEXT PRIMARY KEY,
+            query_hash TEXT NOT NULL,
+            session_id TEXT NOT NULL,
+            workspace_key TEXT NOT NULL,
+            candidate_count INTEGER NOT NULL,
+            created_at INTEGER NOT NULL
+          );
+          CREATE TABLE authority_decisions (
+            id TEXT PRIMARY KEY,
+            run_id TEXT NOT NULL REFERENCES retrieval_runs(id) ON DELETE CASCADE,
+            claim_id TEXT NOT NULL REFERENCES claims(id),
+            action TEXT NOT NULL CHECK (action IN ('use', 'verify', 'ignore')),
+            reason_codes_json TEXT NOT NULL,
+            belief_score REAL NOT NULL,
+            relevance_score REAL NOT NULL,
+            freshness_score REAL NOT NULL,
+            risk_score REAL NOT NULL,
+            created_at INTEGER NOT NULL
+          );
+          CREATE INDEX decisions_run ON authority_decisions(run_id);
+          CREATE TABLE injections (
+            id TEXT PRIMARY KEY,
+            run_id TEXT NOT NULL REFERENCES retrieval_runs(id),
+            session_id TEXT NOT NULL,
+            mode TEXT NOT NULL,
+            claim_ids_json TEXT NOT NULL,
+            message_id TEXT NOT NULL,
+            created_at INTEGER NOT NULL
+          );
+          CREATE TABLE consumption (
+            id TEXT PRIMARY KEY,
+            claim_id TEXT NOT NULL REFERENCES claims(id),
+            session_id TEXT NOT NULL,
+            outcome TEXT NOT NULL,
+            detail TEXT,
+            created_at INTEGER NOT NULL
+          );
+          PRAGMA user_version = 1;
+        `);
+            });
+        }
+        try {
+            this.db.exec("CREATE VIRTUAL TABLE IF NOT EXISTS claim_fts USING fts5(claim_id UNINDEXED, content, tags, tokenize='unicode61')");
+            this.ftsAvailable = true;
+            const row = this.db.prepare('SELECT COUNT(*) AS count FROM claim_fts').get();
+            if (Number(row.count) === 0) {
+                this.db.exec("INSERT INTO claim_fts (claim_id, content, tags) SELECT id, content, replace(replace(tags_json, '[', ''), ']', '') FROM claims WHERE state = 'active'");
+            }
+        }
+        catch {
+            this.ftsAvailable = false;
+        }
+    }
+    transaction(operation) {
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            const result = operation();
+            this.db.exec('COMMIT');
+            return result;
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+}
+export function normalizeContent(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+export function hashContent(value) {
+    return createHash('sha256').update(normalizeContent(value).toLocaleLowerCase()).digest('hex');
+}
+function uniqueTags(tags) {
+    return [...new Set(tags.map((tag) => tag.trim().toLocaleLowerCase()).filter(Boolean))].slice(0, 20);
+}
+function terms(value) {
+    const normalized = value.toLocaleLowerCase().normalize('NFKC');
+    const latin = normalized.match(/[\p{Script=Latin}\p{N}_-]{2,}/gu) ?? [];
+    const hanRuns = normalized.match(/[\p{Script=Han}]+/gu) ?? [];
+    const han = hanRuns.flatMap((run) => {
+        if (run.length <= 2)
+            return [run];
+        return Array.from({ length: run.length - 1 }, (_, index) => run.slice(index, index + 2));
+    });
+    const raw = [...latin, ...han];
+    const aliases = raw.flatMap((term) => recallAliases(term));
+    return [...new Set([...raw, ...aliases])];
+}
+function lexicalSimilarity(queryTerms, content, tags, ftsHit) {
+    if (!queryTerms.length)
+        return 0.5;
+    const candidateTerms = new Set(terms(`${content} ${tags.join(' ')}`));
+    const matched = queryTerms.filter((term) => candidateTerms.has(term)).length;
+    const queryCoverage = matched / queryTerms.length;
+    const candidateCoverage = matched / Math.max(1, candidateTerms.size);
+    const overlap = Math.max(queryCoverage, candidateCoverage);
+    return Math.min(1, overlap * 0.9 + (ftsHit ? 0.1 : 0));
+}
+const RECALL_ALIAS_GROUPS = [
+    ['简洁', '简短', '精炼', '扼要', 'concise', 'brief'],
+    ['中文', '汉语', 'chinese'],
+    ['回答', '回复', '答复', 'answer', 'response'],
+    ['偏好', '喜欢', 'prefer', 'preference'],
+    ['项目', '工程', 'project'],
+    ['测试', '验证', 'test', 'verify'],
+];
+function recallAliases(term) {
+    const aliases = [];
+    for (let index = 0; index < RECALL_ALIAS_GROUPS.length; index += 1) {
+        if (RECALL_ALIAS_GROUPS[index]?.includes(term))
+            aliases.push(`recall_alias_${index}`);
+    }
+    return aliases;
+}
+function buildFtsQuery(value) {
+    return terms(value)
+        .slice(0, 12)
+        .map((term) => `"${term.replaceAll('"', '""')}"`)
+        .join(' OR ');
+}
+function rowToClaim(row) {
+    return {
+        id: String(row.id),
+        scope: String(row.scope),
+        scopeKey: String(row.scope_key),
+        kind: String(row.kind),
+        content: String(row.content),
+        tags: JSON.parse(String(row.tags_json)),
+        state: String(row.state),
+        origin: String(row.origin),
+        sensitivity: String(row.sensitivity),
+        contentHash: String(row.content_hash),
+        ...(row.source_session_id === null || row.source_session_id === undefined ? {} : { sourceSessionId: String(row.source_session_id) }),
+        ...(row.source_event_seq === null || row.source_event_seq === undefined ? {} : { sourceEventSeq: Number(row.source_event_seq) }),
+        validFrom: Number(row.valid_from),
+        ...(row.valid_until === null || row.valid_until === undefined ? {} : { validUntil: Number(row.valid_until) }),
+        createdAt: Number(row.created_at),
+        updatedAt: Number(row.updated_at),
+    };
+}
+function rowToBelief(row) {
+    return {
+        claimId: String(row.claim_id ?? row.id),
+        alpha: Number(row.alpha),
+        beta: Number(row.beta),
+        harmfulCount: Number(row.harmful_count),
+        updatedAt: Number(row.belief_updated_at ?? row.updated_at),
+    };
+}
+function rowToEvidence(row) {
+    return {
+        id: String(row.id),
+        claimId: String(row.claim_id),
+        kind: String(row.kind),
+        weight: Number(row.weight),
+        ...(row.detail === null || row.detail === undefined ? {} : { detail: String(row.detail) }),
+        ...(row.session_id === null || row.session_id === undefined ? {} : { sessionId: String(row.session_id) }),
+        createdAt: Number(row.created_at),
+    };
+}
+//# sourceMappingURL=repository.js.map