qlogicagent 2.6.0 → 2.7.0

package/dist/types/skills/memory/local-memory-provider.d.ts

@@ -0,0 +1,197 @@
+/**
+ * Local Memory Provider — implements MemoryProvider using local SQLite store.
+ *
+ * This is the default provider for desktop use. Requires no external service.
+ * Uses FTS5 for keyword search and optionally embedding API for vector search.
+ *
+ * Falls back gracefully:
+ *   - With embedding API configured: hybrid search (FTS + vector)
+ *   - Without embedding: FTS-only search (still useful for exact/keyword matches)
+ */
+import type { MemoryProvider, MemorySearchResult, MemorySearchOptions, MemoryIngestMessage, MemoryIngestOptions } from "../../protocol/wire/index.js";
+import type { SqliteDatabase } from "./local-store.js";
+import { type LocalEmbeddingConfig } from "./local-embedding.js";
+/** A pre-extracted memory item ready to be stored (no LLM needed). */
+export interface ExtractedMemoryItem {
+    text: string;
+    category?: string;
+    importance?: number;
+    speaker?: string;
+    event_date?: string;
+    tags?: string[];
+}
+export interface LocalMemoryProviderConfig {
+    /** Project root for project-level storage (falls back to user-level). */
+    projectRoot?: string;
+    /** Embedding configuration. If omitted, uses FTS-only search. */
+    embedding?: LocalEmbeddingConfig;
+    /** User ID prefix for multi-tenant isolation. */
+    userIdPrefix?: string;
+    /** Factory function to create the SQLite database instance. */
+    createDatabase?: (dbPath: string) => SqliteDatabase;
+}
+export declare class LocalMemoryProvider implements MemoryProvider {
+    readonly providerId = "qmemory-local";
+    private store;
+    private embedding;
+    private userIdPrefix;
+    private dbPath;
+    constructor(config: LocalMemoryProviderConfig);
+    private resolveUserId;
+    search(query: string, userId: string, options?: MemorySearchOptions): Promise<MemorySearchResult[]>;
+    ingest(messages: MemoryIngestMessage[], userId: string, options?: MemoryIngestOptions): Promise<void>;
+    addText(text: string, userId: string, options?: MemoryIngestOptions & {
+        category?: string;
+        importance?: number;
+    }): Promise<{
+        memoriesAdded: number;
+    }>;
+    remove(memoryId: string): Promise<boolean>;
+    /**
+     * Ingest pre-extracted memory items (no LLM needed).
+     * Compatible with qmemory-adapter's ingestExtracted interface.
+     */
+    ingestExtracted(items: ExtractedMemoryItem[], userId: string, options?: MemoryIngestOptions): Promise<{
+        memoriesAdded: number;
+    }>;
+    /**
+     * Trigger memory decay — multi-strategy (temporal + staleness + noise).
+     * Also enforces capacity limit and runs vacuum for space reclamation.
+     */
+    triggerDecay(userId: string, _maxAgeDays?: number): Promise<{
+        decayed: number;
+    }>;
+    /**
+     * Apply feedback to a memory (useful/irrelevant/outdated/wrong).
+     * Adjusts importance or archives/deletes based on signal.
+     */
+    feedback(memoryIds: string[], signal: "useful" | "irrelevant" | "outdated" | "wrong"): Promise<{
+        affected: number;
+    }>;
+    /**
+     * Get a user profile value.
+     */
+    getProfile(userId: string, key: string): string | null;
+    /**
+     * Set a user profile value (upsert).
+     */
+    setProfile(userId: string, key: string, value: string): void;
+    /**
+     * Get all profile entries for a user.
+     */
+    getAllProfiles(userId: string): Record<string, string>;
+    /**
+     * Delete a profile entry.
+     */
+    deleteProfile(userId: string, key: string): boolean;
+    /**
+     * Get memories within a time range, grouped by day.
+     * Powers "what happened last week" type queries.
+     */
+    getTemporalSlice(userId: string, startMs: number, endMs: number, options?: {
+        category?: string;
+        limit?: number;
+    }): {
+        date: string;
+        memories: Array<{
+            id: string;
+            text: string;
+            category: string;
+            importance: number;
+        }>;
+    }[];
+    /**
+     * Get activity summary over recent N days (daily counts + highlights).
+     */
+    getActivitySummary(userId: string, days?: number): {
+        dailyCounts: Array<{
+            date: string;
+            count: number;
+        }>;
+        highlights: Array<{
+            id: string;
+            text: string;
+            category: string;
+            importance: number;
+            date: string;
+        }>;
+    };
+    /**
+     * Find memories by event date (±tolerance). For temporal context retrieval.
+     */
+    findByEventDate(userId: string, targetDate: string, toleranceDays?: number): import("./local-store.js").MemorySearchHit[];
+    /**
+     * Find related memories (event continuity detection).
+     * Given a new memory, finds existing memories that are semantically related
+     * (cosine 0.6-0.82) and from the past 14 days. These represent continuations
+     * of an ongoing event/thread.
+     *
+     * Example: "周一面试了字节" → finds "上周投了字节的简历" → linked event chain.
+     */
+    findRelatedEvents(text: string, userId: string, options?: {
+        maxDaysBack?: number;
+        minSimilarity?: number;
+        maxSimilarity?: number;
+        limit?: number;
+    }): Promise<Array<{
+        id: string;
+        text: string;
+        score: number;
+        date: string;
+    }>>;
+    /**
+     * Synthesize a temporal narrative from memories in a time range.
+     * Returns a structured timeline suitable for prompt injection.
+     */
+    synthesizeTimeline(userId: string, startMs: number, endMs: number): string;
+    /**
+     * Rerank search results by applying recency boost, access frequency,
+     * and importance weighting. No LLM needed — pure scoring heuristics.
+     *
+     * This goes beyond basic search scoring by considering:
+     *   - Temporal proximity (recent memories get boosted)
+     *   - Access frequency (frequently recalled = more relevant)
+     *   - Category alignment (if preferredCategories specified)
+     */
+    rerank(results: Array<{
+        id: string;
+        text: string;
+        score: number;
+        category?: string;
+        metadata?: Record<string, unknown>;
+    }>, options?: {
+        preferredCategories?: string[];
+        recencyBoostDays?: number;
+    }): Array<{
+        id: string;
+        text: string;
+        score: number;
+        category?: string;
+        metadata?: Record<string, unknown>;
+    }>;
+    /**
+     * Health check — always healthy for local store.
+     */
+    health(): Promise<{
+        status: string;
+        memoryCount: number;
+        dbPath: string;
+    }>;
+    /**
+     * Get memory count for a user.
+     */
+    count(userId: string): number;
+    /**
+     * Reset all memories for a user.
+     */
+    resetUser(userId: string): Promise<number>;
+    /**
+     * Close the database connection.
+     */
+    close(): void;
+}
+/**
+ * Create a local memory provider (convenience factory).
+ * Caller must provide the createDatabase factory to avoid hard dependency on better-sqlite3.
+ */
+export declare function createLocalMemoryProvider(config: LocalMemoryProviderConfig): LocalMemoryProvider;

