claude-master-toolkit 0.1.1 → 0.1.2

package/README.md

@@ -5,8 +5,8 @@
 See what your sessions actually cost. Cut context bloat before it bites. Query your history in a real dashboard instead of squinting at `/cost`.
 
 ```bash
-npm install -g workctl
-workctl dashboard
+npm install -g claude-master-toolkit
+ctk dashboard
 ```
 
 Opens a local dashboard at `http://localhost:3200` backed by SQLite. Reads your Claude Code session JSONL files directly — no API keys, no telemetry, no accounts.
@@ -48,19 +48,19 @@ The server watches `~/.claude/projects/` and syncs new session events in real ti
 
 All commands are designed to return **compact, Claude-friendly output** — ideal for the `Bash` tool in agent loops.
 
-| Command | What it does |
-|---|---|
-| `workctl cost [--quiet]` | Realized cost of the current session (reads session JSONL, applies pricing) |
-| `workctl context` | Current window usage, cumulative totals, cost, threshold advice |
-| `workctl tokens [file]` | Rough token count for a file or stdin (`chars / 4`) |
-| `workctl estimate <file>` | Faithful pre-flight count via Anthropic `count_tokens` API |
-| `workctl slice <file> <symbol>` | Extract just one function / class / type from a file |
-| `workctl find <query> [path]` | Ranked ripgrep, top 20 results |
-| `workctl git-log [N]` | One-line log for last N commits |
-| `workctl git-changed` | Files changed vs main branch with line counts |
-| `workctl test-summary [cmd]` | Run a test command, print only pass/fail summary |
-| `workctl model <phase>` | Model alias recommendation per SDD phase |
-| `workctl dashboard` | Launch the local metrics dashboard |
+| Command                         | What it does                                                                |
+| ------------------------------- | --------------------------------------------------------------------------- |
+| `workctl cost [--quiet]`        | Realized cost of the current session (reads session JSONL, applies pricing) |
+| `workctl context`               | Current window usage, cumulative totals, cost, threshold advice             |
+| `workctl tokens [file]`         | Rough token count for a file or stdin (`chars / 4`)                         |
+| `workctl estimate <file>`       | Faithful pre-flight count via Anthropic `count_tokens` API                  |
+| `workctl slice <file> <symbol>` | Extract just one function / class / type from a file                        |
+| `workctl find <query> [path]`   | Ranked ripgrep, top 20 results                                              |
+| `workctl git-log [N]`           | One-line log for last N commits                                             |
+| `workctl git-changed`           | Files changed vs main branch with line counts                               |
+| `workctl test-summary [cmd]`    | Run a test command, print only pass/fail summary                            |
+| `workctl model <phase>`         | Model alias recommendation per SDD phase                                    |
+| `workctl dashboard`             | Launch the local metrics dashboard                                          |
 
 Every command supports `--json` for machine-readable output.
 
@@ -70,11 +70,11 @@ Every command supports `--json` for machine-readable output.
 
 Three fidelity sources, picked per use case:
 
-| Source | Fidelity | Used by |
-|---|---|---|
-| Session JSONL (`~/.claude/projects/*/*.jsonl`) | **100%** — real API-charged counts | `cost`, `context`, dashboard |
-| Anthropic `count_tokens` API | **100%** — official endpoint | `estimate` (needs `ANTHROPIC_API_KEY`) |
-| `chars / 4` | rough | `tokens`, fallback for `estimate` |
+| Source                                         | Fidelity                           | Used by                                |
+| ---------------------------------------------- | ---------------------------------- | -------------------------------------- |
+| Session JSONL (`~/.claude/projects/*/*.jsonl`) | **100%** — real API-charged counts | `cost`, `context`, dashboard           |
+| Anthropic `count_tokens` API                   | **100%** — official endpoint       | `estimate` (needs `ANTHROPIC_API_KEY`) |
+| `chars / 4`                                    | rough                              | `tokens`, fallback for `estimate`      |
 
 Pricing table is hard-coded in `src/shared/pricing.ts` for the Claude 4.6 / 4.5 family. Update there when Anthropic changes prices.
 

package/bin/ctk.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+
+import { createRequire } from "module";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const require = createRequire(import.meta.url);
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const cliPath = path.join(__dirname, "../dist/cli.js");
+
+await import(cliPath);

package/dist/cli.js

@@ -1,10 +1,15 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -44,9 +49,9 @@ function boxedOutput(title, lines) {
     // --text-muted
   });
 }
