@chude/memory 4.0.0 → 4.0.2

package/README.md

@@ -51,11 +51,19 @@ memory show <session-id>
 # Find related sessions
 memory related <session-id>
 
-# Browse sessions interactively
-memory browse
-```
-
-## How It Works
+# Browse sessions interactively
+memory browse
+
+# Audit durable memory surfaces for suspected secrets
+memory audit-secrets
+
+# Query durable friction signals for first-party tooling
+memory friction list --tool aidev --since 2026-06-01 --count --min 3
+```
+
+Machine consumers should use `memory friction list --json`; see [Friction Query Contract](docs/reference/friction-query-contract.md) for the versioned envelope, filter semantics, privacy behavior, and exit codes.
+
+## How It Works
 
 1. Claude Code stores sessions as JSONL files in `~/.claude/projects/`
 2. `memory sync` extracts messages, topics, and entities into a SQLite database with FTS5
@@ -114,6 +122,19 @@ Known secret patterns in newly synced transcript content, tool inputs/results, e
 memory export backup.json --include-sensitive
 ```
 
+Run a read-only scan of the database and event logs before publishing, syncing to a remote, or reviewing older data:
+
+```bash
+memory audit-secrets
+memory audit-secrets --json
+```
+
+Remediation is explicit. Database redaction rewrites mutable stored fields and rebuilds FTS indexes; event-log quarantine moves raw logs aside and writes sanitized active replacements:
+
+```bash
+memory audit-secrets --redact-db --quarantine-events --report audit-report.json
+```
+
 ## Provider Support
 
 Provider support is explicit and registry-backed. Built-in embedding providers are `local`, `openai`, `ollama`, and `openai-compatible`. Built-in extraction providers are `claude-cli`, `anthropic`, `openai`, `ollama`, and `openai-compatible`.
@@ -132,6 +153,20 @@ Use `openai-compatible` for gateways or providers that expose OpenAI-compatible
 
 `LLM_PROVIDER` selects the extraction provider. `LLM_MODEL` overrides the extraction model without changing embedding configuration.
 
+Remote provider egress is deny-by-default until the config grants consent and the target provider or host is allowlisted. Local providers do not require egress consent.
+
+```json
+{
+  "providerEgress": {
+    "consent": "granted",
+    "allowedHosts": ["api.openai.com", "api.anthropic.com"],
+    "allowedProviders": ["openai", "anthropic", "claude-cli"]
+  }
+}
+```
+
+`memory status` and `memory doctor` report provider egress readiness without printing secrets. The experimental Git remote-sync path also runs an event-log secret preflight before any push and blocks remote sync until active logs are clean or quarantined.
+
 ## AI-First Design
 
 This tool is designed for Claude to use via the Bash tool:
@@ -196,9 +231,10 @@ const contextResult = await executeContextCommand("my-project", {
 | `executeBrowseCommand` | `options: BrowseCommandOptions` | `Promise<CommandResult>` |
 | `executeInstallCommand` | `options: InstallOptions` | `Promise<CommandResult>` |
 | `executeUninstallCommand` | `options: UninstallOptions` | `Promise<CommandResult>` |
-| `executeStatusCommand` | `options: StatusOptions` | `Promise<CommandResult>` |
-| `executeDoctorCommand` | `options: DoctorOptions` | `Promise<CommandResult>` |
-| `executePurgeCommand` | `options: PurgeCommandOptions` | `Promise<CommandResult>` |
+| `executeStatusCommand` | `options: StatusOptions` | `Promise<CommandResult>` |
+| `executeDoctorCommand` | `options: DoctorOptions` | `Promise<CommandResult>` |
+| `executeAuditSecretsCommand` | `options: AuditSecretsOptions` | `Promise<CommandResult>` |
+| `executePurgeCommand` | `options: PurgeCommandOptions` | `Promise<CommandResult>` |
 | `executeExportCommand` | `outputPath: string, options: ExportOptions` | `Promise<CommandResult>` |
 | `executeImportCommand` | `inputPath: string, options: ImportOptions` | `Promise<CommandResult>` |
 | `executeCompletionCommand` | `shell: string` | `CommandResult` |
@@ -206,9 +242,9 @@ const contextResult = await executeContextCommand("my-project", {
 ### CommandResult
 
 ```typescript