package/dist/types/skills/memory/local-store.d.ts

@@ -0,0 +1,254 @@
+/**
+ * Local Memory Store — SQLite-backed persistence for qmemory.
+ *
+ * Ported from Python qmemory's memory_store.py + db.py.
+ * Uses better-sqlite3 for synchronous, fast, single-file persistence.
+ *
+ * Storage location:
+ *   <project>/.qlogicagent/memory/memories.db    (project-level)
+ *   ~/.qlogicagent/memory/memories.db             (user-level fallback)
+ *
+ * Schema:
+ *   - memories: core fact storage with optional embedding blob
+ *   - memories_fts: FTS5 full-text index for keyword search
+ *   - profiles: user profile KV (future)
+ */
+export interface MemoryRecord {
+    id: string;
+    text: string;
+    userId: string;
+    category: string;
+    importance: number;
+    confidence: number;
+    source: string;
+    sessionId: string;
+    eventDate: string;
+    tags: string[];
+    embedding: Float32Array | null;
+    createdAt: number;
+    updatedAt: number;
+    accessCount: number;
+    lastAccessedAt: number;
+    isArchived: boolean;
+}
+export interface MemoryInsertInput {
+    text: string;
+    userId: string;
+    category?: string;
+    importance?: number;
+    source?: string;
+    sessionId?: string;
+    eventDate?: string;
+    tags?: string[];
+    embedding?: Float32Array;
+}
+export interface MemorySearchHit {
+    id: string;
+    text: string;
+    score: number;
+    category: string;
+    importance: number;
+    metadata: Record<string, unknown>;
+}
+export interface SqliteDatabase {
+    exec(sql: string): void;
+    prepare(sql: string): SqliteStatement;
+    pragma(pragma: string): unknown;
+    close(): void;
+}
+export interface SqliteStatement {
+    run(...params: unknown[]): {
+        changes: number;
+        lastInsertRowid: number | bigint;
+    };
+    get(...params: unknown[]): unknown;
+    all(...params: unknown[]): unknown[];
+}
+export declare class LocalMemoryStore {
+    private db;
+    constructor(db: SqliteDatabase);
+    private initSchema;
+    /**
+     * Insert a new memory record. Returns the generated ID.
+     */
+    insert(input: MemoryInsertInput): string;
+    /**
+     * Full-text search using FTS5. Returns ranked results.
+     */
+    searchFts(query: string, userId: string, limit?: number): MemorySearchHit[];
+    /**
+     * Vector similarity search using pre-computed embeddings.
+     * Performs brute-force cosine similarity (efficient for <100k records per user).
+     */
+    searchVector(queryEmbedding: Float32Array, userId: string, limit?: number, minScore?: number): MemorySearchHit[];
+    /**
+     * Hybrid search: FTS5 + vector similarity, de-duplicated and merged.
+     */
+    searchHybrid(query: string, queryEmbedding: Float32Array | null, userId: string, limit?: number): MemorySearchHit[];
+    /**
+     * Get all memories for a user (paginated).
+     */
+    listByUser(userId: string, page?: number, pageSize?: number, activeOnly?: boolean): MemoryRecord[];
+    /**
+     * Get a single memory by ID.
+     */
+    getById(id: string): MemoryRecord | null;
+    /**
+     * Update memory text and bump updatedAt.
+     */
+    updateText(id: string, text: string, embedding?: Float32Array): boolean;
+    /**
+     * Delete a memory by ID.
+     */
+    delete(id: string): boolean;
+    /**
+     * Archive a memory (soft-delete: set is_archived=1).
+     * Used by dedup gate when a similar but newer memory supersedes an older one.
+     */
+    archive(id: string): boolean;
+    /**
+     * Temporal expiry: archive event/plan memories whose event_date has passed
+     * beyond a grace period (e.g., "meeting tomorrow" 3 days after it happened).
+     */
+    decayTemporalExpiry(userId: string, graceDays?: number): number;
+    /**
+     * Staleness decay: reduce importance of memories not accessed in a long time.
+     * Memories accessed recently retain their importance; stale ones degrade.
+     */
+    decayStaleness(userId: string, staleDays?: number, decayFactor?: number): number;
+    /**
+     * Noise archival: archive low-importance memories that never got accessed.
+     * Memories written by the agent but never recalled are likely noise.
+     */
+    decayNoiseArchival(userId: string, minAgeDays?: number, maxImportance?: number): number;
+    /**
+     * Run all decay strategies. Returns total affected count.
+     */
+    runFullDecay(userId: string, options?: {
+        temporalGraceDays?: number;
+        staleDays?: number;
+        staleDecayFactor?: number;
+        noiseMinAgeDays?: number;
+        noiseMaxImportance?: number;
+    }): {
+        temporal: number;
+        stale: number;
+        noise: number;
+        total: number;
+    };
+    /**
+     * Apply feedback signal to a memory, adjusting importance accordingly.
+     *
+     * Signals:
+     *   - "useful"     → boost importance by +0.15 (capped at 1.0)
+     *   - "irrelevant" → reduce importance by -0.2
+     *   - "outdated"   → archive immediately
+     *   - "wrong"      → delete immediately
+     */
+    applyFeedback(memoryId: string, signal: "useful" | "irrelevant" | "outdated" | "wrong"): boolean;
+    /**
+     * Get a profile value for a user.
+     */
+    getProfile(userId: string, key: string): string | null;
+    /**
+     * Set a profile value (upsert).
+     */
+    setProfile(userId: string, key: string, value: string): void;
+    /**
+     * Get all profile entries for a user.
+     */
+    getAllProfiles(userId: string): Record<string, string>;
+    /**
+     * Delete a profile entry.
+     */
+    deleteProfile(userId: string, key: string): boolean;
+    private profileTableCreated;
+    private ensureProfileTable;
+    /**
+     * Retrieve memories within a time range, grouped by day.
+     * Used for "what happened last week" type queries and dream synthesis.
+     */
+    getTemporalSlice(userId: string, startMs: number, endMs: number, options?: {
+        category?: string;
+        limit?: number;
+    }): Array<{
+        date: string;
+        memories: Array<{
+            id: string;
+            text: string;
+            category: string;
+            importance: number;
+        }>;
+    }>;
+    /**
+     * Get memory activity summary over recent N days.
+     * Returns daily counts and high-importance entries — used by temporal synthesis.
+     */
+    getActivitySummary(userId: string, days?: number): {
+        dailyCounts: Array<{
+            date: string;
+            count: number;
+        }>;
+        highlights: Array<{
+            id: string;
+            text: string;
+            category: string;
+            importance: number;
+            date: string;
+        }>;
+    };
+    /**
+     * Find memories related to a specific event date (±tolerance).
+     * Used for temporal context retrieval: "关于上周二的会议" → find memories around that date.
+     */
+    findByEventDate(userId: string, targetDate: string, toleranceDays?: number): MemorySearchHit[];
+    /**
+     * Record an access (for importance/relevance boosting).
+     */
+    recordAccess(id: string): void;
+    /**
+     * Get total memory count for a user.
+     */
+    count(userId: string, activeOnly?: boolean): number;
+    /**
+     * Delete all memories for a user.
+     */
+    resetUser(userId: string): number;
+    /**
+     * Run SQLite VACUUM to reclaim space after deletions/archival.
+     * Should be called periodically (e.g. after decay cycles).
+     */
+    vacuum(): void;
+    /**
+     * Get database size info for capacity monitoring.
+     */
+    getStorageStats(): {
+        pageCount: number;
+        pageSize: number;
+        totalBytes: number;
+        freePages: number;
+    };
+    /**
+     * Export archived memories as JSONL (for cold storage / backup).
+     * Deletes exported records from the database to reclaim space.
+     */
+    exportAndPurgeArchived(userId: string, maxExport?: number): Array<{
+        id: string;
+        text: string;
+        category: string;
+        importance: number;
+        createdAt: number;
+        archivedAt: number;
+        tags: string[];
+    }>;
+    /**
+     * Enforce capacity limit: if active memories exceed maxCount,
+     * archive the oldest lowest-importance ones.
+     */
+    enforceCapacityLimit(userId: string, maxCount?: number): number;
+    close(): void;
+}
+/**
+ * Resolve the database file path for local memory storage.
+ */
+export declare function resolveMemoryDbPath(projectRoot?: string): string;