-function spinner(text) {
+function spinner(text2) {
   return ora({
-    text: c.muted(text),
+    text: c.muted(text2),
     spinner: "dots",
     stream: process.stdout
   });
@@ -70,8 +75,8 @@ function formatTokensColored(n) {
 function padRight(str, width) {
   return str + " ".repeat(Math.max(0, width - str.length));
 }
-function arrow(text) {
-  return `${c.accent("\u2192")}  ${text}`;
+function arrow(text2) {
+  return `${c.accent("\u2192")}  ${text2}`;
 }
 
 // src/shared/output.ts
@@ -320,7 +325,7 @@ function tokensCommand(file) {
   }
 }
 async function estimateCommand(file) {
-  let text;
+  let text2;
   if (file === "-") {
     const chunks = [];
     const { createInterface } = await import("readline");
@@ -328,9 +333,9 @@ async function estimateCommand(file) {
     for await (const line of rl) {
       chunks.push(line);
     }
-    text = chunks.join("\n");
+    text2 = chunks.join("\n");
   } else if (existsSync4(file)) {
-    text = readFileSync4(file, "utf-8");
+    text2 = readFileSync4(file, "utf-8");
   } else {
     outputError(`estimate: not a file: ${file} (use '-' for stdin)`);
     return;
@@ -347,7 +352,7 @@ async function estimateCommand(file) {
         },
         body: JSON.stringify({
           model: "claude-sonnet-4-5",
-          messages: [{ role: "user", content: text }]
+          messages: [{ role: "user", content: text2 }]
         })
       });
       const data = await response.json();
@@ -375,9 +380,9 @@ async function estimateCommand(file) {
       }
     }
   }
-  const rough = Math.floor(text.length / 4);
+  const rough = Math.floor(text2.length / 4);
   if (isJsonMode()) {
-    output({ tokens: rough, method: "rough", chars: text.length });
+    output({ tokens: rough, method: "rough", chars: text2.length });
   } else {
     console.log(`${rough} tokens (rough \u2014 set ANTHROPIC_API_KEY for exact count)`);
   }
@@ -391,10 +396,15 @@ import { readFile } from "fs/promises";
 import { existsSync as existsSync5, readdirSync, statSync } from "fs";
 import { join as join3, basename } from "path";
 import { homedir as homedir3 } from "os";
+import { createHash } from "crypto";
 var CLAUDE_PROJECTS_DIR = join3(homedir3(), ".claude", "projects");
 function encodeCwd(cwd) {
   return cwd.replace(/\//g, "-");
 }
+function listProjectDirs() {
+  if (!existsSync5(CLAUDE_PROJECTS_DIR)) return [];
+  return readdirSync(CLAUDE_PROJECTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => join3(CLAUDE_PROJECTS_DIR, d.name));
+}
 function listSessionFiles(projectDir) {
   if (!existsSync5(projectDir)) return [];
   return readdirSync(projectDir).filter((f) => f.endsWith(".jsonl")).map((f) => join3(projectDir, f)).sort((a, b) => {
@@ -436,10 +446,79 @@ function extractTokenEvents(events) {
     }
   }));
 }
+function extractToolNames(content) {
+  if (!Array.isArray(content)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const block of content) {
+    if (typeof block === "object" && block !== null && block.type === "tool_use" && typeof block.name === "string") {
+      const name = block.name;
+      if (!seen.has(name)) {
+        seen.add(name);
+        result.push(name);
+      }
+    }
+  }
+  return result;
+}
+var EXPLORATION_TOOLS = /* @__PURE__ */ new Set(["Read", "Grep", "Glob", "Agent", "Explore", "WebSearch", "WebFetch"]);
+var IMPLEMENTATION_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "NotebookEdit"]);
+var TEST_PATTERNS = [/\bvitest\b/, /\bjest\b/, /\bpytest\b/, /\btest\b/, /\bspec\b/];
+function extractBashCommands(content) {
+  if (!Array.isArray(content)) return [];
+  const cmds = [];
+  for (const block of content) {
+    if (typeof block === "object" && block !== null && block.type === "tool_use" && block.name === "Bash") {
+      const input = block.input;
+      if (input && typeof input.command === "string") {
+        cmds.push(input.command);
+      }
+    }
+  }
+  return cmds;
+}
+function inferSemanticPhase(tools, bashCommands = []) {
+  if (tools.length === 0) return "unknown";
+  if (tools.includes("Bash") && bashCommands.some((cmd) => TEST_PATTERNS.some((p) => p.test(cmd)))) {
+    return "testing";
+  }
+  if (tools.some((t) => IMPLEMENTATION_TOOLS.has(t))) return "implementation";
+  if (tools.includes("Bash")) return "implementation";
+  if (tools.every((t) => EXPLORATION_TOOLS.has(t))) return "exploration";
+  return "unknown";
+}
+function extractEnrichedTokenEvents(events) {
+  return events.filter(
+    (e) => e.type === "assistant" && !!e.message?.usage
+  ).map((e) => {
+    const content = e.message.content;
+    const toolsUsed = extractToolNames(content);
+    const bashCommands = extractBashCommands(content);
+    const contentStr = JSON.stringify(content);
+    const contentHash = createHash("sha256").update(contentStr).digest("hex");
+    return {
+      timestamp: e.timestamp,
+      model: e.message.model ?? "unknown",
+      usage: {
+        inputTokens: e.message.usage.input_tokens ?? 0,
+        outputTokens: e.message.usage.output_tokens ?? 0,
+        cacheReadTokens: e.message.usage.cache_read_input_tokens ?? 0,
+        cacheCreationTokens: e.message.usage.cache_creation_input_tokens ?? 0
+      },
+      toolsUsed,
+      stopReason: e.message.stop_reason ?? "unknown",
+      isSidechain: e.isSidechain ?? false,
+      parentUuid: e.parentUuid,
+      semanticPhase: inferSemanticPhase(toolsUsed, bashCommands),
+      content: contentStr,
+      contentHash
+    };
+  });
+}
 async function getSessionTokens(filePath) {
   const events = await parseJsonlFile(filePath);
-  const tokenEvents = extractTokenEvents(events);
-  return tokenEvents.reduce(
+  const tokenEvents2 = extractTokenEvents(events);
+  return tokenEvents2.reduce(
     (acc, e) => ({
       inputTokens: acc.inputTokens + e.usage.inputTokens,
       outputTokens: acc.outputTokens + e.usage.outputTokens,
@@ -451,13 +530,36 @@ async function getSessionTokens(filePath) {
 }
 async function getLatestTurnUsage(filePath) {
   const events = await parseJsonlFile(filePath);
-  const tokenEvents = extractTokenEvents(events);
-  const last = tokenEvents.at(-1);
+  const tokenEvents2 = extractTokenEvents(events);
+  const last = tokenEvents2.at(-1);
   if (!last) {
     return { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0 };
   }
   return last.usage;
 }
+function extractSessionMeta(events) {
+  const first = events[0];
+  const last = events.at(-1);
+  const modelCounts = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (e.type === "assistant" && e.message?.model) {
+      const m = e.message.model;
+      modelCounts.set(m, (modelCounts.get(m) ?? 0) + 1);
+    }
+  }
+  const primaryModel = [...modelCounts.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? "unknown";
+  const turnCount = events.filter((e) => e.type === "assistant").length;
+  return {
+    sessionId: first?.sessionId ?? basename(first?.uuid ?? "unknown"),
+    startedAt: first?.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+    lastActiveAt: last?.timestamp ?? first?.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+    cwd: first?.cwd ?? "",
+    gitBranch: first?.gitBranch,
+    version: first?.version,
+    primaryModel,
+    turnCount
+  };
+}
 
 // src/cli/commands/cost.ts
 async function costCommand(options) {
@@ -625,13 +727,1010 @@ exit: ${error.status ?? 1}`);
   }
 }
 
+// src/server/index.ts
+import Fastify from "fastify";
+import cors from "@fastify/cors";
+import fastifyStatic from "@fastify/static";
+import { join as join8, dirname as dirname3 } from "path";
+import { fileURLToPath } from "url";
+import { existsSync as existsSync10 } from "fs";
+
+// src/server/db/migrate.ts
+import Database from "better-sqlite3";
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+import { mkdirSync as mkdirSync2 } from "fs";
+var DEFAULT_DB_DIR = join4(homedir4(), ".claude", "state", "claude-master-toolkit");
+var DEFAULT_DB_PATH = join4(DEFAULT_DB_DIR, "ctk.sqlite");
+function resolveDbPath() {
+  return process.env["CTK_DB_PATH"] ?? DEFAULT_DB_PATH;
+}
+function migrate() {
+  const dbPath = resolveDbPath();
+  mkdirSync2(join4(dbPath, ".."), { recursive: true });
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      project_path TEXT NOT NULL,
+      started_at INTEGER NOT NULL,
+      last_active_at INTEGER NOT NULL,
+      primary_model TEXT NOT NULL DEFAULT 'unknown',
+      git_branch TEXT,
+      version TEXT,
+      turn_count INTEGER NOT NULL DEFAULT 0,
+      total_input_tokens INTEGER NOT NULL DEFAULT 0,
+      total_output_tokens INTEGER NOT NULL DEFAULT 0,
+      total_cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+      total_cache_creation_tokens INTEGER NOT NULL DEFAULT 0,
+      total_cost_usd REAL NOT NULL DEFAULT 0,
+      jsonl_file TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS token_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+      timestamp INTEGER NOT NULL,
+      model TEXT NOT NULL,
+      input_tokens INTEGER NOT NULL DEFAULT 0,
+      output_tokens INTEGER NOT NULL DEFAULT 0,
+      cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+      cache_creation_tokens INTEGER NOT NULL DEFAULT 0,
+      cost_usd REAL NOT NULL DEFAULT 0
+    );
+
+    CREATE TABLE IF NOT EXISTS memories (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      type TEXT NOT NULL,
+      scope TEXT NOT NULL DEFAULT 'project',
+      topic_key TEXT,
+      content TEXT NOT NULL,
+      project_path TEXT,
+      session_id TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS sync_state (
+      file_path TEXT PRIMARY KEY,
+      last_byte_offset INTEGER NOT NULL DEFAULT 0,
+      last_modified INTEGER NOT NULL DEFAULT 0
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_token_events_session ON token_events(session_id);
+    CREATE INDEX IF NOT EXISTS idx_token_events_timestamp ON token_events(timestamp);
+    CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_path);
+    CREATE INDEX IF NOT EXISTS idx_sessions_started ON sessions(started_at);
+    CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type);
+    CREATE INDEX IF NOT EXISTS idx_memories_topic ON memories(topic_key);
+    CREATE INDEX IF NOT EXISTS idx_memories_project ON memories(project_path);
+  `);
+  const addColumnSafe = (table, col, type) => {
+    try {
+      db.exec(`ALTER TABLE ${table} ADD COLUMN ${col} ${type}`);
+    } catch {
+    }
+  };
+  addColumnSafe("token_events", "tools_used", "TEXT");
+  addColumnSafe("token_events", "stop_reason", "TEXT");
+  addColumnSafe("token_events", "is_sidechain", "INTEGER DEFAULT 0");
+  addColumnSafe("token_events", "parent_uuid", "TEXT");
+  addColumnSafe("token_events", "semantic_phase", "TEXT");
+  addColumnSafe("memories", "description", "TEXT");
+  addColumnSafe("memories", "file_path", "TEXT");
+  addColumnSafe("memories", "access_count", "INTEGER NOT NULL DEFAULT 0");
+  addColumnSafe("memories", "last_accessed_at", "INTEGER");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS turn_content (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      event_id INTEGER NOT NULL REFERENCES token_events(id) ON DELETE CASCADE,
+      role TEXT NOT NULL,
+      content TEXT NOT NULL,
+      content_hash TEXT NOT NULL,
+      byte_size INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_turn_content_event ON turn_content(event_id);
+    CREATE INDEX IF NOT EXISTS idx_turn_content_hash ON turn_content(content_hash);
+    CREATE INDEX IF NOT EXISTS idx_token_events_phase ON token_events(semantic_phase);
+    CREATE INDEX IF NOT EXISTS idx_token_events_sidechain ON token_events(is_sidechain);
+  `);
+  db.close();
+}
+if (process.argv[1]?.endsWith("migrate.ts") || process.argv[1]?.endsWith("migrate.js")) {
+  migrate();
+  console.log("Migration complete.");
+}
+
+// src/server/parser/sync.ts
+import { statSync as statSync2, existsSync as existsSync6 } from "fs";
+import { basename as basename3, dirname as dirname2 } from "path";
+import { eq } from "drizzle-orm";
+
+// src/server/db/db.ts
+import Database2 from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { join as join5 } from "path";
+import { homedir as homedir5 } from "os";
+import { mkdirSync as mkdirSync3 } from "fs";
+
+// src/server/db/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  memories: () => memories,
+  sessions: () => sessions,
+  syncState: () => syncState,
+  tokenEvents: () => tokenEvents,
+  turnContent: () => turnContent
+});
+import { sqliteTable, text, integer, real } from "drizzle-orm/sqlite-core";
+var sessions = sqliteTable("sessions", {
+  id: text("id").primaryKey(),
+  projectPath: text("project_path").notNull(),
+  startedAt: integer("started_at").notNull(),
+  lastActiveAt: integer("last_active_at").notNull(),
+  primaryModel: text("primary_model").notNull().default("unknown"),
+  gitBranch: text("git_branch"),
+  version: text("version"),
+  turnCount: integer("turn_count").notNull().default(0),
+  totalInputTokens: integer("total_input_tokens").notNull().default(0),
+  totalOutputTokens: integer("total_output_tokens").notNull().default(0),
+  totalCacheReadTokens: integer("total_cache_read_tokens").notNull().default(0),
+  totalCacheCreationTokens: integer("total_cache_creation_tokens").notNull().default(0),
+  totalCostUsd: real("total_cost_usd").notNull().default(0),
+  jsonlFile: text("jsonl_file").notNull()
+});
+var tokenEvents = sqliteTable("token_events", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  timestamp: integer("timestamp").notNull(),
+  model: text("model").notNull(),
+  inputTokens: integer("input_tokens").notNull().default(0),
+  outputTokens: integer("output_tokens").notNull().default(0),
+  cacheReadTokens: integer("cache_read_tokens").notNull().default(0),
+  cacheCreationTokens: integer("cache_creation_tokens").notNull().default(0),
+  costUsd: real("cost_usd").notNull().default(0),
+  // Enriched columns
+  toolsUsed: text("tools_used"),
+  // JSON array: '["Read","Grep"]'
+  stopReason: text("stop_reason"),
+  // "end_turn" | "tool_use" | "max_tokens"
+  isSidechain: integer("is_sidechain", { mode: "boolean" }).default(false),
+  parentUuid: text("parent_uuid"),
+  semanticPhase: text("semantic_phase")
+  // "exploration" | "implementation" | "testing" | "unknown"
+});
+var turnContent = sqliteTable("turn_content", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  eventId: integer("event_id").notNull().references(() => tokenEvents.id, { onDelete: "cascade" }),
+  role: text("role").notNull(),
+  // 'user' | 'assistant'
+  content: text("content").notNull(),
+  // JSON stringified
+  contentHash: text("content_hash").notNull(),
+  byteSize: integer("byte_size").notNull()
+});
+var memories = sqliteTable("memories", {
+  id: text("id").primaryKey(),
+  title: text("title").notNull(),
+  type: text("type").notNull(),
+  // bugfix | decision | architecture | discovery | pattern | config | preference
+  scope: text("scope").notNull().default("project"),
+  // project | personal
+  topicKey: text("topic_key"),
+  description: text("description"),
+  content: text("content").notNull(),
+  projectPath: text("project_path"),
+  filePath: text("file_path"),
+  sessionId: text("session_id"),
+  accessCount: integer("access_count").notNull().default(0),
+  lastAccessedAt: integer("last_accessed_at"),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull()
+});
+var syncState = sqliteTable("sync_state", {
+  filePath: text("file_path").primaryKey(),
+  lastByteOffset: integer("last_byte_offset").notNull().default(0),
+  lastModified: integer("last_modified").notNull().default(0)
+});
+
+// src/server/db/db.ts
+var DEFAULT_DB_DIR2 = join5(homedir5(), ".claude", "state", "claude-master-toolkit");
+var DEFAULT_DB_PATH2 = join5(DEFAULT_DB_DIR2, "ctk.sqlite");
+function resolveDbPath2() {
+  return process.env["CTK_DB_PATH"] ?? DEFAULT_DB_PATH2;
+}
+var _db = null;
+var _sqlite = null;
+function getDb() {
+  if (_db) return _db;
+  const dbPath = resolveDbPath2();
+  mkdirSync3(join5(dbPath, ".."), { recursive: true });
+  _sqlite = new Database2(dbPath);
+  _sqlite.pragma("journal_mode = WAL");
+  _sqlite.pragma("foreign_keys = ON");
+  _db = drizzle(_sqlite, { schema: schema_exports });
+  return _db;
+}
+function closeDb() {
+  if (_sqlite) {
+    _sqlite.close();
+    _sqlite = null;
+    _db = null;
+  }
+}
+process.on("SIGINT", () => {
+  closeDb();
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  closeDb();
+  process.exit(0);
+});
+
+// src/server/parser/sync.ts
+async function syncFile(filePath) {
+  if (!existsSync6(filePath)) return;
+  const db = getDb();
+  const stat = statSync2(filePath);
+  const existing = db.select().from(syncState).where(eq(syncState.filePath, filePath)).get();
+  if (existing?.lastModified === stat.mtimeMs) return;
+  const allEvents = await parseJsonlFile(filePath);
+  const meta = extractSessionMeta(allEvents);
+  const tokenEvts = extractTokenEvents(allEvents);
+  const totalTokens = tokenEvts.reduce(
+    (acc, e) => ({
+      inputTokens: acc.inputTokens + e.usage.inputTokens,
+      outputTokens: acc.outputTokens + e.usage.outputTokens,
+      cacheReadTokens: acc.cacheReadTokens + e.usage.cacheReadTokens,
+      cacheCreationTokens: acc.cacheCreationTokens + e.usage.cacheCreationTokens
+    }),
+    { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0 }
+  );
+  const totalCost = tokenEvts.reduce(
+    (acc, e) => acc + computeCost(e.model, e.usage),
+    0
+  );
+  const projectDir = basename3(dirname2(filePath));
+  const projectPath = projectDir.replace(/^-/, "/").replace(/-/g, "/");
+  db.insert(sessions).values({
+    id: meta.sessionId,
+    projectPath,
+    startedAt: new Date(meta.startedAt).getTime(),
+    lastActiveAt: new Date(meta.lastActiveAt).getTime(),
+    primaryModel: meta.primaryModel,
+    gitBranch: meta.gitBranch,
+    version: meta.version,
+    turnCount: meta.turnCount,
+    totalInputTokens: totalTokens.inputTokens,
+    totalOutputTokens: totalTokens.outputTokens,
+    totalCacheReadTokens: totalTokens.cacheReadTokens,
+    totalCacheCreationTokens: totalTokens.cacheCreationTokens,
+    totalCostUsd: totalCost,
+    jsonlFile: filePath
+  }).onConflictDoUpdate({
+    target: sessions.id,
+    set: {
+      lastActiveAt: new Date(meta.lastActiveAt).getTime(),
+      primaryModel: meta.primaryModel,
+      turnCount: meta.turnCount,
+      totalInputTokens: totalTokens.inputTokens,
+      totalOutputTokens: totalTokens.outputTokens,
+      totalCacheReadTokens: totalTokens.cacheReadTokens,
+      totalCacheCreationTokens: totalTokens.cacheCreationTokens,
+      totalCostUsd: totalCost
+    }
+  }).run();
+  db.delete(tokenEvents).where(eq(tokenEvents.sessionId, meta.sessionId)).run();
+  const enrichedEvts = extractEnrichedTokenEvents(allEvents);
+  for (const evt of enrichedEvts) {
+    const cost = computeCost(evt.model, evt.usage);
+    const inserted = db.insert(tokenEvents).values({
+      sessionId: meta.sessionId,
+      timestamp: new Date(evt.timestamp).getTime(),
+      model: evt.model,
+      inputTokens: evt.usage.inputTokens,
+      outputTokens: evt.usage.outputTokens,
+      cacheReadTokens: evt.usage.cacheReadTokens,
+      cacheCreationTokens: evt.usage.cacheCreationTokens,
+      costUsd: cost,
+      toolsUsed: JSON.stringify(evt.toolsUsed),
+      stopReason: evt.stopReason,
+      isSidechain: evt.isSidechain,
+      parentUuid: evt.parentUuid,
+      semanticPhase: evt.semanticPhase
+    }).returning({ id: tokenEvents.id }).get();
+    if (inserted && evt.content) {
+      db.insert(turnContent).values({
+        eventId: inserted.id,
+        role: "assistant",
+        content: evt.content,
+        contentHash: evt.contentHash,
+        byteSize: Buffer.byteLength(evt.content, "utf-8")
+      }).run();
+    }
+  }
+  db.insert(syncState).values({ filePath, lastByteOffset: 0, lastModified: stat.mtimeMs }).onConflictDoUpdate({
+    target: syncState.filePath,
+    set: { lastByteOffset: 0, lastModified: stat.mtimeMs }
+  }).run();
+}
+async function syncAll() {
+  const projectDirs = listProjectDirs();
+  let fileCount = 0;
+  for (const dir of projectDirs) {
+    const files = listSessionFiles(dir);
+    for (const file of files) {
+      await syncFile(file);
+      fileCount++;
+    }
+  }
+  const db = getDb();
+  const sessionCount = db.select().from(sessions).all().length;
+  return { files: fileCount, sessions: sessionCount };
+}
+
+// src/server/parser/watcher.ts
+import { watch } from "chokidar";
+import { join as join6 } from "path";
+import { homedir as homedir6 } from "os";
+var CLAUDE_PROJECTS_DIR2 = join6(homedir6(), ".claude", "projects");
+function startWatcher(callback) {
+  const watcher = watch(join6(CLAUDE_PROJECTS_DIR2, "**", "*.jsonl"), {
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 500,
+      pollInterval: 100
+    }
+  });
+  watcher.on("change", async (filePath) => {
+    try {
+      await syncFile(filePath);
+      callback?.("synced", filePath);
+    } catch (err) {
+      console.error(`[watcher] Error syncing ${filePath}:`, err);
+    }
+  });
+  watcher.on("add", async (filePath) => {
+    try {
+      await syncFile(filePath);
+      callback?.("synced", filePath);
+    } catch (err) {
+      console.error(`[watcher] Error syncing new file ${filePath}:`, err);
+    }
+  });
+  return watcher;
+}
+
+// src/server/parser/engram-import.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync5, existsSync as existsSync7 } from "fs";
+import { join as join7 } from "path";
+import { randomUUID } from "crypto";
+import { eq as eq2, and } from "drizzle-orm";
+function parseMemoryFile(filePath) {
+  const raw = readFileSync5(filePath, "utf-8");
+  const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!fmMatch) {
+    return { content: raw };
+  }
+  const frontmatter = fmMatch[1];
+  const content = fmMatch[2].trim();
+  const fields = {};
+  for (const line of frontmatter.split("\n")) {
+    const match = line.match(/^(\w+):\s*(.+)$/);
+    if (match) {
+      fields[match[1]] = match[2].trim();
+    }
+  }
+  return {
+    name: fields["name"],
+    description: fields["description"],
+    type: fields["type"],
+    topicKey: fields["topicKey"],
+    originSessionId: fields["originSessionId"],
+    content
+  };
+}
+function mapMemoryType(type) {
+  const mapping = {
+    user: "preference",
+    feedback: "preference",
+    project: "decision",
+    reference: "discovery",
+    bugfix: "bugfix",
+    decision: "decision",
+    architecture: "architecture",
+    discovery: "discovery",
+    pattern: "pattern",
+    config: "config",
+    preference: "preference"
+  };
+  return mapping[type ?? ""] ?? "discovery";
+}
+async function importAllMemories() {
+  const db = getDb();
+  const projectDirs = listProjectDirs();
+  let imported = 0;
+  let skipped = 0;
+  for (const dir of projectDirs) {
+    const memoryDir = join7(dir, "memory");
+    if (!existsSync7(memoryDir)) continue;
+    const files = readdirSync2(memoryDir).filter(
+      (f) => f.endsWith(".md") && f !== "MEMORY.md"
+    );
+    const dirName = dir.split("/").pop() ?? "";
+    const projectPath = dirName.replace(/^-/, "/").replace(/-/g, "/");
+    for (const file of files) {
+      const filePath = join7(memoryDir, file);
+      const parsed = parseMemoryFile(filePath);
+      if (!parsed) {
+        skipped++;
+        continue;
+      }
+      const title = parsed.name ?? file.replace(".md", "");
+      const now = Date.now();
+      try {
+        const existing = db.select({ id: memories.id }).from(memories).where(and(eq2(memories.title, title), eq2(memories.projectPath, projectPath))).get();
+        if (existing) {
+          db.update(memories).set({
+            type: mapMemoryType(parsed.type),
+            description: parsed.description,
+            content: parsed.content,
+            filePath,
+            topicKey: parsed.topicKey,
+            sessionId: parsed.originSessionId,
+            updatedAt: now
+          }).where(eq2(memories.id, existing.id)).run();
+        } else {
+          const id = randomUUID();
+          db.insert(memories).values({
+            id,
+            title,
+            type: mapMemoryType(parsed.type),
+            scope: "project",
+            description: parsed.description,
+            content: parsed.content,
+            filePath,
+            topicKey: parsed.topicKey,
+            projectPath,
+            sessionId: parsed.originSessionId,
+            createdAt: now,
+            updatedAt: now
+          }).run();
+        }
+        imported++;
+      } catch (e) {
+        console.error(`[engram-import] Error processing ${filePath}:`, e);
+        skipped++;
+      }
+    }
+  }
+  return { imported, skipped };
+}
+
+// src/server/routes/sessions.ts
+import { desc, eq as eq3 } from "drizzle-orm";
+import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync8 } from "fs";
+async function sessionsRoutes(app) {
+  app.get("/sessions", async (_req, reply) => {
+    const db = getDb();
+    const rows = db.select().from(sessions).orderBy(desc(sessions.lastActiveAt)).limit(100).all();
+    const data = rows.map((r) => ({
+      id: r.id,
+      projectPath: r.projectPath,
+      startedAt: r.startedAt,
+      lastActiveAt: r.lastActiveAt,
+      primaryModel: r.primaryModel,
+      gitBranch: r.gitBranch,
+      turnCount: r.turnCount,
+      tokens: {
+        inputTokens: r.totalInputTokens,
+        outputTokens: r.totalOutputTokens,
+        cacheReadTokens: r.totalCacheReadTokens,
+        cacheCreationTokens: r.totalCacheCreationTokens
+      },
+      costUsd: r.totalCostUsd
+    }));
+    return reply.send(data);
+  });
+  app.get("/sessions/:id", async (req, reply) => {
+    const db = getDb();
+    const session = db.select().from(sessions).where(eq3(sessions.id, req.params.id)).get();
+    if (!session) {
+      return reply.status(404).send({ error: "Session not found" });
+    }
+    const events = db.select().from(tokenEvents).where(eq3(tokenEvents.sessionId, req.params.id)).orderBy(tokenEvents.timestamp).all();
+    const modelBreakdown = {};
+    for (const e of events) {
+      const key = e.model;
+      if (!modelBreakdown[key]) {
+        modelBreakdown[key] = {
+          inputTokens: 0,
+          outputTokens: 0,
+          cacheReadTokens: 0,
+          cacheCreationTokens: 0,
+          costUsd: 0,
+          turns: 0
+        };
+      }
+      modelBreakdown[key].inputTokens += e.inputTokens;
+      modelBreakdown[key].outputTokens += e.outputTokens;
+      modelBreakdown[key].cacheReadTokens += e.cacheReadTokens;
+      modelBreakdown[key].cacheCreationTokens += e.cacheCreationTokens;
+      modelBreakdown[key].costUsd += e.costUsd;
+      modelBreakdown[key].turns++;
+    }
+    return reply.send({
+      id: session.id,
+      projectPath: session.projectPath,
+      startedAt: session.startedAt,
+      lastActiveAt: session.lastActiveAt,
+      primaryModel: session.primaryModel,
+      gitBranch: session.gitBranch,
+      version: session.version,
+      turnCount: session.turnCount,
+      tokens: {
+        inputTokens: session.totalInputTokens,
+        outputTokens: session.totalOutputTokens,
+        cacheReadTokens: session.totalCacheReadTokens,
+        cacheCreationTokens: session.totalCacheCreationTokens
+      },
+      costUsd: session.totalCostUsd,
+      events,
+      modelBreakdown
+    });
+  });
+  app.get("/sessions/:id/git-stats", async (req, reply) => {
+    const db = getDb();
+    const session = db.select().from(sessions).where(eq3(sessions.id, req.params.id)).get();
+    if (!session) {
+      return reply.status(404).send({ error: "Session not found" });
+    }
+    const projectPath = session.projectPath;
+    if (!existsSync8(projectPath)) {
+      return reply.send({ insertions: 0, deletions: 0, filesChanged: 0, available: false });
+    }
+    try {
+      const startISO = new Date(session.startedAt).toISOString();
+      const endISO = new Date(session.lastActiveAt + 5 * 60 * 1e3).toISOString();
+      const output2 = execSync2(
+        `git -C "${projectPath}" log --numstat --format="" --after="${startISO}" --before="${endISO}" 2>/dev/null || echo ""`,
+        { encoding: "utf-8", stdio: "pipe" }
+      );
+      let insertions = 0;
+      let deletions = 0;
+      const filesChanged = /* @__PURE__ */ new Set();
+      for (const line of output2.split("\n")) {
+        const parts = line.trim().split("	");
+        if (parts.length >= 3) {
+          const ins = parseInt(parts[0], 10);
+          const dels = parseInt(parts[1], 10);
+          if (!isNaN(ins) && !isNaN(dels)) {
+            insertions += ins;
+            deletions += dels;
+            filesChanged.add(parts[2] || "");
+          }
+        }
+      }
+      return reply.send({
+        insertions,
+        deletions,
+        filesChanged: filesChanged.size,
+        available: true
+      });
+    } catch (e) {
+      console.error(`[sessions] Error getting git stats for ${projectPath}:`, e);
+      return reply.send({ insertions: 0, deletions: 0, filesChanged: 0, available: false });
+    }
+  });
+}
+
+// src/server/routes/stats.ts
+import { desc as desc2, sql as sql2, gte } from "drizzle-orm";
+async function statsRoutes(app) {
+  app.get("/stats/current", async (_req, reply) => {
+    const db = getDb();
+    const latestSession = db.select().from(sessions).orderBy(desc2(sessions.lastActiveAt)).limit(1).get();
+    const totalSessions = db.select({ count: sql2`count(*)` }).from(sessions).get();
+    const totalCost = db.select({ total: sql2`sum(total_cost_usd)` }).from(sessions).get();
+    const totalTurns = db.select({ count: sql2`sum(turn_count)` }).from(sessions).get();
+    const sessionCount = totalSessions?.count ?? 0;
+    const totalCostUsd = totalCost?.total ?? 0;
+    const totalTurnCount = totalTurns?.count ?? 0;
+    return reply.send({
+      latestSession: latestSession ? {
+        id: latestSession.id,
+        projectPath: latestSession.projectPath,
+        primaryModel: latestSession.primaryModel,
+        costUsd: latestSession.totalCostUsd,
+        turnCount: latestSession.turnCount,
+        lastActiveAt: latestSession.lastActiveAt
+      } : null,
+      totalSessions: sessionCount,
+      totalCostUsd,
+      totalTurns: totalTurnCount,
+      avgCostPerSession: sessionCount > 0 ? totalCostUsd / sessionCount : 0
+    });
+  });
+  app.get("/stats/timeline", async (_req, reply) => {
+    const db = getDb();
+    const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1e3;
+    const rows = db.select({
+      date: sql2`date(timestamp / 1000, 'unixepoch')`,
+      costUsd: sql2`sum(cost_usd)`,
+      inputTokens: sql2`sum(input_tokens)`,
+      outputTokens: sql2`sum(output_tokens)`,
+      sessions: sql2`count(distinct session_id)`
+    }).from(tokenEvents).where(gte(tokenEvents.timestamp, sevenDaysAgo)).groupBy(sql2`date(timestamp / 1000, 'unixepoch')`).orderBy(sql2`date(timestamp / 1000, 'unixepoch')`).all();
+    return reply.send(rows);
+  });
+  app.get("/stats/models", async (_req, reply) => {
+    const db = getDb();
+    const rows = db.select({
+      model: tokenEvents.model,
+      totalInput: sql2`sum(input_tokens)`,
+      totalOutput: sql2`sum(output_tokens)`,
+      totalCacheRead: sql2`sum(cache_read_tokens)`,
+      totalCacheCreation: sql2`sum(cache_creation_tokens)`,
+      costUsd: sql2`sum(cost_usd)`,
+      turns: sql2`count(*)`,
+      sessionCount: sql2`count(distinct session_id)`
+    }).from(tokenEvents).groupBy(tokenEvents.model).all();
+    const totalCost = rows.reduce((acc, r) => acc + (r.costUsd ?? 0), 0);
+    const data = rows.map((r) => ({
+      model: r.model,
+      modelKey: resolveModelKey(r.model),
+      totalTokens: (r.totalInput ?? 0) + (r.totalOutput ?? 0) + (r.totalCacheRead ?? 0) + (r.totalCacheCreation ?? 0),
+      tokens: {
+        input: r.totalInput ?? 0,
+        output: r.totalOutput ?? 0,
+        cacheRead: r.totalCacheRead ?? 0,
+        cacheCreation: r.totalCacheCreation ?? 0
+      },
+      costUsd: r.costUsd ?? 0,
+      turns: r.turns ?? 0,
+      sessionCount: r.sessionCount ?? 0,
+      percentage: totalCost > 0 ? (r.costUsd ?? 0) / totalCost * 100 : 0
+    }));
+    return reply.send(data);
+  });
+  app.get("/stats/efficiency", async (req, reply) => {
+    const db = getDb();
+    const filter = req.query.sessionId ? sql2`AND session_id = ${req.query.sessionId}` : sql2``;
+    const rows = db.all(sql2`
+      WITH tool_rows AS (
+        SELECT
+          json_each.value AS tool,
+          input_tokens,
+          output_tokens,
+          cost_usd
+        FROM token_events, json_each(tools_used)
+        WHERE tools_used IS NOT NULL ${filter}
+      )
+      SELECT
+        tool,
+        COUNT(*) AS count,
+        ROUND(AVG(input_tokens), 0) AS avgInput,
+        ROUND(AVG(output_tokens), 0) AS avgOutput,
+        ROUND(AVG(cost_usd), 6) AS avgCost
+      FROM tool_rows
+      GROUP BY tool
+      ORDER BY count DESC
+    `);
+    const overall = db.get(sql2`
+      SELECT
+        ROUND(AVG(input_tokens + output_tokens), 0) AS avgTokens,
+        ROUND(AVG(cost_usd), 6) AS avgCost
+      FROM token_events
+      WHERE tools_used IS NOT NULL ${filter}
+    `);
+    return reply.send({
+      perTool: Object.fromEntries(
+        rows.map((r) => [r.tool, { count: r.count, avgInputTokens: r.avgInput, avgOutputTokens: r.avgOutput, avgCostUsd: r.avgCost }])
+      ),
+      overall: {
+        avgTokensPerTurn: overall?.avgTokens ?? 0,
+        avgCostPerTurn: overall?.avgCost ?? 0
+      }
+    });
+  });
+  app.get("/stats/phases", async (req, reply) => {
+    const db = getDb();
+    const filter = req.query.sessionId ? sql2`AND session_id = ${req.query.sessionId}` : sql2``;
+    const rows = db.all(sql2`
+      SELECT
+        semantic_phase AS phase,
+        COUNT(*) AS turns,
+        SUM(input_tokens + output_tokens) AS tokens
+      FROM token_events
+      WHERE semantic_phase IS NOT NULL ${filter}
+      GROUP BY semantic_phase
+    `);
+    const totalTurns = rows.reduce((acc, r) => acc + r.turns, 0);
+    const data = Object.fromEntries(
+      rows.map((r) => [
+        r.phase,
+        {
+          turns: r.turns,
+          pct: totalTurns > 0 ? Math.round(r.turns / totalTurns * 100) : 0,
+          tokens: r.tokens
+        }
+      ])
+    );
+    return reply.send(data);
+  });
+  app.get("/stats/tools", async (req, reply) => {
+    const db = getDb();
+    const filter = req.query.sessionId ? sql2`AND session_id = ${req.query.sessionId}` : sql2``;
+    const freqRows = db.all(sql2`
+      SELECT json_each.value AS tool, COUNT(*) AS count
+      FROM token_events, json_each(tools_used)
+      WHERE tools_used IS NOT NULL ${filter}
+      GROUP BY tool
+      ORDER BY count DESC
+    `);
+    const comboRows = db.all(sql2`
+      SELECT tools_used AS combo, COUNT(*) AS count
+      FROM token_events
+      WHERE tools_used IS NOT NULL
+        AND json_array_length(tools_used) >= 2
+        ${filter}
+      GROUP BY tools_used
+      ORDER BY count DESC
+      LIMIT 10
+    `);
+    return reply.send({
+      frequency: Object.fromEntries(freqRows.map((r) => [r.tool, r.count])),
+      combos: comboRows.map((r) => ({
+        tools: JSON.parse(r.combo),
+        count: r.count
+      }))
+    });
+  });
+  app.get("/stats/score", async (req, reply) => {
+    const db = getDb();
+    const sessionFilter = req.query.sessionId ? sql2`WHERE session_id = ${req.query.sessionId}` : sql2``;
+    const metrics = db.get(sql2`
+      SELECT
+        ROUND(AVG(input_tokens + output_tokens), 0) AS avgTokensPerTurn,
+        COUNT(*) AS totalTurns,
+        SUM(cache_read_tokens) AS totalCacheRead,
+        SUM(input_tokens) AS totalInput,
+        SUM(CASE WHEN semantic_phase = 'exploration' THEN 1 ELSE 0 END) AS explorationTurns,
+        SUM(CASE WHEN semantic_phase = 'implementation' THEN 1 ELSE 0 END) AS implementationTurns,
+        SUM(CASE WHEN semantic_phase = 'testing' THEN 1 ELSE 0 END) AS testingTurns
+      FROM token_events
+      ${sessionFilter}
+    `);
+    if (!metrics || metrics.totalTurns === 0) {
+      return reply.send({ score: 0, breakdown: { tokensPerTurn: 0, cacheHitRatio: 0, errorRecovery: 0, phaseBalance: 0 } });
+    }
+    const tptScore = Math.max(0, Math.min(100, Math.round(100 - (metrics.avgTokensPerTurn - 2e3) / 180)));
+    const cacheRatio = metrics.totalInput > 0 ? metrics.totalCacheRead / metrics.totalInput : 0;
+    const cacheScore = Math.round(Math.min(100, cacheRatio * 100));
+    const total = metrics.totalTurns;
+    const expPct = metrics.explorationTurns / total;
+    const impPct = metrics.implementationTurns / total;
+    const testPct = metrics.testingTurns / total;
+    const distance = Math.abs(expPct - 0.2) + Math.abs(impPct - 0.6) + Math.abs(testPct - 0.2);
+    const phaseScore = Math.round(Math.max(0, 100 - distance * 100));
+    const errorRecovery = 75;
+    const score = Math.round((tptScore + cacheScore + phaseScore + errorRecovery) / 4);
+    return reply.send({
+      sessionId: req.query.sessionId ?? "all",
+      score,
+      breakdown: {
+        tokensPerTurn: tptScore,
+        cacheHitRatio: cacheScore,
+        errorRecovery,
+        phaseBalance: phaseScore
+      }
+    });
+  });
+}
+
+// src/server/routes/memories.ts
+import { and as and2, desc as desc3, eq as eq5, like, or } from "drizzle-orm";
+import { randomUUID as randomUUID2 } from "crypto";
+import { writeFileSync as writeFileSync2, existsSync as existsSync9 } from "fs";
+async function memoriesRoutes(app) {
+  app.get(
+    "/memories",
+    async (req, reply) => {
+      const db = getDb();
+      const conditions = [];
+      if (req.query.type) {
+        conditions.push(eq5(memories.type, req.query.type));
+      }
+      if (req.query.project) {
+        conditions.push(eq5(memories.projectPath, req.query.project));
+      }
+      if (req.query.search) {
+        const s = `%${req.query.search}%`;
+        conditions.push(or(like(memories.title, s), like(memories.content, s), like(memories.topicKey, s)));
+      }
+      const rows = db.select().from(memories).where(conditions.length > 0 ? and2(...conditions) : void 0).orderBy(desc3(memories.updatedAt)).all();
+      return reply.send(rows);
+    }
+  );
+  app.get("/memories/:id", async (req, reply) => {
+    const db = getDb();
+    const memory = db.select().from(memories).where(eq5(memories.id, req.params.id)).get();
+    if (!memory) {
+      return reply.status(404).send({ error: "Memory not found" });
+    }
+    db.update(memories).set({
+      accessCount: (memory.accessCount || 0) + 1,
+      lastAccessedAt: Date.now()
+    }).where(eq5(memories.id, req.params.id)).run();
+    return reply.send(memory);
+  });
+  app.post("/memories", async (req, reply) => {
+    const db = getDb();
+    const id = randomUUID2();
+    const now = Date.now();
+    db.insert(memories).values({
+      id,
+      title: req.body.title,
+      type: req.body.type,
+      scope: req.body.scope ?? "project",
+      topicKey: req.body.topicKey,
+      description: req.body.description,
+      content: req.body.content,
+      projectPath: req.body.projectPath,
+      filePath: req.body.filePath,
+      sessionId: req.body.sessionId,
+      createdAt: now,
+      updatedAt: now
+    }).run();
+    return reply.status(201).send({ id, created: true });
+  });
+  app.patch("/memories/:id", async (req, reply) => {
+    const db = getDb();
+    const existing = db.select().from(memories).where(eq5(memories.id, req.params.id)).get();
+    if (!existing) {
+      return reply.status(404).send({ error: "Memory not found" });
+    }
+    db.update(memories).set({
+      ...req.body,
+      updatedAt: Date.now()
+    }).where(eq5(memories.id, req.params.id)).run();
+    return reply.send({ updated: true });
+  });
+  app.post("/memories/:id/sync", async (req, reply) => {
+    const db = getDb();
+    const memory = db.select().from(memories).where(eq5(memories.id, req.params.id)).get();
+    if (!memory) {
+      return reply.status(404).send({ error: "Memory not found" });
+    }
+    if (!memory.filePath) {
+      return reply.status(400).send({ error: "No file path associated with this memory" });
+    }
+    if (!existsSync9(memory.filePath)) {
+      return reply.status(400).send({ error: "File does not exist on disk" });
+    }
+    const frontmatter = [
+      "---",
+      `name: ${memory.title}`,
+      `description: ${memory.description || ""}`,
+      `type: ${memory.type}`,
+      memory.topicKey ? `topicKey: ${memory.topicKey}` : null,
+      memory.sessionId ? `originSessionId: ${memory.sessionId}` : null,
+      "---"
+    ].filter(Boolean).join("\n");
+    const content = `${frontmatter}
+
+${memory.content}`;
+    try {
+      writeFileSync2(memory.filePath, content, "utf-8");
+      return reply.send({ synced: true });
+    } catch (e) {
+      console.error(`[memories] Error syncing to ${memory.filePath}:`, e);
+      return reply.status(500).send({ error: "Failed to write file" });
+    }
+  });
+  app.delete("/memories/:id", async (req, reply) => {
+    const db = getDb();
+    db.delete(memories).where(eq5(memories.id, req.params.id)).run();
+    return reply.send({ deleted: true });
+  });
+}
+
+// src/server/routes/health.ts
+import { sql as sql3 } from "drizzle-orm";
+async function healthRoutes(app) {
+  app.get("/health", async (_req, reply) => {
+    const db = getDb();
+    const sessionCount = db.select({ count: sql3`count(*)` }).from(sessions).get();
+    const eventCount = db.select({ count: sql3`count(*)` }).from(tokenEvents).get();
+    const memoryCount = db.select({ count: sql3`count(*)` }).from(memories).get();
+    return reply.send({
+      status: "ok",
+      timestamp: Date.now(),
+      counts: {
+        sessions: sessionCount?.count ?? 0,
+        tokenEvents: eventCount?.count ?? 0,
+        memories: memoryCount?.count ?? 0
+      }
+    });
+  });
+}
+
+// src/server/index.ts
+var __dirname = dirname3(fileURLToPath(import.meta.url));
+async function startServer(port = 3200) {
+  migrate();
+  const app = Fastify({ logger: false });
+  await app.register(cors, { origin: true });
+  const publicDir = join8(__dirname, "public");
+  if (existsSync10(publicDir)) {
+    await app.register(fastifyStatic, {
+      root: publicDir,
+      prefix: "/",
+      wildcard: false
+    });
+  }
+  await app.register(sessionsRoutes, { prefix: "/api" });
+  await app.register(statsRoutes, { prefix: "/api" });
+  await app.register(memoriesRoutes, { prefix: "/api" });
+  await app.register(healthRoutes, { prefix: "/api" });
+  app.setNotFoundHandler((_req, reply) => {
+    const indexPath = join8(publicDir, "index.html");
+    if (existsSync10(indexPath)) {
+      return reply.sendFile("index.html");
+    }
+    return reply.status(404).send({ error: "Not found" });
+  });
+  startWatcher((event, filePath) => {
+    if (event === "synced") {
+      console.log(`[watcher] Synced: ${filePath}`);
+    }
+  });
+  let attempts = 0;
+  const maxAttempts = 5;
+  while (attempts < maxAttempts) {
+    try {
+      await app.listen({ port, host: "0.0.0.0" });
+      break;
+    } catch (err) {
+      if (err?.code === "EADDRINUSE" && attempts < maxAttempts - 1) {
+        attempts++;
+        const delay = Math.min(1e3 * Math.pow(2, attempts), 5e3);
+        console.log(`[ctk] Port ${port} in use, retrying in ${delay}ms...`);
+        await new Promise((r) => setTimeout(r, delay));
+      } else {
+        throw err;
+      }
+    }
+  }
+  syncAll().then(
+    (r) => console.log(`[ctk] Synced ${r.files} files, ${r.sessions} sessions`)
+  ).catch(console.error);
+  importAllMemories().then((r) => {
+    if (r.imported > 0)
+      console.log(
+        `[ctk] Imported ${r.imported} memories (${r.skipped} skipped)`
+      );
+  }).catch(console.error);
+}
+var isDirectRun = process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1];
+if (isDirectRun) {
+  startServer().catch((err) => {
+    console.error("[ctk] Failed to start server:", err);
+    process.exit(1);
+  });
+}
+
 // src/cli/commands/dashboard.ts
-var SERVER_MODULE = new URL("./server.js", import.meta.url).href;
 async function dashboardCommand(options) {
   const port = Number(options.port ?? 3200);
   const spin = spinner("Starting ctk server...");
   try {
-    const { startServer } = await import(SERVER_MODULE);
     await startServer(port);
     spin.succeed("Server started");
     const output2 = [
@@ -653,7 +1752,7 @@ async function dashboardCommand(options) {
 }
 
 // src/cli/index.ts
-var VERSION = "1.0.0";
+var VERSION = "0.1.2";
 var program = new Command().name("ctk").description(
   "Claude Master Toolkit \u2014 token-efficient CLI + metrics dashboard"
 ).version(VERSION).option("--json", "Output in JSON format (AI-friendly)").hook("preAction", (thisCommand) => {

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "claude-master-toolkit",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Token-efficient CLI + metrics dashboard for Claude Code. Measure real cost, cut context bloat, and keep sessions cheap.",
   "type": "module",
   "bin": {
-    "ctk": "dist/cli.js"
+    "ctk": "./bin/ctk.js"
   },
   "files": [
     "dist",
@@ -22,8 +22,9 @@
     "test:watch": "vitest",
     "db:generate": "drizzle-kit generate",
     "db:migrate": "tsx src/server/db/migrate.ts",
+    "postinstall": "chmod +x bin/ctk.js",
     "prepublishOnly": "npm run build",
-    "reinstall": "./uninstall.sh && npm install && npm run db:migrate && npm run build && ./install.sh"
+    "reinstall": "./uninstall.sh && npm install && npm run db:migrate && npm run build && ./install.sh && npm link"
   },
   "keywords": [
     "claude",
@@ -92,5 +93,11 @@
     "typescript": "^5.8.3",
     "vite": "^6.3.4",
     "vitest": "^3.1.3"
+  },
+  "exports": {
+    "./server": {
+      "types": "./src/server/index.ts",
+      "default": "./dist/server.js"
+    }
   }
 }