@cortexkit/magic-context 0.25.0 → 0.26.0

package/dist/index.js

@@ -12212,6 +12212,622 @@ var init_migrate = __esm(async () => {
   await init_sqlite();
 });
 
+// ../plugin/src/features/magic-context/memory/project-identity.ts
+import { execFileSync as execFileSync3 } from "node:child_process";
+import { createHash } from "node:crypto";
+import { statSync as statSync3 } from "node:fs";
+import path2 from "node:path";
+function asError(error) {
+  return error instanceof Error ? error : undefined;
+}
+function getErrorCode(error) {
+  if (error === null || typeof error !== "object" || !("code" in error)) {
+    return;
+  }
+  const code = error.code;
+  return typeof code === "string" ? code : undefined;
+}
+function getErrorSignal(error) {
+  if (error === null || typeof error !== "object" || !("signal" in error)) {
+    return;
+  }
+  const signal = error.signal;
+  return typeof signal === "string" ? signal : undefined;
+}
+function getErrorKilled(error) {
+  if (error === null || typeof error !== "object" || !("killed" in error)) {
+    return false;
+  }
+  return error.killed === true;
+}
+function getErrorStderr(error) {
+  if (error === null || typeof error !== "object" || !("stderr" in error)) {
+    return "";
+  }
+  const stderr = error.stderr;
+  if (typeof stderr === "string") {
+    return stderr;
+  }
+  if (Buffer.isBuffer(stderr)) {
+    return stderr.toString("utf8");
+  }
+  return "";
+}
+function directoryFallback(directory) {
+  const canonical = path2.resolve(directory);
+  const hash = createHash("md5").update(canonical, "utf8").digest("hex").slice(0, 12);
+  return `dir:${hash}`;
+}
+function assertDirectoryUsable(canonicalDirectory, rawDirectory) {
+  try {
+    const stat = statSync3(canonicalDirectory);
+    if (!stat.isDirectory()) {
+      throw new ProjectIdentityError("unknown", rawDirectory, `Project path is not a directory: ${canonicalDirectory}`);
+    }
+  } catch (error) {
+    if (error instanceof ProjectIdentityError) {
+      throw error;
+    }
+    const code = getErrorCode(error);
+    if (code === "EACCES" || code === "EPERM") {
+      throw new ProjectIdentityError("permission_denied", rawDirectory, `Permission denied while accessing project directory: ${canonicalDirectory}`, asError(error));
+    }
+    throw new ProjectIdentityError("unknown", rawDirectory, `Unable to access project directory: ${canonicalDirectory}`, asError(error));
+  }
+}
+function isGitTimeoutError(error) {
+  const code = getErrorCode(error);
+  const signal = getErrorSignal(error);
+  return code === "ETIMEDOUT" || signal === "SIGTERM" || signal === "SIGKILL" || getErrorKilled(error);
+}
+function classifyGitError(error, rawDirectory) {
+  if (isGitTimeoutError(error)) {
+    return new ProjectIdentityError("git_timeout", rawDirectory, `git rev-list timed out after ${GIT_TIMEOUT_MS}ms`, asError(error));
+  }
+  const code = getErrorCode(error);
+  if (code === "ENOENT") {
+    return new ProjectIdentityError("git_missing", rawDirectory, "git binary is not available in PATH", asError(error));
+  }
+  if (code === "EACCES" || code === "EPERM") {
+    return new ProjectIdentityError("permission_denied", rawDirectory, "Permission denied while spawning git", asError(error));
+  }
+  const stderr = getErrorStderr(error).toLowerCase();
+  if (stderr.includes("not a git repository") || stderr.includes("does not have any commits yet") || stderr.includes("ambiguous argument 'head'") || stderr.includes("unknown revision or path")) {
+    return new ProjectIdentityError("not_git_repo", rawDirectory, "Directory has no git root commit; caller may use directory fallback", asError(error));
+  }
+  return new ProjectIdentityError("unknown", rawDirectory, "git rev-list failed while resolving project identity", asError(error));
+}
+function resolveProjectIdentityStrict(directory) {
+  const canonical = path2.resolve(directory);
+  const cached = identityCache.get(canonical);
+  if (cached !== undefined) {
+    return cached;
+  }
+  assertDirectoryUsable(canonical, directory);
+  let output;
+  try {
+    output = execFileSync3("git", ["rev-list", "--max-parents=0", "HEAD"], {
+      cwd: canonical,
+      encoding: "utf8",
+      env: { ...process.env, LC_ALL: "C", LANG: "C" },
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: GIT_TIMEOUT_MS
+    });
+  } catch (error) {
+    throw classifyGitError(error, directory);
+  }
+  const firstLine = output.split(`
+`)[0]?.trim() ?? "";
+  const rootCommit = firstLine.slice(0, 64);
+  if (rootCommit.length < 7) {
+    throw new ProjectIdentityError("unknown", directory, "git rev-list returned no valid root commit hash");
+  }
+  const identity = `git:${rootCommit}`;
+  identityCache.set(canonical, identity);
+  return identity;
+}
+function shouldUseDirectoryFallback(error) {
+  return error.errorClass === "not_git_repo" || error.errorClass === "unknown" && error.message.startsWith("Unable to access project directory:");
+}
+function resolveProjectIdentity(directory) {
+  const canonical = path2.resolve(directory);
+  const cachedFallback = directoryFallbackCache.get(canonical);
+  if (cachedFallback !== undefined) {
+    if (!hasGitDir(canonical)) {
+      return cachedFallback;
+    }
+    directoryFallbackCache.delete(canonical);
+  }
+  try {
+    return resolveProjectIdentityStrict(directory);
+  } catch (error) {
+    if (error instanceof ProjectIdentityError && shouldUseDirectoryFallback(error)) {
+      const fallback = directoryFallback(canonical);
+      if (!hasGitDir(canonical)) {
+        directoryFallbackCache.set(canonical, fallback);
+      }
+      return fallback;
+    }
+    throw error;
+  }
+}
+function hasGitDir(canonical) {
+  try {
+    statSync3(path2.join(canonical, ".git"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+var GIT_TIMEOUT_MS = 5000, identityCache, directoryFallbackCache, ProjectIdentityError;
+var init_project_identity = __esm(() => {
+  identityCache = new Map;
+  directoryFallbackCache = new Map;
+  ProjectIdentityError = class ProjectIdentityError extends Error {
+    errorClass;
+    rawDirectory;
+    constructor(errorClass, rawDirectory, message, cause) {
+      super(message);
+      this.name = "ProjectIdentityError";
+      this.errorClass = errorClass;
+      this.rawDirectory = rawDirectory;
+      if (cause) {
+        this.cause = cause;
+      }
+    }
+  };
+});
+
+// ../plugin/src/features/magic-context/memory/relocate-memory.ts
+function selectRelocatableMemoryIds(db, fromProjectPath, selection = {}) {
+  const statuses = selection.statuses ?? DEFAULT_STATUSES;
+  if (statuses.length === 0)
+    return [];
+  const statusPlaceholders = statuses.map(() => "?").join(", ");
+  const params = [fromProjectPath, ...statuses];
+  let sql = `SELECT id FROM memories WHERE project_path = ? AND status IN (${statusPlaceholders})`;
+  if (selection.sourceSessionId !== undefined) {
+    sql += " AND source_session_id = ?";
+    params.push(selection.sourceSessionId);
+  }
+  sql += " ORDER BY id ASC";
+  const rows = db.prepare(sql).all(...params);
+  return rows.map((row) => row.id);
+}
+function rekeyMemoryRowWithCollisionMerge(db, rowId, fromProjectPath, toIdentity) {
+  const row = db.prepare("SELECT category, normalized_hash, seen_count FROM memories WHERE id = ?").get(rowId);
+  if (!row)
+    return false;
+  const collision = db.prepare(`SELECT id, seen_count FROM memories
+             WHERE project_path = ? AND category = ? AND normalized_hash = ?
+             LIMIT 1`).get(toIdentity, row.category, row.normalized_hash);
+  if (collision && collision.id !== rowId) {
+    const mergedSeen = Math.max(collision.seen_count ?? 1, row.seen_count ?? 1);
+    if (mergedSeen !== (collision.seen_count ?? 1)) {
+      db.prepare("UPDATE memories SET seen_count = ? WHERE id = ?").run(mergedSeen, collision.id);
+    }
+    db.prepare(`INSERT OR IGNORE INTO memory_embeddings (memory_id, embedding, model_id)
+             SELECT ?, embedding, model_id FROM memory_embeddings WHERE memory_id = ?`).run(collision.id, rowId);
+    db.prepare("DELETE FROM memories WHERE id = ?").run(rowId);
+    return true;
+  }
+  const result = db.prepare("UPDATE memories SET project_path = ? WHERE id = ? AND project_path = ?").run(toIdentity, rowId, fromProjectPath);
+  return (result.changes ?? 0) > 0;
+}
+function moveMemoriesToProject(db, ids, fromProjectPath, toIdentity) {
+  let relocated = 0;
+  let merged = 0;
+  for (const id of ids) {
+    const row = db.prepare("SELECT category, normalized_hash FROM memories WHERE id = ?").get(id);
+    if (!row)
+      continue;
+    const collision = db.prepare(`SELECT id FROM memories WHERE project_path = ? AND category = ? AND normalized_hash = ? LIMIT 1`).get(toIdentity, row.category, row.normalized_hash);
+    const changed = rekeyMemoryRowWithCollisionMerge(db, id, fromProjectPath, toIdentity);
+    if (!changed)
+      continue;
+    if (collision && collision.id !== id)
+      merged += 1;
+    else
+      relocated += 1;
+  }
+  return { relocated, merged, skipped: 0 };
+}
+function getMemoryCopyColumns(db) {
+  const cached = memoryCopyColumnsCache.get(db);
+  if (cached)
+    return cached;
+  const columns = db.prepare("PRAGMA table_info(memories)").all();
+  const names = columns.map((c2) => c2.name).filter((n) => typeof n === "string" && n !== "id");
+  memoryCopyColumnsCache.set(db, names);
+  return names;
+}
+function copyMemoriesToProject(db, ids, toIdentity) {
+  const columns = getMemoryCopyColumns(db);
+  const selectExprs = columns.map((c2) => c2 === "project_path" ? "? AS project_path" : c2);
+  const insertSql = `INSERT OR IGNORE INTO memories (${columns.join(", ")})
+        SELECT ${selectExprs.join(", ")} FROM memories WHERE id = ?`;
+  const insertStmt = db.prepare(insertSql);
+  const copyEmbeddingStmt = db.prepare(`INSERT OR IGNORE INTO memory_embeddings (memory_id, embedding, model_id)
+         SELECT ?, embedding, model_id FROM memory_embeddings WHERE memory_id = ?`);
+  let relocated = 0;
+  let skipped = 0;
+  for (const id of ids) {
+    const result = insertStmt.run(toIdentity, id);
+    if ((result.changes ?? 0) > 0) {
+      relocated += 1;
+      copyEmbeddingStmt.run(Number(result.lastInsertRowid), id);
+    } else {
+      skipped += 1;
+    }
+  }
+  return { relocated, merged: 0, skipped };
+}
+var DEFAULT_STATUSES, memoryCopyColumnsCache;
+var init_relocate_memory = __esm(() => {
+  DEFAULT_STATUSES = ["active", "permanent"];
+  memoryCopyColumnsCache = new WeakMap;
+});
+
+// ../plugin/src/features/magic-context/storage-project-state.ts
+function toProjectState(row) {
+  return {
+    projectPath: row.project_path,
+    projectMemoryEpoch: row.project_memory_epoch,
+    projectUserProfileVersion: row.project_user_profile_version,
+    updatedAt: row.updated_at
+  };
+}
+function getProjectState(db, projectPath) {
+  const row = db.prepare(`SELECT project_path, project_memory_epoch, project_user_profile_version, updated_at
+             FROM project_state
+             WHERE project_path = ?`).get(projectPath);
+  return row ? toProjectState(row) : null;
+}
+function bumpProjectMemoryEpoch(db, projectPath, now = Date.now()) {
+  db.prepare(`INSERT INTO project_state
+            (project_path, project_memory_epoch, project_user_profile_version, updated_at)
+         VALUES (?, 1, 0, ?)
+         ON CONFLICT(project_path) DO UPDATE SET
+            project_memory_epoch = project_memory_epoch + 1,
+            updated_at = excluded.updated_at`).run(projectPath, now);
+  const state = getProjectState(db, projectPath);
+  if (!state) {
+    throw new Error(`Failed to bump project memory epoch for ${projectPath}`);
+  }
+  return state;
+}
+
+// src/commands/migrate-session.ts
+var exports_migrate_session = {};
+__export(exports_migrate_session, {
+  runMigrateSessionCli: () => runMigrateSessionCli,
+  planMigrateSession: () => planMigrateSession,
+  applyMigrateSession: () => applyMigrateSession
+});
+import { copyFileSync, existsSync as existsSync11, realpathSync } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import path3, { join as join10 } from "node:path";
+function existingSessionColumns(db) {
+  const rows = db.prepare("PRAGMA table_info(session)").all();
+  return new Set(rows.map((r) => r.name).filter((n) => typeof n === "string"));
+}
+function planMigrateSession(sessionId, rawTargetDirectory, deps) {
+  const sessionRow = deps.opencodeDb.prepare("SELECT id, directory FROM session WHERE id = ?").get(sessionId);
+  if (!sessionRow) {
+    throw new Error(`Session ${sessionId} not found in opencode.db.`);
+  }
+  const targetDirectory = deps.realpath(rawTargetDirectory);
+  const targetIsGit = deps.hasGitDir(targetDirectory);
+  const projectRow = deps.opencodeDb.prepare("SELECT id, worktree FROM project WHERE worktree = ?").get(targetDirectory);
+  let ocProjectId;
+  let ocWorktree;
+  const ocProjectResolvedFromRow = projectRow != null;
+  if (projectRow) {
+    ocProjectId = projectRow.id;
+    ocWorktree = projectRow.worktree;
+  } else {
+    const globalRow = deps.opencodeDb.prepare("SELECT id, worktree FROM project WHERE id = 'global'").get();
+    if (!globalRow) {
+      throw new Error(`The OpenCode 'global' project row is missing.
+` + "Open any folder in OpenCode once to create it, then re-run.");
+    }
+    ocProjectId = "global";
+    ocWorktree = globalRow.worktree || "/";
+  }
+  const sessionPath = path3.relative(ocWorktree, targetDirectory);
+  const ownershipRow = deps.contextDb.prepare("SELECT project_path FROM session_projects WHERE session_id = ? AND harness = 'opencode'").get(sessionId);
+  const fromMcIdentity = ownershipRow?.project_path ?? (sessionRow.directory ? deps.resolveIdentity(sessionRow.directory) : "");
+  const toMcIdentity = deps.resolveIdentity(targetDirectory);
+  const injectableMemoryCount = deps.contextDb.prepare("SELECT COUNT(*) AS c FROM memories WHERE project_path = ? AND status IN ('active','permanent')").get(fromMcIdentity).c;
+  const originatedMemoryCount = deps.contextDb.prepare("SELECT COUNT(*) AS c FROM memories WHERE project_path = ? AND status IN ('active','permanent') AND source_session_id = ?").get(fromMcIdentity, sessionId).c;
+  return {
+    sessionId,
+    currentDirectory: sessionRow.directory,
+    targetDirectory,
+    ocProjectId,
+    ocWorktree,
+    ocProjectResolvedFromRow,
+    sessionPath,
+    fromMcIdentity,
+    toMcIdentity,
+    targetIsGit,
+    injectableMemoryCount,
+    originatedMemoryCount
+  };
+}
+function applyMigrateSession(plan, memoryAction, deps) {
+  const now = deps.now ?? Date.now();
+  const cols = existingSessionColumns(deps.opencodeDb);
+  const sets = ["directory = ?"];
+  const params = [plan.targetDirectory];
+  if (cols.has("project_id")) {
+    sets.push("project_id = ?");
+    params.push(plan.ocProjectId);
+  }
+  if (cols.has("path")) {
+    sets.push("path = ?");
+    params.push(plan.sessionPath);
+  }
+  if (cols.has("workspace_id")) {
+    sets.push("workspace_id = ?");
+    params.push(null);
+  }
+  const restoreCols = ["directory", ...sets.map((s) => s.split(" = ")[0]).slice(1)];
+  const priorRow = deps.opencodeDb.prepare(`SELECT ${restoreCols.join(", ")} FROM session WHERE id = ?`).get(plan.sessionId);
+  deps.opencodeDb.exec("BEGIN IMMEDIATE");
+  try {
+    deps.opencodeDb.prepare(`UPDATE session SET ${sets.join(", ")} WHERE id = ?`).run(...params, plan.sessionId);
+    deps.opencodeDb.exec("COMMIT");
+  } catch (error) {
+    deps.opencodeDb.exec("ROLLBACK");
+    throw error;
+  }
+  const compensateOpenCode = () => {
+    if (!priorRow)
+      return;
+    try {
+      const restoreSets = restoreCols.map((c2) => `${c2} = ?`).join(", ");
+      const restoreParams = restoreCols.map((c2) => priorRow[c2] ?? null);
+      deps.opencodeDb.exec("BEGIN IMMEDIATE");
+      deps.opencodeDb.prepare(`UPDATE session SET ${restoreSets} WHERE id = ?`).run(...restoreParams, plan.sessionId);
+      deps.opencodeDb.exec("COMMIT");
+    } catch {
+      try {
+        deps.opencodeDb.exec("ROLLBACK");
+      } catch {}
+    }
+  };
+  let memoriesRelocated = 0;
+  let memoriesMerged = 0;
+  let memoriesSkipped = 0;
+  let chunkEmbeddingsRestamped = 0;
+  const epochsBumped = [];
+  deps.contextDb.exec("BEGIN IMMEDIATE");
+  try {
+    deps.contextDb.prepare(`INSERT INTO session_projects (session_id, harness, project_path, updated_at)
+                 VALUES (?, 'opencode', ?, ?)
+                 ON CONFLICT(session_id, harness)
+                 DO UPDATE SET project_path = excluded.project_path, updated_at = excluded.updated_at`).run(plan.sessionId, plan.toMcIdentity, now);
+    const chunkResult = deps.contextDb.prepare("UPDATE compartment_chunk_embeddings SET project_path = ? WHERE session_id = ?").run(plan.toMcIdentity, plan.sessionId);
+    chunkEmbeddingsRestamped = chunkResult.changes ?? 0;
+    deps.contextDb.prepare("UPDATE session_meta SET cached_m0_bytes = NULL, cached_m1_bytes = NULL WHERE session_id = ?").run(plan.sessionId);
+    if (memoryAction !== "leave" && plan.fromMcIdentity && plan.fromMcIdentity !== plan.toMcIdentity) {
+      const originatedOnly = memoryAction === "move-originated" || memoryAction === "copy-originated";
+      const ids = selectRelocatableMemoryIds(deps.contextDb, plan.fromMcIdentity, originatedOnly ? { sourceSessionId: plan.sessionId } : {});
+      const isMove = memoryAction === "move-all" || memoryAction === "move-originated";
+      const result = isMove ? moveMemoriesToProject(deps.contextDb, ids, plan.fromMcIdentity, plan.toMcIdentity) : copyMemoriesToProject(deps.contextDb, ids, plan.toMcIdentity);
+      memoriesRelocated = result.relocated;
+      memoriesMerged = result.merged;
+      memoriesSkipped = result.skipped;
+      if (result.relocated > 0 || result.merged > 0) {
+        bumpProjectMemoryEpoch(deps.contextDb, plan.toMcIdentity, now);
+        epochsBumped.push(plan.toMcIdentity);
+        if (isMove) {
+          bumpProjectMemoryEpoch(deps.contextDb, plan.fromMcIdentity, now);
+          epochsBumped.push(plan.fromMcIdentity);
+        }
+      }
+    }
+    deps.contextDb.exec("COMMIT");
+  } catch (error) {
+    deps.contextDb.exec("ROLLBACK");
+    compensateOpenCode();
+    throw error;
+  }
+  return {
+    plan,
+    memoryAction,
+    dryRun: false,
+    memoriesRelocated,
+    memoriesMerged,
+    memoriesSkipped,
+    chunkEmbeddingsRestamped,
+    epochsBumped
+  };
+}
+function defaultOpenCodeDbPath2() {
+  return join10(homedir7(), ".local", "share", "opencode", "opencode.db");
+}
+function defaultContextDbPath() {
+  return join10(getMagicContextStorageDir(), "context.db");
+}
+function realDeps(opencodeDb, contextDb) {
+  return {
+    opencodeDb,
+    contextDb,
+    resolveIdentity: resolveProjectIdentity,
+    hasGitDir: (dir) => existsSync11(join10(dir, ".git")),
+    realpath: (p2) => realpathSync(p2)
+  };
+}
+function valueAfter(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1)
+    return null;
+  const next = args[index + 1];
+  if (next === undefined || next.startsWith("--"))
+    return null;
+  return next;
+}
+function printMigrateSessionHelp() {
+  console.log("");
+  console.log("  doctor migrate-session — re-home an OpenCode session to another directory");
+  console.log("");
+  console.log("  Required:");
+  console.log("    --session <id>     OpenCode session id (ses_...)");
+  console.log("    --to <dir>         Target working directory");
+  console.log("");
+  console.log("  Optional:");
+  console.log("    --memories <a>     Non-interactive memory action:");
+  console.log("                       move-all | move-originated | copy-all |");
+  console.log("                       copy-originated | leave");
+  console.log("    --dry-run          Show the plan; write nothing");
+  console.log("    --yes              Skip the 'OpenCode stopped?' confirmation");
+  console.log("");
+  console.log("  Example:");
+  console.log("    npx @cortexkit/magic-context@latest doctor migrate-session \\");
+  console.log("        --session ses_xxx --to ~/Work/Projects/CortexKit/benchmarks --dry-run");
+  console.log("");
+}
+async function promptMemoryAction(plan) {
+  const all = plan.injectableMemoryCount;
+  const originated = plan.originatedMemoryCount;
+  promptIO.note(`${all} memory${all === 1 ? "" : "ies"} live under the current project ` + `(${plan.fromMcIdentity}); ${originated} of them originated from this session.`, "Memories");
+  const choice = await promptIO.selectOne("How should memories be handled?", [
+    {
+      label: `Move only memories originated from this session (${originated})`,
+      value: "move-originated",
+      recommended: true
+    },
+    { label: `Move all memories of this project (${all})`, value: "move-all" },
+    {
+      label: `Copy only memories originated from this session (${originated})`,
+      value: "copy-originated"
+    },
+    { label: `Copy all memories of this project (${all})`, value: "copy-all" },
+    { label: "Leave memories as is", value: "leave" }
+  ]);
+  return choice;
+}
+async function runMigrateSessionCli(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    printMigrateSessionHelp();
+    return 0;
+  }
+  const sessionId = valueAfter(args, "--session");
+  const toDir = valueAfter(args, "--to");
+  const dryRun = args.includes("--dry-run");
+  const skipConfirm = args.includes("--yes");
+  const memoriesFlag = valueAfter(args, "--memories");
+  if (!sessionId) {
+    console.error("Missing required flag: --session <id>");
+    printMigrateSessionHelp();
+    return 1;
+  }
+  if (!toDir) {
+    console.error("Missing required flag: --to <dir>");
+    printMigrateSessionHelp();
+    return 1;
+  }
+  if (memoriesFlag !== null && !VALID_MEMORY_ACTIONS.has(memoriesFlag)) {
+    console.error(`Invalid --memories value: ${memoriesFlag}`);
+    printMigrateSessionHelp();
+    return 1;
+  }
+  const expandedTo = toDir.startsWith("~") ? join10(homedir7(), toDir.slice(1).replace(/^[/\\]/, "")) : toDir;
+  if (!existsSync11(expandedTo)) {
+    console.error(`Target directory does not exist: ${expandedTo}`);
+    return 1;
+  }
+  const opencodeDbPath = defaultOpenCodeDbPath2();
+  const contextDbPath = defaultContextDbPath();
+  const opencodeDb = new Database(opencodeDbPath);
+  const contextDb = new Database(contextDbPath);
+  try {
+    const deps = realDeps(opencodeDb, contextDb);
+    const plan = planMigrateSession(sessionId, expandedTo, deps);
+    promptIO.note([
+      `session:        ${plan.sessionId}`,
+      `from:           ${plan.currentDirectory ?? "(unknown)"}`,
+      `to:             ${plan.targetDirectory}`,
+      `OpenCode project: ${plan.ocProjectId}${plan.targetIsGit ? " (git)" : " (global / non-git)"}`,
+      `MC identity:    ${plan.fromMcIdentity}  →  ${plan.toMcIdentity}`
+    ].join(`
+`), "Session move plan");
+    if (plan.targetIsGit && !plan.ocProjectResolvedFromRow) {
+      promptIO.log.warn(`${plan.targetDirectory} is a git repo, but OpenCode has no dedicated project for it ` + `(an empty repo with no commits/remote resolves to the shared 'global' project). ` + `For a dedicated project: make a commit (or add a remote), open OpenCode there once, then re-run.`);
+      if (!dryRun) {
+        if (skipConfirm) {
+          promptIO.log.warn("Proceeding — the session will attach to 'global'.");
+        } else {
+          const proceed = await promptIO.confirm("Proceed attaching the session to the shared 'global' project?", false);
+          if (!proceed) {
+            promptIO.log.warn("Aborted. Make a commit / add a remote, then re-run.");
+            return 1;
+          }
+        }
+      }
+    }
+    const memoryAction = memoriesFlag ?? await promptMemoryAction(plan);
+    if (dryRun) {
+      const willMove = memoryAction === "move-all" || memoryAction === "move-originated";
+      const willCopy = memoryAction === "copy-all" || memoryAction === "copy-originated";
+      const count = memoryAction.endsWith("originated") ? plan.originatedMemoryCount : plan.injectableMemoryCount;
+      promptIO.log.info(`[dry-run] Would update opencode.db session row → project ${plan.ocProjectId}, dir ${plan.targetDirectory}.`);
+      promptIO.log.info(`[dry-run] Would re-stamp session_projects + chunk embeddings to ${plan.toMcIdentity} and clear cached m[0]/m[1].`);
+      promptIO.log.info(`[dry-run] Memories: ${memoryAction === "leave" ? "left as is" : `${willMove ? "move" : willCopy ? "copy" : "?"} ${count}`}.`);
+      promptIO.log.info("[dry-run] No changes written.");
+      return 0;
+    }
+    if (!skipConfirm) {
+      const ok = await promptIO.confirm("This edits opencode.db + context.db directly. Is OpenCode (TUI / Desktop / serve) fully stopped?", false);
+      if (!ok) {
+        promptIO.log.warn("Aborted. Stop OpenCode, then re-run.");
+        return 1;
+      }
+    }
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const ocBackup = `${opencodeDbPath}.bak-${stamp}`;
+    const ctxBackup = `${contextDbPath}.bak-${stamp}`;
+    copyFileSync(opencodeDbPath, ocBackup);
+    copyFileSync(contextDbPath, ctxBackup);
+    promptIO.log.info(`Backed up: ${ocBackup}`);
+    promptIO.log.info(`Backed up: ${ctxBackup}`);
+    const result = applyMigrateSession(plan, memoryAction, deps);
+    promptIO.log.success("Session re-homed.");
+    console.log(`  OpenCode: project ${plan.ocProjectId}, directory ${plan.targetDirectory}`);
+    console.log(`  MC identity: ${plan.fromMcIdentity} → ${plan.toMcIdentity}`);
+    console.log(`  chunk embeddings re-stamped: ${result.chunkEmbeddingsRestamped}`);
+    console.log(`  memories: ${result.memoriesRelocated} ${memoryAction.startsWith("copy") ? "copied" : "moved"}` + (result.memoriesMerged ? `, ${result.memoriesMerged} merged` : "") + (result.memoriesSkipped ? `, ${result.memoriesSkipped} skipped (already present)` : ""));
+    if (result.epochsBumped.length > 0) {
+      console.log(`  memory epoch bumped: ${result.epochsBumped.join(", ")}`);
+    }
+    console.log("Restart OpenCode to pick up the moved session.");
+    return 0;
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return 1;
+  } finally {
+    opencodeDb.close();
+    contextDb.close();
+  }
+}
+var VALID_MEMORY_ACTIONS;
+var init_migrate_session = __esm(async () => {
+  init_project_identity();
+  init_relocate_memory();
+  init_data_path();
+  init_prompts();
+  await init_sqlite();
+  VALID_MEMORY_ACTIONS = new Set([
+    "move-all",
+    "move-originated",
+    "copy-all",
+    "copy-originated",
+    "leave"
+  ]);
+});
+
 // ../plugin/src/features/magic-context/compartment-lease.ts
 var COMPARTMENT_LEASE_TTL_MS, COMPARTMENT_LEASE_RENEWAL_MS;
 var init_compartment_lease = __esm(() => {
@@ -12263,9 +12879,9 @@ var init_compartment_storage = __esm(() => {
 });
 // ../plugin/src/shared/logger.ts
 import * as fs from "node:fs";
-import * as path2 from "node:path";
+import * as path4 from "node:path";
 function ensureDir5(filePath) {
-  const dir = path2.dirname(filePath);
+  const dir = path4.dirname(filePath);
   if (dir === lastEnsuredDir)
     return;
   try {
@@ -144879,13 +145495,14 @@ var init_tool_drop_target = __esm(() => {
 });
 
 // ../plugin/src/hooks/magic-context/read-session-chunk.ts
-var sessionProviders;
+var blockTokenMemo, sessionProviders;
 var init_read_session_chunk = __esm(async () => {
   init_read_session_formatting();
   init_tag_part_guards();
   init_tool_drop_target();
   init_read_session_formatting();
   await init_read_session_db();
+  blockTokenMemo = new Map;
   sessionProviders = new Map;
 });
 
@@ -144908,7 +145525,7 @@ function getErrorMessage(error) {
 }
 
 // ../plugin/src/features/magic-context/key-files/project-key-files.ts
-import { existsSync as existsSync11, readFileSync as readFileSync7, realpathSync } from "node:fs";
+import { existsSync as existsSync12, readFileSync as readFileSync7, realpathSync as realpathSync2 } from "node:fs";
 function deleteOrphanProjectKeyFiles(db, now = Date.now()) {
   const cutoff = now - ORPHAN_GRACE_MS;
   const rows = db.prepare(`SELECT project_path AS projectPath, MAX(generated_at) AS lastGen
@@ -144917,7 +145534,7 @@ function deleteOrphanProjectKeyFiles(db, now = Date.now()) {
              HAVING lastGen < ?`).all(cutoff);
   let deletedProjects = 0;
   for (const row of rows) {
-    if (existsSync11(row.projectPath))
+    if (existsSync12(row.projectPath))
       continue;
     try {
       db.transaction(() => {
@@ -144970,10 +145587,10 @@ var init_tool_definition_tokens = __esm(() => {
 });
 
 // ../plugin/src/features/magic-context/tool-owner-backfill.ts
-import { existsSync as existsSync12 } from "node:fs";
-import { join as join10 } from "node:path";
+import { existsSync as existsSync13 } from "node:fs";
+import { join as join11 } from "node:path";
 function resolveOpencodeDbPath() {
-  return join10(getDataDir(), "opencode", "opencode.db");
+  return join11(getDataDir(), "opencode", "opencode.db");
 }
 function ensureBackfillStateTable(db) {
   db.exec(`
@@ -145008,7 +145625,7 @@ function runToolOwnerBackfill(db) {
     return result;
   }
   const opencodeDbPath = resolveOpencodeDbPath();
-  if (!existsSync12(opencodeDbPath)) {
+  if (!existsSync13(opencodeDbPath)) {
     log2(`[backfill] OpenCode DB not found at ${opencodeDbPath} — marking all unbackfilled sessions as skipped. Lazy adoption (defense-in-depth) handles legacy rows at runtime.`);
     markAllUnbackfilledSessionsSkipped(db);
     result.sessionsSkippedNoOcDb = countSessionsByStatus(db, "skipped");
@@ -145231,26 +145848,26 @@ var init_tool_owner_backfill = __esm(() => {
 });
 
 // ../plugin/src/features/magic-context/storage-db.ts
-import { copyFileSync, cpSync, existsSync as existsSync13, mkdirSync as mkdirSync5 } from "node:fs";
-import { dirname as dirname6, join as join11 } from "node:path";
+import { copyFileSync as copyFileSync2, cpSync, existsSync as existsSync14, mkdirSync as mkdirSync5 } from "node:fs";
+import { dirname as dirname6, join as join12 } from "node:path";
 function resolveDatabasePath(dbPathOverride) {
   if (dbPathOverride) {
     return { dbDir: dirname6(dbPathOverride), dbPath: dbPathOverride };
   }
   const testDataDir = process.env.MAGIC_CONTEXT_TEST_DATA_DIR;
   if (testDataDir && !process.env.XDG_DATA_HOME) {
-    const dbDir2 = join11(testDataDir, "cortexkit", "magic-context");
-    return { dbDir: dbDir2, dbPath: join11(dbDir2, "context.db") };
+    const dbDir2 = join12(testDataDir, "cortexkit", "magic-context");
+    return { dbDir: dbDir2, dbPath: join12(dbDir2, "context.db") };
   }
   const dbDir = getMagicContextStorageDir();
-  return { dbDir, dbPath: join11(dbDir, "context.db") };
+  return { dbDir, dbPath: join12(dbDir, "context.db") };
 }
 function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
-  if (existsSync13(targetDbPath))
+  if (existsSync14(targetDbPath))
     return;
   const legacyDir = getLegacyOpenCodeMagicContextStorageDir();
-  const legacyDbPath = join11(legacyDir, "context.db");
-  if (!existsSync13(legacyDbPath))
+  const legacyDbPath = join12(legacyDir, "context.db");
+  if (!existsSync14(legacyDbPath))
     return;
   log2(`[magic-context] migrating legacy plugin storage: ${legacyDir} -> ${targetDbDir} (legacy left in place as backup)`);
   mkdirSync5(targetDbDir, { recursive: true });
@@ -145266,18 +145883,18 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
   }
   for (const suffix of ["", "-wal", "-shm"]) {
     const src = `${legacyDbPath}${suffix}`;
-    const dst = join11(targetDbDir, `context.db${suffix}`);
-    if (existsSync13(src)) {
+    const dst = join12(targetDbDir, `context.db${suffix}`);
+    if (existsSync14(src)) {
       try {
-        copyFileSync(src, dst);
+        copyFileSync2(src, dst);
       } catch (error) {
         log2(`[magic-context] failed to copy ${src}:`, getErrorMessage(error));
       }
     }
   }
-  const legacyModelsDir = join11(legacyDir, "models");
-  const targetModelsDir = join11(targetDbDir, "models");
-  if (existsSync13(legacyModelsDir) && !existsSync13(targetModelsDir)) {
+  const legacyModelsDir = join12(legacyDir, "models");
+  const targetModelsDir = join12(targetDbDir, "models");
+  if (existsSync14(legacyModelsDir) && !existsSync14(targetModelsDir)) {
     try {
       cpSync(legacyModelsDir, targetModelsDir, { recursive: true });
     } catch (error) {
@@ -145746,6 +146363,8 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       recovery_no_eligible_head_count INTEGER NOT NULL DEFAULT 0,
       force_emergency_bypass_window_start INTEGER NOT NULL DEFAULT 0,
       force_emergency_bypass_used INTEGER NOT NULL DEFAULT 0,
+      emergency_drain_active INTEGER NOT NULL DEFAULT 0,
+      historian_drain_failure_at INTEGER NOT NULL DEFAULT 0,
       cached_m0_materialized_at INTEGER,
       cached_m0_session_facts_version INTEGER,
       cached_m0_upgrade_state TEXT,
@@ -145809,6 +146428,23 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
     CREATE INDEX IF NOT EXISTS idx_historian_runs_status
       ON historian_runs(status, created_at DESC);
 
+    CREATE TABLE IF NOT EXISTS transform_decisions (
+      session_id         TEXT    NOT NULL,
+      harness            TEXT    NOT NULL DEFAULT 'opencode',
+      message_id         TEXT    NOT NULL,
+      ts_ms              INTEGER NOT NULL,
+      decision           TEXT    NOT NULL,
+      materialized       INTEGER NOT NULL DEFAULT 0,
+      materialize_reason TEXT,
+      emergency          INTEGER NOT NULL DEFAULT 0,
+      dropped_tokens     INTEGER NOT NULL DEFAULT 0,
+      dropped_count      INTEGER NOT NULL DEFAULT 0,
+      input_tokens       INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (session_id, harness, message_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_transform_decisions_session_harness
+      ON transform_decisions(session_id, harness);
+
     CREATE INDEX IF NOT EXISTS idx_tags_session_tag_number ON tags(session_id, tag_number);
     CREATE INDEX IF NOT EXISTS idx_tags_session_message_id ON tags(session_id, message_id);
     CREATE INDEX IF NOT EXISTS idx_pending_ops_session ON pending_ops(session_id);
@@ -145960,6 +146596,8 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "session_meta", "recovery_no_eligible_head_count", "INTEGER NOT NULL DEFAULT 0");
   ensureColumn(db, "session_meta", "force_emergency_bypass_window_start", "INTEGER NOT NULL DEFAULT 0");
   ensureColumn(db, "session_meta", "force_emergency_bypass_used", "INTEGER NOT NULL DEFAULT 0");
+  ensureColumn(db, "session_meta", "emergency_drain_active", "INTEGER NOT NULL DEFAULT 0");
+  ensureColumn(db, "session_meta", "historian_drain_failure_at", "INTEGER NOT NULL DEFAULT 0");
   ensureColumn(db, "session_meta", "cached_m0_materialized_at", "INTEGER");
   ensureColumn(db, "session_meta", "cached_m0_session_facts_version", "INTEGER");
   ensureColumn(db, "session_meta", "cached_m0_upgrade_state", "TEXT");
@@ -146038,6 +146676,22 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
         failed_at INTEGER NOT NULL,
         UNIQUE(table_name, row_id)
       );
+      CREATE TABLE IF NOT EXISTS transform_decisions (
+        session_id         TEXT    NOT NULL,
+        harness            TEXT    NOT NULL DEFAULT 'opencode',
+        message_id         TEXT    NOT NULL,
+        ts_ms              INTEGER NOT NULL,
+        decision           TEXT    NOT NULL,
+        materialized       INTEGER NOT NULL DEFAULT 0,
+        materialize_reason TEXT,
+        emergency          INTEGER NOT NULL DEFAULT 0,
+        dropped_tokens     INTEGER NOT NULL DEFAULT 0,
+        dropped_count      INTEGER NOT NULL DEFAULT 0,
+        input_tokens       INTEGER NOT NULL DEFAULT 0,
+        PRIMARY KEY (session_id, harness, message_id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_transform_decisions_session_harness
+        ON transform_decisions(session_id, harness);
     `);
   ensureColumn(db, "tags", "harness", "TEXT NOT NULL DEFAULT 'opencode'");
   ensureColumn(db, "pending_ops", "harness", "TEXT NOT NULL DEFAULT 'opencode'");
@@ -146123,7 +146777,9 @@ function healNullIntegerColumns(db) {
     ["protected_tail_drain_tokens", 0],
     ["recovery_no_eligible_head_count", 0],
     ["force_emergency_bypass_window_start", 0],
-    ["force_emergency_bypass_used", 0]
+    ["force_emergency_bypass_used", 0],
+    ["emergency_drain_active", 0],
+    ["historian_drain_failure_at", 0]
   ];
   for (const [column, fallback] of columns) {
     try {
@@ -146199,6 +146855,7 @@ function openDatabase(dbPathOrOptions) {
     setDatabase(db);
     loadToolDefinitionMeasurements(db);
     databases.set(dbPath, db);
+    pathByDatabase.set(db, dbPath);
     persistenceByDatabase.set(db, true);
     persistenceErrorByDatabase.delete(db);
     return db;
@@ -146224,7 +146881,7 @@ function closeDatabase() {
     }
   }
 }
-var databases, persistenceByDatabase, persistenceErrorByDatabase, lastSchemaFenceRejection = null, LATEST_SUPPORTED_VERSION = 36, sqlitePragmaConfig, CHANNEL2_CLAIM_TTL_MS = 120000;
+var databases, persistenceByDatabase, persistenceErrorByDatabase, pathByDatabase, lastSchemaFenceRejection = null, LATEST_SUPPORTED_VERSION = 38, sqlitePragmaConfig, CHANNEL2_CLAIM_TTL_MS = 120000;
 var init_storage_db = __esm(async () => {
   init_data_path();
   init_logger();
@@ -146238,6 +146895,7 @@ var init_storage_db = __esm(async () => {
   databases = new Map;
   persistenceByDatabase = new WeakMap;
   persistenceErrorByDatabase = new WeakMap;
+  pathByDatabase = new WeakMap;
   sqlitePragmaConfig = {
     cacheSizeMb: 64,
     mmapSizeMb: 0
@@ -146279,172 +146937,6 @@ var init_constants = __esm(() => {
   };
 });
 
-// ../plugin/src/features/magic-context/memory/project-identity.ts
-import { execFileSync as execFileSync3 } from "node:child_process";
-import { createHash } from "node:crypto";
-import { statSync as statSync3 } from "node:fs";
-import path3 from "node:path";
-function asError(error) {
-  return error instanceof Error ? error : undefined;
-}
-function getErrorCode(error) {
-  if (error === null || typeof error !== "object" || !("code" in error)) {
-    return;
-  }
-  const code = error.code;
-  return typeof code === "string" ? code : undefined;
-}
-function getErrorSignal(error) {
-  if (error === null || typeof error !== "object" || !("signal" in error)) {
-    return;
-  }
-  const signal = error.signal;
-  return typeof signal === "string" ? signal : undefined;
-}
-function getErrorKilled(error) {
-  if (error === null || typeof error !== "object" || !("killed" in error)) {
-    return false;
-  }
-  return error.killed === true;
-}
-function getErrorStderr(error) {
-  if (error === null || typeof error !== "object" || !("stderr" in error)) {
-    return "";
-  }
-  const stderr = error.stderr;
-  if (typeof stderr === "string") {
-    return stderr;
-  }
-  if (Buffer.isBuffer(stderr)) {
-    return stderr.toString("utf8");
-  }
-  return "";
-}
-function directoryFallback(directory) {
-  const canonical = path3.resolve(directory);
-  const hash = createHash("md5").update(canonical, "utf8").digest("hex").slice(0, 12);
-  return `dir:${hash}`;
-}
-function assertDirectoryUsable(canonicalDirectory, rawDirectory) {
-  try {
-    const stat = statSync3(canonicalDirectory);
-    if (!stat.isDirectory()) {
-      throw new ProjectIdentityError("unknown", rawDirectory, `Project path is not a directory: ${canonicalDirectory}`);
-    }
-  } catch (error) {
-    if (error instanceof ProjectIdentityError) {
-      throw error;
-    }
-    const code = getErrorCode(error);
-    if (code === "EACCES" || code === "EPERM") {
-      throw new ProjectIdentityError("permission_denied", rawDirectory, `Permission denied while accessing project directory: ${canonicalDirectory}`, asError(error));
-    }
-    throw new ProjectIdentityError("unknown", rawDirectory, `Unable to access project directory: ${canonicalDirectory}`, asError(error));
-  }
-}
-function isGitTimeoutError(error) {
-  const code = getErrorCode(error);
-  const signal = getErrorSignal(error);
-  return code === "ETIMEDOUT" || signal === "SIGTERM" || signal === "SIGKILL" || getErrorKilled(error);
-}
-function classifyGitError(error, rawDirectory) {
-  if (isGitTimeoutError(error)) {
-    return new ProjectIdentityError("git_timeout", rawDirectory, `git rev-list timed out after ${GIT_TIMEOUT_MS}ms`, asError(error));
-  }
-  const code = getErrorCode(error);
-  if (code === "ENOENT") {
-    return new ProjectIdentityError("git_missing", rawDirectory, "git binary is not available in PATH", asError(error));
-  }
-  if (code === "EACCES" || code === "EPERM") {
-    return new ProjectIdentityError("permission_denied", rawDirectory, "Permission denied while spawning git", asError(error));
-  }
-  const stderr = getErrorStderr(error).toLowerCase();
-  if (stderr.includes("not a git repository") || stderr.includes("does not have any commits yet") || stderr.includes("ambiguous argument 'head'") || stderr.includes("unknown revision or path")) {
-    return new ProjectIdentityError("not_git_repo", rawDirectory, "Directory has no git root commit; caller may use directory fallback", asError(error));
-  }
-  return new ProjectIdentityError("unknown", rawDirectory, "git rev-list failed while resolving project identity", asError(error));
-}
-function resolveProjectIdentityStrict(directory) {
-  const canonical = path3.resolve(directory);
-  const cached = identityCache.get(canonical);
-  if (cached !== undefined) {
-    return cached;
-  }
-  assertDirectoryUsable(canonical, directory);
-  let output;
-  try {
-    output = execFileSync3("git", ["rev-list", "--max-parents=0", "HEAD"], {
-      cwd: canonical,
-      encoding: "utf8",
-      env: { ...process.env, LC_ALL: "C", LANG: "C" },
-      stdio: ["ignore", "pipe", "pipe"],
-      timeout: GIT_TIMEOUT_MS
-    });
-  } catch (error) {
-    throw classifyGitError(error, directory);
-  }
-  const firstLine = output.split(`
-`)[0]?.trim() ?? "";
-  const rootCommit = firstLine.slice(0, 64);
-  if (rootCommit.length < 7) {
-    throw new ProjectIdentityError("unknown", directory, "git rev-list returned no valid root commit hash");
-  }
-  const identity = `git:${rootCommit}`;
-  identityCache.set(canonical, identity);
-  return identity;
-}
-function shouldUseDirectoryFallback(error) {
-  return error.errorClass === "not_git_repo" || error.errorClass === "unknown" && error.message.startsWith("Unable to access project directory:");
-}
-function resolveProjectIdentity(directory) {
-  const canonical = path3.resolve(directory);
-  const cachedFallback = directoryFallbackCache.get(canonical);
-  if (cachedFallback !== undefined) {
-    if (!hasGitDir(canonical)) {
-      return cachedFallback;
-    }
-    directoryFallbackCache.delete(canonical);
-  }
-  try {
-    return resolveProjectIdentityStrict(directory);
-  } catch (error) {
-    if (error instanceof ProjectIdentityError && shouldUseDirectoryFallback(error)) {
-      const fallback = directoryFallback(canonical);
-      if (!hasGitDir(canonical)) {
-        directoryFallbackCache.set(canonical, fallback);
-      }
-      return fallback;
-    }
-    throw error;
-  }
-}
-function hasGitDir(canonical) {
-  try {
-    statSync3(path3.join(canonical, ".git"));
-    return true;
-  } catch {
-    return false;
-  }
-}
-var GIT_TIMEOUT_MS = 5000, identityCache, directoryFallbackCache, ProjectIdentityError;
-var init_project_identity = __esm(() => {
-  identityCache = new Map;
-  directoryFallbackCache = new Map;
-  ProjectIdentityError = class ProjectIdentityError extends Error {
-    errorClass;
-    rawDirectory;
-    constructor(errorClass, rawDirectory, message, cause) {
-      super(message);
-      this.name = "ProjectIdentityError";
-      this.errorClass = errorClass;
-      this.rawDirectory = rawDirectory;
-      if (cause) {
-        this.cause = cause;
-      }
-    }
-  };
-});
-
 // ../plugin/src/features/magic-context/project-identity.ts
 var init_project_identity2 = __esm(() => {
   init_project_identity();
@@ -147517,6 +148009,41 @@ var init_migrations = __esm(async () => {
                 `);
         }
       }
+    },
+    {
+      version: 37,
+      description: "emergency drain catch-up latch + historian drain failure backoff",
+      up: (db) => {
+        const hasSessionMeta = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='session_meta'").get();
+        if (!hasSessionMeta)
+          return;
+        ensureColumn(db, "session_meta", "emergency_drain_active", "INTEGER NOT NULL DEFAULT 0");
+        ensureColumn(db, "session_meta", "historian_drain_failure_at", "INTEGER NOT NULL DEFAULT 0");
+      }
+    },
+    {
+      version: 38,
+      description: "durable transform decisions for cache-event cause attribution",
+      up: (db) => {
+        db.exec(`
+                CREATE TABLE IF NOT EXISTS transform_decisions (
+                    session_id         TEXT    NOT NULL,
+                    harness            TEXT    NOT NULL DEFAULT 'opencode',
+                    message_id         TEXT    NOT NULL,
+                    ts_ms              INTEGER NOT NULL,
+                    decision           TEXT    NOT NULL,
+                    materialized       INTEGER NOT NULL DEFAULT 0,
+                    materialize_reason TEXT,
+                    emergency          INTEGER NOT NULL DEFAULT 0,
+                    dropped_tokens     INTEGER NOT NULL DEFAULT 0,
+                    dropped_count      INTEGER NOT NULL DEFAULT 0,
+                    input_tokens       INTEGER NOT NULL DEFAULT 0,
+                    PRIMARY KEY (session_id, harness, message_id)
+                );
+                CREATE INDEX IF NOT EXISTS idx_transform_decisions_session_harness
+                    ON transform_decisions(session_id, harness);
+            `);
+      }
     }
   ];
   LATEST_MIGRATION_VERSION = MIGRATIONS.reduce((max, m) => Math.max(max, m.version), 0);
@@ -147548,7 +148075,7 @@ var init_storage_memory_mutation_log = __esm(() => {
 });
 
 // ../plugin/src/features/magic-context/storage-meta-persisted.ts
-var AUTO_SEARCH_NO_HINT_REASONS, DRAIN_WINDOW_MS;
+var AUTO_SEARCH_NO_HINT_REASONS, DRAIN_WINDOW_MS, EMERGENCY_DRAIN_MAX_LATCH_MS;
 var init_storage_meta_persisted = __esm(() => {
   init_logger();
   init_storage_meta_shared();
@@ -147561,6 +148088,7 @@ var init_storage_meta_persisted = __esm(() => {
     "too-short"
   ]);
   DRAIN_WINDOW_MS = 10 * 60 * 1000;
+  EMERGENCY_DRAIN_MAX_LATCH_MS = 30 * 60 * 1000;
 });
 
 // ../plugin/src/features/magic-context/resolve-subagent-fallback.ts
@@ -147604,10 +148132,11 @@ var init_storage_ops = __esm(() => {
   clearPendingOpsStatements = new WeakMap;
   removePendingOpStatements = new WeakMap;
 });
+
 // ../plugin/src/features/magic-context/storage-source.ts
 var init_storage_source = () => {};
 // ../plugin/src/features/magic-context/storage-tags.ts
-var insertTagStatements, updateTagStatusStatements, updateTagDropModeStatements, updateTagMessageIdStatements, getTagNumbersByMessageIdStatements, deleteTagsByMessageIdStatements, getMaxTagNumberBySessionStatements, getTagNumberByMessageIdStatements, updateTagByteSizeStatements, updateTagInputByteSizeStatements, updateTagTokenCountStatements, updateTagInputTokenCountStatements, getOwnerScopedToolTagNumbersStatements, getActiveTagsBySessionStatements, getMaxDroppedTagNumberStatements, getToolTagNumberByOwnerStatements, getNullOwnerToolTagStatements, adoptNullOwnerToolTagStatements, deleteToolTagsByOwnerStatements;
+var insertTagStatements, updateTagStatusStatements, updateTagDropModeStatements, updateTagMessageIdStatements, getTagNumbersByMessageIdStatements, deleteTagsByMessageIdStatements, getMaxTagNumberBySessionStatements, getTagNumberByMessageIdStatements, updateTagByteSizeStatements, updateTagInputByteSizeStatements, updateTagTokenCountStatements, updateTagInputTokenCountStatements, getOwnerScopedToolTagNumbersStatements, getMinMessageTagNumberForRawIdStatements, getActiveTagsBySessionStatements, getMaxDroppedTagNumberStatements, getToolTagNumberByOwnerStatements, getNullOwnerToolTagStatements, adoptNullOwnerToolTagStatements, deleteToolTagsByOwnerStatements;
 var init_storage_tags = __esm(() => {
   insertTagStatements = new WeakMap;
   updateTagStatusStatements = new WeakMap;
@@ -147622,6 +148151,7 @@ var init_storage_tags = __esm(() => {
   updateTagTokenCountStatements = new WeakMap;
   updateTagInputTokenCountStatements = new WeakMap;
   getOwnerScopedToolTagNumbersStatements = new WeakMap;
+  getMinMessageTagNumberForRawIdStatements = new WeakMap;
   getActiveTagsBySessionStatements = new WeakMap;
   getMaxDroppedTagNumberStatements = new WeakMap;
   getToolTagNumberByOwnerStatements = new WeakMap;
@@ -147667,8 +148197,8 @@ var init_storage = __esm(async () => {
 
 // ../plugin/src/features/magic-context/v22-deferred-backfill.ts
 import { createHash as createHash2 } from "node:crypto";
-import { realpathSync as realpathSync2 } from "node:fs";
-import path4 from "node:path";
+import { realpathSync as realpathSync3 } from "node:fs";
+import path5 from "node:path";
 function readMeta(db, key) {
   const row = db.prepare("SELECT value FROM schema_migrations_meta WHERE key = ?").get(key);
   return row?.value ?? null;
@@ -147708,9 +148238,9 @@ function resolveBackfillIdentity(rawProjectPath) {
 function computeLegacyRustDirIdentity(rawProjectPath) {
   let canonical;
   try {
-    canonical = realpathSync2(rawProjectPath);
+    canonical = realpathSync3(rawProjectPath);
   } catch {
-    canonical = path4.isAbsolute(rawProjectPath) ? rawProjectPath : path4.join(process.cwd(), rawProjectPath);
+    canonical = path5.isAbsolute(rawProjectPath) ? rawProjectPath : path5.join(process.cwd(), rawProjectPath);
   }
   return `dir:${createHash2("sha256").update(canonical, "utf8").digest("hex")}`;
 }
@@ -147751,24 +148281,6 @@ function getV22BackfillStatus(db) {
     maxLegacyMemoryId: maxLegacyRow.m
   };
 }
-function rekeyMemoryRowWithCollisionMerge(db, rowId, fromProjectPath, toIdentity) {
-  const row = db.prepare("SELECT category, normalized_hash, seen_count FROM memories WHERE id = ?").get(rowId);
-  if (!row)
-    return false;
-  const collision = db.prepare(`SELECT id, seen_count FROM memories
-             WHERE project_path = ? AND category = ? AND normalized_hash = ?
-             LIMIT 1`).get(toIdentity, row.category, row.normalized_hash);
-  if (collision && collision.id !== rowId) {
-    const mergedSeen = Math.max(collision.seen_count ?? 1, row.seen_count ?? 1);
-    if (mergedSeen !== (collision.seen_count ?? 1)) {
-      db.prepare("UPDATE memories SET seen_count = ? WHERE id = ?").run(mergedSeen, collision.id);
-    }
-    db.prepare("DELETE FROM memories WHERE id = ?").run(rowId);
-    return true;
-  }
-  const result = db.prepare("UPDATE memories SET project_path = ? WHERE id = ? AND project_path = ?").run(toIdentity, rowId, fromProjectPath);
-  return (result.changes ?? 0) > 0;
-}
 async function doctorRetryV22Backfill(db) {
   const failures = db.prepare(`SELECT row_id, raw_project_path
              FROM v22_backfill_failures
@@ -147848,6 +148360,7 @@ var BACKFILL_META_KEY = "v22_legacy_memory_backfill", BACKFILL_CURSOR_META_KEY =
 var init_v22_deferred_backfill = __esm(() => {
   init_logger();
   init_project_identity();
+  init_relocate_memory();
 });
 
 // src/lib/v22-backfill-commands.ts
@@ -148376,10 +148889,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path5) {
-  if (!path5)
+function getElementAtPath(obj, path6) {
+  if (!path6)
     return obj;
-  return path5.reduce((acc, key) => acc?.[key], obj);
+  return path6.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -148707,11 +149220,11 @@ function explicitlyAborted(x2, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path5, issues) {
+function prefixIssues(path6, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path5);
+    iss.path.unshift(path6);
     return iss;
   });
 }
@@ -148924,16 +149437,16 @@ function flattenError(error, mapper = (issue2) => issue2.message) {
 }
 function formatError(error, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error2, path5 = []) => {
+  const processError = (error2, path6 = []) => {
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path5, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path6, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
       } else {
-        const fullpath = [...path5, ...issue2.path];
+        const fullpath = [...path6, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -148960,17 +149473,17 @@ function formatError(error, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error2, path5 = []) => {
+  const processError = (error2, path6 = []) => {
     var _a2, _b;
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path5, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path6, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
       } else {
-        const fullpath = [...path5, ...issue2.path];
+        const fullpath = [...path6, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -149002,8 +149515,8 @@ function treeifyError(error, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path5 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path5) {
+  const path6 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path6) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -162006,13 +162519,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path5 = ref.slice(1).split("/").filter(Boolean);
-  if (path5.length === 0) {
+  const path6 = ref.slice(1).split("/").filter(Boolean);
+  if (path6.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path5[0] === defsKey) {
-    const key = path5[1];
+  if (path6[0] === defsKey) {
+    const key = path6[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -162836,14 +163349,16 @@ var init_magic_context = __esm(() => {
   }).optional();
   HistorianConfigSchema = AgentOverrideConfigSchema.extend({
     two_pass: exports_external.boolean().default(false).describe("Run a second editor pass over historian output to clean low-signal U: lines and cross-compartment duplicates. Adds ~1 extra API call and ~1.3x cost per historian run. Useful for models without extended thinking support. (default: false)"),
-    thinking_level: PiThinkingLevelSchema.describe("Pi only: explicit thinking level passed as --thinking <level> to Pi historian subagent invocations. Required when using reasoning models (e.g. github-copilot/gpt-5.4) because Pi's default thinking-level resolution can pick a value the provider rejects. OpenCode users set variant instead. Valid: off | minimal | low | medium | high | xhigh")
+    thinking_level: PiThinkingLevelSchema.describe("Pi only: explicit thinking level passed as --thinking <level> to Pi historian subagent invocations. Required when using reasoning models (e.g. github-copilot/gpt-5.4) because Pi's default thinking-level resolution can pick a value the provider rejects. OpenCode users set variant instead. Valid: off | minimal | low | medium | high | xhigh"),
+    disallowed_tools: exports_external.array(exports_external.enum(["*", "read", "aft_outline", "aft_zoom", "aft_search"])).default([]).describe(`OpenCode only. Tools to REMOVE from the historian's default allow-list [read, aft_outline, aft_zoom, aft_search]. Applies to both historian and historian-editor agents. Use ["*"] to strip all tool definitions from the model request — this prevents weak instruction-following models (e.g. mistral-small-latest) from entering tool-calling loops. Individual tool names remove just that tool. Note: a user-supplied historian.permission override can re-allow a tool that disallowed_tools removed — disallowed_tools sets the baseline, permission overrides take precedence. (default: [])`)
   }).optional();
   BaseEmbeddingConfigSchema = exports_external.object({
     provider: exports_external.enum(["local", "openai-compatible", "off"]).default("local").describe("Embedding provider. 'local' uses Xenova/all-MiniLM-L6-v2, 'openai-compatible' requires endpoint and model, 'off' disables embeddings."),
     model: exports_external.string().optional().describe("Embedding model name. Required for openai-compatible, ignored for local."),
     endpoint: exports_external.string().optional().describe("API endpoint URL. Required when provider is openai-compatible."),
     api_key: exports_external.string().optional().describe("API key for remote embedding provider (optional)"),
-    input_type: exports_external.string().optional().describe("Optional input_type sent in the embedding request body. Required by some openai-compatible providers (e.g. NVIDIA NIM expects 'query' or 'passage'). Omitted from the request when unset."),
+    input_type: exports_external.string().optional().describe("Default input_type for stored/indexed (passage) embeddings in the request body. Required by some openai-compatible providers (e.g. NVIDIA NIM). Omitted from the request when unset."),
+    query_input_type: exports_external.string().optional().describe("Optional input_type for query (search) embeddings on asymmetric models (e.g. NVIDIA NIM 'query'). When unset, query embeddings use embedding.input_type. Passage/stored content always uses embedding.input_type."),
     truncate: exports_external.string().optional().describe("Optional truncate mode sent in the embedding request body (e.g. NVIDIA NIM accepts 'NONE' | 'START' | 'END'). Omitted from the request when unset."),
     max_input_tokens: exports_external.number().int().positive().optional().describe("Optional maximum input tokens for chunk embeddings. Defaults conservatively to 512 when omitted.")
   }).superRefine((data, ctx) => {
@@ -162873,6 +163388,7 @@ var init_magic_context = __esm(() => {
     if (data.provider === "openai-compatible") {
       const apiKey = data.api_key?.trim();
       const inputType = data.input_type?.trim();
+      const queryInputType = data.query_input_type?.trim();
       const truncate = data.truncate?.trim();
       return {
         provider: "openai-compatible",
@@ -162880,6 +163396,7 @@ var init_magic_context = __esm(() => {
         endpoint: data.endpoint?.trim() ?? "",
         ...apiKey ? { api_key: apiKey } : {},
         ...inputType ? { input_type: inputType } : {},
+        ...queryInputType ? { query_input_type: queryInputType } : {},
         ...truncate ? { truncate } : {},
         ...data.max_input_tokens ? { max_input_tokens: data.max_input_tokens } : {}
       };
@@ -162962,11 +163479,11 @@ var init_magic_context = __esm(() => {
 });
 
 // ../plugin/src/config/variable.ts
-import { existsSync as existsSync14, readFileSync as readFileSync8 } from "node:fs";
-import { homedir as homedir7 } from "node:os";
+import { existsSync as existsSync15, readFileSync as readFileSync8 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
 import { dirname as dirname7, isAbsolute, resolve as resolve2 } from "node:path";
 function sensitiveFilePathReason(resolvedPath) {
-  const home = homedir7();
+  const home = homedir8();
   const sensitiveDirs = [
     { dir: resolve2(home, ".ssh"), label: "SSH keys" },
     { dir: resolve2(home, ".aws"), label: "AWS credentials" },
@@ -163029,7 +163546,7 @@ function substituteConfigVariables(input) {
     }
     let filePath = rawPath.trim();
     if (filePath.startsWith("~/")) {
-      filePath = resolve2(homedir7(), filePath.slice(2));
+      filePath = resolve2(homedir8(), filePath.slice(2));
     } else if (!isAbsolute(filePath)) {
       filePath = resolve2(configDir, filePath);
     }
@@ -163037,7 +163554,7 @@ function substituteConfigVariables(input) {
     if (sensitiveReason) {
       warnings.push(`${token} resolves to a sensitive path (${sensitiveReason}: ${filePath}); ` + "inlining its contents into config — make sure this is intentional.");
     }
-    if (!existsSync14(filePath)) {
+    if (!existsSync15(filePath)) {
       warnings.push(`File not found for ${token} (resolved to ${filePath}); using empty string`);
       continue;
     }
@@ -163062,19 +163579,19 @@ var init_variable = __esm(() => {
 });
 
 // ../plugin/src/config/index.ts
-import { existsSync as existsSync15, readFileSync as readFileSync9 } from "node:fs";
-import { homedir as homedir8 } from "node:os";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync16, readFileSync as readFileSync9 } from "node:fs";
+import { homedir as homedir9 } from "node:os";
+import { join as join13 } from "node:path";
 function getUserConfigBasePath() {
-  const configRoot = process.env.XDG_CONFIG_HOME ?? join12(homedir8(), ".config");
-  return join12(configRoot, "opencode", CONFIG_FILE_BASENAME);
+  const configRoot = process.env.XDG_CONFIG_HOME ?? join13(homedir9(), ".config");
+  return join13(configRoot, "opencode", CONFIG_FILE_BASENAME);
 }
 function getProjectConfigBasePath(directory) {
-  return join12(directory, ".opencode", CONFIG_FILE_BASENAME);
+  return join13(directory, ".opencode", CONFIG_FILE_BASENAME);
 }
 function loadConfigFile(configPath, isProjectConfig = false) {
   try {
-    if (!existsSync15(configPath)) {
+    if (!existsSync16(configPath)) {
       return null;
     }
     const rawText = readFileSync9(configPath, "utf-8");
@@ -163218,7 +163735,7 @@ function parsePluginConfig(rawConfig, recoveredTopLevelKeys = []) {
 }
 function loadPluginConfig(directory) {
   const userDetected = detectConfigFile(getUserConfigBasePath());
-  const rootDetected = detectConfigFile(join12(directory, CONFIG_FILE_BASENAME));
+  const rootDetected = detectConfigFile(join13(directory, CONFIG_FILE_BASENAME));
   const dotOpenCodeDetected = detectConfigFile(getProjectConfigBasePath(directory));
   const projectDetected = rootDetected.format !== "none" ? rootDetected : dotOpenCodeDetected;
   const userLoaded = userDetected.format === "none" ? null : loadConfigFile(userDetected.path);
@@ -163266,14 +163783,14 @@ var init_config = __esm(() => {
 });
 
 // ../plugin/src/features/magic-context/key-files/aft-availability.ts
-import { existsSync as existsSync16, readFileSync as readFileSync10 } from "node:fs";
-import { homedir as homedir9 } from "node:os";
-import { isAbsolute as isAbsolute2, join as join13, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync10 } from "node:fs";
+import { homedir as homedir10 } from "node:os";
+import { isAbsolute as isAbsolute2, join as join14, resolve as resolve3 } from "node:path";
 import { fileURLToPath } from "node:url";
-function parseConfig(path5) {
-  if (!existsSync16(path5))
+function parseConfig(path6) {
+  if (!existsSync17(path6))
     return null;
-  return import_comment_json6.parse(readFileSync10(path5, "utf-8"));
+  return import_comment_json6.parse(readFileSync10(path6, "utf-8"));
 }
 function stringMentionsAft(value) {
   return AFT_NAME_NEEDLES.some((needle) => value.includes(needle));
@@ -163287,14 +163804,14 @@ function resolveLocalEntryPackageName(value, configDir) {
       return null;
     }
   } else if (value.startsWith("~/")) {
-    dir = join13(homedir9(), value.slice(2));
+    dir = join14(homedir10(), value.slice(2));
   } else if (value.startsWith("/") || value.startsWith("./") || value.startsWith("../")) {
     dir = isAbsolute2(value) ? value : resolve3(configDir, value);
   } else {
     return null;
   }
   try {
-    const pkg = JSON.parse(readFileSync10(join13(dir, "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync10(join14(dir, "package.json"), "utf-8"));
     return typeof pkg.name === "string" ? pkg.name : null;
   } catch {
     return null;
@@ -163323,18 +163840,18 @@ function hasAftAtKeys(value, keys, configDir) {
   return false;
 }
 function getAftAvailability() {
-  const home = process.env.HOME || homedir9();
+  const home = process.env.HOME || homedir10();
   const opencodePaths = [
-    join13(home, ".config", "opencode", "opencode.jsonc"),
-    join13(home, ".config", "opencode", "opencode.json")
+    join14(home, ".config", "opencode", "opencode.jsonc"),
+    join14(home, ".config", "opencode", "opencode.json")
   ];
-  const piPaths = [join13(home, ".pi", "agent", "settings.json")];
+  const piPaths = [join14(home, ".pi", "agent", "settings.json")];
   const checkedPaths = [...opencodePaths, ...piPaths];
   let opencode = false;
-  for (const path5 of opencodePaths) {
+  for (const path6 of opencodePaths) {
     try {
-      const config2 = parseConfig(path5);
-      const configDir = join13(path5, "..");
+      const config2 = parseConfig(path6);
+      const configDir = join14(path6, "..");
       if (hasAftAtKeys(config2, ["plugin", "plugins", "mcp", "mcp_servers"], configDir)) {
         opencode = true;
         break;
@@ -163342,10 +163859,10 @@ function getAftAvailability() {
     } catch {}
   }
   let pi = false;
-  for (const path5 of piPaths) {
+  for (const path6 of piPaths) {
     try {
-      const config2 = parseConfig(path5);
-      const configDir = join13(path5, "..");
+      const config2 = parseConfig(path6);
+      const configDir = join14(path6, "..");
       if (hasAftAtKeys(config2, ["packages", "extensions"], configDir)) {
         pi = true;
         break;
@@ -163483,8 +164000,8 @@ function truncate(text2) {
 var DEFAULT_TIMEOUT_MS = 1e4, MAX_PREVIEW_CHARS = 240;
 
 // ../plugin/src/shared/tui-config.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname8, join as join14 } from "node:path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "node:fs";
+import { dirname as dirname8, join as join15 } from "node:path";
 function isMagicContextEntry(entry) {
   if (!entry)
     return false;
@@ -163498,11 +164015,11 @@ function isMagicContextEntry(entry) {
 }
 function resolveTuiConfigPath() {
   const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
-  const jsoncPath = join14(configDir, "tui.jsonc");
-  const jsonPath = join14(configDir, "tui.json");
-  if (existsSync17(jsoncPath))
+  const jsoncPath = join15(configDir, "tui.jsonc");
+  const jsonPath = join15(configDir, "tui.json");
+  if (existsSync18(jsoncPath))
     return jsoncPath;
-  if (existsSync17(jsonPath))
+  if (existsSync18(jsonPath))
     return jsonPath;
   return jsonPath;
 }
@@ -163510,7 +164027,7 @@ function ensureTuiPluginEntry() {
   try {
     const configPath = resolveTuiConfigPath();
     let config2 = {};
-    if (existsSync17(configPath)) {
+    if (existsSync18(configPath)) {
       const raw = readFileSync11(configPath, "utf-8");
       config2 = import_comment_json7.parse(raw) ?? {};
     }
@@ -163681,7 +164198,7 @@ var init_compartment_parser = __esm(() => {
 });
 
 // src/lib/redaction.ts
-import { homedir as homedir10, userInfo } from "node:os";
+import { homedir as homedir11, userInfo } from "node:os";
 function escapeRegex3(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -163725,7 +164242,7 @@ function isSecretKey(key) {
   return false;
 }
 function sanitizePathString(value) {
-  const home = homedir10();
+  const home = homedir11();
   const username = userInfo().username;
   let sanitized = value;
   if (home) {
@@ -163859,10 +164376,10 @@ var init_redaction = __esm(() => {
 });
 
 // src/lib/diagnostics-opencode.ts
-import { existsSync as existsSync18, readdirSync as readdirSync2, readFileSync as readFileSync12, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync19, readdirSync as readdirSync2, readFileSync as readFileSync12, statSync as statSync4 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { homedir as homedir11 } from "node:os";
-import { join as join15 } from "node:path";
+import { homedir as homedir12 } from "node:os";
+import { join as join16 } from "node:path";
 function getSelfVersion() {
   const require2 = createRequire2(import.meta.url);
   for (const relPath of ["../../package.json", "../package.json"]) {
@@ -163876,26 +164393,26 @@ function getSelfVersion() {
   return "unknown";
 }
 function getPluginCacheInfo() {
-  const path5 = join15(getOpenCodeCacheDir(), "packages", PLUGIN_ENTRY_WITH_VERSION);
+  const path6 = join16(getOpenCodeCacheDir(), "packages", PLUGIN_ENTRY_WITH_VERSION);
   let cached2;
   try {
-    const installedPkgPath = join15(path5, "node_modules", "@cortexkit", "opencode-magic-context", "package.json");
-    if (existsSync18(installedPkgPath)) {
+    const installedPkgPath = join16(path6, "node_modules", "@cortexkit", "opencode-magic-context", "package.json");
+    if (existsSync19(installedPkgPath)) {
       const pkg = JSON.parse(readFileSync12(installedPkgPath, "utf-8"));
       cached2 = typeof pkg.version === "string" ? pkg.version : undefined;
     }
   } catch {
     cached2 = undefined;
   }
-  return { path: path5, cached: cached2, latest: getSelfVersion() };
+  return { path: path6, cached: cached2, latest: getSelfVersion() };
 }
 function getStorageDir() {
-  const dataHome = process.env.XDG_DATA_HOME || join15(homedir11(), ".local", "share");
-  return join15(dataHome, "cortexkit", "magic-context");
+  const dataHome = process.env.XDG_DATA_HOME || join16(homedir12(), ".local", "share");
+  return join16(dataHome, "cortexkit", "magic-context");
 }
-function fileSize(path5) {
+function fileSize(path6) {
   try {
-    return existsSync18(path5) ? statSync4(path5).size : 0;
+    return existsSync19(path6) ? statSync4(path6).size : 0;
   } catch {
     return 0;
   }
@@ -163906,11 +164423,11 @@ function sanitizeString(value) {
 function sanitizeValue(value) {
   return sanitizeConfigValue(value);
 }
-function readConfig2(path5) {
-  if (!existsSync18(path5))
+function readConfig2(path6) {
+  if (!existsSync19(path6))
     return { value: null };
   try {
-    const raw = readFileSync12(path5, "utf-8");
+    const raw = readFileSync12(path6, "utf-8");
     const value = import_comment_json8.parse(raw);
     return { value };
   } catch (error51) {
@@ -163931,9 +164448,9 @@ function configHasPluginEntry(config2) {
     return false;
   });
 }
-function parseHistorianDumpMeta(path5) {
+function parseHistorianDumpMeta(path6) {
   try {
-    const xml = readFileSync12(path5, "utf-8");
+    const xml = readFileSync12(path6, "utf-8");
     const parsed = parseCompartmentOutput(xml);
     const factCountByCategory = {};
     for (const fact of parsed.facts) {
@@ -163966,11 +164483,11 @@ function parseHistorianDumpMeta(path5) {
   }
 }
 function listDumpsInDir(dir, limit) {
-  if (!existsSync18(dir))
+  if (!existsSync19(dir))
     return { count: 0, recent: [] };
   try {
     const entries = readdirSync2(dir).filter((name2) => name2.endsWith(".xml")).map((name2) => {
-      const stat = statSync4(join15(dir, name2));
+      const stat = statSync4(join16(dir, name2));
       return {
         name: name2,
         mtime: stat.mtimeMs,
@@ -163979,7 +164496,7 @@ function listDumpsInDir(dir, limit) {
     }).sort((a, b2) => b2.mtime - a.mtime);
     const now = Date.now();
     const recent = entries.slice(0, limit).map((entry) => {
-      const meta3 = parseHistorianDumpMeta(join15(dir, entry.name));
+      const meta3 = parseHistorianDumpMeta(join16(dir, entry.name));
       const summary = {
         name: entry.name,
         ageMinutes: Math.round((now - entry.mtime) / 60000),
@@ -164034,8 +164551,8 @@ function collectHistorianDumps(recentSessions) {
   };
 }
 async function collectRecentSessions() {
-  const opencodeDbPath = join15(homedir11(), ".local", "share", "opencode", "opencode.db");
-  if (!existsSync18(opencodeDbPath))
+  const opencodeDbPath = join16(homedir12(), ".local", "share", "opencode", "opencode.db");
+  if (!existsSync19(opencodeDbPath))
     return [];
   if (typeof globalThis.Bun === "undefined") {
     return [];
@@ -164069,8 +164586,8 @@ async function collectRecentSessions() {
   }
 }
 async function collectHistorianFailures(storageDirPath) {
-  const contextDbPath = join15(storageDirPath, "context.db");
-  if (!existsSync18(contextDbPath))
+  const contextDbPath = join16(storageDirPath, "context.db");
+  if (!existsSync19(contextDbPath))
     return [];
   if (typeof globalThis.Bun === "undefined") {
     return [];
@@ -164102,6 +164619,70 @@ async function collectHistorianFailures(storageDirPath) {
     } catch {}
   }
 }
+async function collectHistorianRuns(storageDirPath) {
+  const contextDbPath = join16(storageDirPath, "context.db");
+  if (!existsSync19(contextDbPath))
+    return [];
+  if (typeof globalThis.Bun === "undefined")
+    return [];
+  let DatabaseClass;
+  try {
+    const mod = await new Function("p", "return import(p)")("bun:sqlite");
+    DatabaseClass = mod.Database;
+  } catch {
+    return [];
+  }
+  let db = null;
+  try {
+    db = new DatabaseClass(contextDbPath, { readonly: true });
+    const aggRows = db.prepare(`SELECT session_id,
+                    COUNT(*) AS total,
+                    SUM(CASE WHEN status='success' THEN 1 ELSE 0 END) AS success,
+                    SUM(CASE WHEN status='failed' THEN 1 ELSE 0 END) AS failed,
+                    SUM(CASE WHEN status='noop' THEN 1 ELSE 0 END) AS noop,
+                    MAX(created_at) AS last_run_at
+                 FROM historian_runs
+                 GROUP BY session_id
+                 ORDER BY last_run_at DESC
+                 LIMIT 10`).all();
+    if (aggRows.length === 0)
+      return [];
+    const reasonRows = db.prepare(`SELECT session_id, failure_reason, created_at
+                 FROM historian_runs
+                 WHERE status='failed' AND failure_reason IS NOT NULL
+                 ORDER BY created_at DESC
+                 LIMIT 200`).all();
+    const latestReasonBySession = new Map;
+    for (const row of reasonRows) {
+      const sid = typeof row.session_id === "string" ? row.session_id : "";
+      if (!sid || latestReasonBySession.has(sid))
+        continue;
+      if (typeof row.failure_reason === "string") {
+        latestReasonBySession.set(sid, row.failure_reason);
+      }
+    }
+    const asNum = (v2) => typeof v2 === "number" ? v2 : 0;
+    return aggRows.map((row) => {
+      const sessionId = typeof row.session_id === "string" ? row.session_id : "<unknown>";
+      const rawReason = latestReasonBySession.get(sessionId) ?? "";
+      return {
+        sessionId,
+        total: asNum(row.total),
+        success: asNum(row.success),
+        failed: asNum(row.failed),
+        noop: asNum(row.noop),
+        lastFailureReason: sanitizeDiagnosticText(rawReason.replace(/\s+/g, " ").trim().slice(0, 400)),
+        lastRunAt: typeof row.last_run_at === "number" ? new Date(row.last_run_at).toISOString() : ""
+      };
+    });
+  } catch {
+    return [];
+  } finally {
+    try {
+      db?.close();
+    } catch {}
+  }
+}
 async function collectDiagnostics() {
   const pluginVersion = getSelfVersion();
   const configPaths = detectConfigPaths();
@@ -164109,9 +164690,9 @@ async function collectDiagnostics() {
   const tuiConfig = readConfig2(configPaths.tuiConfig);
   const magicContextConfig = readConfig2(configPaths.magicContextConfig);
   const storageDirPath = getStorageDir();
-  const contextDbPath = join15(storageDirPath, "context.db");
+  const contextDbPath = join16(storageDirPath, "context.db");
   const logPath = getMagicContextLogPath2("opencode");
-  const logFileSize = existsSync18(logPath) ? statSync4(logPath).size : 0;
+  const logFileSize = existsSync19(logPath) ? statSync4(logPath).size : 0;
   const conflictResult = detectConflicts(process.cwd());
   const recentSessions = await collectRecentSessions();
   return {
@@ -164126,7 +164707,7 @@ async function collectDiagnostics() {
     opencodeConfigHasPlugin: configHasPluginEntry(opencodeConfig.value),
     tuiConfigHasPlugin: configHasPluginEntry(tuiConfig.value),
     magicContextConfig: {
-      exists: existsSync18(configPaths.magicContextConfig),
+      exists: existsSync19(configPaths.magicContextConfig),
       ...magicContextConfig.error ? { parseError: magicContextConfig.error } : {},
       flags: sanitizeValue(magicContextConfig.value ?? {}) ?? {}
     },
@@ -164134,7 +164715,7 @@ async function collectDiagnostics() {
     pluginCache: getPluginCacheInfo(),
     storageDir: {
       path: storageDirPath,
-      exists: existsSync18(storageDirPath),
+      exists: existsSync19(storageDirPath),
       contextDbSizeBytes: fileSize(contextDbPath)
     },
     conflicts: {
@@ -164143,12 +164724,13 @@ async function collectDiagnostics() {
     },
     logFile: {
       path: logPath,
-      exists: existsSync18(logPath),
+      exists: existsSync19(logPath),
       sizeKb: Math.round(logFileSize / 1024)
     },
     recentSessions,
     historianDumps: collectHistorianDumps(recentSessions),
-    historianFailures: await collectHistorianFailures(storageDirPath)
+    historianFailures: await collectHistorianFailures(storageDirPath),
+    historianRuns: await collectHistorianRuns(storageDirPath)
   };
 }
 function formatBytes(bytes) {
@@ -164244,11 +164826,21 @@ function renderDiagnosticsMarkdown(report) {
     "```",
     "",
     "### Historian failures (session_meta)",
+    "_Note: this counter RESETS to 0 on every successful run — see 'Historian runs' below for the durable history._",
     report.historianFailures.length === 0 ? "_No sessions with historian failures._" : [
       "```json",
       JSON.stringify(sanitizeConfigValue(report.historianFailures), null, 2),
       "```"
     ].join(`
+`),
+    "",
+    "### Historian runs (durable telemetry)",
+    "Per-session success/failure/no-op counts from `historian_runs` (never reset).",
+    report.historianRuns.length === 0 ? "_No historian runs recorded (or schema predates v24)._" : [
+      "```json",
+      JSON.stringify(sanitizeConfigValue(report.historianRuns), null, 2),
+      "```"
+    ].join(`
 `),
     "",
     "### Log file",
@@ -164272,33 +164864,33 @@ var init_diagnostics_opencode = __esm(() => {
 });
 
 // src/lib/embedding-runtime.ts
-import { existsSync as existsSync19 } from "node:fs";
+import { existsSync as existsSync20 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import { dirname as dirname9, join as join16, sep } from "node:path";
+import { dirname as dirname9, join as join17, sep } from "node:path";
 function expectedBinaryRelPath(platform, arch) {
   const supportedPlatform = platform === "linux" || platform === "darwin" || platform === "win32";
   const supportedArch = arch === "x64" || arch === "arm64";
   if (!supportedPlatform || !supportedArch)
     return null;
-  return join16("bin", "napi-v6", platform, arch, "onnxruntime_binding.node");
+  return join17("bin", "napi-v6", platform, arch, "onnxruntime_binding.node");
 }
 function checkLocalEmbeddingRuntimeAt(installRoot, platform = process.platform, arch = process.arch) {
-  const packageDir = join16(installRoot, "node_modules", "onnxruntime-node");
-  if (!existsSync19(join16(packageDir, "package.json"))) {
+  const packageDir = join17(installRoot, "node_modules", "onnxruntime-node");
+  if (!existsSync20(join17(packageDir, "package.json"))) {
     return { state: "package-missing", packageDir };
   }
   const rel = expectedBinaryRelPath(platform, arch);
   if (rel === null) {
     return { state: "ok", binaryPath: packageDir };
   }
-  const binaryPath = join16(packageDir, rel);
-  if (!existsSync19(binaryPath)) {
+  const binaryPath = join17(packageDir, rel);
+  if (!existsSync20(binaryPath)) {
     return { state: "binary-missing", packageDir, expectedBinary: binaryPath };
   }
   return { state: "ok", binaryPath };
 }
 function checkLocalEmbeddingRuntime(installRoots, platform = process.platform, arch = process.arch) {
-  const existing = installRoots.filter((root) => existsSync19(root));
+  const existing = installRoots.filter((root) => existsSync20(root));
   if (existing.length === 0) {
     return {
       state: "unknown",
@@ -164321,19 +164913,19 @@ function packageDirFromResolved(resolvedPath, packageName) {
   return idx >= 0 ? resolvedPath.slice(0, idx + marker.length) : dirname9(resolvedPath);
 }
 function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.platform, arch = process.arch) {
-  if (!existsSync19(join16(pluginDir, "package.json"))) {
+  if (!existsSync20(join17(pluginDir, "package.json"))) {
     return { state: "unknown", reason: "plugin package dir not found" };
   }
   let onnxDir = null;
   let resolveError;
   try {
-    const reqPlugin = createRequire3(join16(pluginDir, "package.json"));
+    const reqPlugin = createRequire3(join17(pluginDir, "package.json"));
     try {
       onnxDir = packageDirFromResolved(reqPlugin.resolve("onnxruntime-node"), "onnxruntime-node");
     } catch {
       const tfResolved = reqPlugin.resolve("@huggingface/transformers");
       const tfDir = packageDirFromResolved(tfResolved, "@huggingface/transformers");
-      const reqTf = createRequire3(join16(tfDir, "package.json"));
+      const reqTf = createRequire3(join17(tfDir, "package.json"));
       onnxDir = packageDirFromResolved(reqTf.resolve("onnxruntime-node"), "onnxruntime-node");
     }
   } catch (error51) {
@@ -164341,7 +164933,7 @@ function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.pl
     if (resolveError === "ERR_MODULE_NOT_FOUND" || resolveError === "MODULE_NOT_FOUND") {
       return {
         state: "package-missing",
-        packageDir: join16(pluginDir, "node_modules", "onnxruntime-node")
+        packageDir: join17(pluginDir, "node_modules", "onnxruntime-node")
       };
     }
     return {
@@ -164356,8 +164948,8 @@ function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.pl
   if (rel === null) {
     return { state: "ok", binaryPath: onnxDir };
   }
-  const binaryPath = join16(onnxDir, rel);
-  if (!existsSync19(binaryPath)) {
+  const binaryPath = join17(onnxDir, rel);
+  if (!existsSync20(binaryPath)) {
     return { state: "binary-missing", packageDir: onnxDir, expectedBinary: binaryPath };
   }
   return { state: "ok", binaryPath };
@@ -164451,8 +165043,8 @@ var init_issue_body = __esm(() => {
 
 // src/lib/logs-opencode.ts
 import { readFileSync as readFileSync13, writeFileSync as writeFileSync8 } from "node:fs";
-import { homedir as homedir12 } from "node:os";
-import { join as join17 } from "node:path";
+import { homedir as homedir13 } from "node:os";
+import { join as join18 } from "node:path";
 function sanitizeLogContent(content) {
   return sanitizeDiagnosticText(content);
 }
@@ -164505,7 +165097,7 @@ async function bundleIssueReport(report, description, _title, sessionFilter = nu
 `));
   const recentErrorLines = extractRecentErrors(errorScanWindow, 20);
   const configBody = JSON.stringify(sanitizeConfigValue(report.magicContextConfig.flags), null, 2);
-  const sanitizedConfigPath = report.configPaths.magicContextConfig.replace(homedir12(), "~");
+  const sanitizedConfigPath = report.configPaths.magicContextConfig.replace(homedir13(), "~");
   const rawBodyMarkdown = [
     "## Description",
     description,
@@ -164542,10 +165134,10 @@ async function bundleIssueReport(report, description, _title, sessionFilter = nu
   ].join(`
 `);
   const bodyMarkdown = capBodyToGithubLimit(rawBodyMarkdown);
-  const path5 = join17(process.cwd(), `magic-context-issue-${formatTimestamp(new Date)}.md`);
-  writeFileSync8(path5, `${bodyMarkdown}
+  const path6 = join18(process.cwd(), `magic-context-issue-${formatTimestamp(new Date)}.md`);
+  writeFileSync8(path6, `${bodyMarkdown}
 `);
-  return { path: path5, bodyMarkdown };
+  return { path: path6, bodyMarkdown };
 }
 var HISTORIAN_LOG_PATTERNS;
 var init_logs_opencode = __esm(() => {
@@ -164565,10 +165157,10 @@ var init_logs_opencode = __esm(() => {
 
 // src/commands/doctor-opencode.ts
 import { execSync as execSync2, spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync20, readFileSync as readFileSync14, rmSync, statSync as statSync5, writeFileSync as writeFileSync9 } from "node:fs";
+import { existsSync as existsSync21, readFileSync as readFileSync14, rmSync, statSync as statSync5, writeFileSync as writeFileSync9 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
-import { homedir as homedir13 } from "node:os";
-import { join as join18 } from "node:path";
+import { homedir as homedir14 } from "node:os";
+import { join as join19 } from "node:path";
 function migrateLegacyAgentEnabledConfigForDoctor(mcConfig, logs) {
   let changed = false;
   let fixes = 0;
@@ -164655,14 +165247,14 @@ function compareVersions(a, b2) {
 }
 async function clearPluginCache(force = false) {
   const cacheDir = getOpenCodeCacheDir();
-  const pluginCacheDir = join18(cacheDir, "packages", PLUGIN_ENTRY_WITH_VERSION2);
-  if (!existsSync20(pluginCacheDir)) {
+  const pluginCacheDir = join19(cacheDir, "packages", PLUGIN_ENTRY_WITH_VERSION2);
+  if (!existsSync21(pluginCacheDir)) {
     return { action: "not_found", path: pluginCacheDir };
   }
   let cachedVersion;
   try {
-    const installedPkgPath = join18(pluginCacheDir, "node_modules", "@cortexkit", "opencode-magic-context", "package.json");
-    if (existsSync20(installedPkgPath)) {
+    const installedPkgPath = join19(pluginCacheDir, "node_modules", "@cortexkit", "opencode-magic-context", "package.json");
+    if (existsSync21(installedPkgPath)) {
       const pkg = JSON.parse(readFileSync14(installedPkgPath, "utf-8"));
       if (typeof pkg?.version === "string") {
         cachedVersion = pkg.version;
@@ -164796,8 +165388,8 @@ async function runIssueFlow() {
 }
 function checkLocalEmbeddingRuntimeForDoctor() {
   const runtime = checkLocalEmbeddingRuntime([
-    join18(getOpenCodeCacheDir(), "packages", PLUGIN_ENTRY_WITH_VERSION2),
-    join18(getOpenCodeCacheDir(), "packages", PLUGIN_NAME6)
+    join19(getOpenCodeCacheDir(), "packages", PLUGIN_ENTRY_WITH_VERSION2),
+    join19(getOpenCodeCacheDir(), "packages", PLUGIN_NAME6)
   ]);
   if (runtime.state === "package-missing" || runtime.state === "binary-missing") {
     log.warn("Embedding provider: local — but the native runtime (onnxruntime-node) " + `is ${runtime.state === "package-missing" ? "not installed" : "missing its platform binary"}. ` + "Local embeddings won't work. Fix: re-run with `doctor --force` to reinstall " + "the plugin, or set `embedding.provider` to `openai-compatible` (LM Studio / " + "Ollama) or `off`. Existing memories are unaffected.");
@@ -164807,7 +165399,7 @@ function checkLocalEmbeddingRuntimeForDoctor() {
   return { issues: 0 };
 }
 async function checkEmbeddingConfig(magicContextConfigPath) {
-  if (!existsSync20(magicContextConfigPath)) {
+  if (!existsSync21(magicContextConfigPath)) {
     return checkLocalEmbeddingRuntimeForDoctor();
   }
   let rawText;
@@ -164974,7 +165566,7 @@ async function runDoctor(options = {}) {
   } else {
     pass(`OpenCode config: ${paths.opencodeConfig}`);
   }
-  if (existsSync20(paths.magicContextConfig)) {
+  if (existsSync21(paths.magicContextConfig)) {
     pass(`Magic Context config: ${paths.magicContextConfig}`);
     try {
       const raw = readFileSync14(paths.magicContextConfig, "utf-8");
@@ -165002,7 +165594,7 @@ async function runDoctor(options = {}) {
     warn(`No magic-context.jsonc found — using defaults`);
     log.info("  Run 'setup' to create one with model recommendations");
   }
-  if (existsSync20(paths.magicContextConfig)) {
+  if (existsSync21(paths.magicContextConfig)) {
     try {
       const mcRaw = readFileSync14(paths.magicContextConfig, "utf-8");
       const mcConfig = import_comment_json9.parse(mcRaw);
@@ -165209,7 +165801,7 @@ async function runDoctor(options = {}) {
     pass("Added TUI sidebar plugin to tui.json");
     warn("Restart OpenCode to see the sidebar");
     fixed++;
-  } else if (existsSync20(paths.tuiConfig)) {
+  } else if (existsSync21(paths.tuiConfig)) {
     try {
       const tuiRaw = readFileSync14(paths.tuiConfig, "utf-8");
       const tuiConfig = import_comment_json9.parse(tuiRaw);
@@ -165257,7 +165849,7 @@ async function runDoctor(options = {}) {
   } else {
     pass("TUI sidebar plugin configured (tui.json created)");
   }
-  if (existsSync20(paths.magicContextConfig)) {
+  if (existsSync21(paths.magicContextConfig)) {
     try {
       const mcRaw = readFileSync14(paths.magicContextConfig, "utf-8");
       const mcConfig = import_comment_json9.parse(mcRaw);
@@ -165286,8 +165878,8 @@ async function runDoctor(options = {}) {
     failCount += embeddingCheck.issues;
   else
     passCount++;
-  const dbPath = join18(getMagicContextStorageDir(), "context.db");
-  if (!existsSync20(dbPath)) {
+  const dbPath = join19(getMagicContextStorageDir(), "context.db");
+  if (!existsSync21(dbPath)) {
     log.info(`Shared context DB not yet created at ${dbPath} (will be created on first run)`);
   } else {
     pass(`Shared context DB exists at ${dbPath}`);
@@ -165348,8 +165940,8 @@ async function runDoctor(options = {}) {
   }
   {
     const ageWarnings = [];
-    const npmrcPath = join18(homedir13(), ".npmrc");
-    if (existsSync20(npmrcPath)) {
+    const npmrcPath = join19(homedir14(), ".npmrc");
+    if (existsSync21(npmrcPath)) {
       try {
         const npmrc = readFileSync14(npmrcPath, "utf-8");
         for (const line of npmrc.split(`
@@ -165375,7 +165967,7 @@ async function runDoctor(options = {}) {
     }
   }
   const logPath = getMagicContextLogPath2("opencode");
-  if (existsSync20(logPath)) {
+  if (existsSync21(logPath)) {
     const logStat = statSync5(logPath);
     const sizeKb = (logStat.size / 1024).toFixed(0);
     log.info(`Log file: ${logPath} (${sizeKb} KB)`);
@@ -165447,44 +166039,44 @@ var init_doctor_opencode = __esm(async () => {
 });
 
 // ../pi-plugin/src/config/index.ts
-import { existsSync as existsSync21, readFileSync as readFileSync15 } from "node:fs";
-import { homedir as homedir14 } from "node:os";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync22, readFileSync as readFileSync15 } from "node:fs";
+import { homedir as homedir15 } from "node:os";
+import { join as join20 } from "node:path";
 function getProjectConfigPaths(cwd) {
-  const basePath = join19(cwd, ".pi", CONFIG_FILE_NAME);
+  const basePath = join20(cwd, ".pi", CONFIG_FILE_NAME);
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function getUserConfigPaths() {
-  const home = process.env.HOME ?? homedir14();
-  const basePath = join19(home, ".pi", "agent", CONFIG_FILE_NAME);
+  const home = process.env.HOME ?? homedir15();
+  const basePath = join20(home, ".pi", "agent", CONFIG_FILE_NAME);
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function resolveFirstExisting(paths) {
-  return paths.find((path5) => existsSync21(path5));
+  return paths.find((path6) => existsSync22(path6));
 }
-function loadConfigFile2(path5, scope) {
+function loadConfigFile2(path6, scope) {
   try {
-    const rawText = readFileSync15(path5, "utf-8");
+    const rawText = readFileSync15(path6, "utf-8");
     const substituted = substituteConfigVariables({
       text: rawText,
-      configPath: path5,
+      configPath: path6,
       isProjectConfig: scope === "project"
     });
     return {
-      path: path5,
+      path: path6,
       scope,
       config: import_comment_json10.parse(substituted.text),
-      warnings: substituted.warnings.map((warning) => `${path5}: ${warning}`),
+      warnings: substituted.warnings.map((warning) => `${path6}: ${warning}`),
       loadOutcome: substituted.warnings.length > 0 ? "substitution-failure" : "ok"
     };
   } catch (error51) {
     const message = error51 instanceof Error ? error51.message : String(error51);
     return {
-      path: path5,
+      path: path6,
       scope,
       config: {},
       warnings: [
-        `${path5}: failed to load config: ${message}; using defaults for this file.`
+        `${path6}: failed to load config: ${message}; using defaults for this file.`
       ],
       loadOutcome: typeof error51.code === "string" ? "project-file-io-error" : "project-file-parse-error"
     };
@@ -165640,10 +166232,10 @@ var init_config2 = __esm(() => {
 
 // src/lib/diagnostics-pi.ts
 import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync22, readdirSync as readdirSync3, readFileSync as readFileSync16, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync23, readdirSync as readdirSync3, readFileSync as readFileSync16, statSync as statSync6 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
-import { homedir as homedir15, userInfo as userInfo2 } from "node:os";
-import { join as join20 } from "node:path";
+import { homedir as homedir16, userInfo as userInfo2 } from "node:os";
+import { join as join21 } from "node:path";
 function getSelfVersion3() {
   const req = createRequire5(import.meta.url);
   for (const relPath of ["../../package.json", "../package.json"]) {
@@ -165656,9 +166248,9 @@ function getSelfVersion3() {
   }
   return "unknown";
 }
-function fileSize2(path5) {
+function fileSize2(path6) {
   try {
-    return existsSync22(path5) ? statSync6(path5).size : 0;
+    return existsSync23(path6) ? statSync6(path6).size : 0;
   } catch {
     return 0;
   }
@@ -165674,7 +166266,7 @@ function redactSecretString(value) {
   return value.replace(/Bearer\s+[A-Za-z0-9._~+\-/=]+/g, "Bearer <REDACTED>").replace(/sk-[A-Za-z0-9_-]{12,}/g, "sk-<REDACTED>").replace(/api[_-]?key=([^\s&]+)/gi, "api_key=<REDACTED>").replace(/token=([^\s&]+)/gi, "token=<REDACTED>");
 }
 function sanitizeString2(value) {
-  const home = process.env.HOME || homedir15();
+  const home = process.env.HOME || homedir16();
   const username = userInfo2().username;
   const userHash = `<USER:${currentUserHash()}>`;
   let sanitized = redactSecretString(value);
@@ -165707,12 +166299,12 @@ function sanitizeValue2(value, key = "") {
   }
   return value;
 }
-function readJsonc3(path5) {
-  if (!existsSync22(path5))
+function readJsonc3(path6) {
+  if (!existsSync23(path6))
     return { value: {} };
   try {
     return {
-      value: import_comment_json11.parse(readFileSync16(path5, "utf-8"))
+      value: import_comment_json11.parse(readFileSync16(path6, "utf-8"))
     };
   } catch (error51) {
     return {
@@ -165722,13 +166314,13 @@ function readJsonc3(path5) {
   }
 }
 function getProjectConfigPath(cwd) {
-  return join20(cwd, ".pi", "magic-context.jsonc");
+  return join21(cwd, ".pi", "magic-context.jsonc");
 }
-function readConfigDiagnostic(path5) {
-  const parsed = readJsonc3(path5);
+function readConfigDiagnostic(path6) {
+  const parsed = readJsonc3(path6);
   return {
-    path: path5,
-    exists: existsSync22(path5),
+    path: path6,
+    exists: existsSync23(path6),
     ...parsed.parseError ? { parseError: parsed.parseError } : {},
     flags: sanitizeValue2(parsed.value)
   };
@@ -165745,8 +166337,8 @@ function reverseSlugToDirectory(slug) {
   return `/${inner.replace(/-/g, "/")}`;
 }
 function collectPiRecentSessions() {
-  const sessionsRoot = join20(homedir15(), ".pi", "agent", "sessions");
-  if (!existsSync22(sessionsRoot))
+  const sessionsRoot = join21(homedir16(), ".pi", "agent", "sessions");
+  if (!existsSync23(sessionsRoot))
     return [];
   try {
     const slugs = readdirSync3(sessionsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
@@ -165755,7 +166347,7 @@ function collectPiRecentSessions() {
       const directory = reverseSlugToDirectory(slug);
       if (!directory)
         continue;
-      const slugDir = join20(sessionsRoot, slug);
+      const slugDir = join21(sessionsRoot, slug);
       let files;
       try {
         files = readdirSync3(slugDir).filter((name2) => name2.endsWith(".jsonl"));
@@ -165764,7 +166356,7 @@ function collectPiRecentSessions() {
       }
       for (const file2 of files) {
         try {
-          const mtime = statSync6(join20(slugDir, file2)).mtimeMs;
+          const mtime = statSync6(join21(slugDir, file2)).mtimeMs;
           const sessionId = file2.replace(/\.jsonl$/, "");
           candidates.push({ sessionId, directory, mtime });
         } catch {}
@@ -165780,9 +166372,9 @@ function collectPiRecentSessions() {
     return [];
   }
 }
-function parseHistorianDumpMeta2(path5) {
+function parseHistorianDumpMeta2(path6) {
   try {
-    const xml = readFileSync16(path5, "utf-8");
+    const xml = readFileSync16(path6, "utf-8");
     const parsed = parseCompartmentOutput(xml);
     const factCountByCategory = {};
     for (const fact of parsed.facts) {
@@ -165815,11 +166407,11 @@ function parseHistorianDumpMeta2(path5) {
   }
 }
 function listDumpsInDir2(dir, limit) {
-  if (!existsSync22(dir))
+  if (!existsSync23(dir))
     return { count: 0, recent: [] };
   try {
     const entries = readdirSync3(dir).filter((name2) => name2.endsWith(".xml")).map((name2) => {
-      const stat = statSync6(join20(dir, name2));
+      const stat = statSync6(join21(dir, name2));
       return {
         name: name2,
         mtime: stat.mtimeMs,
@@ -165828,7 +166420,7 @@ function listDumpsInDir2(dir, limit) {
     }).sort((a, b2) => b2.mtime - a.mtime);
     const now = Date.now();
     const recent = entries.slice(0, limit).map((entry) => {
-      const meta3 = parseHistorianDumpMeta2(join20(dir, entry.name));
+      const meta3 = parseHistorianDumpMeta2(join21(dir, entry.name));
       const summary = {
         name: entry.name,
         ageMinutes: Math.round((now - entry.mtime) / 60000),
@@ -165891,9 +166483,9 @@ async function collectDiagnostics2(cwd = process.cwd()) {
   const projectConfigPath = getProjectConfigPath(cwd);
   const loaded = loadPiConfig({ cwd });
   const storageDirPath = getMagicContextStorageDir();
-  const dbPath = join20(storageDirPath, "context.db");
+  const dbPath = join21(storageDirPath, "context.db");
   const logPath = getMagicContextLogPath2("pi");
-  const logFileSize = existsSync22(logPath) ? statSync6(logPath).size : 0;
+  const logFileSize = existsSync23(logPath) ? statSync6(logPath).size : 0;
   const otherPiExtensions = packages.filter((entry) => !isPiMagicContextPackageEntry(entry)).map(describePiPackageEntry);
   const recentSessions = collectPiRecentSessions();
   const historianDumps = collectPiHistorianDumps(recentSessions);
@@ -165908,7 +166500,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     piVersion: pi ? getPiVersion(pi.path) : null,
     settings: {
       path: settingsPath,
-      exists: existsSync22(settingsPath),
+      exists: existsSync23(settingsPath),
       ...settingsParsed.parseError ? { parseError: settingsParsed.parseError } : {},
       hasMagicContextPackage: hasPiMagicContextPackage(packages),
       packages: sanitizeValue2(packages)
@@ -165924,7 +166516,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     loadWarnings: loaded.warnings.map(sanitizeString2),
     storageDir: {
       path: storageDirPath,
-      exists: existsSync22(storageDirPath),
+      exists: existsSync23(storageDirPath),
       contextDbSizeBytes: fileSize2(dbPath)
     },
     conflicts: {
@@ -165933,7 +166525,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     },
     logFile: {
       path: logPath,
-      exists: existsSync22(logPath),
+      exists: existsSync23(logPath),
       sizeKb: Math.round(logFileSize / 1024)
     },
     recentSessions,
@@ -165989,7 +166581,7 @@ function renderDiagnosticsMarkdown2(report) {
     "```",
     "",
     "### Loaded config paths",
-    report.loadedConfigPaths.length === 0 ? "_No config files loaded; defaults are in use._" : report.loadedConfigPaths.map((path5) => `- ${path5}`).join(`
+    report.loadedConfigPaths.length === 0 ? "_No config files loaded; defaults are in use._" : report.loadedConfigPaths.map((path6) => `- ${path6}`).join(`
 `),
     "",
     "### Config load warnings",
@@ -166027,7 +166619,7 @@ var init_diagnostics_pi = __esm(() => {
 
 // src/lib/logs-pi.ts
 import { readFileSync as readFileSync17, writeFileSync as writeFileSync10 } from "node:fs";
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 function sanitizeLogContent2(content) {
   return sanitizeString2(content);
 }
@@ -166092,10 +166684,10 @@ async function bundleIssueReport2(report, description, title, options = {}) {
 `);
   const bodyMarkdown = capBodyToGithubLimit(rawBodyMarkdown);
   const cwd = options.cwd ?? process.cwd();
-  const path5 = join21(cwd, `magic-context-pi-issue-${formatTimestamp2(options.now ?? new Date)}.md`);
-  writeFileSync10(path5, `${bodyMarkdown}
+  const path6 = join22(cwd, `magic-context-pi-issue-${formatTimestamp2(options.now ?? new Date)}.md`);
+  writeFileSync10(path6, `${bodyMarkdown}
 `);
-  return { path: path5, bodyMarkdown };
+  return { path: path6, bodyMarkdown };
 }
 var init_logs_pi = __esm(() => {
   init_diagnostics_pi();
@@ -166105,7 +166697,7 @@ var init_logs_pi = __esm(() => {
 // src/commands/doctor-pi.ts
 import { execFileSync as execFileSync4, spawnSync as spawnSync3 } from "node:child_process";
 import {
-  existsSync as existsSync23,
+  existsSync as existsSync24,
   mkdirSync as mkdirSync7,
   readdirSync as readdirSync4,
   readFileSync as readFileSync18,
@@ -166114,8 +166706,8 @@ import {
   writeFileSync as writeFileSync11
 } from "node:fs";
 import { createRequire as createRequire6 } from "node:module";
-import { homedir as homedir16 } from "node:os";
-import { dirname as dirname10, isAbsolute as isAbsolute3, join as join22 } from "node:path";
+import { homedir as homedir17 } from "node:os";
+import { dirname as dirname10, isAbsolute as isAbsolute3, join as join23 } from "node:path";
 function depsFrom(options) {
   return {
     ...DEFAULT_DEPS,
@@ -166202,10 +166794,10 @@ function summarize(results) {
     fail: results.filter((result) => result.status === "fail").length
   };
 }
-function readJsonc4(path5) {
+function readJsonc4(path6) {
   try {
     return {
-      value: import_comment_json12.parse(readFileSync18(path5, "utf-8"))
+      value: import_comment_json12.parse(readFileSync18(path6, "utf-8"))
     };
   } catch (error51) {
     return {
@@ -166224,24 +166816,24 @@ function piPluginDirCandidates(packages, cwd) {
     const spec = typeof entry === "string" ? entry.trim() : "";
     if (!spec || spec.startsWith("npm:"))
       continue;
-    const resolved = isAbsolute3(spec) ? spec : join22(agentDir, spec);
+    const resolved = isAbsolute3(spec) ? spec : join23(agentDir, spec);
     dirs.push(resolved);
   }
-  dirs.push(join22(agentDir, "npm", "node_modules", PACKAGE_NAME));
-  dirs.push(join22(cwd, ".pi", "npm", "node_modules", PACKAGE_NAME));
-  return dirs.filter((dir) => existsSync23(join22(dir, "package.json")));
+  dirs.push(join23(agentDir, "npm", "node_modules", PACKAGE_NAME));
+  dirs.push(join23(cwd, ".pi", "npm", "node_modules", PACKAGE_NAME));
+  return dirs.filter((dir) => existsSync24(join23(dir, "package.json")));
 }
 function projectConfigPath(cwd) {
-  return join22(cwd, ".pi", "magic-context.jsonc");
+  return join23(cwd, ".pi", "magic-context.jsonc");
 }
-function readConfigForEmbedding(path5) {
-  if (!existsSync23(path5))
+function readConfigForEmbedding(path6) {
+  if (!existsSync24(path6))
     return null;
   try {
-    const rawText = readFileSync18(path5, "utf-8");
+    const rawText = readFileSync18(path6, "utf-8");
     const substituted = substituteConfigVariables({
       text: rawText,
-      configPath: path5
+      configPath: path6
     });
     return import_comment_json12.parse(substituted.text);
   } catch {
@@ -166296,52 +166888,52 @@ function countTable(db, table) {
   }
 }
 function cacheRoots() {
-  const home = homedir16();
-  const cacheHome = process.env.XDG_CACHE_HOME || join22(home, ".cache");
+  const home = homedir17();
+  const cacheHome = process.env.XDG_CACHE_HOME || join23(home, ".cache");
   return [
-    join22(home, ".pi", "cache", "extensions"),
-    join22(home, ".pi", "cache", "packages"),
-    join22(cacheHome, "pi", "extensions"),
-    join22(cacheHome, "pi", "packages"),
-    join22(getPiAgentConfigDir(), "cache", "extensions")
+    join23(home, ".pi", "cache", "extensions"),
+    join23(home, ".pi", "cache", "packages"),
+    join23(cacheHome, "pi", "extensions"),
+    join23(cacheHome, "pi", "packages"),
+    join23(getPiAgentConfigDir(), "cache", "extensions")
   ];
 }
 function findPiMagicContextCacheDirs(self, force = false) {
   const found = new Map;
-  const visit = (path5, depth) => {
-    if (depth < 0 || !existsSync23(path5))
+  const visit = (path6, depth) => {
+    if (depth < 0 || !existsSync24(path6))
       return;
     let stat;
     try {
-      stat = statSync7(path5);
+      stat = statSync7(path6);
     } catch {
       return;
     }
     if (!stat.isDirectory())
       return;
-    const packageJson = join22(path5, "package.json");
-    if (existsSync23(packageJson)) {
+    const packageJson = join23(path6, "package.json");
+    if (existsSync24(packageJson)) {
       try {
         const pkg = JSON.parse(readFileSync18(packageJson, "utf-8"));
         const name2 = typeof pkg.name === "string" ? pkg.name : "";
         const version2 = typeof pkg.version === "string" ? pkg.version : undefined;
-        if (name2 === PACKAGE_NAME || path5.includes("pi-magic-context")) {
+        if (name2 === PACKAGE_NAME || path6.includes("pi-magic-context")) {
           if (force || !version2 || version2 !== self)
-            found.set(path5, { path: path5, version: version2 });
+            found.set(path6, { path: path6, version: version2 });
         }
       } catch {
-        if (path5.includes("pi-magic-context"))
-          found.set(path5, { path: path5 });
+        if (path6.includes("pi-magic-context"))
+          found.set(path6, { path: path6 });
       }
     }
     let entries = [];
     try {
-      entries = readdirSync4(path5);
+      entries = readdirSync4(path6);
     } catch {
       return;
     }
     for (const entry of entries)
-      visit(join22(path5, entry), depth - 1);
+      visit(join23(path6, entry), depth - 1);
   };
   for (const root of cacheRoots())
     visit(root, 5);
@@ -166378,7 +166970,7 @@ async function runHealthChecks(options) {
   }
   const settingsPath = getPiUserExtensionsPath();
   let packages = [];
-  if (!existsSync23(settingsPath)) {
+  if (!existsSync24(settingsPath)) {
     add(results, "warn", `Pi settings not found at ${settingsPath}`);
     repairPlan.addPackageEntry = true;
   } else {
@@ -166398,24 +166990,24 @@ async function runHealthChecks(options) {
   }
   const userConfigPath = getPiUserConfigPath();
   const projectPath = projectConfigPath(options.cwd);
-  for (const [label, path5, required2] of [
+  for (const [label, path6, required2] of [
     ["user", userConfigPath, true],
     ["project", projectPath, false]
   ]) {
-    if (!existsSync23(path5)) {
+    if (!existsSync24(path6)) {
       if (required2) {
-        add(results, "warn", `No ${label} magic-context.jsonc found at ${path5}`);
+        add(results, "warn", `No ${label} magic-context.jsonc found at ${path6}`);
         repairPlan.writeUserConfig = true;
       } else {
-        add(results, "info", `No project Pi magic-context.jsonc found at ${path5}`);
+        add(results, "info", `No project Pi magic-context.jsonc found at ${path6}`);
       }
       continue;
     }
-    const parsed = readJsonc4(path5);
+    const parsed = readJsonc4(path6);
     if (parsed.error)
       add(results, "fail", `${label} magic-context.jsonc is invalid JSONC: ${parsed.error}`);
     else
-      add(results, "pass", `${label} magic-context.jsonc is valid JSONC: ${path5}`);
+      add(results, "pass", `${label} magic-context.jsonc is valid JSONC: ${path6}`);
   }
   const loadedConfig = loadPiConfig({ cwd: options.cwd });
   if (loadedConfig.warnings.length > 0) {
@@ -166435,8 +167027,8 @@ async function runHealthChecks(options) {
     add(results, "pass", `historian.model "${historianModel}" has thinking_level "${historianThinkingLevel}" configured`);
   }
   const storageDir = getMagicContextStorageDir();
-  const dbPath = join22(storageDir, "context.db");
-  const existedBeforeOpen = existsSync23(dbPath);
+  const dbPath = join23(storageDir, "context.db");
+  const existedBeforeOpen = existsSync24(dbPath);
   if (existedBeforeOpen)
     add(results, "pass", `Shared context DB exists at ${dbPath}`);
   else
@@ -166537,7 +167129,7 @@ async function runHealthChecks(options) {
     add(results, "pass", "Pi extension cache clean (no stale cached package found)");
   }
   const logPath = getMagicContextLogPath2("pi");
-  if (existsSync23(logPath)) {
+  if (existsSync24(logPath)) {
     const stat = statSync7(logPath);
     const sizeKb = (stat.size / 1024).toFixed(0);
     const lines = readFileSync18(logPath, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
@@ -166573,13 +167165,13 @@ async function runHealthChecks(options) {
   }
   return { results, repairPlan, ...summarize(results) };
 }
-function writeDefaultMagicContextConfig(path5) {
-  mkdirSync7(dirname10(path5), { recursive: true });
+function writeDefaultMagicContextConfig(path6) {
+  mkdirSync7(dirname10(path6), { recursive: true });
   const config2 = {
     $schema: "https://raw.githubusercontent.com/cortexkit/magic-context/master/assets/magic-context.schema.json",
     ...MagicContextConfigSchema.parse({})
   };
-  writeFileSync11(path5, `${import_comment_json12.stringify(config2, null, 2)}
+  writeFileSync11(path6, `${import_comment_json12.stringify(config2, null, 2)}
 `);
 }
 function repair(plan, prompts) {
@@ -166596,7 +167188,7 @@ function repair(plan, prompts) {
   }
   if (plan.writeUserConfig) {
     const configPath = getPiUserConfigPath();
-    if (!existsSync23(configPath)) {
+    if (!existsSync24(configPath)) {
       try {
         writeDefaultMagicContextConfig(configPath);
         prompts.log.success(`Wrote default Magic Context config to ${configPath}`);
@@ -166606,13 +167198,13 @@ function repair(plan, prompts) {
       }
     }
   }
-  for (const path5 of plan.clearCachePaths) {
+  for (const path6 of plan.clearCachePaths) {
     try {
-      rmSync2(path5, { recursive: true, force: true });
-      prompts.log.success(`Cleared stale Pi extension cache: ${path5}`);
+      rmSync2(path6, { recursive: true, force: true });
+      prompts.log.success(`Cleared stale Pi extension cache: ${path6}`);
       fixed += 1;
     } catch (error51) {
-      console.error(`FAIL Could not clear ${path5}: ${error51 instanceof Error ? error51.message : String(error51)}`);
+      console.error(`FAIL Could not clear ${path6}: ${error51 instanceof Error ? error51.message : String(error51)}`);
     }
   }
   return fixed;
@@ -166737,7 +167329,7 @@ async function runDoctor2(options = {}) {
   prompts.outro(first.fail > 0 ? "Doctor found failures" : "Doctor complete");
   return first.fail > 0 ? 1 : 0;
 }
-function valueAfter(args, flag) {
+function valueAfter2(args, flag) {
   const index = args.indexOf(flag);
   if (index === -1)
     return null;
@@ -166747,7 +167339,7 @@ function valueAfter(args, flag) {
   return next;
 }
 function parseDoctorArgs(args) {
-  const rekeyV22DirIdentity = valueAfter(args, "--rekey-v22-dir-identity");
+  const rekeyV22DirIdentity = valueAfter2(args, "--rekey-v22-dir-identity");
   return {
     force: args.includes("--force"),
     issue: args.includes("--issue"),
@@ -166799,7 +167391,7 @@ var exports_doctor = {};
 __export(exports_doctor, {
   runDoctor: () => runDoctor3
 });
-import { existsSync as existsSync24, rmSync as rmSync3 } from "node:fs";
+import { existsSync as existsSync25, rmSync as rmSync3 } from "node:fs";
 async function runDoctor3(options) {
   if (options.clear)
     return runClear();
@@ -166888,7 +167480,7 @@ async function runClear() {
     const s = spinner();
     s.start(`Clearing ${item.path}`);
     try {
-      if (existsSync24(item.path)) {
+      if (existsSync25(item.path)) {
         rmSync3(item.path, { recursive: true, force: true });
       }
       s.stop(`Cleared ${item.path}`);
@@ -166936,7 +167528,7 @@ function getVersion() {
   }
   return "0.0.0";
 }
-function valueAfter2(args, flag) {
+function valueAfter3(args, flag) {
   const index = args.indexOf(flag);
   if (index === -1)
     return null;
@@ -166960,6 +167552,7 @@ function printUsage() {
   console.log("    doctor --retry-v22-backfill       Retry failed v22 memory backfill rows");
   console.log("    doctor --rekey-v22-dir-identity <path>  Re-key legacy dir identity rows");
   console.log("    doctor migrate   Migrate OpenCode session to Pi JSONL");
+  console.log("    doctor migrate-session   Re-home an OpenCode session to another directory");
   console.log("");
   console.log("  Harness selection:");
   console.log("    --harness opencode    Target OpenCode only");
@@ -166995,8 +167588,12 @@ async function main(argv = process.argv.slice(2)) {
       const { runMigrateCli: runMigrateCli2 } = await init_migrate().then(() => exports_migrate);
       return runMigrateCli2(rest.slice(1));
     }
+    if (rest[0] === "migrate-session") {
+      const { runMigrateSessionCli: runMigrateSessionCli2 } = await init_migrate_session().then(() => exports_migrate_session);
+      return runMigrateSessionCli2(rest.slice(1));
+    }
     const { runDoctor: runDoctor4 } = await init_doctor().then(() => exports_doctor);
-    const rekeyV22DirIdentity = valueAfter2(rest, "--rekey-v22-dir-identity");
+    const rekeyV22DirIdentity = valueAfter3(rest, "--rekey-v22-dir-identity");
     return runDoctor4({
       force: rest.includes("--force"),
       issue: rest.includes("--issue"),