zam-core 0.9.0 → 0.9.1

package/dist/{chunk-BOWP6D5I.js → cli/commands/mcp.js}

@@ -1,4 +1,17 @@
-#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/kernel/analytics/stats.ts
 async function q(db, sql, ...params) {
@@ -109,6 +122,11 @@ async function getDomainCompetence(db, userId) {
   }
   return competences;
 }
+var init_stats = __esm({
+  "src/kernel/analytics/stats.ts"() {
+    "use strict";
+  }
+});
 
 // src/kernel/credentials.ts
 import {
@@ -120,7 +138,6 @@ import {
 } from "fs";
 import { homedir } from "os";
 import { dirname, join } from "path";
-var DEFAULT_CREDENTIALS_PATH = join(homedir(), ".zam", "credentials.json");
 function loadCredentials(path) {
   const p = path ?? DEFAULT_CREDENTIALS_PATH;
   if (!existsSync(p)) return {};
@@ -211,6 +228,13 @@ function clearProviderApiKey(name, path) {
 function listProviderApiKeyRefs(path) {
   return Object.keys(loadCredentials(path).llmProviders ?? {});
 }
+var DEFAULT_CREDENTIALS_PATH;
+var init_credentials = __esm({
+  "src/kernel/credentials.ts"() {
+    "use strict";
+    DEFAULT_CREDENTIALS_PATH = join(homedir(), ".zam", "credentials.json");
+  }
+});
 
 // src/kernel/connectors/azure-devops.ts
 function loadADOConfig() {
@@ -267,16 +291,14 @@ async function fetchActiveWorkItems(config) {
     assignedTo: wi.fields["System.AssignedTo"]?.displayName ?? ""
   }));
 }
-
-// src/kernel/db/connection.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync } from "fs";
-import { createRequire } from "module";
-import { homedir as homedir2 } from "os";
-import { dirname as dirname2, join as join2 } from "path";
+var init_azure_devops = __esm({
+  "src/kernel/connectors/azure-devops.ts"() {
+    "use strict";
+    init_credentials();
+  }
+});
 
 // src/kernel/db/remote/hrana.ts
-var DEFAULT_TIMEOUT_MS = 15e3;
-var DEFAULT_MAX_ATTEMPTS = 2;
 function toHttpUrl(url) {
   return url.replace(/^libsql:\/\//i, "https://").replace(/^wss:\/\//i, "https://").replace(/^ws:\/\//i, "http://").replace(/\/+$/, "");
 }
@@ -329,80 +351,6 @@ function isRetryableTransportError(err) {
   const code = err.cause?.code;
   return code === "ECONNREFUSED" || code === "ENOTFOUND" || code === "EAI_AGAIN";
 }
-var HranaResponseError = class extends Error {
-  name = "HranaResponseError";
-};
-var HranaTransport = class {
-  pipelineUrl;
-  authToken;
-  timeoutMs;
-  maxAttempts;
-  constructor(options) {
-    this.pipelineUrl = `${toHttpUrl(options.url)}/v3/pipeline`;
-    this.authToken = options.authToken;
-    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    this.maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
-  }
-  /**
-   * POST one pipeline of requests. Returns the server results plus the baton
-   * for continuing an open stream. Retries transport-level failures only for
-   * stateless pipelines (no baton involved on either side).
-   */
-  async pipeline(requests, baton, baseUrl) {
-    const url = baseUrl ? `${toHttpUrl(baseUrl)}/v3/pipeline` : this.pipelineUrl;
-    const keepsState = baton != null || !requests.some((r) => r.type === "close");
-    const attempts = keepsState ? 1 : this.maxAttempts;
-    let lastError;
-    for (let attempt = 1; attempt <= attempts; attempt++) {
-      try {
-        return await this.post(url, { baton: baton ?? null, requests });
-      } catch (err) {
-        lastError = err;
-        if (!isRetryableTransportError(err) || attempt === attempts) {
-          throw this.offline(err);
-        }
-      }
-    }
-    throw this.offline(lastError);
-  }
-  async post(url, body) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
-    let response;
-    try {
-      response = await fetch(url, {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          ...this.authToken ? { authorization: `Bearer ${this.authToken}` } : {}
-        },
-        body: JSON.stringify(body),
-        signal: controller.signal
-      });
-    } finally {
-      clearTimeout(timer);
-    }
-    if (response.status === 401 || response.status === 403) {
-      throw new HranaResponseError(
-        `Turso rejected the configured credentials (HTTP ${response.status}). Refresh the token with: zam connector setup turso`
-      );
-    }
-    if (!response.ok) {
-      const detail = await response.text().catch(() => "");
-      throw new HranaResponseError(
-        `Turso request failed with HTTP ${response.status}${detail ? `: ${detail.slice(0, 200)}` : ""}`
-      );
-    }
-    return await response.json();
-  }
-  offline(err) {
-    if (err instanceof HranaResponseError) return err;
-    const cause = err instanceof Error ? err.cause?.message ?? err.message : String(err);
-    return new HranaResponseError(
-      `Cannot reach the Turso database at ${this.pipelineUrl}: ${cause}. Check your network connection, or switch to the local provider (ZAM_DB_PROVIDER=local).`
-    );
-  }
-};
 function unwrapResult(response, index) {
   const entry = response.results[index];
   if (!entry) {
@@ -413,9 +361,90 @@ function unwrapResult(response, index) {
   }
   return entry.response.result;
 }
+var DEFAULT_TIMEOUT_MS, DEFAULT_MAX_ATTEMPTS, HranaResponseError, HranaTransport;
+var init_hrana = __esm({
+  "src/kernel/db/remote/hrana.ts"() {
+    "use strict";
+    DEFAULT_TIMEOUT_MS = 15e3;
+    DEFAULT_MAX_ATTEMPTS = 2;
+    HranaResponseError = class extends Error {
+      name = "HranaResponseError";
+    };
+    HranaTransport = class {
+      pipelineUrl;
+      authToken;
+      timeoutMs;
+      maxAttempts;
+      constructor(options) {
+        this.pipelineUrl = `${toHttpUrl(options.url)}/v3/pipeline`;
+        this.authToken = options.authToken;
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+      }
+      /**
+       * POST one pipeline of requests. Returns the server results plus the baton
+       * for continuing an open stream. Retries transport-level failures only for
+       * stateless pipelines (no baton involved on either side).
+       */
+      async pipeline(requests, baton, baseUrl) {
+        const url = baseUrl ? `${toHttpUrl(baseUrl)}/v3/pipeline` : this.pipelineUrl;
+        const keepsState = baton != null || !requests.some((r) => r.type === "close");
+        const attempts = keepsState ? 1 : this.maxAttempts;
+        let lastError;
+        for (let attempt = 1; attempt <= attempts; attempt++) {
+          try {
+            return await this.post(url, { baton: baton ?? null, requests });
+          } catch (err) {
+            lastError = err;
+            if (!isRetryableTransportError(err) || attempt === attempts) {
+              throw this.offline(err);
+            }
+          }
+        }
+        throw this.offline(lastError);
+      }
+      async post(url, body) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        let response;
+        try {
+          response = await fetch(url, {
+            method: "POST",
+            headers: {
+              "content-type": "application/json",
+              ...this.authToken ? { authorization: `Bearer ${this.authToken}` } : {}
+            },
+            body: JSON.stringify(body),
+            signal: controller.signal
+          });
+        } finally {
+          clearTimeout(timer);
+        }
+        if (response.status === 401 || response.status === 403) {
+          throw new HranaResponseError(
+            `Turso rejected the configured credentials (HTTP ${response.status}). Refresh the token with: zam connector setup turso`
+          );
+        }
+        if (!response.ok) {
+          const detail = await response.text().catch(() => "");
+          throw new HranaResponseError(
+            `Turso request failed with HTTP ${response.status}${detail ? `: ${detail.slice(0, 200)}` : ""}`
+          );
+        }
+        return await response.json();
+      }
+      offline(err) {
+        if (err instanceof HranaResponseError) return err;
+        const cause = err instanceof Error ? err.cause?.message ?? err.message : String(err);
+        return new HranaResponseError(
+          `Cannot reach the Turso database at ${this.pipelineUrl}: ${cause}. Check your network connection, or switch to the local provider (ZAM_DB_PROVIDER=local).`
+        );
+      }
+    };
+  }
+});
 
 // src/kernel/db/remote/provider.ts
-var TABLE_INFO_PRAGMA = /^\s*table_info\s*\(\s*['"]?(\w+)['"]?\s*\)\s*$/i;
 function toRunResult(result) {
   return {
     changes: result?.affected_row_count ?? 0,
@@ -522,9 +551,21 @@ function openRemoteDatabase(options) {
   };
   return makeDatabase(statelessRun, transport);
 }
+var TABLE_INFO_PRAGMA;
+var init_provider = __esm({
+  "src/kernel/db/remote/provider.ts"() {
+    "use strict";
+    init_hrana();
+    TABLE_INFO_PRAGMA = /^\s*table_info\s*\(\s*['"]?(\w+)['"]?\s*\)\s*$/i;
+  }
+});
 
 // src/kernel/db/schema.ts
-var SCHEMA = `
+var SCHEMA;
+var init_schema = __esm({
+  "src/kernel/db/schema.ts"() {
+    "use strict";
+    SCHEMA = `
 -- PRAGMAs (WAL, foreign_keys) are set programmatically in connection.ts,
 -- not here, because libsql embedded replicas manage their own WAL.
 
@@ -700,6 +741,8 @@ CREATE INDEX IF NOT EXISTS idx_session_steps_session ON session_steps(session_id
 CREATE INDEX IF NOT EXISTS idx_tokens_title ON tokens(title);
 CREATE INDEX IF NOT EXISTS idx_token_contexts_context ON token_contexts(context_id);
 `;
+  }
+});
 
 // src/kernel/db/sync-adapter.ts
 function wrapSyncDatabase(driver) {
@@ -751,11 +794,17 @@ function wrapSyncDatabase(driver) {
   };
   return db;
 }
+var init_sync_adapter = __esm({
+  "src/kernel/db/sync-adapter.ts"() {
+    "use strict";
+  }
+});
 
 // src/kernel/db/connection.ts
-var DEFAULT_DB_DIR = join2(homedir2(), ".zam");
-var DEFAULT_DB_PATH = join2(DEFAULT_DB_DIR, "zam.db");
-var require2 = createRequire(import.meta.url);
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync } from "fs";
+import { createRequire } from "module";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, join as join2 } from "path";
 function isRemoteDatabasePath(dbPath) {
   return /^(libsql|https?|wss?):\/\//i.test(dbPath);
 }
@@ -1061,23 +1110,22 @@ async function runMigrations(db) {
     CREATE INDEX IF NOT EXISTS idx_token_contexts_context ON token_contexts(context_id)
   `);
 }
+var DEFAULT_DB_DIR, DEFAULT_DB_PATH, require2;
+var init_connection = __esm({
+  "src/kernel/db/connection.ts"() {
+    "use strict";
+    init_credentials();
+    init_provider();
+    init_schema();
+    init_sync_adapter();
+    DEFAULT_DB_DIR = join2(homedir2(), ".zam");
+    DEFAULT_DB_PATH = join2(DEFAULT_DB_DIR, "zam.db");
+    require2 = createRequire(import.meta.url);
+  }
+});
 
 // src/kernel/db/snapshot.ts
 import { createHash } from "crypto";
-var SNAPSHOT_FORMAT = "zam-snapshot";
-var SNAPSHOT_VERSION = 1;
-var MANIFEST_PREFIX = "-- zam-snapshot: ";
-var SNAPSHOT_TABLES = [
-  "tokens",
-  "sessions",
-  "cards",
-  "prerequisites",
-  "session_steps",
-  "review_logs",
-  "session_syntheses",
-  "user_config",
-  "agent_skills"
-];
 function quoteValue(value) {
   if (value === null || value === void 0) return "NULL";
   if (typeof value === "number") {
@@ -1205,10 +1253,26 @@ async function importSnapshot(db, snapshot, options = {}) {
     return { tables, total };
   });
 }
-
-// src/kernel/goals/engine.ts
-import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { basename, join as join3 } from "path";
+var SNAPSHOT_FORMAT, SNAPSHOT_VERSION, MANIFEST_PREFIX, SNAPSHOT_TABLES;
+var init_snapshot = __esm({
+  "src/kernel/db/snapshot.ts"() {
+    "use strict";
+    SNAPSHOT_FORMAT = "zam-snapshot";
+    SNAPSHOT_VERSION = 1;
+    MANIFEST_PREFIX = "-- zam-snapshot: ";
+    SNAPSHOT_TABLES = [
+      "tokens",
+      "sessions",
+      "cards",
+      "prerequisites",
+      "session_steps",
+      "review_logs",
+      "session_syntheses",
+      "user_config",
+      "agent_skills"
+    ];
+  }
+});
 
 // src/kernel/goals/parser.ts
 function parseGoalFile(content, slug, filePath) {
@@ -1296,8 +1360,15 @@ function splitFrontmatter(content) {
   }
   return { frontmatter, body };
 }
+var init_parser = __esm({
+  "src/kernel/goals/parser.ts"() {
+    "use strict";
+  }
+});
 
 // src/kernel/goals/engine.ts
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { basename, join as join3 } from "path";
 function listGoals(goalsDir) {
   if (!existsSync3(goalsDir)) return [];
   const files = readdirSync(goalsDir).filter(
@@ -1391,6 +1462,12 @@ function getGoalTree(goalsDir) {
   }
   return roots;
 }
+var init_engine = __esm({
+  "src/kernel/goals/engine.ts"() {
+    "use strict";
+    init_parser();
+  }
+});
 
 // src/kernel/models/agent-skill.ts
 import { ulid } from "ulid";
@@ -1433,6 +1510,11 @@ async function listAgentSkills(db) {
   const rows = await db.prepare("SELECT * FROM agent_skills ORDER BY created_at ASC").all();
   return rows.map(parseRow);
 }
+var init_agent_skill = __esm({
+  "src/kernel/models/agent-skill.ts"() {
+    "use strict";
+  }
+});
 
 // src/kernel/models/card.ts
 import { ulid as ulid2 } from "ulid";
@@ -1554,6 +1636,11 @@ async function getBlockedCards(db, userId) {
        ORDER BY t.bloom_level ASC, t.slug ASC`
   ).all(userId);
 }
+var init_card = __esm({
+  "src/kernel/models/card.ts"() {
+    "use strict";
+  }
+});
 
 // src/kernel/models/knowledge-context.ts
 import { ulid as ulid3 } from "ulid";
@@ -1659,6 +1746,11 @@ async function listContextsForToken(db, tokenId) {
        ORDER BY c.name ASC`
   ).all(tokenId);
 }
+var init_knowledge_context = __esm({
+  "src/kernel/models/knowledge-context.ts"() {
+    "use strict";
+  }
+});
 
 // src/kernel/models/token.ts
 import { ulid as ulid4 } from "ulid";
@@ -2411,6 +2503,12 @@ async function assertPrerequisiteDoesNotCreateCycle(db, tokenId, prerequisiteId)
     throw new Error("Cannot add prerequisite: would create a cycle");
   }
 }
+var init_token = __esm({
+  "src/kernel/models/token.ts"() {
+    "use strict";
+    init_card();
+  }
+});
 
 // src/kernel/models/prerequisite.ts
 async function buildAncestorMap(db) {
@@ -2542,6 +2640,13 @@ async function getTokenNeighborhood(db, tokenId, userId) {
   );
   return { center, prerequisites, dependents };
 }
+var init_prerequisite = __esm({
+  "src/kernel/models/prerequisite.ts"() {
+    "use strict";
+    init_card();
+    init_token();
+  }
+});
 
 // src/kernel/models/review.ts
 import { ulid as ulid5 } from "ulid";
@@ -2590,6 +2695,11 @@ async function getReviewsForUser(db, userId, options) {
   }
   return await db.prepare(sql).all(...params);
 }
+var init_review = __esm({
+  "src/kernel/models/review.ts"() {
+    "use strict";
+  }
+});
 
 // src/kernel/models/session.ts
 import { ulid as ulid6 } from "ulid";
@@ -2658,6 +2768,11 @@ async function getSessionSummary(db, sessionId) {
   ).all(sessionId);
   return { session, steps };
 }
+var init_session = __esm({
+  "src/kernel/models/session.ts"() {
+    "use strict";
+  }
+});
 
 // src/kernel/models/settings.ts
 async function getSetting(db, key) {
@@ -2686,6 +2801,11 @@ async function deleteSetting(db, key) {
   const result = await db.prepare("DELETE FROM user_config WHERE key = ?").run(key);
   return result.changes > 0;
 }
+var init_settings = __esm({
+  "src/kernel/models/settings.ts"() {
+    "use strict";
+  }
+});
 
 // src/kernel/models/token-embedding.ts
 import { createHash as createHash2 } from "crypto";
@@ -2846,6 +2966,11 @@ async function listEmbeddedTokens(db, model) {
     }
   });
 }
+var init_token_embedding = __esm({
+  "src/kernel/models/token-embedding.ts"() {
+    "use strict";
+  }
+});
 
 // src/kernel/observation/analyzer.ts
 function parseMonitorLog(jsonl) {
@@ -2904,8 +3029,6 @@ function pairCommands(events) {
   );
   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()));
@@ -3066,6 +3189,14 @@ function inferRating(signals) {
   if (negatives >= 1) return 3;
   return 4;
 }
+var HELP_PATTERNS, HELP_WINDOW_MS;
+var init_analyzer = __esm({
+  "src/kernel/observation/analyzer.ts"() {
+    "use strict";
+    HELP_PATTERNS = ["--help", "man ", "tldr ", "help "];
+    HELP_WINDOW_MS = 6e4;
+  }
+});
 
 // src/kernel/observation/monitor-io.ts
 import {
@@ -3077,7 +3208,6 @@ import {
 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join4 } from "path";
-var MONITOR_DIR = join4(homedir3(), ".zam", "monitor");
 function getMonitorDir() {
   return MONITOR_DIR;
 }
@@ -3116,43 +3246,16 @@ function getMonitorLogStats(sessionId) {
   const lineCount = content.split("\n").filter((l) => l.trim()).length;
   return { exists: true, sizeBytes: stat.size, lineCount };
 }
-
-// src/kernel/observation/observer-sidecar-policy.ts
-import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync3 } from "fs";
-import { join as join6 } from "path";
+var MONITOR_DIR;
+var init_monitor_io = __esm({
+  "src/kernel/observation/monitor-io.ts"() {
+    "use strict";
+    init_analyzer();
+    MONITOR_DIR = join4(homedir3(), ".zam", "monitor");
+  }
+});
 
 // src/kernel/observation/policy.ts
