zam-core 0.3.0

package/dist/cli/index.js

@@ -0,0 +1,3661 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command as Command15 } from "commander";
+
+// src/cli/commands/init.ts
+import { Command } from "commander";
+
+// 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, input5) {
+  const id = ulid();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const bloom = input5.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,
+    input5.slug,
+    input5.concept,
+    input5.domain ?? "",
+    bloom,
+    input5.context ?? "",
+    input5.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);
+}
+
+// src/kernel/models/review.ts
+import { ulid as ulid3 } from "ulid";
+
+// src/kernel/models/session.ts
+import { ulid as ulid4 } from "ulid";
+function startSession(db, input5) {
+  const id = ulid4();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const ctx = input5.execution_context ?? "shell";
+  db.prepare(
+    `INSERT INTO sessions (id, user_id, task, execution_context, started_at)
+     VALUES (?, ?, ?, ?, ?)`
+  ).run(id, input5.user_id, input5.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, input5) {
+  if (input5.done_by !== "user" && input5.done_by !== "agent") {
+    throw new Error(`done_by must be 'user' or 'agent', got '${input5.done_by}'`);
+  }
+  if (input5.rating != null && (input5.rating < 1 || input5.rating > 4)) {
+    throw new Error(`Rating must be between 1 and 4, got ${input5.rating}`);
+  }
+  const session = db.prepare("SELECT id FROM sessions WHERE id = ?").get(input5.session_id);
+  if (!session) {
+    throw new Error(`Session not found: ${input5.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,
+    input5.session_id,
+    input5.token_id,
+    input5.done_by,
+    input5.rating ?? null,
+    input5.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, input5) {
+  const existing = db.prepare("SELECT * FROM agent_skills WHERE slug = ?").get(input5.slug);
+  if (existing) {
+    throw new Error(`Agent skill already exists: ${input5.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,
+    input5.slug,
+    input5.description,
+    JSON.stringify(input5.steps),
+    JSON.stringify(input5.token_slugs ?? []),
+    input5.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(input5) {
+  const bloom = input5.bloomLevel >= 1 && input5.bloomLevel <= 5 ? input5.bloomLevel : 1;
+  return {
+    cardId: input5.cardId,
+    tokenId: input5.tokenId,
+    slug: input5.slug,
+    question: BLOOM_PROMPTS[bloom](input5.concept),
+    concept: input5.concept,
+    domain: input5.domain,
+    bloomLevel: bloom,
+    bloomVerb: BLOOM_VERBS[bloom],
+    hints: []
+  };
+}
+
+// src/kernel/recall/evaluator.ts
+import { ulid as ulid6 } from "ulid";
+function evaluateRating(db, input5) {
+  const card = db.prepare("SELECT * FROM cards WHERE id = ?").get(input5.cardId);
+  if (!card) {
+    throw new Error(`Card not found: ${input5.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, input5.rating, now);
+  updateCard(db, input5.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(),
+    input5.cardId,
+    input5.tokenId,
+    input5.userId,
+    input5.rating,
+    input5.responseTimeMs ?? null,
+    now.toISOString(),
+    card.due_at,
+    input5.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 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, input5) {
+  const filePath = join3(goalsDir, `${input5.slug}.md`);
+  if (existsSync3(filePath)) {
+    throw new Error(`Goal already exists: ${input5.slug}`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const goal = {
+    slug: input5.slug,
+    title: input5.title,
+    status: input5.status ?? "active",
+    parent: input5.parent ?? null,
+    created: now,
+    updated: now,
+    body: input5.description ? `## Description
+${input5.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 ?? ""
+  }));
+}
+
+// src/cli/commands/init.ts
+var initCommand = new Command("init").description("Initialize the ZAM database and config directory").action(() => {
+  try {
+    const dbPath = getDefaultDbPath();
+    const db = openDatabase({ initialize: true });
+    db.close();
+    console.log(`Initialized ZAM database at ${dbPath}`);
+  } catch (err) {
+    console.error("Failed to initialize:", err.message);
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/setup.ts
+import { Command as Command2 } from "commander";
+import { fileURLToPath } from "url";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, copyFileSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4, dirname as dirname2, basename as basename2 } from "path";
+var packageRoot = fileURLToPath(new URL("../..", import.meta.url));
+var SKILL_PAIRS = [
+  {
+    from: join4(packageRoot, ".claude", "skills", "zam", "SKILL.md"),
+    to: join4(".claude", "skills", "zam", "SKILL.md")
+  },
+  {
+    from: join4(packageRoot, ".gemini", "skills", "zam", "SKILL.md"),
+    to: join4(".gemini", "skills", "zam", "SKILL.md")
+  }
+];
+function copySkills(force) {
+  const cwd = process.cwd();
+  let anyAction = false;
+  for (const { from, to } of SKILL_PAIRS) {
+    const dest = join4(cwd, to);
+    if (!existsSync4(from)) {
+      console.warn(`  warn  source not found, skipping: ${from}`);
+      continue;
+    }
+    if (existsSync4(dest) && !force) {
+      console.log(`  skip  ${to} (already present \u2014 use --force to update)`);
+      continue;
+    }
+    mkdirSync3(dirname2(dest), { recursive: true });
+    copyFileSync(from, dest);
+    console.log(`  copy  ${to}`);
+    anyAction = true;
+  }
+  if (!anyAction && !force) {
+    console.log(
+      "\nSkill files are already up to date. Run with --force to overwrite."
+    );
+  }
+}
+function initDatabase(skipInit) {
+  if (skipInit) return;
+  try {
+    const dbPath = getDefaultDbPath();
+    const db = openDatabase({ initialize: true });
+    db.close();
+    console.log(`  init  ZAM database at ${dbPath}`);
+  } catch (err) {
+    const msg = err.message;
+    if (!msg.includes("already")) {
+      console.warn(`  warn  database init: ${msg}`);
+    } else {
+      console.log(`  skip  database already initialized`);
+    }
+  }
+}
+function writeClaudeMd(skipClaudeMd) {
+  if (skipClaudeMd) return;
+  const dest = join4(process.cwd(), "CLAUDE.md");
+  if (existsSync4(dest)) {
+    console.log(`  skip  CLAUDE.md (already present)`);
+    return;
+  }
+  const name = basename2(process.cwd());
+  writeFileSync2(
+    dest,
+    `# ZAM Personal Kernel \u2014 ${name}
+
+This is a ZAM personal instance. ZAM builds lasting skills through spaced
+repetition during real work \u2014 not separate study sessions.
+
+## First time here?
+Run \`/setup\` in Claude Code or Gemini CLI to complete first-time setup.
+
+## Regular use
+Run \`/zam\` to start a learning session on whatever you are working on.
+
+## What lives here
+- \`beliefs/\` \u2014 your worldview, approved by git commit
+- \`goals/\` \u2014 your objectives, decomposed into tasks and learning tokens
+
+## Fast-changing data
+Learning tokens, cards, and review history live in \`~/.zam/zam.db\` (local
+SQLite, not committed to git). Use \`zam connector setup turso\` to enable
+cloud sync across machines.
+`,
+    "utf8"
+  );
+  console.log(`  write CLAUDE.md`);
+}
+var setupCommand = new Command2("setup").description(
+  "Distribute ZAM skill files into this personal instance and initialize the database"
+).option(
+  "--force",
+  "overwrite existing skill files (use after upgrading zam)",
+  false
+).option("--skip-init", "skip database initialization", false).option("--skip-claude-md", "skip CLAUDE.md generation", false).action(
+  (opts) => {
+    console.log(`Setting up ZAM in ${process.cwd()}
+`);
+    copySkills(opts.force);
+    initDatabase(opts.skipInit);
+    writeClaudeMd(opts.skipClaudeMd);
+    console.log(
+      "\nDone. Run `zam whoami --set <your-id>` to set your identity, then open Claude Code or Gemini CLI and run /zam to start a learning session."
+    );
+  }
+);
+
+// src/cli/commands/token.ts
+import { Command as Command3 } from "commander";
+
+// src/cli/commands/resolve-user.ts
+function resolveUser(opts, db, resolveOpts) {
+  if (opts.user) return opts.user;
+  const stored = getSetting(db, "user.id");
+  if (stored) return stored;
+  const message = "No user specified. Set a default with: zam whoami --set <id>";
+  if (resolveOpts?.json) {
+    console.log(JSON.stringify({ error: message }, null, 2));
+  } else {
+    console.error(message);
+  }
+  process.exit(1);
+}
+
+// src/cli/commands/token.ts
+function withDb(fn) {
+  let db;
+  try {
+    db = openDatabase();
+    fn(db);
+  } catch (err) {
+    console.error("Error:", err.message);
+    process.exit(1);
+  } finally {
+    db?.close();
+  }
+}
+var tokenCommand = new Command3("token").description("Manage knowledge tokens");
+tokenCommand.command("register").description("Register a new knowledge token").requiredOption("--slug <slug>", "Unique token slug").requiredOption("--concept <concept>", "Concept description").option("--domain <domain>", "Knowledge domain", "").option("--bloom <level>", "Bloom taxonomy level (1-5)", "1").option("--json", "Output as JSON").action((opts) => {
+  withDb((db) => {
+    const token = createToken(db, {
+      slug: opts.slug,
+      concept: opts.concept,
+      domain: opts.domain,
+      bloom_level: Number(opts.bloom)
+    });
+    if (opts.json) {
+      console.log(JSON.stringify(token, null, 2));
+    } else {
+      console.log(`Registered token: ${token.slug} (${token.id})`);
+      console.log(`  Concept: ${token.concept}`);
+      console.log(`  Domain:  ${token.domain || "(none)"}`);
+      console.log(`  Bloom:   ${token.bloom_level}`);
+    }
+  });
+});
+tokenCommand.command("find").description("Fuzzy search for tokens").requiredOption("--query <query>", "Search query").option("--json", "Output as JSON").action((opts) => {
+  withDb((db) => {
+    const results = findTokens(db, opts.query);
+    if (opts.json) {
+      console.log(JSON.stringify(results, null, 2));
+      return;
+    }
+    if (results.length === 0) {
+      console.log("No tokens found.");
+      return;
+    }
+    console.log(`Found ${results.length} token(s):
+`);
+    console.log(
+      "Score  Slug                  Concept                         Domain      Bloom"
+    );
+    console.log("\u2500".repeat(90));
+    for (const t of results) {
+      console.log(
+        `${String(t.score).padEnd(6)} ${t.slug.padEnd(21)} ${t.concept.slice(0, 31).padEnd(31)} ${(t.domain || "-").padEnd(11)} ${t.bloom_level}`
+      );
+    }
+  });
+});
+tokenCommand.command("list").description("List all tokens").option("--domain <domain>", "Filter by domain").option("--json", "Output as JSON").action((opts) => {
+  withDb((db) => {
+    const tokens = listTokens(db, opts.domain ? { domain: opts.domain } : void 0);
+    if (opts.json) {
+      console.log(JSON.stringify(tokens, null, 2));
+      return;
+    }
+    if (tokens.length === 0) {
+      console.log("No tokens registered.");
+      return;
+    }
+    console.log(
+      "Slug                  Concept                         Domain      Bloom"
+    );
+    console.log("\u2500".repeat(80));
+    for (const t of tokens) {
+      console.log(
+        `${t.slug.padEnd(21)} ${t.concept.slice(0, 31).padEnd(31)} ${(t.domain || "-").padEnd(11)} ${t.bloom_level}`
+      );
+    }
+    console.log(`
+${tokens.length} token(s) total.`);
+  });
+});
+tokenCommand.command("prereq").description("Add a prerequisite edge between tokens").requiredOption("--token <slug>", "Token that requires a prerequisite").requiredOption("--requires <slug>", "Required prerequisite token").option("--json", "Output as JSON").action((opts) => {
+  withDb((db) => {
+    const token = getTokenBySlug(db, opts.token);
+    if (!token) {
+      console.error(`Token not found: ${opts.token}`);
+      process.exit(1);
+    }
+    const requires = getTokenBySlug(db, opts.requires);
+    if (!requires) {
+      console.error(`Prerequisite token not found: ${opts.requires}`);
+      process.exit(1);
+    }
+    addPrerequisite(db, token.id, requires.id);
+    if (opts.json) {
+      console.log(JSON.stringify({ token: opts.token, requires: opts.requires }, null, 2));
+    } else {
+      console.log(`Added prerequisite: ${opts.token} requires ${opts.requires}`);
+    }
+  });
+});
+tokenCommand.command("deprecate").description("Mark a token as deprecated (excluded from reviews, not deleted)").requiredOption("--slug <slug>", "Token slug to deprecate").option("--json", "Output as JSON").action((opts) => {
+  withDb((db) => {
+    const token = deprecateToken(db, opts.slug);
+    if (opts.json) {
+      console.log(JSON.stringify(token, null, 2));
+    } else {
+      console.log(`Deprecated: ${token.slug}`);
+      console.log(`  Concept: ${token.concept}`);
+      console.log(`  At:      ${token.deprecated_at}`);
+    }
+  });
+});
+tokenCommand.command("status").description("Show full status of a token for a user").requiredOption("--token <slug>", "Token slug").option("--user <id>", "User ID (default: whoami)").option("--json", "Output as JSON").action((opts) => {
+  withDb((db) => {
+    const userId = resolveUser(opts, db);
+    const token = getTokenBySlug(db, opts.token);
+    if (!token) {
+      console.error(`Token not found: ${opts.token}`);
+      process.exit(1);
+    }
+    const card = getCard(db, token.id, userId);
+    const prereqs = getPrerequisites(db, token.id);
+    const dependents = getDependents(db, token.id);
+    const status = {
+      token,
+      card: card ?? null,
+      prerequisites: prereqs,
+      dependents
+    };
+    if (opts.json) {
+      console.log(JSON.stringify(status, null, 2));
+      return;
+    }
+    console.log(`Token: ${token.slug} (${token.id})`);
+    console.log(`  Concept: ${token.concept}`);
+    console.log(`  Domain:  ${token.domain || "(none)"}`);
+    console.log(`  Bloom:   ${token.bloom_level}`);
+    console.log();
+    if (card) {
+      console.log("Card status:");
+      console.log(`  State:       ${card.state}`);
+      console.log(`  Due at:      ${card.due_at}`);
+      console.log(`  Stability:   ${card.stability}`);
+      console.log(`  Difficulty:  ${card.difficulty}`);
+      console.log(`  Reps:        ${card.reps}`);
+      console.log(`  Lapses:      ${card.lapses}`);
+      console.log(`  Blocked:     ${card.blocked ? "Yes" : "No"}`);
+    } else {
+      console.log("No card exists for this user yet.");
+    }
+    console.log();
+    if (prereqs.length > 0) {
+      console.log("Prerequisites:");
+      for (const p of prereqs) {
+        console.log(`  - ${p.slug}: ${p.concept} (bloom ${p.bloom_level})`);
+      }
+    } else {
+      console.log("No prerequisites.");
+    }
+    if (dependents.length > 0) {
+      console.log("\nDependents:");
+      for (const d of dependents) {
+        console.log(`  - ${d.slug}: ${d.concept} (bloom ${d.bloom_level})`);
+      }
+    }
+  });
+});
+
+// src/cli/commands/card.ts
+import { Command as Command4 } from "commander";
+function withDb2(fn) {
+  let db;
+  try {
+    db = openDatabase();
+    fn(db);
+  } catch (err) {
+    console.error("Error:", err.message);
+    process.exit(1);
+  } finally {
+    db?.close();
+  }
+}
+var cardCommand = new Command4("card").description("Manage spaced-repetition cards");
+cardCommand.command("due").description("Show due tokens for a user").option("--user <id>", "User ID (default: whoami)").option("--json", "Output as JSON").option("--summary", "Show only counts per domain (no slugs or concepts)").action((opts) => {
+  withDb2((db) => {
+    const userId = resolveUser(opts, db);
+    const dueCards = getDueCards(db, userId);
+    if (opts.json) {
+      console.log(JSON.stringify(dueCards, null, 2));
+      return;
+    }
+    if (dueCards.length === 0) {
+      console.log("No cards due for review.");
+      return;
+    }
+    if (opts.summary) {
+      const byDomain = /* @__PURE__ */ new Map();
+      for (const c of dueCards) {
+        const d = c.domain || "general";
+        const entry = byDomain.get(d) ?? { count: 0, blooms: [] };
+        entry.count++;
+        entry.blooms.push(c.bloom_level);
+        byDomain.set(d, entry);
+      }
+      console.log(`${dueCards.length} card(s) due:
+`);
+      console.log(
+        "Domain           Count  Bloom levels"
+      );
+      console.log("\u2500".repeat(45));
+      for (const [domain, { count, blooms }] of [...byDomain.entries()].sort()) {
+        const bloomStr = blooms.sort().join(", ");
+        console.log(
+          `${domain.padEnd(16)} ${String(count).padEnd(6)} ${bloomStr}`
+        );
+      }
+      return;
+    }
+    console.log(`${dueCards.length} card(s) due:
+`);
+    console.log(
+      "Slug                  Concept                         Domain      Bloom  State"
+    );
+    console.log("\u2500".repeat(90));
+    for (const c of dueCards) {
+      console.log(
+        `${c.slug.padEnd(21)} ${c.concept.slice(0, 31).padEnd(31)} ${(c.domain || "-").padEnd(11)} ${String(c.bloom_level).padEnd(6)} ${c.state}`
+      );
+    }
+  });
+});
+cardCommand.command("update").description("Apply a rating to a card").option("--user <id>", "User ID (default: whoami)").requiredOption("--token <slug>", "Token slug").requiredOption("--rating <n>", "Rating (1=Again, 2=Hard, 3=Good, 4=Easy)").option("--json", "Output as JSON").option("--quiet", "Suppress output (exit code only)").action((opts) => {
+  withDb2((db) => {
+    const userId = resolveUser(opts, db);
+    const token = getTokenBySlug(db, opts.token);
+    if (!token) {
+      console.error(`Token not found: ${opts.token}`);
+      process.exit(1);
+    }
+    const card = ensureCard(db, token.id, userId);
+    const rating = Number(opts.rating);
+    if (rating < 1 || rating > 4) {
+      console.error("Rating must be between 1 and 4.");
+      process.exit(1);
+    }
+    const result = evaluateRating(db, {
+      cardId: card.id,
+      tokenId: token.id,
+      userId,
+      rating
+    });
+    if (rating === 1) {
+      const prereqs = getPrerequisites(db, token.id);
+      if (prereqs.length > 0) {
+        const blockResult = cascadeBlock(db, userId, token.slug);
+        if (opts.quiet) return;
+        if (opts.json) {
+          console.log(JSON.stringify({ evaluation: result, blocked: blockResult }, null, 2));
+        } else {
+          console.log(`Rated ${token.slug} as Again (1) \u2014 next due: ${result.nextDueAt}`);
+          console.log(`Blocked ${blockResult.blockedSlug}. Prerequisites surfaced:`);
+          for (const p of blockResult.prerequisites) {
+            console.log(`  - ${p.slug}: ${p.concept}`);
+          }
+        }
+        return;
+      }
+    }
+    if (opts.quiet) return;
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      const ratingLabels = { 1: "Again", 2: "Hard", 3: "Good", 4: "Easy" };
+      console.log(`Rated ${token.slug} as ${ratingLabels[rating]} (${rating})`);
+      console.log(`  Next due:   ${result.nextDueAt}`);
+      console.log(`  Stability:  ${result.stability.toFixed(2)}`);
+      console.log(`  State:      ${result.state}`);
+      console.log(`  Reps:       ${result.reps}`);
+    }
+  });
+});
+cardCommand.command("unblock").description("Unblock cards whose prerequisites are met").option("--user <id>", "User ID (default: whoami)").option("--json", "Output as JSON").option("--quiet", "Suppress output (exit code only)").action((opts) => {
+  withDb2((db) => {
+    const userId = resolveUser(opts, db);
+    const result = unblockReady(db, userId);
+    if (opts.quiet) return;
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    if (result.unblocked.length === 0) {
+      console.log("No cards ready to unblock.");
+    } else {
+      console.log(`Unblocked ${result.unblocked.length} card(s):`);
+      for (const u of result.unblocked) {
+        console.log(`  - ${u.slug}: ${u.concept}`);
+      }
+    }
+  });
+});
+
+// src/cli/commands/session.ts
+import { Command as Command5 } from "commander";
+import { select, input } from "@inquirer/prompts";
+function withDb3(fn) {
+  let db;
+  try {
+    db = openDatabase();
+    fn(db);
+  } catch (err) {
+    console.error("Error:", err.message);
+    process.exit(1);
+  } finally {
+    db?.close();
+  }
+}
+var sessionCommand = new Command5("session").description("Manage learning sessions");
+sessionCommand.command("start").description("Start a new learning session (review \u2192 task)").option("--user <id>", "User ID (default: whoami)").option("--task <description>", "Task description (interactive if omitted)").option("--context <level>", "Execution context: shell | ui | reallife (default: shell)", "shell").option("--skip-review", "Skip the repetition phase and go straight to task selection").option("--review-minutes <n>", "Maximum minutes for the repetition phase (default: 20)", "20").option("--json", "Output as JSON").option("--quiet", "Output only the session ID").action(async (opts) => {
+  let db;
+  try {
+    db = openDatabase();
+    const validContexts = ["shell", "ui", "reallife"];
+    if (!validContexts.includes(opts.context)) {
+      console.error(`Invalid context: ${opts.context}. Must be one of: ${validContexts.join(", ")}`);
+      process.exit(1);
+    }
+    const userId = resolveUser(opts, db);
+    const reviewMinutes = Number(opts.reviewMinutes);
+    if (!opts.skipReview && !opts.quiet && !opts.json) {
+      const reviewResults = await runRepetitionPhase(db, userId, reviewMinutes);
+      if (reviewResults.reviewed > 0) {
+        console.log();
+      }
+    }
+    let task = opts.task;
+    if (!task && !opts.quiet && !opts.json) {
+      task = await selectTask(db);
+    }
+    if (!task) {
+      console.error("Task description is required. Use --task or run interactively.");
+      process.exit(1);
+    }
+    const session = startSession(db, {
+      user_id: userId,
+      task,
+      execution_context: opts.context
+    });
+    db.close();
+    if (opts.quiet) {
+      console.log(session.id);
+    } else if (opts.json) {
+      console.log(JSON.stringify(session, null, 2));
+    } else {
+      console.log(`
+Session started: ${session.id}`);
+      console.log(`  User:    ${session.user_id}`);
+      console.log(`  Task:    ${session.task}`);
+      console.log(`  Context: ${session.execution_context}`);
+      console.log(`  Started: ${session.started_at}`);
+    }
+  } catch (err) {
+    db?.close();
+    if (err.name === "ExitPromptError") {
+      console.log("\nSession cancelled.");
+      process.exit(0);
+    }
+    console.error("Error:", err.message);
+    process.exit(1);
+  }
+});
+async function runRepetitionPhase(db, userId, maxMinutes) {
+  const queue = buildReviewQueue(db, { userId });
+  if (queue.items.length === 0) {
+    console.log("No cards due for review \u2014 moving to task selection.\n");
+    return { reviewed: 0, skipped: false };
+  }
+  console.log("\u2550".repeat(50));
+  console.log("Phase 1: Repetition");
+  console.log("\u2550".repeat(50));
+  console.log(`${queue.items.length} card(s) due`);
+  console.log(`  New: ${queue.newCount}  Review: ${queue.reviewCount}  Relearn: ${queue.relearnCount}`);
+  console.log(`  Domains: ${queue.totalDomains.join(", ")}`);
+  console.log(`  Time limit: ${maxMinutes} minutes (skip anytime with 's')`);
+  console.log();
+  const startTime = Date.now();
+  const timeLimitMs = maxMinutes * 60 * 1e3;
+  let reviewed = 0;
+  for (const item of queue.items) {
+    if (Date.now() - startTime >= timeLimitMs) {
+      console.log(`
+Time limit reached (${maxMinutes} min). Moving to task selection.`);
+      break;
+    }
+    reviewed++;
+    const prompt = generatePrompt({
+      cardId: item.cardId,
+      tokenId: item.tokenId,
+      slug: item.slug,
+      concept: item.concept,
+      domain: item.domain,
+      bloomLevel: item.bloomLevel
+    });
+    const elapsed = Math.round((Date.now() - startTime) / 6e4);
+    console.log(`[${reviewed}/${queue.items.length}] ${prompt.bloomVerb} (Bloom ${prompt.bloomLevel}) \u2014 ${elapsed}/${maxMinutes} min`);
+    console.log(`Domain: ${prompt.domain || "(none)"}`);
+    console.log(`
+  ${prompt.question}
+`);
+    const rating = await select({
+      message: "How did you do?",
+      choices: [
+        { name: "1 - Again (forgot)", value: 1 },
+        { name: "2 - Hard", value: 2 },
+        { name: "3 - Good", value: 3 },
+        { name: "4 - Easy", value: 4 },
+        { name: "s - Skip to task selection", value: 0 }
+      ]
+    });
+    if (rating === 0) {
+      console.log("Skipping to task selection.");
+      reviewed--;
+      return { reviewed, skipped: true };
+    }
+    const evalResult = evaluateRating(db, {
+      cardId: item.cardId,
+      tokenId: item.tokenId,
+      userId,
+      rating
+    });
+    if (rating === 1) {
+      const prereqs = getPrerequisites(db, item.tokenId);
+      if (prereqs.length > 0) {
+        const blockResult = cascadeBlock(db, userId, item.slug);
+        console.log(`  Blocked ${blockResult.blockedSlug}. Review these prerequisites:`);
+        for (const p of blockResult.prerequisites) {
+          console.log(`    - ${p.slug}: ${p.concept}`);
+        }
+      }
+    }
+    const ratingLabels = { 1: "Again", 2: "Hard", 3: "Good", 4: "Easy" };
+    console.log(`  ${ratingLabels[rating]} \u2014 next due: ${evalResult.nextDueAt}
+`);
+  }
+  if (reviewed > 0) {
+    console.log("\u2500".repeat(50));
+    console.log(`Repetition complete \u2014 ${reviewed} card(s) reviewed.`);
+  }
+  return { reviewed, skipped: false };
+}
+async function selectTask(db) {
+  console.log("\u2550".repeat(50));
+  console.log("Phase 2: Task Selection");
+  console.log("\u2550".repeat(50));
+  const adoConfig = loadADOConfig(db);
+  if (adoConfig) {
+    const items = await fetchActiveWorkItems(adoConfig);
+    if (items.length > 0) {
+      const choices = items.map((wi) => ({
+        name: `[${wi.type}] ${wi.title} (${wi.state})`,
+        value: `[ADO-${wi.id}] ${wi.title}`
+      }));
+      choices.push({ name: "Enter a custom task...", value: "__custom__" });
+      const picked = await select({
+        message: `${items.length} active work item(s) \u2014 pick one:`,
+        choices
+      });
+      if (picked !== "__custom__") return picked;
+    } else {
+      console.log("No active work items found in Azure DevOps.");
+    }
+  }
+  return input({ message: "Task description:" });
+}
+sessionCommand.command("log").description("Log a step within a session").requiredOption("--session <id>", "Session ID").requiredOption("--token <slug>", "Token slug").requiredOption("--done-by <who>", "Who performed the step (user or agent)").option("--rating <n>", "Rating (1-4)").option("--json", "Output as JSON").option("--quiet", "Suppress output (exit code only)").action((opts) => {
+  withDb3((db) => {
+    const token = getTokenBySlug(db, opts.token);
+    if (!token) {
+      console.error(`Token not found: ${opts.token}`);
+      process.exit(1);
+    }
+    const step = logStep(db, {
+      session_id: opts.session,
+      token_id: token.id,
+      done_by: opts.doneBy,
+      rating: opts.rating ? Number(opts.rating) : void 0
+    });
+    if (opts.quiet) return;
+    if (opts.json) {
+      console.log(JSON.stringify(step, null, 2));
+    } else {
+      console.log(`Step logged: ${step.id}`);
+      console.log(`  Token:   ${opts.token}`);
+      console.log(`  Done by: ${step.done_by}`);
+      if (step.rating != null) {
+        console.log(`  Rating:  ${step.rating}`);
+      }
+    }
+  });
+});
+sessionCommand.command("end").description("End a session and show summary").requiredOption("--session <id>", "Session ID").option("--json", "Output as JSON").action((opts) => {
+  withDb3((db) => {
+    endSession(db, opts.session);
+    const summary = getSessionSummary(db, opts.session);
+    if (opts.json) {
+      console.log(JSON.stringify(summary, null, 2));
+      return;
+    }
+    console.log(`Session ${summary.session.id} completed.`);
+    console.log(`  Task: ${summary.session.task}`);
+    console.log(`  Started:   ${summary.session.started_at}`);
+    console.log(`  Completed: ${summary.session.completed_at}`);
+    console.log(`  Steps:     ${summary.steps.length}`);
+    if (summary.steps.length > 0) {
+      console.log("\nSteps:");
+      console.log(
+        "  Token                 Done by  Rating  Concept"
+      );
+      console.log("  " + "\u2500".repeat(70));
+      for (const s of summary.steps) {
+        console.log(
+          `  ${s.slug.padEnd(21)} ${s.done_by.padEnd(8)} ${String(s.rating ?? "-").padEnd(7)} ${s.concept.slice(0, 30)}`
+        );
+      }
+    }
+  });
+});
+
+// src/cli/commands/stats.ts
+import { Command as Command6 } from "commander";
+function withDb4(fn) {
+  let db;
+  try {
+    db = openDatabase();
+    fn(db);
+  } catch (err) {
+    console.error("Error:", err.message);
+    process.exit(1);
+  } finally {
+    db?.close();
+  }
+}
+var statsCommand = new Command6("stats").description("Show learning dashboard for a user").option("--user <id>", "User ID (default: whoami)").option("--json", "Output as JSON").action((opts) => {
+  withDb4((db) => {
+    const userId = resolveUser(opts, db);
+    const stats = getUserStats(db, userId);
+    const domains = getDomainCompetence(db, userId);
+    if (opts.json) {
+      console.log(JSON.stringify({ stats, domains }, null, 2));
+      return;
+    }
+    console.log(`Learning Dashboard \u2014 ${stats.userId}`);
+    console.log("\u2550".repeat(50));
+    console.log(`  Total tokens:     ${stats.totalTokens}`);
+    console.log(`  Cards in deck:    ${stats.cardsInDeck}`);
+    console.log(`  Due today:        ${stats.dueToday}`);
+    console.log(`  Blocked:          ${stats.blocked}`);
+    console.log(`  Mature:           ${stats.mature}`);
+    console.log(`  Avg stability:    ${stats.avgStability ?? "N/A"}`);
+    console.log(`  Total sessions:   ${stats.totalSessions}`);
+    console.log(`  Last session:     ${stats.lastSession ?? "N/A"}`);
+    if (domains.length > 0) {
+      console.log("\nDomain Competence:");
+      console.log("\u2500".repeat(80));
+      console.log(
+        "  Domain           Cards  Mature  Stability  Retention  Suggested Mode"
+      );
+      console.log("  " + "\u2500".repeat(74));
+      for (const d of domains) {
+        console.log(
+          `  ${d.domain.padEnd(17)} ${String(d.totalCards).padEnd(6)} ${String(d.matureCards).padEnd(7)} ${String(d.avgStability).padEnd(10)} ${(d.retentionRate * 100).toFixed(1).padStart(5)}%     ${d.suggestedMode}`
+        );
+      }
+    }
+  });
+});
+
+// src/cli/commands/review.ts
+import { Command as Command7 } from "commander";
+import { select as select2 } from "@inquirer/prompts";
+var reviewCommand = new Command7("review").description("Start an interactive review session").option("--user <id>", "User ID (default: whoami)").option("--max-new <n>", "Maximum new cards", "10").option("--max-reviews <n>", "Maximum review cards", "50").action(async (opts) => {
+  let db;
+  try {
+    db = openDatabase();
+    const userId = resolveUser(opts, db);
+    const queue = buildReviewQueue(db, {
+      userId,
+      maxNew: Number(opts.maxNew),
+      maxReviews: Number(opts.maxReviews)
+    });
+    if (queue.items.length === 0) {
+      console.log("No cards due for review. You're all caught up!");
+      db.close();
+      return;
+    }
+    console.log(`
+Review session: ${queue.items.length} card(s)`);
+    console.log(`  New: ${queue.newCount}  Review: ${queue.reviewCount}  Relearn: ${queue.relearnCount}`);
+    console.log(`  Domains: ${queue.totalDomains.join(", ")}`);
+    console.log();
+    let completed = 0;
+    const results = [];
+    for (const item of queue.items) {
+      completed++;
+      const prompt = generatePrompt({
+        cardId: item.cardId,
+        tokenId: item.tokenId,
+        slug: item.slug,
+        concept: item.concept,
+        domain: item.domain,
+        bloomLevel: item.bloomLevel
+      });
+      console.log(`
+[${completed}/${queue.items.length}] ${prompt.bloomVerb} (Bloom ${prompt.bloomLevel})`);
+      console.log(`Domain: ${prompt.domain || "(none)"}`);
+      console.log(`
+  ${prompt.question}
+`);
+      const rating = await select2({
+        message: "How did you do?",
+        choices: [
+          { name: "1 - Again (forgot)", value: 1 },
+          { name: "2 - Hard", value: 2 },
+          { name: "3 - Good", value: 3 },
+          { name: "4 - Easy", value: 4 }
+        ]
+      });
+      const evalResult = evaluateRating(db, {
+        cardId: item.cardId,
+        tokenId: item.tokenId,
+        userId,
+        rating
+      });
+      if (rating === 1) {
+        const prereqs = getPrerequisites(db, item.tokenId);
+        if (prereqs.length > 0) {
+          const blockResult = cascadeBlock(db, userId, item.slug);
+          console.log(`  Blocked ${blockResult.blockedSlug}. Review these prerequisites:`);
+          for (const p of blockResult.prerequisites) {
+            console.log(`    - ${p.slug}: ${p.concept}`);
+          }
+        }
+      }
+      const ratingLabels = { 1: "Again", 2: "Hard", 3: "Good", 4: "Easy" };
+      console.log(`  ${ratingLabels[rating]} \u2014 next due: ${evalResult.nextDueAt}`);
+      results.push({
+        slug: item.slug,
+        rating,
+        nextDue: evalResult.nextDueAt
+      });
+    }
+    console.log("\n" + "\u2550".repeat(50));
+    console.log("Review session complete!");
+    console.log(`  Cards reviewed: ${results.length}`);
+    const avgRating = results.reduce((s, r) => s + r.rating, 0) / results.length;
+    console.log(`  Average rating: ${avgRating.toFixed(1)}`);
+    const forgot = results.filter((r) => r.rating === 1).length;
+    if (forgot > 0) {
+      console.log(`  Forgot: ${forgot} card(s)`);
+    }
+    db.close();
+  } catch (err) {
+    db?.close();
+    if (err.name === "ExitPromptError") {
+      console.log("\nReview session cancelled.");
+      process.exit(0);
+    }
+    console.error("Error:", err.message);
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/bridge.ts
+import { Command as Command8 } from "commander";
+import { readdirSync as readdirSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join5 } from "path";
+function jsonOut(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function jsonError(message) {
+  console.log(JSON.stringify({ error: message }, null, 2));
+  process.exit(1);
+}
+function withDb5(fn) {
+  let db;
+  try {
+    db = openDatabase();
+    fn(db);
+  } catch (err) {
+    db?.close();
+    jsonError(err.message);
+  } finally {
+    db?.close();
+  }
+}
+var bridgeCommand = new Command8("bridge").description("Machine-readable JSON protocol for AI integration");
+bridgeCommand.command("check-due").description("Check due cards for a user (JSON)").option("--user <id>", "User ID (default: whoami)").action((opts) => {
+  withDb5((db) => {
+    const userId = resolveUser(opts, db, { json: true });
+    const dueCards = getDueCards(db, userId);
+    const domains = [...new Set(dueCards.map((c) => c.domain).filter(Boolean))].sort();
+    jsonOut({
+      userId,
+      dueCount: dueCards.length,
+      domains,
+      cards: dueCards.map((c) => ({
+        cardId: c.id,
+        tokenId: c.token_id,
+        slug: c.slug,
+        concept: c.concept,
+        domain: c.domain,
+        bloomLevel: c.bloom_level,
+        state: c.state,
+        dueAt: c.due_at
+      }))
+    });
+  });
+});
+bridgeCommand.command("get-review").description("Get next review card with prompt (JSON)").option("--user <id>", "User ID (default: whoami)").action((opts) => {
+  withDb5((db) => {
+    const userId = resolveUser(opts, db, { json: true });
+    const queue = buildReviewQueue(db, { userId, maxReviews: 1, maxNew: 1 });
+    if (queue.items.length === 0) {
+      jsonOut({
+        userId,
+        hasReview: false,
+        card: null,
+        prompt: null,
+        queueSize: 0
+      });
+      return;
+    }
+    const item = queue.items[0];
+    const prompt = generatePrompt({
+      cardId: item.cardId,
+      tokenId: item.tokenId,
+      slug: item.slug,
+      concept: item.concept,
+      domain: item.domain,
+      bloomLevel: item.bloomLevel
+    });
+    const fullQueue = buildReviewQueue(db, { userId });
+    jsonOut({
+      userId,
+      hasReview: true,
+      card: item,
+      prompt,
+      queueSize: fullQueue.items.length
+    });
+  });
+});
+bridgeCommand.command("submit").description("Submit a rating for a card (JSON)").option("--user <id>", "User ID (default: whoami)").requiredOption("--card-id <id>", "Card ID").requiredOption("--rating <n>", "Rating (1-4)").action((opts) => {
+  withDb5((db) => {
+    const userId = resolveUser(opts, db, { json: true });
+    const rating = Number(opts.rating);
+    if (rating < 1 || rating > 4) {
+      jsonError("Rating must be between 1 and 4");
+    }
+    const card = db.prepare("SELECT * FROM cards WHERE id = ?").get(opts.cardId);
+    if (!card) {
+      jsonError(`Card not found: ${opts.cardId}`);
+    }
+    const result = evaluateRating(db, {
+      cardId: opts.cardId,
+      tokenId: card.token_id,
+      userId,
+      rating
+    });
+    let blocked = null;
+    if (rating === 1) {
+      const token = db.prepare("SELECT slug FROM tokens WHERE id = ?").get(card.token_id);
+      if (token) {
+        const prereqs = getPrerequisites(db, card.token_id);
+        if (prereqs.length > 0) {
+          blocked = cascadeBlock(db, userId, token.slug);
+        }
+      }
+    }
+    jsonOut({
+      success: true,
+      rating,
+      evaluation: result,
+      blocked
+    });
+  });
+});
+bridgeCommand.command("get-skill").description("Get an agent skill by slug (JSON)").requiredOption("--slug <slug>", "Skill slug").action((opts) => {
+  withDb5((db) => {
+    const skill = getAgentSkill(db, opts.slug);
+    if (!skill) {
+      jsonError(`Skill not found: ${opts.slug}`);
+    }
+    jsonOut({
+      slug: skill.slug,
+      description: skill.description,
+      steps: skill.steps,
+      tokenSlugs: skill.token_slugs,
+      source: skill.source
+    });
+  });
+});
+bridgeCommand.command("get-monitor").description("Read monitor log for a session (JSON)").requiredOption("--session <id>", "Session ID").action((opts) => {
+  if (!monitorLogExists(opts.session)) {
+    jsonOut({ sessionId: opts.session, exists: false, commands: [], timeSpan: null });
+    return;
+  }
+  const events = readMonitorLog(opts.session);
+  const commands = pairCommands(events);
+  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()
+    };
+  }
+  jsonOut({
+    sessionId: opts.session,
+    exists: true,
+    commands: commands.map((c) => ({
+      seq: c.seq,
+      command: c.command,
+      cwd: c.cwd,
+      startedAt: c.startedAt,
+      endedAt: c.endedAt,
+      durationMs: c.durationMs,
+      exitCode: c.exitCode
+    })),
+    timeSpan
+  });
+});
+bridgeCommand.command("analyze-monitor").description("Analyze monitor log with token patterns from stdin (JSON)").requiredOption("--session <id>", "Session ID").action(async (opts) => {
+  try {
+    if (!monitorLogExists(opts.session)) {
+      jsonOut({ sessionId: opts.session, ratings: [], unmatchedCommands: [], timeSpan: null });
+      return;
+    }
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    const raw = Buffer.concat(chunks).toString("utf-8").trim();
+    if (!raw) {
+      jsonError("No input received on stdin. Pipe JSON with token patterns.");
+    }
+    let data;
+    try {
+      data = JSON.parse(raw);
+    } catch {
+      jsonError("Invalid JSON input");
+    }
+    if (!Array.isArray(data.patterns)) {
+      jsonError("JSON must include 'patterns' array");
+    }
+    const events = readMonitorLog(opts.session);
+    const commands = pairCommands(events);
+    const result = analyzeObservation(commands, data.patterns);
+    jsonOut({
+      sessionId: opts.session,
+      ...result
+    });
+  } catch (err) {
+    jsonError(err.message);
+  }
+});
+bridgeCommand.command("add-token").description("Create a token + card from JSON stdin").option("--user <id>", "User ID (default: whoami)").action(async (opts) => {
+  let db;
+  try {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    const raw = Buffer.concat(chunks).toString("utf-8").trim();
+    if (!raw) {
+      jsonError("No input received on stdin. Pipe JSON with token data.");
+    }
+    let data;
+    try {
+      data = JSON.parse(raw);
+    } catch {
+      jsonError("Invalid JSON input");
+    }
+    if (!data.slug || !data.concept) {
+      jsonError("JSON must include 'slug' and 'concept' fields");
+    }
+    db = openDatabase();
+    const userId = resolveUser(opts, db, { json: true });
+    const token = createToken(db, {
+      slug: data.slug,
+      concept: data.concept,
+      domain: data.domain,
+      bloom_level: data.bloom_level ?? 1,
+      context: data.context,
+      symbiosis_mode: data.symbiosis_mode
+    });
+    const card = ensureCard(db, token.id, userId);
+    jsonOut({
+      success: true,
+      token,
+      card: {
+        id: card.id,
+        tokenId: card.token_id,
+        userId: card.user_id,
+        state: card.state,
+        dueAt: card.due_at,
+        blocked: card.blocked
+      }
+    });
+    db.close();
+  } catch (err) {
+    db?.close();
+    if (err.message) {
+      jsonError(err.message);
+    }
+  }
+});
+bridgeCommand.command("discover-skills").description("Analyze monitor logs across sessions to discover recurring patterns").option("--min-sessions <n>", "Minimum sessions a pattern must appear in (default: 2)", "2").option("--limit <n>", "Max number of sessions to analyze (default: 20)", "20").action((opts) => {
+  try {
+    const monitorDir = join5(homedir3(), ".zam", "monitor");
+    let files;
+    try {
+      files = readdirSync2(monitorDir).filter((f) => f.endsWith(".jsonl"));
+    } catch {
+      jsonOut({ proposals: [], message: "No monitor logs found." });
+      return;
+    }
+    if (files.length === 0) {
+      jsonOut({ proposals: [], message: "No monitor logs found." });
+      return;
+    }
+    const limit = Number(opts.limit);
+    const sorted = files.map((f) => ({ name: f, path: join5(monitorDir, f) })).sort((a, b) => b.name.localeCompare(a.name)).slice(0, limit);
+    const sessionCommands = /* @__PURE__ */ new Map();
+    for (const file of sorted) {
+      const sessionId = file.name.replace(".jsonl", "");
+      const events = readMonitorLog(sessionId);
+      const commands = pairCommands(events);
+      if (commands.length > 0) {
+        sessionCommands.set(sessionId, commands);
+      }
+    }
+    if (sessionCommands.size === 0) {
+      jsonOut({ proposals: [], message: "No command data in monitor logs." });
+      return;
+    }
+    let existingSkillSlugs = [];
+    let db;
+    try {
+      db = openDatabase();
+      existingSkillSlugs = listAgentSkills(db).map((s) => s.slug);
+    } catch {
+    } finally {
+      db?.close();
+    }
+    const proposals = discoverSkills(sessionCommands, {
+      minSessions: Number(opts.minSessions),
+      existingSkillSlugs
+    });
+    jsonOut({
+      sessionsAnalyzed: sessionCommands.size,
+      proposals
+    });
+  } catch (err) {
+    jsonError(err.message);
+  }
+});
+
+// src/cli/commands/skill.ts
+import { Command as Command9 } from "commander";
+function withDb6(fn) {
+  let db;
+  try {
+    db = openDatabase();
+    fn(db);
+  } catch (err) {
+    console.error("Error:", err.message);
+    process.exit(1);
+  } finally {
+    db?.close();
+  }
+}
+var skillCommand = new Command9("skill").description("Manage agent skill entries (task recipes)");
+skillCommand.command("list").description("List all agent skills").option("--json", "Output as JSON").action((opts) => {
+  withDb6((db) => {
+    const skills = listAgentSkills(db);
+    if (opts.json) {
+      console.log(JSON.stringify(skills, null, 2));
+      return;
+    }
+    if (skills.length === 0) {
+      console.log("No agent skills registered yet.");
+      return;
+    }
+    console.log(`Agent Skills (${skills.length})`);
+    console.log("\u2500".repeat(60));
+    for (const s of skills) {
+      console.log(`  ${s.slug.padEnd(30)} [${s.source}]  ${s.description.slice(0, 40)}`);
+      console.log(`    ${s.steps.length} step(s)  tokens: ${s.token_slugs.join(", ") || "none"}`);
+    }
+  });
+});
+skillCommand.command("show").description("Show a specific agent skill").requiredOption("--slug <slug>", "Skill slug").option("--json", "Output as JSON").action((opts) => {
+  withDb6((db) => {
+    const skill = getAgentSkill(db, opts.slug);
+    if (!skill) {
+      console.error(`Skill not found: ${opts.slug}`);
+      process.exit(1);
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(skill, null, 2));
+      return;
+    }
+    console.log(`Skill: ${skill.slug}`);
+    console.log(`  Description: ${skill.description}`);
+    console.log(`  Source:      ${skill.source}`);
+    console.log(`  Tokens:      ${skill.token_slugs.join(", ") || "none"}`);
+    console.log(`  Created:     ${skill.created_at}`);
+    console.log(`
+Steps:`);
+    skill.steps.forEach((step, i) => {
+      console.log(`  ${i + 1}. ${step}`);
+    });
+  });
+});
+skillCommand.command("add").description("Register a new agent skill").requiredOption("--slug <slug>", "Unique skill identifier").requiredOption("--description <text>", "One-sentence description").requiredOption("--steps <json>", "JSON array of step strings").option("--tokens <slugs>", "Comma-separated token slugs related to this skill").option("--source <type>", "Source: learned | builtin (default: learned)", "learned").option("--json", "Output as JSON").action((opts) => {
+  withDb6((db) => {
+    let steps;
+    try {
+      steps = JSON.parse(opts.steps);
+      if (!Array.isArray(steps)) throw new Error("steps must be a JSON array");
+    } catch {
+      console.error("Invalid --steps: must be a valid JSON array of strings");
+      process.exit(1);
+    }
+    const tokenSlugs = opts.tokens ? opts.tokens.split(",").map((s) => s.trim()).filter(Boolean) : [];
+    const skill = createAgentSkill(db, {
+      slug: opts.slug,
+      description: opts.description,
+      steps,
+      token_slugs: tokenSlugs,
+      source: opts.source
+    });
+    if (opts.json) {
+      console.log(JSON.stringify(skill, null, 2));
+    } else {
+      console.log(`Skill registered: ${skill.slug}`);
+      console.log(`  ${skill.steps.length} step(s) saved`);
+    }
+  });
+});
+
+// src/cli/commands/monitor.ts
+import { Command as Command10 } from "commander";
+import { basename as basename3, join as join6 } from "path";
+import { execSync } from "child_process";
+import { writeFileSync as writeFileSync3, unlinkSync } from "fs";
+import { tmpdir } from "os";
+function detectShell() {
+  const shell = process.env.SHELL ?? "";
+  return basename3(shell) === "bash" ? "bash" : "zsh";
+}
+var monitorCommand = new Command10("monitor").description("Shell observation for real-time task monitoring");
+monitorCommand.command("start").description("Output shell hook code to install monitoring (wrap with eval)").requiredOption("--session <id>", "Session ID to monitor").option("--shell <type>", "Shell type: zsh | bash (auto-detected from $SHELL)").action((opts) => {
+  let db;
+  try {
+    db = openDatabase();
+    const session = db.prepare("SELECT id, completed_at FROM sessions WHERE id = ?").get(opts.session);
+    if (!session) {
+      console.error(`# Error: Session not found: ${opts.session}`);
+      process.exit(1);
+    }
+    if (session.completed_at) {
+      console.error(`# Error: Session already completed: ${opts.session}`);
+      process.exit(1);
+    }
+  } catch (err) {
+    console.error(`# Error: ${err.message}`);
+    process.exit(1);
+  } finally {
+    db?.close();
+  }
+  ensureMonitorDir();
+  const monitorFile = getMonitorPath(opts.session);
+  const meta = {
+    type: "monitor_meta",
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    event: "start",
+    session_id: opts.session,
+    shell: opts.shell ?? detectShell(),
+    pid: process.pid
+  };
+  writeMonitorEvent(opts.session, meta);
+  const shell = opts.shell ?? detectShell();
+  if (shell === "bash") {
+    console.log(generateBashHooks(monitorFile, opts.session));
+  } else {
+    console.log(generateZshHooks(monitorFile, opts.session));
+  }
+});
+monitorCommand.command("stop").description("Output shell code to remove monitoring hooks (wrap with eval)").requiredOption("--session <id>", "Session ID").option("--shell <type>", "Shell type: zsh | bash (auto-detected from $SHELL)").action((opts) => {
+  if (monitorLogExists(opts.session)) {
+    const meta = {
+      type: "monitor_meta",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      event: "stop",
+      session_id: opts.session
+    };
+    writeMonitorEvent(opts.session, meta);
+  }
+  const shell = opts.shell ?? detectShell();
+  if (shell === "bash") {
+    console.log(generateBashUnhooks());
+  } else {
+    console.log(generateZshUnhooks());
+  }
+});
+monitorCommand.command("status").description("Show monitoring status for a session").requiredOption("--session <id>", "Session ID").option("--json", "Output as JSON").action((opts) => {
+  const stats = getMonitorLogStats(opts.session);
+  if (!stats.exists) {
+    if (opts.json) {
+      console.log(JSON.stringify({ exists: false }));
+    } else {
+      console.log(`No monitor log found for session ${opts.session}`);
+    }
+    return;
+  }
+  const events = readMonitorLog(opts.session);
+  const commands = pairCommands(events);
+  const errors = commands.filter((c) => c.exitCode != null && c.exitCode !== 0).length;
+  const meta = events.find((e) => e.type === "monitor_meta" && e.event === "start");
+  const stopped = events.some((e) => e.type === "monitor_meta" && e.event === "stop");
+  const result = {
+    sessionId: opts.session,
+    exists: true,
+    active: !stopped,
+    shell: meta?.shell ?? "unknown",
+    totalCommands: commands.length,
+    errors,
+    sizeBytes: stats.sizeBytes,
+    timeSpan: commands.length > 0 ? {
+      start: commands[0].startedAt,
+      end: commands[commands.length - 1].endedAt ?? commands[commands.length - 1].startedAt
+    } : null
+  };
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(`Monitor: ${opts.session}`);
+  console.log(`  Status:   ${result.active ? "active" : "stopped"}`);
+  console.log(`  Shell:    ${result.shell}`);
+  console.log(`  Commands: ${result.totalCommands}`);
+  console.log(`  Errors:   ${result.errors}`);
+  if (result.timeSpan) {
+    console.log(`  From:     ${result.timeSpan.start}`);
+    console.log(`  To:       ${result.timeSpan.end}`);
+  }
+});
+function resolveZamBin() {
+  try {
+    const which = execSync("which zam 2>/dev/null", { encoding: "utf-8" }).trim();
+    if (which) return which;
+  } catch {
+  }
+  const projectRoot = join6(import.meta.dirname, "..", "..", "..");
+  return `npx --prefix ${JSON.stringify(projectRoot)} tsx ${join6(projectRoot, "src/cli/index.ts")}`;
+}
+function isItermRunning() {
+  try {
+    const result = execSync(
+      `osascript -e 'tell application "System Events" to (name of processes) contains "iTerm2"' 2>/dev/null`,
+      { encoding: "utf-8" }
+    ).trim();
+    return result === "true";
+  } catch {
+    return false;
+  }
+}
+monitorCommand.command("open").description("Open a new monitored terminal window for a session").requiredOption("--session <id>", "Session ID to monitor").option("--dir <path>", "Working directory (defaults to cwd)").option("--shell <type>", "Shell type: zsh | bash (auto-detected from $SHELL)").action((opts) => {
+  let db;
+  try {
+    db = openDatabase();
+    const session = db.prepare("SELECT id, completed_at FROM sessions WHERE id = ?").get(opts.session);
+    if (!session) {
+      console.error(`Error: Session not found: ${opts.session}`);
+      process.exit(1);
+    }
+    if (session.completed_at) {
+      console.error(`Error: Session already completed: ${opts.session}`);
+      process.exit(1);
+    }
+    if (!getSetting(db, "monitor_method")) {
+      setSetting(db, "monitor_method", "terminal");
+    }
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  } finally {
+    db?.close();
+  }
+  const dir = opts.dir ?? process.cwd();
+  const zamBin = resolveZamBin();
+  const shellSetup = `cd ${JSON.stringify(dir)} && eval "$(${zamBin} monitor start --session ${opts.session})"`;
+  if (process.platform === "darwin") {
+    openMacTerminal(shellSetup, opts.session, dir);
+  } else {
+    console.log(`Run this in a new terminal:
+`);
+    console.log(`  ${shellSetup}
+`);
+    console.log(`(Automatic terminal opening is only supported on macOS for now.)`);
+  }
+});
+function openMacTerminal(shellSetup, sessionId, dir) {
+  const useIterm = isItermRunning();
+  const escaped = shellSetup.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  const appleScript = useIterm ? `tell application "iTerm2"
+  activate
+  set newWindow to (create window with default profile)
+  tell current session of newWindow
+    write text "${escaped}"
+  end tell
+end tell` : `tell application "Terminal"
+  activate
+  do script "${escaped}"
+end tell`;
+  const tmpFile = join6(tmpdir(), `zam-monitor-${sessionId}.scpt`);
+  try {
+    writeFileSync3(tmpFile, appleScript);
+    execSync(`osascript ${JSON.stringify(tmpFile)}`, { stdio: "ignore" });
+    console.log(`Opened ${useIterm ? "iTerm2" : "Terminal.app"} window with monitoring for session ${sessionId}`);
+    console.log(`  Directory: ${dir}`);
+  } catch (err) {
+    console.error(`Failed to open terminal: ${err.message}`);
+    console.log(`
+Run this manually in a new terminal:
+`);
+    console.log(`  ${shellSetup}`);
+  } finally {
+    try {
+      unlinkSync(tmpFile);
+    } catch {
+    }
+  }
+}
+
+// src/cli/commands/settings.ts
+import { Command as Command11 } from "commander";
+function withDb7(fn) {
+  let db;
+  try {
+    db = openDatabase();
+    fn(db);
+  } catch (err) {
+    console.error("Error:", err.message);
+    process.exit(1);
+  } finally {
+    db?.close();
+  }
+}
+var settingsCommand = new Command11("settings").description("Manage user settings");
+settingsCommand.command("show").description("Show all settings").option("--json", "Output as JSON").action((opts) => {
+  withDb7((db) => {
+    if (opts.json) {
+      console.log(JSON.stringify(getAllSettings(db), null, 2));
+      return;
+    }
+    const settings = getAllSettingsDetailed(db);
+    if (settings.length === 0) {
+      console.log("No settings configured.");
+      return;
+    }
+    console.log("Settings:\n");
+    console.log("Key                  Value                Updated");
+    console.log("\u2500".repeat(65));
+    for (const s of settings) {
+      console.log(
+        `${s.key.padEnd(20)} ${s.value.padEnd(20)} ${s.updated_at}`
+      );
+    }
+  });
+});
+settingsCommand.command("get").description("Get a single setting").requiredOption("--key <key>", "Setting key").option("--json", "Output as JSON").action((opts) => {
+  withDb7((db) => {
+    const value = getSetting(db, opts.key);
+    if (opts.json) {
+      console.log(JSON.stringify({ key: opts.key, value: value ?? null }));
+      return;
+    }
+    if (value === void 0) {
+      console.log(`Not set: ${opts.key}`);
+    } else {
+      console.log(value);
+    }
+  });
+});
+settingsCommand.command("set").description("Set a setting").requiredOption("--key <key>", "Setting key").requiredOption("--value <value>", "Setting value").option("--quiet", "Suppress output").action((opts) => {
+  withDb7((db) => {
+    setSetting(db, opts.key, opts.value);
+    if (!opts.quiet) {
+      console.log(`Set ${opts.key} = ${opts.value}`);
+    }
+  });
+});
+settingsCommand.command("delete").description("Delete a setting").requiredOption("--key <key>", "Setting key").option("--quiet", "Suppress output").action((opts) => {
+  withDb7((db) => {
+    const deleted = deleteSetting(db, opts.key);
+    if (!opts.quiet) {
+      if (deleted) {
+        console.log(`Deleted: ${opts.key}`);
+      } else {
+        console.log(`Not found: ${opts.key}`);
+      }
+    }
+  });
+});
+
+// src/cli/commands/whoami.ts
+import { Command as Command12 } from "commander";
+function withDb8(fn) {
+  let db;
+  try {
+    db = openDatabase();
+    fn(db);
+  } catch (err) {
+    console.error("Error:", err.message);
+    process.exit(1);
+  } finally {
+    db?.close();
+  }
+}
+var whoamiCommand = new Command12("whoami").description("Show or set the default user identity").option("--set <id>", "Set the default user ID").option("--clear", "Remove the default user ID").option("--json", "Output as JSON").action((opts) => {
+  withDb8((db) => {
+    if (opts.set) {
+      setSetting(db, "user.id", opts.set);
+      if (opts.json) {
+        console.log(JSON.stringify({ userId: opts.set }));
+      } else {
+        console.log(`Default user set to: ${opts.set}`);
+      }
+      return;
+    }
+    if (opts.clear) {
+      const deleted = deleteSetting(db, "user.id");
+      if (opts.json) {
+        console.log(JSON.stringify({ userId: null, cleared: deleted }));
+      } else if (deleted) {
+        console.log("Default user cleared.");
+      } else {
+        console.log("No default user was set.");
+      }
+      return;
+    }
+    const userId = getSetting(db, "user.id");
+    if (opts.json) {
+      console.log(JSON.stringify({ userId: userId ?? null }));
+      return;
+    }
+    if (userId) {
+      console.log(userId);
+    } else {
+      console.log("No default user set. Use: zam whoami --set <id>");
+    }
+  });
+});
+
+// src/cli/commands/connector.ts
+import { Command as Command13 } from "commander";
+import { input as input3, password } from "@inquirer/prompts";
+function withDb9(fn) {
+  let db;
+  try {
+    db = openDatabase();
+    fn(db);
+  } catch (err) {
+    console.error("Error:", err.message);
+    process.exit(1);
+  } finally {
+    db?.close();
+  }
+}
+var connectorCommand = new Command13("connector").description("Manage external service connectors");
+connectorCommand.command("setup").description("Configure a connector").argument("<type>", "Connector type (ado, turso)").action(async (type) => {
+  if (type === "turso") {
+    return setupTurso();
+  }
+  if (type !== "ado") {
+    console.error(`Unknown connector type: ${type}. Supported: ado, turso`);
+    process.exit(1);
+  }
+  let db;
+  try {
+    const orgUrl = await input3({
+      message: "Organization URL (e.g. https://dev.azure.com/myorg):"
+    });
+    const project = await input3({
+      message: "Project name:"
+    });
+    const pat = await password({
+      message: "Personal Access Token:"
+    });
+    if (!orgUrl || !project || !pat) {
+      console.error("All fields are required.");
+      process.exit(1);
+    }
+    db = openDatabase();
+    setSetting(db, "ado.org_url", orgUrl.replace(/\/+$/, ""));
+    setSetting(db, "ado.project", project);
+    setSetting(db, "ado.pat", pat);
+    db.close();
+    console.log(`Azure DevOps connector configured for ${orgUrl}/${project}`);
+  } catch (err) {
+    db?.close();
+    if (err.name === "ExitPromptError") {
+      console.log("\nSetup cancelled.");
+      process.exit(0);
+    }
+    console.error("Error:", err.message);
+    process.exit(1);
+  }
+});
+connectorCommand.command("tasks").description("List active tasks from connected board").option("--json", "Output as JSON").action(async (opts) => {
+  let db;
+  try {
+    db = openDatabase();
+    const config = loadADOConfig(db);
+    db.close();
+    if (!config) {
+      console.error("No connector configured. Run: zam connector setup ado");
+      process.exit(1);
+    }
+    const items = await fetchActiveWorkItems(config);
+    if (opts.json) {
+      console.log(JSON.stringify(items, null, 2));
+      return;
+    }
+    if (items.length === 0) {
+      console.log("No active work items assigned to you.");
+      return;
+    }
+    console.log(`${items.length} active work item(s):
+`);
+    console.log(
+      "ID       Type          State       Title"
+    );
+    console.log("\u2500".repeat(80));
+    for (const wi of items) {
+      console.log(
+        `${String(wi.id).padEnd(8)} ${wi.type.padEnd(13)} ${wi.state.padEnd(11)} ${wi.title.slice(0, 45)}`
+      );
+    }
+  } catch (err) {
+    db?.close();
+    console.error("Error:", err.message);
+    process.exit(1);
+  }
+});
+connectorCommand.command("clear").description("Remove a connector configuration").argument("<type>", "Connector type (ado, turso)").action((type) => {
+  if (type === "turso") {
+    withDb9((db) => {
+      deleteSetting(db, "turso.url");
+      deleteSetting(db, "turso.token");
+      console.log("Turso cloud sync removed. Database remains local-only.");
+    });
+    return;
+  }
+  if (type !== "ado") {
+    console.error(`Unknown connector type: ${type}. Supported: ado, turso`);
+    process.exit(1);
+  }
+  withDb9((db) => {
+    deleteSetting(db, "ado.org_url");
+    deleteSetting(db, "ado.project");
+    deleteSetting(db, "ado.pat");
+    console.log("Azure DevOps connector removed.");
+  });
+});
+connectorCommand.command("sync").description("Trigger a manual sync with Turso cloud database").action(() => {
+  let db;
+  try {
+    db = openDatabaseWithSync();
+    const url = getSetting(db, "turso.url");
+    if (!url) {
+      console.error("No Turso cloud database configured. Run: zam connector setup turso");
+      process.exit(1);
+    }
+    db.sync();
+    console.log(`Synced with ${url}`);
+    db.close();
+  } catch (err) {
+    db?.close();
+    console.error("Error:", err.message);
+    process.exit(1);
+  }
+});
+async function setupTurso() {
+  let db;
+  try {
+    const url = await input3({
+      message: "Turso database URL (e.g. libsql://my-db-user.turso.io):"
+    });
+    const token = await password({
+      message: "Auth token:"
+    });
+    if (!url || !token) {
+      console.error("Both URL and token are required.");
+      process.exit(1);
+    }
+    db = openDatabase();
+    setSetting(db, "turso.url", url);
+    setSetting(db, "turso.token", token);
+    db.close();
+    db = openDatabaseWithSync();
+    db.sync();
+    db.close();
+    console.log(`Turso cloud sync configured and verified: ${url}`);
+  } catch (err) {
+    db?.close();
+    if (err.name === "ExitPromptError") {
+      console.log("\nSetup cancelled.");
+      process.exit(0);
+    }
+    console.error("Error:", err.message);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/goal.ts
+import { Command as Command14 } from "commander";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4 } from "fs";
+import { resolve } from "path";
+import { input as input4 } from "@inquirer/prompts";
+function resolveGoalsDir() {
+  let goalsDir;
+  let db;
+  try {
+    db = openDatabase();
+    goalsDir = getSetting(db, "personal.goals_dir");
+  } catch {
+  } finally {
+    db?.close();
+  }
+  return goalsDir ? resolve(goalsDir) : resolve("goals");
+}
+var goalCommand = new Command14("goal").description("Manage learning goals (markdown files)");
+goalCommand.command("list").description("List all goals").option("--status <status>", "Filter by status (active, completed, paused, abandoned)").option("--tree", "Show goals as a tree with parent/child relationships").option("--json", "Output as JSON").action((opts) => {
+  const goalsDir = resolveGoalsDir();
+  if (!existsSync5(goalsDir)) {
+    console.error(`Goals directory not found: ${goalsDir}`);
+    console.error("Set it with: zam settings set personal.goals_dir /path/to/goals");
+    process.exit(1);
+  }
+  if (opts.tree) {
+    const tree = getGoalTree(goalsDir);
+    const filtered = opts.status ? tree.filter((g) => g.status === opts.status) : tree;
+    if (opts.json) {
+      console.log(JSON.stringify(filtered, null, 2));
+      return;
+    }
+    if (filtered.length === 0) {
+      console.log("No goals found.");
+      return;
+    }
+    for (const root of filtered) {
+      printGoalLine(root, 0);
+      for (const child of root.children) {
+        printGoalLine(child, 1);
+      }
+    }
+    return;
+  }
+  let goals = listGoals(goalsDir);
+  if (opts.status) {
+    goals = goals.filter((g) => g.status === opts.status);
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(goals, null, 2));
+    return;
+  }
+  if (goals.length === 0) {
+    console.log("No goals found.");
+    return;
+  }
+  console.log("Goals:");
+  console.log("  " + "\u2500".repeat(70));
+  for (const g of goals) {
+    printGoalLine(g, 0);
+  }
+});
+function printGoalLine(g, indent) {
+  const prefix = "  ".repeat(indent + 1);
+  const statusIcon = {
+    active: "[*]",
+    paused: "[-]",
+    completed: "[x]",
+    abandoned: "[ ]"
+  };
+  const icon = statusIcon[g.status] || "[ ]";
+  const tasks = g.taskCount > 0 ? ` (${g.tasksDone}/${g.taskCount} tasks)` : "";
+  console.log(`${prefix}${icon} ${g.title}${tasks}  \u2014 ${g.slug}`);
+}
+goalCommand.command("show <slug>").description("Show a goal's details").option("--json", "Output as JSON").action((slug, opts) => {
+  const goalsDir = resolveGoalsDir();
+  const goal = getGoal(goalsDir, slug);
+  if (!goal) {
+    console.error(`Goal not found: ${slug}`);
+    process.exit(1);
+  }
+  if (opts.json) {
+    const tasks2 = extractTasks(goal.body);
+    const tokens2 = extractTokenRefs(goal.body);
+    console.log(JSON.stringify({ ...goal, tasks: tasks2, tokens: tokens2 }, null, 2));
+    return;
+  }
+  console.log(`Title:   ${goal.title}`);
+  console.log(`Slug:    ${goal.slug}`);
+  console.log(`Status:  ${goal.status}`);
+  if (goal.parent) console.log(`Parent:  ${goal.parent}`);
+  console.log(`Created: ${goal.created}`);
+  console.log(`Updated: ${goal.updated}`);
+  const tasks = extractTasks(goal.body);
+  if (tasks.length > 0) {
+    console.log(`
+Tasks (${tasks.filter((t) => t.done).length}/${tasks.length}):`);
+    for (const t of tasks) {
+      console.log(`  [${t.done ? "x" : " "}] ${t.text}`);
+    }
+  }
+  const tokens = extractTokenRefs(goal.body);
+  if (tokens.length > 0) {
+    console.log(`
+Tokens:`);
+    for (const ref of tokens) {
+      console.log(`  - ${ref}`);
+    }
+  }
+  if (goal.body) {
+    console.log(`
+${"\u2500".repeat(50)}`);
+    console.log(goal.body);
+  }
+});
+goalCommand.command("create").description("Create a new goal").option("--slug <slug>", "Goal slug (used as filename)").option("--title <title>", "Goal title").option("--parent <slug>", "Parent goal slug").option("--description <text>", "Goal description").option("--json", "Output as JSON").action(async (opts) => {
+  const goalsDir = resolveGoalsDir();
+  if (!existsSync5(goalsDir)) {
+    mkdirSync4(goalsDir, { recursive: true });
+  }
+  let slug = opts.slug;
+  let title = opts.title;
+  const parent = opts.parent;
+  const description = opts.description;
+  if (!slug || !title) {
+    try {
+      if (!title) {
+        title = await input4({ message: "Goal title:" });
+      }
+      if (!slug) {
+        const suggested = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+        slug = await input4({
+          message: "Goal slug (filename):",
+          default: suggested
+        });
+      }
+    } catch (err) {
+      if (err.name === "ExitPromptError") {
+        console.log("\nCancelled.");
+        process.exit(0);
+      }
+      throw err;
+    }
+  }
+  const goal = createGoal(goalsDir, { slug, title, parent, description });
+  if (opts.json) {
+    console.log(JSON.stringify(goal, null, 2));
+    return;
+  }
+  console.log(`Goal created: ${goal.slug}`);
+  console.log(`  Title:  ${goal.title}`);
+  console.log(`  Status: ${goal.status}`);
+  console.log(`  File:   ${goal.filePath}`);
+});
+goalCommand.command("status <slug> <status>").description("Update a goal's status (active, paused, completed, abandoned)").option("--json", "Output as JSON").action((slug, status, opts) => {
+  const validStatuses = ["active", "completed", "paused", "abandoned"];
+  if (!validStatuses.includes(status)) {
+    console.error(`Invalid status: ${status}. Must be one of: ${validStatuses.join(", ")}`);
+    process.exit(1);
+  }
+  const goalsDir = resolveGoalsDir();
+  const goal = updateGoalStatus(goalsDir, slug, status);
+  if (opts.json) {
+    console.log(JSON.stringify(goal, null, 2));
+    return;
+  }
+  console.log(`Goal ${slug} updated to: ${status}`);
+});
+
+// src/cli/index.ts
+var program = new Command15();
+program.name("zam").description(
+  "The Symbiotic Learning Kernel: Elevating Human Intelligence through AI Collaboration."
+).version("0.3.0");
+program.addCommand(initCommand);
+program.addCommand(setupCommand);
+program.addCommand(tokenCommand);
+program.addCommand(cardCommand);
+program.addCommand(sessionCommand);
+program.addCommand(statsCommand);
+program.addCommand(reviewCommand);
+program.addCommand(bridgeCommand);
+program.addCommand(skillCommand);
+program.addCommand(monitorCommand);
+program.addCommand(settingsCommand);
+program.addCommand(whoamiCommand);
+program.addCommand(connectorCommand);
+program.addCommand(goalCommand);
+program.parse();
+//# sourceMappingURL=index.js.map