-interface CommandResult {
-  exitCode: number; // 0 = success, 1 = error/not found
-}
+interface CommandResult {
+  exitCode: number; // 0 = success, 1 = error/not found/findings, 2 = operational/remediation failure where used
+}
 ```
 
 All functions handle their own database initialization and teardown. They never call `process.exit()`.
@@ -264,10 +300,21 @@ bun test --timeout 15000
 bun run test:isolation
 bun run test:coverage
 bun audit
+gitleaks detect --no-banner --redact --source .
 ```
 
 `bun run quality` runs the release gate sequence. `bun run test:coverage` uses an Istanbul-backed Bun harness and is intentionally strict: statements, branches, functions, and lines must each be available and at least 95%. Missing metrics fail the gate.
 
+### Published package smoke
+
+After publishing, verify registry metadata plus npm and Bun global installs:
+
+```bash
+bun run verify:published @chude/memory@4.0.2
+```
+
+On Windows, Bun global install creates `memory.exe` in `bun pm bin -g`. Do not assume an npm-style `memory.cmd` shim exists.
+
 ### Running tests on Windows
 
 Current 2026-05-28 verification has `bun test --timeout 15000` passing on Windows 11 with Bun 1.3.5. A previous full-suite run crashed with Bun's `panic(main thread): integer overflow` signature at ~6.8GB peak memory pressure; keep the subdirectory workaround available if that upstream runtime crash returns.

package/dist/application/services/embedding-service.d.ts

@@ -10,7 +10,7 @@
  * Sits between the presentation layer (sync command) and infrastructure
  * (repository + provider). Respects hexagonal architecture boundaries.
  */
-import type { IEmbeddingProvider } from "../../domain/ports/embedding.js";
+import { type IEmbeddingProvider } from "../../domain/ports/embedding.js";
 import type { IRedactor } from "../../domain/ports/redactor.js";
 import type { IEmbeddingRepository, EmbeddingServiceConfig } from "../../domain/ports/repositories.js";
 /**
@@ -88,6 +88,7 @@ export declare class EmbeddingService {
     private readonly repository;
     private readonly provider;
     private readonly batchSize;
+    private readonly maxBatchBytes;
     private readonly modelHash;
     private readonly modelName;
     private readonly redactor;
@@ -128,4 +129,10 @@ export declare class EmbeddingService {
      * @returns Summary of the re-embedding operation
      */
     clearAndReembed(options?: EmbedOptions): Promise<EmbedResult>;
+    private prepareBatch;
+    private chunkByPayloadBytes;
+    private estimatePayloadBytes;
+    private embedChunk;
+    private markPayloadTooLargeSkip;
+    private getSkippedCountForCurrentModel;
 }

package/dist/application/services/friction-service.d.ts

@@ -12,8 +12,9 @@
  * - wontFix flow: resolve() then updateStatus() for correct final state
  * - Auto-ingest: reads friction.jsonl fallback file, saves entries, deletes file
  */
-import type { IFrictionRepository, FrictionStats, FrictionPattern } from "../../domain/ports/repositories.js";
+import type { IFrictionRepository, FrictionStats, FrictionPattern, FrictionQueryResult } from "../../domain/ports/repositories.js";
 import { FrictionEntry, type FrictionSeverity, type FrictionCategory } from "../../domain/entities/friction-entry.js";
+import type { IRedactor } from "../../domain/ports/redactor.js";
 /**
  * Parameters for logging a new friction entry.
  */