-var OBSERVER_POLICY_VERSION = 1;
-var DEFAULT_OBSERVER_POLICY = {
-  version: OBSERVER_POLICY_VERSION,
-  scope: "window",
-  allowlist: [],
-  denylist: [],
-  consent: "per-session",
-  retention: "none",
-  redactWindowTitles: true,
-  audioOptIn: false
-};
-var BUILT_IN_SENSITIVE_MATCHERS = [
-  // Password managers
-  "1password",
-  "bitwarden",
-  "keepass",
-  "lastpass",
-  "dashlane",
-  "nordpass",
-  "enpass",
-  "proton pass",
-  // Authentication / credential / UAC surfaces
-  "credentialuibroker",
-  "consentux",
-  "logonui",
-  "windowssecurity",
-  "authenticator",
-  // Conservative banking/title hints
-  "online banking",
-  "onlinebanking"
-];
 function parseList(raw) {
   if (!raw) return [];
   return raw.split(",").map((entry) => entry.trim().toLowerCase()).filter((entry) => entry.length > 0);
@@ -3363,37 +3466,48 @@ async function isObserverPolicyConfigured(db) {
   const settings = await getAllSettings(db);
   return Object.keys(settings).some((key) => key.startsWith("observer."));
 }
-var OBSERVER_POLICY_UNSET_HINT = "Observer policy is at defaults (scope=window: only a targeted window is captured). Configure with `zam observer status|grant|revoke` or `zam settings set observer.scope <off|window|fullscreen>`.";
-
-// src/kernel/observation/ui-observer-io.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync5 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join5 } from "path";
+var OBSERVER_POLICY_VERSION, DEFAULT_OBSERVER_POLICY, BUILT_IN_SENSITIVE_MATCHERS, OBSERVER_POLICY_UNSET_HINT;
+var init_policy = __esm({
+  "src/kernel/observation/policy.ts"() {
+    "use strict";
+    init_stats();
+    init_settings();
+    OBSERVER_POLICY_VERSION = 1;
+    DEFAULT_OBSERVER_POLICY = {
+      version: OBSERVER_POLICY_VERSION,
+      scope: "window",
+      allowlist: [],
+      denylist: [],
+      consent: "per-session",
+      retention: "none",
+      redactWindowTitles: true,
+      audioOptIn: false
+    };
+    BUILT_IN_SENSITIVE_MATCHERS = [
+      // Password managers
+      "1password",
+      "bitwarden",
+      "keepass",
+      "lastpass",
+      "dashlane",
+      "nordpass",
+      "enpass",
+      "proton pass",
+      // Authentication / credential / UAC surfaces
+      "credentialuibroker",
+      "consentux",
+      "logonui",
+      "windowssecurity",
+      "authenticator",
+      // Conservative banking/title hints
+      "online banking",
+      "onlinebanking"
+    ];
+    OBSERVER_POLICY_UNSET_HINT = "Observer policy is at defaults (scope=window: only a targeted window is captured). Configure with `zam observer status|grant|revoke` or `zam settings set observer.scope <off|window|fullscreen>`.";
+  }
+});
 
 // src/kernel/observation/ui-observer.ts
-var UI_OBSERVATION_PROTOCOL_VERSION = 1;
-var OBSERVATION_KINDS = /* @__PURE__ */ new Set([
-  "progress",
-  "step-completed",
-  "error",
-  "help-seeking",
-  "uncertain",
-  "privacy-pause",
-  "heartbeat"
-]);
-var ACTION_TYPES = /* @__PURE__ */ new Set([
-  "click",
-  "shortcut",
-  "typing",
-  "scroll",
-  "window-change"
-]);
-var EVIDENCE_TYPES = /* @__PURE__ */ new Set([
-  "uia",
-  "keyframe",
-  "clip",
-  "window"
-]);
 function isUiObservationReport(value) {
   if (!isRecord(value)) return false;
   if (value.version !== UI_OBSERVATION_PROTOCOL_VERSION) return false;
@@ -3466,9 +3580,40 @@ function isNonNegativeInteger(value) {
 function isConfidence(value) {
   return typeof value === "number" && value >= 0 && value <= 1;
 }
+var UI_OBSERVATION_PROTOCOL_VERSION, OBSERVATION_KINDS, ACTION_TYPES, EVIDENCE_TYPES;
+var init_ui_observer = __esm({
+  "src/kernel/observation/ui-observer.ts"() {
+    "use strict";
+    UI_OBSERVATION_PROTOCOL_VERSION = 1;
+    OBSERVATION_KINDS = /* @__PURE__ */ new Set([
+      "progress",
+      "step-completed",
+      "error",
+      "help-seeking",
+      "uncertain",
+      "privacy-pause",
+      "heartbeat"
+    ]);
+    ACTION_TYPES = /* @__PURE__ */ new Set([
+      "click",
+      "shortcut",
+      "typing",
+      "scroll",
+      "window-change"
+    ]);
+    EVIDENCE_TYPES = /* @__PURE__ */ new Set([
+      "uia",
+      "keyframe",
+      "clip",
+      "window"
+    ]);
+  }
+});
 
 // src/kernel/observation/ui-observer-io.ts
-var DEFAULT_UI_OBSERVER_DIR = join5(homedir4(), ".zam", "observer");
+import { appendFileSync as appendFileSync2, existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync5 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join5 } from "path";
 function getUiObserverDir() {
   return process.env.ZAM_OBSERVER_DIR || DEFAULT_UI_OBSERVER_DIR;
 }
@@ -3504,9 +3649,18 @@ function appendUiObservationReport(report) {
     { encoding: "utf8", mode: 384 }
   );
 }
+var DEFAULT_UI_OBSERVER_DIR;
+var init_ui_observer_io = __esm({
+  "src/kernel/observation/ui-observer-io.ts"() {
+    "use strict";
+    init_ui_observer();
+    DEFAULT_UI_OBSERVER_DIR = join5(homedir4(), ".zam", "observer");
+  }
+});
 
 // src/kernel/observation/observer-sidecar-policy.ts
-var SIDECAR_POLICY_FILE = "policy.json";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync3 } from "fs";
+import { join as join6 } from "path";
 function toSidecarPrivacyPolicy(policy) {
   return {
     allowProcesses: [...policy.allowlist],
@@ -3525,41 +3679,17 @@ async function syncObserverSidecarPolicy(db, dir = getUiObserverDir()) {
   });
   return { path, policy };
 }
-
-// src/kernel/observation/session-synthesis.ts
-import { ulid as ulid8 } from "ulid";
-
-// src/kernel/recall/evaluator.ts
-import { ulid as ulid7 } from "ulid";
+var SIDECAR_POLICY_FILE;
+var init_observer_sidecar_policy = __esm({
+  "src/kernel/observation/observer-sidecar-policy.ts"() {
+    "use strict";
+    init_policy();
+    init_ui_observer_io();
+    SIDECAR_POLICY_FILE = "policy.json";
+  }
+});
 
 // 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));
 }
@@ -3674,8 +3804,42 @@ function createFSRS(params) {
     params: Object.freeze(resolvedParams)
   };
 }
+var DEFAULT_W, DEFAULT_REQUEST_RETENTION;
+var init_fsrs = __esm({
+  "src/kernel/scheduler/fsrs.ts"() {
+    "use strict";
+    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
+    ];
+    DEFAULT_REQUEST_RETENTION = 0.9;
+  }
+});
 
 // src/kernel/recall/evaluator.ts
+import { ulid as ulid7 } from "ulid";
 async function evaluateRating(db, input) {
   return db.transaction((tx) => evaluateRatingWithinTransaction(tx, input));
 }
@@ -3734,6 +3898,13 @@ async function evaluateRatingWithinTransaction(db, input) {
     lapses: updated.lapses
   };
 }
+var init_evaluator = __esm({
+  "src/kernel/recall/evaluator.ts"() {
+    "use strict";
+    init_card();
+    init_fsrs();
+  }
+});
 
 // src/kernel/scheduler/blocker.ts
 async function cascadeBlock(db, userId, tokenSlug) {
@@ -3795,9 +3966,16 @@ async function unblockReady(db, userId) {
   }
   return { unblocked };
 }
+var init_blocker = __esm({
+  "src/kernel/scheduler/blocker.ts"() {
+    "use strict";
+    init_card();
+    init_prerequisite();
+    init_token();
+  }
+});
 
 // src/kernel/observation/ui-observer-synthesis.ts