package/dist/types/skills/memory/memdir.d.ts

@@ -1,4 +1,4 @@
-/** Max chars for INDEX.md to inject into system prompt (CC uses 25KB, we use 12KB). */
+/** Max bytes (UTF-8) for INDEX.md to inject into system prompt (CC uses 25KB, we use 12KB). */
 export declare const INDEX_MAX_CHARS = 12288;
 /** Max lines for INDEX.md injection. */
 export declare const INDEX_MAX_LINES = 200;
@@ -49,6 +49,11 @@ export declare class Memdir {
     };
     /** Append a line/entry to INDEX.md. */
     addToIndex(content: string): Promise<MemdirResult>;
+    /**
+     * Auto-compact INDEX.md by removing oldest non-structural entries to make room.
+     * Returns the compacted content with the new entry appended, or null if impossible.
+     */
+    private autoCompactIndex;
     /** Replace text in INDEX.md (str_replace semantics). */
     replaceInIndex(oldText: string, newText: string): Promise<MemdirResult>;
     /** Remove text from INDEX.md. */

package/dist/types/skills/memory/memory-provider-factory.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Memory Provider Factory — creates local SQLite memory provider.
+ *
+ * No remote/cloud memory service exists. Memory is always local.
+ * This factory is the single integration point for stdio-server.ts.
+ */
+import type { LocalEmbeddingConfig } from "./local-embedding.js";
+import type { LocalMemoryProvider } from "./local-memory-provider.js";
+export interface MemoryProviderFactoryConfig {
+    /** Project root for local storage path. */
+    projectRoot?: string;
+    /** User ID prefix. */
+    userIdPrefix?: string;
+    /** Embedding config for local provider. */
+    embedding?: LocalEmbeddingConfig;
+}
+export interface MemoryProviderFactoryResult {
+    provider: LocalMemoryProvider | null;
+    mode: "local" | "none";
+    error?: string;
+}
+/**
+ * Create the local SQLite memory provider.
+ * Returns null (mode "none") only if better-sqlite3 is not available.
+ */
+export declare function createMemoryProvider(config: MemoryProviderFactoryConfig): MemoryProviderFactoryResult;
+/**
+ * Build MemoryProviderFactoryConfig from environment variables.
+ * Used by stdio-server to auto-configure memory.
+ *
+ * Environment variables:
+ *   QMEMORY_EMBEDDING_STRATEGY — "auto" | "api" | "onnx" | "none" (default: "none")
+ *     - "auto": detect LLM provider → use their embedding API directly
+ *   QMEMORY_EMBEDDING_BASE_URL — required when strategy=api
+ *   QMEMORY_EMBEDDING_API_KEY  — required when strategy=api
+ *   QMEMORY_EMBEDDING_MODEL    — model name (default: "text-embedding-3-small")
+ *   QMEMORY_ONNX_MODEL_ID      — model for ONNX (default: "Xenova/bge-small-zh-v1.5")
+ *   QMEMORY_USER_PREFIX        — user ID prefix for multi-tenant
+ *
+ * Auto-cascade (strategy=auto):
+ *   Layer 0: LLM provider's embedding API (detected from LLM_PROVIDER + *_API_KEY)
+ *   Layer 1: Self-hosted TEI bge-m3 (QMEMORY_TEI_URL / QMEMORY_TEI_FALLBACK_URL)
+ *   Layer 2: ONNX local (@xenova/transformers)
+ *   Layer 3: FTS5 pure text (NullEmbeddingProvider)
+ *
+ * @param projectRoot — Project root for local storage path
+ * @param embeddingOverride — TurnConfig.embeddingModel override (takes priority over env vars)
+ */
+export declare function resolveMemoryConfigFromEnv(projectRoot?: string, embeddingOverride?: {
+    provider?: string;
+    model?: string;
+    apiKey?: string;
+    baseUrl?: string;
+}): MemoryProviderFactoryConfig;