@@ -32,9 +33,13 @@ export interface LogFrictionParams {
 export interface ListFrictionOptions {
     all?: boolean | undefined;
     status?: string | undefined;
+    severity?: string | undefined;
     category?: string | undefined;
     tool?: string | undefined;
     sourceProject?: string | undefined;
+    since?: Date | undefined;
+    descriptionContains?: string | undefined;
+    contextContains?: string | undefined;
     limit?: number | undefined;
 }
 /**
@@ -45,7 +50,8 @@ export interface ListFrictionOptions {
  */
 export declare class FrictionService {
     private readonly repository;
-    constructor(repository: IFrictionRepository);
+    private readonly redactor;
+    constructor(repository: IFrictionRepository, redactor?: IRedactor);
     /**
      * Log a new friction entry.
      *
@@ -66,6 +72,16 @@ export declare class FrictionService {
      * @returns Array of matching friction entries
      */
     list(options?: ListFrictionOptions): Promise<FrictionEntry[]>;
+    /**
+     * Query friction entries using the durable friction contract.
+     *
+     * Default behavior remains open-only. Explicit status wins; `all: true`
+     * removes the default status filter when no status is provided.
+     *
+     * @param options Query options
+     * @returns Matching entries and total count before limit is applied
+     */
+    query(options?: ListFrictionOptions): Promise<FrictionQueryResult>;
     /**
      * Resolve a friction entry.
      *

package/dist/application/services/index.d.ts

@@ -29,6 +29,16 @@ export type { BackfillResult, BackfillProgress, DryRunResult, BackfillOptions, I
 export { allocateBudget } from "./budget-allocator.js";
 export type { BudgetSection, AllocatedSection, BudgetAllocationResult, } from "./budget-allocator.js";
 export { SmartContextService } from "./smart-context-service.js";
-export type { SmartContextOptions, SmartContextResult, ContextSection, IProjectResolver, SmartContextDeps, } from "./smart-context-service.js";
+export type { SmartContextOptions, SmartContextResult, ContextSection, IProjectResolver, IContextGovernancePolicy, SmartContextDeps, } from "./smart-context-service.js";
 export { AmbientContextService } from "./ambient-context-service.js";
 export type { AmbientContextOptions, AmbientContextResult, } from "./ambient-context-service.js";
+export { ProjectionRegistry } from "./projection-registry.js";
+export { PersonaProfileService, personaEntryFromFactEvent } from "./persona-profile-service.js";
+export { TemporalGraphService, graphEdgesFromFact, governanceEntryForGraphEdge, } from "./temporal-graph-service.js";
+export { MemoryRankingService, candidateFromFact, candidateFromGraphEdge, candidateFromPersonaEntry, } from "./memory-ranking-service.js";
+export type { MemoryRankCandidate, MemoryRankKind, MemoryRankingPolicy, MemoryRankingServiceDeps, RankedMemory, RankedMemoryComponents, } from "./memory-ranking-service.js";
+export type { EventProjection, ProjectionReplayResult, } from "./projection-registry.js";
+export { MemoryGovernanceService } from "./memory-governance-service.js";
+export type { GovernanceControlCommand, MemoryEventWriter, MemoryGovernanceServiceDeps, RegisterDerivedMemoryParams, } from "./memory-governance-service.js";
+export { RemoteEventSyncService, validateMachineIdentity, validateRemoteRef, validateRemoteRepositoryUrl, } from "./remote-event-sync-service.js";
+export type { RemoteEventSyncRequest, RemoteEventSyncResult, RemoteEventSyncServiceDeps, RemoteEventTransport, RemoteGitIdentity, RemotePrivacyPreflightPort, RemoteProjectionRebuilderPort, RemoteTransportCommandResult, } from "./remote-event-sync-service.js";

package/dist/application/services/memory-governance-service.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Memory governance service.
+ *
+ * Application-layer orchestration for durable consent/provenance controls.
+ * It emits canonical memory events and updates the governance projection.
+ */
+import { MemoryEventEnvelope, type ConsentStatus, type RedactionState } from "../../domain/entities/memory-event.js";
+import { MemoryGovernanceEntry, type MemoryGovernanceSurface } from "../../domain/entities/memory-governance.js";
+import type { IMemoryGovernanceRepository, MemoryGovernanceListOptions } from "../../domain/ports/repositories.js";
+export interface MemoryEventWriter {
+    (event: MemoryEventEnvelope): Promise<void>;
+}
+export interface RegisterDerivedMemoryParams {
+    surface: MemoryGovernanceSurface;
+    targetId: string;
+    project?: string | undefined;
+    sourceEventIds: string[];
+    transformationMethod: string;
+    actor?: string | undefined;
+    confidence?: number | undefined;
+    redactionState?: RedactionState | undefined;
+    consentStatus?: ConsentStatus | undefined;
+    consentScopes?: string[] | undefined;
+    visibility?: "project" | "workspace" | "global" | undefined;
+    expiresAt?: Date | null | undefined;
+}
+export interface GovernanceControlCommand {
+    surface: MemoryGovernanceSurface;
+    targetId: string;
+    actor?: string | undefined;
+    reason?: string | undefined;
+    expiresAt?: Date | null | undefined;
+    consentStatus?: ConsentStatus | undefined;
+    consentScopes?: string[] | undefined;
+}
+export interface MemoryGovernanceServiceDeps {
+    repository: IMemoryGovernanceRepository;
+    writeEvent?: MemoryEventWriter | undefined;
+    machineId?: string | undefined;
+    now?: (() => Date) | undefined;
+    nextSequence?: (() => number) | undefined;
+}
+export declare class MemoryGovernanceService {
+    private readonly repository;
+    private readonly writeEvent?;
+    private readonly machineId;
+    private readonly now;
+    private readonly nextSequence;
+    constructor(deps: MemoryGovernanceServiceDeps);
+    registerDerivedMemory(params: RegisterDerivedMemoryParams): Promise<MemoryGovernanceEntry>;
+    suppress(params: GovernanceControlCommand): Promise<MemoryGovernanceEntry>;
+    unsuppress(params: GovernanceControlCommand): Promise<MemoryGovernanceEntry>;
+    invalidate(params: GovernanceControlCommand): Promise<MemoryGovernanceEntry>;
+    expire(params: GovernanceControlCommand): Promise<MemoryGovernanceEntry>;
+    review(params: GovernanceControlCommand): Promise<MemoryGovernanceEntry>;
+    grantConsent(params: GovernanceControlCommand): Promise<MemoryGovernanceEntry>;
+    revokeConsent(params: GovernanceControlCommand): Promise<MemoryGovernanceEntry>;
+    list(options?: MemoryGovernanceListOptions): Promise<MemoryGovernanceEntry[]>;
+    show(surface: MemoryGovernanceSurface, targetId: string): Promise<MemoryGovernanceEntry | null>;
+    isAllowed(surface: MemoryGovernanceSurface, targetId: string): Promise<boolean>;
+    filterAllowed<T>(surface: MemoryGovernanceSurface, items: T[], getTargetId: (item: T) => string): Promise<T[]>;
+    private applyControl;
+    private createEvent;
+    private persistEvent;
+}

package/dist/application/services/memory-ranking-service.d.ts

@@ -0,0 +1,65 @@
+import type { Fact, FactType } from "../../domain/entities/fact.js";
+import type { GraphEdge } from "../../domain/entities/graph-edge.js";
+import type { MemoryGovernanceStatus } from "../../domain/entities/memory-governance.js";
+import type { MemoryUtilityMetric, MemoryUtilitySurface } from "../../domain/entities/memory-utility-metric.js";
+import type { PersonaEntry, PersonaEntryKind } from "../../domain/entities/persona-entry.js";
+export type MemoryRankKind = MemoryUtilitySurface;
+export interface MemoryRankCandidate {
+    id: string;
+    kind: MemoryRankKind;
+    memoryType?: string | undefined;
+    content: string;
+    project?: string | undefined;
+    observedAt?: Date | undefined;
+    validFrom?: Date | undefined;
+    validTo?: Date | null | undefined;
+    supersededAt?: Date | null | undefined;
+    confidence?: number | undefined;
+    importance?: number | undefined;
+    utility?: number | undefined;
+    evergreen?: boolean | undefined;
+    pinned?: boolean | undefined;
+    recencyNoisePenalty?: number | undefined;
+    governanceStatus?: MemoryGovernanceStatus | "reviewed" | undefined;
+    metric?: MemoryUtilityMetric | undefined;
+}
+export interface RankedMemoryComponents {
+    importance: number;
+    utility: number;
+    confidence: number;
+    accessBoost: number;
+    accessCount: number;
+    halfLifeDays: number;
+    ageDays: number;
+    decayMultiplier: number;
+    recencyNoisePenalty: number;
+    baseScore: number;
+    finalScore: number;
+}
+export interface RankedMemory extends MemoryRankCandidate {
+    score: number;
+    whyIncluded: string;
+    components: RankedMemoryComponents;
+}
+export interface MemoryRankingPolicy {
+    defaultHalfLifeDays?: number | undefined;
+    halfLifeByKind?: Partial<Record<MemoryRankKind, number>> | undefined;
+    halfLifeByFactType?: Partial<Record<FactType, number>> | undefined;
+    halfLifeByPersonaKind?: Partial<Record<PersonaEntryKind, number>> | undefined;
+}
+export interface MemoryRankingServiceDeps {
+    now?: (() => Date) | undefined;
+    policy?: MemoryRankingPolicy | undefined;
+}
+export declare class MemoryRankingService {
+    private readonly now;
+    private readonly policy;
+    constructor(deps?: MemoryRankingServiceDeps);
+    rank(candidates: MemoryRankCandidate[]): RankedMemory[];
+    private isEligible;
+    private scoreCandidate;
+    private resolveHalfLifeDays;
+}
+export declare function candidateFromFact(fact: Fact, metric?: MemoryUtilityMetric | undefined): MemoryRankCandidate;
+export declare function candidateFromPersonaEntry(entry: PersonaEntry, metric?: MemoryUtilityMetric | undefined): MemoryRankCandidate;
+export declare function candidateFromGraphEdge(edge: GraphEdge, metric?: MemoryUtilityMetric | undefined): MemoryRankCandidate;

package/dist/application/services/persona-profile-service.d.ts

@@ -0,0 +1,29 @@
+import { Fact } from "../../domain/entities/fact.js";
+import { PersonaEntry } from "../../domain/entities/persona-entry.js";
+import type { IFactRepository, IFrictionRepository, IMemoryGovernanceRepository, IPersonaRepository } from "../../domain/ports/repositories.js";
+export interface PersonaProfileServiceDeps {
+    factRepo: IFactRepository;
+    frictionRepo: IFrictionRepository;
+    personaRepo: IPersonaRepository;
+    governanceRepo: IMemoryGovernanceRepository;
+    now?: () => Date;
+}
+export interface PersonaRebuildOptions {
+    project?: string | undefined;
+}
+export interface PersonaRebuildResult {
+    entries: PersonaEntry[];
+    factCount: number;
+    frictionPatternCount: number;
+}
+export declare class PersonaProfileService {
+    private readonly deps;
+    private readonly now;
+    constructor(deps: PersonaProfileServiceDeps);
+    rebuildProfile(options?: PersonaRebuildOptions): Promise<PersonaRebuildResult>;
+    private entryFromFact;
+    private entryFromFrictionPattern;
+    private governanceEntryFor;
+}
+export declare function personaEntriesFromFact(fact: Fact, now?: Date): PersonaEntry[];
+export declare function personaEntryFromFactEvent(fact: Fact, now?: Date): PersonaEntry | null;

package/dist/application/services/projection-registry.d.ts

@@ -0,0 +1,18 @@
+import type { MemoryEventEnvelope, MemoryEventKind } from "../../domain/entities/memory-event.js";
+export interface EventProjection<TContext> {
+    name: string;
+    consumedKinds: readonly MemoryEventKind[];
+    reset?: (context: TContext) => void | Promise<void>;
+    apply: (event: MemoryEventEnvelope, context: TContext) => void | boolean | Promise<void | boolean>;
+}
+export interface ProjectionReplayResult {
+    processedEvents: number;
+    skippedDuplicateEvents: number;
+    appliedProjections: string[];
+}
+export declare class ProjectionRegistry<TContext> {
+    private readonly projections;
+    constructor(projections: EventProjection<TContext>[]);
+    getConsumedKinds(projectionName: string): MemoryEventKind[];
+    replay(events: Iterable<MemoryEventEnvelope>, context: TContext): Promise<ProjectionReplayResult>;
+}

package/dist/application/services/remote-event-sync-service.d.ts

@@ -0,0 +1,76 @@
+export interface RemoteValidationResult {
+    valid: boolean;
+    error?: string;
+}
+export interface RemoteTransportCommandResult {
+    success: boolean;
+    error?: string;
+    skipped?: boolean;
+}
+export interface RemoteGitIdentity {
+    machineId: string;
+    userName: string;
+    userEmail: string;
+}
+export interface RemoteEventTransport {
+    isRepository(): Promise<boolean>;
+    initRepository(identity: RemoteGitIdentity): Promise<RemoteTransportCommandResult>;
+    getRemoteUrl(): Promise<string | null>;
+    setRemoteUrl(remoteUrl: string): Promise<RemoteTransportCommandResult>;
+    listEventLogFingerprints(): Promise<Record<string, string>>;
+    hasEventLog(machineId: string): Promise<boolean>;
+    commitEventLog(machineId: string, message: string): Promise<RemoteTransportCommandResult>;
+    fetch(remoteName: string): Promise<RemoteTransportCommandResult>;
+    hasRemoteRef(remoteName: string, ref: string): Promise<boolean>;
+    pullRebase(remoteName: string, ref: string): Promise<RemoteTransportCommandResult>;
+    abortRebase(): Promise<RemoteTransportCommandResult>;
+    push(remoteName: string, ref: string): Promise<RemoteTransportCommandResult>;
+}
+export interface RemotePrivacyPreflightPort {
+    audit(): Promise<{
+        eventLogFindings: number;
+    }>;
+}
+export interface RemoteProjectionRebuilderPort {
+    rebuild(): Promise<void>;
+}
+export interface RemoteEventSyncServiceDeps {
+    transport: RemoteEventTransport;
+    privacyPreflight?: RemotePrivacyPreflightPort;
+    projectionRebuilder?: RemoteProjectionRebuilderPort;
+    now?: () => Date;
+}
+export interface RemoteEventSyncRequest {
+    machineId: string;
+    repositoryUrl: string;
+    branch?: string;
+    remoteName?: string;
+    autoPull?: boolean;
+    autoPush?: boolean;
+    allowLocalPathRemote?: boolean;
+}
+export interface RemoteEventSyncResult {
+    success: boolean;
+    status: "synced" | "blocked" | "failed";
+    rebuildNeeded: boolean;
+    projectionRebuilt: boolean;
+    pulled: boolean;
+    pushed: boolean;
+    configuredRemote: boolean;
+    initializedRepository: boolean;
+    error: string | undefined;
+}
+export declare function validateRemoteRepositoryUrl(value: string, options?: {
+    allowLocalPathRemote?: boolean;
+}): RemoteValidationResult;
+export declare function validateRemoteRef(ref: string): RemoteValidationResult;
+export declare function validateMachineIdentity(machineId: string): RemoteValidationResult;
+export declare class RemoteEventSyncService {
+    private readonly transport;
+    private readonly privacyPreflight;
+    private readonly projectionRebuilder;
+    private readonly now;
+    constructor(deps: RemoteEventSyncServiceDeps);
+    sync(request: RemoteEventSyncRequest): Promise<RemoteEventSyncResult>;
+    private rebuildIfNeeded;
+}

package/dist/application/services/smart-context-service.d.ts

@@ -17,7 +17,9 @@
  * Dependencies injected via constructor for hexagonal architecture.
  * Zero imports from infrastructure layer.
  */
-import type { IFactRepository, IFrictionRepository } from "../../domain/ports/repositories.js";
+import type { IFactRepository, IFrictionRepository, IPersonaRepository, IGraphRepository, IMemoryUtilityRepository } from "../../domain/ports/repositories.js";
+import type { MemoryGovernanceSurface } from "../../domain/entities/memory-governance.js";
+import { type MemoryRankingService } from "./memory-ranking-service.js";
 /**
  * Options for smart context retrieval.
  */
@@ -77,6 +79,13 @@ export interface IProjectResolver {
      */
     resolveProjectName(projectFilter: string): string | null;
 }
+/**
+ * Optional governance policy used to suppress/expire/invalidate derived memory
+ * before it reaches context assembly or AI-facing output.
+ */
+export interface IContextGovernancePolicy {
+    filterAllowed<T>(surface: MemoryGovernanceSurface, items: T[], getTargetId: (item: T) => string): Promise<T[]>;
+}
 /**
  * Dependencies for SmartContextService (constructor injection).
  */
@@ -84,6 +93,11 @@ export interface SmartContextDeps {
     projectResolver: IProjectResolver;
     factRepo: IFactRepository;
     frictionRepo: IFrictionRepository;
+    personaRepo?: IPersonaRepository | undefined;
+    graphRepo?: IGraphRepository | undefined;
+    governancePolicy?: IContextGovernancePolicy | undefined;
+    rankingService?: MemoryRankingService | undefined;
+    utilityRepo?: IMemoryUtilityRepository | undefined;
     /** Optional legacy session summary provider */
     getSessionSummary?: (projectFilter: string, days?: number) => Promise<string | null>;
     now?: () => Date;
@@ -98,7 +112,13 @@ export declare class SmartContextService {
     private readonly projectResolver;
     private readonly factRepo;
     private readonly frictionRepo;
+    private readonly personaRepo?;
+    private readonly graphRepo?;
+    private readonly governancePolicy?;
+    private readonly rankingService?;
+    private readonly utilityRepo?;
     private readonly getSessionSummary?;
+    private readonly now;
     constructor(deps: SmartContextDeps);
     /**
      * Get structured context for a project.
@@ -119,6 +139,19 @@ export declare class SmartContextService {
      * Returns null if no friction entries exist.
      */
     private buildFrictionContent;
+    private buildPersonaContent;
+    private buildGraphContent;
+    private rankFacts;
+    private rankPersona;
+    private rankGraph;
+    private lookupMetrics;
+    /**
+     * Remove derived facts blocked by governance controls. Ungoverned facts are
+     * allowed for backward compatibility with pre-governance databases.
+     */
+    private filterAllowedFacts;
+    private filterAllowedPersona;
+    private filterAllowedGraph;
     /**
      * Apply budget allocation and return result with truncation info.
      */

package/dist/application/services/temporal-graph-service.d.ts

@@ -0,0 +1,30 @@
+import { Fact } from "../../domain/entities/fact.js";
+import { GraphEdge } from "../../domain/entities/graph-edge.js";
+import { MemoryGovernanceEntry } from "../../domain/entities/memory-governance.js";
+import type { GraphEdgeQueryOptions, IFactRepository, IGraphRepository, IMemoryGovernanceRepository } from "../../domain/ports/repositories.js";
+import type { IContextGovernancePolicy } from "./smart-context-service.js";
+export interface TemporalGraphServiceDeps {
+    graphRepo: IGraphRepository;
+    factRepo?: IFactRepository | undefined;
+    governanceRepo?: IMemoryGovernanceRepository | undefined;
+    governancePolicy?: IContextGovernancePolicy | undefined;
+    now?: (() => Date) | undefined;
+}
+export interface GraphRebuildOptions {
+    project?: string | undefined;
+}
+export interface GraphRebuildResult {
+    edges: GraphEdge[];
+    edgeCount: number;
+    factCount: number;
+}
+export declare class TemporalGraphService {
+    private readonly deps;
+    private readonly now;
+    constructor(deps: TemporalGraphServiceDeps);
+    rebuildGraph(options?: GraphRebuildOptions): Promise<GraphRebuildResult>;
+    findContextEdges(options: GraphEdgeQueryOptions): Promise<GraphEdge[]>;
+    formatContextLines(edges: GraphEdge[]): string[];
+}
+export declare function graphEdgesFromFact(fact: Fact, now?: Date): GraphEdge[];
+export declare function governanceEntryForGraphEdge(edge: GraphEdge, transformationMethod: string): MemoryGovernanceEntry;

package/dist/domain/entities/graph-edge.d.ts

@@ -0,0 +1,87 @@
+import type { MemoryEventScope, MemoryEventVisibility } from "./memory-event.js";
+export declare const GRAPH_NODE_TYPES: readonly ["project", "tool", "person", "decision", "error", "plan", "file", "command", "capability"];
+export type GraphNodeType = (typeof GRAPH_NODE_TYPES)[number];
+export interface GraphNodeRef {
+    type: GraphNodeType;
+    id: string;
+    label: string;
+}
+export interface GraphEdgeParams {
+    id?: number | undefined;
+    edgeId?: string | undefined;
+    source: GraphNodeRef;
+    target: GraphNodeRef;
+    relationship: string;
+    project?: string | undefined;
+    visibility: MemoryEventVisibility;
+    sourceEventIds: string[];
+    sourceKinds: string[];
+    confidence: number;
+    validFrom: Date;
+    validTo?: Date | null | undefined;
+    why: string;
+    metadata?: Record<string, unknown> | undefined;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface GraphEdgeJson {
+    id?: number | undefined;
+    edge_id: string;
+    source: GraphNodeRef;
+    target: GraphNodeRef;
+    relationship: string;
+    project?: string | undefined;
+    visibility: MemoryEventVisibility;
+    source_event_ids: string[];
+    source_kinds: string[];
+    confidence: number;
+    valid_from: string;
+    valid_to: string | null;
+    why: string;
+    scope: MemoryEventScope;
+    metadata?: Record<string, unknown> | undefined;
+    controls: string[];
+    created_at: string;
+    updated_at: string;
+}
+export declare class GraphEdge {
+    private readonly _id?;
+    private readonly _edgeId;
+    private readonly _source;
+    private readonly _target;
+    private readonly _relationship;
+    private readonly _project?;
+    private readonly _visibility;
+    private readonly _sourceEventIds;
+    private readonly _sourceKinds;
+    private readonly _confidence;
+    private readonly _validFrom;
+    private readonly _validTo;
+    private readonly _why;
+    private readonly _metadata?;
+    private readonly _createdAt;
+    private readonly _updatedAt;
+    private constructor();
+    static create(params: GraphEdgeParams): GraphEdge;
+    get id(): number | undefined;
+    get edgeId(): string;
+    get source(): GraphNodeRef;
+    get target(): GraphNodeRef;
+    get relationship(): string;
+    get project(): string | undefined;
+    get visibility(): MemoryEventVisibility;
+    get sourceEventIds(): string[];
+    get sourceKinds(): string[];
+    get confidence(): number;
+    get validFrom(): Date;
+    get validTo(): Date | null;
+    get why(): string;
+    get metadata(): Record<string, unknown> | undefined;
+    get createdAt(): Date;
+    get updatedAt(): Date;
+    get scope(): MemoryEventScope;
+    get controls(): string[];
+    isCurrent(asOf: Date, minConfidence?: number): boolean;
+    withId(id: number): GraphEdge;
+    toJSON(): GraphEdgeJson;
+}

package/dist/domain/entities/index.d.ts

@@ -13,3 +13,8 @@ export { MemoryFile, type MemoryFileType } from "./memory-file.js";
 export { FrictionEntry, type FrictionSeverity, type FrictionCategory, type FrictionStatus, } from "./friction-entry.js";
 export { BackfillState } from "./backfill-state.js";
 export { Fact, type FactType, type FactParams, type CandidateFact } from "./fact.js";
+export { MemoryEventEnvelope, MEMORY_EVENT_SCHEMA_VERSION, type ConsentStatus, type MemoryEventCausality, type MemoryEventConsent, type MemoryEventCreateParams, type MemoryEventEnvelopeJson, type MemoryEventIntegrity, type MemoryEventKind, type MemoryEventOperation, type MemoryEventPrivacy, type MemoryEventProvenance, type MemoryEventScope, type MemoryEventVisibility, type RedactionState, } from "./memory-event.js";
+export { MemoryGovernanceEntry, MEMORY_GOVERNANCE_CONTROLS, MEMORY_GOVERNANCE_STATUSES, MEMORY_GOVERNANCE_SURFACES, assertMemoryGovernanceControl, assertMemoryGovernanceSurface, type GovernanceControlParams, type MemoryGovernanceControl, type MemoryGovernanceEntryJson, type MemoryGovernanceEntryParams, type MemoryGovernanceStatus, type MemoryGovernanceSurface, } from "./memory-governance.js";
+export { PersonaEntry, PERSONA_ENTRY_CONTROLS, PERSONA_ENTRY_KINDS, type PersonaEntryJson, type PersonaEntryKind, type PersonaEntryParams, type PersonaReviewStatus, } from "./persona-entry.js";
+export { GraphEdge, GRAPH_NODE_TYPES, type GraphEdgeJson, type GraphEdgeParams, type GraphNodeRef, type GraphNodeType, } from "./graph-edge.js";
+export { MemoryUtilityMetric, MEMORY_UTILITY_CONTROLS, MEMORY_UTILITY_SURFACES, type MemoryUtilityControl, type MemoryUtilityMetricJson, type MemoryUtilityMetricParams, type MemoryUtilitySurface, } from "./memory-utility-metric.js";