agentcache 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 a21.ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,193 @@
+# AgentCache
+
+**Knowledge cache for AI coding agents** — learns how you work, remembers across sessions, works everywhere.
+
+AgentCache observes your coding sessions and compiles reusable knowledge (rules, lessons, architectural decisions, context) into a local database. Every future session — regardless of IDE or LLM — gets the benefit of everything you've learned before.
+
+## Why
+
+Every AI coding session starts from zero. The agent doesn't know your team's conventions, past mistakes, or architectural decisions. You repeat yourself. Bugs recur. Context is lost.
+
+AgentCache fixes this. It's a persistent knowledge layer that:
+- **Learns** rules, lessons, and decisions from your sessions
+- **Injects** relevant knowledge at the start of every new session
+- **Works everywhere** — any IDE, any LLM, simultaneously
+- **Stays local** — SQLite database on your machine, nothing leaves your disk
+
+## Install
+
+```bash
+npm install -g agentcache
+```
+
+That's it. No `init`, no per-project setup, no config files.
+
+On install, AgentCache automatically:
+1. Creates `~/.loop/loop.db` (your knowledge store)
+2. Detects installed IDEs (Claude Code, Cursor, Roo Code, Windsurf, Continue, Codex)
+3. Registers itself as an MCP server in each
+4. Sets up Claude Code hooks for automatic transcript recovery
+
+## How It Works
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                        Your Machine                              │
+│                                                                  │
+│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐       │
+│  │  Claude  │  │  Cursor  │  │   Roo    │  │  Codex   │  ...   │
+│  │   Code   │  │          │  │   Code   │  │          │       │
+│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘       │
+│       │              │              │              │              │
+│       └──────────────┴──────────────┴──────────────┘              │
+│                              │                                    │
+│                    MCP Protocol (stdio)                           │
+│                              │                                    │
+│                 ┌────────────┴────────────┐                      │
+│                 │  AgentCache MCP Server   │                      │
+│                 │   (agentcache serve)     │                      │
+│                 └────────────┬────────────┘                      │
+│                              │                                    │
+│                    ┌─────────┴─────────┐                         │
+│                    │  ~/.loop/loop.db   │                         │
+│                    │  (SQLite + WAL)    │                         │
+│                    └───────────────────┘                         │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+### The Cycle
+
+1. **Session starts** — agent calls `loop_inject_context` → gets compiled rules, lessons, decisions
+2. **During session** — agent calls `loop_compile_submit` incrementally as it learns things
+3. **Session ends** — knowledge is already saved. If agent didn't submit (abrupt exit), transcript recovery handles it next session.
+
+### Knowledge Types
+
+| Type | Scope | Example |
+|------|-------|---------|
+| **Rule** | Global | "Always use snake_case for database columns" |
+| **Lesson** | Global | "Don't mock the database in integration tests — we got burned when mocked tests passed but prod migration failed" |
+| **Decision** | Project | "Using Drizzle ORM over Prisma because we need raw SQL escape hatches" |
+| **Context** | Project | "Currently migrating from REST to GraphQL, both coexist" |
+
+Rules and lessons are **global** — they apply to all your projects. Decisions and context are **project-specific**.
+
+## MCP Tools
+
+AgentCache exposes 8 tools via the Model Context Protocol:
+
+| Tool | Purpose |
+|------|---------|
+| `loop_inject_context` | Load compiled knowledge at session start |
+| `loop_compile_submit` | Submit observations incrementally during session |
+| `loop_compile_cluster` | Resolve clustering when observations overlap existing knowledge |
+| `loop_compile_extract` | Process queued transcripts from previous sessions |
+| `loop_enforce` | Check tool calls against enforced policy rules |
+| `loop_save_observation` | Save a permanent observation (USER authority, never auto-deprecated) |
+| `loop_get_knowledge` | Query the knowledge database |
+| `loop_deprecate_knowledge` | Mark knowledge as deprecated when it's no longer valid |
+
+## CLI Commands
+
+```bash
+agentcache setup           # Re-detect IDEs and register (runs automatically on install)
+agentcache serve           # Start MCP server (IDEs spawn this automatically)
+agentcache status          # Show knowledge stats for current project
+agentcache compile-session # Queue transcript for compilation (Stop hook)
+agentcache discover        # Discover uncompiled transcripts (SessionStart hook)
+agentcache enforce         # Policy enforcement (PreToolUse hook)
+```
+
+## Design Principles
+
+### Zero Config
+
+`npm install -g agentcache` is the only step. It detects your IDEs, registers itself, and starts working. No dotfiles in your project. No init commands. No config to maintain.
+
+### Universal
+
+AgentCache uses MCP (Model Context Protocol) as its only interface. Any IDE that supports MCP works. Any LLM — Claude, GPT, Gemini, Qwen, Llama — can use the tools. No IDE-specific code paths. No LLM-specific logic.
+
+### Developer-Scoped
+
+One database per developer (`~/.loop/loop.db`), not per project. Rules and lessons learned in one project benefit all your projects. Project-specific decisions stay scoped to their project.
+
+### Resilient to Abrupt Exits
+
+Sessions can end without warning (crash, ctrl-c, network drop). AgentCache handles this through:
+- **Incremental submission** — observations are saved as they happen, not batched at the end
+- **Transcript recovery** — for Claude Code and Continue, transcripts persist on disk and are compiled next session
+- **Pending queue in SQLite** — concurrent access is safe, nothing lost to race conditions
+
+### Anti-Bloat
+
+AgentCache prevents knowledge from growing unbounded:
+- **Confidence promotion** — observations need repeated confirmation before becoming high-confidence
+- **Decay** — auto-compiled items not seen in 30 days get archived
+- **Budget caps** — max 20 rules, 10 lessons, 10 decisions, 5 context items injected per session
+- **Priority ranking** — USER authority first, then by confidence and recency
+
+## Supported IDEs
+
+| IDE | MCP | Transcript Recovery | Hooks |
+|-----|-----|--------------------|----|
+| Claude Code | Yes | Full (JSONL) | Stop, SessionStart, PreToolUse |
+| Cursor | Yes | Incremental only | — |
+| Roo Code | Yes | Incremental only | — |
+| Windsurf | Yes | Incremental only | — |
+| Continue | Yes | Full (JSON) | — |
+| Codex | Yes | Incremental only | — |
+
+"Incremental only" means if the agent submits observations during the session, they're saved. If the session terminates before any submission, those observations are lost (no transcript access).
+
+## Data Storage
+
+All data lives in `~/.loop/loop.db` (SQLite with WAL mode for concurrent access).
+
+```
+~/.loop/
+└── loop.db          # All knowledge, observations, sessions, pending queue
+```
+
+No data leaves your machine. No network calls. No telemetry. No accounts.
+
+## How Knowledge Compiles
+
+```
+Observations (raw)
+    │
+    ▼
+Extract → Normalize → Canonicalize → Cluster → Detect Contradictions → Compile
+    │                                                                      │
+    │  "Always use ESLint"                                                 │
+    │  "Always use ESLint"  ──→  deduplicated, confidence promoted         │
+    │  "Use Prettier not ESLint"  ──→  contradiction detected              │
+    │                                                                      ▼
+                                                            Knowledge Items (compiled)
+                                                            - status: active/deprecated/superseded
+                                                            - confidence: low/medium/high
+                                                            - authority: AUTO/USER
+```
+
+The compiler is the LLM itself (the agent in your session). AgentCache provides extraction prompts and the agent processes them — no separate API keys or LLM calls needed.
+
+## Project Identity
+
+Projects are identified by a hash of their full filesystem path, not just the folder name. This means:
+- `/work/api` and `/personal/api` are different projects
+- Renaming a folder creates a new project identity
+- Knowledge doesn't leak between same-named projects
+
+## Contributing
+
+```bash
+git clone https://github.com/raghav-a21ai/loop-eng
+cd loop-eng
+npm install
+npm run build
+npm test
+```
+
+## License
+
+MIT