package/dist/types/skills/memory/memory-tool.d.ts

@@ -1,8 +1,9 @@
 import type { MemoryProvider, MemorySearchResult } from "../../protocol/wire/index.js";
+import type { LocalMemoryProvider } from "./local-memory-provider.js";
 import type { Memdir } from "./memdir.js";
 export declare const MEMORY_TOOL_NAME: "memory";
 export declare const MEMORY_TOOL_LABEL = "Memory";
-export declare const MEMORY_TOOL_ACTIONS: readonly ["add", "replace", "remove", "create_file", "write_file", "read_file", "delete_file", "list_files", "search"];
+export declare const MEMORY_TOOL_ACTIONS: readonly ["add", "replace", "remove", "create_file", "write_file", "read_file", "delete_file", "list_files", "search", "remember", "temporal", "feedback"];
 export type MemoryToolAction = (typeof MEMORY_TOOL_ACTIONS)[number];
 export declare const MEMORY_TOOL_SCHEMA: {
     readonly type: "object";
@@ -30,7 +31,28 @@ export declare const MEMORY_TOOL_SCHEMA: {
         };
         readonly query: {
             readonly type: "string";
-            readonly description: "For 'search': natural language query to find relevant memories.";
+            readonly description: "For 'search'/'temporal': natural language query to find relevant memories.";
+        };
+        readonly days: {
+            readonly type: "number";
+            readonly description: "For 'temporal': look back N days from today (default: 7).";
+        };
+        readonly memory_ids: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly description: "For 'feedback': IDs of memories to give feedback on.";
+        };
+        readonly signal: {
+            readonly type: "string";
+            readonly enum: readonly ["useful", "irrelevant", "outdated", "wrong"];
+            readonly description: "For 'feedback': the feedback signal to apply.";
+        };
+        readonly category: {
+            readonly type: "string";
+            readonly enum: readonly ["preference", "personal_fact", "lesson", "pattern", "decision", "context"];
+            readonly description: "For 'remember': categorize the memory (helps with future recall precision).";
         };
     };
     readonly required: readonly ["action"];
