@brainmcp/brainmcp 0.1.11 → 0.1.13

package/dist/runtime/brainmcp-hook-runtime.mjs

@@ -0,0 +1,3211 @@
+#!/usr/bin/env node
+
+// src/runtime/index.ts
+import fs11 from "node:fs";
+import path11 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// src/runtime/hook-dispatcher.ts
+import crypto3 from "node:crypto";
+
+// src/lib/cli-contracts.ts
+var PREFERENCES_SCHEMA_VERSION = 1;
+var SESSION_LEDGER_SCHEMA_VERSION = 1;
+var QUEUE_SCHEMA_VERSION = 1;
+function validatePreferencesRecord(data) {
+  if (!data || typeof data !== "object") {
+    throw new Error("Preferences must be an object");
+  }
+  const obj = data;
+  if (obj.version !== PREFERENCES_SCHEMA_VERSION) {
+    throw new Error(`Unsupported preferences schema version: ${String(obj.version)}`);
+  }
+  if (!obj.consent || typeof obj.consent !== "object") {
+    throw new Error("Preferences must include a consent object");
+  }
+  const consent = obj.consent;
+  if (typeof consent.captureEnabled !== "boolean") {
+    throw new Error("consent.captureEnabled must be a boolean");
+  }
+  if (typeof consent.includePrompts !== "boolean") {
+    throw new Error("consent.includePrompts must be a boolean");
+  }
+  if (typeof consent.policyVersion !== "string" || !consent.policyVersion) {
+    throw new Error("consent.policyVersion must be a non-empty string");
+  }
+  return {
+    version: PREFERENCES_SCHEMA_VERSION,
+    consent: {
+      captureEnabled: consent.captureEnabled,
+      includePrompts: consent.includePrompts,
+      policyVersion: consent.policyVersion,
+      consentedAt: typeof consent.consentedAt === "string" ? consent.consentedAt : void 0,
+      revision: typeof consent.revision === "number" && Number.isSafeInteger(consent.revision) ? Math.max(0, consent.revision) : 0
+    },
+    enabledWorkspaceId: typeof obj.enabledWorkspaceId === "string" ? obj.enabledWorkspaceId : void 0,
+    nudgeEnabled: typeof obj.nudgeEnabled === "boolean" ? obj.nudgeEnabled : false
+  };
+}
+function validateSessionLedgerRecord(data) {
+  if (!data || typeof data !== "object") {
+    throw new Error("Session ledger must be an object");
+  }
+  const obj = data;
+  if (obj.version !== SESSION_LEDGER_SCHEMA_VERSION) {
+    throw new Error(`Unsupported session ledger schema version: ${String(obj.version)}`);
+  }
+  if (typeof obj.sessionKey !== "string" || !obj.sessionKey) {
+    throw new Error("Session ledger requires a sessionKey");
+  }
+  return {
+    version: SESSION_LEDGER_SCHEMA_VERSION,
+    sessionKey: obj.sessionKey,
+    createdAt: typeof obj.createdAt === "string" ? obj.createdAt : (/* @__PURE__ */ new Date()).toISOString(),
+    lastEventAt: typeof obj.lastEventAt === "string" ? obj.lastEventAt : (/* @__PURE__ */ new Date()).toISOString(),
+    eventSequence: typeof obj.eventSequence === "number" ? obj.eventSequence : 0,
+    lastMeaningfulAt: typeof obj.lastMeaningfulAt === "string" ? obj.lastMeaningfulAt : void 0,
+    lastMeaningfulSequence: typeof obj.lastMeaningfulSequence === "number" ? obj.lastMeaningfulSequence : void 0,
+    lastSuccessfulWriteBackAt: typeof obj.lastSuccessfulWriteBackAt === "string" ? obj.lastSuccessfulWriteBackAt : void 0,
+    lastSuccessfulWriteBackSequence: typeof obj.lastSuccessfulWriteBackSequence === "number" ? obj.lastSuccessfulWriteBackSequence : void 0,
+    lastCapturedAt: typeof obj.lastCapturedAt === "string" ? obj.lastCapturedAt : void 0,
+    lastCapturedSequence: typeof obj.lastCapturedSequence === "number" ? obj.lastCapturedSequence : void 0,
+    lastNudgedAt: typeof obj.lastNudgedAt === "string" ? obj.lastNudgedAt : void 0,
+    lastNudgedSequence: typeof obj.lastNudgedSequence === "number" ? obj.lastNudgedSequence : void 0,
+    editedPaths: Array.isArray(obj.editedPaths) ? obj.editedPaths.filter((p) => typeof p === "string").slice(0, 100) : [],
+    prompts: Array.isArray(obj.prompts) ? obj.prompts.filter((p) => typeof p === "string").slice(0, 50) : void 0,
+    assistantSummary: typeof obj.assistantSummary === "string" ? obj.assistantSummary.slice(0, 4e3) : void 0,
+    model: typeof obj.model === "string" ? obj.model.slice(0, 120) : void 0,
+    deliveryIds: Array.isArray(obj.deliveryIds) ? obj.deliveryIds.filter((d) => typeof d === "string").slice(-100) : [],
+    captureRevision: typeof obj.captureRevision === "number" ? obj.captureRevision : void 0,
+    projectKey: typeof obj.projectKey === "string" ? obj.projectKey : void 0,
+    workspaceId: typeof obj.workspaceId === "string" ? obj.workspaceId : void 0
+  };
+}
+function validateQueueItemRecord(data) {
+  if (!data || typeof data !== "object") {
+    throw new Error("Queue item must be an object");
+  }
+  const obj = data;
+  if (obj.version !== QUEUE_SCHEMA_VERSION) {
+    throw new Error(`Unsupported queue schema version: ${String(obj.version)}`);
+  }
+  if (typeof obj.digestId !== "string" || !obj.digestId) {
+    throw new Error("Queue item requires a digestId");
+  }
+  if (typeof obj.workspaceId !== "string" || !obj.workspaceId) {
+    throw new Error("Queue item requires a workspaceId");
+  }
+  return {
+    version: QUEUE_SCHEMA_VERSION,
+    digestId: obj.digestId,
+    workspaceId: obj.workspaceId,
+    captureTrigger: obj.captureTrigger ?? "manual",
+    policyVersion: typeof obj.policyVersion === "string" ? obj.policyVersion : "2026-09-02.capture-v1",
+    digestText: typeof obj.digestText === "string" ? obj.digestText : "",
+    authorizationId: typeof obj.authorizationId === "string" ? obj.authorizationId : void 0,
+    consentRevision: typeof obj.consentRevision === "number" && Number.isSafeInteger(obj.consentRevision) ? Math.max(0, obj.consentRevision) : void 0,
+    status: obj.status ?? "pending",
+    attempts: typeof obj.attempts === "number" ? obj.attempts : 0,
+    nextRetryAt: typeof obj.nextRetryAt === "string" ? obj.nextRetryAt : void 0,
+    lastError: typeof obj.lastError === "string" ? obj.lastError : void 0,
+    createdAt: typeof obj.createdAt === "string" ? obj.createdAt : (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: typeof obj.updatedAt === "string" ? obj.updatedAt : typeof obj.createdAt === "string" ? obj.createdAt : (/* @__PURE__ */ new Date()).toISOString(),
+    deliveredAt: typeof obj.deliveredAt === "string" ? obj.deliveredAt : void 0,
+    deliveryLease: obj.deliveryLease && typeof obj.deliveryLease === "object" && typeof obj.deliveryLease.owner === "string" && typeof obj.deliveryLease.expiresAt === "string" ? obj.deliveryLease : void 0
+  };
+}
+function scrubSecrets(input) {
+  return input.replace(/\b(bearer\s+)?([A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,})\b/gi, "[redacted-jwt]").replace(/\b(AKIA[0-9A-Z]{16})\b/g, "[redacted-access-key]").replace(/(password|passwd|api[_-]?key|secret|token)\s*[:=]\s*([^\s"'`<>{}]{8,})/gi, "$1=[redacted-secret]");
+}
+function filterRelativePaths(paths, rootDir) {
+  const normalizedRoot = rootDir.replace(/\\/g, "/").replace(/\/+$/, "");
+  const out = [];
+  for (const raw of paths) {
+    const p = raw.replace(/\\/g, "/");
+    if (p.startsWith("/") || /^[a-zA-Z]:\//.test(p)) {
+      if (p.startsWith(normalizedRoot + "/")) {
+        out.push(p.slice(normalizedRoot.length + 1));
+      }
+    } else if (!p.startsWith("../") && !p.includes("/../")) {
+      out.push(p);
+    }
+  }
+  return out;
+}
+
+// src/hooks/claude.ts
+function parseClaudeEvent(raw, eventName = "SessionStart") {
+  const input = raw && typeof raw === "object" ? raw : {};
+  return {
+    client: "claude-code",
+    event: eventName,
+    sessionKey: input.session_id || "default_session",
+    cwd: input.cwd,
+    source: input.source,
+    transcriptPath: input.transcript_path,
+    prompt: input.prompt,
+    toolName: input.tool_name,
+    toolInput: input.tool_input,
+    toolResult: input.tool_response ?? input.tool_result,
+    stopHookActive: Boolean(input.stop_hook_active),
+    model: input.model
+  };
+}
+function emitClaudeOutput(event, additionalContext) {
+  if (event.event === "StopNudge" && !event.stopHookActive && additionalContext) {
+    return { decision: "block", reason: additionalContext };
+  }
+  if (event.event === "Stop" || event.stopHookActive) {
+    return {};
+  }
+  if (event.event === "SessionStart" && additionalContext) {
+    return {
+      hookSpecificOutput: {
+        hookEventName: "SessionStart",
+        additionalContext
+      }
+    };
+  }
+  return {};
+}
+
+// src/hooks/codex.ts
+function parseCodexEvent(raw, eventName = "SessionStart") {
+  const input = raw && typeof raw === "object" ? raw : {};
+  return {
+    client: "codex",
+    event: eventName,
+    sessionKey: input.session_id || "default_session",
+    cwd: input.cwd,
+    source: input.source,
+    status: input.status ?? input.reason,
+    prompt: input.prompt,
+    toolName: input.tool_name,
+    toolInput: input.tool_input,
+    toolResult: input.tool_result ?? input.tool_response,
+    model: input.model
+  };
+}
+function emitCodexOutput(event, additionalContext) {
+  if (event.event === "SessionStart" && additionalContext) {
+    return {
+      hookSpecificOutput: {
+        hookEventName: "SessionStart",
+        additionalContext
+      }
+    };
+  }
+  return {};
+}
+
+// src/hooks/cursor.ts
+function parseCursorEvent(raw, eventName = "sessionStart") {
+  const input = raw && typeof raw === "object" ? raw : {};
+  return {
+    client: "cursor",
+    event: eventName,
+    sessionKey: input.session_id || input.conversation_id || "default_session",
+    workspaceRoots: input.workspace_roots,
+    cwd: input.cwd,
+    prompt: input.prompt,
+    assistantText: input.text,
+    toolName: input.tool_name,
+    toolInput: input.tool_input,
+    toolResult: input.tool_result ?? input.tool_output,
+    status: input.final_status ?? input.reason,
+    model: input.model_id ?? input.model
+  };
+}
+function emitCursorOutput(event, additionalContext) {
+  if (event.event === "sessionStart" && additionalContext) {
+    return {
+      additional_context: additionalContext
+    };
+  }
+  return {};
+}
+
+// src/hooks/vscode.ts
+function parseVsCodeEvent(raw, eventName = "sessionStart") {
+  const input = raw && typeof raw === "object" ? raw : {};
+  return {
+    client: "vscode",
+    event: eventName,
+    sessionKey: input.session_id || input.sessionId || "default_session",
+    cwd: input.cwd || input.workspace,
+    source: input.source,
+    prompt: input.prompt,
+    toolName: input.tool_name,
+    toolInput: input.tool_input,
+    toolResult: input.tool_result ?? input.tool_response,
+    model: input.model
+  };
+}
+function emitVsCodeOutput(event, additionalContext) {
+  if ((event.event === "SessionStart" || event.event === "sessionStart") && additionalContext) {
+    return {
+      hookSpecificOutput: {
+        hookEventName: "SessionStart",
+        additionalContext
+      }
+    };
+  }
+  return {};
+}
+
+// src/hooks/adapters.ts
+function parseHostEvent(client, raw, eventName) {
+  switch (client) {
+    case "claude-code":
+      return parseClaudeEvent(raw, eventName);
+    case "codex":
+      return parseCodexEvent(raw, eventName);
+    case "cursor":
+      return parseCursorEvent(raw, eventName);
+    case "vscode":
+      return parseVsCodeEvent(raw, eventName);
+    default:
+      throw new Error(`Unsupported hook host: ${client}`);
+  }
+}
+function emitHostOutput(client, event, additionalContext) {
+  switch (client) {
+    case "claude-code":
+      return emitClaudeOutput(event, additionalContext);
+    case "codex":
+      return emitCodexOutput(event, additionalContext);
+    case "cursor":
+      return emitCursorOutput(event, additionalContext);
+    case "vscode":
+      return emitVsCodeOutput(event, additionalContext);
+    default:
+      return {};
+  }
+}
+
+// src/runtime/session.ts
+import fs6 from "node:fs";
+import path6 from "node:path";
+import { createHash } from "node:crypto";
+
+// src/runtime/queue.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+
+// src/runtime/storage.ts
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import crypto from "node:crypto";
+var CURRENT_ACCOUNT_SCHEMA_VERSION = 1;
+var SERVICE_ACCOUNT_ID = "service";
+var ACCOUNTS_DIR_NAME = "accounts";
+var CURRENT_ACCOUNT_FILENAME = "current.json";
+var LEGACY_STATE_NAMES = [
+  "preferences.json",
+  "credentials.json",
+  "credentials.lock",
+  "credentials.backend.json",
+  "queue",
+  "sessions",
+  "cache",
+  "locks",
+  "logs"
+];
+function getBrainHome() {
+  const override = process.env.BRAINMCP_HOME ?? process.env.BRAIN_HOME;
+  if (override) {
+    return path.resolve(override);
+  }
+  return path.join(os.homedir(), ".brainmcp");
+}
+function sanitizeAccountId(accountId) {
+  const trimmed = accountId.trim();
+  if (!trimmed) {
+    throw new Error("Account id is required");
+  }
+  if (/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(trimmed) && !trimmed.includes("..")) {
+    return trimmed;
+  }
+  const digest = crypto.createHash("sha256").update(trimmed).digest("hex").slice(0, 32);
+  return `id-${digest}`;
+}
+function getCurrentAccountPath(brainHome) {
+  return path.join(brainHome ?? getBrainHome(), CURRENT_ACCOUNT_FILENAME);
+}
+function validateCurrentAccountRecord(data) {
+  if (!data || typeof data !== "object") {
+    throw new Error("Current account pointer must be an object");
+  }
+  const obj = data;
+  if (obj.version !== CURRENT_ACCOUNT_SCHEMA_VERSION) {
+    throw new Error(`Unsupported current-account schema version: ${String(obj.version)}`);
+  }
+  if (typeof obj.accountId !== "string" || !obj.accountId.trim()) {
+    throw new Error("Current account pointer requires accountId");
+  }
+  return {
+    version: CURRENT_ACCOUNT_SCHEMA_VERSION,
+    accountId: sanitizeAccountId(obj.accountId),
+    updatedAt: typeof obj.updatedAt === "string" ? obj.updatedAt : (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function getCurrentAccountId(brainHome) {
+  const record = readSafeJson(getCurrentAccountPath(brainHome), validateCurrentAccountRecord);
+  return record?.accountId ?? null;
+}
+function getAccountStateDir(brainHome, accountId) {
+  const home = path.resolve(brainHome);
+  const id = sanitizeAccountId(accountId);
+  return path.join(home, ACCOUNTS_DIR_NAME, id);
+}
+function resolveStateDir(brainHome) {
+  const home = brainHome ?? getBrainHome();
+  const accountId = getCurrentAccountId(home);
+  if (!accountId) return home;
+  const accountsDir = path.join(path.resolve(home), ACCOUNTS_DIR_NAME);
+  ensureDirectory0700(accountsDir);
+  const dir = getAccountStateDir(home, accountId);
+  ensureDirectory0700(dir);
+  return dir;
+}
+function switchCurrentAccount(brainHome, accountId) {
+  const home = path.resolve(brainHome);
+  ensureDirectory0700(home);
+  const id = sanitizeAccountId(accountId);
+  const accountsDir = path.join(home, ACCOUNTS_DIR_NAME);
+  ensureDirectory0700(accountsDir);
+  const stateDir = getAccountStateDir(home, id);
+  ensureDirectory0700(stateDir);
+  writeAtomic0600(
+    getCurrentAccountPath(home),
+    JSON.stringify(
+      {
+        version: CURRENT_ACCOUNT_SCHEMA_VERSION,
+        accountId: id,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      null,
+      2
+    )
+  );
+  return stateDir;
+}
+function clearCurrentAccount(brainHome) {
+  const currentPath = getCurrentAccountPath(brainHome);
+  if (!fs.existsSync(currentPath)) return;
+  assertNotSymlink(currentPath);
+  fs.unlinkSync(currentPath);
+}
+function migrateLegacyFlatState(brainHome, accountId) {
+  const home = path.resolve(brainHome);
+  const dest = getAccountStateDir(home, accountId);
+  ensureDirectory0700(path.join(home, ACCOUNTS_DIR_NAME));
+  ensureDirectory0700(dest);
+  const migrated = [];
+  for (const name of LEGACY_STATE_NAMES) {
+    const from = path.join(home, name);
+    const to = path.join(dest, name);
+    if (!fs.existsSync(from) || fs.existsSync(to)) continue;
+    assertNotSymlink(from);
+    fs.renameSync(from, to);
+    migrated.push(name);
+  }
+  return migrated;
+}
+function activateAccount(brainHome, accountId) {
+  const migratedInto = switchCurrentAccount(brainHome, accountId);
+  migrateLegacyFlatState(brainHome, accountId);
+  return migratedInto;
+}
+function ensureDirectory0700(dirPath) {
+  const resolved = path.resolve(dirPath);
+  if (fs.existsSync(resolved)) {
+    const stat = fs.lstatSync(resolved);
+    if (stat.isSymbolicLink()) {
+      throw new Error(`Security violation: directory ${resolved} is a symbolic link`);
+    }
+    if (!stat.isDirectory()) {
+      throw new Error(`Path ${resolved} is not a directory`);
+    }
+    if (process.platform !== "win32") {
+      const mode = stat.mode & 511;
+      if (mode !== 448) {
+        fs.chmodSync(resolved, 448);
+      }
+    }
+    return;
+  }
+  let existingParent = path.dirname(resolved);
+  while (!fs.existsSync(existingParent)) {
+    const next = path.dirname(existingParent);
+    if (next === existingParent) break;
+    existingParent = next;
+  }
+  if (fs.existsSync(existingParent) && fs.lstatSync(existingParent).isSymbolicLink()) {
+    throw new Error(`Security violation: directory parent ${existingParent} is a symbolic link`);
+  }
+  fs.mkdirSync(resolved, { recursive: true, mode: 448 });
+}
+function assertNotSymlink(targetPath) {
+  const resolved = path.resolve(targetPath);
+  const stat = fs.lstatSync(resolved, { throwIfNoEntry: false });
+  if (stat?.isSymbolicLink()) {
+    throw new Error(`Security violation: ${resolved} is a symbolic link`);
+  }
+}
+function writeAtomic0600(filePath, content) {
+  const resolved = path.resolve(filePath);
+  const dir = path.dirname(resolved);
+  ensureDirectory0700(dir);
+  assertNotSymlink(resolved);
+  const tmpPath = `${resolved}.tmp.${crypto.randomUUID()}`;
+  const noFollow = typeof fs.constants.O_NOFOLLOW === "number" ? fs.constants.O_NOFOLLOW : 0;
+  try {
+    const fd = fs.openSync(
+      tmpPath,
+      fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY | noFollow,
+      384
+    );
+    try {
+      fs.writeSync(fd, content, 0, "utf8");
+      fs.fsyncSync(fd);
+    } finally {
+      fs.closeSync(fd);
+    }
+    fs.renameSync(tmpPath, resolved);
+  } catch (error) {
+    try {
+      fs.unlinkSync(tmpPath);
+    } catch {
+    }
+    throw error;
+  }
+  if (process.platform !== "win32") {
+    fs.chmodSync(resolved, 384);
+  }
+}
+function readSafeJson(filePath, validator) {
+  const resolved = path.resolve(filePath);
+  if (!fs.existsSync(resolved)) {
+    return null;
+  }
+  assertNotSymlink(resolved);
+  const stat = fs.lstatSync(resolved);
+  if (!stat.isFile()) {
+    throw new Error(`Security violation: ${resolved} is not a regular file`);
+  }
+  if (process.platform !== "win32") {
+    const mode = stat.mode & 511;
+    if (mode !== 384) {
+      throw new Error(`Security violation: ${resolved} permissions are ${mode.toString(8)}, expected 600`);
+    }
+    if (process.getuid && stat.uid !== process.getuid()) {
+      throw new Error(`Security violation: ${resolved} is not owned by the current user`);
+    }
+  }
+  const raw = fs.readFileSync(resolved, "utf8");
+  try {
+    const parsed = JSON.parse(raw);
+    if (validator) {
+      return validator(parsed);
+    }
+    return parsed;
+  } catch (err) {
+    throw new Error(`Corrupt or invalid JSON in ${resolved}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function getPreferencesPath(baseDir) {
+  return path.join(resolveStateDir(baseDir), "preferences.json");
+}
+function readPreferences(baseDir) {
+  return readSafeJson(getPreferencesPath(baseDir), validatePreferencesRecord);
+}
+function writePreferences(prefs, baseDir) {
+  writeAtomic0600(getPreferencesPath(baseDir), JSON.stringify(prefs, null, 2));
+}
+
+// src/runtime/queue.ts
+function getQueueDir(baseDir) {
+  const queueDir = path2.join(resolveStateDir(baseDir), "queue");
+  ensureDirectory0700(queueDir);
+  return queueDir;
+}
+function getQueueItemPath(digestId, baseDir) {
+  const queueDir = getQueueDir(baseDir);
+  const safeId = digestId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return path2.join(queueDir, `${safeId}.json`);
+}
+function enqueueCaptureItem(item, baseDir) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const record = {
+    version: QUEUE_SCHEMA_VERSION,
+    digestId: item.digestId,
+    workspaceId: item.workspaceId,
+    captureTrigger: item.captureTrigger,
+    policyVersion: item.policyVersion,
+    digestText: item.digestText,
+    authorizationId: item.authorizationId,
+    consentRevision: item.consentRevision,
+    status: "pending",
+    attempts: 0,
+    createdAt: now,
+    updatedAt: now
+  };
+  const filePath = getQueueItemPath(record.digestId, baseDir);
+  writeAtomic0600(filePath, JSON.stringify(record, null, 2));
+  return record;
+}
+function listQueueItems(baseDir) {
+  const queueDir = getQueueDir(baseDir);
+  const entries = fs2.readdirSync(queueDir);
+  const items = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".json")) continue;
+    const filePath = path2.join(queueDir, entry);
+    try {
+      assertNotSymlink(filePath);
+      const item = readSafeJson(filePath, validateQueueItemRecord);
+      if (item) {
+        items.push(item);
+      }
+    } catch {
+    }
+  }
+  return items.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+function updateQueueItem(digestId, updates, baseDir) {
+  const filePath = getQueueItemPath(digestId, baseDir);
+  const existing = readSafeJson(filePath, validateQueueItemRecord);
+  if (!existing) {
+    return null;
+  }
+  const updated = {
+    ...existing,
+    ...updates,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeAtomic0600(filePath, JSON.stringify(updated, null, 2));
+  return updated;
+}
+function removeQueueItem(digestId, baseDir) {
+  const filePath = getQueueItemPath(digestId, baseDir);
+  if (fs2.existsSync(filePath)) {
+    assertNotSymlink(filePath);
+    fs2.unlinkSync(filePath);
+    return true;
+  }
+  return false;
+}
+
+// src/runtime/diagnostics.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+var SENSITIVE_KEY_PATTERNS = [
+  /token/i,
+  /bearer/i,
+  /auth/i,
+  /secret/i,
+  /cookie/i,
+  /password/i,
+  /verifier/i,
+  /code/i,
+  /prompt/i,
+  /assistant/i,
+  /content/i,
+  /(api|secret|private|access|auth)key$/i,
+  /^key$/i
+];
+function scrubMetadata(value) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value !== "object") {
+    if (typeof value === "string") {
+      if (/bearer\s+[a-zA-Z0-9._-]+/i.test(value) || /brain_[a-zA-Z0-9_-]{20,}/i.test(value)) {
+        return "[REDACTED_TOKEN]";
+      }
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(scrubMetadata);
+  }
+  const result = {};
+  for (const [k, v] of Object.entries(value)) {
+    if (SENSITIVE_KEY_PATTERNS.some((pattern) => pattern.test(k))) {
+      result[k] = "[REDACTED]";
+    } else {
+      result[k] = scrubMetadata(v);
+    }
+  }
+  return result;
+}
+function getLogsDir(baseDir) {
+  const logsDir = path3.join(resolveStateDir(baseDir), "logs");
+  ensureDirectory0700(logsDir);
+  return logsDir;
+}
+function logRuntimeEvent(level, event, metadata, baseDir) {
+  try {
+    const logsDir = getLogsDir(baseDir);
+    const logFile = path3.join(logsDir, "runtime.log");
+    assertNotSymlink(logFile);
+    if (fs3.existsSync(logFile) && fs3.lstatSync(logFile).size >= 5 * 1024 * 1024) {
+      fs3.truncateSync(logFile, 0);
+    }
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      event,
+      metadata: metadata ? scrubMetadata(metadata) : void 0
+    };
+    fs3.appendFileSync(logFile, JSON.stringify(entry) + "\n", { mode: 384 });
+  } catch {
+  }
+}
+
+// src/runtime/lock.ts
+import fs4 from "node:fs";
+import path4 from "node:path";
+import { randomUUID } from "node:crypto";
+var STALE_LOCK_MS = 5e3;
+function getSessionLockPath(sessionId, baseDir) {
+  const locksDir = path4.join(resolveStateDir(baseDir), "locks");
+  ensureDirectory0700(locksDir);
+  const safeSessionId = sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return path4.join(locksDir, `${safeSessionId}.lock`);
+}
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+async function acquireSessionLock(sessionId, options) {
+  const lockPath = getSessionLockPath(sessionId, options?.baseDir);
+  const timeoutMs = options?.timeoutMs ?? 5e3;
+  const startTime = Date.now();
+  const pollInterval = 20;
+  while (true) {
+    try {
+      assertNotSymlink(lockPath);
+      const metadata = {
+        pid: process.pid,
+        createdAt: Date.now(),
+        sessionId,
+        owner: randomUUID()
+      };
+      fs4.writeFileSync(lockPath, JSON.stringify(metadata), { flag: "wx", mode: 384 });
+      let released = false;
+      return {
+        release: () => {
+          if (released) return;
+          released = true;
+          try {
+            if (fs4.existsSync(lockPath)) {
+              const content = fs4.readFileSync(lockPath, "utf8");
+              const parsed = JSON.parse(content);
+              if (parsed.owner === metadata.owner) {
+                fs4.unlinkSync(lockPath);
+              }
+            }
+          } catch {
+          }
+        }
+      };
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        const now = Date.now();
+        try {
+          const raw = fs4.readFileSync(lockPath, "utf8");
+          const meta = JSON.parse(raw);
+          const age = now - meta.createdAt;
+          if (age > STALE_LOCK_MS && !isProcessAlive(meta.pid)) {
+            try {
+              fs4.unlinkSync(lockPath);
+              continue;
+            } catch {
+            }
+          }
+        } catch {
+          try {
+            if (now - fs4.lstatSync(lockPath).mtimeMs > STALE_LOCK_MS) {
+              fs4.unlinkSync(lockPath);
+              continue;
+            }
+          } catch {
+          }
+        }
+        if (now - startTime > timeoutMs) {
+          throw new Error(`Timed out waiting for session lock: ${sessionId} (waited ${now - startTime}ms)`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        continue;
+      }
+      throw err;
+    }
+  }
+}
+async function withSessionLock(sessionId, fn, options) {
+  const lock = await acquireSessionLock(sessionId, options);
+  try {
+    return await fn();
+  } finally {
+    lock.release();
+  }
+}
+
+// src/runtime/flush.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import fs5 from "node:fs";
+import path5 from "node:path";
+var MAX_CAPTURE_QUEUE_ITEMS = 50;
+var MAX_CAPTURE_QUEUE_BYTES = 10 * 1024 * 1024;
+var MAX_CAPTURE_ATTEMPTS = 8;
+var BACKOFF_MS = [1e3, 2e3, 4e3, 8e3, 16e3, 32e3, 32e3, 32e3];
+function apiCaptureTrigger(trigger) {
+  if (trigger === "pre_compact") return "precompact";
+  return trigger;
+}
+function classifyCaptureFailure(status, message) {
+  if (status === 401 || /unauthorized|invalid_token|auth_required/i.test(message ?? "")) {
+    return "auth_required";
+  }
+  if (status === 403 || /missing required MCP OAuth scope/i.test(message ?? "")) {
+    return "terminal";
+  }
+  if (status === 400 || status !== null && status >= 400 && status < 500 && status !== 429) {
+    return "non_retryable";
+  }
+  if (status === 429 || status !== null && status >= 500 || status === null) {
+    return "retryable";
+  }
+  return "retryable";
+}
+function nextRetryAt(attempts, now = Date.now(), jitterMs = Math.floor(Math.random() * 500)) {
+  const base = BACKOFF_MS[Math.min(Math.max(attempts, 1), BACKOFF_MS.length) - 1] ?? 32e3;
+  return new Date(now + base + jitterMs).toISOString();
+}
+function queueByteSize(baseDir) {
+  const dir = getQueueDir(baseDir);
+  let total = 0;
+  for (const entry of fs5.readdirSync(dir)) {
+    if (!entry.endsWith(".json")) continue;
+    try {
+      total += fs5.statSync(path5.join(dir, entry)).size;
+    } catch {
+    }
+  }
+  return total;
+}
+function canEnqueueCapture(baseDir) {
+  const items = listQueueItems(baseDir).filter((item) => item.status === "pending" || item.status === "sending" || item.status === "delivery_unknown");
+  if (items.length >= MAX_CAPTURE_QUEUE_ITEMS) return false;
+  return queueByteSize(baseDir) < MAX_CAPTURE_QUEUE_BYTES;
+}
+async function postDigest(apiClient, item, signal, beforeSend) {
+  try {
+    await apiClient.request(`/api/workspaces/${item.workspaceId}/digests`, {
+      method: "POST",
+      body: {
+        clientDigestId: item.digestId,
+        trigger: apiCaptureTrigger(item.captureTrigger),
+        capturePolicyVersion: item.policyVersion,
+        digestText: item.digestText.trim() || "Session capture with no assistant summary.",
+        source: "mcp_tool"
+      },
+      signal,
+      expectedAuthorizationId: item.authorizationId,
+      beforeSend,
+      timeoutMs: 5e3
+    });
+    return { ok: true, status: 200 };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const statusFromError = error && typeof error === "object" && "status" in error && typeof error.status === "number" ? error.status : null;
+    const statusMatch = message.match(/status (\d{3})/i);
+    const status = statusFromError ?? (statusMatch ? Number(statusMatch[1]) : null);
+    return { ok: false, status, message };
+  }
+}
+async function flushCaptureQueue(options) {
+  options = { ...options, baseDir: resolveStateDir(options.baseDir) };
+  const result = { sent: 0, failed: 0, skipped: 0, unknown: 0 };
+  const now = options.now ?? Date.now();
+  const items = listQueueItems(options.baseDir);
+  const credentials = options.credentials === void 0 ? await options.apiClient.getEffectiveCredentials() : options.credentials;
+  for (const item of items) {
+    if (options.signal?.aborted) break;
+    if (options.digestId && item.digestId !== options.digestId) continue;
+    if (item.status === "delivered" || item.status === "cancelled" || item.status === "failed") {
+      result.skipped += 1;
+      continue;
+    }
+    if (item.nextRetryAt && Date.parse(item.nextRetryAt) > now) {
+      result.skipped += 1;
+      continue;
+    }
+    if (!options.includeManual && item.captureTrigger === "manual") {
+      continue;
+    }
+    const isAutomatic = item.captureTrigger !== "manual";
+    const consentStillMatches = () => {
+      const prefs = readPreferences(options.baseDir);
+      return prefs?.consent?.captureEnabled === true && (!isAutomatic || options.allowAutomatic === true) && item.consentRevision !== void 0 && item.consentRevision === (prefs.consent.revision ?? 0) && (!isAutomatic || item.workspaceId === prefs.enabledWorkspaceId);
+    };
+    if (isAutomatic) {
+      if (!consentStillMatches()) {
+        if (item.status === "pending") {
+          updateQueueItem(
+            item.digestId,
+            { status: "cancelled", lastError: "Capture consent or project policy changed before delivery" },
+            options.baseDir
+          );
+        }
+        result.skipped += 1;
+        continue;
+      }
+    }
+    const currentAuthorizationId = credentials?.authType === "oauth" ? credentials.authorizationId : void 0;
+    if (!item.authorizationId || !currentAuthorizationId || item.authorizationId !== currentAuthorizationId) {
+      updateQueueItem(
+        item.digestId,
+        { status: "cancelled", lastError: "Capture item belongs to a different or unknown authorization" },
+        options.baseDir
+      );
+      result.skipped += 1;
+      continue;
+    }
+    if (!credentials?.scopes?.includes("digests:write") || !credentials.workspaces?.includes(item.workspaceId)) {
+      result.skipped += 1;
+      continue;
+    }
+    const owner = randomUUID2();
+    const claimed = await withSessionLock("capture-queue", () => {
+      const current = listQueueItems(options.baseDir).find((queued) => queued.digestId === item.digestId);
+      if (!current || ["delivered", "cancelled", "failed"].includes(current.status) || current.deliveryLease && Date.parse(current.deliveryLease.expiresAt) > Date.now() || current.nextRetryAt && Date.parse(current.nextRetryAt) > now || !consentStillMatches() || options.signal?.aborted) return null;
+      return updateQueueItem(item.digestId, {
+        status: "sending",
+        deliveryLease: { owner, expiresAt: new Date(Date.now() + 1e4).toISOString() }
+      }, options.baseDir);
+    }, { baseDir: options.baseDir, timeoutMs: 250 });
+    if (!claimed) {
+      result.skipped += 1;
+      continue;
+    }
+    const finish = (updates) => withSessionLock("capture-queue", () => {
+      const current = listQueueItems(options.baseDir).find((queued) => queued.digestId === item.digestId);
+      if (current?.deliveryLease?.owner !== owner) return;
+      updateQueueItem(item.digestId, { ...updates, deliveryLease: void 0 }, options.baseDir);
+    }, { baseDir: options.baseDir, timeoutMs: 250 });
+    const response = await postDigest(options.apiClient, claimed, options.signal, consentStillMatches);
+    if (response.ok) {
+      await finish({ status: "delivered", deliveredAt: (/* @__PURE__ */ new Date()).toISOString(), lastError: void 0, nextRetryAt: void 0 });
+      result.sent += 1;
+      continue;
+    }
+    const klass = classifyCaptureFailure(response.status, response.message);
+    if (klass === "auth_required" || klass === "terminal" || klass === "non_retryable") {
+      await finish({ status: "failed", lastError: response.message ?? "non-retryable capture failure", attempts: claimed.attempts + 1 });
+      result.failed += 1;
+      continue;
+    }
+    const attempts = claimed.attempts + 1;
+    if (attempts >= MAX_CAPTURE_ATTEMPTS) {
+      await finish({ status: "failed", attempts, lastError: response.message ?? "retry limit reached" });
+      result.failed += 1;
+      continue;
+    }
+    const unknown = response.status === null;
+    await finish({
+      status: unknown ? "delivery_unknown" : "pending",
+      attempts,
+      nextRetryAt: nextRetryAt(attempts, now),
+      lastError: response.message
+    });
+    if (unknown) result.unknown += 1;
+    else result.failed += 1;
+  }
+  logRuntimeEvent(
+    "info",
+    "capture_flush",
+    { ...result },
+    options.baseDir
+  );
+  return result;
+}
+
+// src/runtime/session.ts
+function parseBrainToolResult(toolName, toolResult) {
+  toolName = toolName.replace(/^mcp__brain__/, "").replace(/^mcp__brainmcp__/, "");
+  if (!toolName || !toolResult) {
+    return { isWriteBack: false };
+  }
+  if (toolName === "brain_session_digest" || toolName === "brain_digest_pending" || toolName === "brain_digest_complete" || toolName.includes("read") || toolName.includes("overview") || toolName.includes("search") || toolName.includes("list")) {
+    return { isWriteBack: false };
+  }
+  let resultObj = toolResult;
+  if (typeof toolResult === "string") {
+    try {
+      resultObj = JSON.parse(toolResult);
+    } catch {
+      return { isWriteBack: false };
+    }
+  }
+  if (typeof resultObj !== "object" || resultObj === null) {
+    return { isWriteBack: false };
+  }
+  if (resultObj.isError || resultObj.error) {
+    return { isWriteBack: false, status: "error" };
+  }
+  if (resultObj.structuredContent) return parseBrainToolResult(toolName, resultObj.structuredContent);
+  if (resultObj.kind === "tool_error") return { isWriteBack: false, status: "error" };
+  if (resultObj.data && typeof resultObj.data === "object") return parseBrainToolResult(toolName, resultObj.data);
+  if (Array.isArray(resultObj.content)) {
+    for (const block of resultObj.content.slice(0, 8)) {
+      if (block?.type !== "text" || typeof block.text !== "string") continue;
+      const parsed = parseBrainToolResult(toolName, block.text);
+      if (parsed.isWriteBack) return parsed;
+    }
+    return { isWriteBack: false };
+  }
+  if (toolName === "brain_change_propose" || toolName === "brain_remember" || toolName === "brain_amend" || toolName === "brain_tags_set") {
+    const proposal = resultObj.proposal ?? resultObj;
+    const status = proposal.status ?? resultObj.status;
+    const proposalId = proposal.id ?? resultObj.id ?? resultObj.proposalId;
+    if (status === "applied" && proposalId) {
+      const isIdempotent = Boolean(resultObj.idempotentReplay || resultObj.idempotent || proposal.idempotent);
+      return {
+        isWriteBack: true,
+        actionKind: isIdempotent ? "idempotent" : "proposal_applied",
+        status: "applied",
+        proposalId
+      };
+    }
+    if (proposalId && (status === "pending" || status === "pending_review" || status === "review_required" || status === "queued")) {
+      return {
+        isWriteBack: true,
+        actionKind: "proposal_created",
+        status: "pending_review",
+        proposalId,
+        note: "Proposal created awaiting review"
+      };
+    }
+    if (status === "rejected" || status === "failed") {
+      return { isWriteBack: false, status };
+    }
+    if (proposalId) {
+      return {
+        isWriteBack: true,
+        actionKind: "proposal_created",
+        proposalId,
+        status: status ?? "created"
+      };
+    }
+  }
+  return { isWriteBack: false };
+}
+function getSessionLedgerPath(sessionKey, baseDir) {
+  const sessionsDir = path6.join(resolveStateDir(baseDir), "sessions");
+  ensureDirectory0700(sessionsDir);
+  const safeKey = sessionKey.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return path6.join(sessionsDir, `${safeKey}.json`);
+}
+function loadSessionLedger(sessionKey, baseDir) {
+  const filePath = getSessionLedgerPath(sessionKey, baseDir);
+  const existing = readSafeJson(filePath, validateSessionLedgerRecord);
+  if (existing) {
+    return existing;
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: SESSION_LEDGER_SCHEMA_VERSION,
+    sessionKey,
+    createdAt: now,
+    lastEventAt: now,
+    eventSequence: 0,
+    editedPaths: [],
+    deliveryIds: []
+  };
+}
+function saveSessionLedger(sessionKey, ledger, baseDir) {
+  const filePath = getSessionLedgerPath(sessionKey, baseDir);
+  writeAtomic0600(filePath, JSON.stringify(ledger, null, 2));
+}
+function loadMostRecentSessionLedger(baseDir, projectKey) {
+  const sessionsDir = path6.join(resolveStateDir(baseDir), "sessions");
+  if (!fs6.existsSync(sessionsDir)) return null;
+  const directory = fs6.lstatSync(sessionsDir);
+  if (directory.isSymbolicLink() || !directory.isDirectory()) {
+    throw new Error(`Security violation: ${sessionsDir} is not a safe session directory`);
+  }
+  let latest = null;
+  let latestAt = Number.NEGATIVE_INFINITY;
+  for (const entry of fs6.readdirSync(sessionsDir).slice(0, 1e3)) {
+    if (!entry.endsWith(".json")) continue;
+    const filePath = path6.join(sessionsDir, entry);
+    try {
+      const ledger = readSafeJson(filePath, validateSessionLedgerRecord);
+      if (!ledger) continue;
+      if (projectKey && ledger.projectKey !== projectKey) continue;
+      const timestamp = Date.parse(ledger.lastEventAt);
+      const comparable = Number.isFinite(timestamp) ? timestamp : fs6.lstatSync(filePath).mtimeMs;
+      if (comparable > latestAt) {
+        latest = ledger;
+        latestAt = comparable;
+      }
+    } catch {
+    }
+  }
+  return latest;
+}
+async function recordSessionEvent(input) {
+  return withSessionLock(
+    input.sessionKey,
+    async () => {
+      const ledger = loadSessionLedger(input.sessionKey, input.baseDir);
+      const timestamp = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+      if (input.captureRevision !== void 0 && (ledger.captureRevision !== input.captureRevision || ledger.workspaceId !== input.workspaceId)) {
+        ledger.prompts = [];
+        ledger.editedPaths = [];
+        ledger.assistantSummary = void 0;
+        ledger.model = void 0;
+        ledger.lastCapturedSequence = ledger.eventSequence;
+        ledger.captureRevision = input.captureRevision;
+        ledger.workspaceId = input.workspaceId;
+      }
+      ledger.eventSequence += 1;
+      ledger.lastEventAt = timestamp;
+      if (input.projectKey) ledger.projectKey = input.projectKey;
+      if (input.editedPath && !ledger.editedPaths.includes(input.editedPath)) {
+        if (ledger.editedPaths.length >= 100) {
+          ledger.editedPaths.shift();
+        }
+        ledger.editedPaths.push(input.editedPath);
+      }
+      if (input.prompt && input.persistPrompts) {
+        if (!ledger.prompts) ledger.prompts = [];
+        if (ledger.prompts.length >= 50) {
+          ledger.prompts.shift();
+        }
+        ledger.prompts.push(scrubSecrets(input.prompt).slice(0, 1e3));
+      }
+      if (input.assistantSummary?.trim()) {
+        ledger.assistantSummary = scrubSecrets(input.assistantSummary.trim()).slice(0, 4e3);
+      }
+      if (input.model?.trim()) {
+        ledger.model = input.model.trim().slice(0, 120);
+      }
+      if (input.deliveryId && !ledger.deliveryIds.includes(input.deliveryId)) {
+        ledger.deliveryIds.push(input.deliveryId);
+        ledger.deliveryIds = ledger.deliveryIds.slice(-100);
+      }
+      if (input.isMeaningful) {
+        ledger.lastMeaningfulAt = timestamp;
+        ledger.lastMeaningfulSequence = Math.max(
+          ledger.lastMeaningfulSequence ?? 0,
+          ledger.eventSequence
+        );
+      }
+      if (input.toolResult) {
+        const parsed = parseBrainToolResult(
+          input.toolResult.toolName,
+          input.toolResult.result
+        );
+        if (parsed.isWriteBack) {
+          ledger.lastSuccessfulWriteBackAt = timestamp;
+          ledger.lastSuccessfulWriteBackSequence = Math.max(
+            ledger.lastSuccessfulWriteBackSequence ?? 0,
+            ledger.eventSequence
+          );
+        }
+      }
+      saveSessionLedger(input.sessionKey, ledger, input.baseDir);
+      return ledger;
+    },
+    { baseDir: input.baseDir, timeoutMs: 250 }
+  );
+}
+async function markSessionCaptured(input) {
+  return withSessionLock(
+    input.sessionKey,
+    async () => {
+      const ledger = loadSessionLedger(input.sessionKey, input.baseDir);
+      ledger.lastCapturedAt = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+      ledger.lastCapturedSequence = Math.max(
+        ledger.lastCapturedSequence ?? 0,
+        input.capturedThroughSequence
+      );
+      if (!ledger.deliveryIds.includes(input.digestId)) ledger.deliveryIds.push(input.digestId);
+      ledger.deliveryIds = ledger.deliveryIds.slice(-100);
+      saveSessionLedger(input.sessionKey, ledger, input.baseDir);
+      return ledger;
+    },
+    { baseDir: input.baseDir }
+  );
+}
+async function queueSessionCapture(input) {
+  return withSessionLock(input.sessionKey, () => withSessionLock("capture-queue", () => {
+    const ledger = loadSessionLedger(input.sessionKey, input.baseDir);
+    if ((ledger.lastCapturedSequence ?? 0) >= input.capturedThroughSequence) return null;
+    const hash = createHash("sha256").update(JSON.stringify([
+      input.sessionKey,
+      input.capturedThroughSequence,
+      input.item.authorizationId,
+      input.item.consentRevision,
+      input.item.workspaceId
+    ])).digest("hex");
+    const digestId = `${hash.slice(0, 8)}-${hash.slice(8, 12)}-4${hash.slice(13, 16)}-8${hash.slice(17, 20)}-${hash.slice(20, 32)}`;
+    let item = listQueueItems(input.baseDir).find((queued) => queued.digestId === digestId);
+    if (!item) {
+      if (!canEnqueueCapture(input.baseDir)) return null;
+      let digestText = input.item.digestText;
+      try {
+        const payload = JSON.parse(digestText);
+        if (payload && typeof payload === "object" && "clientDigestId" in payload) digestText = JSON.stringify({ ...payload, clientDigestId: digestId });
+      } catch {
+      }
+      item = enqueueCaptureItem({ ...input.item, digestId, digestText }, input.baseDir);
+    }
+    ledger.lastCapturedAt = item.createdAt;
+    ledger.lastCapturedSequence = input.capturedThroughSequence;
+    ledger.deliveryIds = [...ledger.deliveryIds, item.digestId].slice(-100);
+    saveSessionLedger(input.sessionKey, ledger, input.baseDir);
+    return item;
+  }, { baseDir: input.baseDir, timeoutMs: 250 }), { baseDir: input.baseDir, timeoutMs: 250 });
+}
+async function markSessionNudged(input) {
+  return withSessionLock(
+    input.sessionKey,
+    async () => {
+      const ledger = loadSessionLedger(input.sessionKey, input.baseDir);
+      ledger.lastNudgedAt = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+      ledger.lastNudgedSequence = Math.max(
+        ledger.lastNudgedSequence ?? 0,
+        input.nudgedThroughSequence
+      );
+      saveSessionLedger(input.sessionKey, ledger, input.baseDir);
+      return ledger;
+    },
+    { baseDir: input.baseDir }
+  );
+}
+
+// src/runtime/retention.ts
+import fs7 from "node:fs";
+import path7 from "node:path";
+var SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1e3;
+var FOURTEEN_DAYS_MS = 14 * 24 * 60 * 60 * 1e3;
+var FIVE_MB_BYTES = 5 * 1024 * 1024;
+function listOwnedJsonFiles(directory, accepts) {
+  if (!fs7.existsSync(directory)) return [];
+  assertNotSymlink(directory);
+  return fs7.readdirSync(directory).flatMap((entry) => {
+    if (!accepts(entry)) return [];
+    const filePath = path7.join(directory, entry);
+    try {
+      const stat = fs7.lstatSync(filePath);
+      return stat.isFile() && !stat.isSymbolicLink() ? [filePath] : [];
+    } catch {
+      return [];
+    }
+  });
+}
+function previewCapturePurge(baseDir) {
+  const stateDir = resolveStateDir(baseDir);
+  return {
+    queueItems: listOwnedJsonFiles(path7.join(stateDir, "queue"), (name) => name.endsWith(".json")).length,
+    sessionLedgers: listOwnedJsonFiles(path7.join(stateDir, "sessions"), (name) => name.endsWith(".json")).length,
+    orientationCacheFiles: listOwnedJsonFiles(
+      path7.join(stateDir, "cache"),
+      (name) => name.startsWith("orient-") && name.endsWith(".json")
+    ).length
+  };
+}
+function purgeCaptureLocalState(baseDir) {
+  const stateDir = resolveStateDir(baseDir);
+  const groups = [
+    listOwnedJsonFiles(path7.join(stateDir, "queue"), (name) => name.endsWith(".json")),
+    listOwnedJsonFiles(path7.join(stateDir, "sessions"), (name) => name.endsWith(".json")),
+    listOwnedJsonFiles(path7.join(stateDir, "cache"), (name) => name.startsWith("orient-") && name.endsWith(".json"))
+  ];
+  const removed = {
+    queueItems: 0,
+    sessionLedgers: 0,
+    orientationCacheFiles: 0
+  };
+  const keys = ["queueItems", "sessionLedgers", "orientationCacheFiles"];
+  groups.forEach((files, index) => {
+    for (const filePath of files) {
+      try {
+        fs7.unlinkSync(filePath);
+        removed[keys[index]] += 1;
+      } catch {
+      }
+    }
+  });
+  return removed;
+}
+function pruneLocalState(options) {
+  const baseDir = resolveStateDir(options?.baseDir ?? getBrainHome());
+  const now = options?.now ?? Date.now();
+  const maxQueueAge = options?.maxQueueAgeMs ?? SEVEN_DAYS_MS;
+  const maxSessionAge = options?.maxSessionAgeMs ?? FOURTEEN_DAYS_MS;
+  const maxLogSize = options?.maxLogSizeBytes ?? FIVE_MB_BYTES;
+  let prunedQueueCount = 0;
+  let prunedSessionCount = 0;
+  let prunedLockCount = 0;
+  let logRotated = false;
+  try {
+    const items = listQueueItems(baseDir);
+    for (const item of items) {
+      const createdAtMs = new Date(item.createdAt).getTime();
+      if (now - createdAtMs > maxQueueAge || item.status === "delivered") {
+        if (removeQueueItem(item.digestId, baseDir)) {
+          prunedQueueCount += 1;
+        }
+      }
+    }
+  } catch {
+  }
+  const sessionsDir = path7.join(baseDir, "sessions");
+  if (fs7.existsSync(sessionsDir)) {
+    try {
+      assertNotSymlink(sessionsDir);
+      const sessionFiles = fs7.readdirSync(sessionsDir);
+      for (const file of sessionFiles) {
+        if (!file.endsWith(".json")) continue;
+        const filePath = path7.join(sessionsDir, file);
+        try {
+          const stat = fs7.lstatSync(filePath);
+          if (!stat.isSymbolicLink() && now - stat.mtimeMs > maxSessionAge) {
+            fs7.unlinkSync(filePath);
+            prunedSessionCount += 1;
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  const locksDir = path7.join(baseDir, "locks");
+  if (fs7.existsSync(locksDir)) {
+    try {
+      assertNotSymlink(locksDir);
+      const lockFiles = fs7.readdirSync(locksDir);
+      for (const file of lockFiles) {
+        if (!file.endsWith(".lock")) continue;
+        const filePath = path7.join(locksDir, file);
+        try {
+          const stat = fs7.lstatSync(filePath);
+          if (!stat.isSymbolicLink() && now - stat.mtimeMs > 60 * 1e3) {
+            try {
+              if (isProcessAlive(JSON.parse(fs7.readFileSync(filePath, "utf8")).pid)) continue;
+            } catch {
+            }
+            fs7.unlinkSync(filePath);
+            prunedLockCount += 1;
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  const logFile = path7.join(baseDir, "logs", "runtime.log");
+  if (fs7.existsSync(logFile)) {
+    try {
+      assertNotSymlink(logFile);
+      const stat = fs7.lstatSync(logFile);
+      if (!stat.isSymbolicLink() && stat.size > maxLogSize) {
+        const keepBytes = 1024 * 1024;
+        const buffer = Buffer.alloc(keepBytes);
+        const fd = fs7.openSync(logFile, "r");
+        fs7.readSync(fd, buffer, 0, keepBytes, stat.size - keepBytes);
+        fs7.closeSync(fd);
+        fs7.writeFileSync(logFile, buffer, { mode: 384 });
+        logRotated = true;
+      }
+    } catch {
+    }
+  }
+  return {
+    prunedQueueCount,
+    prunedSessionCount,
+    prunedLockCount,
+    logRotated
+  };
+}
+
+// src/lib/http.ts
+async function withRequestDeadline(timeoutMs, signal, action) {
+  const controller = new AbortController();
+  const abort = () => controller.abort(signal?.reason);
+  signal?.addEventListener("abort", abort, { once: true });
+  if (signal?.aborted) abort();
+  const timer = setTimeout(() => controller.abort(new Error("Request timed out")), timeoutMs);
+  let onAbort;
+  try {
+    controller.signal.throwIfAborted();
+    const cancelled = new Promise((_, reject) => {
+      onAbort = () => reject(new Error("Request cancelled or timed out"));
+      controller.signal.addEventListener("abort", onAbort, { once: true });
+    });
+    return await Promise.race([action(controller.signal), cancelled]);
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", abort);
+    if (onAbort) controller.signal.removeEventListener("abort", onAbort);
+  }
+}
+var BRAIN_ORIGINS = /* @__PURE__ */ new Set([
+  "https://mcp.brainmcp.ai",
+  "https://api.brainmcp.ai",
+  "https://dash.brainmcp.ai"
+]);
+function validateHttpUrl(value, trustedBase) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error("Invalid API or OAuth endpoint URL.");
+  }
+  const loopback = url.hostname === "127.0.0.1" || url.hostname === "localhost" || url.hostname === "[::1]";
+  if (url.protocol !== "https:" && !(loopback && url.protocol === "http:") || url.username || url.password || url.hash) {
+    throw new Error("API and OAuth endpoints require HTTPS (HTTP is allowed only on loopback), without credentials or fragments.");
+  }
+  if (trustedBase) {
+    const origin = new URL(trustedBase).origin;
+    if (url.origin !== origin && !(BRAIN_ORIGINS.has(origin) && BRAIN_ORIGINS.has(url.origin))) {
+      throw new Error("OAuth endpoint origin does not match the trusted Brain issuer.");
+    }
+  }
+  return url;
+}
+
+// src/runtime/capture.ts
+import crypto2 from "node:crypto";
+import { execFileSync } from "node:child_process";
+import fs8 from "node:fs";
+import path8 from "node:path";
+var MAX_DIGEST_BYTES = 14 * 1024;
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var STOP_EVENTS = /* @__PURE__ */ new Set(["Stop", "StopNudge", "stop", "SessionStop", "session_stop"]);
+var CAPTURE_EVENTS = /* @__PURE__ */ new Set([
+  "PreCompact",
+  "preCompact",
+  "pre_compact",
+  "precompact",
+  "SessionEnd",
+  "sessionEnd",
+  "session_end",
+  "manual"
+]);
+function isStopEvent(event, stopHookActive) {
+  return stopHookActive === true || STOP_EVENTS.has(event);
+}
+function captureTriggerForEvent(event) {
+  if (event === "SessionEnd" || event === "sessionEnd" || event === "session_end") return "session_end";
+  if (event === "PreCompact" || event === "preCompact" || event === "pre_compact" || event === "precompact") {
+    return "pre_compact";
+  }
+  if (event === "manual") return "manual";
+  return null;
+}
+function readProjectCaptureRestrictions(startDir) {
+  const result = { captureDisabled: false, promptsDisabled: false };
+  if (!startDir) return result;
+  let dir = path8.resolve(startDir);
+  for (let i = 0; i < 16; i += 1) {
+    const candidate = path8.join(dir, ".brainmcp.json");
+    if (fs8.lstatSync(candidate, { throwIfNoEntry: false })) {
+      try {
+        const stat = fs8.lstatSync(candidate);
+        if (stat.isSymbolicLink() || !stat.isFile() || stat.size > 64 * 1024) return { captureDisabled: true, promptsDisabled: true };
+        const parsed = JSON.parse(fs8.readFileSync(candidate, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return { captureDisabled: true, promptsDisabled: true };
+        const consent = parsed.consent && typeof parsed.consent === "object" ? parsed.consent : void 0;
+        if (parsed.capture === false || parsed.captureEnabled === false || consent?.captureEnabled === false) {
+          result.captureDisabled = true;
+        }
+        if (parsed.includePrompts === false || consent?.includePrompts === false) {
+          result.promptsDisabled = true;
+        }
+      } catch {
+        return { captureDisabled: true, promptsDisabled: true };
+      }
+      return result;
+    }
+    const parent = path8.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return result;
+}
+function resolveCaptureWorkspaceId(prefs) {
+  const candidate = prefs?.enabledWorkspaceId?.trim();
+  if (candidate && UUID_RE.test(candidate)) return candidate;
+  return null;
+}
+function captureProjectKey(cwd) {
+  let dir = fs8.realpathSync(path8.resolve(cwd));
+  const original = dir;
+  for (let i = 0; i < 32; i += 1) {
+    if (fs8.existsSync(path8.join(dir, ".git")) || fs8.lstatSync(path8.join(dir, ".brainmcp.json"), { throwIfNoEntry: false })) break;
+    const parent = path8.dirname(dir);
+    if (parent === dir) {
+      dir = original;
+      break;
+    }
+    dir = parent;
+  }
+  return crypto2.createHash("sha256").update(dir).digest("hex");
+}
+function collectGitMetadata(cwd, runner) {
+  if (!cwd) return void 0;
+  const run = runner ?? ((args) => execFileSync("git", ["-C", cwd, ...args], {
+    encoding: "utf8",
+    timeout: 125,
+    maxBuffer: 64 * 1024,
+    stdio: ["ignore", "pipe", "ignore"]
+  }).trim());
+  const safely = (args) => {
+    try {
+      return run(args).trim();
+    } catch {
+      return "";
+    }
+  };
+  const root = safely(["rev-parse", "--show-toplevel"]);
+  if (!root) return void 0;
+  const branch = safely(["branch", "--show-current"]);
+  const commit = safely(["rev-parse", "--short=12", "HEAD"]);
+  const numstat = safely(["diff", "--numstat", "HEAD"]);
+  const changedFiles = safely(["status", "--porcelain=v1", "--untracked-files=no"]);
+  let insertions = 0;
+  let deletions = 0;
+  for (const line of numstat.split("\n")) {
+    if (!line) continue;
+    const [added, removed] = line.split("	");
+    if (/^\d+$/.test(added ?? "")) insertions += Number(added);
+    if (/^\d+$/.test(removed ?? "")) deletions += Number(removed);
+  }
+  const filesChanged = changedFiles ? changedFiles.split("\n").filter(Boolean).length : 0;
+  return {
+    repository: path8.basename(root),
+    branch: branch || void 0,
+    commit: commit || void 0,
+    diffStats: { filesChanged, insertions, deletions }
+  };
+}
+function truncateUtf8(value, maxBytes) {
+  let output = "";
+  let bytes = 0;
+  for (const character of value) {
+    const characterBytes = Buffer.byteLength(character, "utf8");
+    if (bytes + characterBytes > maxBytes) break;
+    output += character;
+    bytes += characterBytes;
+  }
+  return output;
+}
+function buildDigestPayload(input) {
+  const clientDigestId = crypto2.randomUUID();
+  const safePaths = [];
+  if (input.paths) {
+    for (const p of input.paths) {
+      if (typeof p !== "string") continue;
+      const normalized = path8.normalize(p.trim());
+      if (path8.isAbsolute(normalized)) continue;
+      if (normalized.startsWith("..") || normalized.includes("../") || normalized.includes("..\\")) continue;
+      safePaths.push(truncateUtf8(scrubSecrets(normalized), 180));
+    }
+  }
+  const safePrompts = [];
+  if (input.includePrompts && input.prompts) {
+    for (const pr of input.prompts) {
+      if (typeof pr === "string" && pr.trim()) {
+        safePrompts.push(truncateUtf8(scrubSecrets(pr), 800));
+      }
+    }
+  }
+  const payload = {
+    clientDigestId,
+    trigger: input.trigger,
+    workspaceId: input.workspaceId,
+    host: input.host ? truncateUtf8(scrubSecrets(input.host), 80) : void 0,
+    model: input.model ? truncateUtf8(scrubSecrets(input.model), 120) : void 0,
+    summary: input.summary ? truncateUtf8(scrubSecrets(input.summary), 4e3) : void 0,
+    relativePaths: safePaths.slice(0, 50),
+    gitMetadata: input.gitMetadata ? {
+      branch: input.gitMetadata.branch ? truncateUtf8(scrubSecrets(input.gitMetadata.branch), 180) : void 0,
+      commit: input.gitMetadata.commit ? truncateUtf8(scrubSecrets(input.gitMetadata.commit), 180) : void 0,
+      repository: input.gitMetadata.repository ? truncateUtf8(scrubSecrets(input.gitMetadata.repository), 180) : void 0,
+      diffStats: input.gitMetadata.diffStats ? {
+        filesChanged: Math.max(0, Math.min(1e5, Math.trunc(input.gitMetadata.diffStats.filesChanged))),
+        insertions: Math.max(0, Math.min(1e7, Math.trunc(input.gitMetadata.diffStats.insertions))),
+        deletions: Math.max(0, Math.min(1e7, Math.trunc(input.gitMetadata.diffStats.deletions)))
+      } : void 0
+    } : void 0,
+    prompts: safePrompts.length > 0 ? safePrompts.slice(0, 10) : void 0
+  };
+  while (Buffer.byteLength(JSON.stringify(payload), "utf8") > MAX_DIGEST_BYTES) {
+    if (payload.prompts?.length) {
+      payload.prompts.pop();
+      if (payload.prompts.length === 0) payload.prompts = void 0;
+      continue;
+    }
+    if (payload.relativePaths?.length) {
+      payload.relativePaths.pop();
+      if (payload.relativePaths.length === 0) payload.relativePaths = void 0;
+      continue;
+    }
+    if (payload.summary) {
+      payload.summary = truncateUtf8(
+        payload.summary,
+        Math.max(0, Buffer.byteLength(payload.summary, "utf8") - 512)
+      );
+      if (!payload.summary) payload.summary = void 0;
+      continue;
+    }
+    payload.gitMetadata = void 0;
+    break;
+  }
+  return payload;
+}
+function serializeDigestPayload(payload) {
+  const json = JSON.stringify(payload);
+  const bytes = Buffer.byteLength(json, "utf8");
+  if (bytes > MAX_DIGEST_BYTES) {
+    throw new Error(`Digest payload exceeds max byte cap: ${bytes} > ${MAX_DIGEST_BYTES}`);
+  }
+  return json;
+}
+function isCaptureEligible(event, prefs, projectPolicy) {
+  if (isStopEvent(event)) {
+    return false;
+  }
+  if (projectPolicy?.captureDisabled) {
+    return false;
+  }
+  if (!prefs?.consent?.captureEnabled) {
+    return false;
+  }
+  return CAPTURE_EVENTS.has(event);
+}
+
+// src/runtime/orient.ts
+import fs9 from "node:fs";
+import path9 from "node:path";
+var ORIENT_CACHE_TTL_MS = 10 * 60 * 1e3;
+var ORIENT_CONTEXT_MAX_CHARS = 2400;
+var UUID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var SESSION_START_EVENTS = /* @__PURE__ */ new Set([
+  "SessionStart",
+  "sessionStart",
+  "session_start",
+  "startup"
+]);
+function isSessionStartEvent(event) {
+  return SESSION_START_EVENTS.has(event);
+}
+function isUserPromptEvent(event) {
+  return event === "UserPromptSubmit" || event === "UserPrompt" || event === "prompt" || event === "beforeSubmitPrompt";
+}
+function resolveOrientWorkspaceId(creds, listed) {
+  if (!creds || creds.authType !== "oauth" || !creds.accessToken) {
+    return { workspaceId: null, reason: "login" };
+  }
+  if (creds.defaultWorkspaceId && UUID_RE2.test(creds.defaultWorkspaceId)) {
+    return { workspaceId: creds.defaultWorkspaceId, reason: "ok" };
+  }
+  const fromCreds = (creds.workspaces ?? []).filter((id) => UUID_RE2.test(id));
+  if (fromCreds.length === 1) {
+    return { workspaceId: fromCreds[0], reason: "ok" };
+  }
+  if (listed) {
+    const defaults = listed.filter((ws) => ws.isDefault);
+    if (defaults.length === 1 && UUID_RE2.test(defaults[0].id)) {
+      return { workspaceId: defaults[0].id, reason: "ok" };
+    }
+    if (listed.length === 1 && UUID_RE2.test(listed[0].id)) {
+      return { workspaceId: listed[0].id, reason: "ok" };
+    }
+    if (listed.length !== 1) {
+      return { workspaceId: null, reason: "select" };
+    }
+  }
+  if (fromCreds.length !== 1) {
+    return { workspaceId: null, reason: fromCreds.length === 0 ? "select" : "select" };
+  }
+  return { workspaceId: null, reason: "select" };
+}
+function formatOrientAdditionalContext(payload) {
+  if (!payload || typeof payload !== "object") {
+    return "BrainMCP orientation is available. Call brain_workspace_overview before non-trivial work.";
+  }
+  const data = payload;
+  const lines = ["BrainMCP orientation (no user prompt was sent)."];
+  const workspace = data.workspace && typeof data.workspace === "object" ? data.workspace : void 0;
+  if (typeof workspace?.name === "string") {
+    lines.push(`Workspace: ${workspace.name}`);
+  }
+  const review = data.review && typeof data.review === "object" ? data.review : void 0;
+  if (typeof review?.writePath === "string") {
+    lines.push(`Write path: ${review.writePath}`);
+  }
+  if (review?.humanReviewRequired === true) {
+    lines.push("Human review is required before graph writes apply.");
+  }
+  if (typeof data.pendingProposalCount === "number" && data.pendingProposalCount > 0) {
+    lines.push(`Pending proposals: ${data.pendingProposalCount}`);
+  }
+  if (typeof data.dueWorkflowCount === "number" && data.dueWorkflowCount > 0) {
+    lines.push(`Due workflows: ${data.dueWorkflowCount}`);
+  }
+  const rules = data.rules && typeof data.rules === "object" ? data.rules : void 0;
+  for (const rule of rules?.items?.slice(0, 3) ?? []) {
+    if (typeof rule.body === "string" && rule.body.trim()) {
+      lines.push(`Rule: ${rule.body.trim().slice(0, 280)}`);
+    }
+  }
+  if (typeof data.writeBackHint === "string" && data.writeBackHint.trim()) {
+    lines.push(data.writeBackHint.trim());
+  } else {
+    lines.push("Propose only new durable project knowledge with brain_change_propose after meaningful work.");
+  }
+  const text = lines.join("\n");
+  return text.length > ORIENT_CONTEXT_MAX_CHARS ? `${text.slice(0, ORIENT_CONTEXT_MAX_CHARS - 1)}\u2026` : text;
+}
+function loginOrientationMessage() {
+  return "BrainMCP CLI is not signed in. Run `brainmcp login`, then retry orientation. No remote request was made.";
+}
+function selectWorkspaceOrientationMessage() {
+  return "BrainMCP has more than one authorized workspace. Pass workspaceId or set a default before orientation. No workspace was guessed.";
+}
+function readProjectWorkspaceId(startDir) {
+  if (!startDir) return { kind: "none" };
+  let dir = path9.resolve(startDir);
+  for (let depth = 0; depth < 16; depth += 1) {
+    const configPath = path9.join(dir, ".brainmcp.json");
+    if (fs9.existsSync(configPath)) {
+      try {
+        const stat = fs9.lstatSync(configPath);
+        if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 64 * 1024) {
+          return { kind: "invalid", configPath };
+        }
+        const parsed = JSON.parse(fs9.readFileSync(configPath, "utf8"));
+        const workspaceId = typeof parsed.workspaceId === "string" ? parsed.workspaceId.trim() : "";
+        return UUID_RE2.test(workspaceId) ? { kind: "workspace", configPath, workspaceId } : { kind: "invalid", configPath };
+      } catch {
+        return { kind: "invalid", configPath };
+      }
+    }
+    const parent = path9.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return { kind: "none" };
+}
+function invalidProjectWorkspaceMessage() {
+  return "BrainMCP found an invalid nearest `.brainmcp.json` workspaceId and did not guess another workspace. Fix or remove that project policy file.";
+}
+async function fetchSessionStartOrientation(input) {
+  const initial = resolveOrientWorkspaceId(input.creds);
+  if (initial.reason === "login") {
+    return loginOrientationMessage();
+  }
+  const roots = (input.workspaceRoots?.length ? input.workspaceRoots : input.cwd ? [input.cwd] : []).filter((root, index, all) => Boolean(root) && all.indexOf(root) === index);
+  const projectResolutions = roots.map((root) => readProjectWorkspaceId(root));
+  if (projectResolutions.some((resolution) => resolution.kind === "invalid")) {
+    return invalidProjectWorkspaceMessage();
+  }
+  const projectWorkspaceIds = projectResolutions.filter((resolution) => resolution.kind === "workspace").map((resolution) => resolution.workspaceId);
+  const hasUnboundRoot = roots.length === 0 || projectResolutions.some((resolution) => resolution.kind === "none");
+  let fallbackWorkspaceId = initial.workspaceId;
+  if (hasUnboundRoot && !fallbackWorkspaceId) {
+    try {
+      const listed = await input.apiClient.request(
+        "/api/mcp/workspaces",
+        { timeoutMs: 800, signal: input.signal }
+      );
+      const next = resolveOrientWorkspaceId(input.creds, listed.workspaces ?? []);
+      fallbackWorkspaceId = next.workspaceId;
+    } catch {
+      fallbackWorkspaceId = null;
+    }
+  }
+  const workspaceIds = [.../* @__PURE__ */ new Set([
+    ...projectWorkspaceIds,
+    ...hasUnboundRoot && fallbackWorkspaceId ? [fallbackWorkspaceId] : []
+  ])];
+  if (workspaceIds.length === 0) return selectWorkspaceOrientationMessage();
+  const results = await Promise.allSettled(
+    workspaceIds.map(async (workspaceId) => {
+      const payload = await input.apiClient.request(
+        `/api/workspaces/${workspaceId}/orient`,
+        { timeoutMs: 800, signal: input.signal }
+      );
+      return formatOrientAdditionalContext(payload);
+    })
+  );
+  const contexts = results.filter((result) => result.status === "fulfilled").map((result) => result.value);
+  if (contexts.length === 0) {
+    throw new Error("No project workspace orientation request succeeded.");
+  }
+  if (hasUnboundRoot && !fallbackWorkspaceId) {
+    contexts.push("One or more workspace roots have no resolvable project/default workspace; no workspace was guessed for those roots.");
+  }
+  const combined = contexts.join("\n\n---\n\n");
+  return combined.length > ORIENT_CONTEXT_MAX_CHARS ? `${combined.slice(0, ORIENT_CONTEXT_MAX_CHARS - 1)}\u2026` : combined;
+}
+async function safeSessionStartOrientation(input) {
+  if (!input.apiClient) {
+    return input.creds?.authType === "oauth" ? selectWorkspaceOrientationMessage() : loginOrientationMessage();
+  }
+  try {
+    return await fetchSessionStartOrientation(input);
+  } catch (error) {
+    logRuntimeEvent(
+      "warn",
+      "orient_fetch_failed",
+      { error: error instanceof Error ? error.message : String(error) },
+      input.baseDir
+    );
+    return "BrainMCP orientation is temporarily unavailable. Continue locally and retry brain_workspace_overview when possible.";
+  }
+}
+
+// src/lib/api-client.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+
+// src/types/agent-config-stub.ts
+var BRAIN_MCP_ENDPOINT = "https://mcp.brainmcp.ai/mcp";
+var MCP_OAUTH_CLIENT_IDS = {
+  antigravity: "antigravity",
+  brainmcpCli: "brainmcp-cli",
+  claudeCode: "claude-code",
+  codex: "codex",
+  cursor: "cursor",
+  generic: "generic-mcp"
+};
+var BRAINMCP_CLI_OAUTH_CLIENT_ID = MCP_OAUTH_CLIENT_IDS.brainmcpCli;
+var BRAINMCP_CLI_CLIENT_ID = "brainmcp-cli";
+var BRAINMCP_CLI_ALLOWED_SCOPES = [
+  "graph:read",
+  "skills:read",
+  "workflows:read",
+  "offline_access",
+  "digests:write"
+];
+var BRAINMCP_CLI_DEFAULT_SCOPES = [
+  "graph:read",
+  "skills:read",
+  "workflows:read",
+  "offline_access"
+];
+var CONSENT_ATTEMPT_TTL_MS = 10 * 60 * 1e3;
+
+// src/lib/oauth-client.ts
+function grantedCliScopes(requested, tokenScope) {
+  const allowed = new Set(BRAINMCP_CLI_ALLOWED_SCOPES);
+  const raw = tokenScope === void 0 ? requested : tokenScope.split(/\s+/).filter(Boolean);
+  if (raw.some((scope) => !allowed.has(scope) || !requested.includes(scope))) {
+    throw new Error("The OAuth server granted unrequested or disallowed CLI scopes.");
+  }
+  const granted = [...new Set(raw)];
+  if (requested.some((scope) => !granted.includes(scope))) {
+    throw new Error("The OAuth server did not grant required CLI scopes.");
+  }
+  return granted;
+}
+function validateTokenResponse(value) {
+  const token = value;
+  if (!token || typeof token.access_token !== "string" || !token.access_token.trim() || typeof token.token_type !== "string" || token.token_type.toLowerCase() !== "bearer" || token.refresh_token !== void 0 && (typeof token.refresh_token !== "string" || !token.refresh_token.trim()) || token.scope !== void 0 && typeof token.scope !== "string" || token.expires_in !== void 0 && (typeof token.expires_in !== "number" || !Number.isFinite(token.expires_in) || token.expires_in <= 0)) {
+    throw new Error("OAuth server returned an invalid token response.");
+  }
+  return token;
+}
+var DEFAULT_ISSUER = "https://mcp.brainmcp.ai";
+var OAuthClient = class {
+  issuer;
+  clientId;
+  fetchFn;
+  timeoutMs;
+  constructor(options = {}) {
+    this.issuer = (options.issuerUrl ?? process.env.BRAINMCP_API_URL ?? DEFAULT_ISSUER).replace(/\/+$/, "");
+    this.clientId = options.clientId ?? BRAINMCP_CLI_CLIENT_ID;
+    this.fetchFn = options.fetchFn ?? fetch;
+    this.timeoutMs = options.timeoutMs ?? 1e4;
+    validateHttpUrl(this.issuer);
+  }
+  async discoverEndpoints(signal) {
+    const discoveryUrl = `${this.issuer}/.well-known/oauth-authorization-server`;
+    return withRequestDeadline(this.timeoutMs, signal, async (requestSignal) => {
+      const res = await this.fetchFn(discoveryUrl, { signal: requestSignal, redirect: "error" });
+      if (res.ok) {
+        const meta = await res.json();
+        if (meta && typeof meta === "object" && !Array.isArray(meta)) {
+          const endpoints = {
+            issuer: meta.issuer ?? this.issuer,
+            authorizationEndpoint: meta.authorization_endpoint ?? `${this.issuer}/api/auth/oauth2/authorize`,
+            tokenEndpoint: meta.token_endpoint ?? `${this.issuer}/api/auth/oauth2/token`,
+            revocationEndpoint: meta.revocation_endpoint ?? `${this.issuer}/api/auth/oauth2/revoke`
+          };
+          for (const endpoint of Object.values(endpoints)) validateHttpUrl(endpoint, this.issuer);
+          return endpoints;
+        }
+        throw new Error("OAuth server returned invalid discovery metadata.");
+      }
+      if (res.status !== 404) throw new Error(`OAuth discovery failed (status ${res.status}).`);
+      return {
+        issuer: this.issuer,
+        authorizationEndpoint: `${this.issuer}/api/auth/oauth2/authorize`,
+        tokenEndpoint: `${this.issuer}/api/auth/oauth2/token`,
+        revocationEndpoint: `${this.issuer}/api/auth/oauth2/revoke`
+      };
+    });
+  }
+  buildAuthorizationUrl(input) {
+    const scopes = input.scopes ?? [...BRAINMCP_CLI_DEFAULT_SCOPES];
+    const url = validateHttpUrl(input.authorizationEndpoint, this.issuer);
+    url.searchParams.set("response_type", "code");
+    url.searchParams.set("client_id", this.clientId);
+    url.searchParams.set("redirect_uri", input.redirectUri);
+    url.searchParams.set("scope", scopes.join(" "));
+    url.searchParams.set("state", input.pkce.state);
+    url.searchParams.set("code_challenge", input.pkce.challenge);
+    url.searchParams.set("code_challenge_method", input.pkce.method);
+    url.searchParams.set("prompt", "consent");
+    url.searchParams.set("resource", BRAIN_MCP_ENDPOINT);
+    return url.toString();
+  }
+  async exchangeCodeForTokens(input) {
+    const body = new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: this.clientId,
+      code: input.code,
+      redirect_uri: input.redirectUri,
+      code_verifier: input.codeVerifier,
+      resource: BRAIN_MCP_ENDPOINT
+    });
+    validateHttpUrl(input.tokenEndpoint, this.issuer);
+    return withRequestDeadline(this.timeoutMs, input.signal, async (signal) => {
+      const res = await this.fetchFn(input.tokenEndpoint, {
+        signal,
+        redirect: "error",
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          Accept: "application/json"
+        },
+        body: body.toString()
+      });
+      if (!res.ok) {
+        throw new Error(`Token exchange failed (status ${res.status}).`);
+      }
+      return validateTokenResponse(await res.json());
+    });
+  }
+  async refreshAccessToken(input) {
+    const body = new URLSearchParams({
+      grant_type: "refresh_token",
+      client_id: this.clientId,
+      refresh_token: input.refreshToken,
+      resource: BRAIN_MCP_ENDPOINT
+    });
+    validateHttpUrl(input.tokenEndpoint, this.issuer);
+    return withRequestDeadline(this.timeoutMs, input.signal, async (signal) => {
+      const res = await this.fetchFn(input.tokenEndpoint, {
+        signal,
+        redirect: "error",
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          Accept: "application/json"
+        },
+        body: body.toString()
+      });
+      if (!res.ok) {
+        throw new Error(`Token refresh failed (status ${res.status}).`);
+      }
+      return validateTokenResponse(await res.json());
+    });
+  }
+  async revokeToken(input) {
+    const body = new URLSearchParams({
+      client_id: this.clientId,
+      token: input.token
+    });
+    validateHttpUrl(input.revocationEndpoint, this.issuer);
+    return withRequestDeadline(this.timeoutMs, input.signal, async (signal) => {
+      const res = await this.fetchFn(input.revocationEndpoint, {
+        signal,
+        redirect: "error",
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body: body.toString()
+      });
+      return res.ok;
+    });
+  }
+};
+
+// src/lib/api-client.ts
+var ApiClient = class {
+  apiUrl;
+  store;
+  oauthClient;
+  fetchFn;
+  serviceToken;
+  defaultTimeoutMs;
+  constructor(options) {
+    this.apiUrl = (options.apiUrl ?? process.env.BRAINMCP_API_URL ?? "https://mcp.brainmcp.ai").replace(/\/+$/, "");
+    this.store = options.store;
+    this.fetchFn = options.fetchFn ?? fetch;
+    this.oauthClient = options.oauthClient ?? new OAuthClient({ issuerUrl: this.apiUrl, fetchFn: this.fetchFn });
+    this.serviceToken = options.serviceTokenEnv ?? process.env.BRAINMCP_SERVICE_TOKEN;
+    this.defaultTimeoutMs = options.timeoutMs ?? 15e3;
+    validateHttpUrl(this.apiUrl);
+  }
+  async getEffectiveCredentials() {
+    const stored = await this.store.get();
+    if (stored?.authType === "oauth" && stored.accessToken) {
+      return stored;
+    }
+    if (this.serviceToken) {
+      return {
+        version: 1,
+        authType: "service",
+        serviceToken: this.serviceToken,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    return stored;
+  }
+  async request(path12, options = {}) {
+    return withRequestDeadline(options.timeoutMs ?? this.defaultTimeoutMs, options.signal, async (signal) => {
+      const explicitAuthorization = new Headers(options.headers).has("Authorization");
+      const useStoredAuth = !options.skipAuth && !explicitAuthorization;
+      const creds = useStoredAuth ? await this.getEffectiveCredentials() : null;
+      signal.throwIfAborted();
+      if (options.expectedAuthorizationId && creds?.authorizationId !== options.expectedAuthorizationId) {
+        throw new Error("Companion authorization changed before the request.");
+      }
+      const url = new URL(path12, `${this.apiUrl}/`);
+      if (url.origin !== new URL(this.apiUrl).origin || url.username || url.password) {
+        throw new Error("API requests must use the configured API origin.");
+      }
+      const isOrientEndpoint = url.pathname.endsWith("/orient");
+      if (creds?.authType === "service" && isOrientEndpoint) {
+        throw new Error(
+          "Service tokens cannot access /orient. Interactive companion OAuth credentials are required for session orientation."
+        );
+      }
+      const requestId = randomUUID3();
+      const execute = async (token2) => {
+        const headers = new Headers(options.headers);
+        headers.set("x-request-id", requestId);
+        headers.set("Accept", "application/json");
+        if (options.body && !headers.has("Content-Type")) {
+          headers.set("Content-Type", "application/json");
+        }
+        if (token2 && useStoredAuth) {
+          headers.set("Authorization", `Bearer ${token2}`);
+        }
+        signal.throwIfAborted();
+        if (options.beforeSend && !options.beforeSend()) throw new Error("Request cancelled because capture consent changed.");
+        return await this.fetchFn(url.toString(), {
+          method: options.method ?? (options.body ? "POST" : "GET"),
+          headers,
+          body: options.body ? JSON.stringify(options.body) : void 0,
+          signal,
+          redirect: "error"
+        });
+      };
+      let token = creds?.authType === "oauth" ? creds.accessToken ?? null : creds?.serviceToken ?? null;
+      let res = await execute(token);
+      if (res.status === 401 && creds?.authType === "oauth" && creds.refreshToken) {
+        await res.body?.cancel();
+        const refreshed = await this.refreshTokensWithLock(token, creds, signal);
+        if (refreshed) {
+          token = refreshed.accessToken ?? null;
+          res = await execute(token);
+        }
+      }
+      if (!res.ok) {
+        const error = new Error(`API request failed (status ${res.status})`);
+        error.status = res.status;
+        throw error;
+      }
+      if (res.status === 204) {
+        return void 0;
+      }
+      return await res.json();
+    });
+  }
+  async refreshTokensWithLock(failedAccessToken, original, signal) {
+    const leaseHolder = randomUUID3();
+    const leaseDurationMs = 15e3;
+    let refreshToken = null;
+    for (let attempt = 0; attempt < 50; attempt += 1) {
+      signal.throwIfAborted();
+      const claim = await this.store.withRefreshLock(async (current) => {
+        signal.throwIfAborted();
+        if (current?.authorizationId !== original.authorizationId || current?.userId !== original.userId) {
+          return { kind: "missing", current: null };
+        }
+        if (!current || current.authType !== "oauth" || !current.refreshToken) {
+          return { kind: "missing", current };
+        }
+        if (current.accessToken && current.accessToken !== failedAccessToken) {
+          return { kind: "reuse", current };
+        }
+        const leaseExpiry = current.refreshLease ? Date.parse(current.refreshLease.expiresAt) : Number.NaN;
+        if (current.refreshLease && current.refreshLease.leaseHolder !== leaseHolder && Number.isFinite(leaseExpiry) && leaseExpiry > Date.now()) {
+          return { kind: "wait", current };
+        }
+        const updated = {
+          ...current,
+          refreshLease: {
+            leaseHolder,
+            expiresAt: new Date(Date.now() + leaseDurationMs).toISOString(),
+            revision: (current.refreshLease?.revision ?? 0) + 1
+          },
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        await this.store.set(updated);
+        return { kind: "claimed", current: updated };
+      });
+      if (claim.kind === "missing") return claim.current;
+      if (claim.kind === "reuse") return claim.current;
+      if (claim.kind === "claimed") {
+        refreshToken = claim.current.refreshToken ?? null;
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 80 + Math.floor(Math.random() * 40)));
+    }
+    if (!refreshToken) return null;
+    try {
+      const endpoints = await this.oauthClient.discoverEndpoints(signal);
+      const tokenResponse = await this.oauthClient.refreshAccessToken({
+        tokenEndpoint: endpoints.tokenEndpoint,
+        refreshToken,
+        signal
+      });
+      return await this.store.withRefreshLock(async (current) => {
+        signal.throwIfAborted();
+        if (!current || current.authType !== "oauth" || current.authorizationId !== original.authorizationId || current.userId !== original.userId) return null;
+        if (current.refreshLease?.leaseHolder !== leaseHolder) {
+          return current.accessToken !== failedAccessToken ? current : null;
+        }
+        if (current.refreshToken && current.refreshToken !== refreshToken) {
+          const reused = { ...current, refreshLease: void 0, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+          await this.store.set(reused);
+          return reused;
+        }
+        const now = /* @__PURE__ */ new Date();
+        const scopes = tokenResponse.scope === void 0 ? current.scopes : grantedCliScopes(current.scopes ?? [], tokenResponse.scope);
+        const updated = {
+          ...current,
+          accessToken: tokenResponse.access_token,
+          refreshToken: tokenResponse.refresh_token ?? current.refreshToken,
+          scopes,
+          expiresAt: tokenResponse.expires_in ? new Date(now.getTime() + tokenResponse.expires_in * 1e3).toISOString() : current.expiresAt,
+          refreshLease: void 0,
+          updatedAt: now.toISOString()
+        };
+        await this.store.set(updated);
+        return updated;
+      });
+    } catch (error) {
+      await this.store.withRefreshLock(async (current) => {
+        if (current?.authType === "oauth" && current.refreshLease?.leaseHolder === leaseHolder) {
+          await this.store.set({
+            ...current,
+            refreshLease: void 0,
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+      });
+      throw error;
+    }
+  }
+};
+
+// src/lib/credentials.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import {
+  closeSync,
+  constants,
+  existsSync,
+  fsyncSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { dirname, join } from "node:path";
+
+// src/lib/vault.ts
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var VAULT_SERVICE = "brainmcp.credentials";
+var LEGACY_VAULT_ACCOUNT = "oauth";
+var VAULT_ACCOUNT = LEGACY_VAULT_ACCOUNT;
+var EXEC_TIMEOUT_MS = 4e3;
+function vaultAccountKey(accountId) {
+  return `oauth:${accountId}`;
+}
+var UnavailableSecretVault = class {
+  name = "unavailable";
+  async isAvailable() {
+    return false;
+  }
+  async getSecret() {
+    return null;
+  }
+  async setSecret() {
+    throw new Error("OS credential vault is unavailable.");
+  }
+  async deleteSecret() {
+  }
+};
+var MacosSecurityVault = class {
+  name = "macos-keychain";
+  async isAvailable() {
+    try {
+      await execFileAsync("which", ["security"], { timeout: EXEC_TIMEOUT_MS });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getSecret(key = VAULT_ACCOUNT) {
+    try {
+      const { stdout } = await execFileAsync(
+        "security",
+        ["find-generic-password", "-s", VAULT_SERVICE, "-a", key, "-w"],
+        { timeout: EXEC_TIMEOUT_MS }
+      );
+      const value = stdout.trim();
+      if (!value) return null;
+      if (value.startsWith("{")) return value;
+      if (/^[0-9a-fA-F]+$/.test(value) && value.length % 2 === 0) {
+        const decoded = Buffer.from(value, "hex").toString("utf8");
+        return decoded.length > 0 ? decoded : null;
+      }
+      return value;
+    } catch {
+      return null;
+    }
+  }
+  async setSecret(value, key = VAULT_ACCOUNT) {
+    const hex = Buffer.from(value, "utf8").toString("hex");
+    await new Promise((resolve, reject) => {
+      const child = spawn("security", ["-i"], { stdio: ["pipe", "ignore", "ignore"] });
+      const timer = setTimeout(() => {
+        child.kill("SIGKILL");
+        reject(new Error("macOS keychain store timed out"));
+      }, EXEC_TIMEOUT_MS);
+      const done = (fn) => {
+        clearTimeout(timer);
+        fn();
+      };
+      child.on("error", (error) => done(() => reject(error)));
+      child.on("close", (code) => {
+        if (code === 0) done(() => resolve());
+        else done(() => reject(new Error("macOS keychain store failed")));
+      });
+      child.stdin.write(`add-generic-password -U -s ${VAULT_SERVICE} -a ${key} -w ${hex}
+`);
+      child.stdin.end();
+    });
+  }
+  async deleteSecret(key = VAULT_ACCOUNT) {
+    try {
+      await execFileAsync(
+        "security",
+        ["delete-generic-password", "-s", VAULT_SERVICE, "-a", key],
+        { timeout: EXEC_TIMEOUT_MS }
+      );
+    } catch {
+    }
+  }
+};
+var LinuxSecretToolVault = class {
+  name = "libsecret";
+  async isAvailable() {
+    try {
+      await execFileAsync("which", ["secret-tool"], { timeout: EXEC_TIMEOUT_MS });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getSecret(key = VAULT_ACCOUNT) {
+    try {
+      const { stdout } = await execFileAsync(
+        "secret-tool",
+        ["lookup", "service", VAULT_SERVICE, "account", key],
+        { timeout: EXEC_TIMEOUT_MS }
+      );
+      const value = stdout.trim();
+      return value.length > 0 ? value : null;
+    } catch {
+      return null;
+    }
+  }
+  async setSecret(value, key = VAULT_ACCOUNT) {
+    await new Promise((resolve, reject) => {
+      const child = spawn(
+        "secret-tool",
+        ["store", "--label", "BrainMCP CLI", "service", VAULT_SERVICE, "account", key],
+        { stdio: ["pipe", "ignore", "ignore"] }
+      );
+      const timer = setTimeout(() => {
+        child.kill("SIGKILL");
+        reject(new Error("secret-tool store timed out"));
+      }, EXEC_TIMEOUT_MS);
+      const done = (fn) => {
+        clearTimeout(timer);
+        fn();
+      };
+      child.on("error", (error) => done(() => reject(error)));
+      child.on("close", (code) => {
+        if (code === 0) done(() => resolve());
+        else done(() => reject(new Error("secret-tool store failed")));
+      });
+      child.stdin.write(value);
+      child.stdin.end();
+    });
+  }
+  async deleteSecret(key = VAULT_ACCOUNT) {
+    try {
+      await execFileAsync(
+        "secret-tool",
+        ["clear", "service", VAULT_SERVICE, "account", key],
+        { timeout: EXEC_TIMEOUT_MS }
+      );
+    } catch {
+    }
+  }
+};
+var WindowsCredentialVault = class {
+  name = "windows-credential-manager";
+  async isAvailable() {
+    return process.platform === "win32";
+  }
+  async getSecret(key = VAULT_ACCOUNT) {
+    try {
+      const { stdout } = await execFileAsync(
+        "powershell.exe",
+        [
+          "-NoProfile",
+          "-Command",
+          `try { $v = New-Object Windows.Security.Credentials.PasswordVault; ($v.Retrieve('${VAULT_SERVICE}','${key}')).Password } catch { '' }`
+        ],
+        { timeout: EXEC_TIMEOUT_MS }
+      );
+      const value = stdout.trim();
+      return value.length > 0 ? value : null;
+    } catch {
+      return null;
+    }
+  }
+  async setSecret(value, key = VAULT_ACCOUNT) {
+    await new Promise((resolve, reject) => {
+      const child = spawn(
+        "powershell.exe",
+        [
+          "-NoProfile",
+          "-Command",
+          `$svc='${VAULT_SERVICE}'; $acct='${key}'; $p=[Console]::In.ReadToEnd(); $v=New-Object Windows.Security.Credentials.PasswordVault; try { $v.Remove($v.Retrieve($svc,$acct)) } catch {}; $v.Add((New-Object Windows.Security.Credentials.PasswordCredential($svc,$acct,$p)))`
+        ],
+        { stdio: ["pipe", "ignore", "ignore"] }
+      );
+      const timer = setTimeout(() => {
+        child.kill("SIGKILL");
+        reject(new Error("Windows PasswordVault store timed out"));
+      }, EXEC_TIMEOUT_MS);
+      const done = (fn) => {
+        clearTimeout(timer);
+        fn();
+      };
+      child.on("error", (error) => done(() => reject(error)));
+      child.on("close", (code) => {
+        if (code === 0) done(() => resolve());
+        else done(() => reject(new Error("Windows PasswordVault store failed")));
+      });
+      child.stdin.write(value);
+      child.stdin.end();
+    });
+  }
+  async deleteSecret(key = VAULT_ACCOUNT) {
+    try {
+      await execFileAsync(
+        "powershell.exe",
+        [
+          "-NoProfile",
+          "-Command",
+          `try { $v = New-Object Windows.Security.Credentials.PasswordVault; $v.Remove($v.Retrieve('${VAULT_SERVICE}','${key}')) } catch {}`
+        ],
+        { timeout: EXEC_TIMEOUT_MS }
+      );
+    } catch {
+    }
+  }
+};
+function createPlatformVault() {
+  if (process.platform === "darwin") return new MacosSecurityVault();
+  if (process.platform === "linux") return new LinuxSecretToolVault();
+  if (process.platform === "win32") return new WindowsCredentialVault();
+  return new UnavailableSecretVault();
+}
+
+// src/lib/credentials.ts
+var FileCredentialStore = class {
+  lockContext = new AsyncLocalStorage();
+  baseDir;
+  warn;
+  allowInsecure;
+  constructor(options = {}) {
+    this.baseDir = options.baseDir ?? getBrainHome();
+    this.warn = options.warn ?? ((msg) => console.warn(`[brainmcp credentials] ${msg}`));
+    this.allowInsecure = options.allowInsecureModesForTesting ?? false;
+  }
+  credentialPaths() {
+    const stateDir = this.lockContext.getStore() ?? resolveStateDir(this.baseDir);
+    return {
+      stateDir,
+      filePath: join(stateDir, "credentials.json"),
+      lockPath: join(stateDir, "credentials.lock")
+    };
+  }
+  assertSafePath(targetPath, checkFileExists = true) {
+    if (this.allowInsecure) return;
+    const dir = dirname(targetPath);
+    if (existsSync(dir)) {
+      const dirStat = lstatSync(dir);
+      if (dirStat.isSymbolicLink()) {
+        throw new Error(`Insecure configuration: directory ${dir} is a symbolic link.`);
+      }
+      if (process.platform !== "win32") {
+        const mode = dirStat.mode & 511;
+        if (mode !== 448) {
+          throw new Error(
+            `Insecure permissions on ${dir}: permissions are ${mode.toString(8)}, must be 700.`
+          );
+        }
+        if (process.getuid && dirStat.uid !== process.getuid()) {
+          throw new Error(`Insecure ownership: directory ${dir} is not owned by current user.`);
+        }
+      }
+    }
+    if (existsSync(targetPath)) {
+      const fileStat = lstatSync(targetPath);
+      if (fileStat.isSymbolicLink()) {
+        throw new Error(`Insecure configuration: file ${targetPath} is a symbolic link.`);
+      }
+      if (!fileStat.isFile()) {
+        throw new Error(`Insecure configuration: ${targetPath} is not a regular file.`);
+      }
+      if (process.platform !== "win32") {
+        const mode = fileStat.mode & 511;
+        if (mode !== 384) {
+          throw new Error(
+            `Insecure permissions on ${targetPath}: permissions are ${mode.toString(8)}, must be 600.`
+          );
+        }
+        if (process.getuid && fileStat.uid !== process.getuid()) {
+          throw new Error(`Insecure ownership: file ${targetPath} is not owned by current user.`);
+        }
+      }
+    } else if (checkFileExists) {
+    }
+  }
+  ensureDirectory() {
+    if (!existsSync(this.baseDir)) {
+      mkdirSync(this.baseDir, { recursive: true, mode: 448 });
+    } else if (!this.allowInsecure) {
+      const homeStat = lstatSync(this.baseDir);
+      if (homeStat.isSymbolicLink()) {
+        throw new Error(`Insecure configuration: directory ${this.baseDir} is a symbolic link.`);
+      }
+    }
+    const paths = this.credentialPaths();
+    ensureDirectory0700(paths.stateDir);
+    this.assertSafePath(paths.filePath, false);
+    return paths;
+  }
+  async get() {
+    const { filePath } = this.credentialPaths();
+    if (!existsSync(filePath)) {
+      return null;
+    }
+    this.assertSafePath(filePath);
+    try {
+      const raw = readFileSync(filePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (parsed.version !== 1) {
+        this.warn(`Unsupported credentials schema version: ${parsed.version}`);
+        return null;
+      }
+      return parsed;
+    } catch (error) {
+      this.warn(`Failed to read credentials: ${error instanceof Error ? error.message : String(error)}`);
+      return null;
+    }
+  }
+  async set(credentials) {
+    const { filePath, stateDir } = this.ensureDirectory();
+    const tempFile = join(
+      stateDir,
+      `credentials.tmp.${process.pid}.${Math.random().toString(36).slice(2, 8)}`
+    );
+    const data = JSON.stringify(credentials, null, 2);
+    try {
+      const fd = openSync(
+        tempFile,
+        constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | (typeof constants.O_NOFOLLOW === "number" ? constants.O_NOFOLLOW : 0),
+        384
+      );
+      try {
+        writeFileSync(fd, data, "utf-8");
+        fsyncSync(fd);
+      } finally {
+        closeSync(fd);
+      }
+      this.assertSafePath(tempFile);
+      renameSync(tempFile, filePath);
+      this.assertSafePath(filePath);
+    } catch (error) {
+      try {
+        if (existsSync(tempFile)) unlinkSync(tempFile);
+      } catch {
+      }
+      throw error;
+    }
+  }
+  async clear() {
+    const { filePath } = this.credentialPaths();
+    if (existsSync(filePath)) {
+      this.assertSafePath(filePath);
+      unlinkSync(filePath);
+    }
+  }
+  async adoptLegacySecret() {
+  }
+  async withRefreshLock(action) {
+    const stateDir = this.credentialPaths().stateDir;
+    return withSessionLock("credentials", () => this.lockContext.run(stateDir, async () => action(await this.get())), { baseDir: stateDir });
+  }
+};
+var VaultCredentialStore = class {
+  constructor(vault, lockStore, baseDir) {
+    this.vault = vault;
+    this.lockStore = lockStore;
+    this.baseDir = baseDir;
+  }
+  vault;
+  lockStore;
+  baseDir;
+  lockContext = new AsyncLocalStorage();
+  get backend() {
+    return "os_vault";
+  }
+  backendMarkerPath() {
+    return join(this.lockContext.getStore()?.stateDir ?? resolveStateDir(this.baseDir ?? getBrainHome()), "credentials.backend.json");
+  }
+  secretKey() {
+    if (this.lockContext.getStore()) return this.lockContext.getStore().key;
+    const accountId = getCurrentAccountId(this.baseDir ?? getBrainHome());
+    return accountId ? vaultAccountKey(accountId) : LEGACY_VAULT_ACCOUNT;
+  }
+  async get() {
+    if (!existsSync(this.backendMarkerPath())) return null;
+    assertNotSymlink(this.backendMarkerPath());
+    const raw = await this.vault.getSecret(this.secretKey());
+    if (!raw) return null;
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed.version !== 1) return null;
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  async set(credentials) {
+    const marker = this.backendMarkerPath();
+    await this.vault.setSecret(JSON.stringify(credentials), this.secretKey());
+    ensureDirectory0700(dirname(marker));
+    writeAtomic0600(
+      marker,
+      JSON.stringify({ backend: "os_vault", updatedAt: (/* @__PURE__ */ new Date()).toISOString() })
+    );
+  }
+  async clear() {
+    const marker = this.backendMarkerPath();
+    await this.vault.deleteSecret(this.secretKey());
+    if (existsSync(marker)) {
+      assertNotSymlink(marker);
+      unlinkSync(marker);
+    }
+  }
+  async adoptLegacySecret() {
+    const accountId = getCurrentAccountId(this.baseDir ?? getBrainHome());
+    if (!accountId) return;
+    const namespaced = vaultAccountKey(accountId);
+    if (await this.vault.getSecret(namespaced)) return;
+    const legacy = await this.vault.getSecret(LEGACY_VAULT_ACCOUNT);
+    if (!legacy) return;
+    await this.vault.setSecret(legacy, namespaced);
+    await this.vault.deleteSecret(LEGACY_VAULT_ACCOUNT);
+    writeAtomic0600(this.backendMarkerPath(), JSON.stringify({ backend: "os_vault", updatedAt: (/* @__PURE__ */ new Date()).toISOString() }));
+  }
+  async withRefreshLock(action) {
+    const context = { key: this.secretKey(), stateDir: resolveStateDir(this.baseDir ?? getBrainHome()) };
+    return this.lockStore.withRefreshLock(() => this.lockContext.run(context, async () => action(await this.get())));
+  }
+};
+var FILE_CREDENTIALS_ACK_FILENAME = "allow-file-credentials";
+function fileCredentialsAcknowledged(baseDir) {
+  if (process.env.BRAINMCP_ALLOW_FILE_CREDENTIALS === "1") return true;
+  const home = baseDir ?? getBrainHome();
+  const acknowledgement = join(home, FILE_CREDENTIALS_ACK_FILENAME);
+  if (!existsSync(acknowledgement)) return false;
+  const stat = lstatSync(acknowledgement);
+  if (stat.isSymbolicLink() || !stat.isFile()) return false;
+  if (process.platform !== "win32") {
+    if ((stat.mode & 511) !== 384) return false;
+    if (process.getuid && stat.uid !== process.getuid()) return false;
+  }
+  return true;
+}
+function writeFileCredentialsAcknowledgement(baseDir) {
+  const home = baseDir ?? getBrainHome();
+  ensureDirectory0700(home);
+  writeAtomic0600(
+    join(home, FILE_CREDENTIALS_ACK_FILENAME),
+    JSON.stringify({ acknowledgedAt: (/* @__PURE__ */ new Date()).toISOString() })
+  );
+}
+async function createDefaultCredentialStore(options = {}) {
+  const warn = options.warn ?? ((msg) => console.warn(`[brainmcp credentials] ${msg}`));
+  const fileStore = new FileCredentialStore({
+    baseDir: options.baseDir,
+    warn
+  });
+  const vault = options.vault ?? (options.baseDir ? new UnavailableSecretVault() : createPlatformVault());
+  const home = options.baseDir ?? getBrainHome();
+  const existingFile = existsSync(join(resolveStateDir(home), "credentials.json"));
+  if (existingFile) return { store: fileStore, backend: "file" };
+  if (await vault.isAvailable()) {
+    return { store: new VaultCredentialStore(vault, fileStore, options.baseDir), backend: "os_vault" };
+  }
+  const allowFile = options.allowFileCredentials === true || existingFile || fileCredentialsAcknowledged(options.baseDir);
+  if (!allowFile) {
+    throw new Error(
+      "OS credential vault is unavailable. Re-run `brainmcp login --allow-file-credentials` to store tokens in an owner-only ~/.brainmcp file (0700/0600, no symlinks)."
+    );
+  }
+  if (!existingFile) {
+    warn(
+      "OS credential vault is unavailable; using the owner-only ~/.brainmcp file store. This is an explicit fallback, not the default."
+    );
+  }
+  if (options.persistFileAcknowledgement) {
+    writeFileCredentialsAcknowledgement(options.baseDir);
+  }
+  return { store: fileStore, backend: "file" };
+}
+
+// src/runtime/hook-dispatcher.ts
+var MAX_STDIN_BYTES = 1024 * 1024;
+var DEFAULT_EVENT_TIMEOUT_MS = 1e3;
+var SESSION_END_TIMEOUT_MS = 3e3;
+function isSessionEndEvent(event) {
+  return event === "SessionEnd" || event === "sessionEnd" || event === "session_end";
+}
+function editedPathFromEvent(event) {
+  if (!event.cwd || !event.toolInput || typeof event.toolInput !== "object") return void 0;
+  const input = event.toolInput;
+  const candidate = [input.file_path, input.filePath, input.path].find(
+    (value) => typeof value === "string" && value.trim().length > 0
+  );
+  return candidate ? filterRelativePaths([candidate], event.cwd)[0] : void 0;
+}
+async function readBoundedStdin(stream = process.stdin, maxBytes = MAX_STDIN_BYTES, signal) {
+  return new Promise((resolve, reject) => {
+    let totalBytes = 0;
+    const chunks = [];
+    let settled = false;
+    const cleanup = () => {
+      stream.removeListener("data", data);
+      stream.removeListener("end", end);
+      stream.removeListener("error", fail);
+      signal?.removeEventListener("abort", abort);
+      stream.pause();
+    };
+    const fail = (err) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(err);
+    };
+    const abort = () => fail(new Error("Hook input timed out"));
+    const data = (chunk) => {
+      const buf = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+      totalBytes += buf.length;
+      if (totalBytes > maxBytes) {
+        fail(new Error(`Input exceeded maximum size limit of ${maxBytes} bytes`));
+        return;
+      }
+      chunks.push(buf);
+    };
+    const end = () => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    };
+    stream.on("data", data);
+    stream.on("end", end);
+    stream.on("error", fail);
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted) abort();
+  });
+}
+function hostOutput(event, additionalContext) {
+  try {
+    return emitHostOutput(event.client, event, additionalContext);
+  } catch {
+    return {};
+  }
+}
+async function loadRuntimeClient(options) {
+  if (options?.apiClient) {
+    return {
+      apiClient: options.apiClient,
+      creds: options.credentials === void 0 ? await options.apiClient.getEffectiveCredentials() : options.credentials
+    };
+  }
+  try {
+    const { store } = await createDefaultCredentialStore({
+      baseDir: options?.baseDir,
+      warn: () => void 0
+    });
+    const apiClient = new ApiClient({ store });
+    return { apiClient, creds: await apiClient.getEffectiveCredentials() };
+  } catch {
+    return { apiClient: null, creds: null };
+  }
+}
+async function dispatchHookEvent(event, options) {
+  const timeoutMs = options?.timeoutMs ?? (isSessionEndEvent(event.event) ? SESSION_END_TIMEOUT_MS : DEFAULT_EVENT_TIMEOUT_MS);
+  const controller = new AbortController();
+  const onExternalAbort = () => controller.abort();
+  options?.signal?.addEventListener("abort", onExternalAbort, { once: true });
+  if (options?.signal?.aborted) controller.abort();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  const credentialOptions = options;
+  try {
+    if ((!event.sessionKey || event.sessionKey === "default_session") && !isSessionStartEvent(event.event)) {
+      return { handled: false, emptyFallback: true, outputPayload: {} };
+    }
+    event = { ...event, sessionKey: crypto3.createHash("sha256").update(JSON.stringify([
+      event.client,
+      event.sessionKey,
+      event.workspaceRoots?.length ? [...event.workspaceRoots].sort() : [event.cwd ?? ""]
+    ])).digest("hex") };
+    options = { ...options, baseDir: resolveStateDir(options?.baseDir) };
+    if (controller.signal.aborted) {
+      throw new Error("Hook dispatch timed out");
+    }
+    const prefs = readPreferences(options?.baseDir);
+    const roots = event.workspaceRoots?.length ? event.workspaceRoots : event.cwd ? [event.cwd] : [];
+    const policies = roots.map(readProjectCaptureRestrictions);
+    const projectWorkspaces = roots.map(readProjectWorkspaceId);
+    const projectPolicy = {
+      captureDisabled: policies.some((policy) => policy.captureDisabled) || projectWorkspaces.some((workspace) => workspace.kind === "invalid" || workspace.kind === "workspace" && workspace.workspaceId !== prefs?.enabledWorkspaceId),
+      promptsDisabled: policies.some((policy) => policy.promptsDisabled)
+    };
+    const persistPrompts = Boolean(
+      prefs?.consent?.captureEnabled && prefs?.consent?.includePrompts && !projectPolicy.promptsDisabled
+    );
+    const captureRuntimeEnabled = Boolean(
+      prefs?.consent?.captureEnabled && !projectPolicy.captureDisabled
+    );
+    if (event.event !== "StopNudge" && isStopEvent(event.event, event.stopHookActive)) {
+      logRuntimeEvent(
+        "info",
+        "hook_stop_ignored",
+        { event: event.event, sessionKey: event.sessionKey, client: event.client },
+        options?.baseDir
+      );
+      return {
+        handled: true,
+        emptyFallback: false,
+        outputPayload: hostOutput(event)
+      };
+    }
+    if (!isSessionStartEvent(event.event) && !captureRuntimeEnabled && !event.nudgeLedger && event.event !== "StopNudge") {
+      return {
+        handled: true,
+        emptyFallback: false,
+        outputPayload: hostOutput(event)
+      };
+    }
+    if (isSessionStartEvent(event.event) && !captureRuntimeEnabled && !event.nudgeLedger) {
+      const { apiClient: apiClient2, creds: creds2 } = await withRequestDeadline(timeoutMs, controller.signal, () => loadRuntimeClient(credentialOptions));
+      const additionalContext2 = apiClient2 ? await safeSessionStartOrientation({
+        apiClient: apiClient2,
+        creds: creds2,
+        signal: controller.signal,
+        baseDir: options?.baseDir,
+        cwd: event.cwd,
+        workspaceRoots: event.workspaceRoots
+      }) : loginOrientationMessage();
+      if (controller.signal.aborted) throw new Error("Hook dispatch timed out");
+      return {
+        handled: true,
+        emptyFallback: false,
+        outputPayload: hostOutput(event, additionalContext2)
+      };
+    }
+    const isMeaningful = Boolean(
+      event.prompt || event.assistantText || event.event === "UserPrompt" || event.event === "prompt" || event.toolName && !/read|list/i.test(event.toolName)
+    );
+    if (isSessionStartEvent(event.event)) pruneLocalState({ baseDir: options.baseDir });
+    const ledger = await recordSessionEvent({
+      sessionKey: event.sessionKey,
+      baseDir: options?.baseDir,
+      isMeaningful,
+      editedPath: captureRuntimeEnabled ? editedPathFromEvent(event) : void 0,
+      prompt: persistPrompts ? event.prompt : void 0,
+      assistantSummary: captureRuntimeEnabled ? event.assistantText : void 0,
+      model: captureRuntimeEnabled ? event.model : void 0,
+      persistPrompts,
+      captureRevision: captureRuntimeEnabled ? prefs?.consent.revision ?? 0 : void 0,
+      workspaceId: captureRuntimeEnabled ? prefs?.enabledWorkspaceId : void 0,
+      projectKey: event.cwd ? captureProjectKey(event.cwd) : void 0,
+      toolResult: event.toolName ? {
+        toolName: event.toolName,
+        result: event.toolResult
+      } : void 0
+    });
+    if (controller.signal.aborted) {
+      throw new Error("Hook dispatch timed out");
+    }
+    if (event.event === "StopNudge") {
+      const lastMeaningful = ledger.lastMeaningfulSequence ?? 0;
+      const alreadyHandledThrough = Math.max(
+        ledger.lastSuccessfulWriteBackSequence ?? 0,
+        ledger.lastNudgedSequence ?? 0
+      );
+      if (!event.stopHookActive && lastMeaningful > alreadyHandledThrough) {
+        await markSessionNudged({
+          sessionKey: event.sessionKey,
+          nudgedThroughSequence: lastMeaningful,
+          baseDir: options?.baseDir
+        });
+        return {
+          handled: true,
+          emptyFallback: false,
+          outputPayload: hostOutput(
+            event,
+            "Before finishing, consider whether this work produced genuinely new durable project knowledge. If so, use brain_remember, brain_amend, or brain_change_propose; otherwise continue without writing."
+          )
+        };
+      }
+      return { handled: true, emptyFallback: false, outputPayload: {} };
+    }
+    if (isStopEvent(event.event, event.stopHookActive)) {
+      logRuntimeEvent(
+        "info",
+        "hook_stop_ignored",
+        {
+          event: event.event,
+          sessionKey: event.sessionKey,
+          client: event.client
+        },
+        options?.baseDir
+      );
+      return {
+        handled: true,
+        emptyFallback: false,
+        outputPayload: hostOutput(event)
+      };
+    }
+    const { apiClient, creds } = await withRequestDeadline(timeoutMs, controller.signal, () => loadRuntimeClient(credentialOptions));
+    let additionalContext;
+    if (isSessionStartEvent(event.event)) {
+      additionalContext = apiClient ? await safeSessionStartOrientation({
+        apiClient,
+        creds,
+        signal: controller.signal,
+        baseDir: options?.baseDir,
+        cwd: event.cwd,
+        workspaceRoots: event.workspaceRoots
+      }) : loginOrientationMessage();
+    } else if (isUserPromptEvent(event.event)) {
+      additionalContext = void 0;
+    }
+    if (controller.signal.aborted) {
+      throw new Error("Hook dispatch timed out");
+    }
+    const trigger = captureTriggerForEvent(event.event);
+    const hasUncapturedMeaningfulSlice = (ledger.lastMeaningfulSequence ?? 0) > (ledger.lastCapturedSequence ?? 0);
+    if (trigger && isCaptureEligible(event.event, prefs, projectPolicy) && hasUncapturedMeaningfulSlice) {
+      const workspaceId = resolveCaptureWorkspaceId(prefs);
+      if (!workspaceId) {
+        logRuntimeEvent(
+          "warn",
+          "capture_workspace_unresolved",
+          {
+            event: event.event,
+            sessionKey: event.sessionKey
+          },
+          options?.baseDir
+        );
+      } else if (!canEnqueueCapture(options?.baseDir)) {
+        logRuntimeEvent(
+          "warn",
+          "capture_queue_capped",
+          { event: event.event, sessionKey: event.sessionKey },
+          options?.baseDir
+        );
+      } else {
+        if (creds?.authType !== "oauth" || !creds.authorizationId || !creds.scopes?.includes("digests:write") || !creds.workspaces?.includes(workspaceId)) {
+          logRuntimeEvent(
+            "warn",
+            "capture_authorization_unresolved",
+            { event: event.event, sessionKey: event.sessionKey },
+            options?.baseDir
+          );
+        } else {
+          const payload = buildDigestPayload({
+            trigger,
+            workspaceId,
+            host: event.client,
+            model: event.model ?? ledger.model,
+            summary: ledger.assistantSummary,
+            paths: ledger.editedPaths,
+            gitMetadata: collectGitMetadata(event.cwd ?? event.workspaceRoots?.[0]),
+            prompts: ledger.prompts,
+            includePrompts: Boolean(prefs?.consent?.includePrompts && !projectPolicy.promptsDisabled)
+          });
+          const digestId = payload.clientDigestId;
+          await queueSessionCapture({
+            sessionKey: event.sessionKey,
+            capturedThroughSequence: ledger.lastMeaningfulSequence ?? ledger.eventSequence,
+            baseDir: options?.baseDir,
+            item: {
+              digestId,
+              workspaceId,
+              captureTrigger: trigger,
+              policyVersion: prefs?.consent?.policyVersion ?? "2026-09-02.capture-v1",
+              digestText: serializeDigestPayload(payload),
+              authorizationId: creds.authorizationId,
+              consentRevision: prefs?.consent?.revision ?? 0
+            }
+          });
+          logRuntimeEvent(
+            "info",
+            "capture_queued",
+            {
+              sessionKey: event.sessionKey,
+              digestId,
+              trigger
+            },
+            options?.baseDir
+          );
+        }
+      }
+    }
+    const canFlush = Boolean(apiClient) && creds?.authType === "oauth" && Boolean(creds.accessToken) && Boolean(creds.authorizationId) && Array.isArray(creds.scopes) && creds.scopes.includes("digests:write");
+    const isSessionEnd = isSessionEndEvent(event.event);
+    if (canFlush && apiClient && !controller.signal.aborted && !isSessionStartEvent(event.event) && !isSessionEnd) {
+      await flushCaptureQueue({
+        apiClient,
+        baseDir: options?.baseDir,
+        signal: controller.signal,
+        allowAutomatic: prefs?.consent?.captureEnabled === true && !projectPolicy.captureDisabled,
+        credentials: creds
+      }).catch(() => void 0);
+    }
+    logRuntimeEvent(
+      "info",
+      "hook_event_processed",
+      {
+        event: event.event,
+        sessionKey: event.sessionKey,
+        client: event.client
+      },
+      options?.baseDir
+    );
+    return {
+      handled: true,
+      emptyFallback: false,
+      outputPayload: hostOutput(event, additionalContext)
+    };
+  } catch (err) {
+    logRuntimeEvent(
+      "warn",
+      "hook_dispatch_failed",
+      {
+        event: event.event,
+        sessionKey: event.sessionKey,
+        error: err instanceof Error ? err.message : String(err)
+      },
+      options?.baseDir
+    );
+    return {
+      handled: false,
+      emptyFallback: true,
+      outputPayload: {},
+      error: err instanceof Error ? err.message : String(err)
+    };
+  } finally {
+    clearTimeout(timeoutId);
+    options?.signal?.removeEventListener("abort", onExternalAbort);
+  }
+}
+
+// src/runtime/installer.ts
+import fs10 from "node:fs";
+import path10 from "node:path";
+import crypto4 from "node:crypto";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+var RUNTIME_VERSION_RE = /^[0-9A-Za-z][0-9A-Za-z._-]{0,63}$/;
+function normalizeRuntimeVersion(version) {
+  const normalized = version.trim().replace(/^v/, "");
+  if (!RUNTIME_VERSION_RE.test(normalized) || normalized.includes("..")) {
+    throw new Error(`Invalid BrainMCP runtime version: ${version}`);
+  }
+  return normalized;
+}
+function getRuntimesDir(baseDir) {
+  const home = baseDir ?? getBrainHome();
+  const runtimesDir = path10.join(home, "runtime");
+  ensureDirectory0700(runtimesDir);
+  return runtimesDir;
+}
+function getVersionedRuntimeDir(version, baseDir) {
+  const runtimesDir = getRuntimesDir(baseDir);
+  const versionDir = path10.join(runtimesDir, `v${normalizeRuntimeVersion(version)}`);
+  ensureDirectory0700(versionDir);
+  return versionDir;
+}
+function getVersionedRuntimePath(version, baseDir) {
+  const versionDir = getVersionedRuntimeDir(version, baseDir);
+  return path10.join(versionDir, "brainmcp-hook-runtime.mjs");
+}
+function installRuntimeBundle(version, bundleContent, baseDir) {
+  const versionDir = getVersionedRuntimeDir(version, baseDir);
+  const targetPath = path10.join(versionDir, "brainmcp-hook-runtime.mjs");
+  assertNotSymlink(targetPath);
+  const tmpPath = `${targetPath}.tmp.${crypto4.randomUUID()}`;
+  try {
+    fs10.writeFileSync(tmpPath, bundleContent, { flag: "wx", mode: 493 });
+    fs10.renameSync(tmpPath, targetPath);
+  } catch (error) {
+    try {
+      fs10.unlinkSync(tmpPath);
+    } catch {
+    }
+    throw error;
+  }
+  return {
+    version,
+    runtimePath: targetPath,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function listInstalledRuntimes(baseDir) {
+  const runtimesDir = getRuntimesDir(baseDir);
+  const entries = fs10.readdirSync(runtimesDir);
+  const runtimes = [];
+  for (const entry of entries) {
+    if (!entry.startsWith("v")) continue;
+    const versionDir = path10.join(runtimesDir, entry);
+    const runtimePath = path10.join(versionDir, "brainmcp-hook-runtime.mjs");
+    if (fs10.existsSync(runtimePath)) {
+      try {
+        const stat = fs10.lstatSync(runtimePath);
+        if (!stat.isSymbolicLink()) {
+          runtimes.push({
+            version: entry.replace(/^v/, ""),
+            runtimePath,
+            installedAt: stat.mtime.toISOString()
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  return runtimes;
+}
+function removeRuntimeVersion(version, referencedPaths, baseDir) {
+  const targetPath = getVersionedRuntimePath(version, baseDir);
+  const normalizedTarget = path10.resolve(targetPath);
+  const isReferenced = referencedPaths.some((ref) => {
+    const normRef = path10.resolve(ref);
+    return normRef === normalizedTarget || normRef.includes(`/v${normalizeRuntimeVersion(version)}/`);
+  });
+  if (isReferenced) {
+    return {
+      removed: false,
+      blockedReason: `Runtime v${version} is still referenced by an active host configuration`
+    };
+  }
+  const versionDir = getVersionedRuntimeDir(version, baseDir);
+  if (fs10.existsSync(versionDir)) {
+    fs10.rmSync(versionDir, { recursive: true, force: true });
+    return { removed: true };
+  }
+  return { removed: false, blockedReason: `Runtime v${version} does not exist` };
+}
+function cliPackageVersion() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    return String(require2("../../package.json").version);
+  } catch {
+    return "0.1.13";
+  }
+}
+function loadPackagedRuntimeBundle() {
+  const here = path10.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path10.join(here, "brainmcp-hook-runtime.mjs"),
+    path10.join(here, "../../dist/runtime/brainmcp-hook-runtime.mjs")
+  ];
+  for (const candidate of candidates) {
+    if (fs10.existsSync(candidate)) {
+      return fs10.readFileSync(candidate, "utf8");
+    }
+  }
+  return null;
+}
+
+// src/runtime/index.ts
+async function runHookRuntimeCli(args = process.argv.slice(2)) {
+  try {
+    await withRequestDeadline(args[1]?.toLowerCase().includes("sessionend") ? 2500 : 1500, void 0, async (signal) => {
+      const rawInput = await readBoundedStdin(process.stdin, void 0, signal);
+      if (!rawInput.trim()) {
+        process.stdout.write("{}\n");
+        process.exitCode = 0;
+        return;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(rawInput);
+      } catch {
+        process.stdout.write("{}\n");
+        process.exitCode = 0;
+        return;
+      }
+      const host = String(args[0] || parsed.client || "claude-code");
+      const eventName = String(args[1] || parsed.event || parsed.hook_event_name || "GenericEvent");
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("Invalid hook input");
+      const normalizedEvent = parseHostEvent(host, parsed, eventName);
+      normalizedEvent.nudgeLedger = args.includes("--nudge-ledger");
+      const res = await dispatchHookEvent(normalizedEvent, { signal });
+      signal.throwIfAborted();
+      process.stdout.write(JSON.stringify(res.outputPayload ?? {}) + "\n");
+      process.exitCode = 0;
+    });
+  } catch {
+    logRuntimeEvent("warn", "hook_input_or_deadline_failed");
+    process.stdout.write("{}\n");
+    process.exitCode = 0;
+  }
+}
+function isMainModule() {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  try {
+    return fs11.realpathSync(fileURLToPath2(import.meta.url)) === fs11.realpathSync(path11.resolve(entry));
+  } catch {
+    return false;
+  }
+}
+if (isMainModule()) {
+  void runHookRuntimeCli();
+}
+export {
+  ACCOUNTS_DIR_NAME,
+  CURRENT_ACCOUNT_FILENAME,
+  CURRENT_ACCOUNT_SCHEMA_VERSION,
+  DEFAULT_EVENT_TIMEOUT_MS,
+  MAX_STDIN_BYTES,
+  SERVICE_ACCOUNT_ID,
+  SESSION_END_TIMEOUT_MS,
+  acquireSessionLock,
+  activateAccount,
+  assertNotSymlink,
+  clearCurrentAccount,
+  cliPackageVersion,
+  dispatchHookEvent,
+  enqueueCaptureItem,
+  ensureDirectory0700,
+  getAccountStateDir,
+  getBrainHome,
+  getCurrentAccountId,
+  getCurrentAccountPath,
+  getLogsDir,
+  getPreferencesPath,
+  getQueueDir,
+  getQueueItemPath,
+  getRuntimesDir,
+  getSessionLedgerPath,
+  getSessionLockPath,
+  getVersionedRuntimeDir,
+  getVersionedRuntimePath,
+  installRuntimeBundle,
+  isProcessAlive,
+  listInstalledRuntimes,
+  listQueueItems,
+  loadMostRecentSessionLedger,
+  loadPackagedRuntimeBundle,
+  loadSessionLedger,
+  logRuntimeEvent,
+  markSessionCaptured,
+  markSessionNudged,
+  migrateLegacyFlatState,
+  normalizeRuntimeVersion,
+  parseBrainToolResult,
+  previewCapturePurge,
+  pruneLocalState,
+  purgeCaptureLocalState,
+  queueSessionCapture,
+  readBoundedStdin,
+  readPreferences,
+  readSafeJson,
+  recordSessionEvent,
+  removeQueueItem,
+  removeRuntimeVersion,
+  resolveStateDir,
+  runHookRuntimeCli,
+  sanitizeAccountId,
+  saveSessionLedger,
+  scrubMetadata,
+  switchCurrentAccount,
+  updateQueueItem,
+  validateCurrentAccountRecord,
+  withSessionLock,
+  writeAtomic0600,
+  writePreferences
+};