@retaw106/mmc-oc 2.5.0 → 2.7.1

package/dist/tui.js

@@ -0,0 +1,2144 @@
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
+
+// src/config/agent-disable.ts
+var COMPACTION_ENABLED_PATH;
+var init_agent_disable = __esm(() => {
+  COMPACTION_ENABLED_PATH = `compaction${"."}enabled`;
+});
+
+// src/shared/harness.ts
+function getHarness() {
+  return currentHarness;
+}
+var currentHarness = "opencode";
+
+// src/shared/test-temp-dir.ts
+var STALE_TEMP_DIR_AGE_MS, registeredTempDirs;
+var init_test_temp_dir = __esm(() => {
+  STALE_TEMP_DIR_AGE_MS = 60 * 60 * 1000;
+  registeredTempDirs = new Set;
+});
+
+// src/shared/data-path.ts
+import * as os from "node:os";
+import * as path from "node:path";
+function getMagicContextTempDir(harness = getHarness()) {
+  return path.join(os.tmpdir(), harness, "magic-context");
+}
+function getMagicContextLogPath(harness = getHarness()) {
+  const envPath = process.env.MMC_LOG_PATH?.trim();
+  if (envPath)
+    return envPath;
+  return path.join(getMagicContextTempDir(harness), "magic-context.log");
+}
+function getMagicContextStorageResolution() {
+  const testDataDir = process.env.MMC_TEST_DATA_DIR?.trim();
+  if (testDataDir) {
+    const perTestDataHome = process.env.XDG_DATA_HOME?.trim();
+    if (perTestDataHome && path.resolve(perTestDataHome) !== path.resolve(testDataDir)) {
+      return {
+        path: path.join(perTestDataHome, "mmc"),
+        source: "test isolation"
+      };
+    }
+    return {
+      path: path.join(testDataDir, "mmc"),
+      source: "test isolation"
+    };
+  }
+  if (false) {}
+  const explicitStorageDir = process.env.MMC_STORAGE_DIR?.trim();
+  if (explicitStorageDir) {
+    if (!path.isAbsolute(explicitStorageDir)) {
+      throw new Error("MMC_STORAGE_DIR must be an absolute path");
+    }
+    return { path: explicitStorageDir, source: "environment override" };
+  }
+  const xdgDataHome = process.env.XDG_DATA_HOME?.trim();
+  if (xdgDataHome) {
+    return {
+      path: path.join(xdgDataHome, "mmc"),
+      source: "XDG_DATA_HOME"
+    };
+  }
+  return {
+    path: path.join(os.homedir(), ".local", "share", "mmc"),
+    source: "platform default"
+  };
+}
+function getMagicContextStorageDir() {
+  return getMagicContextStorageResolution().path;
+}
+var init_data_path = __esm(() => {
+  init_test_temp_dir();
+});
+
+// src/shared/redaction.ts
+import { homedir as homedir2, userInfo } from "node:os";
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function redactionTypeForKey(key) {
+  const normalized = key.trim().toLowerCase().replace(/[^a-z0-9_.-]+/g, "_");
+  const suffix = normalized.split(".").filter(Boolean).at(-1) ?? normalized;
+  return suffix || "secret";
+}
+function isNonSecretScalarValue(value) {
+  const v = value.trim();
+  if (v === "true" || v === "false" || v === "null" || v === "undefined")
+    return true;
+  return /^[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(v);
+}
+function isSecretKey(key) {
+  const segments = key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().split(/[._-]+/).filter(Boolean);
+  if (segments.length === 0)
+    return false;
+  if (segments.length === 1) {
+    const first = segments[0];
+    return Boolean(first && SECRET_SEGMENT_PATTERN.test(first));
+  }
+  for (let i = 0;i < segments.length; i++) {
+    const seg = segments[i];
+    if (!seg || !SECRET_SEGMENT_PATTERN.test(seg))
+      continue;
+    let trailingOk = true;
+    for (let j = i + 1;j < segments.length; j++) {
+      const tail = segments[j];
+      if (!tail)
+        continue;
+      if (TRAILING_DESCRIPTORS.has(tail))
+        continue;
+      if (SECRET_SEGMENT_PATTERN.test(tail))
+        continue;
+      trailingOk = false;
+      break;
+    }
+    if (!trailingOk)
+      continue;
+    if (UNQUALIFIED_SECRET_SEGMENT_PATTERN.test(seg))
+      return true;
+    for (let k = i - 1;k >= 0; k--) {
+      const lead = segments[k];
+      if (lead && SECRET_QUALIFIERS.has(lead))
+        return true;
+    }
+  }
+  return false;
+}
+function sanitizePathString(value) {
+  const home = process.env.HOME || process.env.USERPROFILE || homedir2();
+  const username = userInfo().username;
+  let sanitized = value;
+  if (home) {
+    sanitized = sanitized.replace(new RegExp(escapeRegex(home), "g"), "~");
+  }
+  sanitized = sanitized.replace(/\/Users\/[^/]+\//g, "/Users/<USER>/");
+  sanitized = sanitized.replace(/\/home\/[^/]+\//g, "/home/<USER>/");
+  sanitized = sanitized.replace(/C:\\Users\\[^\\]+\\/g, "C:\\Users\\<USER>\\");
+  if (username) {
+    sanitized = sanitized.replace(new RegExp(escapeRegex(username), "g"), "<USER>");
+  }
+  return sanitized;
+}
+function redactSecretText(value) {
+  let redacted = value;
+  for (const { pattern, replacement } of SECRET_TEXT_PATTERNS) {
+    if (typeof replacement === "string") {
+      redacted = redacted.replace(pattern, replacement);
+    } else {
+      redacted = redacted.replace(pattern, replacement);
+    }
+  }
+  return redacted;
+}
+function sanitizeDiagnosticText(value) {
+  return redactSecretText(sanitizePathString(value));
+}
+function sanitizeConfigValue(value, keyPath = []) {
+  if (value === null || typeof value === "number" || typeof value === "boolean")
+    return value;
+  const key = keyPath.at(-1) ?? "";
+  if (key && isSecretKey(key)) {
+    return `<REDACTED:${redactionTypeForKey(key)}>`;
+  }
+  if (typeof value === "string")
+    return sanitizeDiagnosticText(value);
+  if (Array.isArray(value)) {
+    return value.map((entry, index) => sanitizeConfigValue(entry, [...keyPath, String(index)]));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([entryKey, entry]) => [
+      entryKey,
+      sanitizeConfigValue(entry, [...keyPath, entryKey])
+    ]));
+  }
+  return value;
+}
+var SECRET_WORDS, SECRET_SEGMENT_PATTERN, TRAILING_DESCRIPTORS, SECRET_QUALIFIERS, UNQUALIFIED_SECRET_SEGMENT_PATTERN, SECRET_TEXT_PATTERNS;
+var init_redaction = __esm(() => {
+  SECRET_WORDS = [
+    "key",
+    "token",
+    "secret",
+    "password",
+    "auth",
+    "authorization",
+    "bearer",
+    "credential"
+  ];
+  SECRET_SEGMENT_PATTERN = new RegExp(`^(?:${SECRET_WORDS.map((w) => `${w}s?`).join("|")})$`, "i");
+  TRAILING_DESCRIPTORS = new Set(["id", "ids", "value", "values", "header", "headers"]);
+  SECRET_QUALIFIERS = new Set([
+    "api",
+    "access",
+    "private",
+    "client",
+    "auth",
+    "authorization",
+    "secret",
+    "bearer",
+    "session",
+    "refresh",
+    "service",
+    "x",
+    "openai",
+    "anthropic",
+    "google",
+    "github",
+    "huggingface",
+    "aws",
+    "azure",
+    "id"
+  ]);
+  UNQUALIFIED_SECRET_SEGMENT_PATTERN = /^(?:password|secret|credential|bearer|authorization)s?$/;
+  SECRET_TEXT_PATTERNS = [
+    {
+      pattern: /\bsk-ant-(?:api03-)?[A-Za-z0-9_-]{32,}/g,
+      replacement: "<ANTHROPIC_API_KEY_REDACTED>"
+    },
+    {
+      pattern: /\bsk-(?:proj-)?[A-Za-z0-9_-]{12,}/g,
+      replacement: "<OPENAI_API_KEY_REDACTED>"
+    },
+    {
+      pattern: /\bgithub_pat_[A-Za-z0-9_]{20,}/g,
+      replacement: "<GITHUB_PAT_REDACTED>"
+    },
+    {
+      pattern: /\b(?:gh[opsu]|ghr)_[A-Za-z0-9]{30,}/g,
+      replacement: "<GITHUB_TOKEN_REDACTED>"
+    },
+    {
+      pattern: /\bhf_[A-Za-z0-9]{30,}/g,
+      replacement: "<HUGGINGFACE_TOKEN_REDACTED>"
+    },
+    {
+      pattern: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g,
+      replacement: "<AWS_ACCESS_KEY_ID_REDACTED>"
+    },
+    {
+      pattern: /\bxox[abprsuvc]-[A-Za-z0-9-]{10,}/g,
+      replacement: "<SLACK_TOKEN_REDACTED>"
+    },
+    {
+      pattern: /\bAIza[A-Za-z0-9_-]{35}\b/g,
+      replacement: "<GOOGLE_API_KEY_REDACTED>"
+    },
+    {
+      pattern: /\b(Authorization\s*:\s*Bearer\s+)([A-Za-z0-9._~+/=-]{8,})/gi,
+      replacement: (_full, prefix) => `${prefix}<REDACTED:bearer>`
+    },
+    {
+      pattern: /\b((?:Proxy-)?Authorization\s*:\s*(?:Basic|Digest|Token|Negotiate|NTLM)\s+)([A-Za-z0-9._~+/=-]{4,})/gi,
+      replacement: (_full, prefix) => `${prefix}<REDACTED:authorization>`
+    },
+    {
+      pattern: /\b((?:x-)?(?:api-?key|api-?token|auth-?token|access-?token)\s*:\s*)([^\s'"`,;<>]{6,})/gi,
+      replacement: (full, prefix, value) => isNonSecretScalarValue(value) ? full : `${prefix}<REDACTED:api_key>`
+    },
+    {
+      pattern: /\b([a-z][a-z0-9+.-]*:\/\/[^\s/:@]+:)([^\s/@]+)(@)/gi,
+      replacement: (_full, prefix, _password, at) => `${prefix}<REDACTED:password>${at}`
+    },
+    {
+      pattern: /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g,
+      replacement: "<JWT_REDACTED>"
+    },
+    {
+      pattern: /(["'])([^"']*(?:key|token|secret|password|auth|bearer|credential)[^"']*)\1(\s*:\s*)(["'])([^"']*)\4/gi,
+      replacement: (full, quote, key, separator, valueQuote, value) => isNonSecretScalarValue(value) ? full : `${quote}${key}${quote}${separator}${valueQuote}<REDACTED:${redactionTypeForKey(key)}>${valueQuote}`
+    },
+    {
+      pattern: /\b([A-Za-z0-9_.-]*(?:key|token|secret|password|auth|bearer|credential)[A-Za-z0-9_.-]*)\s*=\s*([^\s'"`]+)/gi,
+      replacement: (full, key, value) => isNonSecretScalarValue(value) ? full : `${key}=<REDACTED:${redactionTypeForKey(key)}>`
+    }
+  ];
+});
+
+// src/shared/logger.ts
+import * as fs from "node:fs";
+import * as path2 from "node:path";
+function boundBuffer() {
+  while (bufferedBytes > MAX_BUFFERED_BYTES && buffer.length > 0) {
+    bufferedBytes -= Buffer.byteLength(buffer.shift() ?? "");
+    droppedLines++;
+  }
+}
+function recordSwallowedWrite(error) {
+  try {
+    swallowedWriteCount++;
+    lastErrorMessage = sanitizeDiagnosticText(error instanceof Error ? error.message : String(error));
+    lastErrorTime = new Date().toISOString();
+  } catch {}
+}
+function ensureDir(filePath) {
+  fs.mkdirSync(path2.dirname(filePath), { recursive: true });
+}
+function isMissingFile(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function getCurrentLogSize(logFile) {
+  if (activeLogFile === logFile && activeLogSize !== null && flushesSinceSizeCheck < SIZE_CHECK_INTERVAL_FLUSHES) {
+    return activeLogSize;
+  }
+  try {
+    const stat = fs.statSync(logFile);
+    if (!stat.isFile()) {
+      throw new Error(`Magic Context log path is not a regular file: ${logFile}`);
+    }
+    fs.chmodSync(logFile, 384);
+    activeLogFile = logFile;
+    activeLogSize = stat.size;
+    flushesSinceSizeCheck = 0;
+    return stat.size;
+  } catch (error) {
+    if (!isMissingFile(error))
+      throw error;
+    activeLogFile = logFile;
+    activeLogSize = 0;
+    flushesSinceSizeCheck = 0;
+    return 0;
+  }
+}
+function capLogData(data) {
+  if (Buffer.byteLength(data) <= MAX_LOG_FILE_BYTES)
+    return data;
+  let bounded = Buffer.from(data).subarray(0, MAX_LOG_FILE_BYTES).toString("utf8");
+  while (Buffer.byteLength(bounded) > MAX_LOG_FILE_BYTES) {
+    bounded = bounded.slice(0, -1);
+  }
+  return bounded;
+}
+function writeBoundedPredecessor(logFile, predecessorPath, size) {
+  const predecessorFd = fs.openSync(predecessorPath, "w", 384);
+  try {
+    fs.fchmodSync(predecessorFd, 384);
+    const bytesToCopy = Math.min(size, MAX_LOG_FILE_BYTES);
+    const sourceFd = fs.openSync(logFile, "r");
+    try {
+      const chunk = Buffer.allocUnsafe(Math.min(64 * 1024, bytesToCopy));
+      let remaining = bytesToCopy;
+      let position = Math.max(0, size - bytesToCopy);
+      while (remaining > 0) {
+        const bytesRead = fs.readSync(sourceFd, chunk, 0, Math.min(chunk.length, remaining), position);
+        if (bytesRead === 0)
+          break;
+        fs.writeSync(predecessorFd, chunk, 0, bytesRead);
+        remaining -= bytesRead;
+        position += bytesRead;
+      }
+    } finally {
+      fs.closeSync(sourceFd);
+    }
+  } finally {
+    fs.closeSync(predecessorFd);
+  }
+}
+function rotateLogFile(logFile, size) {
+  const predecessorPath = `${logFile}.1`;
+  writeBoundedPredecessor(logFile, predecessorPath, size);
+  fs.truncateSync(logFile, 0);
+  activeLogSize = 0;
+  flushesSinceSizeCheck = 0;
+}
+function flush() {
+  if (flushTimer) {
+    clearTimeout(flushTimer);
+    flushTimer = null;
+  }
+  if (buffer.length === 0 && droppedLines === 0)
+    return;
+  const notice = droppedLines ? `[${new Date().toISOString()}] [magic-context][global] logger dropped ${droppedLines} ${droppedLines === 1 ? "line" : "lines"}: buffer exceeded ${MAX_BUFFERED_BYTES} bytes while writes were pending
+` : "";
+  try {
+    const data = capLogData(notice + buffer.join(""));
+    const logFile = getMagicContextLogPath();
+    ensureDir(logFile);
+    let currentSize = getCurrentLogSize(logFile);
+    const dataSize = Buffer.byteLength(data);
+    if (currentSize > 0 && currentSize + dataSize > MAX_LOG_FILE_BYTES) {
+      flushesSinceSizeCheck = SIZE_CHECK_INTERVAL_FLUSHES;
+      currentSize = getCurrentLogSize(logFile);
+      if (currentSize > 0 && currentSize + dataSize > MAX_LOG_FILE_BYTES) {
+        rotateLogFile(logFile, currentSize);
+        currentSize = 0;
+      }
+    }
+    fs.appendFileSync(logFile, data, { encoding: "utf8", mode: 384 });
+    buffer = [];
+    bufferedBytes = 0;
+    droppedLines = 0;
+    activeLogFile = logFile;
+    activeLogSize = currentSize + dataSize;
+    flushesSinceSizeCheck++;
+  } catch (error) {
+    activeLogFile = null;
+    activeLogSize = null;
+    flushesSinceSizeCheck = 0;
+    recordSwallowedWrite(error);
+    boundBuffer();
+  }
+}
+function scheduleFlush() {
+  if (flushTimer)
+    return;
+  flushTimer = setTimeout(() => {
+    flushTimer = null;
+    flush();
+  }, FLUSH_INTERVAL_MS);
+}
+function log(message, data) {
+  if (isTestEnv)
+    return;
+  try {
+    const timestamp = new Date().toISOString();
+    const serialized = data === undefined ? "" : data instanceof Error ? ` ${sanitizeDiagnosticText(`${data.message}${data.stack ? `
+${data.stack}` : ""}`)}` : ` ${JSON.stringify(sanitizeConfigValue(data))}`;
+    const line = `[${timestamp}] ${sanitizeDiagnosticText(message)}${serialized}
+`;
+    buffer.push(line);
+    bufferedBytes += Buffer.byteLength(line);
+    boundBuffer();
+    if (buffer.length >= BUFFER_SIZE_LIMIT) {
+      flush();
+    } else {
+      scheduleFlush();
+    }
+  } catch {}
+}
+function flushLogger() {
+  flush();
+}
+var isTestEnv = false, buffer, flushTimer = null, FLUSH_INTERVAL_MS = 500, BUFFER_SIZE_LIMIT = 50, MAX_BUFFERED_BYTES, bufferedBytes = 0, droppedLines = 0, MAX_LOG_FILE_BYTES, SIZE_CHECK_INTERVAL_FLUSHES = 64, activeLogFile = null, activeLogSize = null, flushesSinceSizeCheck = 0, swallowedWriteCount = 0, lastErrorMessage = null, lastErrorTime = null;
+var init_logger = __esm(() => {
+  init_data_path();
+  init_redaction();
+  buffer = [];
+  MAX_BUFFERED_BYTES = 1024 * 1024;
+  MAX_LOG_FILE_BYTES = 32 * 1024 * 1024;
+  if (!isTestEnv) {
+    process.on("exit", flush);
+  }
+});
+
+// src/shared/plugin-package-version.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname as dirname2, join as join2 } from "node:path";
+import { fileURLToPath } from "node:url";
+function pluginPackageVersion(moduleUrl = import.meta.url) {
+  const useCache = moduleUrl === import.meta.url;
+  if (useCache && cachedVersion !== undefined)
+    return cachedVersion;
+  let found = null;
+  try {
+    let directory = dirname2(fileURLToPath(moduleUrl));
+    for (let depth = 0;depth < 10; depth++) {
+      const candidate = join2(directory, "package.json");
+      if (existsSync(candidate)) {
+        const parsed = JSON.parse(readFileSync(candidate, "utf8"));
+        if (typeof parsed === "object" && parsed !== null && "name" in parsed && parsed.name === PACKAGE_NAME && "version" in parsed && typeof parsed.version === "string") {
+          found = parsed.version;
+          break;
+        }
+      }
+      const parent = dirname2(directory);
+      if (parent === directory)
+        break;
+      directory = parent;
+    }
+  } catch {}
+  if (useCache)
+    cachedVersion = found;
+  return found;
+}
+var PACKAGE_NAME = "@retaw106/mmc-oc", cachedVersion;
+var init_plugin_package_version = () => {};
+
+// src/shared/harness-provider-map.ts
+var init_harness_provider_map = () => {};
+
+// src/shared/prompt-surface.ts
+var init_prompt_surface = __esm(() => {
+  init_harness_provider_map();
+});
+
+// src/shared/model-cache-ttl.ts
+var init_model_cache_ttl = __esm(() => {
+  init_harness_provider_map();
+  init_prompt_surface();
+});
+
+// src/shared/cache-ttl-display.ts
+var init_cache_ttl_display = __esm(() => {
+  init_model_cache_ttl();
+});
+
+// src/shared/config-diagnostics.ts
+var claimedFailures;
+var init_config_diagnostics = __esm(() => {
+  claimedFailures = new Set;
+});
+// src/shared/user-facing-codes.ts
+function renderUserFacingFailure(key, style = "markdown") {
+  const failure = USER_FACING_FAILURES[key];
+  const action = style === "plain" ? failure.action.replaceAll("`", "") : failure.action;
+  return `${failure.sentence} ${action} (${failure.code})`;
+}
+var USER_FACING_FAILURES;
+var init_user_facing_codes = __esm(() => {
+  USER_FACING_FAILURES = {
+    historian_unavailable: {
+      code: "MC-H01",
+      sentence: "History compression could not finish this turn.",
+      action: "It will retry automatically."
+    },
+    hidden_cleanup_unbound: {
+      code: "MC-H02",
+      sentence: "Some finished background sessions could not be removed from this host.",
+      action: "They are removed automatically the next time Magic Context runs inside a registered OpenCode service."
+    },
+    historian_saved_history_misaligned: {
+      code: "MC-H03",
+      sentence: "History compression is paused because this session's saved summaries no longer line up with its messages.",
+      action: "Run /mmc-recomp to rebuild them."
+    },
+    history_boundary_unresolved: {
+      code: "MC-H04",
+      sentence: "This request was not sent: Magic Context could not safely place the history summary boundary in the loaded conversation, and the untrimmed request is larger than the model's context window.",
+      action: "Reopen this session in its current project directory, then run /mmc-recomp to rebuild the history summary. A model with a larger context window can also help."
+    },
+    history_over_window_unmanaged: {
+      code: "MC-H06",
+      sentence: "This request was not sent: this session's history is larger than the model's context window, and Magic Context does not have a summary of it yet to send in its place.",
+      action: "Send your message again once history compression has caught up, or switch to a model with a larger context window."
+    },
+    frozen_history_over_window: {
+      code: "MC-H07",
+      sentence: "This request was not sent: the conversation is larger than the context window the provider reported, and the compressed history Magic Context has ready does not fit either.",
+      action: "Run /mmc-flush to compress it now, then send your message again."
+    },
+    historian_window_too_small: {
+      code: "MC-H05",
+      sentence: "History compression is paused because the history model's context window is too small for its instructions.",
+      action: "Set historian.model in magic-context.jsonc to a model with a larger context window."
+    },
+    recomp_unavailable: {
+      code: "MC-R01",
+      sentence: "History compression could not be rebuilt.",
+      action: "Run /mmc-recomp again."
+    },
+    status_unavailable: {
+      code: "MC-S01",
+      sentence: "Magic Context status is temporarily unavailable.",
+      action: "Retry /mmc-status in a moment."
+    },
+    transform_update_failed: {
+      code: "MC-S02",
+      sentence: "The last context update did not finish.",
+      action: "Send another message to retry."
+    },
+    transform_pass_degraded: {
+      code: "MC-S06",
+      sentence: "This request was not sent: Magic Context could not finish preparing it, and without that preparation it could be far larger than the previous request.",
+      action: "Send your message again."
+    },
+    configuration_warning: {
+      code: "MC-S03",
+      sentence: "Some configuration settings could not be applied.",
+      action: "Fix the configuration warning shown in /mmc-status, then restart."
+    },
+    status_log_unavailable: {
+      code: "MC-S04",
+      sentence: "Some diagnostic details could not be saved.",
+      action: "Retry /mmc-status in a moment."
+    },
+    memory_writes_paused: {
+      code: "MC-C01",
+      sentence: "Memory writes are paused while the engine syncs.",
+      action: "Retry in a moment."
+    },
+    memory_access_unavailable: {
+      code: "MC-C02",
+      sentence: "Memory access is temporarily unavailable.",
+      action: "Retry in a moment."
+    },
+    note_changes_paused: {
+      code: "MC-C03",
+      sentence: "Note changes are paused while the engine syncs.",
+      action: "Retry in a moment."
+    },
+    note_access_unavailable: {
+      code: "MC-C04",
+      sentence: "Notes are temporarily unavailable.",
+      action: "Retry in a moment."
+    },
+    context_cleanup_paused: {
+      code: "MC-C05",
+      sentence: "Context cleanup is paused while the engine syncs.",
+      action: "Retry in a moment."
+    },
+    partial_history_unavailable: {
+      code: "MC-C06",
+      sentence: "Partial history compression is not available in the current mode.",
+      action: "Run /mmc-recomp without a range."
+    },
+    history_compression_paused: {
+      code: "MC-C09",
+      sentence: "History compression is paused while the engine syncs.",
+      action: "Retry in a moment."
+    },
+    history_compression_needs_message: {
+      code: "MC-C12",
+      sentence: "History compression has not seen this session since Magic Context reconnected.",
+      action: "Send a message in this session first, then run /mmc-wrapup again."
+    },
+    context_service_unavailable: {
+      code: "MC-C10",
+      sentence: "Magic Context is temporarily unavailable.",
+      action: "Retry in a moment."
+    },
+    compaction_marker_missing: {
+      code: "MC-C11",
+      sentence: "The history boundary marker is missing from the OpenCode store, so requests carry the full session.",
+      action: "It is retried on every message; if this persists, run `/mmc-flush`."
+    },
+    memory_mirror_stalled: {
+      code: "MC-M01",
+      sentence: "Memory synchronization stopped before the host mirror caught up.",
+      action: "Send another message to resume it, or run `ck doctor drain-authority`."
+    },
+    memory_authority_mismatch: {
+      code: "MC-M02",
+      sentence: "Memory authority is inconsistent between the host and module.",
+      action: "Run `ck doctor drain-authority` before changing Rust mode."
+    }
+  };
+});
+
+// src/shared/status-summary.ts
+function statusWarningsFromDetail(detail) {
+  const warnings = [];
+  if (detail.lastTransformError)
+    warnings.push("transform_update_failed");
+  if ((detail.historianFailureCount ?? 0) > 0)
+    warnings.push("historian_unavailable");
+  if ((detail.configParseFailures?.length ?? 0) > 0)
+    warnings.push("configuration_warning");
+  if ((detail.loggerDiagnostics?.swallowedWriteCount ?? 0) > 0) {
+    warnings.push("status_log_unavailable");
+  }
+  if (detail.memoryMirror?.stalled)
+    warnings.push("memory_mirror_stalled");
+  if (detail.compactionMarker?.code)
+    warnings.push("compaction_marker_missing");
+  if (detail.memoryAuthorityMismatch)
+    warnings.push("memory_authority_mismatch");
+  warnings.push(...detail.hostLimitations ?? []);
+  return [...new Set(warnings)];
+}
+var init_status_summary = __esm(() => {
+  init_cache_ttl_display();
+  init_user_facing_codes();
+});
+
+// src/shared/status-view-check.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNumber(value) {
+  return typeof value === "number" && !Number.isNaN(value);
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function isUserFacingFailureKey(value) {
+  return typeof value === "string" && Object.hasOwn(USER_FACING_FAILURES, value);
+}
+
+class OptionalFields {
+  raw;
+  ignored = [];
+  constructor(raw) {
+    this.raw = raw;
+  }
+  read(field, accept) {
+    const value = this.raw[field];
+    if (value === undefined)
+      return;
+    if (accept(value))
+      return value;
+    this.ignored.push(field);
+    return;
+  }
+  readArray(field, accept) {
+    const value = this.raw[field];
+    if (value === undefined)
+      return;
+    if (!Array.isArray(value)) {
+      this.ignored.push(field);
+      return;
+    }
+    const kept = value.filter(accept);
+    if (kept.length !== value.length)
+      this.ignored.push(field);
+    return kept;
+  }
+}
+function isWindowGeometry(value) {
+  if (!isRecord(value) || !isNumber(value.usableSoft) || !isRecord(value.derivation))
+    return false;
+  const derivation = value.derivation;
+  return isNumber(derivation.window) && isNumber(derivation.reserve) && isString(derivation.reserveSource);
+}
+function isTailHygiene(value) {
+  return isRecord(value) && isNumber(value.u) && isNumber(value.t) && isNumber(value.severity) && isBoolean(value.evaluable);
+}
+function isCompactionMarker(value) {
+  return isRecord(value) && (value.code === null || value.code === "MC-C11") && isNumber(value.attempts) && (value.lastError === null || isString(value.lastError));
+}
+function isConfigParseFailure(value) {
+  return isRecord(value);
+}
+function isConfigReloadFailure(value) {
+  return isRecord(value) && isString(value.path) && isString(value.message);
+}
+function isUnconfirmedMigrationHolders(value) {
+  return isRecord(value) && Array.isArray(value.pids) && value.pids.every(isNumber) && isNumber(value.fromVersion) && isNumber(value.toVersion);
+}
+function isNullableNumber(value) {
+  return value === null || isNumber(value);
+}
+function isNullableString(value) {
+  return value === null || isString(value);
+}
+function isCacheTtlSource(value) {
+  return isString(value);
+}
+function checkStatusViewSource(candidate) {
+  if (!isRecord(candidate))
+    return { ok: false, fields: ["(the payload is not an object)"] };
+  const missing = [];
+  const numbers = {};
+  for (const field of REQUIRED_NUMBER_FIELDS) {
+    const value = candidate[field];
+    if (isNumber(value))
+      numbers[field] = value;
+    else
+      missing.push(field);
+  }
+  for (const field of REQUIRED_BOOLEAN_FIELDS) {
+    if (!isBoolean(candidate[field]))
+      missing.push(field);
+  }
+  const cacheTtl = isString(candidate.cacheTtl) ? candidate.cacheTtl : undefined;
+  if (cacheTtl === undefined)
+    missing.push("cacheTtl");
+  if (missing.length > 0 || cacheTtl === undefined)
+    return { ok: false, fields: missing };
+  const optional = new OptionalFields(candidate);
+  const source = {
+    ...numbers,
+    isSubagent: candidate.isSubagent === true,
+    cacheExpired: candidate.cacheExpired === true,
+    cacheTtl,
+    compressionBudget: optional.read("compressionBudget", isNullableNumber) ?? null,
+    compressionUsage: optional.read("compressionUsage", isNullableString) ?? null,
+    executeThresholdClamped: optional.read("executeThresholdClamped", isBoolean),
+    windowGeometry: optional.read("windowGeometry", isWindowGeometry),
+    tailHygiene: optional.read("tailHygiene", isTailHygiene),
+    tagCountsAuthoritative: optional.read("tagCountsAuthoritative", isBoolean),
+    compactionMarker: optional.read("compactionMarker", isCompactionMarker),
+    cacheTtlSource: optional.read("cacheTtlSource", isCacheTtlSource),
+    cacheTtlModelKey: optional.read("cacheTtlModelKey", isString),
+    cacheNeverExpires: optional.read("cacheNeverExpires", isBoolean),
+    sessionNoteCount: optional.read("sessionNoteCount", isNumber),
+    archivedCompartmentCount: optional.read("archivedCompartmentCount", isNumber),
+    configParseFailures: optional.readArray("configParseFailures", isConfigParseFailure),
+    configGeneration: optional.read("configGeneration", isNumber),
+    configAdoptedAt: optional.read("configAdoptedAt", isNumber),
+    configReloadFailure: optional.read("configReloadFailure", isConfigReloadFailure),
+    compaction_enabled: optional.read("compaction_enabled", isBoolean),
+    compactionEnabled: optional.read("compactionEnabled", isBoolean),
+    warnings: optional.readArray("warnings", isUserFacingFailureKey),
+    hiddenVariantWarnings: optional.readArray("hiddenVariantWarnings", isString),
+    unconfirmedMigrationHolders: optional.read("unconfirmedMigrationHolders", isUnconfirmedMigrationHolders)
+  };
+  return { ok: true, source, ignoredFields: optional.ignored };
+}
+function statusRpcFailure(message) {
+  return { state: "unavailable", reason: { kind: "rpc_error", message }, versions: null };
+}
+function isRecompProgress(value) {
+  return isRecord(value) && isString(value.phase) && (value.kind === undefined || isString(value.kind)) && isNumber(value.processedMessages) && isNumber(value.totalMessages) && isNumber(value.passCount) && isNumber(value.compartmentsCreated) && (value.message === undefined || isString(value.message)) && (value.note === undefined || isString(value.note));
+}
+function warningInputFrom(raw, optional) {
+  return {
+    lastTransformError: optional.read("lastTransformError", isNullableString) ?? null,
+    historianFailureCount: optional.read("historianFailureCount", isNumber),
+    configParseFailures: optional.readArray("configParseFailures", isConfigParseFailure),
+    loggerDiagnostics: isRecord(raw.loggerDiagnostics) && isNumber(raw.loggerDiagnostics.swallowedWriteCount) ? { swallowedWriteCount: raw.loggerDiagnostics.swallowedWriteCount } : undefined,
+    memoryMirror: isRecord(raw.memoryMirror) ? { stalled: raw.memoryMirror.stalled === true } : undefined,
+    compactionMarker: optional.read("compactionMarker", isCompactionMarker),
+    memoryAuthorityMismatch: raw.memoryAuthorityMismatch === true,
+    hostLimitations: optional.readArray("hostLimitations", isUserFacingFailureKey)
+  };
+}
+function dialogContextLimit(raw) {
+  const { contextLimit, usagePercentage, inputTokens } = raw;
+  if (!isNumber(contextLimit))
+    return contextLimit;
+  if (contextLimit > 0)
+    return contextLimit;
+  if (isFiniteNumber(usagePercentage) && usagePercentage > 0 && isFiniteNumber(inputTokens)) {
+    return Math.round(inputTokens / (usagePercentage / 100));
+  }
+  return 0;
+}
+function checkStatusDetailPayload(raw, uiVersion) {
+  if (!isRecord(raw)) {
+    return {
+      state: "unavailable",
+      reason: { kind: "malformed", fields: ["(the payload is not an object)"] },
+      versions: null
+    };
+  }
+  const versions = {
+    server: isString(raw.pluginVersion) ? raw.pluginVersion : null,
+    ui: uiVersion
+  };
+  if (isString(raw.error)) {
+    return {
+      state: "unavailable",
+      reason: { kind: "rpc_error", message: raw.error },
+      versions: versions.server === null ? null : versions
+    };
+  }
+  if (raw.disabled === true) {
+    return {
+      state: "unavailable",
+      reason: {
+        kind: "not_tracked",
+        cause: raw.paused === true ? "identity_paused" : "home_directory"
+      },
+      versions
+    };
+  }
+  const extrasFields = new OptionalFields(raw);
+  const warnings = statusWarningsFromDetail(warningInputFrom(raw, extrasFields));
+  const checked = checkStatusViewSource({
+    ...raw,
+    contextLimit: dialogContextLimit(raw),
+    warnings
+  });
+  if (!checked.ok) {
+    return {
+      state: "unavailable",
+      reason: { kind: "malformed", fields: checked.fields },
+      versions
+    };
+  }
+  const extras = {
+    recompProgress: extrasFields.read("recompProgress", (value) => value === null || isRecompProgress(value)) ?? null,
+    hostBackendsModuleSide: extrasFields.read("hostBackendsModuleSide", isBoolean) ?? false,
+    historianRunning: extrasFields.read("historianRunning", isBoolean) ?? false,
+    lastTransformError: extrasFields.read("lastTransformError", isNullableString) ?? null
+  };
+  return {
+    state: "ready",
+    source: checked.source,
+    ignoredFields: [...new Set([...checked.ignoredFields, ...extrasFields.ignored])],
+    versions,
+    extras
+  };
+}
+function statusVersionNotice(versions) {
+  if (!versions)
+    return null;
+  if (versions.server === versions.ui)
+    return null;
+  if (versions.server === null) {
+    return `An older Magic Context server (one too old to report its version) is still running, while this UI is ${versions.ui}: quit all OpenCode processes, then start OpenCode again`;
+  }
+  if (compareVersions(versions.server, versions.ui) < 0) {
+    return `An older Magic Context (${versions.server}) server is still running, while this UI is ${versions.ui}: quit all OpenCode processes, then start OpenCode again`;
+  }
+  return `Magic Context server is ${versions.server}, this UI is ${versions.ui}: restart OpenCode`;
+}
+function compareVersions(left, right) {
+  const parts = (version) => version.split(/[-+]/, 1)[0]?.split(".").map((part) => Number.parseInt(part, 10) || 0) ?? [];
+  const a = parts(left);
+  const b = parts(right);
+  for (let index = 0;index < Math.max(a.length, b.length); index++) {
+    const difference = (a[index] ?? 0) - (b[index] ?? 0);
+    if (difference !== 0)
+      return difference;
+  }
+  return 0;
+}
+var REQUIRED_NUMBER_FIELDS, REQUIRED_BOOLEAN_FIELDS;
+var init_status_view_check = __esm(() => {
+  init_status_summary();
+  init_user_facing_codes();
+  REQUIRED_NUMBER_FIELDS = [
+    "usagePercentage",
+    "inputTokens",
+    "contextLimit",
+    "executeThreshold",
+    "systemPromptTokens",
+    "compartmentTokens",
+    "compartmentCount",
+    "factTokens",
+    "memoryTokens",
+    "memoryBlockCount",
+    "conversationTokens",
+    "toolCallTokens",
+    "toolDefinitionTokens",
+    "activeTags",
+    "droppedTags",
+    "totalTags",
+    "activeBytes",
+    "lastNudgeTokens",
+    "pendingOpsCount",
+    "protectedTagCount",
+    "lastResponseTime",
+    "cacheRemainingMs",
+    "historyBlockTokens",
+    "memoryCount"
+  ];
+  REQUIRED_BOOLEAN_FIELDS = [
+    "isSubagent",
+    "cacheExpired"
+  ];
+});
+// src/shared/window-geometry.ts
+var geometryClampLogSeen;
+var init_window_geometry = __esm(() => {
+  init_logger();
+  geometryClampLogSeen = new Set;
+});
+
+// src/shared/status-view.ts
+function unavailableLabel(reason) {
+  if (reason.kind === "rpc_error")
+    return "server did not answer";
+  if (reason.kind === "not_tracked") {
+    return reason.cause === "home_directory" ? "home directory" : "memory paused";
+  }
+  if (reason.kind === "malformed")
+    return "incomplete status data";
+  return "view error";
+}
+function unavailableExplanation(reason, versionNotice) {
+  const persists = "If this persists after a restart, report it with magic-context.log attached.";
+  if (reason.kind === "rpc_error") {
+    return [
+      `The Magic Context server did not return status: ${reason.message}`,
+      renderUserFacingFailure("status_unavailable", "plain")
+    ];
+  }
+  if (reason.kind === "not_tracked" && reason.cause === "home_directory") {
+    return [
+      "This is your home directory, so Magic Context keeps no project history or memory here.",
+      "Set allow_home_project in magic-context.jsonc to opt in."
+    ];
+  }
+  if (reason.kind === "not_tracked") {
+    return [
+      "Magic Context could not work out a project identity for this directory, so its memory features are paused.",
+      'magic-context.log names the cause (search for "memory features paused"), for example a git command that failed.'
+    ];
+  }
+  if (reason.kind === "malformed") {
+    return [
+      `The status reply is missing, or has unexpected values for: ${reason.fields.join(", ")}.`,
+      versionNotice ? "The version difference above is the likely cause." : persists
+    ];
+  }
+  return [`The status view could not be drawn: ${reason.message}`, persists];
+}
+function buildUnavailableStatusView(reason, versions, options) {
+  const label = unavailableLabel(reason);
+  const versionNotice = statusVersionNotice(versions);
+  const rows = [{ label: "Reason", value: label, tone: "warning" }];
+  if (versions) {
+    rows.push({ label: "Server", value: versions.server ?? "not reported", tone: "muted" }, { label: "UI", value: versions.ui, tone: "muted" });
+  }
+  return {
+    title: "⚡ Magic Context Status",
+    version: `v${options.version}`,
+    headline: {
+      left: { text: "Status unavailable", tone: "error" },
+      right: { text: label, tone: "muted" }
+    },
+    windowLine: null,
+    bar: [],
+    breakdown: [],
+    hygiene: null,
+    sections: [{ title: "Status unavailable", labelWidth: 8, rows }],
+    warnings: [
+      ...versionNotice ? [{ text: versionNotice, tone: "error" }] : [],
+      ...unavailableExplanation(reason, versionNotice).map((text) => ({
+        text,
+        tone: "warning"
+      }))
+    ],
+    footer: "Esc to close"
+  };
+}
+var init_status_view = __esm(() => {
+  init_cache_ttl_display();
+  init_config_diagnostics();
+  init_status_view_check();
+  init_user_facing_codes();
+  init_window_geometry();
+});
+
+// src/shared/pi-executable.ts
+var PI_IMAGE_NAMES;
+var init_pi_executable = __esm(() => {
+  PI_IMAGE_NAMES = new Set(["pi", "pi.cmd", "omp", "oh-my-pi"]);
+});
+
+// src/shared/project-directory-key.ts
+import { realpathSync } from "node:fs";
+import path3 from "node:path";
+function projectDirectoryKey(directory) {
+  const slashed = directory.replaceAll("\\", "/").replace(/^\/\/\?\/UNC\//i, "//").replace(/^\/\/\?\//, "");
+  if (/^[a-z]:\//i.test(slashed) || slashed.startsWith("//")) {
+    return path3.win32.normalize(slashed).replaceAll("\\", "/").replace(/\/$/, "").toLowerCase();
+  }
+  return path3.resolve(directory);
+}
+function canonicalProjectDirectory(directory) {
+  let resolved = directory;
+  try {
+    resolved = realpathForCanonicalDirectory(directory);
+  } catch {}
+  return projectDirectoryKey(resolved);
+}
+var realpathForCanonicalDirectory = (directory) => realpathSync.native(directory);
+var init_project_directory_key = () => {};
+
+// src/shared/rpc-utils.ts
+import { execFile, execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { join as join3 } from "node:path";
+function projectHash(directory) {
+  return createHash("sha256").update(canonicalProjectDirectory(directory)).digest("hex").slice(0, 16);
+}
+function legacyProjectHash(directory) {
+  const normalized = directory.replace(/\/+$/, "");
+  return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
+}
+function rpcPortDir(storageDir, directory) {
+  return join3(storageDir, "rpc", projectHash(directory));
+}
+function legacyRpcPortFilePath(storageDir, directory) {
+  return join3(storageDir, "rpc", legacyProjectHash(directory), "port");
+}
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return "dead";
+  if (rpcIdentityPlatform === "win32")
+    return readWindowsProcess(pid).state;
+  try {
+    rpcIdentityProcessKill(pid, 0);
+    return "alive";
+  } catch (error) {
+    return error.code === "ESRCH" ? "dead" : "inconclusive";
+  }
+}
+function parseCsvLine(line) {
+  const fields = [];
+  let field = "";
+  let quoted = false;
+  for (let index = 0;index < line.length; index += 1) {
+    const character = line[index];
+    if (character === '"') {
+      if (quoted && line[index + 1] === '"') {
+        field += '"';
+        index += 1;
+      } else {
+        quoted = !quoted;
+      }
+    } else if (character === "," && !quoted) {
+      fields.push(field);
+      field = "";
+    } else {
+      field += character;
+    }
+  }
+  if (quoted)
+    return null;
+  fields.push(field);
+  return fields;
+}
+function parseTasklistOutput(output) {
+  const entries = [];
+  for (const rawLine of output.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line)
+      continue;
+    const fields = parseCsvLine(line);
+    if (!fields)
+      continue;
+    if (fields[1]?.trim().toLowerCase() === "pid") {
+      continue;
+    }
+    const pid = Number(fields[1]);
+    if (!Number.isInteger(pid) || pid <= 0 || !fields[0])
+      continue;
+    entries.push({ pid, command: fields[0] });
+  }
+  return entries;
+}
+function readWindowsProcess(pid) {
+  try {
+    const output = rpcIdentityExecFileSync("tasklist", ["/FO", "CSV", "/NH", "/FI", `PID eq ${pid}`], {
+      encoding: "utf8",
+      timeout: PS_PROBE_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    const entries = parseTasklistOutput(String(output));
+    if (entries === null)
+      return { state: "inconclusive" };
+    const process2 = entries.find((entry) => entry.pid === pid);
+    return process2 ? { state: "alive", command: process2.command } : { state: "dead" };
+  } catch {
+    return { state: "inconclusive" };
+  }
+}
+function parseRpcPortFile(content, fallbackPid = 0) {
+  const trimmed = content.trim();
+  if (!trimmed)
+    return null;
+  if (trimmed.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      const port = Number(parsed.port);
+      const pid = Number(parsed.pid);
+      const startedAt = Number(parsed.started_at);
+      if (!isValidPort(port) || !Number.isInteger(pid) || pid <= 0)
+        return null;
+      return {
+        port,
+        pid,
+        started_at: Number.isFinite(startedAt) ? startedAt : 0,
+        kind: typeof parsed.kind === "string" ? parsed.kind : undefined,
+        harness: typeof parsed.harness === "string" ? parsed.harness : undefined,
+        token: typeof parsed.token === "string" ? parsed.token : undefined,
+        instance_id: typeof parsed.instance_id === "string" ? parsed.instance_id : undefined
+      };
+    } catch {
+      return null;
+    }
+  }
+  const port = Number.parseInt(trimmed, 10);
+  if (!isValidPort(port))
+    return null;
+  return { port, pid: fallbackPid, started_at: 0 };
+}
+function isValidPort(port) {
+  return Number.isInteger(port) && port > 0 && port <= 65535;
+}
+var ownRpcServerInstanceIds, PS_PROBE_TIMEOUT_MS = 1000, PROCESS_LIST_MAX_BUFFER_BYTES, rpcIdentityExecFileSync, rpcIdentityProcessKill, rpcIdentityPlatform;
+var init_rpc_utils = __esm(() => {
+  init_logger();
+  init_pi_executable();
+  init_project_directory_key();
+  ownRpcServerInstanceIds = new Set;
+  PROCESS_LIST_MAX_BUFFER_BYTES = 8 * 1024 * 1024;
+  rpcIdentityExecFileSync = execFileSync;
+  rpcIdentityProcessKill = process.kill;
+  rpcIdentityPlatform = process.platform;
+});
+
+// src/shared/rpc-client.ts
+import { readdirSync, readFileSync as readFileSync2 } from "node:fs";
+import { join as join4 } from "node:path";
+
+class MagicContextRpcClient {
+  port = null;
+  token = null;
+  instanceId = null;
+  portDir;
+  legacyPortFilePath;
+  healthChecked = false;
+  constructor(storageDir, directory) {
+    this.portDir = rpcPortDir(storageDir, directory);
+    this.legacyPortFilePath = legacyRpcPortFilePath(storageDir, directory);
+  }
+  async call(method, params = {}) {
+    let lastError = null;
+    for (let attempt = 0;attempt < MAX_RERESOLVE_ATTEMPTS; attempt++) {
+      const port = await this.resolvePort();
+      if (!port) {
+        lastError = new Error("Magic Context RPC server not available");
+        this.reset();
+        continue;
+      }
+      try {
+        const response = await this.fetchWithTimeout(`http://127.0.0.1:${port}/rpc/${method}`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...this.token ? { Authorization: `Bearer ${this.token}` } : {}
+          },
+          body: JSON.stringify(params)
+        });
+        if (!response.ok) {
+          const text = await response.text();
+          const error = new Error(`RPC ${method} failed (${response.status}): ${text}`);
+          if (response.status === 401 || response.status >= 500) {
+            lastError = error;
+            this.reset();
+            continue;
+          }
+          error[NON_RETRYABLE_RPC_ERROR] = true;
+          throw error;
+        }
+        return await response.json();
+      } catch (err) {
+        if (isNonRetryableRpcError(err)) {
+          throw err;
+        }
+        lastError = err;
+        this.reset();
+      }
+    }
+    if (lastError instanceof Error) {
+      throw lastError;
+    }
+    throw new Error("Magic Context RPC server not available");
+  }
+  async isAvailable() {
+    try {
+      const port = await this.resolvePort();
+      return port !== null;
+    } catch {
+      return false;
+    }
+  }
+  async resolveEndpoint() {
+    try {
+      const port = await this.resolvePort(1);
+      if (port === null)
+        return null;
+      return { port, token: this.token, instanceId: this.instanceId };
+    } catch {
+      return null;
+    }
+  }
+  async resolvePort(maxAttempts = MAX_RETRIES) {
+    if (this.port && this.healthChecked) {
+      return this.port;
+    }
+    for (let attempt = 0;attempt < maxAttempts; attempt++) {
+      for (const record of this.readPortFiles()) {
+        if (!await this.healthCheck(record))
+          continue;
+        this.port = record.port;
+        this.token = record.token ?? null;
+        this.instanceId = record.instance_id ?? null;
+        this.healthChecked = true;
+        return record.port;
+      }
+      this.reset();
+      if (attempt < maxAttempts - 1) {
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
+      }
+    }
+    return null;
+  }
+  readPortFiles() {
+    const records = [];
+    try {
+      for (const entry of readdirSync(this.portDir)) {
+        if (!entry.startsWith("port-") || !entry.endsWith(".json"))
+          continue;
+        const record = parseRpcPortFile(readFileSync2(join4(this.portDir, entry), "utf-8"));
+        if (!record || isPidAlive(record.pid) === "dead")
+          continue;
+        records.push(record);
+      }
+    } catch {}
+    try {
+      const legacy = parseRpcPortFile(readFileSync2(this.legacyPortFilePath, "utf-8"));
+      if (legacy && (!legacy.pid || isPidAlive(legacy.pid) !== "dead"))
+        records.push(legacy);
+    } catch {}
+    records.sort((a, b) => {
+      const aLocal = a.pid === process.pid ? 1 : 0;
+      const bLocal = b.pid === process.pid ? 1 : 0;
+      return bLocal - aLocal || b.started_at - a.started_at;
+    });
+    return records;
+  }
+  async healthCheck(record) {
+    try {
+      const response = await this.fetchWithTimeout(`http://127.0.0.1:${record.port}/health`, {
+        method: "GET"
+      });
+      if (!response.ok)
+        return false;
+      const body = await response.json();
+      if (body.pid !== record.pid)
+        return false;
+      return body.instance_id === undefined || record.instance_id === undefined || body.instance_id === record.instance_id;
+    } catch {
+      return false;
+    }
+  }
+  async fetchWithTimeout(url, options) {
+    const controller = new AbortController;
+    const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    try {
+      return await fetch(url, { ...options, signal: controller.signal });
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  reset() {
+    this.port = null;
+    this.token = null;
+    this.instanceId = null;
+    this.healthChecked = false;
+  }
+}
+function isNonRetryableRpcError(err) {
+  return typeof err === "object" && err !== null && NON_RETRYABLE_RPC_ERROR in err;
+}
+var MAX_RETRIES = 10, RETRY_DELAY_MS = 500, REQUEST_TIMEOUT_MS = 5000, MAX_RERESOLVE_ATTEMPTS = 3, NON_RETRYABLE_RPC_ERROR;
+var init_rpc_client = __esm(() => {
+  init_rpc_utils();
+  NON_RETRYABLE_RPC_ERROR = Symbol("nonRetryableRpcError");
+});
+
+// src/v2/tui/context-rpc.ts
+function initRpcClient(directory) {
+  const storageDir = getMagicContextStorageDir();
+  rpcGeneration += 1;
+  rpcClient = new MagicContextRpcClient(storageDir, directory);
+  rpcClientDirectory = directory;
+  resetSessionDirectoryClients();
+}
+function resetSessionDirectoryClients() {
+  for (const client of sessionDirectoryClients.values())
+    client.reset();
+  sessionDirectoryClients.clear();
+}
+function clientForDirectory(directory) {
+  if (!rpcClient)
+    return null;
+  if (!directory || directory === rpcClientDirectory)
+    return rpcClient;
+  const existing = sessionDirectoryClients.get(directory);
+  if (existing)
+    return existing;
+  if (sessionDirectoryClients.size >= MAX_SESSION_DIRECTORY_CLIENTS) {
+    const oldest = sessionDirectoryClients.keys().next().value;
+    if (oldest !== undefined) {
+      sessionDirectoryClients.get(oldest)?.reset();
+      sessionDirectoryClients.delete(oldest);
+    }
+  }
+  const client = new MagicContextRpcClient(getMagicContextStorageDir(), directory);
+  sessionDirectoryClients.set(directory, client);
+  return client;
+}
+async function resolveNotificationTarget(sessionDirectory) {
+  const startup = rpcClient;
+  if (!startup)
+    return null;
+  const directory = sessionDirectory ?? "";
+  const client = clientForDirectory(directory) ?? startup;
+  const endpoint = await client.resolveEndpoint();
+  if (endpoint) {
+    return {
+      client,
+      directory: client === startup ? rpcClientDirectory ?? "" : directory,
+      endpoint
+    };
+  }
+  if (client === startup)
+    return null;
+  const startupEndpoint = await startup.resolveEndpoint();
+  return startupEndpoint ? { client: startup, directory: rpcClientDirectory ?? "", endpoint: startupEndpoint } : null;
+}
+function notificationDirectoryFor(sessionDirectory) {
+  const directory = sessionDirectory ?? "";
+  if (!directory || directory === rpcClientDirectory)
+    return rpcClientDirectory ?? "";
+  return directory;
+}
+async function callSessionRpc(directory, method, params) {
+  const client = clientForDirectory(directory);
+  if (!client)
+    throw new Error("RPC client is not initialized");
+  return client.call(method, params);
+}
+function getRpcGeneration() {
+  return rpcGeneration;
+}
+function closeRpc() {
+  rpcGeneration += 1;
+  rpcClient?.reset();
+  rpcClient = null;
+  rpcClientDirectory = null;
+  resetSessionDirectoryClients();
+}
+async function loadStatusDetail(sessionId, directory, modelKey) {
+  if (!rpcClient)
+    return statusRpcFailure("RPC client is not initialized");
+  try {
+    const reply = await callSessionRpc(directory, "status-detail", {
+      sessionId,
+      directory,
+      modelKey
+    });
+    return checkStatusDetailPayload(reply, pluginPackageVersion() ?? "unknown");
+  } catch (error) {
+    return statusRpcFailure(error instanceof Error ? error.message : String(error));
+  }
+}
+async function requestRecomp(sessionId, directory) {
+  if (!rpcClient)
+    return false;
+  try {
+    const result = await callSessionRpc(directory ?? "", "recomp", {
+      sessionId
+    });
+    return result.ok ?? false;
+  } catch {
+    return false;
+  }
+}
+async function callCommandRpc(method, params) {
+  if (!rpcClient)
+    return { ok: false };
+  try {
+    const result = await rpcClient.call(method, params);
+    return result.ok === true ? result : { ok: false, error: result.error };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function requestFlush(sessionId) {
+  return callCommandRpc("flush", { sessionId });
+}
+async function requestWrapup(sessionId, messagesToKeep) {
+  return callCommandRpc("wrapup", { sessionId, messagesToKeep });
+}
+async function requestMaintenance(sessionId) {
+  return callCommandRpc("maintenance", { sessionId, subcommand: "run" });
+}
+var rpcClient = null, rpcClientDirectory = null, rpcGeneration = 0, sessionDirectoryClients, MAX_SESSION_DIRECTORY_CLIENTS = 16;
+var init_context_rpc = __esm(() => {
+  init_data_path();
+  init_plugin_package_version();
+  init_rpc_client();
+  init_status_view_check();
+  sessionDirectoryClients = new Map;
+});
+
+// src/v2/tui/notification-socket.ts
+function logResolveFailure() {
+  resolveFailureCount += 1;
+  if (resolveFailureCount === 1 || resolveFailureCount % 10 === 0) {
+    log(`[tui] notification socket: RPC endpoint not found (attempt ${resolveFailureCount}); retrying`);
+  }
+}
+function startNotificationSocket(options) {
+  opts = options;
+  closed = false;
+  if (!socket && inFlightAttemptId === null)
+    connect();
+  if (!sessionWatchTimer) {
+    sessionWatchTimer = setInterval(watchSession, SESSION_WATCH_MS);
+  }
+}
+function stopNotificationSocket() {
+  closed = true;
+  nextAttemptId += 1;
+  inFlightAttemptId = null;
+  if (reconnectTimer) {
+    clearTimeout(reconnectTimer);
+    reconnectTimer = undefined;
+  }
+  if (sessionWatchTimer) {
+    clearInterval(sessionWatchTimer);
+    sessionWatchTimer = undefined;
+  }
+  try {
+    socket?.close();
+  } catch {}
+  socket = null;
+  opts = null;
+  activeToken = null;
+  helloedSession = null;
+  connectedDirectory = null;
+  lastRetargetAt = 0;
+  reconnectAttempt = 0;
+  activeInstanceId = null;
+  notificationProtocolMode = null;
+  bufferedNotifications.length = 0;
+  lastHandledIdByCursor.clear();
+  handledNotificationIds.clear();
+  handledNotificationIdOrder.length = 0;
+  legacyUnconsumedIdsByCursor.clear();
+  legacyConsumedIdsByCursor.clear();
+  notificationHandlingChain = Promise.resolve();
+}
+function scheduleReconnect() {
+  if (closed)
+    return;
+  if (reconnectTimer)
+    return;
+  const delay = Math.min(RECONNECT_BASE_MS * 2 ** reconnectAttempt, RECONNECT_MAX_MS);
+  reconnectAttempt += 1;
+  reconnectTimer = setTimeout(() => {
+    reconnectTimer = undefined;
+    connect();
+  }, delay);
+}
+async function connect() {
+  if (closed || socket || inFlightAttemptId !== null)
+    return;
+  const attemptId = ++nextAttemptId;
+  const rpcGeneration = getRpcGeneration();
+  inFlightAttemptId = attemptId;
+  const target = await resolveNotificationTarget(opts?.getSessionDirectory?.() ?? null);
+  if (closed || inFlightAttemptId !== attemptId || getRpcGeneration() !== rpcGeneration) {
+    return;
+  }
+  if (target)
+    resolveFailureCount = 0;
+  inFlightAttemptId = null;
+  if (!target) {
+    logResolveFailure();
+    scheduleReconnect();
+    return;
+  }
+  const { client, endpoint } = target;
+  let ws;
+  try {
+    ws = new WebSocket(`ws://127.0.0.1:${endpoint.port}/ws`, {
+      headers: endpoint.token ? { Authorization: `Bearer ${endpoint.token}` } : {}
+    });
+  } catch (error) {
+    log(`[tui] notification socket: WebSocket constructor failed: ${String(error)}`);
+    client.reset();
+    scheduleReconnect();
+    return;
+  }
+  if (closed || getRpcGeneration() !== rpcGeneration || socket) {
+    ws.close();
+    return;
+  }
+  connectGeneration = rpcGeneration;
+  connectedDirectory = target.directory;
+  activeToken = endpoint.token;
+  notificationProtocolMode = null;
+  bufferedNotifications.length = 0;
+  switchNotificationEpoch(endpoint.instanceId ?? LEGACY_INSTANCE_ID);
+  socket = ws;
+  ws.addEventListener("open", () => {
+    if (socket !== ws || getRpcGeneration() !== connectGeneration) {
+      ws.close();
+      return;
+    }
+    reconnectAttempt = 0;
+    log(`[tui] notification socket connected (ws://127.0.0.1:${endpoint.port}, directory=${target.directory || "startup"})`);
+    sendHello(ws, endpoint.token);
+  });
+  ws.addEventListener("message", (event) => {
+    if (socket !== ws)
+      return;
+    handleSocketMessage(ws, String(event.data), endpoint.token);
+  });
+  const onDown = () => {
+    if (socket !== ws)
+      return;
+    client.reset();
+    socket = null;
+    activeToken = null;
+    helloedSession = null;
+    notificationProtocolMode = null;
+    bufferedNotifications.length = 0;
+    scheduleReconnect();
+  };
+  ws.addEventListener("close", onDown);
+  ws.addEventListener("error", onDown);
+}
+function sendHello(ws, token) {
+  const sessionId = opts?.getSessionId() ?? undefined;
+  helloedSession = sessionId ?? null;
+  ws.send(JSON.stringify({
+    type: "hello",
+    protocol: 2,
+    instanceId: activeInstanceId,
+    token: token ?? "",
+    sessionId,
+    lastReceivedId: cursorForKey(cursorKeyForSession(sessionId)),
+    globalLastReceivedId: cursorForKey(cursorKeyForSession(undefined))
+  }));
+}
+function handleSocketMessage(ws, raw, token) {
+  let msg;
+  try {
+    msg = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  if (msg.type === "hello-ack") {
+    if (typeof msg.instanceId === "string") {
+      notificationProtocolMode = "v2";
+      if (msg.instanceId !== activeInstanceId) {
+        switchNotificationEpoch(msg.instanceId);
+        sendHello(ws, token);
+      }
+    } else {
+      notificationProtocolMode = "legacy";
+      switchNotificationEpoch(LEGACY_INSTANCE_ID);
+    }
+    flushBufferedNotifications(ws);
+    return;
+  }
+  if (msg.type === "notification" && msg.notification) {
+    if (notificationProtocolMode === null) {
+      bufferedNotifications.push(msg.notification);
+    } else {
+      queueNotification(ws, msg.notification);
+    }
+    return;
+  }
+  if (msg.type === "error") {
+    try {
+      ws.close();
+    } catch {}
+  }
+}
+function flushBufferedNotifications(ws) {
+  const pending = bufferedNotifications.splice(0);
+  for (const notification of pending)
+    queueNotification(ws, notification);
+}
+function queueNotification(ws, notification) {
+  const deliveryInstanceId = activeInstanceId ?? LEGACY_INSTANCE_ID;
+  const deliveryMode = notificationProtocolMode;
+  if (deliveryMode === null)
+    return;
+  notificationHandlingChain = notificationHandlingChain.then(() => handleNotification(ws, notification, deliveryInstanceId, deliveryMode)).catch(() => {});
+}
+async function handleNotification(ws, notification, deliveryInstanceId, deliveryMode) {
+  if (socket !== ws || getRpcGeneration() !== connectGeneration || activeInstanceId !== deliveryInstanceId || notificationProtocolMode !== deliveryMode) {
+    return;
+  }
+  const active = opts?.getSessionId() ?? null;
+  if (notification.sessionId !== undefined && notification.sessionId !== active)
+    return;
+  if (deliveryMode === "legacy")
+    markLegacyUnconsumed(notification);
+  if (handledNotificationIds.has(notificationDedupKey(notification.id, deliveryInstanceId))) {
+    if (deliveryMode === "legacy")
+      markLegacyConsumed(notification);
+    sendAck(ws, notification, deliveryMode);
+    return;
+  }
+  let consumed = false;
+  try {
+    consumed = await Promise.resolve(opts?.onNotification(notification) ?? false);
+  } catch {
+    consumed = false;
+  }
+  if (socket !== ws || getRpcGeneration() !== connectGeneration || activeInstanceId !== deliveryInstanceId || notificationProtocolMode !== deliveryMode) {
+    return;
+  }
+  if (consumed) {
+    rememberHandledId(notification.id, deliveryInstanceId);
+    if (deliveryMode === "legacy") {
+      markLegacyConsumed(notification);
+    } else {
+      advanceCursor(notificationCursorKey(notification), notification.id);
+    }
+    sendAck(ws, notification, deliveryMode);
+  }
+}
+function cursorKeyForSession(sessionId) {
+  const scope = sessionId ? `${SESSION_CURSOR_PREFIX}${sessionId}` : GLOBAL_CURSOR_KEY;
+  return `${activeInstanceId ?? LEGACY_INSTANCE_ID}:${scope}`;
+}
+function notificationCursorKey(notification) {
+  return cursorKeyForSession(notification.sessionId);
+}
+function cursorForKey(key) {
+  return lastHandledIdByCursor.get(key) ?? 0;
+}
+function advanceCursor(key, id) {
+  if (id > cursorForKey(key))
+    lastHandledIdByCursor.set(key, id);
+}
+function idsForCursor(map, key) {
+  let ids = map.get(key);
+  if (!ids) {
+    ids = new Set;
+    map.set(key, ids);
+  }
+  return ids;
+}
+function markLegacyUnconsumed(notification) {
+  const key = notificationCursorKey(notification);
+  if (idsForCursor(legacyConsumedIdsByCursor, key).has(notification.id))
+    return;
+  idsForCursor(legacyUnconsumedIdsByCursor, key).add(notification.id);
+}
+function markLegacyConsumed(notification) {
+  const key = notificationCursorKey(notification);
+  idsForCursor(legacyUnconsumedIdsByCursor, key).delete(notification.id);
+  const consumedIds = idsForCursor(legacyConsumedIdsByCursor, key);
+  consumedIds.add(notification.id);
+  let safeCursor = Math.max(cursorForKey(key), ...consumedIds);
+  const unconsumedIds = legacyUnconsumedIdsByCursor.get(key);
+  if (unconsumedIds && unconsumedIds.size > 0) {
+    safeCursor = Math.min(safeCursor, Math.min(...unconsumedIds) - 1);
+  }
+  advanceCursor(key, safeCursor);
+  for (const id of consumedIds) {
+    if (id <= cursorForKey(key))
+      consumedIds.delete(id);
+  }
+}
+function notificationDedupKey(id, instanceId = activeInstanceId ?? LEGACY_INSTANCE_ID) {
+  return `${instanceId}:${id}`;
+}
+function rememberHandledId(id, instanceId) {
+  const key = notificationDedupKey(id, instanceId);
+  if (handledNotificationIds.has(key))
+    return;
+  handledNotificationIds.add(key);
+  handledNotificationIdOrder.push(key);
+  while (handledNotificationIdOrder.length > MAX_DEDUPED_NOTIFICATION_IDS) {
+    const evicted = handledNotificationIdOrder.shift();
+    if (evicted !== undefined)
+      handledNotificationIds.delete(evicted);
+  }
+}
+function switchNotificationEpoch(instanceId) {
+  if (activeInstanceId === instanceId)
+    return;
+  activeInstanceId = instanceId;
+  lastHandledIdByCursor.clear();
+  handledNotificationIds.clear();
+  handledNotificationIdOrder.length = 0;
+  legacyUnconsumedIdsByCursor.clear();
+  legacyConsumedIdsByCursor.clear();
+}
+function sendAck(ws, notification, mode) {
+  try {
+    if (mode === "legacy") {
+      const cursor = cursorForKey(notificationCursorKey(notification));
+      ws.send(JSON.stringify({
+        type: "ack",
+        cursor,
+        ...notification.sessionId ? { sessionId: notification.sessionId } : { ackScope: "global" }
+      }));
+      return;
+    }
+    ws.send(JSON.stringify({ type: "ack", ids: [notification.id] }));
+  } catch {}
+}
+function watchSession() {
+  if (closed || !socket || socket.readyState !== WebSocket.OPEN)
+    return;
+  const wanted = notificationDirectoryFor(opts?.getSessionDirectory?.() ?? null);
+  if (wanted !== connectedDirectory && Date.now() - lastRetargetAt >= RETARGET_MIN_INTERVAL_MS) {
+    lastRetargetAt = Date.now();
+    const previous = socket;
+    socket = null;
+    activeToken = null;
+    helloedSession = null;
+    connectedDirectory = null;
+    notificationProtocolMode = null;
+    bufferedNotifications.length = 0;
+    try {
+      previous.close();
+    } catch {}
+    connect();
+    return;
+  }
+  const current = opts?.getSessionId() ?? null;
+  if (current === helloedSession)
+    return;
+  sendHello(socket, activeToken);
+}
+var resolveFailureCount = 0, RECONNECT_BASE_MS = 500, RECONNECT_MAX_MS = 1e4, SESSION_WATCH_MS = 1000, socket = null, reconnectTimer, sessionWatchTimer, reconnectAttempt = 0, closed = false, helloedSession = null, connectedDirectory = null, lastRetargetAt = 0, RETARGET_MIN_INTERVAL_MS = 1e4, opts = null, activeToken = null, connectGeneration = 0, nextAttemptId = 0, inFlightAttemptId = null, GLOBAL_CURSOR_KEY = "global", SESSION_CURSOR_PREFIX = "session:", MAX_DEDUPED_NOTIFICATION_IDS = 500, LEGACY_INSTANCE_ID = "legacy", activeInstanceId = null, notificationProtocolMode = null, bufferedNotifications, lastHandledIdByCursor, handledNotificationIds, handledNotificationIdOrder, legacyUnconsumedIdsByCursor, legacyConsumedIdsByCursor, notificationHandlingChain;
+var init_notification_socket = __esm(() => {
+  init_logger();
+  init_context_rpc();
+  bufferedNotifications = [];
+  lastHandledIdByCursor = new Map;
+  handledNotificationIds = new Set;
+  handledNotificationIdOrder = [];
+  legacyUnconsumedIdsByCursor = new Map;
+  legacyConsumedIdsByCursor = new Map;
+  notificationHandlingChain = Promise.resolve();
+});
+
+// src/v2/tui/session-directory.ts
+function directoryForSession(sessionDirectory, startupDirectory) {
+  return typeof sessionDirectory === "string" && sessionDirectory.length > 0 ? sessionDirectory : startupDirectory;
+}
+function sessionDirectory(context, sessionID) {
+  try {
+    return context.data.session?.get(sessionID)?.location?.directory;
+  } catch {
+    return;
+  }
+}
+
+// src/v2/tui/client.ts
+function compactTokens(value) {
+  if (value >= 1e6)
+    return `${(value / 1e6).toFixed(1)}M`;
+  if (value >= 1000)
+    return `${Math.round(value / 1000)}K`;
+  return String(value);
+}
+function statusText(detail) {
+  const context = detail.contextLimit > 0 ? `${detail.usagePercentage.toFixed(1)}% (${compactTokens(detail.inputTokens)}/${compactTokens(detail.contextLimit)} tokens)` : `${compactTokens(detail.inputTokens)} tokens`;
+  return [
+    ...detail.compaction_enabled === false ? [
+      `Compaction: disabled (${COMPACTION_ENABLED_PATH}: false) — native compaction owns the context window.`
+    ] : [],
+    `Context: ${context}`,
+    `Historian: ${detail.historianRunning ? "running" : "idle"}`,
+    `Compartments: ${detail.compartmentCount}`,
+    `Memories: ${detail.memoryBlockCount} injected / ${detail.memoryCount} stored`,
+    `Pending reductions: ${detail.pendingOpsCount}`,
+    `Harness: opencode2`,
+    ...detail.configGeneration === undefined ? [] : [
+      `Config generation: ${detail.configGeneration} (adopted ${detail.configAdoptedAt ? new Date(detail.configAdoptedAt).toLocaleString() : "unknown"})`
+    ],
+    ...detail.configReloadFailure ? [
+      `Config reload failed ${detail.configReloadFailure.path}: ${detail.configReloadFailure.message}`
+    ] : [],
+    ...detail.lastTransformError ? [`Warning: ${detail.lastTransformError}`] : []
+  ].join(`
+`);
+}
+function statusTextFor(status) {
+  if (status.state === "unavailable") {
+    const view = buildUnavailableStatusView(status.reason, status.versions, {
+      version: pluginPackageVersion() ?? "unknown"
+    });
+    return [
+      `${view.headline.left.text}: ${view.headline.right.text}`,
+      ...view.sections.flatMap((section) => section.rows.map((row) => `${row.label}: ${row.value}`)),
+      ...view.warnings.map((warning) => warning.text)
+    ].join(`
+`);
+  }
+  const notice = statusVersionNotice(status.versions);
+  const text = statusText({
+    ...status.source,
+    historianRunning: status.extras.historianRunning,
+    lastTransformError: status.extras.lastTransformError
+  });
+  return notice ? `${notice}
+${text}` : text;
+}
+function currentSessionID(context) {
+  const route = context.ui.router.current();
+  return route.type === "session" && route.sessionID ? route.sessionID : null;
+}
+function createCommandRunner(context) {
+  return async (title, call, pending) => {
+    const target = currentSessionID(context);
+    if (!target) {
+      context.ui.toast.show({ message: "No active session", variant: "warning" });
+      return false;
+    }
+    const result = await call(target);
+    if (!result.ok) {
+      context.ui.toast.show({
+        message: result.error ?? `${title} request failed`,
+        variant: "error"
+      });
+      return false;
+    }
+    if (result.started) {
+      context.ui.toast.show({ message: pending ?? `${title} started`, variant: "info" });
+      return true;
+    }
+    if (currentSessionID(context) !== target)
+      return false;
+    await context.ui.dialog.alert({ title, message: result.message ?? "" });
+    return true;
+  };
+}
+function buildKeymapLayer(context, hooks) {
+  return {
+    mode: "global",
+    commands: [
+      {
+        id: "magic-context.status",
+        title: "Magic Context: Status",
+        group: "Magic Context",
+        palette: true,
+        slash: { name: "mmc-status" },
+        run: async () => {
+          await hooks.showStatus();
+        }
+      },
+      {
+        id: "magic-context.recomp",
+        title: "Magic Context: Recomp",
+        group: "Magic Context",
+        palette: true,
+        slash: { name: "mmc-recomp" },
+        run: async () => {
+          await hooks.showRecomp();
+        }
+      },
+      {
+        id: "magic-context.flush",
+        title: "Magic Context: Flush",
+        group: "Magic Context",
+        palette: true,
+        slash: { name: "mmc-flush" },
+        run: async () => {
+          await hooks.runCommand("Flush", requestFlush);
+        }
+      },
+      {
+        id: "magic-context.wrapup",
+        title: "Magic Context: Wrapup",
+        group: "Magic Context",
+        palette: true,
+        slash: { name: "mmc-wrapup", arguments: true },
+        run: async (input) => {
+          const argument = input?.trim() ?? "";
+          if (argument !== "" && !/^\d+$/.test(argument)) {
+            context.ui.toast.show({
+              message: "Usage: /mmc-wrapup [messages_to_keep] where messages_to_keep is a positive integer",
+              variant: "warning"
+            });
+            return;
+          }
+          const messagesToKeep = argument === "" ? 20 : Number.parseInt(argument, 10);
+          if (messagesToKeep <= 0) {
+            context.ui.toast.show({
+              message: "messages_to_keep must be a positive integer",
+              variant: "warning"
+            });
+            return;
+          }
+          await hooks.runCommand("Wrapup", (sessionID) => requestWrapup(sessionID, messagesToKeep), "Wrapup started; the summary appears when it finishes");
+        }
+      },
+      {
+        id: "magic-context.maintain",
+        title: "Magic Context: Memory maintenance",
+        group: "Magic Context",
+        palette: true,
+        slash: { name: "mmc-memory-maintain" },
+        run: async () => {
+          await hooks.runCommand("Memory maintenance", requestMaintenance, "Memory maintenance started");
+        }
+      }
+    ]
+  };
+}
+function createNotificationHandler(context, hooks) {
+  return async (notification) => {
+    const target = notification.sessionId ?? currentSessionID(context);
+    if (notification.sessionId && notification.sessionId !== currentSessionID(context))
+      return false;
+    if (notification.type === "toast") {
+      const payload = notification.payload;
+      context.ui.toast.show({
+        title: typeof payload.title === "string" ? payload.title : undefined,
+        message: String(payload.message ?? ""),
+        variant: payload.variant === "success" || payload.variant === "warning" || payload.variant === "error" ? payload.variant : "info",
+        duration: typeof payload.duration === "number" ? payload.duration : undefined
+      });
+      return true;
+    }
+    if (notification.type !== "action")
+      return false;
+    if (notification.payload.action === "show-status-dialog") {
+      return hooks.showStatus(target);
+    }
+    if (notification.payload.action === "show-recomp-dialog")
+      return hooks.showRecomp(target);
+    if (notification.payload.action === "refresh-sidebar")
+      return false;
+    if (notification.payload.action === "show-result-dialog") {
+      await context.ui.dialog.alert({
+        title: String(notification.payload.title ?? "Magic Context"),
+        message: String(notification.payload.message ?? "")
+      });
+      return true;
+    }
+    return false;
+  };
+}
+function createTextClient(context, directoryOf) {
+  const showStatus = async (target = currentSessionID(context)) => {
+    if (!target) {
+      context.ui.toast.show({ message: "No active session", variant: "warning" });
+      return false;
+    }
+    const result = await loadStatusDetail(target, directoryOf(target));
+    if (currentSessionID(context) !== target)
+      return false;
+    await context.ui.dialog.alert({
+      title: "Magic Context status",
+      message: statusTextFor(result)
+    });
+    return true;
+  };
+  const showRecomp = async (target = currentSessionID(context)) => {
+    if (!target) {
+      context.ui.toast.show({ message: "No active session", variant: "warning" });
+      return false;
+    }
+    const confirmed = await context.ui.dialog.confirm({
+      title: "Recomp confirmation",
+      message: "Recomp rebuilds compressed history and can consume significant tokens.",
+      label: { confirm: "Run recomp", cancel: "Cancel" }
+    });
+    if (!confirmed)
+      return true;
+    const requested = await requestRecomp(target, directoryOf(target));
+    context.ui.toast.show({
+      message: requested ? "Recomp requested; historian will start shortly" : "Recomp request failed",
+      variant: requested ? "info" : "error"
+    });
+    return requested;
+  };
+  const handleNotification = createNotificationHandler(context, { showStatus, showRecomp });
+  const runCommand = createCommandRunner(context);
+  let keymapLayerRegistered = false;
+  let keymapGapLogged = false;
+  const registerKeymapLayer = () => {
+    if (keymapLayerRegistered)
+      return true;
+    try {
+      context.keymap.layer(() => buildKeymapLayer(context, { showStatus, showRecomp, runCommand }));
+      keymapLayerRegistered = true;
+      const registered = `registered slash commands: ${buildKeymapLayer(context, {
+        showStatus,
+        showRecomp,
+        runCommand
+      }).commands.map((command) => command.slash.name).join(" ")}`;
+      log(`[magic-context] ${registered}`);
+      flushLogger();
+      return true;
+    } catch (error) {
+      if (!(error instanceof Error) || error.message !== "Keymap.Provider is missing")
+        throw error;
+      return false;
+    }
+  };
+  let unregisterKeymapSlot;
+  if (!registerKeymapLayer()) {
+    unregisterKeymapSlot = context.ui.slot({
+      append: "app",
+      render: () => {
+        let registered = false;
+        try {
+          registered = registerKeymapLayer();
+        } catch (error) {
+          log("[magic-context] keymap.layer registration failed", error);
+        }
+        if (!registered && !keymapGapLogged) {
+          keymapGapLogged = true;
+          log("[magic-context] OpenCode 2 keymap.layer is unavailable; /mmc-status, /mmc-recomp, /mmc-flush, /mmc-wrapup and /mmc-memory-maintain were not registered");
+        }
+        return null;
+      }
+    });
+  }
+  startNotificationSocket({
+    getSessionId: () => currentSessionID(context),
+    getSessionDirectory: () => {
+      const sessionID = currentSessionID(context);
+      return sessionID ? directoryOf(sessionID) : null;
+    },
+    onNotification: handleNotification
+  });
+  return {
+    dispose: () => {
+      unregisterKeymapSlot?.();
+      stopNotificationSocket();
+      closeRpc();
+    }
+  };
+}
+async function setup(context) {
+  const directory = context.location?.directory ?? context.data.location.default().directory;
+  initRpcClient(directory);
+  const directoryOf = (sessionID) => directoryForSession(sessionDirectory(context, sessionID), directory);
+  const client = createTextClient(context, directoryOf);
+  log("[magic-context] @retaw106/mmc-oc v2 text TUI setup");
+  return () => {
+    client.dispose();
+  };
+}
+var init_client = __esm(() => {
+  init_agent_disable();
+  init_logger();
+  init_plugin_package_version();
+  init_status_view();
+  init_status_view_check();
+  init_context_rpc();
+  init_notification_socket();
+});
+
+// src/v2/tui/entry.ts
+async function setup2(context) {
+  const client = await Promise.resolve().then(() => (init_client(), {}));
+  return setup(context);
+}
+var entry_default = { id: "mmc-oc-tui", setup: setup2 };
+export {
+  entry_default as default
+};