zencefyl 0.1.0

package/dist/index.js

@@ -0,0 +1,1773 @@
+#!/usr/bin/env node
+
+// src/cli/index.tsx
+import { render } from "ink";
+import { createElement } from "react";
+
+// src/bootstrap/setup.ts
+import readline from "readline";
+
+// src/constants/models.ts
+var DEFAULT_MODELS = {
+  fast: "claude-haiku-4-5-20251001",
+  // Cheap + fast — background tasks
+  default: "claude-sonnet-4-6",
+  // Main model for most turns
+  deep: "claude-opus-4-6"
+  // Reserved for deep reasoning (Phase 4+)
+};
+var MODEL_PRICING = {
+  "claude-haiku-4-5-20251001": { inputPerM: 0.8, outputPerM: 4 },
+  "claude-sonnet-4-6": { inputPerM: 3, outputPerM: 15 },
+  "claude-opus-4-6": { inputPerM: 15, outputPerM: 75 }
+};
+
+// src/utils/config.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+var ZENCEFYL_DIR = path.join(os.homedir(), ".zencefyl");
+var CONFIG_PATH = path.join(ZENCEFYL_DIR, "config.json");
+var DEFAULT_CONFIG = {
+  provider: "claude-code",
+  models: { ...DEFAULT_MODELS },
+  dataDir: ZENCEFYL_DIR
+};
+function loadConfig() {
+  fs.mkdirSync(ZENCEFYL_DIR, { recursive: true });
+  if (!fs.existsSync(CONFIG_PATH)) {
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(DEFAULT_CONFIG, null, 2), "utf8");
+    return { ...DEFAULT_CONFIG };
+  }
+  const raw = fs.readFileSync(CONFIG_PATH, "utf8");
+  const parsed = JSON.parse(raw);
+  return {
+    ...DEFAULT_CONFIG,
+    ...parsed,
+    models: { ...DEFAULT_MODELS, ...parsed.models }
+  };
+}
+function saveConfig(config) {
+  fs.mkdirSync(ZENCEFYL_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), "utf8");
+}
+
+// src/bootstrap/setup.ts
+import fs2 from "fs";
+function ask(rl, prompt) {
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => resolve(answer.trim()));
+  });
+}
+function askSecret(prompt) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl._writeToOutput = function(s) {
+      const code = s.charCodeAt(0);
+      if (code === 13 || code === 10) {
+        rl.output.write("\n");
+      }
+    };
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+async function validateAnthropicKey(apiKey, model) {
+  try {
+    const { default: Anthropic2 } = await import("@anthropic-ai/sdk");
+    const client = new Anthropic2({ apiKey });
+    await client.messages.create({
+      model,
+      max_tokens: 1,
+      messages: [{ role: "user", content: "hi" }]
+    });
+    return null;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("401") || msg.includes("authentication") || msg.includes("invalid x-api-key")) {
+      return "Invalid API key \u2014 check for typos and try again.";
+    }
+    if (msg.includes("network") || msg.includes("ENOTFOUND") || msg.includes("fetch")) {
+      return "Could not reach the Anthropic API \u2014 check your internet connection.";
+    }
+    return `Unexpected error: ${msg}`;
+  }
+}
+async function runSetupIfNeeded() {
+  if (fs2.existsSync(CONFIG_PATH)) return false;
+  fs2.mkdirSync(ZENCEFYL_DIR, { recursive: true });
+  process.stdout.write("\n");
+  process.stdout.write("  Welcome to Zencefyl.\n\n");
+  process.stdout.write("  How do you want to connect?\n");
+  process.stdout.write("    [1] Claude.ai subscription (uses Claude Code \u2014 no API key needed)\n");
+  process.stdout.write("    [2] Anthropic API key\n\n");
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  let config;
+  while (true) {
+    const choice = await ask(rl, "  > ");
+    if (choice === "1") {
+      rl.close();
+      config = {
+        provider: "claude-code",
+        models: { ...DEFAULT_MODELS },
+        dataDir: ZENCEFYL_DIR
+      };
+      process.stdout.write("\n  Using Claude Code (no API key needed).\n\n");
+      break;
+    }
+    if (choice === "2") {
+      rl.close();
+      let apiKey = "";
+      while (true) {
+        apiKey = await askSecret("  Enter your Anthropic API key: ");
+        if (!apiKey) {
+          process.stdout.write("  Key cannot be empty.\n");
+          continue;
+        }
+        if (!apiKey.startsWith("sk-ant-")) {
+          process.stdout.write("  That doesn't look like an Anthropic key (should start with sk-ant-).\n");
+          continue;
+        }
+        process.stdout.write("  Validating...\n");
+        const err = await validateAnthropicKey(apiKey, DEFAULT_MODELS.default);
+        if (err) {
+          process.stdout.write(`  ${err}
+`);
+          continue;
+        }
+        process.stdout.write("  Connected.\n\n");
+        break;
+      }
+      config = {
+        provider: "anthropic",
+        apiKey,
+        models: { ...DEFAULT_MODELS },
+        dataDir: ZENCEFYL_DIR
+      };
+      break;
+    }
+    process.stdout.write("  Type 1 or 2.\n");
+  }
+  saveConfig(config);
+  return true;
+}
+
+// src/bootstrap/container.ts
+import Database from "better-sqlite3";
+import path2 from "path";
+
+// src/providers/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+var AnthropicProvider = class {
+  client;
+  constructor(config) {
+    const apiKey = config.apiKey ?? process.env["ANTHROPIC_API_KEY"];
+    if (!apiKey) {
+      throw new Error(
+        "Anthropic API key not found.\nRun zencefyl again \u2014 the setup wizard will prompt you for it."
+      );
+    }
+    this.client = new Anthropic({ apiKey });
+  }
+  // Stream a conversation turn, including tool call handling.
+  //
+  // Yields text deltas as they arrive. When the model wants to use a tool,
+  // yields a tool_use delta with the full parsed input. Yields usage + done
+  // at the end of each call. The engine drives the agentic loop.
+  async *chat(messages, systemPrompt, model, options) {
+    const apiMessages = messages.filter((m) => m.role !== "system").map((m) => ({
+      role: m.role,
+      content: this.serializeContent(m.content)
+    }));
+    const apiTools = options?.tools?.length ? options.tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.inputSchema
+    })) : void 0;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    const pendingToolUse = /* @__PURE__ */ new Map();
+    try {
+      const stream = await this.client.messages.create(
+        {
+          model,
+          max_tokens: 8096,
+          system: systemPrompt,
+          messages: apiMessages,
+          tools: apiTools,
+          stream: true
+        },
+        { signal: options?.signal }
+      );
+      for await (const event of stream) {
+        if (event.type === "message_start") {
+          inputTokens = event.message.usage.input_tokens;
+        }
+        if (event.type === "content_block_start") {
+          if (event.content_block.type === "tool_use") {
+            pendingToolUse.set(event.index, {
+              id: event.content_block.id,
+              name: event.content_block.name,
+              partialInput: ""
+            });
+          }
+        }
+        if (event.type === "content_block_delta") {
+          if (event.delta.type === "text_delta") {
+            yield { type: "text", text: event.delta.text };
+          }
+          if (event.delta.type === "input_json_delta") {
+            const pending = pendingToolUse.get(event.index);
+            if (pending) {
+              pending.partialInput += event.delta.partial_json;
+            }
+          }
+        }
+        if (event.type === "content_block_stop") {
+          const pending = pendingToolUse.get(event.index);
+          if (pending) {
+            let parsedInput = {};
+            try {
+              parsedInput = JSON.parse(pending.partialInput || "{}");
+            } catch {
+            }
+            yield { type: "tool_use", id: pending.id, name: pending.name, input: parsedInput };
+            pendingToolUse.delete(event.index);
+          }
+        }
+        if (event.type === "message_delta") {
+          outputTokens = event.usage.output_tokens;
+        }
+      }
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") return;
+      throw err;
+    }
+    yield { type: "usage", inputTokens, outputTokens };
+    yield { type: "done" };
+  }
+  // ── Private helpers ──────────────────────────────────────────────────────────
+  // Serialize a message's content to what the Anthropic SDK accepts.
+  // String messages are passed through. ContentBlock arrays are mapped to
+  // the SDK's specific block types.
+  serializeContent(content) {
+    if (typeof content === "string") return content;
+    return content.map((block) => {
+      if (block.type === "text") {
+        return { type: "text", text: block.text };
+      }
+      if (block.type === "tool_use") {
+        return {
+          type: "tool_use",
+          id: block.id,
+          name: block.name,
+          input: block.input
+        };
+      }
+      if (block.type === "tool_result") {
+        return {
+          type: "tool_result",
+          tool_use_id: block.tool_use_id,
+          content: block.content,
+          is_error: block.is_error
+        };
+      }
+      throw new Error(`Unknown content block type: ${block.type}`);
+    });
+  }
+};
+
+// src/providers/claude-code.ts
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+
+// src/constants/personality.ts
+var PERSONALITY_PROMPT = `You are Zencefyl \u2014 a personal AI engineering companion. Not a corporate assistant. Not a help desk bot.
+
+You are direct, opinionated, and brutally honest. You tell the user when they're wrong. You argue back when they're mistaken. You never hedge with "it depends" when you have a real recommendation.
+
+Your core job: help the user learn and build. Track what they know, correct misconceptions in real time, push them toward genuine understanding \u2014 not just getting the answer.
+
+Tone rules:
+- Casual. Match the user's register. Mirror their energy.
+- No corporate politeness. Never say "Great question!" or "Certainly!".
+- Short answers when the question is simple. Long when the concept genuinely needs it.
+- You swear when it fits the moment. You joke when it calls for it.
+
+When the user makes a statement about a technical topic:
+1. Identify what they got right \u2014 acknowledge it explicitly.
+2. Identify what is wrong, oversimplified, or missing \u2014 correct it with the real explanation.
+3. Give the accurate mental model, not a lie that "mostly works."
+
+When you correct the user:
+- Be specific about what was wrong and why.
+- Don't soften corrections into suggestions. Be direct.
+- Never dismiss everything \u2014 validate what they got right first.
+
+You are their Jarvis, not their yes-man. You're on their side, which means you don't let them walk around with wrong beliefs.`;
+
+// src/providers/claude-code.ts
+async function* readLines(stream) {
+  const rl = createInterface({ input: stream, crlfDelay: Infinity });
+  for await (const line of rl) {
+    yield line;
+  }
+}
+var ClaudeCodeProvider = class {
+  // The Claude Code session ID from the last completed turn.
+  // null on the first turn — Claude Code creates a new session.
+  // Stored and reused so each turn resumes where the last one left off.
+  cliSessionId = null;
+  // Whether we've injected the Lokkomo personality on this session yet.
+  // We inject once on the first turn via --append-system-prompt.
+  // On resumes the session already has it — no re-injection needed.
+  personalityInjected = false;
+  // Stream a conversation turn through claude -p.
+  //
+  // Only the latest message in `messages` is sent as the prompt — Claude Code
+  // holds the full history in its session store when resuming.
+  // `model` is passed as --model on the first turn only (can't change mid-session).
+  async *chat(messages, systemPrompt, model, options) {
+    const latestUser = [...messages].reverse().find((m) => m.role === "user");
+    if (!latestUser) return;
+    const args = [
+      "--print",
+      // non-interactive, exit when done
+      "--output-format",
+      "stream-json",
+      // one JSON event per line on stdout
+      "--include-partial-messages",
+      // emit text deltas as they arrive (streaming)
+      "--verbose",
+      // required for stream-json to emit events
+      "--permission-mode",
+      "bypassPermissions"
+      // no interactive prompts mid-response
+    ];
+    if (this.cliSessionId) {
+      args.push("--resume", this.cliSessionId);
+    } else {
+      args.push("--append-system-prompt", PERSONALITY_PROMPT);
+      if (model) {
+        args.push("--model", model);
+      }
+    }
+    const proc = spawn("claude", args, {
+      cwd: process.cwd(),
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    options?.signal?.addEventListener("abort", () => {
+      proc.kill("SIGTERM");
+    });
+    proc.stdin.write(latestUser.content, "utf8");
+    proc.stdin.end();
+    let newSessionId = null;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let stderr = "";
+    proc.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    for await (const line of readLines(proc.stdout)) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      let event;
+      try {
+        event = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      const eventType = event["type"];
+      if (eventType === "stream_event") {
+        const inner = event["event"];
+        if (inner?.["type"] === "content_block_delta") {
+          const delta = inner["delta"];
+          if (delta?.["type"] === "text_delta" && typeof delta["text"] === "string") {
+            yield { type: "text", text: delta["text"] };
+          }
+        }
+      }
+      if (eventType === "result") {
+        if (typeof event["session_id"] === "string") {
+          newSessionId = event["session_id"];
+        }
+        const usage = event["usage"];
+        if (usage) {
+          inputTokens = typeof usage["input_tokens"] === "number" ? usage["input_tokens"] : 0;
+          outputTokens = typeof usage["output_tokens"] === "number" ? usage["output_tokens"] : 0;
+        }
+      }
+    }
+    await new Promise((resolve) => proc.on("close", resolve));
+    if (!newSessionId && stderr.trim()) {
+      throw new Error(`claude process failed:
+${stderr.trim()}`);
+    }
+    if (newSessionId) {
+      this.cliSessionId = newSessionId;
+      this.personalityInjected = true;
+    }
+    yield { type: "usage", inputTokens, outputTokens };
+    yield { type: "done" };
+  }
+  // Reset the session (start a fresh conversation).
+  // Called if the user wants to clear history — Phase 3+.
+  resetSession() {
+    this.cliSessionId = null;
+    this.personalityInjected = false;
+  }
+  // Whether a Claude Code session is currently active.
+  hasActiveSession() {
+    return this.cliSessionId !== null;
+  }
+};
+
+// src/store/sqlite/lock.ts
+function withWriteLock(fn) {
+  return fn();
+}
+
+// src/store/sqlite/index.ts
+function topicFromRow(r) {
+  return {
+    id: r.id,
+    name: r.name,
+    parentId: r.parent_id,
+    fullPath: r.full_path,
+    domain: r.domain,
+    stability: r.stability,
+    difficulty: r.difficulty,
+    retrievability: r.retrievability,
+    lastReviewedAt: r.last_reviewed_at,
+    nextReviewAt: r.next_review_at,
+    reviewCount: r.review_count,
+    needsReview: r.needs_review === 1,
+    createdAt: r.created_at,
+    updatedAt: r.updated_at
+  };
+}
+function evidenceFromRow(r) {
+  return {
+    id: r.id,
+    topicId: r.topic_id,
+    sessionId: r.session_id,
+    type: r.type,
+    description: r.description,
+    weight: r.weight,
+    createdAt: r.created_at
+  };
+}
+function sessionFromRow(r) {
+  return {
+    id: r.id,
+    startedAt: r.started_at,
+    endedAt: r.ended_at,
+    model: r.model,
+    provider: r.provider,
+    projectName: r.project_name,
+    messageCount: r.message_count,
+    activeDurationSeconds: r.active_duration_seconds,
+    interleavingIndex: r.interleaving_index,
+    timeOfDay: r.time_of_day,
+    inputTokens: r.input_tokens,
+    outputTokens: r.output_tokens
+  };
+}
+function projectFromRow(r) {
+  return {
+    id: r.id,
+    name: r.name,
+    path: r.path,
+    gitRemote: r.git_remote,
+    language: r.language,
+    lastSeenAt: r.last_seen_at,
+    createdAt: r.created_at
+  };
+}
+function memoryFromRow(r) {
+  return {
+    id: r.id,
+    content: r.content,
+    tags: JSON.parse(r.tags),
+    createdAt: r.created_at
+  };
+}
+var SqliteKnowledgeStore = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  // --- Topics ---------------------------------------------------------------
+  getTopic(id) {
+    const row = this.db.prepare("SELECT * FROM topics WHERE id = ?").get(id);
+    return row ? topicFromRow(row) : null;
+  }
+  getTopicByPath(fullPath) {
+    const row = this.db.prepare("SELECT * FROM topics WHERE full_path = ?").get(fullPath);
+    return row ? topicFromRow(row) : null;
+  }
+  getTopicsByDomain(domain) {
+    const rows = this.db.prepare("SELECT * FROM topics WHERE domain = ? ORDER BY full_path").all(domain);
+    return rows.map(topicFromRow);
+  }
+  getDueTopics() {
+    const rows = this.db.prepare(`SELECT * FROM topics WHERE next_review_at IS NOT NULL AND next_review_at <= datetime('now') ORDER BY next_review_at ASC`).all();
+    return rows.map(topicFromRow);
+  }
+  saveTopic(topic) {
+    const stmt = this.db.prepare(`
+      INSERT INTO topics (name, parent_id, full_path, domain, stability, difficulty, retrievability,
+        last_reviewed_at, next_review_at, review_count, needs_review)
+      VALUES (@name, @parentId, @fullPath, @domain, @stability, @difficulty, @retrievability,
+        @lastReviewedAt, @nextReviewAt, @reviewCount, @needsReview)
+    `);
+    const info = withWriteLock(() => stmt.run({
+      name: topic.name,
+      parentId: topic.parentId,
+      fullPath: topic.fullPath,
+      domain: topic.domain,
+      stability: topic.stability,
+      difficulty: topic.difficulty,
+      retrievability: topic.retrievability,
+      lastReviewedAt: topic.lastReviewedAt,
+      nextReviewAt: topic.nextReviewAt,
+      reviewCount: topic.reviewCount,
+      needsReview: topic.needsReview ? 1 : 0
+    }));
+    return this.getTopic(info.lastInsertRowid);
+  }
+  updateTopic(id, patch) {
+    const sets = [];
+    const params = { id };
+    if (patch.name !== void 0) {
+      sets.push("name = @name");
+      params.name = patch.name;
+    }
+    if (patch.parentId !== void 0) {
+      sets.push("parent_id = @parentId");
+      params.parentId = patch.parentId;
+    }
+    if (patch.fullPath !== void 0) {
+      sets.push("full_path = @fullPath");
+      params.fullPath = patch.fullPath;
+    }
+    if (patch.domain !== void 0) {
+      sets.push("domain = @domain");
+      params.domain = patch.domain;
+    }
+    if (patch.stability !== void 0) {
+      sets.push("stability = @stability");
+      params.stability = patch.stability;
+    }
+    if (patch.difficulty !== void 0) {
+      sets.push("difficulty = @difficulty");
+      params.difficulty = patch.difficulty;
+    }
+    if (patch.retrievability !== void 0) {
+      sets.push("retrievability = @retrievability");
+      params.retrievability = patch.retrievability;
+    }
+    if (patch.lastReviewedAt !== void 0) {
+      sets.push("last_reviewed_at = @lastReviewedAt");
+      params.lastReviewedAt = patch.lastReviewedAt;
+    }
+    if (patch.nextReviewAt !== void 0) {
+      sets.push("next_review_at = @nextReviewAt");
+      params.nextReviewAt = patch.nextReviewAt;
+    }
+    if (patch.reviewCount !== void 0) {
+      sets.push("review_count = @reviewCount");
+      params.reviewCount = patch.reviewCount;
+    }
+    if (patch.needsReview !== void 0) {
+      sets.push("needs_review = @needsReview");
+      params.needsReview = patch.needsReview ? 1 : 0;
+    }
+    if (sets.length === 0) return;
+    sets.push("updated_at = datetime('now')");
+    withWriteLock(
+      () => this.db.prepare(`UPDATE topics SET ${sets.join(", ")} WHERE id = @id`).run(params)
+    );
+  }
+  // --- Evidence -------------------------------------------------------------
+  getEvidence(topicId) {
+    const rows = this.db.prepare("SELECT * FROM evidence WHERE topic_id = ? ORDER BY created_at DESC").all(topicId);
+    return rows.map(evidenceFromRow);
+  }
+  logEvidence(evidence) {
+    const stmt = this.db.prepare(`
+      INSERT INTO evidence (topic_id, session_id, type, description, weight)
+      VALUES (@topicId, @sessionId, @type, @description, @weight)
+    `);
+    const info = withWriteLock(() => stmt.run(evidence));
+    const row = this.db.prepare("SELECT * FROM evidence WHERE id = ?").get(info.lastInsertRowid);
+    return evidenceFromRow(row);
+  }
+  // --- Corrections ----------------------------------------------------------
+  logCorrection(correction) {
+    const stmt = this.db.prepare(`
+      INSERT INTO correction_events (topic_id, session_id, user_claim, correction, severity)
+      VALUES (@topicId, @sessionId, @userClaim, @correction, @severity)
+    `);
+    const info = withWriteLock(() => stmt.run({
+      topicId: correction.topicId,
+      sessionId: correction.sessionId,
+      userClaim: correction.userClaim,
+      correction: correction.correction,
+      severity: correction.severity
+    }));
+    const row = this.db.prepare("SELECT * FROM correction_events WHERE id = ?").get(info.lastInsertRowid);
+    return {
+      id: row.id,
+      topicId: row.topic_id,
+      sessionId: row.session_id,
+      userClaim: row.user_claim,
+      correction: row.correction,
+      severity: row.severity,
+      createdAt: row.created_at
+    };
+  }
+  // --- Domains --------------------------------------------------------------
+  getAllDomains() {
+    const rows = this.db.prepare("SELECT DISTINCT domain FROM topics WHERE domain IS NOT NULL ORDER BY domain").all();
+    return rows.map((r) => r.domain);
+  }
+  // --- Profile --------------------------------------------------------------
+  getProfile(key) {
+    const row = this.db.prepare("SELECT value FROM profile WHERE key = ?").get(key);
+    return row?.value ?? null;
+  }
+  setProfile(key, value) {
+    withWriteLock(
+      () => this.db.prepare(`
+        INSERT INTO profile (key, value, updated_at)
+        VALUES (@key, @value, datetime('now'))
+        ON CONFLICT(key) DO UPDATE SET value = @value, updated_at = datetime('now')
+      `).run({ key, value })
+    );
+  }
+  // --- Projects -------------------------------------------------------------
+  getProject(name) {
+    const row = this.db.prepare("SELECT * FROM projects WHERE name = ?").get(name);
+    return row ? projectFromRow(row) : null;
+  }
+  saveProject(project) {
+    const stmt = this.db.prepare(`
+      INSERT INTO projects (name, path, git_remote, language, last_seen_at)
+      VALUES (@name, @path, @gitRemote, @language, @lastSeenAt)
+      ON CONFLICT(name) DO UPDATE SET
+        path       = @path,
+        git_remote = @gitRemote,
+        language   = @language,
+        last_seen_at = @lastSeenAt
+    `);
+    withWriteLock(() => stmt.run({
+      name: project.name,
+      path: project.path,
+      gitRemote: project.gitRemote,
+      language: project.language,
+      lastSeenAt: project.lastSeenAt
+    }));
+    return this.getProject(project.name);
+  }
+  // --- Sessions -------------------------------------------------------------
+  saveSession(session2) {
+    const stmt = this.db.prepare(`
+      INSERT INTO sessions (id, started_at, ended_at, model, provider, project_name,
+        message_count, active_duration_seconds, interleaving_index, time_of_day,
+        input_tokens, output_tokens)
+      VALUES (@id, @startedAt, @endedAt, @model, @provider, @projectName,
+        0, @activeDurationSeconds, @interleavingIndex, @timeOfDay, 0, 0)
+    `);
+    withWriteLock(() => stmt.run({
+      id: session2.id,
+      startedAt: session2.startedAt,
+      endedAt: session2.endedAt,
+      model: session2.model,
+      provider: session2.provider,
+      projectName: session2.projectName,
+      activeDurationSeconds: session2.activeDurationSeconds,
+      interleavingIndex: session2.interleavingIndex,
+      timeOfDay: session2.timeOfDay
+    }));
+    return this.getSession(session2.id);
+  }
+  updateSession(id, patch) {
+    const sets = [];
+    const params = { id };
+    if (patch.endedAt !== void 0) {
+      sets.push("ended_at = @endedAt");
+      params.endedAt = patch.endedAt;
+    }
+    if (patch.messageCount !== void 0) {
+      sets.push("message_count = @messageCount");
+      params.messageCount = patch.messageCount;
+    }
+    if (patch.activeDurationSeconds !== void 0) {
+      sets.push("active_duration_seconds = @activeDurationSeconds");
+      params.activeDurationSeconds = patch.activeDurationSeconds;
+    }
+    if (patch.interleavingIndex !== void 0) {
+      sets.push("interleaving_index = @interleavingIndex");
+      params.interleavingIndex = patch.interleavingIndex;
+    }
+    if (patch.timeOfDay !== void 0) {
+      sets.push("time_of_day = @timeOfDay");
+      params.timeOfDay = patch.timeOfDay;
+    }
+    if (patch.inputTokens !== void 0) {
+      sets.push("input_tokens = @inputTokens");
+      params.inputTokens = patch.inputTokens;
+    }
+    if (patch.outputTokens !== void 0) {
+      sets.push("output_tokens = @outputTokens");
+      params.outputTokens = patch.outputTokens;
+    }
+    if (sets.length === 0) return;
+    withWriteLock(
+      () => this.db.prepare(`UPDATE sessions SET ${sets.join(", ")} WHERE id = @id`).run(params)
+    );
+  }
+  getSession(id) {
+    const row = this.db.prepare("SELECT * FROM sessions WHERE id = ?").get(id);
+    return row ? sessionFromRow(row) : null;
+  }
+};
+var LocalMemoryStore = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  write(content, tags) {
+    const stmt = this.db.prepare(`
+      INSERT INTO memories (content, tags) VALUES (@content, @tags)
+    `);
+    const info = withWriteLock(() => stmt.run({ content, tags: JSON.stringify(tags) }));
+    const row = this.db.prepare("SELECT * FROM memories WHERE id = ?").get(info.lastInsertRowid);
+    return memoryFromRow(row);
+  }
+  search(query, limit) {
+    const rows = this.db.prepare(`
+      SELECT * FROM memories WHERE content LIKE @pattern ORDER BY created_at DESC LIMIT @limit
+    `).all({ pattern: `%${query}%`, limit });
+    return rows.map(memoryFromRow);
+  }
+  getAll() {
+    const rows = this.db.prepare("SELECT * FROM memories ORDER BY created_at DESC").all();
+    return rows.map(memoryFromRow);
+  }
+};
+
+// src/store/migrations/runner.ts
+import { readFileSync, readdirSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var SQL_DIR = join(__dirname, "sql");
+function listMigrationFiles() {
+  return readdirSync(SQL_DIR).filter((f) => /^\d+_.*\.sql$/.test(f)).map((f) => ({
+    version: parseInt(f.split("_")[0], 10),
+    path: join(SQL_DIR, f)
+  })).sort((a, b) => a.version - b.version);
+}
+function appliedVersions(db) {
+  const tableExists = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='schema_migrations'`).get();
+  if (!tableExists) return /* @__PURE__ */ new Set();
+  const rows = db.prepare("SELECT version FROM schema_migrations").all();
+  return new Set(rows.map((r) => r.version));
+}
+function runMigrations(db) {
+  const files = listMigrationFiles();
+  const applied = appliedVersions(db);
+  const pending = files.filter((f) => !applied.has(f.version));
+  if (pending.length === 0) return;
+  const applyAll = db.transaction(() => {
+    for (const { version, path: path3 } of pending) {
+      const sql = readFileSync(path3, "utf8");
+      db.exec(sql);
+      db.prepare("INSERT INTO schema_migrations (version) VALUES (?)").run(version);
+      console.log(`[zencefyl] applied migration ${version.toString().padStart(3, "0")}`);
+    }
+  });
+  applyAll();
+}
+
+// src/bootstrap/state.ts
+import { randomUUID } from "crypto";
+var session = {
+  sessionId: randomUUID(),
+  startTime: /* @__PURE__ */ new Date(),
+  inputTokens: 0,
+  outputTokens: 0,
+  model: ""
+  // Filled in by createContainer() after config loads
+};
+function accumulateUsage(inputTokens, outputTokens) {
+  session.inputTokens += inputTokens;
+  session.outputTokens += outputTokens;
+}
+
+// src/bootstrap/container.ts
+function createContainer(config) {
+  session.model = config.models.default;
+  const dbPath = path2.join(config.dataDir ?? ZENCEFYL_DIR, "knowledge.db");
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  runMigrations(db);
+  const store = new SqliteKnowledgeStore(db);
+  const memoryStore = new LocalMemoryStore(db);
+  let provider;
+  switch (config.provider) {
+    case "anthropic":
+      provider = new AnthropicProvider(config);
+      break;
+    default:
+      provider = new ClaudeCodeProvider();
+      break;
+  }
+  const timeOfDay = computeTimeOfDay(session.startTime);
+  store.saveSession({
+    id: session.sessionId,
+    startedAt: session.startTime.toISOString(),
+    endedAt: null,
+    model: config.models.default,
+    provider: config.provider ?? "claude-code",
+    projectName: null,
+    // Phase 3 fills this from cwd detection
+    activeDurationSeconds: null,
+    interleavingIndex: null,
+    timeOfDay
+  });
+  return { provider, store, memoryStore, config };
+}
+function computeTimeOfDay(date) {
+  const hour = date.getHours();
+  if (hour >= 5 && hour < 12) return "morning";
+  if (hour >= 12 && hour < 17) return "afternoon";
+  if (hour >= 17 && hour < 21) return "evening";
+  return "night";
+}
+
+// src/constants/limits.ts
+var EVIDENCE_WEIGHTS = {
+  explicit: 0.6,
+  // user stated they know it — lowest weight (self-report)
+  code_reviewed: 0.9,
+  // reviewed code using this concept
+  code_built: 1,
+  // wrote working code — strong signal
+  physical_build: 1.1,
+  // built physical hardware — even stronger
+  project_built: 1.2
+  // shipped a full project — strongest signal
+};
+
+// src/core/knowledge/extractor.ts
+var EXTRACTOR_PROMPT = `You are a knowledge extraction engine. You analyze a conversation between a user and Zencefyl (an AI companion) and extract knowledge signals.
+
+Return ONLY valid JSON matching this schema \u2014 no markdown, no explanation, nothing else:
+{
+  "signals": [
+    {
+      "topic_path": "Domain/Topic/Concept",
+      "domain": "Domain",
+      "evidence_type": "explicit" | "code_reviewed" | "code_built" | "physical_build" | "project_built",
+      "description": "one-sentence summary of what was demonstrated",
+      "confidence": 0.0-1.0,
+      "correction": {
+        "user_claim": "what the user stated",
+        "correction": "what was actually correct",
+        "severity": "minor" | "moderate" | "fundamental"
+      }
+    }
+  ]
+}
+
+Evidence type rules:
+- explicit: user stated they know or learned something (lowest weight)
+- code_reviewed: user discussed reviewing existing code
+- code_built: user described writing or building code
+- physical_build: user described building physical hardware, wiring, soldering
+- project_built: user described completing an entire project
+
+Correction field: only include if Zencefyl explicitly corrected a user mistake.
+
+Topic path format: TitleCase/TitleCase/TitleCase \u2014 max 5 levels, singular nouns.
+Examples: "C++/Memory Management/RAII", "Electronics/FPGA/HDL/FSM/State Encoding"
+
+Include a signal only if there is genuine evidence in this specific exchange.
+If nothing knowledge-relevant happened (chit-chat, procedural questions), return { "signals": [] }.
+Return ONLY the JSON object. No other text.`;
+function parseSignals(raw) {
+  const cleaned = raw.trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "");
+  try {
+    const parsed = JSON.parse(cleaned);
+    return Array.isArray(parsed.signals) ? parsed.signals : [];
+  } catch {
+    return [];
+  }
+}
+function normalizePath(raw) {
+  return raw.split("/").map((segment) => segment.trim()).filter(Boolean).slice(0, 5).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("/");
+}
+function ensureTopicPath(store, fullPath, domain) {
+  const existing = store.getTopicByPath(fullPath);
+  if (existing) return existing.id;
+  const segments = fullPath.split("/");
+  let parentId = null;
+  for (let depth = 1; depth <= segments.length; depth++) {
+    const partialPath = segments.slice(0, depth).join("/");
+    const name = segments[depth - 1];
+    const node = store.getTopicByPath(partialPath);
+    if (node) {
+      parentId = node.id;
+      continue;
+    }
+    const created = store.saveTopic({
+      name,
+      parentId,
+      fullPath: partialPath,
+      domain: depth === 1 ? name : domain,
+      stability: 1,
+      difficulty: 0.3,
+      retrievability: 1,
+      lastReviewedAt: null,
+      nextReviewAt: null,
+      reviewCount: 0,
+      needsReview: false
+    });
+    parentId = created.id;
+  }
+  return parentId;
+}
+async function extractKnowledge(userMessage, assistantMessage, sessionId, store, provider, fastModel) {
+  const conversationSnippet = `USER: ${userMessage}
+
+ZENCEFYL: ${assistantMessage}`;
+  let raw = "";
+  try {
+    for await (const delta of provider.chat(
+      [{ role: "user", content: conversationSnippet }],
+      EXTRACTOR_PROMPT,
+      fastModel
+    )) {
+      if (delta.type === "text") raw += delta.text;
+    }
+  } catch {
+    return;
+  }
+  const signals = parseSignals(raw);
+  if (signals.length === 0) return;
+  for (const signal of signals) {
+    if (signal.confidence < 0.3) continue;
+    const fullPath = normalizePath(signal.topic_path);
+    if (!fullPath) continue;
+    const topicId = ensureTopicPath(store, fullPath, signal.domain);
+    const baseWeight = EVIDENCE_WEIGHTS[signal.evidence_type] ?? 0.6;
+    const weight = parseFloat((baseWeight * signal.confidence).toFixed(3));
+    store.logEvidence({
+      topicId,
+      sessionId,
+      type: signal.evidence_type,
+      description: signal.description,
+      weight
+    });
+    if (signal.correction) {
+      const severity = signal.correction.severity === "minor" ? "minor" : signal.correction.severity === "moderate" ? "moderate" : "fundamental";
+      store.logCorrection({
+        topicId,
+        sessionId,
+        userClaim: signal.correction.user_claim,
+        correction: signal.correction.correction,
+        severity
+      });
+    }
+  }
+}
+
+// src/core/knowledge/context.ts
+var MAX_TOPICS = 12;
+var MAX_DUE = 5;
+function buildKnowledgeContext(store) {
+  const dueTopics = store.getDueTopics().slice(0, MAX_DUE);
+  const recentTopics = collectRecentTopics(store, MAX_TOPICS);
+  if (recentTopics.length === 0 && dueTopics.length === 0) return "";
+  const lines = ["[Knowledge Store Context]"];
+  if (dueTopics.length > 0) {
+    lines.push("\nTopics due for review (bring these up naturally if relevant):");
+    for (const t of dueTopics) {
+      const days = t.nextReviewAt ? Math.floor((Date.now() - new Date(t.nextReviewAt).getTime()) / 864e5) : 0;
+      lines.push(`  - ${t.fullPath} (R=${t.retrievability.toFixed(2)}, ${days}d overdue)`);
+    }
+  }
+  if (recentTopics.length > 0) {
+    lines.push("\nRecently active knowledge:");
+    for (const t of recentTopics) {
+      const r = t.retrievability.toFixed(2);
+      lines.push(`  - ${t.fullPath} (R=${r})`);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function collectRecentTopics(store, limit) {
+  const domains = store.getAllDomains();
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const domain of domains) {
+    const domainTopics = store.getTopicsByDomain(domain);
+    for (const t of domainTopics) {
+      if (!seen.has(t.id)) {
+        seen.add(t.id);
+        result.push(t);
+      }
+    }
+    if (result.length >= limit * 2) break;
+  }
+  return result.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()).slice(0, limit);
+}
+
+// src/tools/knowledge/read-topic/index.ts
+import { z } from "zod";
+
+// src/tools/knowledge/read-topic/prompt.ts
+var TOOL_DESCRIPTION = 'Look up what the user knows about a specific topic or concept. Use this when the user asks what they know about something, when you need to check their current understanding before explaining, or when you want to see if a concept has been logged before. Path format: "Domain/Topic/Concept" (e.g. "C++/Memory Management/RAII"). You can pass just a domain ("C++") to see the top-level topic.';
+
+// src/tools/knowledge/read-topic/index.ts
+var InputSchema = z.object({
+  path: z.string().min(1, "path must not be empty"),
+  include_evidence: z.boolean().optional()
+});
+var INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    path: {
+      type: "string",
+      description: 'Full topic path to look up, e.g. "C++/Memory Management/RAII" or just "C++" for the domain. Case-insensitive.'
+    },
+    include_evidence: {
+      type: "boolean",
+      description: "Include the last 5 evidence records. Default true."
+    }
+  },
+  required: ["path"]
+};
+function confidenceLabel(r) {
+  if (r >= 0.85) return "strong";
+  if (r >= 0.65) return "good";
+  if (r >= 0.45) return "moderate";
+  if (r >= 0.25) return "weak";
+  return "very weak";
+}
+var readTopicTool = {
+  name: "read-topic",
+  description: TOOL_DESCRIPTION,
+  inputSchema: INPUT_SCHEMA,
+  async execute(input, ctx) {
+    const parsed = InputSchema.safeParse(input);
+    if (!parsed.success) {
+      return { content: `Invalid input: ${parsed.error.issues.map((i) => i.message).join(", ")}`, isError: true };
+    }
+    const path3 = parsed.data.path.trim();
+    const includeEvidence = parsed.data.include_evidence ?? true;
+    if (!path3) {
+      return { content: "Error: path must not be empty.", isError: true };
+    }
+    let topic = ctx.store.getTopicByPath(path3);
+    if (!topic) {
+      const domain2 = path3.split("/")[0] ?? path3;
+      const allTopics2 = ctx.store.getTopicsByDomain(domain2);
+      const lower = path3.toLowerCase();
+      topic = allTopics2.find((t) => t.fullPath.toLowerCase() === lower) ?? null;
+      if (!topic) {
+        const partial = allTopics2.find(
+          (t) => t.fullPath.toLowerCase().startsWith(lower) || lower.startsWith(t.fullPath.toLowerCase())
+        ) ?? null;
+        topic = partial;
+      }
+    }
+    if (!topic) {
+      return {
+        content: `No topic found for "${path3}".
+
+This topic hasn't been logged yet. If the user just learned something about it, use log-evidence to record it.`
+      };
+    }
+    const lines = [];
+    lines.push(`TOPIC: ${topic.fullPath}`);
+    lines.push(`Confidence: ${confidenceLabel(topic.retrievability)} (R=${topic.retrievability.toFixed(2)}, stability=${topic.stability.toFixed(1)} days)`);
+    lines.push(`Reviews: ${topic.reviewCount}`);
+    if (topic.nextReviewAt) {
+      const due = new Date(topic.nextReviewAt);
+      const now = /* @__PURE__ */ new Date();
+      const overdue = due < now;
+      lines.push(`Next review: ${due.toLocaleDateString()} ${overdue ? "(OVERDUE)" : ""}`);
+    } else {
+      lines.push("Next review: not scheduled");
+    }
+    if (topic.needsReview) {
+      lines.push("Flag: possible duplicate \u2014 needs review");
+    }
+    const domain = topic.domain ?? topic.name;
+    const allTopics = ctx.store.getTopicsByDomain(domain);
+    const children = allTopics.filter((t) => t.parentId === topic.id);
+    if (children.length > 0) {
+      lines.push(`
+Sub-topics (${children.length}):`);
+      for (const child of children.slice(0, 8)) {
+        lines.push(`  - ${child.name} (R=${child.retrievability.toFixed(2)})`);
+      }
+      if (children.length > 8) {
+        lines.push(`  ... and ${children.length - 8} more`);
+      }
+    }
+    if (includeEvidence) {
+      const evidence = ctx.store.getEvidence(topic.id).slice(0, 5);
+      if (evidence.length > 0) {
+        lines.push("\nRecent evidence:");
+        for (const ev of evidence) {
+          const date = new Date(ev.createdAt).toLocaleDateString();
+          lines.push(`  [${date}] (${ev.type}, w=${ev.weight.toFixed(2)}) ${ev.description}`);
+        }
+      } else {
+        lines.push("\nNo evidence recorded yet.");
+      }
+    }
+    return { content: lines.join("\n") };
+  }
+};
+
+// src/tools/knowledge/write-topic/index.ts
+import { z as z2 } from "zod";
+
+// src/tools/knowledge/write-topic/prompt.ts
+var TOOL_DESCRIPTION2 = "Create a new topic node in the knowledge graph, or confirm an existing one. Use this before log-evidence when you need to ensure a topic path exists. All parent nodes are created automatically \u2014 you only need to call this once for the full path. Idempotent: safe to call even if the topic already exists.";
+
+// src/tools/knowledge/write-topic/index.ts
+var InputSchema2 = z2.object({
+  path: z2.string().min(1, "path must not be empty"),
+  domain: z2.string().optional()
+});
+var INPUT_SCHEMA2 = {
+  type: "object",
+  properties: {
+    path: {
+      type: "string",
+      description: 'Full topic path to create, e.g. "C++/Memory Management/RAII". All parent nodes are created automatically.'
+    },
+    domain: {
+      type: "string",
+      description: 'Top-level domain for this topic (e.g. "C++", "Electronics"). Inferred from path if omitted.'
+    }
+  },
+  required: ["path"]
+};
+function titleCase(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function ensurePath(store, fullPath, domain) {
+  const segments = fullPath.split("/");
+  let parentId = null;
+  for (let depth = 1; depth <= segments.length; depth++) {
+    const partialPath = segments.slice(0, depth).join("/");
+    const name = segments[depth - 1] ?? "";
+    const existing = store.getTopicByPath(partialPath);
+    if (existing) {
+      parentId = existing.id;
+      continue;
+    }
+    const created = store.saveTopic({
+      name,
+      parentId,
+      fullPath: partialPath,
+      domain: depth === 1 ? name : domain,
+      stability: 1,
+      difficulty: 0.3,
+      retrievability: 1,
+      lastReviewedAt: null,
+      nextReviewAt: null,
+      reviewCount: 0,
+      needsReview: false
+    });
+    parentId = created.id;
+  }
+  return parentId;
+}
+var writeTopicTool = {
+  name: "write-topic",
+  description: TOOL_DESCRIPTION2,
+  inputSchema: INPUT_SCHEMA2,
+  async execute(input, ctx) {
+    const parsed = InputSchema2.safeParse(input);
+    if (!parsed.success) {
+      return { content: `Invalid input: ${parsed.error.issues.map((i) => i.message).join(", ")}`, isError: true };
+    }
+    const rawPath = parsed.data.path.trim();
+    if (!rawPath) {
+      return { content: "Error: path must not be empty.", isError: true };
+    }
+    const normalizedPath = rawPath.split("/").map((s) => titleCase(s.trim())).filter(Boolean).slice(0, 5).join("/");
+    const domain = parsed.data.domain?.trim() ?? normalizedPath.split("/")[0] ?? normalizedPath;
+    const existing = ctx.store.getTopicByPath(normalizedPath);
+    if (existing) {
+      return {
+        content: `Topic already exists: ${normalizedPath} (id=${existing.id}, R=${existing.retrievability.toFixed(2)})`
+      };
+    }
+    const id = ensurePath(ctx.store, normalizedPath, domain);
+    const created = ctx.store.getTopic(id);
+    return {
+      content: `Created topic: ${normalizedPath} (id=${id})${created?.parentId ? ` under parent id=${created.parentId}` : ""}`
+    };
+  }
+};
+
+// src/tools/knowledge/log-evidence/index.ts
+import { z as z3 } from "zod";
+
+// src/tools/knowledge/log-evidence/prompt.ts
+var TOOL_DESCRIPTION3 = "Record learning evidence for a topic. Use this when the user demonstrates knowledge: writes code, builds something, explicitly learns a concept, or you correct them and they understand. Pick the evidence type carefully \u2014 it determines how much weight the evidence carries. Use explicit for stated knowledge, code_built for working code, project_built for shipped work. The topic is created automatically if it does not exist.";
+
+// src/tools/knowledge/log-evidence/index.ts
+var EVIDENCE_TYPES = ["explicit", "code_reviewed", "code_built", "physical_build", "project_built"];
+var InputSchema3 = z3.object({
+  topic_path: z3.string().min(1, "topic_path must not be empty"),
+  type: z3.enum(EVIDENCE_TYPES),
+  description: z3.string().min(1, "description must not be empty")
+});
+var INPUT_SCHEMA3 = {
+  type: "object",
+  properties: {
+    topic_path: {
+      type: "string",
+      description: 'Full topic path, e.g. "C++/Memory Management/RAII". Created if it does not exist.'
+    },
+    type: {
+      type: "string",
+      enum: [...EVIDENCE_TYPES],
+      description: "Evidence type. explicit = user stated they know it (weight 0.6). code_reviewed = reviewed code using this concept (0.9). code_built = wrote working code applying it (1.0). physical_build = built physical hardware using it (1.1). project_built = shipped a full project applying it (1.2)."
+    },
+    description: {
+      type: "string",
+      description: "One-sentence summary of what was demonstrated or learned."
+    }
+  },
+  required: ["topic_path", "type", "description"]
+};
+function ensureTopicPath2(store, fullPath) {
+  const segments = fullPath.split("/");
+  const domain = segments[0] ?? fullPath;
+  let parentId = null;
+  for (let depth = 1; depth <= segments.length; depth++) {
+    const partialPath = segments.slice(0, depth).join("/");
+    const name = segments[depth - 1] ?? "";
+    const existing = store.getTopicByPath(partialPath);
+    if (existing) {
+      parentId = existing.id;
+      continue;
+    }
+    const created = store.saveTopic({
+      name,
+      parentId,
+      fullPath: partialPath,
+      domain: depth === 1 ? name : domain,
+      stability: 1,
+      difficulty: 0.3,
+      retrievability: 1,
+      lastReviewedAt: null,
+      nextReviewAt: null,
+      reviewCount: 0,
+      needsReview: false
+    });
+    parentId = created.id;
+  }
+  return parentId;
+}
+var logEvidenceTool = {
+  name: "log-evidence",
+  description: TOOL_DESCRIPTION3,
+  inputSchema: INPUT_SCHEMA3,
+  async execute(input, ctx) {
+    const parsed = InputSchema3.safeParse(input);
+    if (!parsed.success) {
+      return { content: `Invalid input: ${parsed.error.issues.map((i) => i.message).join(", ")}`, isError: true };
+    }
+    const { topic_path: rawPath, type, description: desc } = parsed.data;
+    const fullPath = rawPath.trim().split("/").map((s) => {
+      const t = s.trim();
+      return t.charAt(0).toUpperCase() + t.slice(1);
+    }).filter(Boolean).slice(0, 5).join("/");
+    const topicId = ensureTopicPath2(ctx.store, fullPath);
+    const weight = EVIDENCE_WEIGHTS[type];
+    const ev = ctx.store.logEvidence({
+      topicId,
+      sessionId: ctx.sessionId,
+      type,
+      description: desc,
+      weight
+    });
+    return {
+      content: `Logged evidence for "${fullPath}"
+Type: ${type} (weight=${weight})
+Description: ${desc}
+Evidence id: ${ev.id}`
+    };
+  }
+};
+
+// src/tools/knowledge/search-topics/index.ts
+import { z as z4 } from "zod";
+
+// src/tools/knowledge/search-topics/prompt.ts
+var TOOL_DESCRIPTION4 = 'Search the knowledge graph by topic name or path. Use this when the user asks "what do I know about X" for a broad topic that might span multiple sub-paths. Returns a summary of matching topics with confidence scores. For a specific known path, prefer read-topic instead.';
+
+// src/tools/knowledge/search-topics/index.ts
+var InputSchema4 = z4.object({
+  query: z4.string().min(1, "query must not be empty"),
+  domain: z4.string().optional(),
+  min_confidence: z4.number().min(0).max(1).optional()
+});
+var INPUT_SCHEMA4 = {
+  type: "object",
+  properties: {
+    query: {
+      type: "string",
+      description: "Search term. Matched against topic paths and names (case-insensitive substring match)."
+    },
+    domain: {
+      type: "string",
+      description: 'Limit results to this top-level domain, e.g. "C++", "Electronics". Optional.'
+    },
+    min_confidence: {
+      type: "number",
+      description: "Only return topics with retrievability >= this value (0.0\u20131.0). Default 0 (all)."
+    }
+  },
+  required: ["query"]
+};
+var searchTopicsTool = {
+  name: "search-topics",
+  description: TOOL_DESCRIPTION4,
+  inputSchema: INPUT_SCHEMA4,
+  async execute(input, ctx) {
+    const parsed = InputSchema4.safeParse(input);
+    if (!parsed.success) {
+      return { content: `Invalid input: ${parsed.error.issues.map((i) => i.message).join(", ")}`, isError: true };
+    }
+    const query = parsed.data.query.trim().toLowerCase();
+    const domain = parsed.data.domain?.trim();
+    const minConfidence = parsed.data.min_confidence ?? 0;
+    let candidates = domain ? ctx.store.getTopicsByDomain(domain) : (() => {
+      const allDomains = ctx.store.getAllDomains();
+      const seen = /* @__PURE__ */ new Set();
+      const all = [];
+      for (const d of allDomains) {
+        for (const t of ctx.store.getTopicsByDomain(d)) {
+          if (!seen.has(t.id)) {
+            seen.add(t.id);
+            all.push(t);
+          }
+        }
+      }
+      return all;
+    })();
+    const matches = candidates.filter(
+      (t) => t.fullPath.toLowerCase().includes(query) && t.retrievability >= minConfidence
+    );
+    if (matches.length === 0) {
+      return {
+        content: `No topics found matching "${query}"${domain ? ` in domain "${domain}"` : ""}.
+The user hasn't logged any knowledge about this yet.`
+      };
+    }
+    matches.sort((a, b) => b.retrievability - a.retrievability);
+    const lines = [
+      `Found ${matches.length} topic(s) matching "${query}":`,
+      ""
+    ];
+    for (const t of matches.slice(0, 20)) {
+      const r = t.retrievability.toFixed(2);
+      const s = t.stability.toFixed(1);
+      const due = t.nextReviewAt ? ` | due ${new Date(t.nextReviewAt).toLocaleDateString()}` : "";
+      const flag = t.needsReview ? " [needs review]" : "";
+      lines.push(`  ${t.fullPath}`);
+      lines.push(`    R=${r} (stability=${s}d, ${t.reviewCount} reviews)${due}${flag}`);
+    }
+    if (matches.length > 20) {
+      lines.push(`  ... and ${matches.length - 20} more (use domain filter to narrow)`);
+    }
+    return { content: lines.join("\n") };
+  }
+};
+
+// src/core/engine.ts
+var MAX_TOOL_ITERATIONS = 8;
+var Engine = class {
+  history;
+  container;
+  // All knowledge tools available to the model.
+  // Only used by AnthropicProvider (Phase 2). ClaudeCodeProvider gets
+  // knowledge via system prompt context injection instead.
+  tools;
+  constructor(container) {
+    this.container = container;
+    this.history = [];
+    this.tools = [readTopicTool, writeTopicTool, logEvidenceTool, searchTopicsTool];
+  }
+  // ── Public API ──────────────────────────────────────────────────────────────
+  // Send a user message and stream back the response.
+  //
+  // Yields StreamDeltas: text chunks, tool_use signals, tool_result signals,
+  // usage summary, then done. The caller (App.tsx) renders these in real time.
+  //
+  // The agentic loop runs transparently — if the model calls a tool, we
+  // execute it and continue without breaking the stream. The caller sees
+  // tool_use and tool_result deltas so it can render "[reading: ...]" UI.
+  //
+  // Abort: if signal fires mid-stream, the generator returns without
+  // committing anything to history (user turn is rolled back).
+  async *sendMessage(text, signal) {
+    const model = this.container.config.models.default;
+    const knowledgeContext = buildKnowledgeContext(this.container.store);
+    const systemPrompt = knowledgeContext ? `${PERSONALITY_PROMPT}
+
+${knowledgeContext}` : PERSONALITY_PROMPT;
+    const workingMessages = [
+      ...this.history,
+      { role: "user", content: text }
+    ];
+    let finalText = "";
+    try {
+      for (let iteration = 0; iteration < MAX_TOOL_ITERATIONS; iteration++) {
+        const toolCallsThisIteration = [];
+        let iterText = "";
+        for await (const delta of this.container.provider.chat(
+          workingMessages,
+          systemPrompt,
+          model,
+          { signal, tools: this.tools }
+        )) {
+          switch (delta.type) {
+            case "text":
+              iterText += delta.text;
+              yield delta;
+              break;
+            case "tool_use":
+              toolCallsThisIteration.push({ id: delta.id, name: delta.name, input: delta.input });
+              yield delta;
+              break;
+            case "usage":
+              accumulateUsage(delta.inputTokens, delta.outputTokens);
+              yield delta;
+              break;
+            case "done":
+              break;
+          }
+        }
+        if (toolCallsThisIteration.length === 0) {
+          finalText = iterText;
+          break;
+        }
+        const assistantContent = [];
+        if (iterText) {
+          assistantContent.push({ type: "text", text: iterText });
+        }
+        for (const tc of toolCallsThisIteration) {
+          assistantContent.push({ type: "tool_use", id: tc.id, name: tc.name, input: tc.input });
+        }
+        workingMessages.push({ role: "assistant", content: assistantContent });
+        const toolResultContent = [];
+        for (const tc of toolCallsThisIteration) {
+          const toolDef = this.tools.find((t) => t.name === tc.name);
+          const result = toolDef ? await toolDef.execute(tc.input, {
+            sessionId: session.sessionId,
+            store: this.container.store
+          }).catch((err) => ({
+            content: `Tool execution error: ${err instanceof Error ? err.message : String(err)}`,
+            isError: true
+          })) : { content: `Unknown tool: ${tc.name}`, isError: true };
+          yield {
+            type: "tool_result",
+            toolName: tc.name,
+            content: result.content,
+            isError: result.isError ?? false
+          };
+          toolResultContent.push({
+            type: "tool_result",
+            tool_use_id: tc.id,
+            content: result.content,
+            is_error: result.isError
+          });
+        }
+        workingMessages.push({ role: "user", content: toolResultContent });
+      }
+    } catch (err) {
+      if (signal?.aborted) return;
+      throw err;
+    }
+    if (finalText.length > 0) {
+      this.history.push({ role: "user", content: text });
+      this.history.push({ role: "assistant", content: finalText });
+      void this.runPassiveExtraction(text, finalText);
+    }
+  }
+  // Return a snapshot of the conversation history for the UI to render.
+  // Spread-copy so callers can't mutate the engine's internal state.
+  getHistory() {
+    return [...this.history];
+  }
+  // ── Private ─────────────────────────────────────────────────────────────────
+  // Background knowledge extraction — called after every completed turn.
+  // Uses the fast model (haiku) to keep latency and cost low.
+  // Errors are swallowed — extraction failure must never affect the conversation.
+  async runPassiveExtraction(userMessage, assistantMessage) {
+    if (!assistantMessage) return;
+    try {
+      await extractKnowledge(
+        userMessage,
+        assistantMessage,
+        session.sessionId,
+        this.container.store,
+        this.container.provider,
+        this.container.config.models.fast
+      );
+    } catch {
+    }
+  }
+};
+
+// src/cli/App.tsx
+import { useState, useRef } from "react";
+import { Box as Box3, Text as Text3, useInput, useApp } from "ink";
+
+// src/cli/components/Message.tsx
+import { Box, Text } from "ink";
+
+// src/types/message.ts
+function messageText(content) {
+  if (typeof content === "string") return content;
+  return content.filter((b) => b.type === "text").map((b) => b.text).join("");
+}
+
+// src/cli/components/Message.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function MessageComponent({ message }) {
+  const isUser = message.role === "user";
+  const text = messageText(message.content);
+  if (!text) return null;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx(Text, { color: isUser ? "cyan" : "green", bold: true, children: isUser ? "you" : "zencefyl" }),
+    /* @__PURE__ */ jsx(Box, { marginLeft: 2, children: /* @__PURE__ */ jsx(Text, { children: text }) })
+  ] });
+}
+
+// src/cli/components/StatusBar.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function calculateCost(model, inputTokens, outputTokens) {
+  const pricing = MODEL_PRICING[model];
+  if (!pricing) return 0;
+  return inputTokens / 1e6 * pricing.inputPerM + outputTokens / 1e6 * pricing.outputPerM;
+}
+function formatCost(usd) {
+  if (usd === 0) return "$0.0000";
+  if (usd < 1e-4) return `$${usd.toExponential(2)}`;
+  return `$${usd.toFixed(4)}`;
+}
+function formatTokens(n) {
+  return n.toLocaleString();
+}
+function StatusBar({ mode, inputTokens, outputTokens, model }) {
+  const totalTokens = inputTokens + outputTokens;
+  const cost = calculateCost(model, inputTokens, outputTokens);
+  const width = process.stdout.columns ?? 80;
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\u2500".repeat(width) }),
+    /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      mode,
+      " \xB7 ",
+      formatTokens(totalTokens),
+      " tok \xB7 ",
+      formatCost(cost)
+    ] })
+  ] });
+}
+
+// src/cli/App.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function App({ engine }) {
+  const { exit } = useApp();
+  const [messages, setMessages] = useState([]);
+  const [inputBuffer, setInputBuffer] = useState("");
+  const [isStreaming, setIsStreaming] = useState(false);
+  const [streamText, setStreamText] = useState("");
+  const [toolEvents, setToolEvents] = useState([]);
+  const [error, setError] = useState(null);
+  const [inputTokens, setInputTokens] = useState(0);
+  const [outputTokens, setOutputTokens] = useState(0);
+  const abortRef = useRef(null);
+  const handleSubmit = async (text) => {
+    const trimmed = text.trim();
+    if (!trimmed) return;
+    if (trimmed === "exit" || trimmed === "quit") {
+      exit();
+      return;
+    }
+    setError(null);
+    setIsStreaming(true);
+    setStreamText("");
+    setToolEvents([]);
+    const controller = new AbortController();
+    abortRef.current = controller;
+    let accumulated = "";
+    try {
+      for await (const delta of engine.sendMessage(trimmed, controller.signal)) {
+        if (delta.type === "text") {
+          accumulated += delta.text;
+          setStreamText(accumulated);
+        }
+        if (delta.type === "tool_use") {
+          setToolEvents((prev) => [...prev, { type: "tool_use", name: delta.name }]);
+          accumulated = "";
+          setStreamText("");
+        }
+        if (delta.type === "tool_result") {
+          setToolEvents((prev) => {
+            const updated = [...prev];
+            const last = updated[updated.length - 1];
+            if (last?.name === delta.toolName && last.type === "tool_use") {
+              updated[updated.length - 1] = {
+                type: "tool_result",
+                name: delta.toolName,
+                isError: delta.isError
+              };
+            }
+            return updated;
+          });
+        }
+        if (delta.type === "usage") {
+          setInputTokens((prev) => prev + delta.inputTokens);
+          setOutputTokens((prev) => prev + delta.outputTokens);
+        }
+      }
+    } catch (err) {
+      if (err instanceof Error && err.name !== "AbortError") {
+        setError(err.message);
+      }
+    } finally {
+      setStreamText("");
+      setToolEvents([]);
+      setIsStreaming(false);
+      abortRef.current = null;
+      setMessages(engine.getHistory());
+    }
+  };
+  useInput((input, key) => {
+    if (isStreaming) {
+      if (key.ctrl && input === "c") {
+        abortRef.current?.abort();
+      }
+      return;
+    }
+    if (key.return) {
+      const text = inputBuffer;
+      setInputBuffer("");
+      handleSubmit(text);
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setInputBuffer((prev) => prev.slice(0, -1));
+      return;
+    }
+    if (key.escape || key.ctrl || key.meta) return;
+    if (input) {
+      setInputBuffer((prev) => prev + input);
+    }
+  });
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    messages.length === 0 && !isStreaming && /* @__PURE__ */ jsxs3(Box3, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "green", bold: true, children: "zencefyl" }),
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "  v0.1.0  \xB7  type 'exit' to quit" })
+    ] }),
+    messages.map((msg, i) => /* @__PURE__ */ jsx3(MessageComponent, { message: msg }, i)),
+    isStreaming && /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "green", bold: true, children: "zencefyl" }),
+      toolEvents.map((ev, i) => /* @__PURE__ */ jsxs3(Box3, { marginLeft: 2, children: [
+        ev.type === "tool_use" && /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+          "[",
+          toolLabel(ev.name),
+          "]"
+        ] }),
+        ev.type === "tool_result" && /* @__PURE__ */ jsxs3(Text3, { color: ev.isError ? "red" : "green", dimColor: true, children: [
+          "[",
+          toolLabel(ev.name),
+          " \u2713]"
+        ] })
+      ] }, i)),
+      /* @__PURE__ */ jsx3(Box3, { marginLeft: 2, children: streamText ? /* @__PURE__ */ jsx3(Text3, { children: streamText }) : /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "thinking..." }) })
+    ] }),
+    error && /* @__PURE__ */ jsx3(Box3, { marginBottom: 1, children: /* @__PURE__ */ jsxs3(Text3, { color: "red", children: [
+      "error: ",
+      error
+    ] }) }),
+    !isStreaming && /* @__PURE__ */ jsxs3(Box3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "cyan", bold: true, children: "\u276F " }),
+      /* @__PURE__ */ jsx3(Text3, { children: inputBuffer }),
+      /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: "\u258C" })
+    ] }),
+    /* @__PURE__ */ jsx3(
+      StatusBar,
+      {
+        mode: "normal",
+        inputTokens,
+        outputTokens,
+        model: session.model
+      }
+    )
+  ] });
+}
+function toolLabel(name) {
+  switch (name) {
+    case "read-topic":
+      return "reading knowledge";
+    case "write-topic":
+      return "writing topic";
+    case "log-evidence":
+      return "logging evidence";
+    case "search-topics":
+      return "searching knowledge";
+    default:
+      return `tool: ${name}`;
+  }
+}
+
+// src/cli/index.tsx
+async function main() {
+  let container, engine;
+  try {
+    await runSetupIfNeeded();
+    const config = loadConfig();
+    container = createContainer(config);
+    engine = new Engine(container);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`
+Zencefyl failed to start:
+${message}
+
+`);
+    process.exit(1);
+  }
+  render(createElement(App, { engine }));
+}
+main();
+//# sourceMappingURL=index.js.map