-var MIN_UI_CONFIDENCE = 0.6;
 function kindToRating(kind) {
   switch (kind) {
     case "step-completed":
@@ -3889,8 +4067,16 @@ function uiObservationTimeSpan(reports) {
   const durationMs = Math.max(0, Date.parse(end) - Date.parse(start));
   return { start, end, durationMs };
 }
+var MIN_UI_CONFIDENCE;
+var init_ui_observer_synthesis = __esm({
+  "src/kernel/observation/ui-observer-synthesis.ts"() {
+    "use strict";
+    MIN_UI_CONFIDENCE = 0.6;
+  }
+});
 
 // src/kernel/observation/session-synthesis.ts
+import { ulid as ulid8 } from "ulid";
 function parseSynthesisRow(row) {
   return {
     ...row,
@@ -4099,6 +4285,22 @@ async function applySessionSynthesis(db, input) {
     };
   });
 }
+var init_session_synthesis = __esm({
+  "src/kernel/observation/session-synthesis.ts"() {
+    "use strict";
+    init_agent_skill();
+    init_card();
+    init_prerequisite();
+    init_session();
+    init_token();
+    init_evaluator();
+    init_blocker();
+    init_analyzer();
+    init_monitor_io();
+    init_ui_observer_io();
+    init_ui_observer_synthesis();
+  }
+});
 
 // src/kernel/observation/shell-hooks.ts
 function psSingleQuoted(value) {
@@ -4319,6 +4521,11 @@ Remove-Variable -Name __ZAM_MONITOR_FILE,__ZAM_MONITOR_SEQ,__ZAM_MONITOR_SESSION
 Write-Host "ZAM monitor stopped."
 `.trim();
 }
+var init_shell_hooks = __esm({
+  "src/kernel/observation/shell-hooks.ts"() {
+    "use strict";
+  }
+});
 
 // src/kernel/observation/skill-discovery.ts
 function discoverSkills(sessionCommands, options = {}) {
@@ -4461,6 +4668,11 @@ function generateSlug(steps) {
 function describeSequence(steps) {
   return `Recurring pattern: ${steps.join(" \u2192 ")}`;
 }
+var init_skill_discovery = __esm({
+  "src/kernel/observation/skill-discovery.ts"() {
+    "use strict";
+  }
+});
 
 // src/kernel/recall/actions.ts
 async function getReviewTarget(db, cardId, userId) {
@@ -4558,25 +4770,21 @@ async function executeReviewAction(db, input) {
     }
   }
 }
+var init_actions = __esm({
+  "src/kernel/recall/actions.ts"() {
+    "use strict";
+    init_card();
+    init_prerequisite();
+    init_token();
+    init_blocker();
+    init_evaluator();
+  }
+});
 
 // src/kernel/recall/prompter.ts
-var BLOOM_VERBS = {
-  1: "Remember",
-  2: "Understand",
-  3: "Apply",
-  4: "Analyze",
-  5: "Synthesize"
-};
 function formatSlugForCue(slug) {
   return slug.replace(/[-_]/g, " ");
 }
-var BLOOM_CUES = {
-  1: (slug) => `Recall the definition and core concept of: ${formatSlugForCue(slug)}`,
-  2: (slug) => `Explain the concept and how ${formatSlugForCue(slug)} works.`,
-  3: (slug) => `Describe how or where you would apply the concept of ${formatSlugForCue(slug)}.`,
-  4: (slug) => `Analyze the trade-offs, advantages, or alternatives of ${formatSlugForCue(slug)}.`,
-  5: (slug) => `How would you design a solution using the concept of ${formatSlugForCue(slug)}?`
-};
 function generateConceptFreeCue(bloomLevel, slug, _domain) {
   const bloom = bloomLevel >= 1 && bloomLevel <= 5 ? bloomLevel : 1;
   return BLOOM_CUES[bloom](slug);
@@ -4597,13 +4805,30 @@ function generatePrompt(input) {
     sourceLink: input.sourceLink ?? null
   };
 }
+var BLOOM_VERBS, BLOOM_CUES;
+var init_prompter = __esm({
+  "src/kernel/recall/prompter.ts"() {
+    "use strict";
+    BLOOM_VERBS = {
+      1: "Remember",
+      2: "Understand",
+      3: "Apply",
+      4: "Analyze",
+      5: "Synthesize"
+    };
+    BLOOM_CUES = {
+      1: (slug) => `Recall the definition and core concept of: ${formatSlugForCue(slug)}`,
+      2: (slug) => `Explain the concept and how ${formatSlugForCue(slug)} works.`,
+      3: (slug) => `Describe how or where you would apply the concept of ${formatSlugForCue(slug)}.`,
+      4: (slug) => `Analyze the trade-offs, advantages, or alternatives of ${formatSlugForCue(slug)}.`,
+      5: (slug) => `How would you design a solution using the concept of ${formatSlugForCue(slug)}?`
+    };
+  }
+});
 
 // src/kernel/recall/reference-resolver.ts
 import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
 import { dirname as dirname3, join as join7, resolve } from "path";
-var DEFAULT_REVIEW_CONTEXT_MAX_CHARS = 6e3;
-var REVIEW_CONTEXT_CACHE_TTL_MS = 5 * 60 * 1e3;
-var reviewContextCache = /* @__PURE__ */ new Map();
 function reviewContextCacheKey(sourceLink, maxChars) {
   return `${sourceLink}\0${maxChars}`;
 }
@@ -4799,6 +5024,15 @@ function matchesFilePath(sourceLink, changedFile) {
   }
   return normSource.endsWith(normChanged) || normChanged.endsWith(normSource);
 }
+var DEFAULT_REVIEW_CONTEXT_MAX_CHARS, REVIEW_CONTEXT_CACHE_TTL_MS, reviewContextCache;
+var init_reference_resolver = __esm({
+  "src/kernel/recall/reference-resolver.ts"() {
+    "use strict";
+    DEFAULT_REVIEW_CONTEXT_MAX_CHARS = 6e3;
+    REVIEW_CONTEXT_CACHE_TTL_MS = 5 * 60 * 1e3;
+    reviewContextCache = /* @__PURE__ */ new Map();
+  }
+});
 
 // src/kernel/scheduler/interleaver.ts
 function interleave(items, maxConsecutive = 2) {
@@ -4865,6 +5099,11 @@ function interleave(items, maxConsecutive = 2) {
   }
   return result;
 }
+var init_interleaver = __esm({
+  "src/kernel/scheduler/interleaver.ts"() {
+    "use strict";
+  }
+});
 
 // src/kernel/scheduler/queue.ts
 async function buildReviewQueue(db, options) {
@@ -5007,6 +5246,13 @@ function intersperseNew(reviews, newCards, interval) {
   }
   return result;
 }
+var init_queue = __esm({
+  "src/kernel/scheduler/queue.ts"() {
+    "use strict";
+    init_token();
+    init_interleaver();
+  }
+});
 
 // src/kernel/search/hybrid.ts
 function cosineSimilarity(a, b) {
@@ -5083,6 +5329,13 @@ async function searchTokensHybrid(db, query, opts) {
   });
   return results.slice(0, limit);
 }
+var init_hybrid = __esm({
+  "src/kernel/search/hybrid.ts"() {
+    "use strict";
+    init_token();
+    init_token_embedding();
+  }
+});
 
 // src/kernel/search/suggestions.ts
 async function suggestFoundations(db, opts) {
@@ -5148,6 +5401,14 @@ async function suggestFoundations(db, opts) {
   }
   return results;
 }
+var init_suggestions = __esm({
+  "src/kernel/search/suggestions.ts"() {
+    "use strict";
+    init_prerequisite();
+    init_token_embedding();
+    init_hybrid();
+  }
+});
 
 // src/kernel/system/hooks.ts
 import {
@@ -5161,7 +5422,6 @@ import {
 import { homedir as homedir5 } from "os";
 import { join as join8 } from "path";
 import { fileURLToPath } from "url";
-var HOME = homedir5();
 function getPackageSkillPath(agent = "default") {
   const packageRoot = [
     fileURLToPath(new URL("../../..", import.meta.url)),
@@ -5272,15 +5532,6 @@ function distributeGlobalSkills(home = HOME) {
   }
   return results;
 }
-var POSIX_OLD_HOOK = `
-# ZAM Shell Observation Hooks
-if (command -v zam >/dev/null 2>&1); then eval "$(zam monitor start --quiet)"; fi
-`;
-var POWERSHELL_OLD_HOOK = `
-# ZAM Shell Observation Hooks
-if (Get-Command zam -ErrorAction SilentlyContinue) { Invoke-Expression (& zam monitor start --quiet pwsh) }
-`;
-var HOOK_MARKER = "# ZAM Monitor Session Helper";
 function posixHook(shell) {
   return `
 ${HOOK_MARKER}
@@ -5295,13 +5546,6 @@ zam-monitor-session() {
 }
 `;
 }
-var POWERSHELL_HOOK = `
-${HOOK_MARKER}
-function Start-ZamMonitor {
-  param([Parameter(Mandatory = $true)][string]$Session)
-  Invoke-Expression (& zam monitor start --session $Session --shell pwsh)
-}
-`;
 function installHook(file, hook, oldHook) {
   try {
     const content = existsSync7(file) ? readFileSync7(file, "utf8") : "";
@@ -5359,206 +5603,31 @@ function injectShellHooks(home = HOME) {
   }
   return results;
 }
+var HOME, POSIX_OLD_HOOK, POWERSHELL_OLD_HOOK, HOOK_MARKER, POWERSHELL_HOOK;
+var init_hooks = __esm({
+  "src/kernel/system/hooks.ts"() {
+    "use strict";
+    HOME = homedir5();
+    POSIX_OLD_HOOK = `
+# ZAM Shell Observation Hooks
+if (command -v zam >/dev/null 2>&1); then eval "$(zam monitor start --quiet)"; fi
+`;
+    POWERSHELL_OLD_HOOK = `
+# ZAM Shell Observation Hooks
+if (Get-Command zam -ErrorAction SilentlyContinue) { Invoke-Expression (& zam monitor start --quiet pwsh) }
+`;
+    HOOK_MARKER = "# ZAM Monitor Session Helper";
+    POWERSHELL_HOOK = `
+${HOOK_MARKER}
+function Start-ZamMonitor {
+  param([Parameter(Mandatory = $true)][string]$Session)
+  Invoke-Expression (& zam monitor start --session $Session --shell pwsh)
+}
+`;
+  }
+});
 
 // src/kernel/system/i18n.ts
-var TRANSLATIONS = {
-  en: {
-    welcome: "Learning session: {count} card(s)",
-    new_review_relearn: "  New: {newC}  Review: {reviewC}  Relearn: {relearnC}",
-    domains: "  Domains: {domains}",
-    instruction: "\nRecall each answer first, reveal it, then rate yourself honestly.",
-    quit_hint: "Type 'q' at the answer prompt (or press Ctrl+C) to stop anytime.",
-    offline_warning: "\n\x1B[33m\u26A0 LLM-Feedback & automatic translation are disabled.\x1B[0m",
-    offline_instruction: "  Enable with: \x1B[36mnpm run dev -- settings llm on\x1B[0m\n",
-    nothing_due: "Nothing due to learn. You're all caught up!",
-    evaluating: "Evaluating answer via local AI...",
-    generating_question: "Generating dynamic question...",
-    translating: "Translating question dynamically...",
-    prompt_answer: "Your answer (Enter to reveal \xB7 'q' to stop):",
-    session_ended: "Learning session ended.",
-    session_complete: "Learning session complete!",
-    cards_rated: "  Cards rated: {count}",
-    avg_rating: "  Average rating: {avg}",
-    forgot: "  Forgot: {count} card(s)",
-    feedback_title: "\u2500\u2500 ZAM Feedback {line}",
-    answer_title: "\u2500\u2500 Answer {line}",
-    keep_waiting: "Would you like to keep waiting?",
-    local_ai_working: "The local AI is still generating the response.",
-    wait_warning: "\u26A0 The LLM server is taking a while to load the model.",
-    wait_info: "(This is expected when transitioning between models or starting up from cold.)",
-    keep_waiting_llm: "Would you like to keep waiting for the model?",
-    proceeding_offline: "\u26A0 Proceeding in offline-mode (without active LLM evaluations for this session).",
-    eval_skipped: "  [LLM Evaluation skipped: {reason}]"
-  },
-  de: {
-    welcome: "Lern-Session: {count} Karte(n)",
-    new_review_relearn: "  Neu: {newC}  Wiederholen: {reviewC}  Lernen: {relearnC}",
-    domains: "  Dom\xE4nen: {domains}",
-    instruction: "\nRufe jede Antwort zuerst ab, decke sie auf und bewerte dich dann ehrlich selbst.",
-    quit_hint: "Gib 'q' bei der Antwortaufforderung ein (oder dr\xFCcke Strg+C), um jederzeit zu beenden.",
-    offline_warning: "\n\x1B[33m\u26A0 LLM-Feedback & automatische \xDCbersetzung sind deaktiviert.\x1B[0m",
-    offline_instruction: "  Aktivieren mit: \x1B[36mnpm run dev -- settings llm on\x1B[0m\n",
-    nothing_due: "Nichts f\xE4llig zu lernen. Du bist komplett auf dem Laufenden!",
-    evaluating: "Bewerte Antwort via lokaler KI...",
-    generating_question: "Generiere dynamische Frage...",
-    translating: "\xDCbersetze Frage dynamisch...",
-    prompt_answer: "Deine Antwort (Eingabe zum Aufdecken \xB7 'q' zum Beenden):",
-    session_ended: "Lern-Session beendet.",
-    session_complete: "Lern-Session abgeschlossen!",
-    cards_rated: "  Bewertete Karten: {count}",
-    avg_rating: "  Durchschnittliche Bewertung: {avg}",
-    forgot: "  Vergessen: {count} Karte(n)",
-    feedback_title: "\u2500\u2500 ZAM Feedback {line}",
-    answer_title: "\u2500\u2500 Antwort {line}",
-    keep_waiting: "M\xF6chtest du weiter auf die Bewertung warten?",
-    local_ai_working: "Die lokale KI arbeitet noch an der Antwort.",
-    wait_warning: "\u26A0 Der LLM-Server braucht ungew\xF6hnlich lange, um das Modell zu laden.",
-    wait_info: "(Das ist normal, wenn das Modell gewechselt wird oder kalt startet.)",
-    keep_waiting_llm: "M\xF6chtest du weiter auf das Modell warten?",
-    proceeding_offline: "\u26A0 Fahre im Offline-Modus fort (ohne aktive LLM-Bewertungen in dieser Runde).",
-    eval_skipped: "  [LLM-Bewertung \xFCbersprungen: {reason}]"
-  },
-  es: {
-    welcome: "Sesi\xF3n de aprendizaje: {count} tarjeta(s)",
-    new_review_relearn: "  Nuevas: {newC}  Repasar: {reviewC}  Reaprender: {relearnC}",
-    domains: "  Dominios: {domains}",
-    instruction: "\nRecuerda cada respuesta primero, rev\xE9lala y calif\xEDcate honestamente.",
-    quit_hint: "Escribe 'q' en la respuesta (o presiona Ctrl+C) para salir en cualquier momento.",
-    offline_warning: "\n\x1B[33m\u26A0 Los comentarios de LLM y la traducci\xF3n autom\xE1tica est\xE1n desactivados.\x1B[0m",
-    offline_instruction: "  Activar con: \x1B[36mnpm run dev -- settings llm on\x1B[0m\n",
-    nothing_due: "No hay nada pendiente para aprender. \xA1Est\xE1s al d\xEDa!",
-    evaluating: "Evaluando respuesta con IA local...",
-    generating_question: "Generando pregunta din\xE1mica...",
-    translating: "Traduciendo pregunta din\xE1micamente...",
-    prompt_answer: "Tu respuesta (Intro para revelar \xB7 'q' para salir):",
-    session_ended: "Sesi\xF3n de aprendizaje finalizada.",
-    session_complete: "\xA1Sesi\xF3n de aprendizaje completada!",
-    cards_rated: "  Tarjetas calificadas: {count}",
-    avg_rating: "  Calificaci\xF3n promedio: {avg}",
-    forgot: "  Olvidadas: {count} tarjeta(s)",
-    feedback_title: "\u2500\u2500 Comentarios de ZAM {line}",
-    answer_title: "\u2500\u2500 Respuesta {line}",
-    keep_waiting: "\xBFDeseas seguir esperando la evaluaci\xF3n?",
-    local_ai_working: "La IA local todav\xEDa est\xE1 generando la respuesta.",
-    wait_warning: "\u26A0 El servidor LLM est\xE1 tardando en cargar el modelo.",
-    wait_info: "(Esto es normal al cambiar de modelo o iniciar en fr\xEDo.)",
-    keep_waiting_llm: "\xBFDeseas seguir esperando el modelo?",
-    proceeding_offline: "\u26A0 Continuando en modo fuera de l\xEDnea (sin evaluaciones de LLM en esta sesi\xF3n).",
-    eval_skipped: "  [Evaluaci\xF3n de LLM omitida: {reason}]"
-  },
-  fr: {
-    welcome: "Session d'apprentissage : {count} carte(s)",
-    new_review_relearn: "  Nouveau: {newC}  R\xE9vision: {reviewC}  Relever: {relearnC}",
-    domains: "  Domaines: {domains}",
-    instruction: "\nRappelez-vous chaque r\xE9ponse d'abord, r\xE9v\xE9lez-la, puis \xE9valuez-vous honn\xEAtement.",
-    quit_hint: "Tapez 'q' (ou Ctrl+C) pour quitter \xE0 tout moment.",
-    offline_warning: "\n\x1B[33m\u26A0 Les commentaires LLM et la traduction automatique sont d\xE9sactiv\xE9s.\x1B[0m",
-    offline_instruction: "  Activer avec : \x1B[36mnpm run dev -- settings llm on\x1B[0m\n",
-    nothing_due: "Rien \xE0 apprendre. Vous \xEAtes \xE0 jour !",
-    evaluating: "\xC9valuation de la r\xE9ponse via l'IA locale...",
-    generating_question: "G\xE9n\xE9ration d'une question dynamique...",
-    translating: "Traduction dynamique de la question...",
-    prompt_answer: "Votre r\xE9ponse (Entr\xE9e pour r\xE9v\xE9ler \xB7 'q' pour quitter) :",
-    session_ended: "Session d'apprentissage arr\xEAt\xE9e.",
-    session_complete: "Session d'apprentissage termin\xE9e !",
-    cards_rated: "  Cartes \xE9valu\xE9es: {count}",
-    avg_rating: "  Note moyenne: {avg}",
-    forgot: "  Oubli\xE9es: {count} carte(s)",
-    feedback_title: "\u2500\u2500 Commentaires ZAM {line}",
-    answer_title: "\u2500\u2500 R\xE9ponse {line}",
-    keep_waiting: "Voulez-vous continuer \xE0 attendre l'\xE9valuation ?",
-    local_ai_working: "L'IA locale est toujours en train de g\xE9n\xE9rer la r\xE9ponse.",
-    wait_warning: "\u26A0 Le serveur LLM prend du temps pour charger le mod\xE8le.",
-    wait_info: "(Ceci est normal lors de la transition entre mod\xE8les ou du d\xE9marrage \xE0 froid.)",
-    keep_waiting_llm: "Voulez-vous continuer \xE0 attendre le mod\xE8le ?",
-    proceeding_offline: "\u26A0 Poursuite en mode hors ligne (sans \xE9valuation active de l'IA pour cette session).",
-    eval_skipped: "  [\xC9valuation LLM ignor\xE9e : {reason}]"
-  },
-  pt: {
-    welcome: "Sess\xE3o de aprendizado: {count} cart\xE3o(\xF5es)",
-    new_review_relearn: "  Novos: {newC}  Revisar: {reviewC}  Reaprender: {relearnC}",
-    domains: "  Dom\xEDnios: {domains}",
-    instruction: "\nLembre-se de cada resposta primeiro, revele-a e avalie-se honestamente.",
-    quit_hint: "Digite 'q' (ou Ctrl+C) para parar a qualquer momento.",
-    offline_warning: "\n\x1B[33m\u26A0 O feedback do LLM e a tradu\xE7\xE3o autom\xE1tica est\xE3o desativados.\x1B[0m",
-    offline_instruction: "  Ativar com: \x1B[36mnpm run dev -- settings llm on\x1B[0m\n",
-    nothing_due: "Nada faturado para aprender. Voc\xEA est\xE1 atualizado!",
-    evaluating: "Avaliando a resposta via IA local...",
-    generating_question: "Gerando pergunta din\xE2mica...",
-    translating: "Traduzindo pergunta dinamicamente...",
-    prompt_answer: "Sua resposta (Enter para revelar \xB7 'q' para parar):",
-    session_ended: "Sess\xE3o de aprendizado encerrada.",
-    session_complete: "Sess\xE3o de aprendizado conclu\xEDda!",
-    cards_rated: "  Cart\xF5es avaliados: {count}",
-    avg_rating: "  Nota m\xE9dia: {avg}",
-    forgot: "  Esquecidos: {count} cart\xE3o(\xF5es)",
-    feedback_title: "\u2500\u2500 Feedback ZAM {line}",
-    answer_title: "\u2500\u2500 Resposta {line}",
-    keep_waiting: "Deseja continuar esperando pela avalia\xE7\xE3o?",
-    local_ai_working: "A IA local ainda est\xE1 gerando a resposta.",
-    wait_warning: "\u26A0 O servidor LLM est\xE1 demorando para carregar o modelo.",
-    wait_info: "(Isso \xE9 esperado ao alternar modelos ou iniciar do zero.)",
-    keep_waiting_llm: "Deseja continuar esperando o modelo?",
-    proceeding_offline: "\u26A0 Continuando no modo offline (sem avalia\xE7\xF5es de LLM ativas nesta sess\xE3o).",
-    eval_skipped: "  [Avalia\xE7\xE3o LLM omitida: {reason}]"
-  },
-  zh: {
-    welcome: "\u5B66\u4E60\u8BFE: {count} \u5F20\u5361\u7247",
-    new_review_relearn: "  \u65B0\u5361: {newC}  \u590D\u4E60: {reviewC}  \u91CD\u5B66: {relearnC}",
-    domains: "  \u77E5\u8BC6\u9886\u57DF: {domains}",
-    instruction: "\n\u9996\u5148\u5728\u8111\u4E2D\u56DE\u5FC6\u7B54\u6848\uFF0C\u7136\u540E\u63ED\u6653\u5E76\u8BDA\u5B9E\u81EA\u6211\u8BC4\u5206\u3002",
-    quit_hint: "\u5728\u56DE\u7B54\u63D0\u793A\u5904\u8F93\u5165 'q' (\u6216\u6309 Ctrl+C) \u53EF\u968F\u65F6\u9000\u51FA\u3002",
-    offline_warning: "\n\x1B[33m\u26A0 LLM \u53CD\u9988\u4E0E\u81EA\u52A8\u7FFB\u8BD1\u5DF2\u7981\u7528\u3002\x1B[0m",
-    offline_instruction: "  \u5F00\u542F\u547D\u4EE4: \x1B[36mnpm run dev -- settings llm on\x1B[0m\n",
-    nothing_due: "\u76EE\u524D\u6CA1\u6709\u9700\u8981\u5B66\u4E60\u7684\u5185\u5BB9\u3002\u60A8\u5DF2\u5168\u90E8\u638C\u63E1\uFF01",
-    evaluating: "\u6B63\u5728\u901A\u8FC7\u672C\u5730 AI \u8BC4\u4F30\u56DE\u7B54...",
-    generating_question: "\u6B63\u5728\u52A8\u6001\u751F\u6210\u95EE\u9898...",
-    translating: "\u6B63\u5728\u52A8\u6001\u7FFB\u8BD1\u95EE\u9898...",
-    prompt_answer: "\u60A8\u7684\u56DE\u7B54 (\u6309\u56DE\u8F66\u63ED\u6653 \xB7 \u8F93\u5165 'q' \u9000\u51FA):",
-    session_ended: "\u5B66\u4E60\u8BFE\u5DF2\u7ED3\u675F\u3002",
-    session_complete: "\u5B66\u4E60\u8BFE\u5DF2\u5B8C\u6210\uFF01",
-    cards_rated: "  \u5DF2\u8BC4\u5206\u5361\u7247: {count}",
-    avg_rating: "  \u5E73\u5747\u5206: {avg}",
-    forgot: "  \u9057\u5FD8: {count} \u5F20\u5361\u7247",
-    feedback_title: "\u2500\u2500 ZAM \u53CD\u9988 {line}",
-    answer_title: "\u2500\u2500 \u53C2\u8003\u7B54\u6848 {line}",
-    keep_waiting: "\u662F\u5426\u7EE7\u7EED\u7B49\u5F85\u8BC4\u5206\uFF1F",
-    local_ai_working: "\u672C\u5730 AI \u4ECD\u5728\u751F\u6210\u56DE\u7B54\u3002",
-    wait_warning: "\u26A0 LLM \u670D\u52A1\u5668\u6B63\u5728\u52A0\u8F7D\u6A21\u578B\uFF0C\u8FD9\u53EF\u80FD\u9700\u8981\u4E00\u4E9B\u65F6\u95F4\u3002",
-    wait_info: "(\u8FD9\u5728\u5207\u6362\u6A21\u578B\u6216\u51B7\u542F\u52A8\u65F6\u662F\u6B63\u5E38\u73B0\u8C61\u3002)",
-    keep_waiting_llm: "\u662F\u5426\u7EE7\u7EED\u7B49\u5F85\u6A21\u578B\u52A0\u8F7D\uFF1F",
-    proceeding_offline: "\u26A0 \u6B63\u5728\u4EE5\u79BB\u7EBF\u6A21\u5F0F\u7EE7\u7EED\uFF08\u672C\u6B21\u5B66\u4E60\u8BFE\u5C06\u4E0D\u5305\u542B\u6D3B\u8DC3\u7684 AI \u8BC4\u4F30\uFF09\u3002",
-    eval_skipped: "  [\u5DF2\u8DF3\u8FC7 LLM \u8BC4\u4F30: {reason}]"
-  },
-  ja: {
-    welcome: "\u5B66\u7FD2\u30BB\u30C3\u30B7\u30E7\u30F3: {count} \u679A\u306E\u30AB\u30FC\u30C9",
-    new_review_relearn: "  \u65B0\u898F: {newC}  \u5FA9\u7FD2: {reviewC}  \u518D\u5B66\u7FD2: {relearnC}",
-    domains: "  \u30C9\u30E1\u30A4\u30F3: {domains}",
-    instruction: "\n\u6700\u521D\u306B\u56DE\u7B54\u3092\u601D\u3044\u51FA\u3057\u3001\u6B21\u306B\u56DE\u7B54\u3092\u8868\u793A\u3057\u3066\u3001\u6B63\u76F4\u306B\u81EA\u5DF1\u8A55\u4FA1\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
-    quit_hint: "\u56DE\u7B54\u30D7\u30ED\u30F3\u30D7\u30C8\u3067\u300Cq\u300D\u3092\u5165\u529B\u3059\u308B\uFF08\u307E\u305F\u306F Ctrl+C \u3092\u62BC\u3059\uFF09\u3068\u3001\u3044\u3064\u3067\u3082\u7D42\u4E86\u3067\u304D\u307E\u3059\u3002",
-    offline_warning: "\n\x1B[33m\u26A0 LLM \u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF\u3068\u81EA\u52D5\u7FFB\u8A33\u306F\u7121\u52B9\u3067\u3059\u3002\x1B[0m",
-    offline_instruction: "  \u6709\u52B9\u5316\u3059\u308B\u306B\u306F: \x1B[36mnpm run dev -- settings llm on\x1B[0m\n",
-    nothing_due: "\u5B66\u7FD2\u4E88\u5B9A\u306E\u30AB\u30FC\u30C9\u306F\u3042\u308A\u307E\u305B\u3093\u3002\u3059\u3079\u3066\u5B8C\u4E86\u3057\u3066\u3044\u307E\u3059\uFF01",
-    evaluating: "\u30ED\u30FC\u30AB\u30EBAI\u306B\u3088\u308B\u56DE\u7B54\u306E\u8A55\u4FA1\u4E2D...",
-    generating_question: "\u8CEA\u554F\u3092\u52D5\u7684\u306B\u751F\u6210\u4E2D...",
-    translating: "\u8CEA\u554F\u3092\u52D5\u7684\u306B\u7FFB\u8A33\u4E2D...",
-    prompt_answer: "\u3042\u306A\u305F\u306E\u56DE\u7B54 (Enter\u3067\u8868\u793A \xB7 'q'\u3067\u7D42\u4E86):",
-    session_ended: "\u5B66\u7FD2\u30BB\u30C3\u30B7\u30E7\u30F3\u304C\u7D42\u4E86\u3057\u307E\u3057\u305F\u3002",
-    session_complete: "\u5B66\u7FD2\u30BB\u30C3\u30B7\u30E7\u30F3\u304C\u5B8C\u4E86\u3057\u307E\u3057\u305F\uFF01",
-    cards_rated: "  \u8A55\u4FA1\u6E08\u307F\u30AB\u30FC\u30C9\u6570: {count}",
-    avg_rating: "  \u5E73\u5747\u8A55\u4FA1: {avg}",
-    forgot: "  \u5FD8\u308C\u305F\u30AB\u30FC\u30C9\u6570: {count} \u679A",
-    feedback_title: "\u2500\u2500 ZAM \u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF {line}",
-    answer_title: "\u2500\u2500 \u89E3\u7B54 {line}",
-    keep_waiting: "\u8A55\u4FA1\u306E\u751F\u6210\u3092\u5F85\u3061\u307E\u3059\u304B\uFF1F",
-    local_ai_working: "\u30ED\u30FC\u30AB\u30EBAI\u304C\u56DE\u7B54\u3092\u751F\u6210\u3057\u3066\u3044\u307E\u3059\u3002",
-    wait_warning: "\u26A0 LLM \u30B5\u30FC\u30D0\u30FC\u304C\u30E2\u30C7\u30EB\u3092\u30ED\u30FC\u30C9\u3059\u308B\u306E\u306B\u6642\u9593\u304C\u304B\u304B\u3063\u3066\u3044\u307E\u3059\u3002",
-    wait_info: "(\u30E2\u30C7\u30EB\u306E\u79FB\u884C\u4E2D\u3084\u30B3\u30FC\u30EB\u30C9\u30B9\u30BF\u30FC\u30C8\u6642\u306B\u306F\u3001\u3053\u308C\u304C\u4E88\u60F3\u3055\u308C\u307E\u3059\u3002)",
-    keep_waiting_llm: "\u30E2\u30C7\u30EB\u306E\u30ED\u30FC\u30C9\u3092\u5F85\u3061\u7D9A\u3051\u307E\u3059\u304B\uFF1F",
-    proceeding_offline: "\u26A0 \u30AA\u30D5\u30E9\u30A4\u30F3\u30E2\u30FC\u30C9\u3067\u7D9A\u884C\u3057\u307E\u3059\uFF08\u3053\u306E\u30BB\u30C3\u30B7\u30E7\u30F3\u3067\u306F\u30A2\u30AF\u30C6\u30A3\u30D6\u306A AI \u8A55\u4FA1\u306F\u884C\u308F\u308C\u307E\u305B\u3093\uFF09\u3002",
-    eval_skipped: "  [LLM \u8A55\u4FA1\u304C\u30B9\u30AD\u30C3\u30D7\u3055\u308C\u307E\u3057\u305F: {reason}]"
-  }
-};
 function t(locale, key, params = {}) {
   const dict = TRANSLATIONS[locale] || TRANSLATIONS.en;
   let str = dict[key] || TRANSLATIONS.en[key] || "";
@@ -5567,6 +5636,210 @@ function t(locale, key, params = {}) {
   }
   return str;
 }
+var TRANSLATIONS;
+var init_i18n = __esm({
+  "src/kernel/system/i18n.ts"() {
+    "use strict";
+    TRANSLATIONS = {
+      en: {
+        welcome: "Learning session: {count} card(s)",
+        new_review_relearn: "  New: {newC}  Review: {reviewC}  Relearn: {relearnC}",
+        domains: "  Domains: {domains}",
+        instruction: "\nRecall each answer first, reveal it, then rate yourself honestly.",
+        quit_hint: "Type 'q' at the answer prompt (or press Ctrl+C) to stop anytime.",
+        offline_warning: "\n\x1B[33m\u26A0 LLM-Feedback & automatic translation are disabled.\x1B[0m",
+        offline_instruction: "  Enable with: \x1B[36mnpm run dev -- settings llm on\x1B[0m\n",
+        nothing_due: "Nothing due to learn. You're all caught up!",
+        evaluating: "Evaluating answer via local AI...",
+        generating_question: "Generating dynamic question...",
+        translating: "Translating question dynamically...",
+        prompt_answer: "Your answer (Enter to reveal \xB7 'q' to stop):",
+        session_ended: "Learning session ended.",
+        session_complete: "Learning session complete!",
+        cards_rated: "  Cards rated: {count}",
+        avg_rating: "  Average rating: {avg}",
+        forgot: "  Forgot: {count} card(s)",
+        feedback_title: "\u2500\u2500 ZAM Feedback {line}",
+        answer_title: "\u2500\u2500 Answer {line}",
+        keep_waiting: "Would you like to keep waiting?",
+        local_ai_working: "The local AI is still generating the response.",
+        wait_warning: "\u26A0 The LLM server is taking a while to load the model.",
+        wait_info: "(This is expected when transitioning between models or starting up from cold.)",
+        keep_waiting_llm: "Would you like to keep waiting for the model?",
+        proceeding_offline: "\u26A0 Proceeding in offline-mode (without active LLM evaluations for this session).",
+        eval_skipped: "  [LLM Evaluation skipped: {reason}]"
+      },
+      de: {
+        welcome: "Lern-Session: {count} Karte(n)",
+        new_review_relearn: "  Neu: {newC}  Wiederholen: {reviewC}  Lernen: {relearnC}",
+        domains: "  Dom\xE4nen: {domains}",
+        instruction: "\nRufe jede Antwort zuerst ab, decke sie auf und bewerte dich dann ehrlich selbst.",
+        quit_hint: "Gib 'q' bei der Antwortaufforderung ein (oder dr\xFCcke Strg+C), um jederzeit zu beenden.",
+        offline_warning: "\n\x1B[33m\u26A0 LLM-Feedback & automatische \xDCbersetzung sind deaktiviert.\x1B[0m",
+        offline_instruction: "  Aktivieren mit: \x1B[36mnpm run dev -- settings llm on\x1B[0m\n",
+        nothing_due: "Nichts f\xE4llig zu lernen. Du bist komplett auf dem Laufenden!",
+        evaluating: "Bewerte Antwort via lokaler KI...",
+        generating_question: "Generiere dynamische Frage...",
+        translating: "\xDCbersetze Frage dynamisch...",
+        prompt_answer: "Deine Antwort (Eingabe zum Aufdecken \xB7 'q' zum Beenden):",
+        session_ended: "Lern-Session beendet.",
+        session_complete: "Lern-Session abgeschlossen!",
+        cards_rated: "  Bewertete Karten: {count}",
+        avg_rating: "  Durchschnittliche Bewertung: {avg}",
+        forgot: "  Vergessen: {count} Karte(n)",
+        feedback_title: "\u2500\u2500 ZAM Feedback {line}",
+        answer_title: "\u2500\u2500 Antwort {line}",
+        keep_waiting: "M\xF6chtest du weiter auf die Bewertung warten?",
+        local_ai_working: "Die lokale KI arbeitet noch an der Antwort.",
+        wait_warning: "\u26A0 Der LLM-Server braucht ungew\xF6hnlich lange, um das Modell zu laden.",
+        wait_info: "(Das ist normal, wenn das Modell gewechselt wird oder kalt startet.)",
+        keep_waiting_llm: "M\xF6chtest du weiter auf das Modell warten?",
+        proceeding_offline: "\u26A0 Fahre im Offline-Modus fort (ohne aktive LLM-Bewertungen in dieser Runde).",
+        eval_skipped: "  [LLM-Bewertung \xFCbersprungen: {reason}]"
+      },
+      es: {
+        welcome: "Sesi\xF3n de aprendizaje: {count} tarjeta(s)",
+        new_review_relearn: "  Nuevas: {newC}  Repasar: {reviewC}  Reaprender: {relearnC}",
+        domains: "  Dominios: {domains}",
+        instruction: "\nRecuerda cada respuesta primero, rev\xE9lala y calif\xEDcate honestamente.",
+        quit_hint: "Escribe 'q' en la respuesta (o presiona Ctrl+C) para salir en cualquier momento.",
+        offline_warning: "\n\x1B[33m\u26A0 Los comentarios de LLM y la traducci\xF3n autom\xE1tica est\xE1n desactivados.\x1B[0m",
+        offline_instruction: "  Activar con: \x1B[36mnpm run dev -- settings llm on\x1B[0m\n",
+        nothing_due: "No hay nada pendiente para aprender. \xA1Est\xE1s al d\xEDa!",
+        evaluating: "Evaluando respuesta con IA local...",
+        generating_question: "Generando pregunta din\xE1mica...",
+        translating: "Traduciendo pregunta din\xE1micamente...",
+        prompt_answer: "Tu respuesta (Intro para revelar \xB7 'q' para salir):",
+        session_ended: "Sesi\xF3n de aprendizaje finalizada.",
+        session_complete: "\xA1Sesi\xF3n de aprendizaje completada!",
+        cards_rated: "  Tarjetas calificadas: {count}",
+        avg_rating: "  Calificaci\xF3n promedio: {avg}",
+        forgot: "  Olvidadas: {count} tarjeta(s)",
+        feedback_title: "\u2500\u2500 Comentarios de ZAM {line}",
+        answer_title: "\u2500\u2500 Respuesta {line}",
+        keep_waiting: "\xBFDeseas seguir esperando la evaluaci\xF3n?",
+        local_ai_working: "La IA local todav\xEDa est\xE1 generando la respuesta.",
+        wait_warning: "\u26A0 El servidor LLM est\xE1 tardando en cargar el modelo.",
+        wait_info: "(Esto es normal al cambiar de modelo o iniciar en fr\xEDo.)",
+        keep_waiting_llm: "\xBFDeseas seguir esperando el modelo?",
+        proceeding_offline: "\u26A0 Continuando en modo fuera de l\xEDnea (sin evaluaciones de LLM en esta sesi\xF3n).",
+        eval_skipped: "  [Evaluaci\xF3n de LLM omitida: {reason}]"
+      },
+      fr: {
+        welcome: "Session d'apprentissage : {count} carte(s)",
+        new_review_relearn: "  Nouveau: {newC}  R\xE9vision: {reviewC}  Relever: {relearnC}",
+        domains: "  Domaines: {domains}",
+        instruction: "\nRappelez-vous chaque r\xE9ponse d'abord, r\xE9v\xE9lez-la, puis \xE9valuez-vous honn\xEAtement.",
+        quit_hint: "Tapez 'q' (ou Ctrl+C) pour quitter \xE0 tout moment.",
+        offline_warning: "\n\x1B[33m\u26A0 Les commentaires LLM et la traduction automatique sont d\xE9sactiv\xE9s.\x1B[0m",
+        offline_instruction: "  Activer avec : \x1B[36mnpm run dev -- settings llm on\x1B[0m\n",
+        nothing_due: "Rien \xE0 apprendre. Vous \xEAtes \xE0 jour !",
+        evaluating: "\xC9valuation de la r\xE9ponse via l'IA locale...",
+        generating_question: "G\xE9n\xE9ration d'une question dynamique...",
+        translating: "Traduction dynamique de la question...",
+        prompt_answer: "Votre r\xE9ponse (Entr\xE9e pour r\xE9v\xE9ler \xB7 'q' pour quitter) :",
+        session_ended: "Session d'apprentissage arr\xEAt\xE9e.",
+        session_complete: "Session d'apprentissage termin\xE9e !",
+        cards_rated: "  Cartes \xE9valu\xE9es: {count}",
+        avg_rating: "  Note moyenne: {avg}",
+        forgot: "  Oubli\xE9es: {count} carte(s)",
+        feedback_title: "\u2500\u2500 Commentaires ZAM {line}",
+        answer_title: "\u2500\u2500 R\xE9ponse {line}",
+        keep_waiting: "Voulez-vous continuer \xE0 attendre l'\xE9valuation ?",
+        local_ai_working: "L'IA locale est toujours en train de g\xE9n\xE9rer la r\xE9ponse.",
+        wait_warning: "\u26A0 Le serveur LLM prend du temps pour charger le mod\xE8le.",
+        wait_info: "(Ceci est normal lors de la transition entre mod\xE8les ou du d\xE9marrage \xE0 froid.)",
+        keep_waiting_llm: "Voulez-vous continuer \xE0 attendre le mod\xE8le ?",
+        proceeding_offline: "\u26A0 Poursuite en mode hors ligne (sans \xE9valuation active de l'IA pour cette session).",
+        eval_skipped: "  [\xC9valuation LLM ignor\xE9e : {reason}]"
+      },
+      pt: {
+        welcome: "Sess\xE3o de aprendizado: {count} cart\xE3o(\xF5es)",
+        new_review_relearn: "  Novos: {newC}  Revisar: {reviewC}  Reaprender: {relearnC}",
+        domains: "  Dom\xEDnios: {domains}",
+        instruction: "\nLembre-se de cada resposta primeiro, revele-a e avalie-se honestamente.",
+        quit_hint: "Digite 'q' (ou Ctrl+C) para parar a qualquer momento.",
+        offline_warning: "\n\x1B[33m\u26A0 O feedback do LLM e a tradu\xE7\xE3o autom\xE1tica est\xE3o desativados.\x1B[0m",
+        offline_instruction: "  Ativar com: \x1B[36mnpm run dev -- settings llm on\x1B[0m\n",
+        nothing_due: "Nada faturado para aprender. Voc\xEA est\xE1 atualizado!",
+        evaluating: "Avaliando a resposta via IA local...",
+        generating_question: "Gerando pergunta din\xE2mica...",
+        translating: "Traduzindo pergunta dinamicamente...",
+        prompt_answer: "Sua resposta (Enter para revelar \xB7 'q' para parar):",
+        session_ended: "Sess\xE3o de aprendizado encerrada.",
+        session_complete: "Sess\xE3o de aprendizado conclu\xEDda!",
+        cards_rated: "  Cart\xF5es avaliados: {count}",
+        avg_rating: "  Nota m\xE9dia: {avg}",
+        forgot: "  Esquecidos: {count} cart\xE3o(\xF5es)",
+        feedback_title: "\u2500\u2500 Feedback ZAM {line}",
+        answer_title: "\u2500\u2500 Resposta {line}",
+        keep_waiting: "Deseja continuar esperando pela avalia\xE7\xE3o?",
+        local_ai_working: "A IA local ainda est\xE1 gerando a resposta.",
+        wait_warning: "\u26A0 O servidor LLM est\xE1 demorando para carregar o modelo.",
+        wait_info: "(Isso \xE9 esperado ao alternar modelos ou iniciar do zero.)",
+        keep_waiting_llm: "Deseja continuar esperando o modelo?",
+        proceeding_offline: "\u26A0 Continuando no modo offline (sem avalia\xE7\xF5es de LLM ativas nesta sess\xE3o).",
+        eval_skipped: "  [Avalia\xE7\xE3o LLM omitida: {reason}]"
+      },
+      zh: {
+        welcome: "\u5B66\u4E60\u8BFE: {count} \u5F20\u5361\u7247",
+        new_review_relearn: "  \u65B0\u5361: {newC}  \u590D\u4E60: {reviewC}  \u91CD\u5B66: {relearnC}",
+        domains: "  \u77E5\u8BC6\u9886\u57DF: {domains}",
+        instruction: "\n\u9996\u5148\u5728\u8111\u4E2D\u56DE\u5FC6\u7B54\u6848\uFF0C\u7136\u540E\u63ED\u6653\u5E76\u8BDA\u5B9E\u81EA\u6211\u8BC4\u5206\u3002",
+        quit_hint: "\u5728\u56DE\u7B54\u63D0\u793A\u5904\u8F93\u5165 'q' (\u6216\u6309 Ctrl+C) \u53EF\u968F\u65F6\u9000\u51FA\u3002",
+        offline_warning: "\n\x1B[33m\u26A0 LLM \u53CD\u9988\u4E0E\u81EA\u52A8\u7FFB\u8BD1\u5DF2\u7981\u7528\u3002\x1B[0m",
+        offline_instruction: "  \u5F00\u542F\u547D\u4EE4: \x1B[36mnpm run dev -- settings llm on\x1B[0m\n",
+        nothing_due: "\u76EE\u524D\u6CA1\u6709\u9700\u8981\u5B66\u4E60\u7684\u5185\u5BB9\u3002\u60A8\u5DF2\u5168\u90E8\u638C\u63E1\uFF01",
+        evaluating: "\u6B63\u5728\u901A\u8FC7\u672C\u5730 AI \u8BC4\u4F30\u56DE\u7B54...",
+        generating_question: "\u6B63\u5728\u52A8\u6001\u751F\u6210\u95EE\u9898...",
+        translating: "\u6B63\u5728\u52A8\u6001\u7FFB\u8BD1\u95EE\u9898...",
+        prompt_answer: "\u60A8\u7684\u56DE\u7B54 (\u6309\u56DE\u8F66\u63ED\u6653 \xB7 \u8F93\u5165 'q' \u9000\u51FA):",
+        session_ended: "\u5B66\u4E60\u8BFE\u5DF2\u7ED3\u675F\u3002",
+        session_complete: "\u5B66\u4E60\u8BFE\u5DF2\u5B8C\u6210\uFF01",
+        cards_rated: "  \u5DF2\u8BC4\u5206\u5361\u7247: {count}",
+        avg_rating: "  \u5E73\u5747\u5206: {avg}",
+        forgot: "  \u9057\u5FD8: {count} \u5F20\u5361\u7247",
+        feedback_title: "\u2500\u2500 ZAM \u53CD\u9988 {line}",
+        answer_title: "\u2500\u2500 \u53C2\u8003\u7B54\u6848 {line}",
+        keep_waiting: "\u662F\u5426\u7EE7\u7EED\u7B49\u5F85\u8BC4\u5206\uFF1F",
+        local_ai_working: "\u672C\u5730 AI \u4ECD\u5728\u751F\u6210\u56DE\u7B54\u3002",
+        wait_warning: "\u26A0 LLM \u670D\u52A1\u5668\u6B63\u5728\u52A0\u8F7D\u6A21\u578B\uFF0C\u8FD9\u53EF\u80FD\u9700\u8981\u4E00\u4E9B\u65F6\u95F4\u3002",
+        wait_info: "(\u8FD9\u5728\u5207\u6362\u6A21\u578B\u6216\u51B7\u542F\u52A8\u65F6\u662F\u6B63\u5E38\u73B0\u8C61\u3002)",
+        keep_waiting_llm: "\u662F\u5426\u7EE7\u7EED\u7B49\u5F85\u6A21\u578B\u52A0\u8F7D\uFF1F",
+        proceeding_offline: "\u26A0 \u6B63\u5728\u4EE5\u79BB\u7EBF\u6A21\u5F0F\u7EE7\u7EED\uFF08\u672C\u6B21\u5B66\u4E60\u8BFE\u5C06\u4E0D\u5305\u542B\u6D3B\u8DC3\u7684 AI \u8BC4\u4F30\uFF09\u3002",
+        eval_skipped: "  [\u5DF2\u8DF3\u8FC7 LLM \u8BC4\u4F30: {reason}]"
+      },
+      ja: {
+        welcome: "\u5B66\u7FD2\u30BB\u30C3\u30B7\u30E7\u30F3: {count} \u679A\u306E\u30AB\u30FC\u30C9",
+        new_review_relearn: "  \u65B0\u898F: {newC}  \u5FA9\u7FD2: {reviewC}  \u518D\u5B66\u7FD2: {relearnC}",
+        domains: "  \u30C9\u30E1\u30A4\u30F3: {domains}",
+        instruction: "\n\u6700\u521D\u306B\u56DE\u7B54\u3092\u601D\u3044\u51FA\u3057\u3001\u6B21\u306B\u56DE\u7B54\u3092\u8868\u793A\u3057\u3066\u3001\u6B63\u76F4\u306B\u81EA\u5DF1\u8A55\u4FA1\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+        quit_hint: "\u56DE\u7B54\u30D7\u30ED\u30F3\u30D7\u30C8\u3067\u300Cq\u300D\u3092\u5165\u529B\u3059\u308B\uFF08\u307E\u305F\u306F Ctrl+C \u3092\u62BC\u3059\uFF09\u3068\u3001\u3044\u3064\u3067\u3082\u7D42\u4E86\u3067\u304D\u307E\u3059\u3002",
+        offline_warning: "\n\x1B[33m\u26A0 LLM \u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF\u3068\u81EA\u52D5\u7FFB\u8A33\u306F\u7121\u52B9\u3067\u3059\u3002\x1B[0m",
+        offline_instruction: "  \u6709\u52B9\u5316\u3059\u308B\u306B\u306F: \x1B[36mnpm run dev -- settings llm on\x1B[0m\n",
+        nothing_due: "\u5B66\u7FD2\u4E88\u5B9A\u306E\u30AB\u30FC\u30C9\u306F\u3042\u308A\u307E\u305B\u3093\u3002\u3059\u3079\u3066\u5B8C\u4E86\u3057\u3066\u3044\u307E\u3059\uFF01",
+        evaluating: "\u30ED\u30FC\u30AB\u30EBAI\u306B\u3088\u308B\u56DE\u7B54\u306E\u8A55\u4FA1\u4E2D...",
+        generating_question: "\u8CEA\u554F\u3092\u52D5\u7684\u306B\u751F\u6210\u4E2D...",
+        translating: "\u8CEA\u554F\u3092\u52D5\u7684\u306B\u7FFB\u8A33\u4E2D...",
+        prompt_answer: "\u3042\u306A\u305F\u306E\u56DE\u7B54 (Enter\u3067\u8868\u793A \xB7 'q'\u3067\u7D42\u4E86):",
+        session_ended: "\u5B66\u7FD2\u30BB\u30C3\u30B7\u30E7\u30F3\u304C\u7D42\u4E86\u3057\u307E\u3057\u305F\u3002",
+        session_complete: "\u5B66\u7FD2\u30BB\u30C3\u30B7\u30E7\u30F3\u304C\u5B8C\u4E86\u3057\u307E\u3057\u305F\uFF01",
+        cards_rated: "  \u8A55\u4FA1\u6E08\u307F\u30AB\u30FC\u30C9\u6570: {count}",
+        avg_rating: "  \u5E73\u5747\u8A55\u4FA1: {avg}",
+        forgot: "  \u5FD8\u308C\u305F\u30AB\u30FC\u30C9\u6570: {count} \u679A",
+        feedback_title: "\u2500\u2500 ZAM \u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF {line}",
+        answer_title: "\u2500\u2500 \u89E3\u7B54 {line}",
+        keep_waiting: "\u8A55\u4FA1\u306E\u751F\u6210\u3092\u5F85\u3061\u307E\u3059\u304B\uFF1F",
+        local_ai_working: "\u30ED\u30FC\u30AB\u30EBAI\u304C\u56DE\u7B54\u3092\u751F\u6210\u3057\u3066\u3044\u307E\u3059\u3002",
+        wait_warning: "\u26A0 LLM \u30B5\u30FC\u30D0\u30FC\u304C\u30E2\u30C7\u30EB\u3092\u30ED\u30FC\u30C9\u3059\u308B\u306E\u306B\u6642\u9593\u304C\u304B\u304B\u3063\u3066\u3044\u307E\u3059\u3002",
+        wait_info: "(\u30E2\u30C7\u30EB\u306E\u79FB\u884C\u4E2D\u3084\u30B3\u30FC\u30EB\u30C9\u30B9\u30BF\u30FC\u30C8\u6642\u306B\u306F\u3001\u3053\u308C\u304C\u4E88\u60F3\u3055\u308C\u307E\u3059\u3002)",
+        keep_waiting_llm: "\u30E2\u30C7\u30EB\u306E\u30ED\u30FC\u30C9\u3092\u5F85\u3061\u7D9A\u3051\u307E\u3059\u304B\uFF1F",
+        proceeding_offline: "\u26A0 \u30AA\u30D5\u30E9\u30A4\u30F3\u30E2\u30FC\u30C9\u3067\u7D9A\u884C\u3057\u307E\u3059\uFF08\u3053\u306E\u30BB\u30C3\u30B7\u30E7\u30F3\u3067\u306F\u30A2\u30AF\u30C6\u30A3\u30D6\u306A AI \u8A55\u4FA1\u306F\u884C\u308F\u308C\u307E\u305B\u3093\uFF09\u3002",
+        eval_skipped: "  [LLM \u8A55\u4FA1\u304C\u30B9\u30AD\u30C3\u30D7\u3055\u308C\u307E\u3057\u305F: {reason}]"
+      }
+    };
+  }
+});
 
 // src/kernel/system/install-config.ts
 import { existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
@@ -5699,6 +5972,11 @@ function setActiveWorkspaceContext(contextName, path = defaultConfigPath()) {
   }
   return false;
 }
+var init_install_config = __esm({
+  "src/kernel/system/install-config.ts"() {
+    "use strict";
+  }
+});
 
 // src/kernel/system/installer.ts
 import { execFileSync, execSync } from "child_process";
@@ -5907,18 +6185,14 @@ function installOpenCode() {
     };
   }
 }
+var init_installer = __esm({
+  "src/kernel/system/installer.ts"() {
+    "use strict";
+  }
+});
 
 // src/kernel/system/locale.ts
 import { execSync as execSync2 } from "child_process";
-var SUPPORTED_LOCALES = /* @__PURE__ */ new Set([
-  "en",
-  "de",
-  "es",
-  "fr",
-  "pt",
-  "zh",
-  "ja"
-]);
 function normalizeLocale(raw) {
   const clean = raw.trim().toLowerCase().split(/[_-]/)[0];
   if (SUPPORTED_LOCALES.has(clean)) {
@@ -5952,6 +6226,21 @@ function detectSystemLocale() {
   }
   return "en";
 }
+var SUPPORTED_LOCALES;
+var init_locale = __esm({
+  "src/kernel/system/locale.ts"() {
+    "use strict";
+    SUPPORTED_LOCALES = /* @__PURE__ */ new Set([
+      "en",
+      "de",
+      "es",
+      "fr",
+      "pt",
+      "zh",
+      "ja"
+    ]);
+  }
+});
 
 // src/kernel/system/profiler.ts
 import { execSync as execSync3 } from "child_process";
@@ -6010,6 +6299,11 @@ function getSystemProfile() {
     recommendedModel
   };
 }
+var init_profiler = __esm({
+  "src/kernel/system/profiler.ts"() {
+    "use strict";
+  }
+});
 
 // src/kernel/system/repos.ts
 import { existsSync as existsSync10 } from "fs";
@@ -6062,10 +6356,15 @@ async function resolveAllGoalPaths(db) {
   }
   return dirs;
 }
+var init_repos = __esm({
+  "src/kernel/system/repos.ts"() {
+    "use strict";
+    init_settings();
+    init_install_config();
+  }
+});
 
 // src/kernel/system/update-check.ts
-var WINGET_PACKAGE_ID = "ZAM.ZAM";
-var HOMEBREW_CASK = "zam";
 function parseVersion(version) {
   const clean = version.trim().replace(/^v/i, "");
   const [main, pre = ""] = clean.split("-", 2);
@@ -6155,6 +6454,7 @@ function planUpdate(decision) {
         { kind: "git-pull", label: "Pull the latest source" },
         { kind: "npm-install", label: "Install dependencies" },
         { kind: "npm-build", label: "Rebuild the CLI" },
+        { kind: "smoke-test", label: "Verify the rebuilt CLI launches" },
         {
           kind: "distribute-skills",
           label: "Refresh skill files (zam setup --force)"
@@ -6178,214 +6478,2126 @@ function planUpdate(decision) {
       ];
   }
 }
+var WINGET_PACKAGE_ID, HOMEBREW_CASK;
+var init_update_check = __esm({
+  "src/kernel/system/update-check.ts"() {
+    "use strict";
+    WINGET_PACKAGE_ID = "ZAM.ZAM";
+    HOMEBREW_CASK = "zam";
+  }
+});
+
+// src/kernel/index.ts
+var kernel_exports = {};
+__export(kernel_exports, {
+  BUILT_IN_SENSITIVE_MATCHERS: () => BUILT_IN_SENSITIVE_MATCHERS,
+  DEFAULT_OBSERVER_POLICY: () => DEFAULT_OBSERVER_POLICY,
+  DEFAULT_REVIEW_CONTEXT_MAX_CHARS: () => DEFAULT_REVIEW_CONTEXT_MAX_CHARS,
+  HOMEBREW_CASK: () => HOMEBREW_CASK,
+  OBSERVER_POLICY_UNSET_HINT: () => OBSERVER_POLICY_UNSET_HINT,
+  OBSERVER_POLICY_VERSION: () => OBSERVER_POLICY_VERSION,
+  REVIEW_CONTEXT_CACHE_TTL_MS: () => REVIEW_CONTEXT_CACHE_TTL_MS,
+  SIDECAR_POLICY_FILE: () => SIDECAR_POLICY_FILE,
+  SNAPSHOT_VERSION: () => SNAPSHOT_VERSION,
+  UI_OBSERVATION_PROTOCOL_VERSION: () => UI_OBSERVATION_PROTOCOL_VERSION,
+  WINGET_PACKAGE_ID: () => WINGET_PACKAGE_ID,
+  addPrerequisite: () => addPrerequisite,
+  analyzeObservation: () => analyzeObservation,
+  appendUiObservationReport: () => appendUiObservationReport,
+  applySessionSynthesis: () => applySessionSynthesis,
+  assignTokenToContext: () => assignTokenToContext,
+  buildAncestorMap: () => buildAncestorMap,
+  buildReviewQueue: () => buildReviewQueue,
+  buildUiSynthesisCandidates: () => buildUiSynthesisCandidates,
+  cascadeBlock: () => cascadeBlock,
+  clearADOCredentials: () => clearADOCredentials,
+  clearProviderApiKey: () => clearProviderApiKey,
+  clearReviewContextCache: () => clearReviewContextCache,
+  clearTursoCredentials: () => clearTursoCredentials,
+  compareVersions: () => compareVersions,
+  computeContentHash: () => computeContentHash,
+  confirmCardSplit: () => confirmCardSplit,
+  confirmFoundations: () => confirmFoundations,
+  confirmSourceImport: () => confirmSourceImport,
+  cosineSimilarity: () => cosineSimilarity,
+  createAgentSkill: () => createAgentSkill,
+  createFSRS: () => createFSRS,
+  createGoal: () => createGoal,
+  createKnowledgeContext: () => createKnowledgeContext,
+  createToken: () => createToken,
+  decidePostCapture: () => decidePostCapture,
+  decidePreCapture: () => decidePreCapture,
+  decideUpdate: () => decideUpdate,
+  decodeEmbedding: () => decodeEmbedding,
+  deleteCardForUser: () => deleteCardForUser,
+  deleteKnowledgeContext: () => deleteKnowledgeContext,
+  deleteSetting: () => deleteSetting,
+  deleteToken: () => deleteToken,
+  deprecateToken: () => deprecateToken,
+  detectSyncProvider: () => detectSyncProvider,
+  detectSystemLocale: () => detectSystemLocale,
+  discoverSkills: () => discoverSkills,
+  distributeGlobalSkills: () => distributeGlobalSkills,
+  embeddingContentForToken: () => embeddingContentForToken,
+  encodeEmbedding: () => encodeEmbedding,
+  endSession: () => endSession,
+  ensureCard: () => ensureCard,
+  ensureMonitorDir: () => ensureMonitorDir,
+  ensureUiObserverDir: () => ensureUiObserverDir,
+  evaluateRating: () => evaluateRating,
+  executeReviewAction: () => executeReviewAction,
+  exportSnapshot: () => exportSnapshot,
+  extractTasks: () => extractTasks,
+  extractTokenRefs: () => extractTokenRefs,
+  fetchActiveWorkItems: () => fetchActiveWorkItems,
+  findTokens: () => findTokens,
+  generateBashHooks: () => generateBashHooks,
+  generateBashUnhooks: () => generateBashUnhooks,
+  generateConceptFreeCue: () => generateConceptFreeCue,
+  generatePowerShellHooks: () => generatePowerShellHooks,
+  generatePowerShellUnhooks: () => generatePowerShellUnhooks,
+  generatePrompt: () => generatePrompt,
+  generateTokenSlug: () => generateTokenSlug,
+  generateZshHooks: () => generateZshHooks,
+  generateZshUnhooks: () => generateZshUnhooks,
+  getADOCredentials: () => getADOCredentials,
+  getActiveWorkspace: () => getActiveWorkspace,
+  getActiveWorkspaceContext: () => getActiveWorkspaceContext,
+  getActiveWorkspaceId: () => getActiveWorkspaceId,
+  getAgentSkill: () => getAgentSkill,
+  getAllSettings: () => getAllSettings,
+  getAllSettingsDetailed: () => getAllSettingsDetailed,
+  getBlockedCards: () => getBlockedCards,
+  getCard: () => getCard,
+  getCardById: () => getCardById,
+  getCardDeletionImpact: () => getCardDeletionImpact,
+  getConfiguredWorkspaces: () => getConfiguredWorkspaces,
+  getDatabaseTargetInfo: () => getDatabaseTargetInfo,
+  getDefaultDbPath: () => getDefaultDbPath,
+  getDependents: () => getDependents,
+  getDisplayTitle: () => getDisplayTitle,
+  getDomainCompetence: () => getDomainCompetence,
+  getDueCards: () => getDueCards,
+  getEmbeddingCoverage: () => getEmbeddingCoverage,
+  getGoal: () => getGoal,
+  getGoalTree: () => getGoalTree,
+  getInstallChannel: () => getInstallChannel,
+  getInstallMode: () => getInstallMode,
+  getKnowledgeContextById: () => getKnowledgeContextById,
+  getKnowledgeContextByName: () => getKnowledgeContextByName,
+  getMachineAiConfig: () => getMachineAiConfig,
+  getMonitorDir: () => getMonitorDir,
+  getMonitorLogStats: () => getMonitorLogStats,
+  getMonitorPath: () => getMonitorPath,
+  getPackageSkillPath: () => getPackageSkillPath,
+  getPrerequisites: () => getPrerequisites,
+  getProviderApiKey: () => getProviderApiKey,
+  getRepoPaths: () => getRepoPaths,
+  getReviewsForCard: () => getReviewsForCard,
+  getReviewsForUser: () => getReviewsForUser,
+  getSessionSummary: () => getSessionSummary,
+  getSessionSynthesisRecords: () => getSessionSynthesisRecords,
+  getSetting: () => getSetting,
+  getShortSlug: () => getShortSlug,
+  getSystemProfile: () => getSystemProfile,
+  getTokenById: () => getTokenById,
+  getTokenBySlug: () => getTokenBySlug,
+  getTokenDeleteImpact: () => getTokenDeleteImpact,
+  getTokenEmbedding: () => getTokenEmbedding,
+  getTokenNeighborhood: () => getTokenNeighborhood,
+  getTursoCredentials: () => getTursoCredentials,
+  getUiObservationPath: () => getUiObservationPath,
+  getUiObserverDir: () => getUiObserverDir,
+  getUserStats: () => getUserStats,
+  hasCommand: () => hasCommand,
+  importCurriculumCards: () => importCurriculumCards,
+  importSnapshot: () => importSnapshot,
+  injectShellHooks: () => injectShellHooks,
+  installFastFlowLM: () => installFastFlowLM,
+  installOllama: () => installOllama,
+  installOpenCode: () => installOpenCode,
+  interleave: () => interleave,
+  isObserverPolicyConfigured: () => isObserverPolicyConfigured,
+  isOllamaInstalled: () => isOllamaInstalled,
+  isUiObservationReport: () => isUiObservationReport,
+  listAgentSkills: () => listAgentSkills,
+  listContextsForToken: () => listContextsForToken,
+  listEmbeddedTokens: () => listEmbeddedTokens,
+  listGoals: () => listGoals,
+  listKnowledgeContexts: () => listKnowledgeContexts,
+  listPersonalCards: () => listPersonalCards,
+  listProviderApiKeyRefs: () => listProviderApiKeyRefs,
+  listTokens: () => listTokens,
+  listTokensNeedingEmbedding: () => listTokensNeedingEmbedding,
+  loadADOConfig: () => loadADOConfig,
+  loadCredentials: () => loadCredentials,
+  loadInstallConfig: () => loadInstallConfig,
+  logReview: () => logReview,
+  logStep: () => logStep,
+  matchBuiltInSensitive: () => matchBuiltInSensitive,
+  matchDenylist: () => matchDenylist,
+  matchesFilePath: () => matchesFilePath,
+  monitorLogExists: () => monitorLogExists,
+  normalizeLocale: () => normalizeLocale,
+  normalizePath: () => normalizePath,
+  openDatabase: () => openDatabase,
+  openDatabaseWithSync: () => openDatabaseWithSync,
+  openRemoteDatabase: () => openRemoteDatabase,
+  pairCommands: () => pairCommands,
+  parseGoalFile: () => parseGoalFile,
+  parseMonitorLog: () => parseMonitorLog,
+  parseObserverList: () => parseObserverList,
+  parseObserverPolicy: () => parseObserverPolicy,
+  parseSnapshot: () => parseSnapshot,
+  parseUiObservationLog: () => parseUiObservationLog,
+  planOpenCodeInstall: () => planOpenCodeInstall,
+  planUpdate: () => planUpdate,
+  prepareLocalModel: () => prepareLocalModel,
+  prepareSessionSynthesis: () => prepareSessionSynthesis,
+  readMonitorLog: () => readMonitorLog,
+  readUiObservationLog: () => readUiObservationLog,
+  removeConfiguredWorkspace: () => removeConfiguredWorkspace,
+  resolveAllBeliefPaths: () => resolveAllBeliefPaths,
+  resolveAllGoalPaths: () => resolveAllGoalPaths,
+  resolveObserverPolicy: () => resolveObserverPolicy,
+  resolveOllamaCommand: () => resolveOllamaCommand,
+  resolveReference: () => resolveReference,
+  resolveRepoPath: () => resolveRepoPath,
+  resolveReviewContext: () => resolveReviewContext,
+  saveConfiguredWorkspaces: () => saveConfiguredWorkspaces,
+  saveCredentials: () => saveCredentials,
+  saveInstallConfig: () => saveInstallConfig,
+  saveMachineAiConfig: () => saveMachineAiConfig,
+  searchTokensHybrid: () => searchTokensHybrid,
+  serializeGoal: () => serializeGoal,
+  setADOCredentials: () => setADOCredentials,
+  setActiveWorkspaceContext: () => setActiveWorkspaceContext,
+  setActiveWorkspaceId: () => setActiveWorkspaceId,
+  setInstallChannel: () => setInstallChannel,
+  setInstallMode: () => setInstallMode,
+  setProviderApiKey: () => setProviderApiKey,
+  setSetting: () => setSetting,
+  setTursoCredentials: () => setTursoCredentials,
+  slugify: () => slugify,
+  startSession: () => startSession,
+  suggestFoundations: () => suggestFoundations,
+  syncObserverSidecarPolicy: () => syncObserverSidecarPolicy,
+  t: () => t,
+  toSidecarPrivacyPolicy: () => toSidecarPrivacyPolicy,
+  uiObservationLogExists: () => uiObservationLogExists,
+  uiObservationTimeSpan: () => uiObservationTimeSpan,
+  unassignTokenFromContext: () => unassignTokenFromContext,
+  unblockReady: () => unblockReady,
+  updateCard: () => updateCard,
+  updateGoalStatus: () => updateGoalStatus,
+  updateKnowledgeContext: () => updateKnowledgeContext,
+  updateToken: () => updateToken,
+  upsertConfiguredWorkspace: () => upsertConfiguredWorkspace,
+  upsertTokenEmbedding: () => upsertTokenEmbedding,
+  verifySnapshot: () => verifySnapshot,
+  wouldCreateCycle: () => wouldCreateCycle,
+  writeMonitorEvent: () => writeMonitorEvent
+});
+var init_kernel = __esm({
+  "src/kernel/index.ts"() {
+    "use strict";
+    init_stats();
+    init_azure_devops();
+    init_credentials();
+    init_connection();
+    init_provider();
+    init_snapshot();
+    init_engine();
+    init_parser();
+    init_agent_skill();
+    init_card();
+    init_knowledge_context();
+    init_prerequisite();
+    init_review();
+    init_session();
+    init_settings();
+    init_token();
+    init_token_embedding();
+    init_analyzer();
+    init_monitor_io();
+    init_observer_sidecar_policy();
+    init_policy();
+    init_session_synthesis();
+    init_shell_hooks();
+    init_skill_discovery();
+    init_ui_observer();
+    init_ui_observer_io();
+    init_ui_observer_synthesis();
+    init_actions();
+    init_evaluator();
+    init_prompter();
+    init_reference_resolver();
+    init_blocker();
+    init_fsrs();
+    init_interleaver();
+    init_queue();
+    init_hybrid();
+    init_suggestions();
+    init_hooks();
+    init_i18n();
+    init_install_config();
+    init_installer();
+    init_locale();
+    init_profiler();
+    init_repos();
+    init_update_check();
+  }
+});
+
+// src/cli/commands/mcp.ts
+init_kernel();
+import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
+import { dirname as dirname5, join as join11 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// src/cli/bridge-handlers.ts
+init_kernel();
+
+// src/cli/knowledge-contexts.ts
+init_kernel();
+async function resolveOperationKnowledgeContexts(db, requestedNames) {
+  const explicitNames = [
+    ...new Set(requestedNames.map((name) => name.trim()).filter(Boolean))
+  ];
+  const activeDefault = getActiveWorkspaceContext();
+  const selectedNames = explicitNames.length > 0 ? explicitNames : activeDefault ? [activeDefault] : [];
+  const contexts = [];
+  for (const name of selectedNames) {
+    const context = await getKnowledgeContextByName(db, name);
+    if (!context) {
+      const subject = explicitNames.length > 0 ? "Knowledge" : "Active knowledge";
+      throw new Error(`${subject} context not found: ${name}`);
+    }
+    contexts.push(context);
+  }
+  return contexts;
+}
+
+// src/cli/llm/client.ts
+init_kernel();
+import { spawn } from "child_process";
+import { existsSync as existsSync11, readFileSync as readFileSync9, statSync as statSync2 } from "fs";
+var DEFAULT_LLM_URL = "http://localhost:8000/v1";
+var RECALL_QUESTION_MAX_OUTPUT_TOKENS = 400;
+var RECALL_ENDPOINT_CACHE_MS = 6e4;
+var cachedRecallEndpoint = null;
+function recallEndpointSignature(cfg) {
+  return [
+    cfg.enabled ? "on" : "off",
+    cfg.providerName ?? "",
+    cfg.url,
+    cfg.model,
+    cfg.apiFlavor,
+    cfg.fallback?.url ?? "",
+    cfg.fallback?.model ?? ""
+  ].join("|");
+}
+var DEFAULT_LLM_MODEL = "qwen3.5:4b";
+var DEFAULT_LLM_API_KEY = "sk-none";
+async function getLlmConfig(db) {
+  return {
+    enabled: await getSetting(db, "llm.enabled") === "true",
+    url: await getSetting(db, "llm.url") || DEFAULT_LLM_URL,
+    model: await getSetting(db, "llm.model") || DEFAULT_LLM_MODEL,
+    apiKey: await getSetting(db, "llm.api_key") || DEFAULT_LLM_API_KEY,
+    locale: await getSetting(db, "system.locale") || "en"
+  };
+}
+function getCloudModelRecommendation(url) {
+  const lowercase = url.toLowerCase();
+  if (lowercase.includes("openrouter.ai")) {
+    return { model: "openrouter/free", flavor: "chat-completions" };
+  }
+  if (lowercase.includes("openai.com") || lowercase.includes("api.openai")) {
+    return { model: "gpt-5-mini", flavor: "chat-completions" };
+  }
+  if (lowercase.includes("googleapis.com") || lowercase.includes("google")) {
+    return { model: "gemini-3.5-flash", flavor: "chat-completions" };
+  }
+  if (lowercase.includes("deepseek.com")) {
+    return { model: "deepseek-v4-flash", flavor: "chat-completions" };
+  }
+  if (lowercase.includes("mimo")) {
+    return { model: "mimo-v2.5", flavor: "chat-completions" };
+  }
+  if (lowercase.includes("anthropic.com")) {
+    return {
+      model: "claude-haiku-4-5-20251001",
+      flavor: "anthropic-messages"
+    };
+  }
+  return null;
+}
+function inferApiFlavor(url) {
+  try {
+    return new URL(url).hostname.toLowerCase().endsWith("anthropic.com") ? "anthropic-messages" : "chat-completions";
+  } catch {
+    return "chat-completions";
+  }
+}
+async function readJsonSetting(db, key) {
+  const raw = await getSetting(db, key);
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function resolveProviderApiKey(rec) {
+  if (rec.apiKey) return rec.apiKey;
+  if (rec.apiKeyRef) {
+    const key = getProviderApiKey(rec.apiKeyRef);
+    if (key) return key;
+  }
+  return DEFAULT_LLM_API_KEY;
+}
+async function getProviderForRole(db, role) {
+  const enabled = role === "vision" ? await getSetting(db, "llm.vision.enabled") === "true" : await getSetting(db, "llm.enabled") === "true";
+  const base = await getLegacyRoleConfig(db, role, enabled);
+  const providers = await readJsonSetting(db, "llm.providers");
+  const roles = await readJsonSetting(db, "llm.roles");
+  const binding = roles?.[role];
+  let resolved = base;
+  if (providers && binding?.primary && providers[binding.primary]) {
+    const primary = materializeProvider(
+      providers[binding.primary],
+      base,
+      role,
+      {
+        providerName: binding.primary,
+        source: "shared"
+      }
+    );
+    const fallback = binding.fallback && providers[binding.fallback] ? materializeProvider(providers[binding.fallback], base, role, {
+      providerName: binding.fallback,
+      source: "shared"
+    }) : void 0;
+    resolved = { ...primary, fallback };
+  }
+  const machine = getMachineAiConfig();
+  const machineProviders = machine.providers;
+  const machineBinding = machine.roles?.[role];
+  if (machineProviders && machineBinding?.primary && machineProviders[machineBinding.primary]) {
+    const primary = materializeProvider(
+      machineProviders[machineBinding.primary],
+      resolved,
+      role,
+      { providerName: machineBinding.primary, source: "machine" }
+    );
+    const fallback = machineBinding.fallback && machineProviders[machineBinding.fallback] ? materializeProvider(
+      machineProviders[machineBinding.fallback],
+      resolved,
+      role,
+      { providerName: machineBinding.fallback, source: "machine" }
+    ) : void 0;
+    return { ...primary, fallback };
+  }
+  return resolved;
+}
+function materializeProvider(rec, base, role, meta) {
+  const url = rec.url || base.url;
+  return {
+    enabled: base.enabled,
+    url,
+    model: rec.model || base.model,
+    apiKey: resolveProviderApiKey(rec),
+    apiFlavor: rec.apiFlavor || inferApiFlavor(url),
+    locale: base.locale,
+    providerName: meta.providerName,
+    label: rec.label,
+    source: meta.source,
+    local: rec.local ?? isLocalEndpoint(url),
+    ...rec.runner ? { runner: rec.runner } : {},
+    ...role === "vision" ? { maxFrames: base.maxFrames } : {}
+  };
+}
+async function getLegacyRoleConfig(db, role, enabled) {
+  const base = await getLlmConfig(db);
+  if (role === "vision") {
+    const maxFramesStr = await getSetting(db, "llm.vision.max_frames");
+    const parsed = maxFramesStr ? parseInt(maxFramesStr, 10) : 100;
+    const url = await getSetting(db, "llm.vision.url") || base.url;
+    const recommendation = getCloudModelRecommendation(url);
+    let model = await getSetting(db, "llm.vision.model");
+    if (!model) model = recommendation?.model || base.model;
+    return {
+      enabled,
+      url,
+      model,
+      apiKey: await getSetting(db, "llm.vision.api_key") || base.apiKey,
+      apiFlavor: recommendation?.flavor || inferApiFlavor(url),
+      locale: base.locale,
+      source: "legacy",
+      local: isLocalEndpoint(url),
+      maxFrames: Number.isNaN(parsed) ? 100 : parsed
+    };
+  }
+  if (role === "embedding") {
+    const url = await getSetting(db, "llm.embedding.url") || base.url;
+    return {
+      enabled,
+      url,
+      // Kept as a literal (not imported) to avoid a client.ts <-> embedder.ts
+      // import cycle; must match DEFAULT_EMBEDDING_MODEL in embedder.ts.
+      model: await getSetting(db, "llm.embedding.model") || "embeddinggemma",
+      apiKey: await getSetting(db, "llm.embedding.api_key") || base.apiKey,
+      apiFlavor: inferApiFlavor(url),
+      locale: base.locale,
+      source: "legacy",
+      local: isLocalEndpoint(url)
+    };
+  }
+  return {
+    enabled,
+    url: base.url,
+    model: base.model,
+    apiKey: base.apiKey,
+    apiFlavor: inferApiFlavor(base.url),
+    locale: base.locale,
+    source: "legacy",
+    local: isLocalEndpoint(base.url)
+  };
+}
+function assertChatCompletions(cfg) {
+  if (cfg.apiFlavor !== "chat-completions") {
+    throw new Error(
+      `This role is configured for a "${cfg.apiFlavor}" provider, which is not supported here yet. Use a chat-completions provider for this role.`
+    );
+  }
+}
+var LANGUAGE_NAMES = {
+  en: "English",
+  de: "German",
+  es: "Spanish",
+  fr: "French",
+  pt: "Portuguese",
+  zh: "Chinese",
+  ja: "Japanese"
+};
+var BLOOM_VERBS2 = {
+  1: "Remember",
+  2: "Understand",
+  3: "Apply",
+  4: "Analyze",
+  5: "Synthesize"
+};
+var LlmResponseTruncatedError = class extends Error {
+  constructor(label) {
+    super(
+      `${label}: the model's response was cut off before producing usable output (finish_reason=length). The prompt likely left no room in the model's context window for a reply.`
+    );
+    this.name = "LlmResponseTruncatedError";
+  }
+};
+async function readChatContent(res, label) {
+  if (!res.ok) {
+    const errorText = await res.text().catch(() => "");
+    throw new Error(
+      `${label} failed: ${res.statusText} (${res.status}) - ${errorText}`
+    );
+  }
+  const data = await res.json();
+  const choice = data.choices?.[0];
+  const content = choice?.message?.content;
+  const trimmed = content?.trim() ?? "";
+  if (choice?.finish_reason === "length") {
+    throw new LlmResponseTruncatedError(label);
+  }
+  if (!trimmed) {
+    throw new Error("Empty response from LLM");
+  }
+  return trimmed;
+}
+async function generateQuestionViaLLM(db, input) {
+  const cfg = await getProviderForRole(db, "recall");
+  const endpoint = await resolveUsableRecallEndpoint(db);
+  const bloom = input.bloomLevel >= 1 && input.bloomLevel <= 5 ? input.bloomLevel : 1;
+  const verb = BLOOM_VERBS2[bloom];
+  const langName = LANGUAGE_NAMES[cfg.locale] || "English";
+  const systemPrompt = `You are ZAM, a highly precise agentic skills trainer.
+Your task is to generate a single, clear, conceptual active-recall question (flashcard front) in ${langName} for a knowledge token.
 
+Guidelines:
+1. The question MUST match the Bloom level: ${verb} (Level ${bloom}).
+2. CRITICAL: The question MUST NOT contain or reveal the concept text itself! The concept is the answer (flashcard back) that the learner needs to recall.
+3. Keep the question concise, highly specific, and clear. Avoid generic prompts like "What is the concept of..." if possible, and ask about the core mechanism, function, or purpose of the slug/concept without giving the answer away.
+4. Output ONLY the raw question text in ${langName}. Do not include any preamble, headers, markdown fences, or conversational filler.`;
+  const userPrompt = `Domain: ${input.domain}
+Slug: ${input.slug}
+Concept to Recall (DO NOT REVEAL IN QUESTION): ${input.concept}
+Context: ${input.context || "(none)"}
+${input.sourceLinkContent ? `Source Reference:
+${input.sourceLinkContent}` : ""}
+
+Active-Recall Question:`;
+  const res = await fetchWithInteractiveTimeout(
+    `${endpoint.url}/chat/completions`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${endpoint.apiKey}`
+      },
+      body: JSON.stringify({
+        model: endpoint.model,
+        messages: [
+          { role: "system", content: systemPrompt },
+          { role: "user", content: userPrompt }
+        ],
+        temperature: 0.1,
+        max_tokens: RECALL_QUESTION_MAX_OUTPUT_TOKENS
+      }),
+      locale: cfg.locale
+    }
+  );
+  const text = await readChatContent(res, "LLM request");
+  return {
+    text,
+    model: endpoint.model,
+    providerName: endpoint.providerName
+  };
+}
+async function isLlmOnline(url) {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 1500);
+    const res = await fetch(`${url}/models`, {
+      method: "GET",
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    return res.ok || res.status < 500;
+  } catch {
+    return false;
+  }
+}
+async function getAvailableModels(url, apiKey = DEFAULT_LLM_API_KEY) {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3e3);
+    const res = await fetch(`${url}/models`, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!res.ok) return [];
+    const data = await res.json();
+    return (data.data ?? []).map((m) => m.id).filter((id) => typeof id === "string" && id.length > 0);
+  } catch {
+    return [];
+  }
+}
+function isLocalEndpoint(url) {
+  return url.includes("localhost") || url.includes("127.0.0.1") || url.includes("[::1]") || url.includes("::1");
+}
+async function checkProviderEndpoint(endpoint) {
+  const online = await isLlmOnline(endpoint.url);
+  if (!online) {
+    return {
+      endpoint,
+      online: false,
+      availableModels: [],
+      modelAvailable: false
+    };
+  }
+  const availableModels = await getAvailableModels(
+    endpoint.url,
+    endpoint.apiKey
+  );
+  const modelAvailable = availableModels.length === 0 || availableModels.some(
+    (candidate) => candidate.toLowerCase() === endpoint.model.toLowerCase()
+  );
+  return { endpoint, online, availableModels, modelAvailable };
+}
+function isEndpointUsable(readiness) {
+  return readiness.online && readiness.modelAvailable;
+}
+function providerChain(primary) {
+  return [primary, ...primary.fallback ? [primary.fallback] : []];
+}
+async function checkProviderChain(primary) {
+  let first;
+  for (const endpoint of providerChain(primary)) {
+    const readiness = await checkProviderEndpoint(endpoint);
+    first ??= readiness;
+    if (isEndpointUsable(readiness)) {
+      return { primary: first, firstUsable: readiness };
+    }
+  }
+  return { primary: first };
+}
+async function resolveUsableRecallEndpoint(db) {
+  const cfg = await getProviderForRole(db, "recall");
+  if (!cfg.enabled) {
+    throw new Error("LLM integration is disabled in settings (llm.enabled)");
+  }
+  assertChatCompletions(cfg);
+  const signature = recallEndpointSignature(cfg);
+  if (cachedRecallEndpoint && cachedRecallEndpoint.signature === signature && cachedRecallEndpoint.expiresAt > Date.now()) {
+    return cachedRecallEndpoint.endpoint;
+  }
+  const chain = await checkProviderChain(cfg);
+  const selected = chain.firstUsable;
+  if (!selected || !isEndpointUsable(selected)) {
+    throw new Error("No recall LLM endpoint is online");
+  }
+  cachedRecallEndpoint = {
+    endpoint: selected.endpoint,
+    signature,
+    expiresAt: Date.now() + RECALL_ENDPOINT_CACHE_MS
+  };
+  return selected.endpoint;
+}
+async function fetchWithInteractiveTimeout(url, options = {}) {
+  const {
+    timeoutMs = 2e4,
+    hardTimeoutMs = 12e4,
+    locale = "en",
+    ...fetchOptions
+  } = options;
+  const controller = new AbortController();
+  const fetchPromise = fetch(url, {
+    ...fetchOptions,
+    signal: controller.signal
+  });
+  if (!process.stdout.isTTY || process.env.ZAM_BRIDGE === "true") {
+    let timeoutId;
+    const hardTimeout = new Promise((_resolve, reject) => {
+      timeoutId = setTimeout(() => {
+        reject(new Error(`LLM request timed out after ${hardTimeoutMs}ms`));
+        controller.abort();
+      }, hardTimeoutMs);
+    });
+    try {
+      return await Promise.race([fetchPromise, hardTimeout]);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  let attempts = 0;
+  const dotsPerLine = 30;
+  while (true) {
+    let timeoutId;
+    const timeoutPromise = new Promise((resolve3) => {
+      timeoutId = setTimeout(() => resolve3("timeout"), timeoutMs);
+    });
+    const dotsInterval = setInterval(() => {
+      process.stdout.write(".");
+      attempts++;
+      if (attempts % dotsPerLine === 0) process.stdout.write("\n");
+    }, 500);
+    try {
+      const result = await Promise.race([fetchPromise, timeoutPromise]);
+      clearInterval(dotsInterval);
+      clearTimeout(timeoutId);
+      if (result !== "timeout") {
+        if (attempts > 0) process.stdout.write("\n");
+        return result;
+      }
+      console.log(`
+\x1B[33m${t(locale, "local_ai_working")}\x1B[0m`);
+      const { confirm } = await import("@inquirer/prompts");
+      const keepWaiting = await confirm({
+        message: t(locale, "keep_waiting"),
+        default: true
+      }).catch(() => false);
+      if (!keepWaiting) {
+        controller.abort();
+        console.log(`\x1B[33m${t(locale, "proceeding_offline")}\x1B[0m
+`);
+        throw new Error("User cancelled waiting for slow LLM response");
+      }
+      attempts = 0;
+    } catch (err) {
+      clearInterval(dotsInterval);
+      clearTimeout(timeoutId);
+      if (attempts > 0) process.stdout.write("\n");
+      throw err;
+    }
+  }
+}
+async function ensureHighQualityQuestion(db, token) {
+  const { enabled } = await getLlmConfig(db);
+  if (enabled) {
+    try {
+      let sourceLinkContent = null;
+      if (token.sourceLink) {
+        const resolved = await resolveReviewContext(token.sourceLink).catch(
+          () => null
+        );
+        if (resolved) {
+          sourceLinkContent = resolved.content;
+        }
+      }
+      const generated = await generateQuestionViaLLM(db, {
+        slug: token.slug,
+        concept: token.concept,
+        domain: token.domain,
+        bloomLevel: token.bloomLevel,
+        sourceLinkContent
+      });
+      if (generated.text.trim().length > 0) {
+        await updateToken(db, token.slug, { question: generated.text });
+        return {
+          question: generated.text,
+          source: "llm",
+          model: generated.model
+        };
+      }
+    } catch {
+    }
+  }
+  if (token.question && token.question.trim().length > 0) {
+    return {
+      question: token.question.trim(),
+      source: "original"
+    };
+  }
+  return null;
+}
+
+// src/cli/llm/embedder.ts
+init_kernel();
+var CANONICAL_EMBEDDING_MODEL_ID = "embeddinggemma-300m";
+var EMBEDDINGGEMMA_ALIASES = /* @__PURE__ */ new Set([
+  "embeddinggemma",
+  "embeddinggemma:300m",
+  "embeddinggemma-300m",
+  "embed-gemma",
+  "embed-gemma:300m",
+  "google/embeddinggemma-300m"
+]);
+function canonicalEmbeddingModelId(model) {
+  const lowered = model.trim().toLowerCase();
+  if (EMBEDDINGGEMMA_ALIASES.has(lowered)) {
+    return CANONICAL_EMBEDDING_MODEL_ID;
+  }
+  return lowered;
+}
+function embeddingTextForToken(t2, model) {
+  const isGemma = EMBEDDINGGEMMA_ALIASES.has(model.trim().toLowerCase());
+  const content = embeddingContentForToken(t2);
+  return isGemma ? `title: none | text: ${content}` : content;
+}
+function embeddingTextForQuery(text, model) {
+  const isGemma = EMBEDDINGGEMMA_ALIASES.has(model.trim().toLowerCase());
+  return isGemma ? `task: search result | query: ${text}` : text;
+}
+async function resolveUsableEmbeddingEndpoint(db) {
+  const cfg = await getProviderForRole(db, "embedding");
+  if (!cfg.enabled) return null;
+  for (const endpoint of [cfg, ...cfg.fallback ? [cfg.fallback] : []]) {
+    if (endpoint.apiFlavor !== "chat-completions") continue;
+    const online = await isLlmOnline(endpoint.url);
+    if (!online) continue;
+    const availableModels = await getAvailableModels(
+      endpoint.url,
+      endpoint.apiKey
+    );
+    const modelAvailable = availableModels.length === 0 || availableModels.some(
+      (candidate) => candidate.toLowerCase() === endpoint.model.toLowerCase()
+    );
+    if (modelAvailable) return endpoint;
+  }
+  return null;
+}
+async function embedTexts(endpoint, texts) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 6e4);
+  let res;
+  try {
+    res = await fetch(`${endpoint.url}/embeddings`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${endpoint.apiKey || DEFAULT_LLM_API_KEY}`
+      },
+      body: JSON.stringify({ model: endpoint.model, input: texts }),
+      signal: controller.signal
+    });
+  } finally {
+    clearTimeout(timeoutId);
+  }
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(
+      `Embedding request failed: ${res.statusText} (${res.status}) - ${body}`
+    );
+  }
+  const data = await res.json();
+  const items = data.data ?? [];
+  if (items.length !== texts.length) {
+    throw new Error(
+      `Embedding response returned ${items.length} vectors for ${texts.length} inputs`
+    );
+  }
+  const ordered = new Array(texts.length);
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    const index = typeof item.index === "number" ? item.index : i;
+    if (!Number.isInteger(index)) {
+      throw new Error("Embedding response item is missing a valid index");
+    }
+    if (index < 0 || index >= texts.length) {
+      throw new Error(`Embedding response index out of range: ${index}`);
+    }
+    if (!Array.isArray(item.embedding) || item.embedding.length === 0 || !item.embedding.every((n) => typeof n === "number" && Number.isFinite(n))) {
+      throw new Error(
+        `Embedding response at index ${index} is not a non-empty array of finite numbers`
+      );
+    }
+    ordered[index] = item.embedding;
+  }
+  const firstLength = ordered[0]?.length;
+  if (ordered.some((vec) => vec === void 0 || vec.length !== firstLength)) {
+    throw new Error("Embedding response vectors have inconsistent lengths");
+  }
+  return ordered;
+}
+var EMBED_BATCH_SIZE = 16;
+async function ensureTokenEmbeddings(db, opts) {
+  const endpoint = await resolveUsableEmbeddingEndpoint(db);
+  if (!endpoint) {
+    const reason = await describeUnavailableReason(db);
+    return { status: "unavailable", embedded: 0, remaining: 0, reason };
+  }
+  const model = canonicalEmbeddingModelId(endpoint.model);
+  const pending = await listTokensNeedingEmbedding(db, model, {
+    limit: opts?.limit ?? 64,
+    force: opts?.force,
+    dims: opts?.dims
+  });
+  let embedded = 0;
+  let failure;
+  try {
+    for (let i = 0; i < pending.length; i += EMBED_BATCH_SIZE) {
+      const batch = pending.slice(i, i + EMBED_BATCH_SIZE);
+      const formattedTexts = batch.map(
+        (item) => embeddingTextForToken(item.token, endpoint.model)
+      );
+      const vectors = await embedTexts(
+        { url: endpoint.url, model: endpoint.model, apiKey: endpoint.apiKey },
+        formattedTexts
+      );
+      for (const [index, item] of batch.entries()) {
+        await upsertTokenEmbedding(db, {
+          tokenId: item.token.id,
+          embedding: vectors[index],
+          model,
+          contentHash: computeContentHash(item.text)
+        });
+        embedded++;
+      }
+    }
+  } catch (err) {
+    failure = err instanceof Error ? err.message : String(err);
+  }
+  const coverage = await getEmbeddingCoverage(db, model, { dims: opts?.dims });
+  const remaining = coverage.missing + coverage.stale;
+  if (failure !== void 0) {
+    return { status: "unavailable", embedded, remaining, reason: failure };
+  }
+  return { status: "ok", embedded, remaining };
+}
+async function describeUnavailableReason(db) {
+  const cfg = await getProviderForRole(db, "embedding");
+  if (!cfg.enabled) {
+    return "embedding role is disabled in settings (llm.enabled)";
+  }
+  const endpoints = [cfg, ...cfg.fallback ? [cfg.fallback] : []];
+  const online = await Promise.all(
+    endpoints.map((endpoint) => isLlmOnline(endpoint.url))
+  );
+  if (!online.some(Boolean)) {
+    return `embedding endpoints offline (${endpoints.map((endpoint) => endpoint.url).join(", ")})`;
+  }
+  return `no configured embedding model is available (${endpoints.map((endpoint) => endpoint.model).join(", ")})`;
+}
+async function embedQuery(db, text) {
+  const endpoint = await resolveUsableEmbeddingEndpoint(db);
+  if (!endpoint) return null;
+  try {
+    const [vector] = await embedTexts(
+      { url: endpoint.url, model: endpoint.model, apiKey: endpoint.apiKey },
+      [embeddingTextForQuery(text, endpoint.model)]
+    );
+    return { vector, model: canonicalEmbeddingModelId(endpoint.model) };
+  } catch {
+    return null;
+  }
+}
+async function findPossibleDuplicates(db, candidate, embed = embedQuery) {
+  const queryText = embeddingContentForToken({
+    concept: candidate.concept,
+    question: candidate.question ?? null,
+    domain: candidate.domain ?? "",
+    title: candidate.title ?? null
+  });
+  const q2 = await embed(db, queryText);
+  if (!q2) {
+    return [];
+  }
+  const coverage = await getEmbeddingCoverage(db, q2.model, {
+    dims: q2.vector.length
+  });
+  const totalNeeding = coverage.missing + coverage.stale;
+  if (totalNeeding > 0) {
+    await ensureTokenEmbeddings(db, { limit: 100, dims: q2.vector.length });
+    if (totalNeeding > 100) {
+      console.warn(
+        `Warning: Duplicate check is incomplete. ${totalNeeding - 100} tokens are still missing embeddings. Run 'zam token reembed' to complete indexing.`
+      );
+    }
+  }
+  const threshold = await resolveDedupThreshold(db);
+  const hits = await searchTokensHybrid(db, queryText, {
+    queryEmbedding: q2.vector,
+    model: q2.model,
+    limit: 1e3,
+    vectorTopK: 1e3
+  });
+  const results = [];
+  for (const hit of hits) {
+    if (hit.similarity !== null && hit.similarity >= threshold) {
+      results.push({
+        slug: hit.slug,
+        concept: hit.concept,
+        title: hit.title,
+        similarity: hit.similarity
+      });
+    }
+  }
+  return results;
+}
+async function resolveDedupThreshold(db) {
+  const thresholdStr = await getSetting(db, "search.dedup_threshold");
+  const parsed = thresholdStr ? Number.parseFloat(thresholdStr) : Number.NaN;
+  return Number.isFinite(parsed) && parsed > 0 && parsed <= 1 ? parsed : 0.85;
+}
+async function resolveSuggestMinSimilarity(db) {
+  const minStr = await getSetting(db, "search.suggest_min_similarity");
+  const parsed = minStr ? Number.parseFloat(minStr) : Number.NaN;
+  return Number.isFinite(parsed) && parsed > 0 && parsed <= 1 ? parsed : 0.45;
+}
+
+// src/cli/bridge-handlers.ts
+var BLOOM_VERBS3 = {
+  1: "Remember",
+  2: "Understand",
+  3: "Apply",
+  4: "Analyze",
+  5: "Synthesize"
+};
+async function resolveHandlerUser(db, user) {
+  if (user) return user;
+  const stored = await getSetting(db, "user.id");
+  if (stored) return stored;
+  throw new Error(
+    "No user specified. Set a default with: zam whoami --set <id>"
+  );
+}
+function parseKnowledgeContextNames(value) {
+  if (value == null) return [];
+  if (!Array.isArray(value) || value.some((name) => typeof name !== "string" || !name.trim())) {
+    throw new Error(
+      "knowledgeContexts must be an array of non-empty context names"
+    );
+  }
+  return [...new Set(value.map((name) => name.trim()))];
+}
+async function resolveKnowledgeContexts(db, names) {
+  return await resolveOperationKnowledgeContexts(db, names);
+}
+async function checkDue(db, params) {
+  const userId = await resolveHandlerUser(db, params.user);
+  const dueCards = await getDueCards(
+    db,
+    userId,
+    void 0,
+    params.domain,
+    params.knowledgeContext
+  );
+  const domains = [
+    ...new Set(dueCards.map((c) => c.domain).filter(Boolean))
+  ].sort();
+  const stats = await getUserStats(db, userId);
+  return {
+    database: getDatabaseTargetInfo(),
+    stats,
+    userId,
+    domain: params.domain ?? null,
+    knowledgeContext: params.knowledgeContext ?? null,
+    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
+    }))
+  };
+}
+async function getReviewsBatch(db, params) {
+  const userId = await resolveHandlerUser(db, params.user);
+  const dueCards = await getDueCards(
+    db,
+    userId,
+    void 0,
+    params.domain,
+    params.knowledgeContext
+  );
+  const isLlmEnabled = await getSetting(db, "llm.enabled") === "true";
+  const cards = [];
+  for (const card of dueCards) {
+    if (params.includeQuestions) {
+      const token = await getTokenBySlug(db, card.slug);
+      if (!token) {
+        cards.push({
+          cardId: card.id,
+          tokenId: card.token_id,
+          slug: card.slug,
+          concept: card.concept,
+          domain: card.domain,
+          bloomLevel: card.bloom_level,
+          state: card.state,
+          dueAt: card.due_at
+        });
+        continue;
+      }
+      let resolvedQuestion = token.question;
+      if (isLlmEnabled && params.noDynamicQuestion !== true) {
+        try {
+          const healed = await ensureHighQualityQuestion(db, {
+            id: token.id,
+            slug: token.slug,
+            concept: token.concept,
+            domain: token.domain,
+            bloomLevel: token.bloom_level,
+            sourceLink: token.source_link,
+            question: token.question
+          });
+          if (healed) {
+            resolvedQuestion = healed.question;
+          }
+        } catch {
+        }
+      }
+      const finalQuestion = resolvedQuestion?.trim() ? resolvedQuestion.trim() : generateConceptFreeCue(
+        token.bloom_level,
+        token.slug,
+        token.domain
+      );
+      let resolvedContext = null;
+      if (params.noResolve !== true && token.source_link) {
+        try {
+          resolvedContext = await resolveReviewContext(token.source_link);
+        } catch {
+          resolvedContext = null;
+        }
+      }
+      const bloom = token.bloom_level >= 1 && token.bloom_level <= 5 ? token.bloom_level : 1;
+      cards.push({
+        cardId: card.id,
+        tokenId: card.token_id,
+        slug: card.slug,
+        concept: card.concept,
+        domain: card.domain,
+        bloomLevel: card.bloom_level,
+        state: card.state,
+        dueAt: card.due_at,
+        bloomVerb: BLOOM_VERBS3[bloom],
+        question: finalQuestion,
+        sourceLink: token.source_link ?? null,
+        resolvedContext
+      });
+    } else {
+      cards.push({
+        cardId: card.id,
+        tokenId: card.token_id,
+        slug: card.slug,
+        concept: card.concept,
+        domain: card.domain,
+        bloomLevel: card.bloom_level,
+        state: card.state,
+        dueAt: card.due_at
+      });
+    }
+  }
+  return { cards };
+}
+async function submitReview(db, params) {
+  const userId = await resolveHandlerUser(db, params.user);
+  if (params.doneBy !== void 0 && !["user", "agent"].includes(params.doneBy)) {
+    throw new Error("doneBy must be user or agent");
+  }
+  if (params.doneBy === "agent") {
+    if (params.rating !== void 0) {
+      throw new Error("Agent-completed steps must not include a rating");
+    }
+    if (!params.sessionId) {
+      throw new Error("sessionId is required for an agent-completed step");
+    }
+    if (!params.cardId) {
+      throw new Error("cardId is required for an agent-completed step");
+    }
+    const card = await getCardById(db, params.cardId);
+    if (!card) {
+      throw new Error(`Card not found: ${params.cardId}`);
+    }
+    if (card.user_id !== userId) {
+      throw new Error(
+        `Card ${params.cardId} does not belong to user ${userId}`
+      );
+    }
+    await logStep(db, {
+      session_id: params.sessionId,
+      token_id: card.token_id,
+      done_by: "agent"
+    });
+    return {
+      success: true,
+      rating: null,
+      evaluation: null,
+      blocked: null,
+      recordedOnly: true
+    };
+  }
+  if (params.rating == null || params.rating < 1 || params.rating > 4) {
+    throw new Error("Rating must be between 1 and 4");
+  }
+  let cardId = params.cardId;
+  if (!cardId) {
+    if (!params.tokenId) {
+      throw new Error("cardId or tokenId is required");
+    }
+    const token = await getTokenById(db, params.tokenId);
+    if (!token || token.deprecated_at) {
+      throw new Error(`Active token not found: ${params.tokenId}`);
+    }
+    cardId = (await ensureCard(db, token.id, userId)).id;
+  }
+  const result = await executeReviewAction(db, {
+    action: "rate",
+    cardId,
+    userId,
+    rating: params.rating
+  });
+  let stepError;
+  if (params.sessionId) {
+    try {
+      await logStep(db, {
+        session_id: params.sessionId,
+        token_id: result.token.id,
+        done_by: "user",
+        rating: params.rating
+      });
+    } catch (err) {
+      stepError = err.message;
+    }
+  }
+  return {
+    success: true,
+    rating: params.rating,
+    evaluation: result.evaluation,
+    blocked: result.blocked ?? null,
+    ...stepError ? { stepError } : {}
+  };
+}
+async function reviewAction(db, params) {
+  const userId = await resolveHandlerUser(db, params.user);
+  const action = params.action;
+  const validActions = [
+    "rate",
+    "skip",
+    "edit-token",
+    "deprecate-token",
+    "delete-token",
+    "delete-card",
+    "stop"
+  ];
+  if (!validActions.includes(action)) {
+    throw new Error(`Unsupported action: ${action}`);
+  }
+  const target = await db.prepare(
+    `SELECT c.id AS card_id, c.token_id, c.user_id, t.slug
+       FROM cards c
+       JOIN tokens t ON t.id = c.token_id
+       WHERE c.id = ?`
+  ).get(params.cardId);
+  if (!target) {
+    throw new Error(`Card not found: ${params.cardId}`);
+  }
+  if (target.user_id !== userId) {
+    throw new Error(`Card ${params.cardId} does not belong to user ${userId}`);
+  }
+  if ((action === "delete-token" || action === "delete-card") && !params.confirm) {
+    if (action === "delete-token") {
+      return {
+        success: true,
+        action,
+        preview: true,
+        requiresConfirmation: true,
+        token: { slug: target.slug, tokenId: target.token_id },
+        impact: await getTokenDeleteImpact(db, target.slug)
+      };
+    }
+    return {
+      success: true,
+      action,
+      preview: true,
+      requiresConfirmation: true,
+      token: { slug: target.slug, tokenId: target.token_id },
+      impact: await getCardDeletionImpact(db, target.token_id, userId)
+    };
+  }
+  if (action === "rate" && (params.rating == null || params.rating < 1 || params.rating > 4)) {
+    throw new Error("Rating must be between 1 and 4 for action=rate");
+  }
+  let tokenUpdates;
+  if (action === "edit-token") {
+    tokenUpdates = {};
+    if (params.concept !== void 0) tokenUpdates.concept = params.concept;
+    if (params.domain !== void 0) tokenUpdates.domain = params.domain;
+    if (params.bloomLevel !== void 0)
+      tokenUpdates.bloom_level = params.bloomLevel;
+    if (params.context !== void 0) tokenUpdates.context = params.context;
+    if (params.sourceLink !== void 0) {
+      tokenUpdates.source_link = params.sourceLink === "" ? null : params.sourceLink;
+    }
+    if (params.symbiosisMode !== void 0) {
+      const validModes = ["shadowing", "copilot", "autonomy", "none"];
+      if (!validModes.includes(params.symbiosisMode)) {
+        throw new Error(`Invalid mode: ${params.symbiosisMode}`);
+      }
+      tokenUpdates.symbiosis_mode = params.symbiosisMode === "none" ? null : params.symbiosisMode;
+    }
+  }
+  const result = await executeReviewAction(db, {
+    action,
+    cardId: params.cardId,
+    userId,
+    rating: params.rating,
+    tokenUpdates
+  });
+  return {
+    success: true,
+    action,
+    token: {
+      slug: result.token.slug,
+      tokenId: result.token.id
+    },
+    rating: params.rating ?? null,
+    evaluation: result.evaluation ?? null,
+    blocked: result.blocked ?? null,
+    updatedToken: result.updatedToken ?? null,
+    deletedToken: result.deletedToken ?? null,
+    deletedCard: result.deletedCard ?? null,
+    skipped: result.skipped ?? false,
+    stopped: result.stopped ?? false
+  };
+}
+async function addToken(db, params) {
+  const userId = await resolveHandlerUser(db, params.user);
+  if (!params.slug.trim() || !params.concept.trim()) {
+    throw new Error("slug and concept must be non-empty");
+  }
+  if (params.bloomLevel !== void 0 && (!Number.isInteger(params.bloomLevel) || params.bloomLevel < 1 || params.bloomLevel > 5)) {
+    throw new Error("bloomLevel must be an integer between 1 and 5");
+  }
+  const possibleDuplicates = await findPossibleDuplicates(db, {
+    concept: params.concept,
+    question: params.question ?? null,
+    domain: params.domain,
+    title: params.title ?? null
+  });
+  const ctxNames = parseKnowledgeContextNames(
+    params.knowledgeContexts ?? params.knowledge_contexts
+  );
+  const assignedContexts = await resolveKnowledgeContexts(db, ctxNames);
+  const prerequisiteSlugs = [
+    ...new Set(
+      (params.prerequisites ?? []).map((slug) => slug.trim()).filter(Boolean)
+    )
+  ];
+  const prerequisites = [];
+  for (const slug of prerequisiteSlugs) {
+    const prerequisite = await getTokenBySlug(db, slug);
+    if (!prerequisite) {
+      throw new Error(`Prerequisite token not found: ${slug}`);
+    }
+    prerequisites.push(prerequisite);
+  }
+  const token = await createToken(db, {
+    slug: params.slug,
+    title: params.title,
+    concept: params.concept,
+    domain: params.domain,
+    bloom_level: params.bloomLevel ?? 1,
+    context: params.context,
+    symbiosis_mode: params.symbiosisMode,
+    source_link: params.sourceLink ?? null,
+    question: params.question ?? null
+  });
+  for (const context of assignedContexts) {
+    await assignTokenToContext(db, token.id, context.id);
+  }
+  for (const prerequisite of prerequisites) {
+    await addPrerequisite(db, token.id, prerequisite.id);
+  }
+  const card = await ensureCard(db, token.id, userId);
+  try {
+    await ensureTokenEmbeddings(db, { limit: 8 });
+  } catch {
+  }
+  return {
+    success: true,
+    token: {
+      ...token,
+      knowledgeContexts: assignedContexts.map((c) => ({
+        name: c.name,
+        label: c.label,
+        language: c.language
+      })),
+      prerequisites: prerequisites.map((prerequisite) => prerequisite.slug)
+    },
+    card: {
+      id: card.id,
+      tokenId: card.token_id,
+      userId: card.user_id,
+      state: card.state,
+      dueAt: card.due_at,
+      blocked: card.blocked
+    },
+    possible_duplicates: possibleDuplicates
+  };
+}
+async function findTokens2(db, params) {
+  const userId = await resolveHandlerUser(db, params.user);
+  if (!params.context.trim()) {
+    throw new Error("context must be non-empty");
+  }
+  const truncatedContext = params.context.slice(0, 2e3);
+  const q2 = await embedQuery(db, truncatedContext);
+  try {
+    await ensureTokenEmbeddings(db, {
+      limit: 32,
+      dims: q2?.vector.length
+    });
+  } catch {
+  }
+  let limit = params.limit ?? 10;
+  if (typeof limit !== "number" || limit <= 0 || !Number.isInteger(limit)) {
+    limit = 10;
+  }
+  if (limit > 100) {
+    limit = 100;
+  }
+  const results = await searchTokensHybrid(db, truncatedContext, {
+    queryEmbedding: q2?.vector,
+    model: q2?.model,
+    limit
+  });
+  const tokens = [];
+  const contextMap = /* @__PURE__ */ new Map();
+  if (results.length > 0) {
+    const ids = results.map((t2) => t2.id);
+    const placeholders = ids.map(() => "?").join(",");
+    const mappings = await db.prepare(
+      `SELECT tc.token_id, c.name, c.label, c.language
+         FROM token_contexts tc
+         INNER JOIN contexts c ON c.id = tc.context_id
+         WHERE tc.token_id IN (${placeholders})`
+    ).all(...ids);
+    for (const m of mappings) {
+      const list = contextMap.get(m.token_id) ?? [];
+      list.push({ name: m.name, label: m.label, language: m.language });
+      contextMap.set(m.token_id, list);
+    }
+  }
+  for (const t2 of results) {
+    const card = await getCard(db, t2.id, userId);
+    tokens.push({
+      slug: t2.slug,
+      title: t2.title,
+      display_title: getDisplayTitle(t2),
+      concept: t2.concept,
+      domain: t2.domain,
+      bloom_level: t2.bloom_level,
+      score: t2.score,
+      similarity: t2.similarity,
+      knowledgeContexts: contextMap.get(t2.id) ?? [],
+      card: card ? {
+        state: card.state,
+        due_at: card.due_at,
+        blocked: card.blocked
+      } : null
+    });
+  }
+  return {
+    semantic: q2 !== null,
+    tokens
+  };
+}
+async function suggestFoundations2(db, params) {
+  let queryText = "";
+  let targetTokenId;
+  let targetBloomLevel;
+  let targetJson = null;
+  if (params.slug !== void 0) {
+    if (typeof params.slug !== "string" || params.slug.trim() === "") {
+      throw new Error("Invalid slug");
+    }
+    const token = await getTokenBySlug(db, params.slug);
+    if (!token) {
+      throw new Error(`Token not found: ${params.slug}`);
+    }
+    const { embeddingContentForToken: getContent } = await Promise.resolve().then(() => (init_kernel(), kernel_exports));
+    queryText = getContent(token);
+    targetTokenId = token.id;
+    targetBloomLevel = token.bloom_level;
+    targetJson = { slug: token.slug };
+  } else {
+    if (!params.concept || typeof params.concept !== "string" || params.concept.trim() === "") {
+      throw new Error(
+        "JSON must include a non-empty 'slug' or 'concept' field"
+      );
+    }
+    const { embeddingContentForToken: getContent } = await Promise.resolve().then(() => (init_kernel(), kernel_exports));
+    queryText = getContent({
+      concept: params.concept,
+      question: typeof params.question === "string" ? params.question : null,
+      domain: typeof params.domain === "string" ? params.domain : "",
+      title: typeof params.title === "string" ? params.title : null
+    });
+    if (params.bloom_level !== void 0) {
+      if (typeof params.bloom_level !== "number" || !Number.isInteger(params.bloom_level) || params.bloom_level < 1 || params.bloom_level > 5) {
+        throw new Error("bloom_level must be an integer between 1 and 5");
+      }
+      targetBloomLevel = params.bloom_level;
+    }
+  }
+  let limit = params.limit ?? 5;
+  if (typeof limit !== "number" || limit <= 0 || !Number.isInteger(limit)) {
+    limit = 5;
+  }
+  if (limit > 20) {
+    limit = 20;
+  }
+  const q2 = await embedQuery(db, queryText);
+  if (q2 === null) {
+    return {
+      semantic: false,
+      target: targetJson,
+      suggestions: []
+    };
+  }
+  try {
+    await ensureTokenEmbeddings(db, {
+      limit: 100,
+      dims: q2.vector.length
+    });
+  } catch {
+  }
+  const maxSimilarity = await resolveDedupThreshold(db);
+  const minSimilarity = await resolveSuggestMinSimilarity(db);
+  if (minSimilarity >= maxSimilarity) {
+    return {
+      semantic: true,
+      target: targetJson,
+      suggestions: []
+    };
+  }
+  const suggestions = await suggestFoundations(db, {
+    queryEmbedding: q2.vector,
+    model: q2.model,
+    targetTokenId,
+    targetBloomLevel,
+    limit,
+    minSimilarity,
+    maxSimilarity
+  });
+  return {
+    semantic: true,
+    target: targetJson,
+    suggestions: suggestions.map((s) => ({
+      slug: s.token.slug,
+      concept: s.token.concept,
+      domain: s.token.domain,
+      bloom_level: s.token.bloom_level,
+      similarity: s.similarity,
+      already_prerequisite: s.alreadyPrerequisite,
+      would_create_cycle: s.wouldCreateCycle,
+      bloom_above_target: s.bloomAboveTarget
+    }))
+  };
+}
+async function linkPrereq(db, params) {
+  if (!params.token.trim() || !params.requires.trim()) {
+    throw new Error("token and requires must be non-empty slugs");
+  }
+  const token = await getTokenBySlug(db, params.token);
+  if (!token) {
+    throw new Error(`Token not found: ${params.token}`);
+  }
+  const requires = await getTokenBySlug(db, params.requires);
+  if (!requires) {
+    throw new Error(`Prerequisite token not found: ${params.requires}`);
+  }
+  await addPrerequisite(db, token.id, requires.id);
+  let blockedCardId;
+  if (params.blockUser) {
+    const card = await getCard(db, token.id, params.blockUser);
+    if (card) {
+      await updateCard(db, card.id, { blocked: 1 });
+      blockedCardId = card.id;
+    }
+  }
+  return {
+    success: true,
+    token: params.token,
+    requires: params.requires,
+    ...blockedCardId ? { blockedCardId } : {}
+  };
+}
+async function startSession2(db, params) {
+  if (!params.task.trim()) {
+    throw new Error("task must be non-empty");
+  }
+  const context = params.context ?? "shell";
+  if (!["shell", "ui", "reallife"].includes(context)) {
+    throw new Error("context must be shell, ui, or reallife");
+  }
+  const userId = await resolveHandlerUser(db, params.user);
+  const session = await startSession(db, {
+    user_id: userId,
+    task: params.task,
+    execution_context: context
+  });
+  const observerPolicyHint = context === "ui" && !await isObserverPolicyConfigured(db) ? OBSERVER_POLICY_UNSET_HINT : void 0;
+  return {
+    id: session.id,
+    userId: session.user_id,
+    task: session.task,
+    executionContext: session.execution_context,
+    startedAt: session.started_at,
+    completedAt: session.completed_at,
+    ...observerPolicyHint ? { observerPolicyHint } : {}
+  };
+}
+async function endSession2(db, params) {
+  const synthesisPreview = params.synthesize ? await prepareSessionSynthesis(db, {
+    sessionId: params.session,
+    explicitPatterns: params.patterns,
+    minConfidence: params.minConfidence ?? "medium"
+  }) : void 0;
+  const synthesis = synthesisPreview ? {
+    ...synthesisPreview,
+    candidates: await Promise.all(
+      synthesisPreview.candidates.map(async (candidate) => ({
+        ...candidate,
+        cardId: (await getCard(db, candidate.tokenId, synthesisPreview.userId))?.id ?? null
+      }))
+    )
+  } : void 0;
+  const session = await endSession(db, params.session);
+  const summary = await getSessionSummary(db, params.session);
+  return {
+    id: session.id,
+    userId: session.user_id,
+    task: session.task,
+    executionContext: session.execution_context,
+    startedAt: session.started_at,
+    completedAt: session.completed_at,
+    summary,
+    ...synthesis ? { synthesis } : {}
+  };
+}
+async function getMonitor(_db, params) {
+  if (!monitorLogExists(params.session)) {
+    return {
+      sessionId: params.session,
+      exists: false,
+      commands: [],
+      timeSpan: null
+    };
+  }
+  const events = readMonitorLog(params.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()
+    };
+  }
+  return {
+    sessionId: params.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
+  };
+}
+async function analyzeMonitor(_db, params) {
+  if (!monitorLogExists(params.session)) {
+    return {
+      sessionId: params.session,
+      ratings: [],
+      unmatchedCommands: [],
+      timeSpan: null
+    };
+  }
+  const events = readMonitorLog(params.session);
+  const commands = pairCommands(events);
+  const result = analyzeObservation(commands, params.patterns);
+  return {
+    sessionId: params.session,
+    ...result
+  };
+}
+
+// src/cli/commands/mcp.ts
+var __dirname = dirname5(fileURLToPath2(import.meta.url));
+var pkgPath = join11(__dirname, "..", "..", "package.json");
+if (!existsSync12(pkgPath)) {
+  pkgPath = join11(__dirname, "..", "..", "..", "package.json");
+}
+var pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
+function createMcpServer(db) {
+  const server = new McpServer({
+    name: "zam",
+    version: pkg.version
+  });
+  async function getUserId(paramUser) {
+    if (paramUser) return paramUser;
+    const stored = await getSetting(db, "user.id");
+    if (stored) return stored;
+    throw new Error(
+      "No user specified. Set a default with: zam whoami --set <id>"
+    );
+  }
+  const commonAnnotations = {
+    openWorldHint: false
+  };
+  const externalAnnotations = {
+    openWorldHint: true
+  };
+  function wrapHandler(fn) {
+    return async (params) => {
+      try {
+        const result = await fn(params);
+        const structuredContent = typeof result === "object" && result !== null && !Array.isArray(result) ? result : { result };
+        return {
+          structuredContent,
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        const errMsg = error instanceof Error ? error.message : String(error);
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ error: errMsg }, null, 2)
+            }
+          ]
+        };
+      }
+    };
+  }
+  server.registerTool(
+    "zam_status",
+    {
+      description: "Check due cards and review stats",
+      inputSchema: {
+        user: z.string().optional().describe("User ID to query cards for"),
+        domain: z.string().optional().describe("Filter by domain prefix"),
+        knowledgeContext: z.string().optional().describe("Filter by knowledge context")
+      },
+      annotations: {
+        ...commonAnnotations,
+        readOnlyHint: true
+      }
+    },
+    wrapHandler(async (params) => {
+      const userId = await getUserId(params.user);
+      return await checkDue(db, {
+        user: userId,
+        domain: params.domain,
+        knowledgeContext: params.knowledgeContext
+      });
+    })
+  );
+  server.registerTool(
+    "zam_session_start",
+    {
+      description: "Start a learning/work session",
+      inputSchema: {
+        user: z.string().optional().describe("User ID starting the session"),
+        task: z.string().describe("Task description for the session"),
+        context: z.enum(["shell", "ui", "reallife"]).optional().describe("Execution context")
+      },
+      annotations: {
+        ...commonAnnotations,
+        destructiveHint: false
+      }
+    },
+    wrapHandler(async (params) => {
+      const userId = await getUserId(params.user);
+      return await startSession2(db, {
+        user: userId,
+        task: params.task,
+        context: params.context
+      });
+    })
+  );
+  server.registerTool(
+    "zam_session_end",
+    {
+      description: "End a learning/work session",
+      inputSchema: {
+        session: z.string().describe("Session ULID to end"),
+        synthesize: z.boolean().optional().describe("Return monitor-based rating candidates before ending"),
+        patterns: z.array(
+          z.object({
+            slug: z.string(),
+            patterns: z.array(z.string())
+          })
+        ).optional().describe("Additional token command patterns for synthesis"),
+        minConfidence: z.enum(["medium", "high"]).optional().describe("Minimum confidence for synthesis candidates")
+      },
+      annotations: {
+        ...commonAnnotations,
+        destructiveHint: false
+      }
+    },
+    wrapHandler(async (params) => {
+      return await endSession2(db, {
+        session: params.session,
+        synthesize: params.synthesize,
+        patterns: params.patterns,
+        minConfidence: params.minConfidence
+      });
+    })
+  );
+  server.registerTool(
+    "zam_get_reviews",
+    {
+      description: "Fetch a batch of review cards",
+      inputSchema: {
+        user: z.string().optional().describe("User ID to review for"),
+        domain: z.string().optional().describe("Filter by domain prefix"),
+        knowledgeContext: z.string().optional().describe("Filter by knowledge context"),
+        includeQuestions: z.boolean().optional().describe("Include question contents in response"),
+        noResolve: z.boolean().optional().describe("Do not auto-generate missing questions"),
+        noDynamicQuestion: z.literal(true).optional().describe("Keep review retrieval read-only (always true over MCP)")
+      },
+      annotations: {
+        ...externalAnnotations,
+        readOnlyHint: true
+      }
+    },
+    wrapHandler(async (params) => {
+      const userId = await getUserId(params.user);
+      return await getReviewsBatch(db, {
+        user: userId,
+        domain: params.domain,
+        knowledgeContext: params.knowledgeContext,
+        includeQuestions: params.includeQuestions,
+        noResolve: params.noResolve,
+        noDynamicQuestion: true
+      });
+    })
+  );
+  server.registerTool(
+    "zam_submit_review",
+    {
+      description: "Submit a user rating or log an unrated agent step",
+      inputSchema: {
+        user: z.string().optional().describe("User ID submitting the review"),
+        cardId: z.string().optional().describe("Card ULID; required for agent steps"),
+        tokenId: z.string().optional().describe("Token ULID for a confirmed synthesis without a card yet"),
+        rating: z.coerce.number().int().min(1).max(4).optional().describe(
+          "User FSRS rating (1=Again, 2=Hard, 3=Good, 4=Easy); omit when doneBy is agent"
+        ),
+        sessionId: z.string().optional().describe("Optional active session ULID to log step"),
+        doneBy: z.enum(["user", "agent"]).optional().describe("Who performed the review step")
+      },
+      annotations: {
+        ...commonAnnotations,
+        destructiveHint: false,
+        idempotentHint: false
+      }
+    },
+    wrapHandler(async (params) => {
+      const userId = await getUserId(params.user);
+      return await submitReview(db, {
+        user: userId,
+        cardId: params.cardId,
+        tokenId: params.tokenId,
+        rating: params.rating,
+        sessionId: params.sessionId,
+        doneBy: params.doneBy
+      });
+    })
+  );
+  server.registerTool(
+    "zam_review_action",
+    {
+      description: "Perform a review action (e.g. rate, edit, delete)",
+      inputSchema: {
+        user: z.string().optional().describe("User ID performing the action"),
+        cardId: z.string().describe("Card ULID target"),
+        action: z.enum([
+          "rate",
+          "skip",
+          "edit-token",
+          "deprecate-token",
+          "delete-token",
+          "delete-card",
+          "stop"
+        ]).describe("The action type"),
+        rating: z.coerce.number().int().min(1).max(4).optional().describe(
+          "Rating (1=Again, 2=Hard, 3=Good, 4=Easy; required for rate)"
+        ),
+        concept: z.string().optional().describe("Updated concept text (for edit-token)"),
+        domain: z.string().optional().describe("Updated domain (for edit-token)"),
+        bloomLevel: z.number().int().min(1).max(5).optional().describe("Updated Bloom level (for edit-token)"),
+        context: z.string().optional().describe("Updated context text (for edit-token)"),
+        symbiosisMode: z.string().optional().describe("Updated symbiosis mode (for edit-token)"),
+        sourceLink: z.string().optional().describe("Updated source link (for edit-token)"),
+        confirm: z.boolean().optional().describe("Confirm deletion (required for delete action)")
+      },
+      annotations: {
+        ...commonAnnotations,
+        destructiveHint: true
+      }
+    },
+    wrapHandler(async (params) => {
+      const userId = await getUserId(params.user);
+      return await reviewAction(db, {
+        user: userId,
+        cardId: params.cardId,
+        action: params.action,
+        rating: params.rating,
+        concept: params.concept,
+        domain: params.domain,
+        bloomLevel: params.bloomLevel,
+        context: params.context,
+        symbiosisMode: params.symbiosisMode,
+        sourceLink: params.sourceLink,
+        confirm: params.confirm
+      });
+    })
+  );
+  server.registerTool(
+    "zam_add_token",
+    {
+      description: "Add a new knowledge token",
+      inputSchema: {
+        user: z.string().optional().describe("User ID to auto-create card for"),
+        slug: z.string().describe("Unique slug for the token"),
+        concept: z.string().describe("Detailed description of the concept"),
+        title: z.string().optional().describe("Optional display title"),
+        domain: z.string().optional().describe("Domain path"),
+        bloomLevel: z.number().int().min(1).max(5).optional().describe("Bloom taxonomy level (1-5)"),
+        context: z.string().optional().describe("Markdown content block/context"),
+        symbiosisMode: z.enum(["shadowing", "copilot", "autonomy"]).nullable().optional().describe("Symbiosis mode override"),
+        sourceLink: z.string().nullable().optional().describe("Optional URL/file path source"),
+        question: z.string().nullable().optional().describe("Pre-defined review question"),
+        knowledgeContexts: z.array(z.string()).optional().describe("List of contexts to assign the token to"),
+        prerequisites: z.array(z.string()).optional().describe("Existing token slugs required by the new token")
+      },
+      annotations: {
+        ...externalAnnotations,
+        destructiveHint: false
+      }
+    },
+    wrapHandler(async (params) => {
+      const userId = await getUserId(params.user);
+      return await addToken(db, {
+        user: userId,
+        slug: params.slug,
+        concept: params.concept,
+        title: params.title,
+        domain: params.domain,
+        bloomLevel: params.bloomLevel,
+        context: params.context,
+        symbiosisMode: params.symbiosisMode,
+        sourceLink: params.sourceLink,
+        question: params.question,
+        knowledgeContexts: params.knowledgeContexts,
+        prerequisites: params.prerequisites
+      });
+    })
+  );
+  server.registerTool(
+    "zam_find_tokens",
+    {
+      description: "Search/find matching tokens using semantic search",
+      inputSchema: {
+        user: z.string().optional().describe("User ID"),
+        context: z.string().describe("Query context to embed and match"),
+        limit: z.number().int().positive().optional().describe("Max number of matches to return")
+      },
+      annotations: {
+        ...externalAnnotations,
+        readOnlyHint: true
+      }
+    },
+    wrapHandler(async (params) => {
+      const userId = await getUserId(params.user);
+      return await findTokens2(db, {
+        user: userId,
+        context: params.context,
+        limit: params.limit
+      });
+    })
+  );
+  server.registerTool(
+    "zam_suggest_foundations",
+    {
+      description: "Suggest foundational concept prerequisites",
+      inputSchema: {
+        user: z.string().optional().describe("User ID"),
+        slug: z.string().optional().describe("Target token slug to find prereqs for"),
+        concept: z.string().optional().describe("Or concept text description for pre-registration"),
+        question: z.string().optional().describe("Optional question content for pre-registration"),
+        domain: z.string().optional().describe("Domain filter"),
+        title: z.string().optional().describe("Optional title"),
+        bloom_level: z.number().int().min(1).max(5).optional().describe("Bloom level of target"),
+        limit: z.number().int().positive().optional().describe("Max number of suggestions")
+      },
+      annotations: {
+        ...externalAnnotations,
+        readOnlyHint: true
+      }
+    },
+    wrapHandler(async (params) => {
+      return await suggestFoundations2(db, {
+        user: params.user,
+        slug: params.slug,
+        concept: params.concept,
+        question: params.question,
+        domain: params.domain,
+        title: params.title,
+        bloom_level: params.bloom_level,
+        limit: params.limit
+      });
+    })
+  );
+  server.registerTool(
+    "zam_link_prereq",
+    {
+      description: "Link a prerequisite dependency between two tokens",
+      inputSchema: {
+        token: z.string().describe("Slug of dependent token"),
+        requires: z.string().describe("Slug of required prerequisite token"),
+        blockUser: z.string().optional().describe("Block card for this user until prereq is learned")
+      },
+      annotations: {
+        ...commonAnnotations,
+        destructiveHint: false
+      }
+    },
+    wrapHandler(async (params) => {
+      return await linkPrereq(db, {
+        token: params.token,
+        requires: params.requires,
+        blockUser: params.blockUser
+      });
+    })
+  );
+  server.registerTool(
+    "zam_monitor",
+    {
+      description: "Get or analyze session monitor commands",
+      inputSchema: {
+        session: z.string().describe("Session ULID to monitor"),
+        patterns: z.array(
+          z.object({
+            slug: z.string(),
+            patterns: z.array(z.string())
+          })
+        ).optional().describe("Patterns to match against monitor events for evaluation")
+      },
+      annotations: {
+        ...commonAnnotations,
+        readOnlyHint: true
+      }
+    },
+    wrapHandler(async (params) => {
+      if (params.patterns) {
+        return await analyzeMonitor(db, {
+          session: params.session,
+          patterns: params.patterns
+        });
+      }
+      return await getMonitor(db, {
+        session: params.session
+      });
+    })
+  );
+  return server;
+}
+async function runMcpServer() {
+  console.log = console.error;
+  const db = await openDatabase();
+  const server = createMcpServer(db);
+  let dbClosed = false;
+  async function cleanup() {
+    if (dbClosed) return;
+    dbClosed = true;
+    try {
+      await server.close();
+    } catch {
+    }
+    try {
+      await db.close();
+    } catch {
+    }
+    process.exit(0);
+  }
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  const transport = new StdioServerTransport();
+  transport.onclose = () => {
+    cleanup();
+  };
+  await server.connect(transport);
+}
 export {
-  getUserStats,
-  getDomainCompetence,
-  loadCredentials,
-  saveCredentials,
-  getTursoCredentials,
-  setTursoCredentials,
-  clearTursoCredentials,
-  getADOCredentials,
-  setADOCredentials,
-  clearADOCredentials,
-  getProviderApiKey,
-  setProviderApiKey,
-  clearProviderApiKey,
-  listProviderApiKeyRefs,
-  loadADOConfig,
-  fetchActiveWorkItems,
-  openRemoteDatabase,
-  getDatabaseTargetInfo,
-  openDatabase,
-  openDatabaseWithSync,
-  getDefaultDbPath,
-  SNAPSHOT_VERSION,
-  exportSnapshot,
-  parseSnapshot,
-  verifySnapshot,
-  importSnapshot,
-  parseGoalFile,
-  serializeGoal,
-  extractTasks,
-  extractTokenRefs,
-  listGoals,
-  getGoal,
-  createGoal,
-  updateGoalStatus,
-  getGoalTree,
-  createAgentSkill,
-  getAgentSkill,
-  listAgentSkills,
-  ensureCard,
-  getCard,
-  getCardById,
-  updateCard,
-  getCardDeletionImpact,
-  deleteCardForUser,
-  getDueCards,
-  getBlockedCards,
-  createKnowledgeContext,
-  getKnowledgeContextByName,
-  getKnowledgeContextById,
-  listKnowledgeContexts,
-  updateKnowledgeContext,
-  deleteKnowledgeContext,
-  assignTokenToContext,
-  unassignTokenFromContext,
-  listContextsForToken,
-  createToken,
-  getTokenBySlug,
-  getTokenById,
-  updateToken,
-  deprecateToken,
-  getTokenDeleteImpact,
-  deleteToken,
-  findTokens,
-  listTokens,
-  slugify,
-  getShortSlug,
-  getDisplayTitle,
-  generateTokenSlug,
-  listPersonalCards,
-  importCurriculumCards,
-  confirmCardSplit,
-  confirmFoundations,
-  confirmSourceImport,
-  buildAncestorMap,
-  wouldCreateCycle,
-  addPrerequisite,
-  getPrerequisites,
-  getDependents,
-  getTokenNeighborhood,
-  logReview,
-  getReviewsForCard,
-  getReviewsForUser,
-  startSession,
-  endSession,
-  logStep,
-  getSessionSummary,
-  getSetting,
-  getAllSettings,
-  getAllSettingsDetailed,
-  setSetting,
-  deleteSetting,
-  embeddingContentForToken,
-  computeContentHash,
-  encodeEmbedding,
-  decodeEmbedding,
-  upsertTokenEmbedding,
-  getTokenEmbedding,
-  listTokensNeedingEmbedding,
-  getEmbeddingCoverage,
-  listEmbeddedTokens,
-  parseMonitorLog,
-  pairCommands,
-  analyzeObservation,
-  getMonitorDir,
-  getMonitorPath,
-  ensureMonitorDir,
-  writeMonitorEvent,
-  readMonitorLog,
-  monitorLogExists,
-  getMonitorLogStats,
-  OBSERVER_POLICY_VERSION,
-  DEFAULT_OBSERVER_POLICY,
-  BUILT_IN_SENSITIVE_MATCHERS,
-  parseObserverList,
-  parseObserverPolicy,
-  resolveObserverPolicy,
-  matchBuiltInSensitive,
-  matchDenylist,
-  decidePreCapture,
-  decidePostCapture,
-  isObserverPolicyConfigured,
-  OBSERVER_POLICY_UNSET_HINT,
-  UI_OBSERVATION_PROTOCOL_VERSION,
-  isUiObservationReport,
-  parseUiObservationLog,
-  getUiObserverDir,
-  getUiObservationPath,
-  ensureUiObserverDir,
-  uiObservationLogExists,
-  readUiObservationLog,
-  appendUiObservationReport,
-  SIDECAR_POLICY_FILE,
-  toSidecarPrivacyPolicy,
-  syncObserverSidecarPolicy,
-  createFSRS,
-  evaluateRating,
-  cascadeBlock,
-  unblockReady,
-  buildUiSynthesisCandidates,
-  uiObservationTimeSpan,
-  getSessionSynthesisRecords,
-  prepareSessionSynthesis,
-  applySessionSynthesis,
-  generateZshHooks,
-  generateBashHooks,
-  generatePowerShellHooks,
-  generateZshUnhooks,
-  generateBashUnhooks,
-  generatePowerShellUnhooks,
-  discoverSkills,
-  executeReviewAction,
-  generateConceptFreeCue,
-  generatePrompt,
-  DEFAULT_REVIEW_CONTEXT_MAX_CHARS,
-  REVIEW_CONTEXT_CACHE_TTL_MS,
-  clearReviewContextCache,
-  resolveReference,
-  resolveReviewContext,
-  normalizePath,
-  matchesFilePath,
-  interleave,
-  buildReviewQueue,
-  cosineSimilarity,
-  searchTokensHybrid,
-  suggestFoundations,
-  getPackageSkillPath,
-  distributeGlobalSkills,
-  injectShellHooks,
-  t,
-  loadInstallConfig,
-  saveInstallConfig,
-  getInstallMode,
-  setInstallMode,
-  getInstallChannel,
-  setInstallChannel,
-  getMachineAiConfig,
-  saveMachineAiConfig,
-  getConfiguredWorkspaces,
-  saveConfiguredWorkspaces,
-  getActiveWorkspaceId,
-  setActiveWorkspaceId,
-  getActiveWorkspace,
-  upsertConfiguredWorkspace,
-  removeConfiguredWorkspace,
-  detectSyncProvider,
-  getActiveWorkspaceContext,
-  setActiveWorkspaceContext,
-  hasCommand,
-  installFastFlowLM,
-  installOllama,
-  resolveOllamaCommand,
-  isOllamaInstalled,
-  prepareLocalModel,
-  planOpenCodeInstall,
-  installOpenCode,
-  normalizeLocale,
-  detectSystemLocale,
-  getSystemProfile,
-  getRepoPaths,
-  resolveRepoPath,
-  resolveAllBeliefPaths,
-  resolveAllGoalPaths,
-  WINGET_PACKAGE_ID,
-  HOMEBREW_CASK,
-  compareVersions,
-  decideUpdate,
-  planUpdate
+  createMcpServer,
+  runMcpServer
 };
-//# sourceMappingURL=chunk-BOWP6D5I.js.map
+//# sourceMappingURL=mcp.js.map