zam-core 0.3.0

package/dist/index.js

@@ -0,0 +1,1920 @@
+// src/kernel/db/connection.ts
+import Database from "libsql";
+import { existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+
+// src/kernel/db/schema.ts
+var SCHEMA = `
+-- Use WAL mode for concurrent reads (AI CLI + user CLI)
+PRAGMA journal_mode = WAL;
+PRAGMA foreign_keys = ON;
+
+-- Knowledge tokens: atomic concepts/facts with Bloom levels
+CREATE TABLE IF NOT EXISTS tokens (
+  id            TEXT PRIMARY KEY,
+  slug          TEXT UNIQUE NOT NULL,
+  concept       TEXT NOT NULL,
+  domain        TEXT NOT NULL DEFAULT '',
+  bloom_level   INTEGER NOT NULL DEFAULT 1 CHECK (bloom_level BETWEEN 1 AND 5),
+  context       TEXT NOT NULL DEFAULT '',
+  symbiosis_mode TEXT CHECK (symbiosis_mode IN ('shadowing', 'copilot', 'autonomy')),
+  created_at    TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at    TEXT NOT NULL DEFAULT (datetime('now')),
+  deprecated_at TEXT
+);
+
+-- Prerequisite dependency graph: "to learn A, first know B"
+CREATE TABLE IF NOT EXISTS prerequisites (
+  token_id    TEXT NOT NULL REFERENCES tokens(id) ON DELETE CASCADE,
+  requires_id TEXT NOT NULL REFERENCES tokens(id) ON DELETE CASCADE,
+  PRIMARY KEY (token_id, requires_id)
+);
+
+-- Per-user scheduling state for each token (FSRS fields)
+CREATE TABLE IF NOT EXISTS cards (
+  id            TEXT PRIMARY KEY,
+  token_id      TEXT NOT NULL REFERENCES tokens(id) ON DELETE CASCADE,
+  user_id       TEXT NOT NULL,
+  stability     REAL NOT NULL DEFAULT 0.0,
+  difficulty    REAL NOT NULL DEFAULT 0.5,
+  elapsed_days  REAL NOT NULL DEFAULT 0.0,
+  scheduled_days REAL NOT NULL DEFAULT 0.0,
+  reps          INTEGER NOT NULL DEFAULT 0,
+  lapses        INTEGER NOT NULL DEFAULT 0,
+  state         TEXT NOT NULL DEFAULT 'new' CHECK (state IN ('new', 'learning', 'review', 'relearning')),
+  due_at        TEXT NOT NULL DEFAULT (datetime('now')),
+  last_review_at TEXT,
+  blocked       INTEGER NOT NULL DEFAULT 0,
+  UNIQUE(token_id, user_id)
+);
+
+-- Immutable review log: every rating event
+CREATE TABLE IF NOT EXISTS review_logs (
+  id              TEXT PRIMARY KEY,
+  card_id         TEXT NOT NULL REFERENCES cards(id) ON DELETE CASCADE,
+  token_id        TEXT NOT NULL REFERENCES tokens(id) ON DELETE CASCADE,
+  user_id         TEXT NOT NULL,
+  rating          INTEGER NOT NULL CHECK (rating BETWEEN 1 AND 4),
+  response_time_ms INTEGER,
+  reviewed_at     TEXT NOT NULL DEFAULT (datetime('now')),
+  scheduled_at    TEXT NOT NULL,
+  session_id      TEXT REFERENCES sessions(id)
+);
+
+-- Work+learning sessions
+CREATE TABLE IF NOT EXISTS sessions (
+  id            TEXT PRIMARY KEY,
+  user_id       TEXT NOT NULL,
+  task          TEXT NOT NULL,
+  started_at    TEXT NOT NULL DEFAULT (datetime('now')),
+  completed_at  TEXT
+);
+
+-- Steps within a session: who did what
+CREATE TABLE IF NOT EXISTS session_steps (
+  id          TEXT PRIMARY KEY,
+  session_id  TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  token_id    TEXT NOT NULL REFERENCES tokens(id) ON DELETE CASCADE,
+  done_by     TEXT NOT NULL CHECK (done_by IN ('user', 'agent')),
+  rating      INTEGER CHECK (rating BETWEEN 1 AND 4),
+  notes       TEXT,
+  created_at  TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+-- User configuration
+CREATE TABLE IF NOT EXISTS user_config (
+  key         TEXT PRIMARY KEY,
+  value       TEXT NOT NULL,
+  updated_at  TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+-- Agent skills: task recipes the agent learns from user guidance
+CREATE TABLE IF NOT EXISTS agent_skills (
+  id          TEXT PRIMARY KEY,
+  slug        TEXT NOT NULL UNIQUE,
+  description TEXT NOT NULL,
+  steps       TEXT NOT NULL DEFAULT '[]',       -- JSON array of step strings
+  token_slugs TEXT NOT NULL DEFAULT '[]',       -- JSON array of related token slugs
+  source      TEXT NOT NULL DEFAULT 'learned'
+    CHECK(source IN ('learned', 'builtin')),
+  created_at  TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at  TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+-- Performance indexes
+CREATE INDEX IF NOT EXISTS idx_tokens_domain ON tokens(domain);
+CREATE INDEX IF NOT EXISTS idx_tokens_slug ON tokens(slug);
+CREATE INDEX IF NOT EXISTS idx_prereqs_token ON prerequisites(token_id);
+CREATE INDEX IF NOT EXISTS idx_prereqs_requires ON prerequisites(requires_id);
+CREATE INDEX IF NOT EXISTS idx_cards_user_due ON cards(user_id, blocked, due_at);
+CREATE INDEX IF NOT EXISTS idx_cards_token_user ON cards(token_id, user_id);
+CREATE INDEX IF NOT EXISTS idx_review_logs_card ON review_logs(card_id);
+CREATE INDEX IF NOT EXISTS idx_review_logs_user ON review_logs(user_id, reviewed_at);
+CREATE INDEX IF NOT EXISTS idx_session_steps_session ON session_steps(session_id);
+`;
+
+// src/kernel/db/connection.ts
+var DEFAULT_DB_DIR = join(homedir(), ".zam");
+var DEFAULT_DB_PATH = join(DEFAULT_DB_DIR, "zam.db");
+function openDatabase(options = {}) {
+  const dbPath = options.dbPath ?? DEFAULT_DB_PATH;
+  if (options.initialize) {
+    const dir = dirname(dbPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+  const dbOpts = {};
+  if (options.syncUrl) {
+    dbOpts.syncUrl = options.syncUrl;
+  }
+  if (options.authToken) {
+    dbOpts.authToken = options.authToken;
+  }
+  const db = new Database(dbPath, dbOpts);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.pragma("busy_timeout = 5000");
+  if (options.initialize) {
+    db.exec(SCHEMA);
+  }
+  runMigrations(db);
+  if (options.syncUrl) {
+    db.sync();
+  }
+  return db;
+}
+function openDatabaseWithSync(options = {}) {
+  const db = openDatabase(options);
+  const syncUrl = db.prepare("SELECT value FROM user_config WHERE key = ?").get("turso.url");
+  const authToken = db.prepare("SELECT value FROM user_config WHERE key = ?").get("turso.token");
+  if (!syncUrl || !authToken) return db;
+  db.close();
+  return openDatabase({ ...options, syncUrl: syncUrl.value, authToken: authToken.value });
+}
+function getDefaultDbPath() {
+  return DEFAULT_DB_PATH;
+}
+function runMigrations(db) {
+  const sessionCols = db.pragma("table_info(sessions)");
+  if (sessionCols.length > 0 && !sessionCols.some((c) => c.name === "execution_context")) {
+    db.exec(
+      `ALTER TABLE sessions ADD COLUMN execution_context TEXT NOT NULL DEFAULT 'shell'`
+    );
+  }
+  const tokenCols = db.pragma("table_info(tokens)");
+  if (tokenCols.length > 0 && !tokenCols.some((c) => c.name === "deprecated_at")) {
+    db.exec(`ALTER TABLE tokens ADD COLUMN deprecated_at TEXT`);
+  }
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS agent_skills (
+      id          TEXT PRIMARY KEY,
+      slug        TEXT NOT NULL UNIQUE,
+      description TEXT NOT NULL,
+      steps       TEXT NOT NULL DEFAULT '[]',
+      token_slugs TEXT NOT NULL DEFAULT '[]',
+      source      TEXT NOT NULL DEFAULT 'learned',
+      created_at  TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at  TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+}
+
+// src/kernel/models/token.ts
+import { ulid } from "ulid";
+function createToken(db, input) {
+  const id = ulid();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const bloom = input.bloom_level ?? 1;
+  if (bloom < 1 || bloom > 5) {
+    throw new Error(`bloom_level must be between 1 and 5, got ${bloom}`);
+  }
+  db.prepare(`
+    INSERT INTO tokens (id, slug, concept, domain, bloom_level, context, symbiosis_mode, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    id,
+    input.slug,
+    input.concept,
+    input.domain ?? "",
+    bloom,
+    input.context ?? "",
+    input.symbiosis_mode ?? null,
+    now,
+    now
+  );
+  return getTokenById(db, id);
+}
+function getTokenBySlug(db, slug) {
+  return db.prepare("SELECT * FROM tokens WHERE slug = ?").get(slug);
+}
+function getTokenById(db, id) {
+  return db.prepare("SELECT * FROM tokens WHERE id = ?").get(id);
+}
+function deprecateToken(db, slug) {
+  const token = getTokenBySlug(db, slug);
+  if (!token) {
+    throw new Error(`Token not found: ${slug}`);
+  }
+  if (token.deprecated_at) {
+    throw new Error(`Token already deprecated: ${slug}`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare("UPDATE tokens SET deprecated_at = ?, updated_at = ? WHERE slug = ?").run(
+    now,
+    now,
+    slug
+  );
+  return getTokenBySlug(db, slug);
+}
+function findTokens(db, query) {
+  const normalised = query.toLowerCase();
+  const qTokens = new Set(
+    normalised.split(/[\s,.\-_/\\:;!?()\[\]{}]+/).filter((t) => t.length > 2)
+  );
+  const tokens = db.prepare("SELECT * FROM tokens WHERE deprecated_at IS NULL").all();
+  const scored = [];
+  for (const t of tokens) {
+    const words = (t.slug + " " + t.concept + " " + t.domain).toLowerCase().split(/[\s,.\-_/\\:;!?()\[\]{}]+/).filter(Boolean);
+    let score = 0;
+    for (const w of words) {
+      if (qTokens.has(w)) score++;
+    }
+    if (t.concept.toLowerCase().includes(normalised.slice(0, 25))) {
+      score += 3;
+    }
+    if (score > 0) {
+      scored.push({ score, ...t });
+    }
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return scored;
+}
+function listTokens(db, options) {
+  if (options?.domain) {
+    return db.prepare(
+      "SELECT * FROM tokens WHERE domain = ? AND deprecated_at IS NULL ORDER BY bloom_level, slug"
+    ).all(options.domain);
+  }
+  return db.prepare(
+    "SELECT * FROM tokens WHERE deprecated_at IS NULL ORDER BY bloom_level, domain, slug"
+  ).all();
+}
+
+// src/kernel/models/prerequisite.ts
+function addPrerequisite(db, tokenId, requiresId) {
+  if (tokenId === requiresId) {
+    throw new Error("A token cannot be a prerequisite of itself");
+  }
+  db.prepare(
+    "INSERT OR IGNORE INTO prerequisites (token_id, requires_id) VALUES (?, ?)"
+  ).run(tokenId, requiresId);
+}
+function getPrerequisites(db, tokenId) {
+  return db.prepare(
+    `SELECT p.token_id, p.requires_id, t.slug, t.concept, t.domain, t.bloom_level
+       FROM prerequisites p
+       JOIN tokens t ON t.id = p.requires_id
+       WHERE p.token_id = ?`
+  ).all(tokenId);
+}
+function getDependents(db, tokenId) {
+  return db.prepare(
+    `SELECT p.token_id, p.requires_id, t.slug, t.concept, t.domain, t.bloom_level
+       FROM prerequisites p
+       JOIN tokens t ON t.id = p.token_id
+       WHERE p.requires_id = ?`
+  ).all(tokenId);
+}
+
+// src/kernel/models/card.ts
+import { ulid as ulid2 } from "ulid";
+function ensureCard(db, tokenId, userId) {
+  const existing = db.prepare("SELECT * FROM cards WHERE token_id = ? AND user_id = ?").get(tokenId, userId);
+  if (existing) return existing;
+  const id = ulid2();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(
+    `INSERT INTO cards (id, token_id, user_id, due_at)
+     VALUES (?, ?, ?, ?)`
+  ).run(id, tokenId, userId, now);
+  return db.prepare("SELECT * FROM cards WHERE id = ?").get(id);
+}
+function getCard(db, tokenId, userId) {
+  return db.prepare("SELECT * FROM cards WHERE token_id = ? AND user_id = ?").get(tokenId, userId);
+}
+function updateCard(db, cardId, updates) {
+  const fields = [];
+  const values = [];
+  if (updates.stability !== void 0) {
+    fields.push("stability = ?");
+    values.push(updates.stability);
+  }
+  if (updates.difficulty !== void 0) {
+    fields.push("difficulty = ?");
+    values.push(updates.difficulty);
+  }
+  if (updates.elapsed_days !== void 0) {
+    fields.push("elapsed_days = ?");
+    values.push(updates.elapsed_days);
+  }
+  if (updates.scheduled_days !== void 0) {
+    fields.push("scheduled_days = ?");
+    values.push(updates.scheduled_days);
+  }
+  if (updates.reps !== void 0) {
+    fields.push("reps = ?");
+    values.push(updates.reps);
+  }
+  if (updates.lapses !== void 0) {
+    fields.push("lapses = ?");
+    values.push(updates.lapses);
+  }
+  if (updates.state !== void 0) {
+    fields.push("state = ?");
+    values.push(updates.state);
+  }
+  if (updates.due_at !== void 0) {
+    fields.push("due_at = ?");
+    values.push(updates.due_at);
+  }
+  if (updates.last_review_at !== void 0) {
+    fields.push("last_review_at = ?");
+    values.push(updates.last_review_at);
+  }
+  if (updates.blocked !== void 0) {
+    fields.push("blocked = ?");
+    values.push(updates.blocked);
+  }
+  if (fields.length === 0) {
+    throw new Error("updateCard called with no fields to update");
+  }
+  values.push(cardId);
+  const result = db.prepare(`UPDATE cards SET ${fields.join(", ")} WHERE id = ?`).run(...values);
+  if (result.changes === 0) {
+    throw new Error(`Card not found: ${cardId}`);
+  }
+  return db.prepare("SELECT * FROM cards WHERE id = ?").get(cardId);
+}
+function getDueCards(db, userId, now) {
+  const cutoff = now ?? (/* @__PURE__ */ new Date()).toISOString();
+  return db.prepare(
+    `SELECT c.*, t.slug, t.concept, t.domain, t.bloom_level
+       FROM cards c
+       JOIN tokens t ON t.id = c.token_id
+       WHERE c.user_id = ? AND c.blocked = 0 AND c.due_at <= ?
+       ORDER BY t.bloom_level ASC, c.due_at ASC`
+  ).all(userId, cutoff);
+}
+function getBlockedCards(db, userId) {
+  return db.prepare(
+    `SELECT c.*, t.slug, t.concept, t.domain, t.bloom_level
+       FROM cards c
+       JOIN tokens t ON t.id = c.token_id
+       WHERE c.user_id = ? AND c.blocked = 1
+       ORDER BY t.bloom_level ASC, t.slug ASC`
+  ).all(userId);
+}
+
+// src/kernel/models/review.ts
+import { ulid as ulid3 } from "ulid";
+function logReview(db, input) {
+  if (input.rating < 1 || input.rating > 4) {
+    throw new Error(`Rating must be between 1 and 4, got ${input.rating}`);
+  }
+  const id = ulid3();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(
+    `INSERT INTO review_logs (id, card_id, token_id, user_id, rating, response_time_ms, reviewed_at, scheduled_at, session_id)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    id,
+    input.card_id,
+    input.token_id,
+    input.user_id,
+    input.rating,
+    input.response_time_ms ?? null,
+    now,
+    input.scheduled_at,
+    input.session_id ?? null
+  );
+  return db.prepare("SELECT * FROM review_logs WHERE id = ?").get(id);
+}
+function getReviewsForCard(db, cardId) {
+  return db.prepare(
+    "SELECT * FROM review_logs WHERE card_id = ? ORDER BY reviewed_at ASC"
+  ).all(cardId);
+}
+function getReviewsForUser(db, userId, options) {
+  const conditions = ["user_id = ?"];
+  const params = [userId];
+  if (options?.after) {
+    conditions.push("reviewed_at > ?");
+    params.push(options.after);
+  }
+  if (options?.before) {
+    conditions.push("reviewed_at < ?");
+    params.push(options.before);
+  }
+  let sql = `SELECT * FROM review_logs WHERE ${conditions.join(" AND ")} ORDER BY reviewed_at DESC`;
+  if (options?.limit) {
+    sql += " LIMIT ?";
+    params.push(options.limit);
+  }
+  return db.prepare(sql).all(...params);
+}
+
+// src/kernel/models/session.ts
+import { ulid as ulid4 } from "ulid";
+function startSession(db, input) {
+  const id = ulid4();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const ctx = input.execution_context ?? "shell";
+  db.prepare(
+    `INSERT INTO sessions (id, user_id, task, execution_context, started_at)
+     VALUES (?, ?, ?, ?, ?)`
+  ).run(id, input.user_id, input.task, ctx, now);
+  return db.prepare("SELECT * FROM sessions WHERE id = ?").get(id);
+}
+function endSession(db, sessionId) {
+  const session = db.prepare("SELECT * FROM sessions WHERE id = ?").get(sessionId);
+  if (!session) {
+    throw new Error(`Session not found: ${sessionId}`);
+  }
+  if (session.completed_at) {
+    throw new Error(`Session already completed: ${sessionId}`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare("UPDATE sessions SET completed_at = ? WHERE id = ?").run(now, sessionId);
+  return db.prepare("SELECT * FROM sessions WHERE id = ?").get(sessionId);
+}
+function logStep(db, input) {
+  if (input.done_by !== "user" && input.done_by !== "agent") {
+    throw new Error(`done_by must be 'user' or 'agent', got '${input.done_by}'`);
+  }
+  if (input.rating != null && (input.rating < 1 || input.rating > 4)) {
+    throw new Error(`Rating must be between 1 and 4, got ${input.rating}`);
+  }
+  const session = db.prepare("SELECT id FROM sessions WHERE id = ?").get(input.session_id);
+  if (!session) {
+    throw new Error(`Session not found: ${input.session_id}`);
+  }
+  const id = ulid4();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(
+    `INSERT INTO session_steps (id, session_id, token_id, done_by, rating, notes, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    id,
+    input.session_id,
+    input.token_id,
+    input.done_by,
+    input.rating ?? null,
+    input.notes ?? null,
+    now
+  );
+  return db.prepare("SELECT * FROM session_steps WHERE id = ?").get(id);
+}
+function getSessionSummary(db, sessionId) {
+  const session = db.prepare("SELECT * FROM sessions WHERE id = ?").get(sessionId);
+  if (!session) {
+    throw new Error(`Session not found: ${sessionId}`);
+  }
+  const steps = db.prepare(
+    `SELECT ss.*, t.slug, t.concept, t.domain, t.bloom_level
+       FROM session_steps ss
+       JOIN tokens t ON t.id = ss.token_id
+       WHERE ss.session_id = ?
+       ORDER BY ss.created_at ASC`
+  ).all(sessionId);
+  return { session, steps };
+}
+
+// src/kernel/models/agent-skill.ts
+import { ulid as ulid5 } from "ulid";
+function parseRow(row) {
+  return {
+    ...row,
+    steps: JSON.parse(row.steps),
+    token_slugs: JSON.parse(row.token_slugs)
+  };
+}
+function createAgentSkill(db, input) {
+  const existing = db.prepare("SELECT * FROM agent_skills WHERE slug = ?").get(input.slug);
+  if (existing) {
+    throw new Error(`Agent skill already exists: ${input.slug}`);
+  }
+  const id = ulid5();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(
+    `INSERT INTO agent_skills (id, slug, description, steps, token_slugs, source, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    id,
+    input.slug,
+    input.description,
+    JSON.stringify(input.steps),
+    JSON.stringify(input.token_slugs ?? []),
+    input.source ?? "learned",
+    now,
+    now
+  );
+  return parseRow(
+    db.prepare("SELECT * FROM agent_skills WHERE id = ?").get(id)
+  );
+}
+function getAgentSkill(db, slug) {
+  const row = db.prepare("SELECT * FROM agent_skills WHERE slug = ?").get(slug);
+  return row ? parseRow(row) : void 0;
+}
+function listAgentSkills(db) {
+  const rows = db.prepare("SELECT * FROM agent_skills ORDER BY created_at ASC").all();
+  return rows.map(parseRow);
+}
+
+// src/kernel/models/settings.ts
+function getSetting(db, key) {
+  const row = db.prepare("SELECT value FROM user_config WHERE key = ?").get(key);
+  return row?.value;
+}
+function getAllSettings(db) {
+  const rows = db.prepare("SELECT key, value FROM user_config ORDER BY key").all();
+  const map = {};
+  for (const row of rows) {
+    map[row.key] = row.value;
+  }
+  return map;
+}
+function getAllSettingsDetailed(db) {
+  return db.prepare("SELECT key, value, updated_at FROM user_config ORDER BY key").all();
+}
+function setSetting(db, key, value) {
+  db.prepare(
+    `INSERT INTO user_config (key, value, updated_at)
+     VALUES (?, ?, datetime('now'))
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`
+  ).run(key, value);
+}
+function deleteSetting(db, key) {
+  const result = db.prepare("DELETE FROM user_config WHERE key = ?").run(key);
+  return result.changes > 0;
+}
+
+// src/kernel/scheduler/fsrs.ts
+var DEFAULT_W = [
+  0.4072,
+  1.1829,
+  3.1262,
+  15.4722,
+  // w0–w3:  initial stability per rating
+  7.2102,
+  0.5316,
+  1.0651,
+  // w4–w6:  difficulty
+  92e-4,
+  1.5988,
+  0.1176,
+  1.0014,
+  // w7–w10: stability after forgetting
+  2.0032,
+  0.0266,
+  0.3077,
+  0.15,
+  // w11–w14: stability increase
+  0,
+  2.7849,
+  0.3477,
+  0.6831
+  // w15–w18: additional parameters
+];
+var DEFAULT_REQUEST_RETENTION = 0.9;
+function clamp(value, lo, hi) {
+  return Math.min(hi, Math.max(lo, value));
+}
+function daysBetween(a, b) {
+  return (b.getTime() - a.getTime()) / (1e3 * 60 * 60 * 24);
+}
+function initialStability(w, rating) {
+  return w[rating - 1];
+}
+function initialDifficulty(w, rating) {
+  return clamp(w[4] - Math.exp(w[5] * (rating - 1)) + 1, 1, 10);
+}
+function nextDifficulty(w, d, rating) {
+  const d0ForGood = initialDifficulty(w, 3);
+  const updated = w[7] * d0ForGood + (1 - w[7]) * (d - w[6] * (rating - 3));
+  return clamp(updated, 1, 10);
+}
+function retrievability(elapsed, stability) {
+  if (stability <= 0) return 0;
+  return Math.pow(1 + elapsed / (9 * stability), -1);
+}
+function stabilityAfterSuccess(w, s, d, r, rating) {
+  const hardPenalty = rating === 2 ? w[15] : 1;
+  const easyBonus = rating === 4 ? w[16] : 1;
+  const inner = Math.exp(w[8]) * (11 - d) * Math.pow(s, -w[9]) * (Math.exp(w[10] * (1 - r)) - 1) * hardPenalty * easyBonus;
+  return s * (inner + 1);
+}
+function stabilityAfterForgetting(w, s, d, r) {
+  return w[11] * Math.pow(d, -w[12]) * (Math.pow(s + 1, w[13]) - 1) * Math.exp(w[14] * (1 - r));
+}
+function nextInterval(stability, requestRetention) {
+  const interval = 9 * stability * (1 / requestRetention - 1);
+  return Math.max(1, Math.round(interval));
+}
+function createFSRS(params) {
+  const resolvedParams = {
+    w: params?.w ?? [...DEFAULT_W],
+    requestRetention: params?.requestRetention ?? DEFAULT_REQUEST_RETENTION
+  };
+  function schedule(card, rating, now) {
+    const reviewTime = now ?? /* @__PURE__ */ new Date();
+    const w = resolvedParams.w;
+    const elapsed = card.lastReviewAt !== null ? Math.max(0, daysBetween(card.lastReviewAt, reviewTime)) : 0;
+    if (card.state === "new") {
+      const s = initialStability(w, rating);
+      const d = initialDifficulty(w, rating);
+      const interval2 = nextInterval(s, resolvedParams.requestRetention);
+      const dueAt2 = new Date(reviewTime);
+      dueAt2.setDate(dueAt2.getDate() + interval2);
+      return {
+        stability: s,
+        difficulty: d,
+        elapsedDays: 0,
+        scheduledDays: interval2,
+        reps: rating >= 2 ? 1 : 0,
+        lapses: rating === 1 ? 1 : 0,
+        state: "learning",
+        dueAt: dueAt2,
+        lastReviewAt: reviewTime
+      };
+    }
+    const r = retrievability(elapsed, card.stability);
+    let newStability;
+    let newDifficulty;
+    let newReps;
+    let newLapses;
+    let newState;
+    if (rating === 1) {
+      newStability = stabilityAfterForgetting(w, card.stability, card.difficulty, r);
+      newDifficulty = nextDifficulty(w, card.difficulty, rating);
+      newReps = 0;
+      newLapses = card.lapses + 1;
+      newState = "relearning";
+    } else {
+      newStability = stabilityAfterSuccess(w, card.stability, card.difficulty, r, rating);
+      newDifficulty = nextDifficulty(w, card.difficulty, rating);
+      newReps = card.reps + 1;
+      newLapses = card.lapses;
+      newState = "review";
+    }
+    const interval = nextInterval(newStability, resolvedParams.requestRetention);
+    const dueAt = new Date(reviewTime);
+    dueAt.setDate(dueAt.getDate() + interval);
+    return {
+      stability: newStability,
+      difficulty: newDifficulty,
+      elapsedDays: elapsed,
+      scheduledDays: interval,
+      reps: newReps,
+      lapses: newLapses,
+      state: newState,
+      dueAt,
+      lastReviewAt: reviewTime
+    };
+  }
+  return {
+    schedule,
+    params: Object.freeze(resolvedParams)
+  };
+}
+
+// src/kernel/scheduler/blocker.ts
+function cascadeBlock(db, userId, tokenSlug) {
+  const token = getTokenBySlug(db, tokenSlug);
+  if (!token) {
+    throw new Error(`Unknown token slug: ${tokenSlug}`);
+  }
+  ensureCard(db, token.id, userId);
+  db.prepare(
+    "UPDATE cards SET blocked = 1 WHERE token_id = ? AND user_id = ?"
+  ).run(token.id, userId);
+  const prereqs = getPrerequisites(db, token.id);
+  const surfaced = [];
+  for (const prereq of prereqs) {
+    const card = ensureCard(db, prereq.requires_id, userId);
+    if (card.blocked === 1) {
+      const prereqOfPrereq = db.prepare("SELECT COUNT(*) as n FROM prerequisites WHERE token_id = ?").get(prereq.requires_id);
+      if (prereqOfPrereq.n === 0) {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        db.prepare(
+          "UPDATE cards SET blocked = 0, due_at = ? WHERE token_id = ? AND user_id = ?"
+        ).run(now, prereq.requires_id, userId);
+      }
+    }
+    surfaced.push({
+      slug: prereq.slug,
+      concept: prereq.concept,
+      bloomLevel: prereq.bloom_level
+    });
+  }
+  return {
+    blockedSlug: tokenSlug,
+    prerequisites: surfaced
+  };
+}
+function unblockReady(db, userId) {
+  const blockedCards = db.prepare(
+    `SELECT c.token_id, t.slug, t.concept
+       FROM cards c
+       JOIN tokens t ON t.id = c.token_id
+       WHERE c.user_id = ? AND c.blocked = 1`
+  ).all(userId);
+  const unblocked = [];
+  for (const card of blockedCards) {
+    const totalPrereqs = db.prepare("SELECT COUNT(*) as n FROM prerequisites WHERE token_id = ?").get(card.token_id);
+    const metPrereqs = db.prepare(
+      `SELECT COUNT(*) as n FROM cards c
+         JOIN prerequisites p ON p.requires_id = c.token_id
+         WHERE p.token_id = ? AND c.user_id = ? AND c.reps >= 1 AND c.blocked = 0`
+    ).get(card.token_id, userId);
+    if (totalPrereqs.n === 0 || metPrereqs.n === totalPrereqs.n) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      db.prepare(
+        "UPDATE cards SET blocked = 0, due_at = ? WHERE token_id = ? AND user_id = ?"
+      ).run(now, card.token_id, userId);
+      unblocked.push({ slug: card.slug, concept: card.concept });
+    }
+  }
+  return { unblocked };
+}
+
+// src/kernel/scheduler/interleaver.ts
+function interleave(items, maxConsecutive = 2) {
+  if (items.length <= 1) return [...items];
+  const byDomain = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const group = byDomain.get(item.domain);
+    if (group) {
+      group.push(item);
+    } else {
+      byDomain.set(item.domain, [item]);
+    }
+  }
+  if (byDomain.size === 1) return [...items];
+  const result = [];
+  let consecutiveCount = 0;
+  let lastDomain = null;
+  const cursors = /* @__PURE__ */ new Map();
+  for (const domain of byDomain.keys()) {
+    cursors.set(domain, 0);
+  }
+  while (result.length < items.length) {
+    const activeDomains = [...byDomain.entries()].filter(([domain]) => cursors.get(domain) < byDomain.get(domain).length).sort((a, b) => {
+      const remainA = a[1].length - cursors.get(a[0]);
+      const remainB = b[1].length - cursors.get(b[0]);
+      return remainB - remainA;
+    });
+    if (activeDomains.length === 0) break;
+    let pickedThisRound = false;
+    for (const [domain, group] of activeDomains) {
+      const cursor = cursors.get(domain);
+      if (cursor >= group.length) continue;
+      if (domain === lastDomain && consecutiveCount >= maxConsecutive) {
+        continue;
+      }
+      result.push(group[cursor]);
+      cursors.set(domain, cursor + 1);
+      pickedThisRound = true;
+      if (domain === lastDomain) {
+        consecutiveCount++;
+      } else {
+        lastDomain = domain;
+        consecutiveCount = 1;
+      }
+      break;
+    }
+    if (!pickedThisRound) {
+      for (const [domain, group] of activeDomains) {
+        const cursor = cursors.get(domain);
+        if (cursor >= group.length) continue;
+        result.push(group[cursor]);
+        cursors.set(domain, cursor + 1);
+        if (domain === lastDomain) {
+          consecutiveCount++;
+        } else {
+          lastDomain = domain;
+          consecutiveCount = 1;
+        }
+        break;
+      }
+    }
+  }
+  return result;
+}
+
+// src/kernel/scheduler/queue.ts
+function buildReviewQueue(db, options) {
+  const maxNew = options.maxNew ?? 10;
+  const maxReviews = options.maxReviews ?? 50;
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const nowISO = now.toISOString();
+  const dueRows = db.prepare(
+    `SELECT
+         c.id       AS card_id,
+         c.token_id AS token_id,
+         t.slug     AS slug,
+         t.concept  AS concept,
+         t.domain   AS domain,
+         t.bloom_level AS bloom_level,
+         c.state    AS state,
+         c.due_at   AS due_at
+       FROM cards c
+       JOIN tokens t ON t.id = c.token_id
+       WHERE c.user_id = ?
+         AND c.blocked = 0
+         AND c.due_at <= ?
+         AND c.state IN ('review', 'relearning', 'learning')
+         AND t.deprecated_at IS NULL
+       ORDER BY c.due_at ASC`
+  ).all(options.userId, nowISO);
+  const newRows = db.prepare(
+    `SELECT
+         c.id       AS card_id,
+         c.token_id AS token_id,
+         t.slug     AS slug,
+         t.concept  AS concept,
+         t.domain   AS domain,
+         t.bloom_level AS bloom_level,
+         c.state    AS state,
+         c.due_at   AS due_at
+       FROM cards c
+       JOIN tokens t ON t.id = c.token_id
+       WHERE c.user_id = ?
+         AND c.blocked = 0
+         AND c.state = 'new'
+         AND t.deprecated_at IS NULL
+       ORDER BY t.bloom_level ASC, t.slug ASC
+       LIMIT ?`
+  ).all(options.userId, maxNew);
+  const nowMs = now.getTime();
+  const sortedDue = [...dueRows].sort((a, b) => {
+    const overdueA = nowMs - new Date(a.due_at).getTime();
+    const overdueB = nowMs - new Date(b.due_at).getTime();
+    return overdueB - overdueA;
+  });
+  const interleavedDue = interleave(
+    sortedDue.map((row) => ({ ...rowToItem(row), domain: row.domain }))
+  );
+  const newItems = newRows.map(rowToItem);
+  const merged = intersperseNew(interleavedDue, newItems, 5);
+  const capped = merged.slice(0, maxReviews);
+  let newCount = 0;
+  let reviewCount = 0;
+  let relearnCount = 0;
+  const domainSet = /* @__PURE__ */ new Set();
+  for (const item of capped) {
+    domainSet.add(item.domain);
+    switch (item.state) {
+      case "new":
+        newCount++;
+        break;
+      case "relearning":
+        relearnCount++;
+        break;
+      default:
+        reviewCount++;
+        break;
+    }
+  }
+  return {
+    items: capped,
+    newCount,
+    reviewCount,
+    relearnCount,
+    totalDomains: [...domainSet].sort()
+  };
+}
+function rowToItem(row) {
+  return {
+    cardId: row.card_id,
+    tokenId: row.token_id,
+    slug: row.slug,
+    concept: row.concept,
+    domain: row.domain,
+    bloomLevel: row.bloom_level,
+    state: row.state,
+    dueAt: row.due_at
+  };
+}
+function intersperseNew(reviews, newCards, interval) {
+  if (newCards.length === 0) return [...reviews];
+  if (reviews.length === 0) return [...newCards];
+  const result = [];
+  let reviewIdx = 0;
+  let newIdx = 0;
+  let position = 0;
+  while (reviewIdx < reviews.length || newIdx < newCards.length) {
+    if (newIdx < newCards.length && position > 0 && position % interval === interval - 1) {
+      result.push(newCards[newIdx]);
+      newIdx++;
+    } else if (reviewIdx < reviews.length) {
+      result.push(reviews[reviewIdx]);
+      reviewIdx++;
+    } else if (newIdx < newCards.length) {
+      result.push(newCards[newIdx]);
+      newIdx++;
+    }
+    position++;
+  }
+  return result;
+}
+
+// src/kernel/recall/prompter.ts
+var BLOOM_VERBS = {
+  1: "Remember",
+  2: "Understand",
+  3: "Apply",
+  4: "Analyze",
+  5: "Synthesize"
+};
+var BLOOM_PROMPTS = {
+  1: (c) => `What is: ${c}?`,
+  2: (c) => `Explain how this works: ${c}`,
+  3: (c) => `Apply this concept: ${c}`,
+  4: (c) => `Analyze the trade-offs: ${c}`,
+  5: (c) => `Design a solution using: ${c}`
+};
+function generatePrompt(input) {
+  const bloom = input.bloomLevel >= 1 && input.bloomLevel <= 5 ? input.bloomLevel : 1;
+  return {
+    cardId: input.cardId,
+    tokenId: input.tokenId,
+    slug: input.slug,
+    question: BLOOM_PROMPTS[bloom](input.concept),
+    concept: input.concept,
+    domain: input.domain,
+    bloomLevel: bloom,
+    bloomVerb: BLOOM_VERBS[bloom],
+    hints: []
+  };
+}
+
+// src/kernel/recall/evaluator.ts
+import { ulid as ulid6 } from "ulid";
+function evaluateRating(db, input) {
+  const card = db.prepare("SELECT * FROM cards WHERE id = ?").get(input.cardId);
+  if (!card) {
+    throw new Error(`Card not found: ${input.cardId}`);
+  }
+  const now = /* @__PURE__ */ new Date();
+  const fsrs = createFSRS();
+  const schedulingCard = {
+    stability: card.stability,
+    difficulty: card.difficulty,
+    elapsedDays: card.elapsed_days,
+    scheduledDays: card.scheduled_days,
+    reps: card.reps,
+    lapses: card.lapses,
+    state: card.state,
+    dueAt: new Date(card.due_at),
+    lastReviewAt: card.last_review_at ? new Date(card.last_review_at) : null
+  };
+  const updated = fsrs.schedule(schedulingCard, input.rating, now);
+  updateCard(db, input.cardId, {
+    stability: updated.stability,
+    difficulty: updated.difficulty,
+    elapsed_days: updated.elapsedDays,
+    scheduled_days: updated.scheduledDays,
+    reps: updated.reps,
+    lapses: updated.lapses,
+    state: updated.state,
+    due_at: updated.dueAt.toISOString(),
+    last_review_at: now.toISOString()
+  });
+  db.prepare(
+    `INSERT INTO review_logs (id, card_id, token_id, user_id, rating, response_time_ms, reviewed_at, scheduled_at, session_id)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    ulid6(),
+    input.cardId,
+    input.tokenId,
+    input.userId,
+    input.rating,
+    input.responseTimeMs ?? null,
+    now.toISOString(),
+    card.due_at,
+    input.sessionId ?? null
+  );
+  return {
+    nextDueAt: updated.dueAt.toISOString(),
+    stability: updated.stability,
+    difficulty: updated.difficulty,
+    state: updated.state,
+    scheduledDays: updated.scheduledDays,
+    reps: updated.reps,
+    lapses: updated.lapses
+  };
+}
+
+// src/kernel/analytics/stats.ts
+function q(db, sql, ...params) {
+  return db.prepare(sql).get(...params);
+}
+function getUserStats(db, userId) {
+  return {
+    userId,
+    totalTokens: q(db, "SELECT COUNT(*) as n FROM tokens").n,
+    cardsInDeck: q(db, "SELECT COUNT(*) as n FROM cards WHERE user_id = ?", userId).n,
+    dueToday: q(
+      db,
+      "SELECT COUNT(*) as n FROM cards WHERE user_id = ? AND blocked = 0 AND due_at <= datetime('now')",
+      userId
+    ).n,
+    blocked: q(db, "SELECT COUNT(*) as n FROM cards WHERE user_id = ? AND blocked = 1", userId).n,
+    mature: q(
+      db,
+      "SELECT COUNT(*) as n FROM cards WHERE user_id = ? AND reps >= 3 AND stability >= 21",
+      userId
+    ).n,
+    avgStability: (() => {
+      const v = q(db, "SELECT AVG(stability) as v FROM cards WHERE user_id = ? AND reps > 0", userId);
+      return v.v ? Math.round(v.v * 100) / 100 : null;
+    })(),
+    totalSessions: q(db, "SELECT COUNT(*) as n FROM sessions WHERE user_id = ?", userId).n,
+    lastSession: (() => {
+      const r = db.prepare(
+        "SELECT started_at FROM sessions WHERE user_id = ? ORDER BY started_at DESC LIMIT 1"
+      ).get(userId);
+      return r?.started_at ?? null;
+    })()
+  };
+}
+function getDomainCompetence(db, userId) {
+  const domains = db.prepare(
+    `SELECT DISTINCT t.domain FROM cards c
+       JOIN tokens t ON t.id = c.token_id
+       WHERE c.user_id = ? AND t.domain != ''`
+  ).all(userId);
+  return domains.map((d) => {
+    const total = q(
+      db,
+      `SELECT COUNT(*) as n FROM cards c
+       JOIN tokens t ON t.id = c.token_id
+       WHERE c.user_id = ? AND t.domain = ?`,
+      userId,
+      d.domain
+    ).n;
+    const mature = q(
+      db,
+      `SELECT COUNT(*) as n FROM cards c
+       JOIN tokens t ON t.id = c.token_id
+       WHERE c.user_id = ? AND t.domain = ? AND c.reps >= 3 AND c.stability >= 21`,
+      userId,
+      d.domain
+    ).n;
+    const avgStab = q(
+      db,
+      `SELECT AVG(c.stability) as v FROM cards c
+       JOIN tokens t ON t.id = c.token_id
+       WHERE c.user_id = ? AND t.domain = ? AND c.reps > 0`,
+      userId,
+      d.domain
+    ).v ?? 0;
+    const reviews = q(
+      db,
+      `SELECT COUNT(*) as total,
+              SUM(CASE WHEN rating >= 2 THEN 1 ELSE 0 END) as passed
+       FROM review_logs
+       WHERE user_id = ? AND token_id IN (SELECT id FROM tokens WHERE domain = ?)`,
+      userId,
+      d.domain
+    );
+    const retentionRate = reviews.total > 0 ? reviews.passed / reviews.total : 0;
+    let suggestedMode;
+    if (retentionRate > 0.9 && avgStab > 30) {
+      suggestedMode = "autonomy";
+    } else if (retentionRate > 0.7 && avgStab > 7) {
+      suggestedMode = "copilot";
+    } else {
+      suggestedMode = "shadowing";
+    }
+    return {
+      domain: d.domain,
+      totalCards: total,
+      matureCards: mature,
+      avgStability: Math.round(avgStab * 100) / 100,
+      retentionRate: Math.round(retentionRate * 1e3) / 1e3,
+      suggestedMode
+    };
+  });
+}
+
+// src/kernel/observation/analyzer.ts
+function parseMonitorLog(jsonl) {
+  const events = [];
+  for (const line of jsonl.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      events.push(JSON.parse(trimmed));
+    } catch {
+    }
+  }
+  return events;
+}
+function pairCommands(events) {
+  const starts = /* @__PURE__ */ new Map();
+  const records = [];
+  for (const e of events) {
+    if (e.type === "command_start" && e.seq != null) {
+      const key = `${e.pid ?? 0}:${e.seq}`;
+      starts.set(key, e);
+    } else if (e.type === "command_end" && e.seq != null) {
+      const key = `${e.pid ?? 0}:${e.seq}`;
+      const start = starts.get(key);
+      if (start) {
+        const startMs = new Date(start.ts).getTime();
+        const endMs = new Date(e.ts).getTime();
+        records.push({
+          seq: e.seq,
+          pid: e.pid ?? 0,
+          command: start.command ?? "",
+          cwd: start.cwd ?? "",
+          startedAt: start.ts,
+          endedAt: e.ts,
+          durationMs: endMs - startMs,
+          exitCode: e.exit_code ?? null
+        });
+        starts.delete(key);
+      }
+    }
+  }
+  for (const [, start] of starts) {
+    records.push({
+      seq: start.seq ?? 0,
+      pid: start.pid ?? 0,
+      command: start.command ?? "",
+      cwd: start.cwd ?? "",
+      startedAt: start.ts,
+      endedAt: null,
+      durationMs: null,
+      exitCode: null
+    });
+  }
+  records.sort((a, b) => new Date(a.startedAt).getTime() - new Date(b.startedAt).getTime());
+  return records;
+}
+var HELP_PATTERNS = ["--help", "man ", "tldr ", "help "];
+var HELP_WINDOW_MS = 6e4;
+function matchesToken(command, patterns) {
+  const lower = command.toLowerCase();
+  return patterns.some((p) => lower.includes(p.toLowerCase()));
+}
+function isHelpCommand(command) {
+  const lower = command.toLowerCase();
+  return HELP_PATTERNS.some((p) => lower.includes(p));
+}
+function commandPrefix(command) {
+  return command.split(/\s+/).slice(0, 2).join(" ").toLowerCase();
+}
+function computeMedian(values) {
+  if (values.length === 0) return null;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 !== 0 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+function analyzeObservation(commands, tokenPatterns) {
+  const matchedSet = /* @__PURE__ */ new Set();
+  const ratings = [];
+  for (const tp of tokenPatterns) {
+    const matchIndices = [];
+    const matchedTexts = [];
+    for (let i = 0; i < commands.length; i++) {
+      if (matchesToken(commands[i].command, tp.patterns)) {
+        matchIndices.push(i);
+        matchedTexts.push(commands[i].command);
+        matchedSet.add(i);
+      }
+    }
+    if (matchIndices.length === 0) {
+      ratings.push({
+        tokenSlug: tp.slug,
+        rating: null,
+        confidence: "low",
+        evidence: {
+          matchedCommands: 0,
+          helpSeeking: false,
+          errorCount: 0,
+          selfCorrections: 0,
+          medianGapMs: null,
+          thinkingGapMs: null
+        },
+        matchedCommandTexts: []
+      });
+      continue;
+    }
+    let helpSeeking = false;
+    for (const mi of matchIndices) {
+      const matchTime = new Date(commands[mi].startedAt).getTime();
+      for (let j = 0; j < commands.length; j++) {
+        if (j === mi) continue;
+        const cmdTime = new Date(commands[j].startedAt).getTime();
+        if (cmdTime >= matchTime - HELP_WINDOW_MS && cmdTime < matchTime) {
+          if (isHelpCommand(commands[j].command)) {
+            helpSeeking = true;
+            break;
+          }
+        }
+      }
+      if (helpSeeking) break;
+    }
+    let errorCount = 0;
+    for (const mi of matchIndices) {
+      if (commands[mi].exitCode != null && commands[mi].exitCode !== 0) {
+        errorCount++;
+      }
+    }
+    let selfCorrections = 0;
+    const prefixGroups = /* @__PURE__ */ new Map();
+    for (const mi of matchIndices) {
+      const prefix = commandPrefix(commands[mi].command);
+      prefixGroups.set(prefix, (prefixGroups.get(prefix) ?? 0) + 1);
+    }
+    for (const count of prefixGroups.values()) {
+      if (count > 1) selfCorrections += count - 1;
+    }
+    const gaps = [];
+    for (let k = 1; k < matchIndices.length; k++) {
+      const prev = commands[matchIndices[k - 1]];
+      const curr = commands[matchIndices[k]];
+      if (prev.endedAt) {
+        const gap = new Date(curr.startedAt).getTime() - new Date(prev.endedAt).getTime();
+        if (gap >= 0) gaps.push(gap);
+      }
+    }
+    let thinkingGapMs = null;
+    const firstMatchIdx = matchIndices[0];
+    if (firstMatchIdx > 0) {
+      const prev = commands[firstMatchIdx - 1];
+      if (prev.endedAt) {
+        thinkingGapMs = new Date(commands[firstMatchIdx].startedAt).getTime() - new Date(prev.endedAt).getTime();
+      }
+    }
+    const medianGapMs = computeMedian(gaps);
+    const rating = inferRating({
+      helpSeeking,
+      errorCount,
+      selfCorrections,
+      medianGapMs,
+      thinkingGapMs,
+      matchedCommands: matchIndices.length
+    });
+    const confidence = matchIndices.length >= 3 ? "high" : matchIndices.length >= 2 ? "medium" : "low";
+    ratings.push({
+      tokenSlug: tp.slug,
+      rating,
+      confidence,
+      evidence: {
+        matchedCommands: matchIndices.length,
+        helpSeeking,
+        errorCount,
+        selfCorrections,
+        medianGapMs,
+        thinkingGapMs
+      },
+      matchedCommandTexts: matchedTexts
+    });
+  }
+  const unmatchedCommands = [];
+  for (let i = 0; i < commands.length; i++) {
+    if (!matchedSet.has(i) && !isHelpCommand(commands[i].command)) {
+      unmatchedCommands.push(commands[i].command);
+    }
+  }
+  let timeSpan = null;
+  if (commands.length > 0) {
+    const first = commands[0];
+    const last = commands[commands.length - 1];
+    const endTs = last.endedAt ?? last.startedAt;
+    timeSpan = {
+      start: first.startedAt,
+      end: endTs,
+      durationMs: new Date(endTs).getTime() - new Date(first.startedAt).getTime()
+    };
+  }
+  return { ratings, unmatchedCommands, timeSpan };
+}
+function inferRating(signals) {
+  const { helpSeeking, errorCount, selfCorrections, medianGapMs, thinkingGapMs } = signals;
+  let negatives = 0;
+  if (helpSeeking) negatives += 2;
+  if (errorCount >= 3) negatives += 3;
+  else if (errorCount >= 1) negatives += 1;
+  if (selfCorrections >= 2) negatives += 2;
+  else if (selfCorrections >= 1) negatives += 1;
+  if (medianGapMs != null && medianGapMs > 3e4) negatives += 2;
+  else if (medianGapMs != null && medianGapMs > 1e4) negatives += 1;
+  if (thinkingGapMs != null && thinkingGapMs > 3e4) negatives += 1;
+  if (negatives >= 5) return 1;
+  if (negatives >= 3) return 2;
+  if (negatives >= 1) return 3;
+  return 4;
+}
+
+// src/kernel/observation/monitor-io.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, appendFileSync, statSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var MONITOR_DIR = join2(homedir2(), ".zam", "monitor");
+function getMonitorDir() {
+  return MONITOR_DIR;
+}
+function getMonitorPath(sessionId) {
+  return join2(MONITOR_DIR, `${sessionId}.jsonl`);
+}
+function ensureMonitorDir() {
+  if (!existsSync2(MONITOR_DIR)) {
+    mkdirSync2(MONITOR_DIR, { recursive: true, mode: 448 });
+  }
+}
+function writeMonitorEvent(sessionId, event) {
+  ensureMonitorDir();
+  const path = getMonitorPath(sessionId);
+  appendFileSync(path, JSON.stringify(event) + "\n");
+}
+function readMonitorLog(sessionId) {
+  const path = getMonitorPath(sessionId);
+  if (!existsSync2(path)) {
+    return [];
+  }
+  const content = readFileSync(path, "utf-8");
+  return parseMonitorLog(content);
+}
+function monitorLogExists(sessionId) {
+  return existsSync2(getMonitorPath(sessionId));
+}
+function getMonitorLogStats(sessionId) {
+  const path = getMonitorPath(sessionId);
+  if (!existsSync2(path)) {
+    return { exists: false, sizeBytes: 0, lineCount: 0 };
+  }
+  const stat = statSync(path);
+  const content = readFileSync(path, "utf-8");
+  const lineCount = content.split("\n").filter((l) => l.trim()).length;
+  return { exists: true, sizeBytes: stat.size, lineCount };
+}
+
+// src/kernel/observation/shell-hooks.ts
+function generateZshHooks(monitorFile, sessionId) {
+  return `
+# ZAM monitor hooks for session ${sessionId}
+export __ZAM_MONITOR_FILE="${monitorFile}"
+export __ZAM_MONITOR_SEQ=0
+export __ZAM_MONITOR_SESSION="${sessionId}"
+
+__zam_ts() {
+  if [[ -n "\${EPOCHREALTIME:-}" ]]; then
+    local sec="\${EPOCHREALTIME%%.*}"
+    local frac="\${EPOCHREALTIME##*.}"
+    frac="\${frac:0:3}"
+    printf '%s.%sZ' "$(date -u -r "$sec" '+%Y-%m-%dT%H:%M:%S' 2>/dev/null || date -u '+%Y-%m-%dT%H:%M:%S')" "$frac"
+  else
+    date -u '+%Y-%m-%dT%H:%M:%SZ'
+  fi
+}
+
+__zam_preexec() {
+  (( __ZAM_MONITOR_SEQ++ ))
+  local cmd="\${1//\\"/\\\\\\"}"
+  local cwd="\${PWD//\\"/\\\\\\"}"
+  local ts="$(__zam_ts)"
+  printf '{"type":"command_start","ts":"%s","command":"%s","cwd":"%s","seq":%d,"pid":%d}\\n' \\
+    "$ts" "$cmd" "$cwd" "$__ZAM_MONITOR_SEQ" "$$" \\
+    >> "$__ZAM_MONITOR_FILE"
+}
+
+__zam_precmd() {
+  local exit_code=$?
+  [[ $__ZAM_MONITOR_SEQ -eq 0 ]] && return
+  local ts="$(__zam_ts)"
+  printf '{"type":"command_end","ts":"%s","exit_code":%d,"seq":%d,"pid":%d}\\n' \\
+    "$ts" "$exit_code" "$__ZAM_MONITOR_SEQ" "$$" \\
+    >> "$__ZAM_MONITOR_FILE"
+}
+
+autoload -Uz add-zsh-hook
+add-zsh-hook preexec __zam_preexec
+add-zsh-hook precmd __zam_precmd
+
+echo "ZAM monitor active for session $__ZAM_MONITOR_SESSION"
+`.trim();
+}
+function generateBashHooks(monitorFile, sessionId) {
+  return `
+# ZAM monitor hooks for session ${sessionId}
+export __ZAM_MONITOR_FILE="${monitorFile}"
+export __ZAM_MONITOR_SEQ=0
+export __ZAM_MONITOR_SESSION="${sessionId}"
+export __ZAM_MONITOR_CMD_ACTIVE=0
+
+__zam_ts() {
+  date -u '+%Y-%m-%dT%H:%M:%SZ'
+}
+
+__zam_debug_trap() {
+  [[ "$__ZAM_MONITOR_CMD_ACTIVE" -eq 1 ]] && return
+  __ZAM_MONITOR_CMD_ACTIVE=1
+  (( __ZAM_MONITOR_SEQ++ ))
+  local cmd="\${BASH_COMMAND//\\"/\\\\\\"}"
+  local cwd="\${PWD//\\"/\\\\\\"}"
+  local ts="$(__zam_ts)"
+  printf '{"type":"command_start","ts":"%s","command":"%s","cwd":"%s","seq":%d,"pid":%d}\\n' \\
+    "$ts" "$cmd" "$cwd" "$__ZAM_MONITOR_SEQ" "$$" \\
+    >> "$__ZAM_MONITOR_FILE"
+}
+
+__zam_prompt_cmd() {
+  local exit_code=$?
+  if [[ "$__ZAM_MONITOR_CMD_ACTIVE" -eq 1 ]]; then
+    __ZAM_MONITOR_CMD_ACTIVE=0
+    local ts="$(__zam_ts)"
+    printf '{"type":"command_end","ts":"%s","exit_code":%d,"seq":%d,"pid":%d}\\n' \\
+      "$ts" "$exit_code" "$__ZAM_MONITOR_SEQ" "$$" \\
+      >> "$__ZAM_MONITOR_FILE"
+  fi
+}
+
+trap '__zam_debug_trap' DEBUG
+PROMPT_COMMAND="__zam_prompt_cmd;\${PROMPT_COMMAND:-}"
+
+echo "ZAM monitor active for session $__ZAM_MONITOR_SESSION"
+`.trim();
+}
+function generateZshUnhooks() {
+  return `
+# Remove ZAM monitor hooks
+add-zsh-hook -d preexec __zam_preexec 2>/dev/null
+add-zsh-hook -d precmd __zam_precmd 2>/dev/null
+unset -f __zam_preexec __zam_precmd __zam_ts 2>/dev/null
+unset __ZAM_MONITOR_FILE __ZAM_MONITOR_SEQ __ZAM_MONITOR_SESSION 2>/dev/null
+echo "ZAM monitor stopped."
+`.trim();
+}
+function generateBashUnhooks() {
+  return `
+# Remove ZAM monitor hooks
+trap - DEBUG
+PROMPT_COMMAND="\${PROMPT_COMMAND/__zam_prompt_cmd;/}"
+unset -f __zam_debug_trap __zam_prompt_cmd __zam_ts 2>/dev/null
+unset __ZAM_MONITOR_FILE __ZAM_MONITOR_SEQ __ZAM_MONITOR_SESSION __ZAM_MONITOR_CMD_ACTIVE 2>/dev/null
+echo "ZAM monitor stopped."
+`.trim();
+}
+
+// src/kernel/observation/skill-discovery.ts
+function discoverSkills(sessionCommands, options = {}) {
+  const minSessions = options.minSessions ?? 2;
+  const minLen = options.minSequenceLength ?? 2;
+  const maxLen = options.maxSequenceLength ?? 5;
+  const existing = new Set(options.existingSkillSlugs ?? []);
+  const sessionSequences = /* @__PURE__ */ new Map();
+  for (const [sessionId, commands] of sessionCommands) {
+    const sequences = extractSequences(commands, minLen, maxLen);
+    if (sequences.length > 0) {
+      sessionSequences.set(sessionId, sequences);
+    }
+  }
+  const sequenceIndex = /* @__PURE__ */ new Map();
+  for (const [, sequences] of sessionSequences) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const seq of sequences) {
+      const key = seq.join(" \u2192 ");
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const entry = sequenceIndex.get(key);
+      if (entry) {
+        entry.sessionCount++;
+        entry.totalOccurrences++;
+      } else {
+        sequenceIndex.set(key, {
+          steps: seq,
+          sessionCount: 1,
+          totalOccurrences: 1,
+          examples: []
+        });
+      }
+    }
+  }
+  const lastSessionId = [...sessionCommands.keys()].pop();
+  if (lastSessionId) {
+    const lastCommands = sessionCommands.get(lastSessionId);
+    for (const [key, entry] of sequenceIndex) {
+      if (entry.sessionCount >= minSessions) {
+        entry.examples = findExamplesForSequence(lastCommands, entry.steps);
+      }
+    }
+  }
+  const candidates = [...sequenceIndex.values()].filter(
+    (s) => s.sessionCount >= minSessions
+  );
+  const pruned = removeSubsequences(candidates);
+  const proposals = [];
+  for (const seq of pruned) {
+    const slug = generateSlug(seq.steps);
+    if (existing.has(slug)) continue;
+    proposals.push({
+      slug,
+      description: describeSequence(seq.steps),
+      steps: seq.steps,
+      sessionCount: seq.sessionCount,
+      confidence: seq.sessionCount >= 4 ? "high" : seq.sessionCount >= 3 ? "medium" : "low",
+      examples: seq.examples
+    });
+  }
+  const confidenceOrder = { high: 0, medium: 1, low: 2 };
+  proposals.sort((a, b) => {
+    const confDiff = confidenceOrder[a.confidence] - confidenceOrder[b.confidence];
+    if (confDiff !== 0) return confDiff;
+    return b.sessionCount - a.sessionCount;
+  });
+  return proposals;
+}
+function normalizeCommand(command) {
+  const parts = command.trim().split(/\s+/);
+  const multiWord = ["docker compose", "npm run", "npx", "git"];
+  const lower = command.toLowerCase();
+  for (const mw of multiWord) {
+    if (lower.startsWith(mw) && parts.length >= mw.split(" ").length + 1) {
+      return parts.slice(0, mw.split(" ").length + 1).join(" ").toLowerCase();
+    }
+  }
+  return parts.slice(0, Math.min(2, parts.length)).join(" ").toLowerCase();
+}
+function extractSequences(commands, minLen, maxLen) {
+  const filtered = commands.filter((c) => {
+    const lower = c.command.toLowerCase().trim();
+    return lower.length > 0 && !lower.startsWith("cd ") && lower !== "cd" && lower !== "ls" && lower !== "pwd" && lower !== "clear" && lower !== "exit" && !lower.startsWith("echo ");
+  });
+  const normalized = filtered.map((c) => normalizeCommand(c.command));
+  const sequences = [];
+  for (let len = minLen; len <= maxLen; len++) {
+    for (let i = 0; i <= normalized.length - len; i++) {
+      const seq = normalized.slice(i, i + len);
+      if (new Set(seq).size >= 2) {
+        sequences.push(seq);
+      }
+    }
+  }
+  return sequences;
+}
+function findExamplesForSequence(commands, steps) {
+  const normalized = commands.map((c) => ({
+    norm: normalizeCommand(c.command),
+    full: c.command
+  }));
+  for (let i = 0; i <= normalized.length - steps.length; i++) {
+    let match = true;
+    for (let j = 0; j < steps.length; j++) {
+      if (normalized[i + j].norm !== steps[j]) {
+        match = false;
+        break;
+      }
+    }
+    if (match) {
+      return normalized.slice(i, i + steps.length).map((n) => n.full);
+    }
+  }
+  return [];
+}
+function removeSubsequences(candidates) {
+  const sorted = [...candidates].sort((a, b) => b.steps.length - a.steps.length);
+  const result = [];
+  for (const candidate of sorted) {
+    const key = candidate.steps.join(" \u2192 ");
+    const isSubsequence = result.some((longer) => {
+      const longerKey = longer.steps.join(" \u2192 ");
+      return longerKey.includes(key) && longerKey !== key;
+    });
+    if (!isSubsequence) {
+      result.push(candidate);
+    }
+  }
+  return result;
+}
+function generateSlug(steps) {
+  return steps.map((s) => {
+    const parts = s.split(/\s+/);
+    return parts[parts.length - 1];
+  }).join("-");
+}
+function describeSequence(steps) {
+  return `Recurring pattern: ${steps.join(" \u2192 ")}`;
+}
+
+// src/kernel/goals/engine.ts
+import { readdirSync, readFileSync as readFileSync2, writeFileSync, existsSync as existsSync3 } from "fs";
+import { join as join3, basename } from "path";
+
+// src/kernel/goals/parser.ts
+function parseGoalFile(content, slug, filePath) {
+  const { frontmatter, body } = splitFrontmatter(content);
+  const validStatuses = ["active", "completed", "paused", "abandoned"];
+  const status = validStatuses.includes(frontmatter.status) ? frontmatter.status : "active";
+  const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return {
+    slug,
+    title: frontmatter.title || slug,
+    status,
+    parent: frontmatter.parent || null,
+    created: frontmatter.created || now,
+    updated: frontmatter.updated || now,
+    body,
+    filePath
+  };
+}
+function serializeGoal(goal) {
+  const lines = [
+    "---",
+    `title: ${goal.title}`,
+    `status: ${goal.status}`
+  ];
+  if (goal.parent) {
+    lines.push(`parent: ${goal.parent}`);
+  }
+  lines.push(`created: ${goal.created}`);
+  lines.push(`updated: ${goal.updated}`);
+  lines.push("---");
+  lines.push("");
+  if (goal.body.trim()) {
+    lines.push(goal.body.trim());
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function extractTasks(body) {
+  const tasks = [];
+  const taskRegex = /^[-*]\s+\[([ xX])\]\s+(.+)$/gm;
+  let match;
+  while ((match = taskRegex.exec(body)) !== null) {
+    tasks.push({
+      done: match[1] !== " ",
+      text: match[2].trim()
+    });
+  }
+  return tasks;
+}
+function extractTokenRefs(body) {
+  const tokensSection = body.match(/## Tokens\n([\s\S]*?)(?=\n## |\n*$)/);
+  if (!tokensSection) return [];
+  const refs = [];
+  const lines = tokensSection[1].split("\n");
+  for (const line of lines) {
+    const match = line.match(/^[-*]\s+(\S+)/);
+    if (match) {
+      refs.push(match[1]);
+    }
+  }
+  return refs;
+}
+function splitFrontmatter(content) {
+  const trimmed = content.trim();
+  if (!trimmed.startsWith("---")) {
+    return { frontmatter: {}, body: trimmed };
+  }
+  const endIndex = trimmed.indexOf("---", 3);
+  if (endIndex === -1) {
+    return { frontmatter: {}, body: trimmed };
+  }
+  const fmBlock = trimmed.slice(3, endIndex).trim();
+  const body = trimmed.slice(endIndex + 3).trim();
+  const frontmatter = {};
+  for (const line of fmBlock.split("\n")) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = line.slice(0, colonIndex).trim();
+    const value = line.slice(colonIndex + 1).trim();
+    if (key && value) {
+      frontmatter[key] = value;
+    }
+  }
+  return { frontmatter, body };
+}
+
+// src/kernel/goals/engine.ts
+function listGoals(goalsDir) {
+  if (!existsSync3(goalsDir)) return [];
+  const files = readdirSync(goalsDir).filter(
+    (f) => f.endsWith(".md") && f !== "README.md"
+  );
+  const summaries = [];
+  for (const file of files) {
+    const filePath = join3(goalsDir, file);
+    const content = readFileSync2(filePath, "utf-8");
+    const slug = basename(file, ".md");
+    const goal = parseGoalFile(content, slug, filePath);
+    const tasks = extractTasks(goal.body);
+    const tokens = extractTokenRefs(goal.body);
+    summaries.push({
+      slug: goal.slug,
+      title: goal.title,
+      status: goal.status,
+      parent: goal.parent,
+      taskCount: tasks.length,
+      tasksDone: tasks.filter((t) => t.done).length,
+      tokenCount: tokens.length
+    });
+  }
+  const statusOrder = {
+    active: 0,
+    paused: 1,
+    completed: 2,
+    abandoned: 3
+  };
+  summaries.sort((a, b) => {
+    const statusDiff = statusOrder[a.status] - statusOrder[b.status];
+    if (statusDiff !== 0) return statusDiff;
+    return a.title.localeCompare(b.title);
+  });
+  return summaries;
+}
+function getGoal(goalsDir, slug) {
+  const filePath = join3(goalsDir, `${slug}.md`);
+  if (!existsSync3(filePath)) return void 0;
+  const content = readFileSync2(filePath, "utf-8");
+  return parseGoalFile(content, slug, filePath);
+}
+function createGoal(goalsDir, input) {
+  const filePath = join3(goalsDir, `${input.slug}.md`);
+  if (existsSync3(filePath)) {
+    throw new Error(`Goal already exists: ${input.slug}`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const goal = {
+    slug: input.slug,
+    title: input.title,
+    status: input.status ?? "active",
+    parent: input.parent ?? null,
+    created: now,
+    updated: now,
+    body: input.description ? `## Description
+${input.description}
+
+## Tasks
+
+## Tokens` : "## Description\n\n## Tasks\n\n## Tokens",
+    filePath
+  };
+  writeFileSync(filePath, serializeGoal(goal), "utf-8");
+  return goal;
+}
+function updateGoalStatus(goalsDir, slug, status) {
+  const goal = getGoal(goalsDir, slug);
+  if (!goal) throw new Error(`Goal not found: ${slug}`);
+  goal.status = status;
+  goal.updated = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  writeFileSync(goal.filePath, serializeGoal(goal), "utf-8");
+  return goal;
+}
+function getGoalTree(goalsDir) {
+  const all = listGoals(goalsDir);
+  const bySlug = new Map(all.map((g) => [g.slug, g]));
+  const roots = [];
+  const children = /* @__PURE__ */ new Map();
+  for (const g of all) {
+    if (g.parent && bySlug.has(g.parent)) {
+      const list = children.get(g.parent) ?? [];
+      list.push(g);
+      children.set(g.parent, list);
+    }
+  }
+  for (const g of all) {
+    if (!g.parent || !bySlug.has(g.parent)) {
+      roots.push({ ...g, children: children.get(g.slug) ?? [] });
+    }
+  }
+  return roots;
+}
+
+// src/kernel/connectors/azure-devops.ts
+function loadADOConfig(db) {
+  const orgUrl = getSetting(db, "ado.org_url");
+  const project = getSetting(db, "ado.project");
+  const pat = getSetting(db, "ado.pat");
+  if (!orgUrl || !project || !pat) return null;
+  return { orgUrl: orgUrl.replace(/\/+$/, ""), project, pat };
+}
+function authHeader(pat) {
+  return `Basic ${Buffer.from(`:${pat}`).toString("base64")}`;
+}
+async function fetchActiveWorkItems(config) {
+  const { orgUrl, project, pat } = config;
+  const wiqlUrl = `${orgUrl}/${project}/_apis/wit/wiql?api-version=7.1`;
+  const wiqlBody = {
+    query: `SELECT [System.Id] FROM WorkItems WHERE [System.AssignedTo] = @me AND [System.State] NOT IN ('Closed', 'Completed', 'Done', 'Removed') ORDER BY [Microsoft.VSTS.Common.Priority] ASC, [System.ChangedDate] DESC`
+  };
+  const wiqlRes = await fetch(wiqlUrl, {
+    method: "POST",
+    headers: {
+      Authorization: authHeader(pat),
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(wiqlBody)
+  });
+  if (!wiqlRes.ok) {
+    const text = await wiqlRes.text();
+    throw new Error(`ADO WIQL query failed (${wiqlRes.status}): ${text}`);
+  }
+  const wiqlData = await wiqlRes.json();
+  const ids = wiqlData.workItems.map((wi) => wi.id);
+  if (ids.length === 0) return [];
+  const batchIds = ids.slice(0, 200);
+  const fields = "System.Id,System.Title,System.State,System.WorkItemType,System.AssignedTo";
+  const detailUrl = `${orgUrl}/${project}/_apis/wit/workitems?ids=${batchIds.join(",")}&fields=${fields}&api-version=7.1`;
+  const detailRes = await fetch(detailUrl, {
+    headers: { Authorization: authHeader(pat) }
+  });
+  if (!detailRes.ok) {
+    const text = await detailRes.text();
+    throw new Error(`ADO work items fetch failed (${detailRes.status}): ${text}`);
+  }
+  const detailData = await detailRes.json();
+  return detailData.value.map((wi) => ({
+    id: wi.id,
+    title: wi.fields["System.Title"],
+    state: wi.fields["System.State"],
+    type: wi.fields["System.WorkItemType"],
+    assignedTo: wi.fields["System.AssignedTo"]?.displayName ?? ""
+  }));
+}
+export {
+  addPrerequisite,
+  analyzeObservation,
+  buildReviewQueue,
+  cascadeBlock,
+  createAgentSkill,
+  createFSRS,
+  createGoal,
+  createToken,
+  deleteSetting,
+  deprecateToken,
+  discoverSkills,
+  endSession,
+  ensureCard,
+  ensureMonitorDir,
+  evaluateRating,
+  extractTasks,
+  extractTokenRefs,
+  fetchActiveWorkItems,
+  findTokens,
+  generateBashHooks,
+  generateBashUnhooks,
+  generatePrompt,
+  generateZshHooks,
+  generateZshUnhooks,
+  getAgentSkill,
+  getAllSettings,
+  getAllSettingsDetailed,
+  getBlockedCards,
+  getCard,
+  getDefaultDbPath,
+  getDependents,
+  getDomainCompetence,
+  getDueCards,
+  getGoal,
+  getGoalTree,
+  getMonitorDir,
+  getMonitorLogStats,
+  getMonitorPath,
+  getPrerequisites,
+  getReviewsForCard,
+  getReviewsForUser,
+  getSessionSummary,
+  getSetting,
+  getTokenById,
+  getTokenBySlug,
+  getUserStats,
+  interleave,
+  listAgentSkills,
+  listGoals,
+  listTokens,
+  loadADOConfig,
+  logReview,
+  logStep,
+  monitorLogExists,
+  openDatabase,
+  openDatabaseWithSync,
+  pairCommands,
+  parseGoalFile,
+  parseMonitorLog,
+  readMonitorLog,
+  serializeGoal,
+  setSetting,
+  startSession,
+  unblockReady,
+  updateCard,
+  updateGoalStatus,
+  writeMonitorEvent
+};
+//# sourceMappingURL=index.js.map