package/dist/chunk-MLKGABMK.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/dist/chunk-MMSMDJ4O.js

@@ -0,0 +1,466 @@
+// src/storage/sqlite.ts
+import Database from "better-sqlite3";
+var SqliteKnowledgeRepository = class {
+  db;
+  constructor(dbPath) {
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    this.initSchema();
+  }
+  initSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        project TEXT NOT NULL,
+        started_at INTEGER NOT NULL,
+        ended_at INTEGER NOT NULL,
+        git_branch TEXT,
+        git_commit TEXT,
+        provider TEXT NOT NULL DEFAULT 'claude',
+        model TEXT NOT NULL,
+        transcript_path TEXT NOT NULL,
+        observation_count INTEGER NOT NULL DEFAULT 0
+      );
+
+      CREATE TABLE IF NOT EXISTS observations (
+        id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL REFERENCES sessions(id),
+        timestamp INTEGER NOT NULL,
+        type TEXT NOT NULL,
+        content TEXT NOT NULL,
+        source_quote TEXT NOT NULL,
+        confidence TEXT NOT NULL,
+        project TEXT NOT NULL,
+        scope TEXT NOT NULL DEFAULT 'project'
+      );
+
+      CREATE TABLE IF NOT EXISTS knowledge_items (
+        id TEXT PRIMARY KEY,
+        canonical_hash TEXT NOT NULL UNIQUE,
+        type TEXT NOT NULL,
+        title TEXT NOT NULL,
+        content TEXT NOT NULL,
+        confidence TEXT NOT NULL DEFAULT 'low',
+        observation_count INTEGER NOT NULL DEFAULT 1,
+        authority TEXT NOT NULL DEFAULT 'AUTO',
+        status TEXT NOT NULL DEFAULT 'active',
+        superseded_by_id TEXT,
+        enforce INTEGER NOT NULL DEFAULT 0,
+        project TEXT NOT NULL,
+        scope TEXT NOT NULL DEFAULT 'project',
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        last_seen_at INTEGER NOT NULL,
+        metadata TEXT NOT NULL DEFAULT '{}'
+      );
+
+      CREATE TABLE IF NOT EXISTS compile_runs (
+        id TEXT PRIMARY KEY,
+        project TEXT NOT NULL,
+        session_id TEXT REFERENCES sessions(id),
+        compiler_version TEXT NOT NULL,
+        prompt_versions TEXT NOT NULL DEFAULT '{}',
+        started_at INTEGER NOT NULL,
+        ended_at INTEGER NOT NULL,
+        duration_ms INTEGER NOT NULL,
+        observations_processed INTEGER NOT NULL DEFAULT 0,
+        knowledge_created INTEGER NOT NULL DEFAULT 0,
+        knowledge_reinforced INTEGER NOT NULL DEFAULT 0,
+        knowledge_deprecated INTEGER NOT NULL DEFAULT 0,
+        knowledge_superseded INTEGER NOT NULL DEFAULT 0,
+        knowledge_ignored INTEGER NOT NULL DEFAULT 0,
+        contradictions_detected INTEGER NOT NULL DEFAULT 0,
+        diagnostics TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS contradictions (
+        id TEXT PRIMARY KEY,
+        project TEXT NOT NULL,
+        item_a_id TEXT NOT NULL,
+        item_b_id TEXT NOT NULL,
+        topic TEXT NOT NULL,
+        description TEXT NOT NULL,
+        recommendation TEXT NOT NULL,
+        resolved INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS pending_transcripts (
+        id TEXT PRIMARY KEY,
+        transcript_path TEXT NOT NULL UNIQUE,
+        project TEXT NOT NULL,
+        project_root TEXT NOT NULL,
+        provider TEXT NOT NULL,
+        queued_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_observations_project ON observations(project);
+      CREATE INDEX IF NOT EXISTS idx_observations_session ON observations(session_id);
+      CREATE INDEX IF NOT EXISTS idx_knowledge_project ON knowledge_items(project);
+      CREATE INDEX IF NOT EXISTS idx_knowledge_enforce ON knowledge_items(enforce);
+      CREATE INDEX IF NOT EXISTS idx_knowledge_status ON knowledge_items(status);
+      CREATE INDEX IF NOT EXISTS idx_ki_scope_status ON knowledge_items(scope, status);
+      CREATE INDEX IF NOT EXISTS idx_ki_project_status ON knowledge_items(project, status);
+      CREATE INDEX IF NOT EXISTS idx_compile_runs_project ON compile_runs(project);
+      CREATE INDEX IF NOT EXISTS idx_contradictions_project ON contradictions(project, resolved);
+    `);
+  }
+  saveSession(session) {
+    this.db.prepare(
+      `INSERT INTO sessions (id, project, started_at, ended_at, git_branch, git_commit, provider, model, transcript_path, observation_count)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      session.id,
+      session.project,
+      session.startedAt,
+      session.endedAt,
+      session.gitBranch,
+      session.gitCommit,
+      session.provider,
+      session.model,
+      session.transcriptPath,
+      session.observationCount
+    );
+  }
+  getSession(id) {
+    const row = this.db.prepare("SELECT * FROM sessions WHERE id = ?").get(id);
+    if (!row) return null;
+    return this.mapSession(row);
+  }
+  getCompiledTranscriptPaths(project) {
+    const rows = this.db.prepare("SELECT transcript_path FROM sessions WHERE project = ? AND transcript_path != ''").all(project);
+    return rows.map((r) => r.transcript_path);
+  }
+  getAllCompiledTranscriptPaths() {
+    const rows = this.db.prepare("SELECT transcript_path FROM sessions WHERE transcript_path != ''").all();
+    return rows.map((r) => r.transcript_path);
+  }
+  saveObservation(obs) {
+    this.db.prepare(
+      `INSERT INTO observations (id, session_id, timestamp, type, content, source_quote, confidence, project, scope)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      obs.id,
+      obs.sessionId,
+      obs.timestamp,
+      obs.type,
+      obs.content,
+      obs.sourceQuote,
+      obs.confidence,
+      obs.project,
+      obs.scope
+    );
+  }
+  saveObservations(obs) {
+    const insert = this.db.prepare(
+      `INSERT INTO observations (id, session_id, timestamp, type, content, source_quote, confidence, project, scope)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+    const transaction = this.db.transaction((observations) => {
+      for (const o of observations) {
+        insert.run(
+          o.id,
+          o.sessionId,
+          o.timestamp,
+          o.type,
+          o.content,
+          o.sourceQuote,
+          o.confidence,
+          o.project,
+          o.scope
+        );
+      }
+    });
+    transaction(obs);
+  }
+  getObservations(project, since) {
+    let sql = "SELECT * FROM observations WHERE project = ?";
+    const params = [project];
+    if (since !== void 0) {
+      sql += " AND timestamp >= ?";
+      params.push(since);
+    }
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((row) => this.mapObservation(row));
+  }
+  saveKnowledgeItem(item) {
+    this.db.prepare(
+      `INSERT INTO knowledge_items (id, canonical_hash, type, title, content, confidence, observation_count, authority, status, superseded_by_id, enforce, project, scope, created_at, updated_at, last_seen_at, metadata)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      item.id,
+      item.canonicalHash,
+      item.type,
+      item.title,
+      item.content,
+      item.confidence,
+      item.observationCount,
+      item.authority,
+      item.status,
+      item.supersededById ?? null,
+      item.enforce ? 1 : 0,
+      item.project,
+      item.scope,
+      item.createdAt,
+      item.updatedAt,
+      item.lastSeenAt,
+      JSON.stringify(item.metadata)
+    );
+  }
+  updateKnowledgeItem(id, patch) {
+    const fieldMap = {
+      canonicalHash: "canonical_hash",
+      type: "type",
+      title: "title",
+      content: "content",
+      confidence: "confidence",
+      observationCount: "observation_count",
+      authority: "authority",
+      status: "status",
+      supersededById: "superseded_by_id",
+      enforce: "enforce",
+      project: "project",
+      scope: "scope",
+      createdAt: "created_at",
+      updatedAt: "updated_at",
+      lastSeenAt: "last_seen_at",
+      metadata: "metadata"
+    };
+    const setClauses = [];
+    const values = [];
+    for (const [key, value] of Object.entries(patch)) {
+      const column = fieldMap[key];
+      if (!column) continue;
+      setClauses.push(`${column} = ?`);
+      if (key === "enforce") {
+        values.push(value ? 1 : 0);
+      } else if (key === "metadata") {
+        values.push(JSON.stringify(value));
+      } else {
+        values.push(value);
+      }
+    }
+    if (setClauses.length === 0) return;
+    values.push(id);
+    this.db.prepare(`UPDATE knowledge_items SET ${setClauses.join(", ")} WHERE id = ?`).run(...values);
+  }
+  getKnowledgeItems(project, filter) {
+    let sql = "SELECT * FROM knowledge_items WHERE project = ?";
+    const params = [project];
+    if (filter) {
+      if (filter.type !== void 0) {
+        sql += " AND type = ?";
+        params.push(filter.type);
+      }
+      if (filter.status !== void 0) {
+        sql += " AND status = ?";
+        params.push(filter.status);
+      }
+      if (filter.enforce !== void 0) {
+        sql += " AND enforce = ?";
+        params.push(filter.enforce ? 1 : 0);
+      }
+      if (filter.authority !== void 0) {
+        sql += " AND authority = ?";
+        params.push(filter.authority);
+      }
+    }
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((row) => this.mapKnowledgeItem(row));
+  }
+  getKnowledgeItem(id) {
+    const row = this.db.prepare("SELECT * FROM knowledge_items WHERE id = ?").get(id);
+    if (!row) return null;
+    return this.mapKnowledgeItem(row);
+  }
+  getKnowledgeForContext(project) {
+    const decayThreshold = Date.now() - 30 * 24 * 60 * 60 * 1e3;
+    this.db.prepare(
+      `UPDATE knowledge_items SET status = 'archived', updated_at = ?
+       WHERE status = 'active' AND authority = 'AUTO' AND last_seen_at < ?`
+    ).run(Date.now(), decayThreshold);
+    const rows = this.db.prepare(
+      `SELECT * FROM knowledge_items WHERE status = 'active' AND (scope = 'global' OR project = ?)
+         ORDER BY
+           CASE authority WHEN 'USER' THEN 0 ELSE 1 END,
+           CASE confidence WHEN 'high' THEN 3 WHEN 'medium' THEN 2 ELSE 1 END DESC,
+           last_seen_at DESC
+         LIMIT 50`
+    ).all(project);
+    return rows.map((row) => this.mapKnowledgeItem(row));
+  }
+  getEnforcedRules(project) {
+    const rows = this.db.prepare(
+      `SELECT * FROM knowledge_items WHERE enforce = 1 AND status = 'active' AND (scope = 'global' OR project = ?)`
+    ).all(project);
+    return rows.map((row) => this.mapKnowledgeItem(row));
+  }
+  saveCompileRun(run) {
+    this.db.prepare(
+      `INSERT INTO compile_runs (id, project, session_id, compiler_version, prompt_versions, started_at, ended_at, duration_ms, observations_processed, knowledge_created, knowledge_reinforced, knowledge_deprecated, knowledge_superseded, knowledge_ignored, contradictions_detected, diagnostics)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      run.id,
+      run.project,
+      run.sessionId,
+      run.compilerVersion,
+      JSON.stringify(run.promptVersions),
+      run.startedAt,
+      run.endedAt,
+      run.durationMs,
+      run.observationsProcessed,
+      run.knowledgeCreated,
+      run.knowledgeReinforced,
+      run.knowledgeDeprecated,
+      run.knowledgeSuperseded,
+      run.knowledgeIgnored,
+      run.contradictionsDetected,
+      run.diagnostics
+    );
+  }
+  getCompileRuns(project, limit) {
+    let sql = "SELECT * FROM compile_runs WHERE project = ? ORDER BY started_at DESC";
+    const params = [project];
+    if (limit !== void 0) {
+      sql += " LIMIT ?";
+      params.push(limit);
+    }
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((row) => this.mapCompileRun(row));
+  }
+  saveContradiction(report) {
+    this.db.prepare(
+      `INSERT INTO contradictions (id, project, item_a_id, item_b_id, topic, description, recommendation, resolved, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      report.id,
+      report.project,
+      report.itemAId,
+      report.itemBId,
+      report.topic,
+      report.description,
+      report.recommendation,
+      report.resolved ? 1 : 0,
+      report.createdAt
+    );
+  }
+  getUnresolvedContradictions(project) {
+    const rows = this.db.prepare("SELECT * FROM contradictions WHERE project = ? AND resolved = 0").all(project);
+    return rows.map((row) => this.mapContradiction(row));
+  }
+  resolveContradiction(id) {
+    this.db.prepare("UPDATE contradictions SET resolved = 1 WHERE id = ?").run(id);
+  }
+  queueTranscript(entry) {
+    this.db.prepare(
+      `INSERT OR IGNORE INTO pending_transcripts (id, transcript_path, project, project_root, provider, queued_at)
+         VALUES (?, ?, ?, ?, ?, ?)`
+    ).run(entry.id, entry.transcriptPath, entry.project, entry.projectRoot, entry.provider, entry.queuedAt);
+  }
+  popPendingTranscript() {
+    const row = this.db.prepare("SELECT * FROM pending_transcripts ORDER BY queued_at ASC LIMIT 1").get();
+    if (!row) return null;
+    this.db.prepare("DELETE FROM pending_transcripts WHERE id = ?").run(row.id);
+    return {
+      id: row.id,
+      transcriptPath: row.transcript_path,
+      project: row.project,
+      projectRoot: row.project_root,
+      provider: row.provider,
+      queuedAt: row.queued_at
+    };
+  }
+  getPendingCount() {
+    const row = this.db.prepare("SELECT COUNT(*) as count FROM pending_transcripts").get();
+    return row.count;
+  }
+  close() {
+    this.db.close();
+  }
+  mapSession(row) {
+    return {
+      id: row.id,
+      project: row.project,
+      startedAt: row.started_at,
+      endedAt: row.ended_at,
+      gitBranch: row.git_branch,
+      gitCommit: row.git_commit,
+      provider: row.provider,
+      model: row.model,
+      transcriptPath: row.transcript_path,
+      observationCount: row.observation_count
+    };
+  }
+  mapObservation(row) {
+    return {
+      id: row.id,
+      sessionId: row.session_id,
+      timestamp: row.timestamp,
+      type: row.type,
+      content: row.content,
+      sourceQuote: row.source_quote,
+      confidence: row.confidence,
+      project: row.project,
+      scope: row.scope || "project"
+    };
+  }
+  mapKnowledgeItem(row) {
+    return {
+      id: row.id,
+      canonicalHash: row.canonical_hash,
+      type: row.type,
+      title: row.title,
+      content: row.content,
+      confidence: row.confidence,
+      observationCount: row.observation_count,
+      authority: row.authority,
+      status: row.status,
+      supersededById: row.superseded_by_id ?? void 0,
+      enforce: row.enforce === 1,
+      project: row.project,
+      scope: row.scope || "project",
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      lastSeenAt: row.last_seen_at,
+      metadata: JSON.parse(row.metadata)
+    };
+  }
+  mapCompileRun(row) {
+    return {
+      id: row.id,
+      project: row.project,
+      sessionId: row.session_id,
+      compilerVersion: row.compiler_version,
+      promptVersions: JSON.parse(row.prompt_versions),
+      startedAt: row.started_at,
+      endedAt: row.ended_at,
+      durationMs: row.duration_ms,
+      observationsProcessed: row.observations_processed,
+      knowledgeCreated: row.knowledge_created,
+      knowledgeReinforced: row.knowledge_reinforced,
+      knowledgeDeprecated: row.knowledge_deprecated,
+      knowledgeSuperseded: row.knowledge_superseded,
+      knowledgeIgnored: row.knowledge_ignored,
+      contradictionsDetected: row.contradictions_detected,
+      diagnostics: row.diagnostics
+    };
+  }
+  mapContradiction(row) {
+    return {
+      id: row.id,
+      project: row.project,
+      itemAId: row.item_a_id,
+      itemBId: row.item_b_id,
+      topic: row.topic,
+      description: row.description,
+      recommendation: row.recommendation,
+      resolved: row.resolved === 1,
+      createdAt: row.created_at
+    };
+  }
+};
+
+export {
+  SqliteKnowledgeRepository
+};