zam-core 0.7.2 → 0.8.0

package/dist/cli/index.js

@@ -4,7 +4,7 @@
 import { readFileSync as readFileSync16 } from "fs";
 import { dirname as dirname10, join as join25 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { Command as Command26 } from "commander";
+import { Command as Command27 } from "commander";
 
 // src/cli/commands/agent.ts
 import { existsSync as existsSync13 } from "fs";
@@ -682,6 +682,22 @@ CREATE TABLE IF NOT EXISTS agent_skills (
   updated_at  TEXT NOT NULL DEFAULT (datetime('now'))
 );
 
+-- Knowledge contexts: work, school, private
+CREATE TABLE IF NOT EXISTS contexts (
+  id         TEXT PRIMARY KEY,
+  name       TEXT NOT NULL UNIQUE,
+  label      TEXT,
+  language   TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+-- Join table mapping tokens to their knowledge contexts
+CREATE TABLE IF NOT EXISTS token_contexts (
+  token_id   TEXT NOT NULL REFERENCES tokens(id) ON DELETE CASCADE,
+  context_id TEXT NOT NULL REFERENCES contexts(id) ON DELETE CASCADE,
+  PRIMARY KEY (token_id, context_id)
+);
+
 -- Performance indexes
 CREATE INDEX IF NOT EXISTS idx_tokens_domain ON tokens(domain);
 CREATE INDEX IF NOT EXISTS idx_tokens_slug ON tokens(slug);
@@ -693,7 +709,7 @@ CREATE INDEX IF NOT EXISTS idx_review_logs_card ON review_logs(card_id);
 CREATE INDEX IF NOT EXISTS idx_review_logs_user ON review_logs(user_id, reviewed_at);
 CREATE INDEX IF NOT EXISTS idx_session_steps_session ON session_steps(session_id);
 CREATE INDEX IF NOT EXISTS idx_tokens_title ON tokens(title);
-CREATE INDEX IF NOT EXISTS idx_tokens_domain ON tokens(domain);
+CREATE INDEX IF NOT EXISTS idx_token_contexts_context ON token_contexts(context_id);
 `;
 
 // src/kernel/db/sync-adapter.ts
@@ -1036,6 +1052,25 @@ async function runMigrations(db) {
   await db.exec(
     `CREATE INDEX IF NOT EXISTS idx_tokens_domain ON tokens(domain)`
   );
+  await db.exec(`
+    CREATE TABLE IF NOT EXISTS contexts (
+      id         TEXT PRIMARY KEY,
+      name       TEXT NOT NULL UNIQUE,
+      label      TEXT,
+      language   TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  await db.exec(`
+    CREATE TABLE IF NOT EXISTS token_contexts (
+      token_id   TEXT NOT NULL REFERENCES tokens(id) ON DELETE CASCADE,
+      context_id TEXT NOT NULL REFERENCES contexts(id) ON DELETE CASCADE,
+      PRIMARY KEY (token_id, context_id)
+    )
+  `);
+  await db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_token_contexts_context ON token_contexts(context_id)
+  `);
 }
 
 // src/kernel/db/snapshot.ts
@@ -1499,31 +1534,98 @@ async function deleteCardForUser(db, tokenId, userId) {
   await db.prepare("DELETE FROM cards WHERE id = ?").run(card.id);
   return { card, impact };
 }
-async function getDueCards(db, userId, now, domain) {
+async function getDueCards(db, userId, now, domain, knowledgeContext) {
   const cutoff = now ?? (/* @__PURE__ */ new Date()).toISOString();
+  let sql = `SELECT c.*, t.slug, t.concept, t.domain, t.bloom_level
+    FROM cards c
+    JOIN tokens t ON t.id = c.token_id
+    WHERE c.user_id = ? AND c.blocked = 0 AND c.due_at <= ?`;
+  const params = [userId, cutoff];
   if (domain) {
-    return await db.prepare(
-      `SELECT c.*, t.slug, t.concept, t.domain, t.bloom_level
-         FROM cards c
-         JOIN tokens t ON t.id = c.token_id
-         WHERE c.user_id = ? AND c.blocked = 0 AND c.due_at <= ? AND t.domain = ?
-         ORDER BY t.bloom_level ASC, c.due_at ASC`
-    ).all(userId, cutoff, domain);
+    sql += " AND t.domain = ?";
+    params.push(domain);
   }
-  return await db.prepare(
-    `SELECT c.*, t.slug, t.concept, t.domain, t.bloom_level
-       FROM cards c
-       JOIN tokens t ON t.id = c.token_id
-       WHERE c.user_id = ? AND c.blocked = 0 AND c.due_at <= ?
-       ORDER BY t.bloom_level ASC, c.due_at ASC`
-  ).all(userId, cutoff);
+  if (knowledgeContext) {
+    sql += ` AND EXISTS (
+      SELECT 1 FROM token_contexts tc
+      INNER JOIN contexts context_filter ON context_filter.id = tc.context_id
+      WHERE tc.token_id = t.id AND context_filter.name = ?
+    )`;
+    params.push(knowledgeContext);
+  }
+  sql += " ORDER BY t.bloom_level ASC, c.due_at ASC";
+  return await db.prepare(sql).all(...params);
 }
 
-// src/kernel/models/token.ts
+// src/kernel/models/knowledge-context.ts
 import { ulid as ulid3 } from "ulid";
-async function createToken(db, input8) {
+function normalizeContextName(name) {
+  const normalized = name.trim();
+  if (!normalized) {
+    throw new Error("Context name cannot be empty");
+  }
+  return normalized;
+}
+function normalizeOptionalText(value) {
+  if (value == null) return null;
+  const normalized = value.trim();
+  return normalized || null;
+}
+async function createKnowledgeContext(db, input8) {
   const id = ulid3();
   const now = (/* @__PURE__ */ new Date()).toISOString();
+  const name = normalizeContextName(input8.name);
+  const existing = await getKnowledgeContextByName(db, name);
+  if (existing) {
+    throw new Error(`Knowledge context with name "${name}" already exists`);
+  }
+  await db.prepare(
+    `INSERT INTO contexts (id, name, label, language, created_at)
+       VALUES (?, ?, ?, ?, ?)`
+  ).run(
+    id,
+    name,
+    normalizeOptionalText(input8.label),
+    normalizeOptionalText(input8.language),
+    now
+  );
+  const context = await getKnowledgeContextById(db, id);
+  if (!context) {
+    throw new Error(
+      `Failed to retrieve newly created knowledge context: ${id}`
+    );
+  }
+  return context;
+}
+async function getKnowledgeContextByName(db, name) {
+  const normalized = name.trim();
+  if (!normalized) return void 0;
+  return await db.prepare("SELECT * FROM contexts WHERE name = ?").get(normalized);
+}
+async function getKnowledgeContextById(db, id) {
+  return await db.prepare("SELECT * FROM contexts WHERE id = ?").get(id);
+}
+async function listKnowledgeContexts(db) {
+  return await db.prepare("SELECT * FROM contexts ORDER BY name ASC").all();
+}
+async function deleteKnowledgeContext(db, id) {
+  await db.prepare("DELETE FROM contexts WHERE id = ?").run(id);
+}
+async function assignTokenToContext(db, tokenId, contextId) {
+  await db.prepare(
+    `INSERT OR IGNORE INTO token_contexts (token_id, context_id)
+       VALUES (?, ?)`
+  ).run(tokenId, contextId);
+}
+async function unassignTokenFromContext(db, tokenId, contextId) {
+  await db.prepare("DELETE FROM token_contexts WHERE token_id = ? AND context_id = ?").run(tokenId, contextId);
+}
+
+// src/kernel/models/token.ts
+import { ulid as ulid4 } from "ulid";
+async function createToken(db, input8) {
+  const id = ulid4();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
   const bloom = input8.bloom_level ?? 1;
   if (bloom < 1 || bloom > 5) {
     throw new Error(`bloom_level must be between 1 and 5, got ${bloom}`);
@@ -1759,21 +1861,27 @@ async function findTokens(db, query) {
   return scored;
 }
 async function listTokens(db, options) {
-  let tokens;
+  const whereClauses = ["deprecated_at IS NULL"];
+  const params = [];
   if (options?.domain) {
-    tokens = await db.prepare(
-      "SELECT * FROM tokens WHERE domain = ? AND deprecated_at IS NULL ORDER BY bloom_level, slug"
-    ).all(options.domain);
+    whereClauses.push("domain = ?");
+    params.push(options.domain);
   } else if (options?.domainPrefix) {
     const prefix = options.domainPrefix;
-    tokens = await db.prepare(
-      `SELECT * FROM tokens WHERE (domain = ? OR domain LIKE ?) AND deprecated_at IS NULL ORDER BY bloom_level, slug`
-    ).all(prefix, `${prefix}/%`);
-  } else {
-    tokens = await db.prepare(
-      "SELECT * FROM tokens WHERE deprecated_at IS NULL ORDER BY bloom_level, domain, slug"
-    ).all();
-  }
+    whereClauses.push("(domain = ? OR domain LIKE ?)");
+    params.push(prefix, `${prefix}/%`);
+  }
+  if (options?.knowledgeContext) {
+    whereClauses.push(`EXISTS (
+      SELECT 1 FROM token_contexts tc
+      INNER JOIN contexts c ON c.id = tc.context_id
+      WHERE tc.token_id = tokens.id AND c.name = ?
+    )`);
+    params.push(options.knowledgeContext);
+  }
+  const orderBy = options?.domain || options?.domainPrefix ? "ORDER BY bloom_level, slug" : "ORDER BY bloom_level, domain, slug";
+  const sql = `SELECT * FROM tokens WHERE ${whereClauses.join(" AND ")} ${orderBy}`;
+  const tokens = await db.prepare(sql).all(...params);
   for (const token of tokens) {
     parseTokenFallback(token);
   }
@@ -1864,6 +1972,14 @@ async function listPersonalCards(db, userId, options) {
     sql += " AND t.domain = ?";
     values.push(options.domain);
   }
+  if (options?.knowledgeContext) {
+    sql += ` AND EXISTS (
+      SELECT 1 FROM token_contexts tc
+      INNER JOIN contexts kc ON kc.id = tc.context_id
+      WHERE tc.token_id = t.id AND kc.name = ?
+    )`;
+    values.push(options.knowledgeContext);
+  }
   if (options?.query) {
     const terms = options.query.toLowerCase().split(/\s+/).filter(Boolean);
     for (const term of terms) {
@@ -2389,12 +2505,12 @@ async function getTokenNeighborhood(db, tokenId, userId) {
 }
 
 // src/kernel/models/review.ts
-import { ulid as ulid4 } from "ulid";
+import { ulid as ulid5 } from "ulid";
 
 // src/kernel/models/session.ts
-import { ulid as ulid5 } from "ulid";
+import { ulid as ulid6 } from "ulid";
 async function startSession(db, input8) {
-  const id = ulid5();
+  const id = ulid6();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const ctx = input8.execution_context ?? "shell";
   await db.prepare(
@@ -2428,7 +2544,7 @@ async function logStep(db, input8) {
   if (!session) {
     throw new Error(`Session not found: ${input8.session_id}`);
   }
-  const id = ulid5();
+  const id = ulid6();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   await db.prepare(
     `INSERT INTO session_steps (id, session_id, token_id, done_by, rating, notes, created_at)
@@ -3310,10 +3426,10 @@ async function syncObserverSidecarPolicy(db, dir = getUiObserverDir()) {
 }
 
 // src/kernel/observation/session-synthesis.ts
-import { ulid as ulid7 } from "ulid";
+import { ulid as ulid8 } from "ulid";
 
 // src/kernel/recall/evaluator.ts
-import { ulid as ulid6 } from "ulid";
+import { ulid as ulid7 } from "ulid";
 
 // src/kernel/scheduler/fsrs.ts
 var DEFAULT_W = [
@@ -3492,7 +3608,7 @@ async function evaluateRatingWithinTransaction(db, input8) {
     due_at: updated.dueAt.toISOString(),
     last_review_at: now.toISOString()
   });
-  const reviewLogId = input8.reviewLogId ?? ulid6();
+  const reviewLogId = input8.reviewLogId ?? ulid7();
   await db.prepare(
     `INSERT INTO review_logs (id, card_id, token_id, user_id, rating, response_time_ms, reviewed_at, scheduled_at, session_id)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
@@ -3826,7 +3942,7 @@ async function applySessionSynthesis(db, input8) {
       return { applied: false, record: parseSynthesisRow(existing) };
     }
     const card = await ensureCard(tx, token.id, session.user_id);
-    const reviewLogId = ulid7();
+    const reviewLogId = ulid8();
     await evaluateRatingWithinTransaction(tx, {
       cardId: card.id,
       tokenId: token.id,
@@ -4652,8 +4768,7 @@ async function buildReviewQueue(db, options) {
   const maxReviews = options.maxReviews ?? 50;
   const now = options.now ?? /* @__PURE__ */ new Date();
   const nowISO = now.toISOString();
-  const dueRows = await db.prepare(
-    `SELECT
+  let dueSql = `SELECT
          c.id       AS card_id,
          c.token_id AS token_id,
          t.slug     AS slug,
@@ -4671,11 +4786,19 @@ async function buildReviewQueue(db, options) {
          AND c.blocked = 0
          AND c.due_at <= ?
          AND c.state IN ('review', 'relearning', 'learning')
-         AND t.deprecated_at IS NULL
-       ORDER BY c.due_at ASC`
-  ).all(options.userId, nowISO);
-  const newRows = await db.prepare(
-    `SELECT
+         AND t.deprecated_at IS NULL`;
+  const dueParams = [options.userId, nowISO];
+  if (options.knowledgeContext) {
+    dueSql += ` AND EXISTS (
+      SELECT 1 FROM token_contexts tc
+      INNER JOIN contexts ctx ON ctx.id = tc.context_id
+      WHERE tc.token_id = t.id AND ctx.name = ?
+    )`;
+    dueParams.push(options.knowledgeContext);
+  }
+  dueSql += ` ORDER BY c.due_at ASC`;
+  const dueRows = await db.prepare(dueSql).all(...dueParams);
+  let newSql = `SELECT
          c.id       AS card_id,
          c.token_id AS token_id,
          t.slug     AS slug,
@@ -4692,10 +4815,19 @@ async function buildReviewQueue(db, options) {
        WHERE c.user_id = ?
          AND c.blocked = 0
          AND c.state = 'new'
-         AND t.deprecated_at IS NULL
-       ORDER BY t.bloom_level ASC, t.slug ASC
-       LIMIT ?`
-  ).all(options.userId, maxNew);
+         AND t.deprecated_at IS NULL`;
+  const newParams = [options.userId];
+  if (options.knowledgeContext) {
+    newSql += ` AND EXISTS (
+      SELECT 1 FROM token_contexts tc
+      INNER JOIN contexts ctx ON ctx.id = tc.context_id
+      WHERE tc.token_id = t.id AND ctx.name = ?
+    )`;
+    newParams.push(options.knowledgeContext);
+  }
+  newSql += ` ORDER BY t.bloom_level ASC, t.slug ASC LIMIT ?`;
+  newParams.push(maxNew);
+  const newRows = await db.prepare(newSql).all(...newParams);
   const nowMs = now.getTime();
   const sortedDue = [...dueRows].sort((a, b) => {
     const overdueA = nowMs - new Date(a.due_at).getTime();
@@ -5426,6 +5558,27 @@ function detectSyncProvider(dir) {
   }
   return null;
 }
+function getActiveWorkspaceContext(path = defaultConfigPath()) {
+  const activeWorkspace = getActiveWorkspace(path);
+  return activeWorkspace?.activeKnowledgeContext;
+}
+function setActiveWorkspaceContext(contextName, path = defaultConfigPath()) {
+  const config = loadInstallConfig(path);
+  const activeId = config.activeWorkspaceId;
+  if (activeId && config.workspaces) {
+    const workspace = config.workspaces.find((w) => w.id === activeId);
+    if (workspace) {
+      if (contextName) {
+        workspace.activeKnowledgeContext = contextName;
+      } else {
+        delete workspace.activeKnowledgeContext;
+      }
+      saveInstallConfig(config, path);
+      return true;
+    }
+  }
+  return false;
+}
 
 // src/kernel/system/installer.ts
 import { execFileSync, execSync } from "child_process";
@@ -6292,7 +6445,7 @@ import { existsSync as existsSync17, readdirSync as readdirSync2, readFileSync a
 import { homedir as homedir10, tmpdir as tmpdir3 } from "os";
 import { join as join18, resolve as resolve4 } from "path";
 import { Command as Command2 } from "commander";
-import { ulid as ulid8 } from "ulid";
+import { ulid as ulid9 } from "ulid";
 
 // src/cli/adapters/source-reader.ts
 import dns from "dns";
@@ -6819,20 +6972,28 @@ JSON Array Output:`;
   );
   return readChatContent(res, "LLM curriculum import");
 }
-async function importCurriculumViaLLM(db, text, targetCategory, sourceUrl) {
+async function importCurriculumViaLLM(db, text, targetCategory, sourceUrl, options) {
   if (text.length > MAX_IMPORT_TEXT_CHARS) {
     throw new Error(
       `Curriculum text exceeds the ${MAX_IMPORT_TEXT_CHARS.toLocaleString()} character limit`
     );
   }
   const cfg = await getProviderForRole(db, "text");
+  let locale = cfg.locale;
+  const contextName = options?.knowledgeContext || getActiveWorkspaceContext();
+  if (contextName) {
+    const context = await getKnowledgeContextByName(db, contextName);
+    if (context?.language) {
+      locale = normalizeLocale(context.language);
+    }
+  }
   const endpoint = await resolveUsableTextEndpoint(db);
-  const langName = LANGUAGE_NAMES[cfg.locale] || "English";
+  const langName = LANGUAGE_NAMES[locale] || "English";
   let responseText;
   try {
     responseText = await requestCurriculumCards(
       endpoint,
-      cfg.locale,
+      locale,
       langName,
       text,
       targetCategory,
@@ -6849,7 +7010,7 @@ async function importCurriculumViaLLM(db, text, targetCategory, sourceUrl) {
       try {
         chunkResponse = await requestCurriculumCards(
           endpoint,
-          cfg.locale,
+          locale,
           langName,
           chunk,
           targetCategory,
@@ -7703,6 +7864,14 @@ async function ensureHighQualityQuestion(db, token) {
 }
 async function generateTitleViaLLM(db, input8, opts = {}) {
   const cfg = await getProviderForRole(db, "text");
+  let locale = cfg.locale;
+  const contextName = opts.knowledgeContext || getActiveWorkspaceContext();
+  if (contextName) {
+    const context = await getKnowledgeContextByName(db, contextName);
+    if (context?.language) {
+      locale = normalizeLocale(context.language);
+    }
+  }
   const endpoint = await resolveUsableTextEndpoint(db);
   const systemPrompt = `You are an expert at naming knowledge items for a personal knowledge graph.
 Your task: given a knowledge token's concept (the full reference answer), question, domain, and optional context, produce a short, descriptive, human-friendly TITLE.
@@ -7710,7 +7879,7 @@ Your task: given a knowledge token's concept (the full reference answer), questi
 Strict rules from the project ADR:
 - Concise name for the concept (\u2264 80 chars ideal).
 - Thoughtful, memorable name \u2014 NOT a definition or the first sentence of the concept.
-- NEVER echo the domain name (e.g. do not say "Node Drain" if domain is "axon-ivy"; just "Node Drain Protection").
+- NEVER echo the domain name (e.g. do not say "Workflow Engine Node Drain" if domain is "workflow-engine"; just "Node Drain Protection").
 - Prefer a name over spoiling the full concept.
 - Support Unicode (umlauts, etc.).
 - Output the title in the same language as the concept/content (e.g., German if the concept is German, English if the concept is English).
@@ -7747,7 +7916,7 @@ Title:`;
         temperature: 0.2,
         max_tokens: 100
       }),
-      locale: cfg.locale,
+      locale,
       timeoutMs: opts.timeoutMs,
       hardTimeoutMs: opts.timeoutMs
     });
@@ -7883,7 +8052,7 @@ async function readWebLink(url) {
         redirect: "manual",
         signal: controller.signal,
         headers: {
-          "User-Agent": "ZAM-Content-Studio/0.6.3"
+          "User-Agent": "ZAM-Content-Studio/0.8.0"
         }
       });
       if (res.status >= 300 && res.status < 400) {
@@ -10607,6 +10776,25 @@ function getCurriculumProvider(id) {
   return CURRICULUM_PROVIDERS.find((provider) => provider.id === id);
 }
 
+// src/cli/knowledge-contexts.ts
+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/embedder.ts
 var CANONICAL_EMBEDDING_MODEL_ID = "embeddinggemma-300m";
 var EMBEDDINGGEMMA_ALIASES = /* @__PURE__ */ new Set([
@@ -11921,6 +12109,20 @@ function jsonError(message) {
   console.log(JSON.stringify({ error: msg }, null, 2));
   process.exit(1);
 }
+function parseKnowledgeContextNames(value) {
+  if (value == null) return [];
+  if (!Array.isArray(value) || value.some((name) => typeof name !== "string" || !name.trim())) {
+    jsonError("knowledgeContexts must be an array of non-empty context names");
+  }
+  return [...new Set(value.map((name) => name.trim()))];
+}
+async function resolveKnowledgeContexts(db, names) {
+  try {
+    return await resolveOperationKnowledgeContexts(db, names);
+  } catch (error) {
+    jsonError(error.message);
+  }
+}
 function parseNonNegativeIntegerOption(name, value) {
   const parsed = Number(value);
   if (!Number.isInteger(parsed) || parsed < 0) {
@@ -11974,16 +12176,23 @@ function parseTokenUpdates(opts) {
 var bridgeCommand = new Command2("bridge").description(
   "Machine-readable JSON protocol for AI integration"
 );
-bridgeCommand.command("check-due").description("Check due cards for a user (JSON)").option("--user <id>", "User ID (default: whoami)").option("--domain <domain>", "Filter by knowledge domain").action(async (opts) => {
+bridgeCommand.command("check-due").description("Check due cards for a user (JSON)").option("--user <id>", "User ID (default: whoami)").option("--domain <domain>", "Filter by knowledge domain").option("--knowledge-context <context>", "Filter by knowledge context").action(async (opts) => {
   await withDb2(async (db) => {
     const userId = await resolveUser(opts, db, { json: true });
-    const dueCards = await getDueCards(db, userId, void 0, opts.domain);
+    const dueCards = await getDueCards(
+      db,
+      userId,
+      void 0,
+      opts.domain,
+      opts.knowledgeContext
+    );
     const domains = [
       ...new Set(dueCards.map((c) => c.domain).filter(Boolean))
     ].sort();
     jsonOut2({
       userId,
       domain: opts.domain ?? null,
+      knowledgeContext: opts.knowledgeContext ?? null,
       dueCount: dueCards.length,
       domains,
       cards: dueCards.map((c) => ({
@@ -12244,13 +12453,14 @@ bridgeCommand.command("agent-open").description("Launch an agent harness in the
 bridgeCommand.command("get-review").description("Get next review card with prompt (JSON)").option("--user <id>", "User ID (default: whoami)").option("--no-resolve", "Skip resolving the token's source_link into context").option(
   "--no-dynamic-question",
   "Use the stored question without generating a fresh LLM question"
-).action(async (opts) => {
+).option("--knowledge-context <context>", "Filter cards by knowledge context").action(async (opts) => {
   await withDb2(async (db) => {
     const userId = await resolveUser(opts, db, { json: true });
     const queue = await buildReviewQueue(db, {
       userId,
       maxReviews: 1,
-      maxNew: 1
+      maxNew: 1,
+      knowledgeContext: opts.knowledgeContext || void 0
     });
     if (queue.items.length === 0) {
       jsonOut2({
@@ -12305,7 +12515,10 @@ bridgeCommand.command("get-review").description("Get next review card with promp
         resolvedContext = null;
       }
     }
-    const fullQueue = await buildReviewQueue(db, { userId });
+    const fullQueue = await buildReviewQueue(db, {
+      userId,
+      knowledgeContext: opts.knowledgeContext || void 0
+    });
     jsonOut2({
       userId,
       hasReview: true,
@@ -12579,6 +12792,10 @@ bridgeCommand.command("add-token").description("Create a token + card from JSON
       domain: data?.domain,
       title: data?.title ?? null
     });
+    const ctxNames = parseKnowledgeContextNames(
+      data?.knowledgeContexts ?? data?.knowledge_contexts
+    );
+    const assignedContexts = await resolveKnowledgeContexts(db, ctxNames);
     const token = await createToken(db, {
       slug: data?.slug,
       title: data?.title,
@@ -12590,6 +12807,9 @@ bridgeCommand.command("add-token").description("Create a token + card from JSON
       source_link: data?.source_link ?? null,
       question: data?.question ?? null
     });
+    for (const context of assignedContexts) {
+      await assignTokenToContext(db, token.id, context.id);
+    }
     const card = await ensureCard(db, token.id, userId);
     try {
       await ensureTokenEmbeddings(db, { limit: 8 });
@@ -12597,7 +12817,14 @@ bridgeCommand.command("add-token").description("Create a token + card from JSON
     }
     jsonOut2({
       success: true,
-      token,
+      token: {
+        ...token,
+        knowledgeContexts: assignedContexts.map((c) => ({
+          name: c.name,
+          label: c.label,
+          language: c.language
+        }))
+      },
       card: {
         id: card.id,
         tokenId: card.token_id,
@@ -12657,6 +12884,22 @@ bridgeCommand.command("relevant-tokens").description("Find tokens relevant to a
       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({
@@ -12668,6 +12911,7 @@ bridgeCommand.command("relevant-tokens").description("Find tokens relevant to a
         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,
@@ -13960,13 +14204,15 @@ bridgeCommand.command("list-tokens").description(
   "User ID (default: whoami) \u2014 when provided, includes personal card info"
 ).option("--domain <domain>", "Filter by exact domain").option(
   "--domain-prefix <prefix>",
-  "Filter by domain prefix (e.g. docuware-cops) \u2014 uses / separator for hierarchy"
-).action(async (opts) => {
+  "Filter by domain prefix (e.g. company-team) \u2014 uses / separator for hierarchy"
+).option("--knowledge-context <context>", "Filter by knowledge context").action(async (opts) => {
   await withDb2(async (db) => {
     const userId = opts.user ? await resolveUser(opts, db, { json: true }) : void 0;
     const listOpts = {};
     if (opts.domain) listOpts.domain = opts.domain;
     if (opts.domainPrefix) listOpts.domainPrefix = opts.domainPrefix;
+    if (opts.knowledgeContext)
+      listOpts.knowledgeContext = opts.knowledgeContext;
     const tokens = await listTokens(
       db,
       Object.keys(listOpts).length ? listOpts : void 0
@@ -13981,6 +14227,22 @@ bridgeCommand.command("list-tokens").description(
       ).all(...ids, userId);
       for (const c of cards) cardMap.set(c.token_id, c);
     }
+    const contextMap = /* @__PURE__ */ new Map();
+    if (tokens.length > 0) {
+      const ids = tokens.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);
+      }
+    }
     const out = tokens.map((t2) => {
       const c = cardMap.get(t2.id);
       return {
@@ -13991,6 +14253,7 @@ bridgeCommand.command("list-tokens").description(
         concept: t2.concept,
         domain: t2.domain,
         bloomLevel: t2.bloom_level,
+        knowledgeContexts: contextMap.get(t2.id) ?? [],
         card: c ? {
           state: c.state,
           reps: c.reps,
@@ -14018,6 +14281,23 @@ bridgeCommand.command("get-neighborhood").description(
       jsonError(`Token not found: ${opts.focus}`);
     }
     const nb = await getTokenNeighborhood(db, token.id, userId);
+    const allTokens = [nb.center, ...nb.prerequisites, ...nb.dependents];
+    const contextMap = /* @__PURE__ */ new Map();
+    if (allTokens.length > 0) {
+      const ids = allTokens.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);
+      }
+    }
     const mapToken = (nt) => ({
       id: nt.id,
       slug: nt.slug,
@@ -14026,6 +14306,7 @@ bridgeCommand.command("get-neighborhood").description(
       concept: nt.concept,
       domain: nt.domain,
       bloomLevel: nt.bloom_level,
+      knowledgeContexts: contextMap.get(nt.id) ?? [],
       card: nt.card ? {
         state: nt.card.state,
         reps: nt.card.reps,
@@ -14044,23 +14325,62 @@ bridgeCommand.command("get-neighborhood").description(
     });
   });
 });
-bridgeCommand.command("personal-card-list").description("List and search personal learning cards (JSON)").option("--user <id>", "User ID (default: whoami)").option("--query <query>", "Text search query").option("--domain <domain>", "Filter by category/domain").action(async (opts) => {
+bridgeCommand.command("personal-card-list").description("List and search personal learning cards (JSON)").option("--user <id>", "User ID (default: whoami)").option("--query <query>", "Text search query").option("--domain <domain>", "Filter by category/domain").option("--knowledge-context <context>", "Filter by knowledge context").action(async (opts) => {
   await withDb2(async (db) => {
     const userId = await resolveUser(opts, db, { json: true });
     const cards = await listPersonalCards(db, userId, {
       query: opts.query,
-      domain: opts.domain
+      domain: opts.domain,
+      knowledgeContext: opts.knowledgeContext
+    });
+    const contextMap = /* @__PURE__ */ new Map();
+    if (cards.length > 0) {
+      const tokenIds = cards.map((card) => card.tokenId);
+      const placeholders = tokenIds.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})
+             ORDER BY c.name`
+      ).all(...tokenIds);
+      for (const mapping of mappings) {
+        const contexts = contextMap.get(mapping.token_id) ?? [];
+        contexts.push({
+          name: mapping.name,
+          label: mapping.label,
+          language: mapping.language
+        });
+        contextMap.set(mapping.token_id, contexts);
+      }
+    }
+    jsonOut2({
+      cards: cards.map((card) => ({
+        ...card,
+        knowledgeContexts: contextMap.get(card.tokenId) ?? []
+      }))
     });
-    jsonOut2({ cards });
   });
 });
 bridgeCommand.command("personal-card-create").description("Atomically create a token and its personal card (JSON)").option("--user <id>", "User ID (default: whoami)").requiredOption("--concept <concept>", "Concept description / answer").option("--title <title>", "Human-friendly display title").option("--domain <domain>", "Knowledge category / domain", "").option("--question <question>", "Question prompt for recall").option("--source-link <link>", "Source file path or reference URL").option("--bloom <level>", "Bloom taxonomy level (1-5)", "1").option(
   "--mode <mode>",
   "Symbiosis mode: shadowing | copilot | autonomy | none",
   "none"
-).option("--context <context>", "Context description", "").action(async (opts) => {
+).option("--context <context>", "Context description", "").option(
+  "--knowledge-context <context>",
+  "Assign token to a knowledge context (repeatable)",
+  (val, memo) => {
+    memo.push(val);
+    return memo;
+  },
+  []
+).action(async (opts) => {
   await withDb2(async (db) => {
     const userId = await resolveUser(opts, db, { json: true });
+    const contextNames = parseKnowledgeContextNames(
+      opts.knowledgeContext || []
+    );
+    const contexts = await resolveKnowledgeContexts(db, contextNames);
     const bloom = Number(opts.bloom);
     if (bloom < 1 || bloom > 5) {
       jsonError("bloom must be between 1 and 5");
@@ -14091,6 +14411,9 @@ bridgeCommand.command("personal-card-create").description("Atomically create a t
         source_link: opts.sourceLink || null,
         question
       });
+      for (const context of contexts) {
+        await assignTokenToContext(tx, createdToken.id, context.id);
+      }
       const createdCard = await ensureCard(tx, createdToken.id, userId);
       return { token: createdToken, card: createdCard };
     });
@@ -14109,7 +14432,12 @@ bridgeCommand.command("personal-card-create").description("Atomically create a t
         sourceLink: token.source_link,
         question: token.question,
         createdAt: token.created_at,
-        updatedAt: token.updated_at
+        updatedAt: token.updated_at,
+        knowledgeContexts: contexts.map((context) => ({
+          name: context.name,
+          label: context.label,
+          language: context.language
+        }))
       },
       card: {
         id: card.id,
@@ -14263,14 +14591,28 @@ bridgeCommand.command("personal-card-delete").description("Hard-delete a token a
 bridgeCommand.command("personal-card-import-curriculum").description("Parse curriculum text using LLM and import cards (JSON)").option("--user <id>", "User ID (default: whoami)").requiredOption("--text <text>", "Curriculum syllabus/content text").requiredOption(
   "--domain <domain>",
   "Default category/domain for imported cards"
-).option("--source <url>", "Provenance source link or URL").option("--preview", "Return parsed cards without saving them").action(async (opts) => {
+).option("--source <url>", "Provenance source link or URL").option("--preview", "Return parsed cards without saving them").option(
+  "--knowledge-context <context>",
+  "Assign imported tokens to a knowledge context (repeatable)",
+  (val, memo) => {
+    memo.push(val);
+    return memo;
+  },
+  []
+).action(async (opts) => {
   await withDb2(async (db) => {
     const userId = await resolveUser(opts, db, { json: true });
+    const contextNames = parseKnowledgeContextNames(
+      opts.knowledgeContext || []
+    );
+    const contexts = await resolveKnowledgeContexts(db, contextNames);
+    const firstContext = contexts[0]?.name;
     const cards = await importCurriculumViaLLM(
       db,
       opts.text,
       opts.domain,
-      opts.source || null
+      opts.source || null,
+      { knowledgeContext: firstContext }
     );
     if (opts.preview) {
       jsonOut2({
@@ -14280,6 +14622,24 @@ bridgeCommand.command("personal-card-import-curriculum").description("Parse curr
       return;
     }
     const result = await importCurriculumCards(db, userId, cards);
+    for (const card of cards) {
+      const baseText = card.question && card.question.trim().length > 0 ? card.question : card.concept;
+      const cleanDomain = slugify(card.domain || "");
+      const cleanBase = slugify(baseText);
+      let baseSlug = cleanDomain ? `${cleanDomain}-${cleanBase}` : cleanBase;
+      if (baseSlug.length > 60) {
+        baseSlug = baseSlug.slice(0, 60).replace(/-$/, "");
+      }
+      if (!baseSlug) {
+        baseSlug = "token";
+      }
+      const token = await getTokenBySlug(db, baseSlug);
+      if (token) {
+        for (const context of contexts) {
+          await assignTokenToContext(db, token.id, context.id);
+        }
+      }
+    }
     jsonOut2({
       success: true,
       createdCount: result.createdCount,
@@ -14418,7 +14778,7 @@ bridgeCommand.command("personal-source-import").description(
     } else {
       throw new Error(`Invalid source type: ${opts.type}`);
     }
-    const sourceId = ulid8();
+    const sourceId = ulid9();
     await db.prepare(
       `INSERT INTO sources (id, type, uri, content)
            VALUES (?, ?, ?, ?)
@@ -14440,16 +14800,46 @@ bridgeCommand.command("personal-source-confirm-import").description(
 ).option("--user <id>", "User ID (default: whoami)").requiredOption("--sourceId <id>", "Source database ID").requiredOption(
   "--proposals <json>",
   "JSON string representing proposals array"
+).option(
+  "--knowledge-context <context>",
+  "Assign confirmed tokens to a knowledge context (repeatable)",
+  (val, memo) => {
+    memo.push(val);
+    return memo;
+  },
+  []
 ).action(async (opts) => {
   await withDb2(async (db) => {
     const userId = await resolveUser(opts, db, { json: true });
     const proposals = JSON.parse(opts.proposals);
+    const contextNames = parseKnowledgeContextNames(
+      opts.knowledgeContext || []
+    );
+    const contexts = await resolveKnowledgeContexts(db, contextNames);
     const result = await confirmSourceImport(
       db,
       userId,
       opts.sourceId,
       proposals
     );
+    for (const p of proposals) {
+      const baseText = p.question && p.question.trim().length > 0 ? p.question : p.concept;
+      const cleanDomain = slugify(p.domain || "");
+      const cleanBase = slugify(baseText);
+      let baseSlug = cleanDomain ? `${cleanDomain}-${cleanBase}` : cleanBase;
+      if (baseSlug.length > 60) {
+        baseSlug = baseSlug.slice(0, 60).replace(/-$/, "");
+      }
+      if (!baseSlug) {
+        baseSlug = "token";
+      }
+      const token = await getTokenBySlug(db, baseSlug);
+      if (token) {
+        for (const context of contexts) {
+          await assignTokenToContext(db, token.id, context.id);
+        }
+      }
+    }
     jsonOut2({
       success: true,
       createdCount: result.createdCount,
@@ -14607,7 +14997,7 @@ bridgeCommand.command("curriculum-extract-topics").description(
         }
       }
       const pageCleanedText = cleanHtml(rawHtml);
-      const sourceId = ulid8();
+      const sourceId = ulid9();
       await db.prepare(
         `INSERT INTO sources (id, type, uri, content)
              VALUES (?, 'web', ?, ?)
@@ -14656,6 +15046,71 @@ bridgeCommand.command("curriculum-set-last-selection").description("Persist the
     jsonOut2({ success: true });
   });
 });
+bridgeCommand.command("list-knowledge-contexts").description("List all knowledge contexts (JSON)").action(async () => {
+  await withDb2(async (db) => {
+    const contexts = await listKnowledgeContexts(db);
+    jsonOut2({ success: true, contexts });
+  });
+});
+bridgeCommand.command("assign-knowledge-context").description("Assign a token to a knowledge context (JSON)").requiredOption("--token <slug>", "Token slug").requiredOption("--context <name>", "Context name").action(async (opts) => {
+  await withDb2(async (db) => {
+    const context = await getKnowledgeContextByName(db, opts.context);
+    if (!context) {
+      jsonError(`Knowledge context not found: ${opts.context}`);
+    }
+    const token = await getTokenBySlug(db, opts.token);
+    if (!token) {
+      jsonError(`Token not found: ${opts.token}`);
+    }
+    await assignTokenToContext(db, token.id, context.id);
+    jsonOut2({ success: true, token: token.slug, context: context.name });
+  });
+});
+bridgeCommand.command("unassign-knowledge-context").description("Remove a token from a knowledge context (JSON)").requiredOption("--token <slug>", "Token slug").requiredOption("--context <name>", "Context name").action(async (opts) => {
+  await withDb2(async (db) => {
+    const context = await getKnowledgeContextByName(db, opts.context);
+    if (!context) {
+      jsonError(`Knowledge context not found: ${opts.context}`);
+    }
+    const token = await getTokenBySlug(db, opts.token);
+    if (!token) {
+      jsonError(`Token not found: ${opts.token}`);
+    }
+    await unassignTokenFromContext(db, token.id, context.id);
+    jsonOut2({ success: true, token: token.slug, context: context.name });
+  });
+});
+bridgeCommand.command("get-active-knowledge-context").description("Get the active knowledge context name (JSON)").action(async () => {
+  await withDb2(async (db) => {
+    const configured = getActiveWorkspaceContext();
+    const active = configured ? await getKnowledgeContextByName(db, configured) : void 0;
+    jsonOut2({
+      success: true,
+      activeContext: active?.name ?? null,
+      staleContext: configured && !active ? configured : null
+    });
+  });
+});
+bridgeCommand.command("set-active-knowledge-context").description("Set the active knowledge context name (JSON)").argument("[name]", "Context name to use (use empty/none to clear)").action(async (name) => {
+  await withDb2(async (db) => {
+    if (!name || name === "none" || name === "null" || name === "undefined") {
+      if (!setActiveWorkspaceContext(void 0)) {
+        jsonError("No active workspace configured");
+      }
+      jsonOut2({ success: true, activeContext: null });
+      return;
+    }
+    const context = await getKnowledgeContextByName(db, name);
+    if (!context) {
+      jsonError(`Knowledge context not found: ${name}`);
+      return;
+    }
+    if (!setActiveWorkspaceContext(context.name)) {
+      jsonError("No active workspace configured");
+    }
+    jsonOut2({ success: true, activeContext: context.name });
+  });
+});
 bridgeCommand.command("serve").description("Start the persistent JSON-RPC stdin/stdout server").option("--stdin", "Use stdin/stdout for communication").action(async (_opts) => {
   isServeMode = true;
   const {
@@ -14790,10 +15245,16 @@ import { Command as Command3 } from "commander";
 var cardCommand = new Command3("card").description(
   "Manage spaced-repetition cards"
 );
-cardCommand.command("due").description("Show due tokens for a user").option("--user <id>", "User ID (default: whoami)").option("--domain <domain>", "Filter by knowledge domain").option("--json", "Output as JSON").option("--summary", "Show only counts per domain (no slugs or concepts)").action(async (opts) => {
+cardCommand.command("due").description("Show due tokens for a user").option("--user <id>", "User ID (default: whoami)").option("--domain <domain>", "Filter by knowledge domain").option("--knowledge-context <context>", "Filter by knowledge context").option("--json", "Output as JSON").option("--summary", "Show only counts per domain (no slugs or concepts)").action(async (opts) => {
   await withDb(async (db) => {
     const userId = await resolveUser(opts, db);
-    const dueCards = await getDueCards(db, userId, void 0, opts.domain);
+    const dueCards = await getDueCards(
+      db,
+      userId,
+      void 0,
+      opts.domain,
+      opts.knowledgeContext
+    );
     if (opts.json) {
       console.log(JSON.stringify(dueCards, null, 2));
       return;
@@ -15141,6 +15602,48 @@ import { Command as Command5 } from "commander";
 function shouldApplyFixes(opts) {
   return opts.fix === true && opts.dryRun !== true;
 }
+function stringifyDoctorOutput(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+async function captureDoctorTaskOutput(task, db, opts) {
+  const chunks = [];
+  const append = (value) => {
+    for (const line of value.split(/[\r\n]+/)) {
+      const trimmed = line.trim();
+      if (trimmed) chunks.push(trimmed);
+    }
+  };
+  const capture = (...args) => {
+    append(args.map(stringifyDoctorOutput).join(" "));
+  };
+  const originalLog = console.log;
+  const originalWarn = console.warn;
+  const originalError = console.error;
+  const originalWrite = process.stdout.write;
+  console.log = capture;
+  console.warn = capture;
+  console.error = capture;
+  process.stdout.write = ((chunk) => {
+    append(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString());
+    return true;
+  });
+  try {
+    await task.run(db, opts);
+    return { lines: chunks };
+  } catch (error) {
+    return { lines: chunks, error: error.message };
+  } finally {
+    console.log = originalLog;
+    console.warn = originalWarn;
+    console.error = originalError;
+    process.stdout.write = originalWrite;
+  }
+}
 async function confirmDeterministicChanges(opts, message) {
   if (opts.yes) return true;
   if (!process.stdin.isTTY || !process.stdout.isTTY) {
@@ -15244,6 +15747,27 @@ function validatedTitleProposal(token, raw) {
   }
   return null;
 }
+var LANGUAGE_MARKERS = {
+  de: ["der", "die", "das", "und", "ist", "sind", "f\xFCr", "mit", "nicht"],
+  en: ["the", "and", "is", "are", "for", "with", "not", "from", "that"],
+  es: ["el", "la", "los", "las", "y", "es", "son", "para", "con"],
+  fr: ["le", "la", "les", "et", "est", "sont", "pour", "avec"],
+  pt: ["o", "a", "os", "as", "e", "\xE9", "s\xE3o", "para", "com"]
+};
+function inferEstablishedLanguage(token) {
+  const text = [token.title, token.concept, token.question, token.context].filter(Boolean).join(" ").toLowerCase();
+  if (/[぀-ヿ]/u.test(text)) return "ja";
+  if (/[㐀-鿿]/u.test(text)) return "zh";
+  const words = new Set(text.match(/\p{L}+/gu) ?? []);
+  const scores = Object.entries(LANGUAGE_MARKERS).map(([language, markers]) => ({
+    language,
+    score: markers.filter((marker) => words.has(marker)).length
+  })).sort((a, b) => b.score - a.score);
+  return scores[0].score >= 2 && scores[0].score > scores[1].score ? scores[0].language : null;
+}
+function primaryLanguage(language) {
+  return language?.trim().toLowerCase().split(/[-_]/)[0] || null;
+}
 var doctorTasks = [
   {
     name: "titles",
@@ -15268,9 +15792,11 @@ var doctorTasks = [
       let rejected = 0;
       for (let i = 0; i < needing.length; i++) {
         const item = needing[i];
-        process.stdout.write(
-          `\r  [${i + 1}/${needing.length}] ${item.token.slug.slice(0, 40)}...`
-        );
+        if (!opts.json) {
+          process.stdout.write(
+            `\r  [${i + 1}/${needing.length}] ${item.token.slug.slice(0, 40)}...`
+          );
+        }
         let rawProposal = "";
         if (useLLM) {
           try {
@@ -15283,7 +15809,10 @@ var doctorTasks = [
                 question: item.token.question,
                 context: item.token.context
               },
-              { timeoutMs: opts.timeoutMs }
+              {
+                timeoutMs: opts.timeoutMs,
+                knowledgeContext: opts.knowledgeContext
+              }
             );
             rawProposal = gen.text;
           } catch (_e) {
@@ -15304,7 +15833,7 @@ var doctorTasks = [
           reason: item.reason
         });
       }
-      process.stdout.write("\n");
+      if (!opts.json) process.stdout.write("\n");
       if (rejected > 0) {
         console.warn(
           `Skipped ${rejected} token(s) because no proposal passed title quality validation.`
@@ -15647,6 +16176,194 @@ Duplicates scan complete. Deprecated ${deprecatedCount} token(s).`
         `Domains rename complete. Renamed ${changes.length} domain(s).`
       );
     }
+  },
+  {
+    name: "contexts",
+    description: "Backfill contexts on old/unassigned tokens using heuristic rules.",
+    run: async (db, opts) => {
+      const tokensWithoutContext = await db.prepare(
+        `SELECT t.* FROM tokens t
+           WHERE NOT EXISTS (
+             SELECT 1 FROM token_contexts tc WHERE tc.token_id = t.id
+           )`
+      ).all();
+      const allContexts = await listKnowledgeContexts(db);
+      const contexts = opts.knowledgeContext ? allContexts.filter(
+        (context) => context.name === opts.knowledgeContext
+      ) : allContexts;
+      if (opts.knowledgeContext && contexts.length === 0) {
+        throw new Error(
+          `Knowledge context not found: ${opts.knowledgeContext}`
+        );
+      }
+      if (contexts.length === 0) {
+        if (opts.json) {
+          console.log(
+            JSON.stringify({
+              success: false,
+              error: "No knowledge contexts defined."
+            })
+          );
+        } else {
+          console.log(
+            "No knowledge contexts defined. Run `zam kc create` first."
+          );
+        }
+        return;
+      }
+      const proposals = [];
+      for (const t2 of tokensWithoutContext) {
+        const domain = (t2.domain || "").toLowerCase();
+        const slug = t2.slug.toLowerCase();
+        const title = (t2.title || "").toLowerCase();
+        const source = (t2.source_link || "").toLowerCase();
+        const establishedLanguage = inferEstablishedLanguage(t2);
+        const languageMatches = establishedLanguage ? contexts.filter(
+          (context) => primaryLanguage(context.language) === establishedLanguage
+        ) : [];
+        for (const ctx of contexts) {
+          const ctxName = ctx.name.toLowerCase();
+          const ctxLabel = (ctx.label || "").toLowerCase();
+          let match = false;
+          let highConfidence = false;
+          if (domain) {
+            if (domain === ctxName) {
+              match = true;
+              highConfidence = true;
+            } else if (ctxName.includes(domain) || domain.includes(ctxName)) {
+              match = true;
+              highConfidence = domain.length >= 2;
+            } else if (ctxLabel && (ctxLabel.includes(domain) || domain.includes(ctxLabel))) {
+              match = true;
+              highConfidence = domain.length >= 2;
+            }
+          }
+          if (slug.includes(ctxName) || title.includes(ctxName)) {
+            match = true;
+          }
+          if (ctxLabel) {
+            const labelWords = ctxLabel.split(/\s+/).filter((w) => w.length > 3);
+            for (const word of labelWords) {
+              if (domain.includes(word) || slug.includes(word) || title.includes(word)) {
+                match = true;
+              }
+            }
+          }
+          if (source && (source.includes(ctxName) || ctxLabel.split(/\s+/).filter((word) => word.length > 3).some((word) => source.includes(word)))) {
+            match = true;
+            highConfidence = true;
+          }
+          if (languageMatches.length === 1 && languageMatches[0].id === ctx.id) {
+            match = true;
+          }
+          if (match) {
+            proposals.push({
+              token: t2,
+              context: ctx,
+              highConfidence
+            });
+          }
+        }
+      }
+      const applying = shouldApplyFixes(opts);
+      if (opts.json) {
+        if (!applying) {
+          const formatted = proposals.map((p) => ({
+            tokenSlug: p.token.slug,
+            contextName: p.context.name,
+            highConfidence: p.highConfidence
+          }));
+          console.log(
+            JSON.stringify({
+              success: true,
+              task: "contexts",
+              proposals: formatted,
+              totalUnassigned: tokensWithoutContext.length
+            })
+          );
+          return;
+        }
+      } else {
+        console.log(
+          `Found ${proposals.length} proposed context assignments for ${tokensWithoutContext.length} unassigned tokens.`
+        );
+      }
+      if (proposals.length === 0) {
+        if (opts.json && applying) {
+          console.log(
+            JSON.stringify({
+              success: true,
+              task: "contexts",
+              applied: [],
+              totalApplied: 0
+            })
+          );
+        }
+        return;
+      }
+      if (!applying) {
+        console.log("\nProposed context assignments (Dry run):");
+        for (const prop of proposals) {
+          const confStr = prop.highConfidence ? " [High Confidence]" : "";
+          console.log(
+            `  - Assign token "${prop.token.slug}" to context "${prop.context.name}"${confStr}`
+          );
+        }
+        console.log("\nRun with --fix to apply these assignments.");
+        return;
+      }
+      if (opts.yes) {
+        let applied = 0;
+        const appliedProposals = [];
+        for (const prop of proposals) {
+          if (prop.highConfidence) {
+            await assignTokenToContext(db, prop.token.id, prop.context.id);
+            if (!opts.json) {
+              console.log(
+                `Auto-assigned: "${prop.token.slug}" -> context "${prop.context.name}"`
+              );
+            }
+            appliedProposals.push({
+              tokenSlug: prop.token.slug,
+              contextName: prop.context.name
+            });
+            applied++;
+          }
+        }
+        if (opts.json) {
+          console.log(
+            JSON.stringify({
+              success: true,
+              task: "contexts",
+              applied: appliedProposals,
+              totalApplied: applied
+            })
+          );
+        } else {
+          console.log(`Auto-assigned ${applied} high-confidence contexts.`);
+        }
+        return;
+      }
+      const { confirm: confirm5 } = await import("@inquirer/prompts");
+      let assignedCount = 0;
+      for (const prop of proposals) {
+        const confStr = prop.highConfidence ? " (high confidence)" : "";
+        const ans = await confirm5({
+          message: `Assign token "${prop.token.slug}" to context "${prop.context.name}"${confStr}?`,
+          default: prop.highConfidence
+        });
+        if (ans) {
+          await assignTokenToContext(db, prop.token.id, prop.context.id);
+          console.log(
+            `Assigned "${prop.token.slug}" -> context "${prop.context.name}"`
+          );
+          assignedCount++;
+        }
+      }
+      console.log(
+        `Completed contexts backfill. Assigned ${assignedCount} tokens.`
+      );
+    }
   }
 ];
 function parseDoctorTimeout(value) {
@@ -15665,30 +16382,128 @@ var doctorCommand = new Command5("doctor").description(
   "--timeout <ms>",
   "LLM timeout in ms per call (default: 20000)",
   "20000"
-).argument("[task]", "Specific task: titles, texts, duplicates, domains").action(async (taskName, opts) => {
+).option(
+  "--knowledge-context <context>",
+  "Knowledge context to limit/guide doctor task"
+).option("--json", "Emit report in JSON format").argument(
+  "[task]",
+  "Specific task: titles, texts, duplicates, domains, contexts"
+).action(async (taskName, opts) => {
   await withDb(async (db) => {
     const fix = !!opts.fix;
     const dryRun = !fix || !!opts.dryRun;
     const yes = !!opts.yes;
     const noLlm = opts.llm === false;
     const timeoutMs = parseDoctorTimeout(opts.timeout);
+    const knowledgeContext = opts.knowledgeContext;
+    const json = !!opts.json;
     if (!taskName) {
-      console.log("Available doctor tasks:");
-      for (const t2 of doctorTasks) {
-        console.log(`  ${t2.name} \u2014 ${t2.description}`);
+      const diagnosisOptions = {
+        fix: false,
+        dryRun: true,
+        yes: false,
+        noLlm: true,
+        timeoutMs,
+        knowledgeContext,
+        json: false
+      };
+      if (json) {
+        const reports = [];
+        for (const task2 of doctorTasks) {
+          const report = await captureDoctorTaskOutput(
+            task2,
+            db,
+            diagnosisOptions
+          );
+          reports.push({
+            name: task2.name,
+            description: task2.description,
+            ...report
+          });
+        }
+        const success = reports.every((report) => !report.error);
+        console.log(
+          JSON.stringify({ success, readOnly: true, tasks: reports })
+        );
+        if (!success) process.exitCode = 1;
+      } else {
+        console.log("ZAM doctor read-only diagnosis (LLM disabled):");
+        for (const task2 of doctorTasks) {
+          console.log(`
+[${task2.name}] ${task2.description}`);
+          await task2.run(db, diagnosisOptions);
+        }
       }
-      console.log("\nRun with a task name, e.g. `zam doctor titles --fix`");
       return;
     }
     const task = doctorTasks.find((t2) => t2.name === taskName);
     if (!task) {
-      console.error(`Unknown task: ${taskName}`);
+      if (json) {
+        console.log(
+          JSON.stringify({
+            success: false,
+            error: `Unknown task: ${taskName}`
+          })
+        );
+      } else {
+        console.error(`Unknown task: ${taskName}`);
+      }
       process.exit(1);
     }
-    console.log(
-      `Running doctor task: ${task.name} (fix=${fix}, dryRun=${dryRun}${noLlm ? ", noLlm=true" : ""})`
-    );
-    await task.run(db, { fix, dryRun, yes, noLlm, timeoutMs });
+    if (!json) {
+      console.log(
+        `Running doctor task: ${task.name} (fix=${fix}, dryRun=${dryRun}${noLlm ? ", noLlm=true" : ""})`
+      );
+    }
+    const taskOptions = {
+      fix,
+      dryRun,
+      yes,
+      noLlm,
+      timeoutMs,
+      knowledgeContext,
+      json
+    };
+    if (json && fix && !yes) {
+      console.log(
+        JSON.stringify({
+          success: false,
+          error: "--json --fix requires --yes; interactive prompts are not machine-readable"
+        })
+      );
+      process.exitCode = 1;
+      return;
+    }
+    if (json && fix && yes && (task.name === "duplicates" || task.name === "domains")) {
+      console.log(
+        JSON.stringify({
+          success: false,
+          error: `${task.name} fixes require interactive choices and cannot use --json --yes`
+        })
+      );
+      process.exitCode = 1;
+      return;
+    }
+    if (json) {
+      const report = await captureDoctorTaskOutput(task, db, taskOptions);
+      let payload = {
+        success: report.error === void 0,
+        task: task.name,
+        ...report
+      };
+      if (task.name === "contexts" && !report.error && report.lines.length === 1) {
+        try {
+          payload = JSON.parse(report.lines[0]);
+        } catch {
+        }
+      }
+      console.log(JSON.stringify(payload));
+      if (report.error || payload.success === false) {
+        process.exitCode = 1;
+      }
+      return;
+    }
+    await task.run(db, taskOptions);
   });
 });
 
@@ -16216,9 +17031,202 @@ var initCommand = new Command8("init").description("Launch the guided interactiv
   printLine();
 });
 
+// src/cli/commands/knowledge-context.ts
+import { Command as Command9 } from "commander";
+var knowledgeContextCommand = new Command9("knowledge-context").alias("kc").description("Manage knowledge contexts (work, school, private)");
+function commandError(message, json) {
+  if (json) {
+    jsonOut({ success: false, error: message });
+  } else {
+    console.error(message);
+  }
+  process.exit(1);
+}
+knowledgeContextCommand.command("list").description("List all knowledge contexts").option("--json", "Output as JSON").action(async (opts) => {
+  await withDb(async (db) => {
+    const contexts = await listKnowledgeContexts(db);
+    if (opts.json) {
+      jsonOut(contexts);
+      return;
+    }
+    if (contexts.length === 0) {
+      console.log("No knowledge contexts registered yet.");
+      return;
+    }
+    console.log(`Knowledge Contexts (${contexts.length})`);
+    console.log("\u2500".repeat(60));
+    for (const c of contexts) {
+      const lang = c.language ? ` (${c.language})` : "";
+      const label = c.label ? ` - ${c.label}` : "";
+      console.log(`  ${c.name.padEnd(20)}${label}${lang}`);
+    }
+  });
+});
+knowledgeContextCommand.command("create").description("Create a new knowledge context").requiredOption(
+  "--name <name>",
+  "Unique context identifier (e.g. work-company)"
+).option("--label <label>", "Display name").option(
+  "--language <language>",
+  "Default language (BCP-47 code, e.g. en, de)"
+).option("--json", "Output as JSON").action(async (opts) => {
+  await withDb(async (db) => {
+    const context = await createKnowledgeContext(db, {
+      name: opts.name,
+      label: opts.label || null,
+      language: opts.language || null
+    });
+    if (opts.json) {
+      jsonOut({ success: true, context });
+      return;
+    }
+    console.log(`Created knowledge context: ${context.name}`);
+    if (context.label) console.log(`  Label:    ${context.label}`);
+    if (context.language) console.log(`  Language: ${context.language}`);
+  });
+});
+knowledgeContextCommand.command("delete").description("Delete a knowledge context").requiredOption("--name <name>", "Context name").option(
+  "--confirm",
+  "Confirm removal of the context and its token assignments"
+).option("--json", "Output as JSON").action(async (opts) => {
+  await withDb(async (db) => {
+    const context = await getKnowledgeContextByName(db, opts.name);
+    if (!context) {
+      commandError(`Knowledge context not found: ${opts.name}`, !!opts.json);
+    }
+    const assignmentCount = (await db.prepare(
+      "SELECT COUNT(*) AS n FROM token_contexts WHERE context_id = ?"
+    ).get(context.id)).n;
+    if (!opts.confirm) {
+      if (opts.json) {
+        jsonOut({
+          success: true,
+          preview: true,
+          requiresConfirmation: true,
+          name: context.name,
+          tokenAssignments: assignmentCount
+        });
+      } else {
+        console.log(
+          `Deleting "${context.name}" removes ${assignmentCount} token assignment(s). Re-run with --confirm.`
+        );
+      }
+      return;
+    }
+    await deleteKnowledgeContext(db, context.id);
+    if (getActiveWorkspaceContext() === context.name) {
+      setActiveWorkspaceContext(void 0);
+    }
+    if (opts.json) {
+      jsonOut({
+        success: true,
+        name: context.name,
+        tokenAssignmentsRemoved: assignmentCount
+      });
+      return;
+    }
+    console.log(`Deleted knowledge context: ${context.name}`);
+  });
+});
+knowledgeContextCommand.command("assign").description("Assign a token to a knowledge context").requiredOption("--token <slug>", "Token slug").requiredOption("--context <name>", "Context name").option("--json", "Output as JSON").action(async (opts) => {
+  await withDb(async (db) => {
+    const context = await getKnowledgeContextByName(db, opts.context);
+    if (!context) {
+      commandError(
+        `Knowledge context not found: ${opts.context}`,
+        !!opts.json
+      );
+    }
+    const token = await getTokenBySlug(db, opts.token);
+    if (!token) {
+      commandError(`Token not found: ${opts.token}`, !!opts.json);
+    }
+    await assignTokenToContext(db, token.id, context.id);
+    if (opts.json) {
+      jsonOut({ success: true, token: token.slug, context: context.name });
+      return;
+    }
+    console.log(
+      `Assigned token "${token.slug}" to context "${context.name}"`
+    );
+  });
+});
+knowledgeContextCommand.command("unassign").description("Remove a token from a knowledge context").requiredOption("--token <slug>", "Token slug").requiredOption("--context <name>", "Context name").option("--json", "Output as JSON").action(async (opts) => {
+  await withDb(async (db) => {
+    const context = await getKnowledgeContextByName(db, opts.context);
+    if (!context) {
+      commandError(
+        `Knowledge context not found: ${opts.context}`,
+        !!opts.json
+      );
+    }
+    const token = await getTokenBySlug(db, opts.token);
+    if (!token) {
+      commandError(`Token not found: ${opts.token}`, !!opts.json);
+    }
+    await unassignTokenFromContext(db, token.id, context.id);
+    if (opts.json) {
+      jsonOut({ success: true, token: token.slug, context: context.name });
+      return;
+    }
+    console.log(
+      `Unassigned token "${token.slug}" from context "${context.name}"`
+    );
+  });
+});
+knowledgeContextCommand.command("use").description("Set the active knowledge context default for this device").argument("[name]", "Context name to use (use without argument to clear)").option("--json", "Output as JSON").action(async (name, opts) => {
+  await withDb(async (db) => {
+    if (!name) {
+      if (!setActiveWorkspaceContext(void 0)) {
+        commandError("No active workspace configured", !!opts.json);
+      }
+      if (opts.json) {
+        jsonOut({ success: true, activeContext: null });
+        return;
+      }
+      console.log("Cleared active knowledge context default.");
+      return;
+    }
+    const context = await getKnowledgeContextByName(db, name);
+    if (!context) {
+      commandError(`Knowledge context not found: ${name}`, !!opts.json);
+    }
+    if (!setActiveWorkspaceContext(context.name)) {
+      commandError("No active workspace configured", !!opts.json);
+    }
+    if (opts.json) {
+      jsonOut({ success: true, activeContext: context.name });
+      return;
+    }
+    console.log(`Active knowledge context set to: ${context.name}`);
+  });
+});
+knowledgeContextCommand.command("show").description("Show the active knowledge context default for this device").option("--json", "Output as JSON").action(async (opts) => {
+  await withDb(async (db) => {
+    const configured = getActiveWorkspaceContext();
+    const active = configured ? await getKnowledgeContextByName(db, configured) : void 0;
+    if (opts.json) {
+      jsonOut({
+        success: true,
+        activeContext: active?.name ?? null,
+        staleContext: configured && !active ? configured : null
+      });
+      return;
+    }
+    if (active) {
+      console.log(`Active knowledge context: ${active.name}`);
+    } else if (configured) {
+      console.warn(
+        `Configured knowledge context no longer exists: ${configured}`
+      );
+    } else {
+      console.log("No active knowledge context default set.");
+    }
+  });
+});
+
 // src/cli/commands/learn.ts
 import { input as input5 } from "@inquirer/prompts";
-import { Command as Command9 } from "commander";
+import { Command as Command10 } from "commander";
 
 // src/cli/learn-format.ts
 var BLOOM_VERBS3 = {
@@ -16562,7 +17570,7 @@ var STOP_WORDS = /* @__PURE__ */ new Set(["q", ":q", "quit", "stop"]);
 function isExitPrompt(err) {
   return err instanceof Error && err.name === "ExitPromptError";
 }
-var learnCommand = new Command9("learn").description(
+var learnCommand = new Command10("learn").description(
   "Run a spoiler-free, in-process learning session (recall \u2192 reveal \u2192 self-rate)"
 ).option("--user <id>", "User ID (default: whoami)").option("--max-new <n>", "Maximum new cards", "10").option("--max-reviews <n>", "Maximum review cards", "50").option("--no-resolve", "Skip resolving source_link into the revealed answer").action(async (opts) => {
   let db;
@@ -16808,8 +17816,8 @@ learnCommand.command("open").description("Open a new terminal window running zam
 });
 
 // src/cli/commands/monitor.ts
-import { Command as Command10 } from "commander";
-var monitorCommand = new Command10("monitor").description(
+import { Command as Command11 } from "commander";
+var monitorCommand = new Command11("monitor").description(
   "Shell observation for real-time task monitoring"
 );
 monitorCommand.command("start").description("Output shell hook code to install monitoring").requiredOption("--session <id>", "Session ID to monitor").option(
@@ -16991,8 +17999,8 @@ monitorCommand.command("open").description("Open a new monitored terminal window
 });
 
 // src/cli/commands/observer.ts
-import { Command as Command11 } from "commander";
-var observerCommand = new Command11("observer").description(
+import { Command as Command12 } from "commander";
+var observerCommand = new Command12("observer").description(
   "Configure what the UI observer may capture (Layer 2 policy)"
 );
 function applyObserverListChange(current, entry, op) {
@@ -17055,7 +18063,7 @@ observerCommand.command("revoke <process>").description("Remove a process from o
 
 // src/cli/commands/profile.ts
 import { dirname as dirname6, resolve as resolve7 } from "path";
-import { Command as Command12 } from "commander";
+import { Command as Command13 } from "commander";
 var C2 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -17072,7 +18080,7 @@ function render(profile) {
   console.log(`  data dir:      ${C2.cyan}${profile.dataDir}${C2.reset}`);
   console.log(`  database:      ${C2.cyan}${profile.dbPath}${C2.reset}`);
 }
-var profileCommand = new Command12("profile").description("Show or change this machine's ZAM install profile").option("--mode <mode>", "Set install mode: developer | default").option("--dir <path>", "Set the personal-content folder").option("--json", "Output as JSON").action(async (opts) => {
+var profileCommand = new Command13("profile").description("Show or change this machine's ZAM install profile").option("--mode <mode>", "Set install mode: developer | default").option("--dir <path>", "Set the personal-content folder").option("--json", "Output as JSON").action(async (opts) => {
   if (opts.mode && opts.mode !== "developer" && opts.mode !== "default") {
     console.error(`Invalid --mode: ${opts.mode}. Use developer or default.`);
     process.exit(1);
@@ -17112,8 +18120,8 @@ var profileCommand = new Command12("profile").description("Show or change this m
 
 // src/cli/commands/provider.ts
 import { password as password2 } from "@inquirer/prompts";
-import { Command as Command13 } from "commander";
-var providerCommand = new Command13("provider").description(
+import { Command as Command14 } from "commander";
+var providerCommand = new Command14("provider").description(
   "Configure role-based AI providers (url/model/flavor/key, per role)"
 );
 providerCommand.command("list").description("Show configured providers, role bindings, and key status").option("--json", "Output as JSON").option("--machine", "Read machine-local providers from ~/.zam/config.json").action(async (opts) => {
@@ -17348,16 +18356,33 @@ providerCommand.command("clear-key <ref>").description("Remove a stored API key"
 });
 
 // src/cli/commands/review.ts
-import { Command as Command14 } from "commander";
-var reviewCommand = new Command14("review").description("Start an interactive review session").option("--user <id>", "User ID (default: whoami)").option("--max-new <n>", "Maximum new cards", "10").option("--max-reviews <n>", "Maximum review cards", "50").option("--no-resolve", "Skip resolving source_link into inline context").action(async (opts) => {
+import { Command as Command15 } from "commander";
+var reviewCommand = new Command15("review").description("Start an interactive review session").option("--user <id>", "User ID (default: whoami)").option("--max-new <n>", "Maximum new cards", "10").option("--max-reviews <n>", "Maximum review cards", "50").option("--no-resolve", "Skip resolving source_link into inline context").option(
+  "--knowledge-context <context>",
+  "Filter review queue by knowledge context"
+).action(async (opts) => {
   let db;
   try {
     db = await openDatabase();
     const userId = await resolveUser(opts, db);
+    let resolvedContext;
+    if (opts.knowledgeContext) {
+      const context = await getKnowledgeContextByName(
+        db,
+        opts.knowledgeContext
+      );
+      if (!context) {
+        throw new Error(
+          `Knowledge context not found: ${opts.knowledgeContext}`
+        );
+      }
+      resolvedContext = context.name;
+    }
     const queue = await buildReviewQueue(db, {
       userId,
       maxNew: Number(opts.maxNew),
-      maxReviews: Number(opts.maxReviews)
+      maxReviews: Number(opts.maxReviews),
+      knowledgeContext: resolvedContext
     });
     if (queue.items.length === 0) {
       console.log("No cards due for review. You're all caught up!");
@@ -17366,6 +18391,9 @@ var reviewCommand = new Command14("review").description("Start an interactive re
     }
     console.log(`
 Review session: ${queue.items.length} card(s)`);
+    if (resolvedContext) {
+      console.log(`  Context: ${resolvedContext}`);
+    }
     console.log(
       `  New: ${queue.newCount}  Review: ${queue.reviewCount}  Relearn: ${queue.relearnCount}`
     );
@@ -17463,8 +18491,8 @@ ${"\u2550".repeat(50)}`);
 // src/cli/commands/session.ts
 import { readFileSync as readFileSync13 } from "fs";
 import { input as input6, select as select2 } from "@inquirer/prompts";
-import { Command as Command15 } from "commander";
-var sessionCommand = new Command15("session").description(
+import { Command as Command16 } from "commander";
+var sessionCommand = new Command16("session").description(
   "Manage learning sessions"
 );
 sessionCommand.command("start").description("Start a new learning session (review \u2192 task)").option("--user <id>", "User ID (default: whoami)").option("--task <description>", "Task description (interactive if omitted)").option(
@@ -17843,8 +18871,8 @@ sessionCommand.command("end").description("End a session and show summary").requ
 
 // src/cli/commands/settings.ts
 import { existsSync as existsSync21 } from "fs";
-import { Command as Command16 } from "commander";
-var settingsCommand = new Command16("settings").description(
+import { Command as Command17 } from "commander";
+var settingsCommand = new Command17("settings").description(
   "Manage user settings"
 );
 var BOOLEAN_SETTING_KEYS = /* @__PURE__ */ new Set(["llm.enabled", "llm.vision.enabled"]);
@@ -18020,7 +19048,7 @@ settingsCommand.command("repos").description("Show or set Personal, Team, and Or
 
 // src/cli/commands/setup.ts
 import { resolve as resolve8 } from "path";
-import { Command as Command17 } from "commander";
+import { Command as Command18 } from "commander";
 function formatDatabaseInitTarget(target) {
   switch (target.kind) {
     case "local":
@@ -18061,7 +19089,7 @@ async function activateMachineProviderConfig(db) {
     `  activate  ${providerCount} machine-local provider(s) from ~/.zam/config.json`
   );
 }
-var setupCommand = new Command17("setup").description(
+var setupCommand = new Command18("setup").description(
   "Link ZAM skill directories into this workspace and initialize the database"
 ).option("--force", "replace an unmanaged existing ZAM skill directory", false).option("--skip-init", "skip database initialization", false).option("--skip-claude-md", "skip CLAUDE.md generation", false).option("--skip-agents-md", "skip AGENTS.md generation", false).option("--target <path>", "repository/workspace directory to set up").option(
   "--agents <list>",
@@ -18115,8 +19143,8 @@ var setupCommand = new Command17("setup").description(
 );
 
 // src/cli/commands/skill.ts
-import { Command as Command18 } from "commander";
-var skillCommand = new Command18("skill").description(
+import { Command as Command19 } from "commander";
+var skillCommand = new Command19("skill").description(
   "Manage agent skill entries (task recipes)"
 );
 skillCommand.command("list").description("List all agent skills").option("--json", "Output as JSON").action(async (opts) => {
@@ -18203,7 +19231,7 @@ skillCommand.command("add").description("Register a new agent skill").requiredOp
 // src/cli/commands/snapshot.ts
 import { existsSync as existsSync22, mkdirSync as mkdirSync13, readFileSync as readFileSync14, writeFileSync as writeFileSync10 } from "fs";
 import { dirname as dirname7, join as join21 } from "path";
-import { Command as Command19 } from "commander";
+import { Command as Command20 } from "commander";
 function defaultOutName() {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d+Z$/, "").replace(/:/g, "-");
   return `zam-snapshot-${stamp}.sql`;
@@ -18217,7 +19245,7 @@ function summarize(tables) {
   }
   return { total, nonEmpty };
 }
-var exportCmd = new Command19("export").description("Write a portable SQL-text snapshot of the database").option("--out <file>", "Output file (use - for stdout)").action(async (opts) => {
+var exportCmd = new Command20("export").description("Write a portable SQL-text snapshot of the database").option("--out <file>", "Output file (use - for stdout)").action(async (opts) => {
   let db;
   try {
     db = await openDatabaseWithSync({ initialize: true });
@@ -18247,7 +19275,7 @@ var exportCmd = new Command19("export").description("Write a portable SQL-text s
     process.exit(1);
   }
 });
-var importCmd = new Command19("import").description("Restore a snapshot into the database").argument("<file>", "Snapshot file to restore").option("--force", "Overwrite a non-empty database", false).action(async (file, opts) => {
+var importCmd = new Command20("import").description("Restore a snapshot into the database").argument("<file>", "Snapshot file to restore").option("--force", "Overwrite a non-empty database", false).action(async (file, opts) => {
   let db;
   try {
     if (!existsSync22(file)) {
@@ -18270,7 +19298,7 @@ var importCmd = new Command19("import").description("Restore a snapshot into the
     process.exit(1);
   }
 });
-var verifyCmd = new Command19("verify").description("Check a snapshot's manifest and checksum without importing").argument("<file>", "Snapshot file to verify").action((file) => {
+var verifyCmd = new Command20("verify").description("Check a snapshot's manifest and checksum without importing").argument("<file>", "Snapshot file to verify").action((file) => {
   try {
     if (!existsSync22(file)) {
       console.error(`Error: Snapshot file not found: ${file}`);
@@ -18288,11 +19316,11 @@ var verifyCmd = new Command19("verify").description("Check a snapshot's manifest
     process.exit(1);
   }
 });
-var snapshotCommand = new Command19("snapshot").description("Export, import, or verify a portable database snapshot").addCommand(exportCmd).addCommand(importCmd).addCommand(verifyCmd);
+var snapshotCommand = new Command20("snapshot").description("Export, import, or verify a portable database snapshot").addCommand(exportCmd).addCommand(importCmd).addCommand(verifyCmd);
 
 // src/cli/commands/stats.ts
-import { Command as Command20 } from "commander";
-var statsCommand = new Command20("stats").description("Show learning dashboard for a user").option("--user <id>", "User ID (default: whoami)").option("--json", "Output as JSON").action(async (opts) => {
+import { Command as Command21 } from "commander";
+var statsCommand = new Command21("stats").description("Show learning dashboard for a user").option("--user <id>", "User ID (default: whoami)").option("--json", "Output as JSON").action(async (opts) => {
   await withDb(async (db) => {
     const userId = await resolveUser(opts, db);
     const stats = await getUserStats(db, userId);
@@ -18328,11 +19356,19 @@ var statsCommand = new Command20("stats").description("Show learning dashboard f
 });
 
 // src/cli/commands/token.ts
-import { Command as Command21 } from "commander";
-var tokenCommand = new Command21("token").description(
+import { Command as Command22 } from "commander";
+var tokenCommand = new Command22("token").description(
   "Manage knowledge tokens"
 );
-tokenCommand.command("register").description("Register a new knowledge token").requiredOption("--slug <slug>", "Unique token slug").requiredOption("--concept <concept>", "Concept description").option("--domain <domain>", "Knowledge domain", "").option("--bloom <level>", "Bloom taxonomy level (1-5)", "1").option("--source-link <link>", "Source file path or reference URL", "").option("--question <question>", "Specific question prompt for recall", "").option("--user <id>", "Owner of the personal card (default: whoami)").option("--no-card", "Register the token only; do not create a personal card").option("--json", "Output as JSON").option("--quiet", "Suppress output (exit code only)").action(async (opts) => {
+tokenCommand.command("register").description("Register a new knowledge token").requiredOption("--slug <slug>", "Unique token slug").requiredOption("--concept <concept>", "Concept description").option("--domain <domain>", "Knowledge domain", "").option("--bloom <level>", "Bloom taxonomy level (1-5)", "1").option("--source-link <link>", "Source file path or reference URL", "").option("--question <question>", "Specific question prompt for recall", "").option(
+  "--knowledge-context <context>",
+  "Assign token to a knowledge context (repeatable)",
+  (val, memo) => {
+    memo.push(val);
+    return memo;
+  },
+  []
+).option("--user <id>", "Owner of the personal card (default: whoami)").option("--no-card", "Register the token only; do not create a personal card").option("--json", "Output as JSON").option("--quiet", "Suppress output (exit code only)").action(async (opts) => {
   await withDb(async (db) => {
     let question = opts.question || null;
     if (!question) {
@@ -18342,6 +19378,10 @@ tokenCommand.command("register").description("Register a new knowledge token").r
         opts.domain
       );
     }
+    const assignedContexts = await resolveOperationKnowledgeContexts(
+      db,
+      opts.knowledgeContext || []
+    );
     const possibleDuplicates = await findPossibleDuplicates(db, {
       concept: opts.concept,
       question,
@@ -18355,6 +19395,9 @@ tokenCommand.command("register").description("Register a new knowledge token").r
       source_link: opts.sourceLink || null,
       question
     });
+    for (const context of assignedContexts) {
+      await assignTokenToContext(db, token.id, context.id);
+    }
     let cardUserId = null;
     if (opts.card !== false) {
       cardUserId = opts.user ?? await getSetting(db, "user.id");
@@ -18373,7 +19416,12 @@ tokenCommand.command("register").description("Register a new knowledge token").r
           {
             ...token,
             card: cardUserId ? { userId: cardUserId } : null,
-            possible_duplicates: possibleDuplicates
+            possible_duplicates: possibleDuplicates,
+            knowledgeContexts: assignedContexts.map((c) => ({
+              name: c.name,
+              label: c.label,
+              language: c.language
+            }))
           },
           null,
           2
@@ -18389,6 +19437,11 @@ tokenCommand.command("register").description("Register a new knowledge token").r
       console.log(`  Domain:   ${token.domain || "(none)"}`);
       console.log(`  Bloom:    ${token.bloom_level}`);
       console.log(`  Question: ${token.question}`);
+      if (assignedContexts.length > 0) {
+        console.log(
+          `  Contexts: ${assignedContexts.map((c) => c.name).join(", ")}`
+        );
+      }
       if (token.source_link) {
         console.log(`  Source:   ${token.source_link}`);
       }
@@ -18495,11 +19548,15 @@ tokenCommand.command("find").description("Fuzzy search for tokens").requiredOpti
     console.log("\n(Use slug for CLI commands -- slugs are technical IDs)");
   });
 });
-tokenCommand.command("list").description("List all tokens").option("--domain <domain>", "Filter by domain").option("--json", "Output as JSON").option("--quiet", "Suppress output (exit code only)").action(async (opts) => {
+tokenCommand.command("list").description("List all tokens").option("--domain <domain>", "Filter by domain").option("--knowledge-context <context>", "Filter by knowledge context").option("--json", "Output as JSON").option("--quiet", "Suppress output (exit code only)").action(async (opts) => {
   await withDb(async (db) => {
+    const filterOpts = {};
+    if (opts.domain) filterOpts.domain = opts.domain;
+    if (opts.knowledgeContext)
+      filterOpts.knowledgeContext = opts.knowledgeContext;
     const tokens = await listTokens(
       db,
-      opts.domain ? { domain: opts.domain } : void 0
+      Object.keys(filterOpts).length ? filterOpts : void 0
     );
     if (opts.quiet) return;
     if (opts.json) {
@@ -18797,7 +19854,7 @@ import { existsSync as existsSync23 } from "fs";
 import { homedir as homedir12 } from "os";
 import { dirname as dirname8, join as join22 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { Command as Command22 } from "commander";
+import { Command as Command23 } from "commander";
 var C3 = {
   reset: "\x1B[0m",
   red: "\x1B[31m",
@@ -18977,7 +20034,7 @@ function createShortcuts(appPath, repoRoot) {
     console.error(`${C3.red}\u2717 Could not create shortcuts.${C3.reset}`);
   }
 }
-var uiCommand = new Command22("ui").description("Launch the ZAM Desktop GUI (Active-Recall Studio)").option("--dev", "Run in hot-reload development mode (needs Rust)").option(
+var uiCommand = new Command23("ui").description("Launch the ZAM Desktop GUI (Active-Recall Studio)").option("--dev", "Run in hot-reload development mode (needs Rust)").option(
   "--build",
   "Build the native installer for your OS (needs Rust, one-time)"
 ).option("--shortcut", "Create Desktop + Start-menu shortcuts to the GUI").action((opts) => {
@@ -19085,7 +20142,7 @@ import { existsSync as existsSync24, readFileSync as readFileSync15, realpathSyn
 import { dirname as dirname9, join as join23 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { confirm as confirm3 } from "@inquirer/prompts";
-import { Command as Command23 } from "commander";
+import { Command as Command24 } from "commander";
 var GITHUB_REPO = "zam-os/zam";
 var CHANNELS = [
   "developer",
@@ -19163,7 +20220,7 @@ function render2(decision) {
     );
   }
 }
-var checkCmd = new Command23("check").description("Check whether a newer ZAM has been released").option(
+var checkCmd = new Command24("check").description("Check whether a newer ZAM has been released").option(
   "--latest <version>",
   "Compare against this version instead of fetching"
 ).option("--channel <channel>", "Override the detected install channel").option("--json", "Output as JSON").action(
@@ -19330,7 +20387,7 @@ ${C4.dim}This install updates through the desktop app's signed updater \u2014 op
     process.exit(1);
   }
 }
-var updateCommand = new Command23("update").description(
+var updateCommand = new Command24("update").description(
   "Update ZAM to the latest release (use `update check` to only check)"
 ).option("-y, --yes", "Apply without confirmation").option(
   "--force",
@@ -19340,8 +20397,8 @@ var updateCommand = new Command23("update").description(
 }).addCommand(checkCmd);
 
 // src/cli/commands/whoami.ts
-import { Command as Command24 } from "commander";
-var whoamiCommand = new Command24("whoami").description("Show or set the default user identity").option("--set <id>", "Set the default user ID").option("--clear", "Remove the default user ID").option("--json", "Output as JSON").action(async (opts) => {
+import { Command as Command25 } from "commander";
+var whoamiCommand = new Command25("whoami").description("Show or set the default user identity").option("--set <id>", "Set the default user ID").option("--clear", "Remove the default user ID").option("--json", "Output as JSON").action(async (opts) => {
   await withDb(async (db) => {
     if (opts.set) {
       await setSetting(db, "user.id", opts.set);
@@ -19382,7 +20439,7 @@ import { existsSync as existsSync25, writeFileSync as writeFileSync11 } from "fs
 import { homedir as homedir13 } from "os";
 import { join as join24, resolve as resolve9 } from "path";
 import { confirm as confirm4, input as input7 } from "@inquirer/prompts";
-import { Command as Command25 } from "commander";
+import { Command as Command26 } from "commander";
 function runGit2(cwd, args) {
   try {
     return execFileSync4("git", args, {
@@ -19400,7 +20457,7 @@ function ghRepoCreateArgs(repoName, repoVisibility) {
 function gitRemoteArgs(githubUrl, hasOrigin) {
   return hasOrigin ? ["remote", "set-url", "origin", githubUrl] : ["remote", "add", "origin", githubUrl];
 }
-var workspaceCommand = new Command25("workspace").description(
+var workspaceCommand = new Command26("workspace").description(
   "Manage your ZAM learning workspace"
 );
 var WORKSPACE_KINDS = [
@@ -19755,13 +20812,14 @@ var __dirname = dirname10(fileURLToPath5(import.meta.url));
 var pkg = JSON.parse(
   readFileSync16(join25(__dirname, "..", "..", "package.json"), "utf-8")
 );
-var program = new Command26();
+var program = new Command27();
 program.name("zam").description(
   "The Symbiotic Learning Kernel: Elevating Human Intelligence through AI Collaboration."
 ).version(pkg.version);
 program.addCommand(initCommand);
 program.addCommand(setupCommand);
 program.addCommand(tokenCommand);
+program.addCommand(knowledgeContextCommand);
 program.addCommand(doctorCommand);
 program.addCommand(cardCommand);
 program.addCommand(sessionCommand);