@@ -44,6 +66,10 @@ export interface MemoryToolParams {
     new_text?: string;
     file?: string;
     query?: string;
+    days?: number;
+    memory_ids?: string[];
+    signal?: "useful" | "irrelevant" | "outdated" | "wrong";
+    category?: string;
 }
 export interface MemoryToolResult {
     ok: boolean;
@@ -54,6 +80,8 @@ export interface MemoryToolResult {
 export interface MemoryToolExecutorDeps {
     memdir: Memdir;
     provider?: MemoryProvider;
+    /** LocalMemoryProvider for temporal/feedback (typed narrow for advanced ops). */
+    localProvider?: LocalMemoryProvider;
     userId: string;
 }
 export declare function executeMemoryTool(params: MemoryToolParams, deps: MemoryToolExecutorDeps): Promise<MemoryToolResult>;

package/dist/types/skills/permissions/denial-audit-log.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Denial Audit Log — Persistent structured record of all permission denials.
+ *
+ * Writes denial events to a JSONL file for post-session analysis,
+ * compliance auditing, and permission calibration improvement.
+ *
+ * Storage layout:
+ *   <project>/.qlogicagent/audit/denials.jsonl   (project-level)
+ *   ~/.qlogicagent/audit/denials.jsonl            (user-level fallback)
+ *
+ * Each line is a self-contained JSON record with full context.
+ * File is append-only; rotation handled externally if needed.
+ */
+export interface DenialAuditEntry {
+    /** ISO 8601 timestamp */
+    timestamp: string;
+    /** Session identifier */
+    sessionId: string;
+    /** Turn identifier (if available) */
+    turnId: string;
+    /** Tool that was denied */
+    toolName: string;
+    /** Human-readable reason for denial */
+    reason: string;
+    /** Source of the denial decision */
+    source: "classifier" | "rule-engine" | "user" | "timeout" | "safety" | "static-deny";
+    /** Permission role at time of denial */
+    permissionRole: string;
+    /** Tool call ID */
+    callId: string;
+    /** Tool arguments (sanitized — no secrets) */
+    toolArgs?: Record<string, unknown>;
+    /** Cumulative denial count at this point */
+    cumulativeDenials: number;
+    /** Consecutive denial count at this point */
+    consecutiveDenials: number;
+}
+export declare class DenialAuditLogger {
+    private filePath;
+    private writeQueue;
+    constructor(projectRoot?: string);
+    /**
+     * Append a denial event to the audit log.
+     * Non-blocking; errors are swallowed to avoid disrupting agent flow.
+     */
+    record(entry: DenialAuditEntry): void;
+    /** Get the audit log file path (for external tools/export). */
+    getFilePath(): string;
+    private doWrite;
+}
+/** Remove potential secrets from tool args before logging. */
+export declare function sanitizeToolArgs(args: Record<string, unknown> | undefined): Record<string, unknown> | undefined;

package/dist/types/skills/permissions/hook-runner.d.ts

@@ -4,6 +4,7 @@ import { PermissionRuleEngine } from "./rule-engine.js";
 import type { PermissionUpdate, ApprovalRequest, ApprovalResponse } from "./types.js";
 import { type ClassifierLLMCall } from "./permission-classifier.js";
 import type { PermissionRole } from "../../orchestration/subagent/task-types.js";
+import { DenialAuditLogger } from "./denial-audit-log.js";
 export interface PermissionCheckerDeps {
     ruleEngine: PermissionRuleEngine;
     hookRegistry: HookRegistry;
@@ -35,6 +36,12 @@ export interface PermissionCheckerDeps {
      * - worker: classifier-only path, no approval dialog fallback
      */
     permissionRole?: PermissionRole;
+    /** Denial audit logger for persistent audit trail. */
+    auditLogger?: DenialAuditLogger;
+    /** Current session ID (for audit context). */
+    sessionId?: string;
+    /** Getter for current turn ID (changes per turn). */
+    getTurnId?: () => string;
 }
 export declare class PermissionChecker {
     private readonly ruleEngine;
@@ -46,12 +53,15 @@ export declare class PermissionChecker {
     private readonly getRecentMessages;
     private readonly permissionRole;
     private readonly pendingApprovals;
+    private readonly auditLogger;
+    private readonly sessionId;
+    private readonly getTurnId;
     private unregisterHook;
-    /** Tool meta cache 鈥?populated from ToolDefinition[] at agent creation */
+    /** Tool meta cache — populated from ToolDefinition[] at agent creation */
     private toolMetaCache;
-    /** Classifier result cache 鈥?avoids redundant LLM calls (CC permissionCache parity) */
+    /** Classifier result cache — avoids redundant LLM calls (CC permissionCache parity) */
     private classifierCache;
-    /** Denial tracking state 鈥?CC denialTracking.ts parity */
+    /** Denial tracking state — CC denialTracking.ts parity */
     private denialTracking;
     constructor(deps: PermissionCheckerDeps);
     /**
@@ -68,7 +78,7 @@ export declare class PermissionChecker {
      */
     setToolMeta(tools: ToolDefinition[]): void;
     get ruleEngineRef(): PermissionRuleEngine;
-    /** Fire permission.denied hook + onDenied callback */
+    /** Fire permission.denied hook + onDenied callback + audit log */
     private fireDenied;
     private handleResult;
     /**