@agnamo/nopilot 0.0.0-stage → 0.1.1

package/main.js

@@ -0,0 +1,2320 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+
+// src/main.ts
+var main_exports = {};
+__export(main_exports, {
+  default: () => NopilotPlugin
+});
+module.exports = __toCommonJS(main_exports);
+var import_obsidian6 = require("obsidian");
+
+// src/agent-runner.ts
+var OUTPUT_LIMIT = 8e3;
+var SHELL_METACHARACTERS = /[&|<>;$`\n\r"']/;
+async function runLocalAgent(options) {
+  if (!options.enabled) {
+    return failure("Agent is off. Enable it in Nopilot settings.");
+  }
+  const command = options.command.trim();
+  if (command.length === 0) {
+    return failure("Agent command is empty.");
+  }
+  if (isShellLine(options.command) || isShellLine(command)) {
+    return failure("Agent command must be one executable, not a shell line.");
+  }
+  if (options.prompt.trim().length === 0) {
+    return failure("Nothing to send to the agent.");
+  }
+  const cwd = options.cwd.trim();
+  if (cwd.length === 0) {
+    return failure("Agent working directory is empty.");
+  }
+  let childProcess;
+  try {
+    childProcess = await loadChildProcess();
+  } catch {
+    return failure("Local agent needs the desktop app.");
+  }
+  return runExecFile(
+    childProcess,
+    command,
+    options.args ?? [],
+    options.prompt,
+    cwd,
+    options.timeoutMs,
+    options.sendStdin !== false
+  );
+}
+function isShellLine(command) {
+  return SHELL_METACHARACTERS.test(command) || command.includes("..");
+}
+function failure(reason, code = null, stdout = "", stderr = "") {
+  return {
+    ok: false,
+    code,
+    stdout: truncate(stdout),
+    stderr: truncate(stderr),
+    reason
+  };
+}
+function truncate(value) {
+  return value.length <= OUTPUT_LIMIT ? value : value.slice(0, OUTPUT_LIMIT);
+}
+function asText(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value == null) {
+    return "";
+  }
+  return value.toString("utf8");
+}
+async function loadChildProcess() {
+  const moduleName = "child_process";
+  const loaded = await loadBuiltin(moduleName);
+  return asChildProcessModule(loaded);
+}
+async function loadBuiltin(moduleName) {
+  const lexical = readLexicalRequire();
+  if (lexical) {
+    try {
+      return lexical(moduleName);
+    } catch {
+    }
+  }
+  const hostRequire = readHostRequire();
+  if (hostRequire) {
+    try {
+      return hostRequire(moduleName);
+    } catch {
+    }
+  }
+  return loadWithCreateRequire(moduleName);
+}
+function readLexicalRequire() {
+  if (typeof require !== "function") {
+    return null;
+  }
+  return require;
+}
+function readHostRequire() {
+  const host = globalThis;
+  if (typeof host.require !== "function") {
+    return null;
+  }
+  return host.require;
+}
+async function loadWithCreateRequire(moduleName) {
+  const imported = await import(moduleSpecifier());
+  if (!isCreateRequireModule(imported)) {
+    throw new Error("createRequire missing");
+  }
+  return imported.createRequire(anchorFile())(moduleName);
+}
+function anchorFile() {
+  const cwd = typeof process === "object" && process !== null && typeof process.cwd === "function" ? process.cwd() : ".";
+  return `${cwd.split("\\").join("/")}/nopilot-anchor.cjs`;
+}
+function moduleSpecifier() {
+  return ["mod", "ule"].join("");
+}
+function isCreateRequireModule(value) {
+  if (typeof value !== "object" || value === null || !("createRequire" in value)) {
+    return false;
+  }
+  const createRequire = value.createRequire;
+  return typeof createRequire === "function";
+}
+function asChildProcessModule(value) {
+  if (typeof value !== "object" || value === null || !("execFile" in value)) {
+    throw new Error("execFile missing");
+  }
+  const execFile = value.execFile;
+  if (typeof execFile !== "function") {
+    throw new Error("execFile missing");
+  }
+  return value;
+}
+function runExecFile(childProcess, command, args, prompt, cwd, timeoutMs, sendStdin) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      resolve(result);
+    };
+    let child;
+    try {
+      child = childProcess.execFile(
+        command,
+        cleanArgs(args),
+        {
+          cwd,
+          timeout: timeoutMs ?? 12e4,
+          windowsHide: true,
+          maxBuffer: 1e6,
+          shell: false
+        },
+        (error, stdout, stderr) => {
+          finish(resultFromExec(error, asText(stdout), asText(stderr)));
+        }
+      );
+    } catch (error) {
+      finish(
+        failure(error instanceof Error ? error.message : "Local agent needs the desktop app.")
+      );
+      return;
+    }
+    const stdin = child.stdin;
+    if (stdin == null) {
+      stopChild(child);
+      finish(failure("Local agent needs the desktop app."));
+      return;
+    }
+    if (!sendStdin) {
+      try {
+        stdin.end();
+      } catch {
+      }
+      return;
+    }
+    stdin.on("error", (error) => {
+      stopChild(child);
+      finish(failure(error.message || "Failed to send the prompt."));
+    });
+    try {
+      stdin.write(prompt);
+      stdin.end();
+    } catch (error) {
+      stopChild(child);
+      finish(failure(error instanceof Error ? error.message : "Failed to send the prompt."));
+    }
+  });
+}
+function resultFromExec(error, stdout, stderr) {
+  if (error == null) {
+    return {
+      ok: true,
+      code: 0,
+      stdout: truncate(stdout),
+      stderr: truncate(stderr)
+    };
+  }
+  if (error.killed === true || Boolean(error.signal) || typeof error.code !== "number") {
+    return failure(error.message, null, stdout, stderr);
+  }
+  if (error.code === 0) {
+    return {
+      ok: true,
+      code: 0,
+      stdout: truncate(stdout),
+      stderr: truncate(stderr)
+    };
+  }
+  return {
+    ok: false,
+    code: error.code,
+    stdout: truncate(stdout),
+    stderr: truncate(stderr)
+  };
+}
+function cleanArgs(args) {
+  if (args.length > 24) {
+    throw new Error("Agent arguments are not allowed.");
+  }
+  const cleaned = [];
+  for (const arg of args) {
+    if (arg.length === 0 || arg.length > 8e3 || arg.includes("\0")) {
+      throw new Error("Agent arguments are not allowed.");
+    }
+    cleaned.push(arg);
+  }
+  return cleaned;
+}
+function stopChild(child) {
+  try {
+    child.kill();
+  } catch {
+  }
+}
+async function writeQueryFile(text) {
+  const fs2 = asFs(await loadBuiltin("fs"));
+  const os = asOs(await loadBuiltin("os"));
+  const path2 = asPath(await loadBuiltin("path"));
+  const dir = fs2.mkdtempSync(path2.join(os.tmpdir(), "nopilot-packet-"));
+  const file = path2.join(dir, "packet.md");
+  fs2.writeFileSync(file, text, "utf8");
+  return file;
+}
+async function removeQueryFile(filePath) {
+  try {
+    const fs2 = asFs(await loadBuiltin("fs"));
+    const os = asOs(await loadBuiltin("os"));
+    const path2 = asPath(await loadBuiltin("path"));
+    const root = path2.join(os.tmpdir(), "nopilot-packet-");
+    if (!filePath.startsWith(root)) return;
+    fs2.rmSync(path2.dirname(filePath), { recursive: true, force: true });
+  } catch {
+  }
+}
+function asFs(value) {
+  if (!isRecord(value) || typeof value.mkdtempSync !== "function" || typeof value.writeFileSync !== "function") {
+    throw new Error("Local agent needs the desktop app.");
+  }
+  return value;
+}
+function asOs(value) {
+  if (!isRecord(value) || typeof value.tmpdir !== "function") {
+    throw new Error("Local agent needs the desktop app.");
+  }
+  return value;
+}
+function asPath(value) {
+  if (!isRecord(value) || typeof value.join !== "function" || typeof value.dirname !== "function") {
+    throw new Error("Local agent needs the desktop app.");
+  }
+  return value;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/chat-view.ts
+var import_obsidian2 = require("obsidian");
+
+// src/constants.ts
+var VIEW_TYPE_CHAT = "nopilot-chat";
+var DEFAULT_SETTINGS = {
+  provider: "openai-compatible",
+  baseUrl: "https://api.deepseek.com",
+  apiKey: "",
+  model: "deepseek-chat",
+  systemPrompt: "You are Nopilot, the LuxDev vault assistant. Be concise. When note context is provided, cite the note title. Do not invent notes.",
+  conversationsFolder: "nopilot/conversations",
+  promptsFolder: "nopilot/prompts",
+  skillsFolder: "nopilot/skills",
+  memoryFolder: "nopilot/memory",
+  contextTurns: 12,
+  includeActiveNote: true,
+  includeSelection: true,
+  temperature: 0.7,
+  agentCommand: "opencode",
+  agentEnabled: false,
+  backend: "byok",
+  modules: {
+    byok: true,
+    hermes: true,
+    opencode: true,
+    pi: true
+  },
+  hermesCommand: "hermes",
+  opencodeCommand: "opencode",
+  piCommand: "pi",
+  subagentEnabled: false,
+  subagentBackend: "pi",
+  maxSubagents: 1,
+  includeDirectory: true
+};
+function surfaceLabel(settings) {
+  if (settings.backend === "byok") {
+    const model = settings.model.trim();
+    return model.length > 0 ? model : "byok";
+  }
+  return settings.backend;
+}
+
+// src/vault-context.ts
+var import_obsidian = require("obsidian");
+var ACTIVE_NOTE_LIMIT = 12e3;
+var SELECTION_LIMIT = 8e3;
+var MEMORY_LIMIT = 4e3;
+function approximateTokens(text) {
+  if (text.length === 0) {
+    return 0;
+  }
+  return Math.ceil(text.length / 4);
+}
+function truncate2(text, max) {
+  if (text.length <= max) return text;
+  const marker = "\n\n[truncated]\n";
+  const keep = Math.max(0, max - marker.length);
+  return `${text.slice(0, keep)}${marker}`;
+}
+function isNonEmpty(value) {
+  return value !== null && value.length > 0;
+}
+function vaultPath(folder, name) {
+  const joined = `${folder}/${name}`.replace(/\\/g, "/").replace(/\/{2,}/g, "/");
+  return joined.replace(/^\//, "");
+}
+function renderContextBlock(ctx) {
+  const sections = [];
+  const title = ctx.activeNoteTitle ?? "";
+  const path2 = ctx.activeNotePath ?? "";
+  const body = ctx.activeNoteBody ?? "";
+  if (title.length > 0 || path2.length > 0 || body.length > 0) {
+    sections.push(`Active note: ${title} (${path2})
+---
+${body}
+---`);
+  }
+  if (isNonEmpty(ctx.selection)) {
+    sections.push(`Selection:
+${ctx.selection}
+---`);
+  }
+  if (isNonEmpty(ctx.memory)) {
+    sections.push(`Memory:
+${ctx.memory}`);
+  }
+  if (sections.length === 0) {
+    return "";
+  }
+  return `[Nopilot context]
+${sections.join("\n")}`;
+}
+async function readVaultContext(app, settings) {
+  const ctx = {
+    activeNotePath: null,
+    activeNoteTitle: null,
+    activeNoteBody: null,
+    selection: null,
+    memory: null
+  };
+  if (settings.includeActiveNote) {
+    try {
+      const file = app.workspace.getActiveFile();
+      const view = app.workspace.getActiveViewOfType(import_obsidian.MarkdownView);
+      const editorFile = view?.file;
+      if (file && file.extension.toLowerCase() === "md") {
+        const raw = view && editorFile?.path === file.path ? view.editor.getValue() : await app.vault.cachedRead(file);
+        ctx.activeNotePath = file.path;
+        ctx.activeNoteTitle = file.basename;
+        ctx.activeNoteBody = truncate2(raw, ACTIVE_NOTE_LIMIT);
+      }
+    } catch {
+      ctx.activeNotePath = null;
+      ctx.activeNoteTitle = null;
+      ctx.activeNoteBody = null;
+    }
+  }
+  if (settings.includeSelection) {
+    try {
+      const view = app.workspace.getActiveViewOfType(import_obsidian.MarkdownView);
+      if (view) {
+        const selected = view.editor.getSelection();
+        ctx.selection = selected.trim().length > 0 ? truncate2(selected, SELECTION_LIMIT) : null;
+      }
+    } catch {
+      ctx.selection = null;
+    }
+  }
+  if (settings.memoryFolder) {
+    try {
+      const path2 = vaultPath(settings.memoryFolder, "memory.md");
+      const abstract = app.vault.getAbstractFileByPath(path2);
+      if (abstract instanceof import_obsidian.TFile) {
+        const raw = await app.vault.cachedRead(abstract);
+        ctx.memory = truncate2(raw, MEMORY_LIMIT);
+      }
+    } catch {
+      ctx.memory = null;
+    }
+  }
+  return ctx;
+}
+
+// src/chat-view.ts
+var _messages;
+var NopilotChatView = class extends import_obsidian2.ItemView {
+  constructor(leaf, host) {
+    super(leaf);
+    // A method and a field cannot share this name under strict TS.
+    __privateAdd(this, _messages, []);
+    this.pending = false;
+    this.extraContext = [];
+    this.epoch = 0;
+    this.host = host;
+  }
+  getViewType() {
+    return VIEW_TYPE_CHAT;
+  }
+  getDisplayText() {
+    return "Nopilot";
+  }
+  getIcon() {
+    return "message-square";
+  }
+  messages() {
+    return __privateGet(this, _messages).slice();
+  }
+  /** Host save path. Same shallow copy as messages(). */
+  getMessages() {
+    return this.messages();
+  }
+  draft() {
+    return this.inputEl?.value ?? "";
+  }
+  isBusy() {
+    return this.pending;
+  }
+  refreshLabel() {
+    if (this.modelEl) {
+      this.modelEl.textContent = surfaceLabel(this.host.settings);
+    }
+  }
+  newChat() {
+    if (this.pending) {
+      new import_obsidian2.Notice("Wait for the current reply.");
+      return;
+    }
+    this.epoch += 1;
+    __privateSet(this, _messages, []);
+    this.extraContext = [];
+    this.clearError();
+    this.renderLog();
+  }
+  addContext(label, body) {
+    this.extraContext.push({ label, body });
+    this.renderLog();
+  }
+  async sendText(text) {
+    const trimmed = text.trim();
+    if (trimmed.length === 0 || this.pending) {
+      return;
+    }
+    this.pending = true;
+    if (this.sendBtn) {
+      this.sendBtn.disabled = true;
+    }
+    const epoch = this.epoch;
+    try {
+      const content = await this.buildUserContent(trimmed);
+      if (epoch !== this.epoch) {
+        return;
+      }
+      __privateGet(this, _messages).push({
+        role: "user",
+        content,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      this.extraContext = [];
+      if (this.inputEl) {
+        this.inputEl.value = "";
+      }
+      this.clearError();
+      this.renderLog();
+      const outbound = this.outboundMessages();
+      const result = await this.host.complete(outbound);
+      if (epoch !== this.epoch) {
+        return;
+      }
+      __privateGet(this, _messages).push({
+        role: "assistant",
+        content: result.text,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } catch (err) {
+      if (epoch !== this.epoch) {
+        return;
+      }
+      const message = thrownMessage(err);
+      this.setError(message);
+      new import_obsidian2.Notice(message);
+    } finally {
+      this.pending = false;
+      if (this.sendBtn) {
+        this.sendBtn.disabled = false;
+      }
+      if (this.logEl?.isConnected) {
+        this.renderLog();
+        this.logEl.scrollTop = this.logEl.scrollHeight;
+      }
+    }
+  }
+  async onOpen() {
+    const root = this.contentEl;
+    root.empty();
+    root.addClass("nopilot-root");
+    const header = root.createDiv({ cls: "nopilot-header" });
+    header.createEl("span", { text: "Nopilot" });
+    this.modelEl = header.createEl("span", {
+      cls: "nopilot-model",
+      text: surfaceLabel(this.host.settings)
+    });
+    this.logEl = root.createDiv({ cls: "nopilot-log" });
+    this.errorEl = root.createDiv({ cls: "nopilot-error" });
+    this.errorEl.hidden = true;
+    const composer = root.createDiv({ cls: "nopilot-composer" });
+    this.inputEl = composer.createEl("textarea", {
+      cls: "nopilot-input",
+      attr: { placeholder: "Write to Nopilot", rows: "3" }
+    });
+    this.sendBtn = composer.createEl("button", {
+      cls: "nopilot-send",
+      text: "Send",
+      attr: { type: "button" }
+    });
+    this.inputEl.addEventListener("keydown", (evt) => {
+      if (evt.key !== "Enter" || evt.shiftKey || evt.isComposing || evt.repeat) {
+        return;
+      }
+      evt.preventDefault();
+      void this.sendText(this.inputEl.value);
+    });
+    this.sendBtn.addEventListener("click", () => {
+      void this.sendText(this.inputEl.value);
+    });
+    this.renderLog();
+  }
+  async onClose() {
+    this.contentEl.empty();
+  }
+  async buildUserContent(trimmed) {
+    let content = trimmed;
+    if (this.host.settings.includeActiveNote || this.host.settings.includeSelection) {
+      const ctx = await this.host.readContext();
+      const block = renderContextBlock(ctx);
+      if (block.trim().length > 0) {
+        content = `${block}
+
+${content}`;
+      }
+    }
+    if (this.extraContext.length > 0) {
+      const extras = this.extraContext.map((item) => `[${item.label}]
+${item.body}`).join("\n\n");
+      content = `${content}
+
+${extras}`;
+    }
+    return content;
+  }
+  outboundMessages() {
+    const nonSystem = __privateGet(this, _messages).filter((message) => message.role !== "system");
+    const turns = Math.max(1, this.host.settings.contextTurns);
+    const recent = nonSystem.slice(-turns);
+    const outbound = [];
+    const prompt = this.host.settings.systemPrompt;
+    if (prompt.trim().length > 0) {
+      outbound.push({
+        role: "system",
+        content: prompt,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    outbound.push(...recent);
+    return outbound;
+  }
+  renderLog() {
+    if (!this.logEl?.isConnected) {
+      return;
+    }
+    if (this.modelEl) {
+      this.modelEl.textContent = surfaceLabel(this.host.settings);
+    }
+    this.logEl.empty();
+    for (const extra of this.extraContext) {
+      this.logEl.createDiv({ cls: "nopilot-context", text: extra.label });
+    }
+    const visible = __privateGet(this, _messages).filter((message) => message.role !== "system");
+    if (visible.length === 0) {
+      this.logEl.createDiv({ cls: "nopilot-empty", text: "No messages yet." });
+      return;
+    }
+    for (const message of visible) {
+      const row = this.logEl.createDiv({
+        cls: message.role === "user" ? "nopilot-msg nopilot-msg-user" : "nopilot-msg nopilot-msg-assistant"
+      });
+      row.createDiv({ text: message.role === "user" ? "You" : "Nopilot" });
+      const body = row.createDiv();
+      body.textContent = message.content;
+    }
+  }
+  setError(message) {
+    if (!this.errorEl) {
+      return;
+    }
+    this.errorEl.textContent = message;
+    this.errorEl.hidden = message.length === 0;
+  }
+  clearError() {
+    this.setError("");
+  }
+};
+_messages = new WeakMap();
+function thrownMessage(err) {
+  if (err instanceof Error && err.message.length > 0) {
+    return err.message;
+  }
+  if (typeof err === "string" && err.length > 0) {
+    return err;
+  }
+  return "Nopilot request failed.";
+}
+
+// src/commands.ts
+var import_obsidian3 = require("obsidian");
+function registerNopilotCommands(plugin, actions) {
+  add(plugin, "open-chat", "Open chat", actions.openChat);
+  add(plugin, "new-chat", "New chat", actions.newChat);
+  add(plugin, "save-chat", "Save chat", actions.saveChat);
+  add(plugin, "add-active-note", "Add active note", actions.addActiveNote);
+  add(plugin, "add-selection", "Add selection", actions.addSelection);
+  add(plugin, "summarize-selection", "Summarize selection", actions.summarizeSelection);
+  add(plugin, "count-selection", "Count selection", actions.countSelection);
+  add(plugin, "run-agent", "Run agent", actions.runAgent);
+  add(plugin, "storage-check", "Storage check", actions.checkStorage);
+  add(plugin, "open-island-tree", "Open Island tree", actions.openIslandTree);
+  add(plugin, "open-island-tree-sidebar", "Open Island tree in sidebar", actions.openIslandTreeSidebar);
+  add(plugin, "translate-theme", "Translate current theme settings", actions.translateTheme);
+  add(plugin, "translate-all-themes", "Translate all theme settings", actions.translateAllThemes);
+}
+function add(plugin, id, name, action) {
+  plugin.addCommand({
+    id,
+    name,
+    callback: () => {
+      void action().catch((error) => {
+        const message = error instanceof Error && error.message.length > 0 ? error.message : "Nopilot command failed.";
+        new import_obsidian3.Notice(message);
+      });
+    }
+  });
+}
+
+// src/conversations.ts
+function headingFor(role) {
+  switch (role) {
+    case "user":
+      return "## You";
+    case "assistant":
+      return "## Nopilot";
+    case "system":
+      return "## System";
+    default: {
+      const unreachable = role;
+      return unreachable;
+    }
+  }
+}
+function errorMessage(err) {
+  if (err instanceof Error) {
+    return err.message;
+  }
+  if (typeof err === "string") {
+    return err;
+  }
+  if (typeof err === "object" && err !== null && "message" in err) {
+    const message = err.message;
+    if (typeof message === "string") {
+      return message;
+    }
+  }
+  return "";
+}
+function alreadyExists(err) {
+  return errorMessage(err).toLowerCase().includes("already exists");
+}
+function normalizeFolder(folder) {
+  const normalized = folder.replace(/\\/g, "/").replace(/\/{2,}/g, "/").replace(/^\/+|\/+$/g, "");
+  if (normalized.length === 0 || /^[a-zA-Z]:/.test(normalized)) {
+    throw new Error("Folder must be a relative vault path.");
+  }
+  const parts = normalized.split("/");
+  if (parts.some((part) => part.length === 0 || part === "." || part === "..")) {
+    throw new Error("Folder must be a relative vault path.");
+  }
+  return normalized;
+}
+async function ensureFolder(app, folderPath) {
+  const parts = folderPath.split("/");
+  let current = "";
+  for (const part of parts) {
+    current = current.length > 0 ? `${current}/${part}` : part;
+    try {
+      await app.vault.createFolder(current);
+    } catch (err) {
+      if (!alreadyExists(err)) {
+        throw err;
+      }
+    }
+  }
+}
+function localStamp(now) {
+  const pad = (value, width = 2) => value.toString().padStart(width, "0");
+  return `${pad(now.getFullYear(), 4)}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+}
+function conversationMarkdown(messages) {
+  const saved = (/* @__PURE__ */ new Date()).toISOString();
+  const header = `---
+type: nopilot-conversation
+saved: ${saved}
+---`;
+  if (messages.length === 0) {
+    return `${header}
+`;
+  }
+  const body = messages.map((message) => `${headingFor(message.role)}
+
+${message.content}`).join("\n\n");
+  return `${header}
+
+${body}
+`;
+}
+async function saveConversation(app, folder, messages) {
+  if (messages.length === 0) {
+    throw new Error("Nothing to save.");
+  }
+  const folderPath = normalizeFolder(folder);
+  await ensureFolder(app, folderPath);
+  const markdown = conversationMarkdown(messages);
+  const base = `${folderPath}/`;
+  const stamp = localStamp(/* @__PURE__ */ new Date());
+  for (let attempt = 0; attempt < 20; attempt += 1) {
+    const suffix = attempt === 0 ? "" : `-${attempt + 1}`;
+    const path2 = `${base}Nopilot-${stamp}${suffix}.md`;
+    try {
+      await app.vault.create(path2, markdown);
+      return path2;
+    } catch (err) {
+      if (!alreadyExists(err) || attempt === 19) {
+        throw err;
+      }
+    }
+  }
+  throw new Error("Could not save chat.");
+}
+
+// src/providers.ts
+var import_obsidian4 = require("obsidian");
+var SLICE_LIMIT = 180;
+var ANTHROPIC_VERSION = "2023-06-01";
+var ANTHROPIC_MAX_TOKENS = 4096;
+async function completeChat(request) {
+  const { settings } = request;
+  const apiKey = settings.apiKey.trim();
+  if (apiKey.length === 0) {
+    throw new Error("Nopilot needs an API key. Add one in settings.");
+  }
+  const model = settings.model.trim();
+  if (model.length === 0) {
+    throw new Error("Nopilot needs a model name.");
+  }
+  const messages = toOutbound(request.messages);
+  if (messages.length === 0) {
+    throw new Error("Nopilot has nothing to send.");
+  }
+  if (settings.provider === "openai-compatible") {
+    return completeOpenAI(settings, apiKey, model, messages);
+  }
+  if (settings.provider === "anthropic") {
+    return completeAnthropic(settings, apiKey, model, messages);
+  }
+  return unsupportedProvider(settings.provider);
+}
+function toOutbound(messages) {
+  const outbound = [];
+  for (const message of messages) {
+    if (message.content.trim().length === 0) continue;
+    outbound.push({ role: message.role, content: message.content });
+  }
+  return outbound;
+}
+function providerUrl(provider, baseUrl) {
+  const base = httpBase(baseUrl);
+  if (provider === "anthropic") return anthropicEndpoint(base);
+  return openaiEndpoint(base);
+}
+function httpBase(baseUrl) {
+  const base = baseUrl.trim();
+  if (/\s/.test(base) || !/^https?:\/\//i.test(base)) {
+    throw new Error("Provider URL must be an http(s) address.");
+  }
+  return base.replace(/\/+$/, "");
+}
+function openaiEndpoint(base) {
+  if (base.endsWith("/chat/completions")) return base;
+  return `${base}/chat/completions`;
+}
+function anthropicEndpoint(base) {
+  if (base.endsWith("/v1/messages") || base.endsWith("/messages")) return base;
+  if (base.endsWith("/v1")) return `${base}/messages`;
+  return `${base}/v1/messages`;
+}
+async function completeOpenAI(settings, apiKey, model, messages) {
+  const result = await postJson(
+    providerUrl("openai-compatible", settings.baseUrl),
+    {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    {
+      model,
+      messages,
+      temperature: settings.temperature,
+      stream: false
+    },
+    apiKey
+  );
+  const text = openAIText(parseJson(result.text, result.status, apiKey));
+  if (text === void 0) {
+    throw missingCompletion(result.status, result.text, apiKey);
+  }
+  return { text, model: settings.model, provider: settings.provider };
+}
+async function completeAnthropic(settings, apiKey, model, messages) {
+  const anthropic = toAnthropic(messages);
+  if (anthropic.messages.length === 0) {
+    throw new Error("Nopilot has nothing to send.");
+  }
+  const result = await postJson(
+    providerUrl("anthropic", settings.baseUrl),
+    {
+      "x-api-key": apiKey,
+      "anthropic-version": ANTHROPIC_VERSION,
+      "content-type": "application/json"
+    },
+    anthropicBody(settings.model, anthropic),
+    apiKey
+  );
+  const text = anthropicText(parseJson(result.text, result.status, apiKey));
+  if (text === void 0) {
+    throw missingCompletion(result.status, result.text, apiKey);
+  }
+  return { text, model: settings.model, provider: settings.provider };
+}
+function anthropicBody(model, anthropic) {
+  const body = {
+    model,
+    max_tokens: ANTHROPIC_MAX_TOKENS,
+    messages: anthropic.messages
+  };
+  if (anthropic.system.length > 0) {
+    body.system = anthropic.system;
+  }
+  return body;
+}
+function toAnthropic(messages) {
+  const systemParts = [];
+  const rawTurns = [];
+  for (const message of messages) {
+    if (message.role === "system") {
+      systemParts.push(message.content);
+      continue;
+    }
+    rawTurns.push({ role: message.role, content: message.content });
+  }
+  const turns = mergeTurns(rawTurns);
+  const first = turns[0];
+  if (first !== void 0 && first.role === "assistant") {
+    turns.unshift({ role: "user", content: "Continue." });
+  }
+  const system = systemParts.join("\n\n").trim();
+  return { system, messages: turns };
+}
+function mergeTurns(turns) {
+  const merged = [];
+  for (const turn of turns) {
+    const last = merged[merged.length - 1];
+    if (last && last.role === turn.role) {
+      last.content = `${last.content}
+
+${turn.content}`;
+      continue;
+    }
+    merged.push({ role: turn.role, content: turn.content });
+  }
+  return merged;
+}
+async function postJson(url, headers, body, apiKey) {
+  try {
+    const response = await (0, import_obsidian4.requestUrl)({
+      url,
+      method: "POST",
+      contentType: "application/json",
+      headers,
+      body: JSON.stringify(body)
+    });
+    const text = typeof response.text === "string" ? response.text : "";
+    const status = response.status;
+    if (status < 200 || status >= 300) {
+      throw new Error(
+        `Nopilot request failed (${status}): ${clip(text, apiKey)}`
+      );
+    }
+    return { status, text };
+  } catch (error) {
+    if (isNopilotError(error)) throw error;
+    throw wrapRequestError(error, apiKey);
+  }
+}
+function openAIText(payload) {
+  if (!isRecord2(payload)) return void 0;
+  if (!isUnknownArray(payload.choices)) return void 0;
+  const first = payload.choices[0];
+  if (!isRecord2(first)) return void 0;
+  const message = first.message;
+  if (!isRecord2(message)) return void 0;
+  if (typeof message.content === "string") return message.content;
+  if (!Array.isArray(message.content)) return void 0;
+  const parts = [];
+  for (const block of message.content) {
+    if (typeof block === "string") {
+      parts.push(block);
+      continue;
+    }
+    if (!isRecord2(block) || typeof block.text !== "string") continue;
+    parts.push(block.text);
+  }
+  return parts.length > 0 ? parts.join("") : void 0;
+}
+function anthropicText(payload) {
+  if (!isRecord2(payload)) return void 0;
+  if (!isUnknownArray(payload.content)) return void 0;
+  const parts = [];
+  for (const block of payload.content) {
+    if (!isRecord2(block)) continue;
+    if (block.type !== "text") continue;
+    if (typeof block.text !== "string") continue;
+    parts.push(block.text);
+  }
+  if (parts.length === 0) return void 0;
+  return parts.join("");
+}
+function parseJson(text, status, apiKey) {
+  try {
+    const parsed = JSON.parse(text);
+    return parsed;
+  } catch {
+    throw missingCompletion(status, text, apiKey);
+  }
+}
+function missingCompletion(status, body, apiKey) {
+  return new Error(
+    `Nopilot completion missing (${status}): ${clip(body, apiKey)}`
+  );
+}
+function wrapRequestError(error, apiKey) {
+  const status = readStatus(error);
+  const label = status || "network";
+  return new Error(
+    `Nopilot request failed (${label}): ${clip(readThrownMessage(error), apiKey)}`
+  );
+}
+function readStatus(error) {
+  if (isRecord2(error)) {
+    const status = error.status;
+    if (typeof status === "number" && Number.isFinite(status) && status > 0) {
+      return status;
+    }
+  }
+  const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+  const match = /status (\d{3})\b/.exec(message);
+  if (match === null) return void 0;
+  return Number(match[1]);
+}
+function readThrownMessage(error) {
+  if (isRecord2(error) && typeof error.text === "string" && error.text.trim().length > 0) {
+    return error.text;
+  }
+  if (error instanceof Error && error.message.trim().length > 0) {
+    return error.message;
+  }
+  if (typeof error === "string" && error.trim().length > 0) return error;
+  if (isRecord2(error) && typeof error.message === "string" && error.message.trim().length > 0) {
+    return error.message;
+  }
+  return "request failed";
+}
+function clip(text, apiKey) {
+  const redacted = redact(text, apiKey).replace(/\s+/g, " ").trim();
+  return redacted.length <= SLICE_LIMIT ? redacted : redacted.slice(0, SLICE_LIMIT);
+}
+function redact(text, apiKey) {
+  if (apiKey.length === 0) return text;
+  return text.split(apiKey).join("[redacted]");
+}
+function isNopilotError(error) {
+  return error instanceof Error && error.message.startsWith("Nopilot ");
+}
+function unsupportedProvider(provider) {
+  throw new Error(`Nopilot does not support provider: ${String(provider)}`);
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isUnknownArray(value) {
+  return Array.isArray(value);
+}
+
+// src/settings.ts
+var STRING_KEYS = [
+  "baseUrl",
+  "apiKey",
+  "model",
+  "systemPrompt",
+  "conversationsFolder",
+  "promptsFolder",
+  "skillsFolder",
+  "memoryFolder",
+  "agentCommand",
+  "hermesCommand",
+  "opencodeCommand",
+  "piCommand"
+];
+var NUMBER_KEYS = ["contextTurns", "temperature", "maxSubagents"];
+var BOOLEAN_KEYS = [
+  "includeActiveNote",
+  "includeSelection",
+  "agentEnabled",
+  "subagentEnabled",
+  "includeDirectory"
+];
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  if (Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isProviderKind(value) {
+  return value === "openai-compatible" || value === "anthropic";
+}
+function isBackendId(value) {
+  return value === "byok" || value === "hermes" || value === "opencode" || value === "pi";
+}
+function isCliBackendId(value) {
+  return value === "hermes" || value === "opencode" || value === "pi";
+}
+function readModules(value, base) {
+  const next = { ...base };
+  if (!isPlainObject(value)) return next;
+  const keys = ["byok", "hermes", "opencode", "pi"];
+  for (const key of keys) {
+    if (hasOwn(value, key) && typeof value[key] === "boolean") next[key] = value[key];
+  }
+  return next;
+}
+function hasOwn(record, key) {
+  return Object.prototype.hasOwnProperty.call(record, key);
+}
+function overlayKnown(next, raw) {
+  if (hasOwn(raw, "provider") && isProviderKind(raw.provider)) {
+    next.provider = raw.provider;
+  }
+  if (hasOwn(raw, "backend") && isBackendId(raw.backend)) {
+    next.backend = raw.backend;
+  }
+  if (hasOwn(raw, "subagentBackend") && isCliBackendId(raw.subagentBackend)) {
+    next.subagentBackend = raw.subagentBackend;
+  }
+  if (hasOwn(raw, "modules")) {
+    next.modules = readModules(raw.modules, next.modules);
+  }
+  for (const key of STRING_KEYS) {
+    if (!hasOwn(raw, key)) continue;
+    const value = raw[key];
+    if (typeof value === "string") next[key] = value;
+  }
+  for (const key of NUMBER_KEYS) {
+    if (!hasOwn(raw, key)) continue;
+    const value = raw[key];
+    if (typeof value === "number" && Number.isFinite(value)) next[key] = value;
+  }
+  for (const key of BOOLEAN_KEYS) {
+    if (!hasOwn(raw, key)) continue;
+    const value = raw[key];
+    if (typeof value === "boolean") next[key] = value;
+  }
+}
+function mergeSettings(base, raw) {
+  const next = { ...base };
+  try {
+    if (!isPlainObject(raw)) return next;
+    overlayKnown(next, raw);
+    if (next.contextTurns < 1) next.contextTurns = 1;
+    if (next.contextTurns > 50) next.contextTurns = 50;
+    if (next.temperature < 0) next.temperature = 0;
+    if (next.temperature > 2) next.temperature = 2;
+    if (next.maxSubagents < 1) next.maxSubagents = 1;
+    if (next.maxSubagents > 3) next.maxSubagents = 3;
+    if (!next.modules[next.backend]) {
+      const fallback = ["byok", "hermes", "opencode", "pi"].find((id) => next.modules[id]);
+      if (fallback) next.backend = fallback;
+    }
+    if (!next.modules[next.subagentBackend]) next.subagentBackend = "pi";
+    return next;
+  } catch {
+    return { ...base };
+  }
+}
+
+// src/settings-tab.ts
+var import_obsidian5 = require("obsidian");
+
+// src/desk/plan.ts
+var UNLOADED = "No activation plan loaded.";
+function unloaded() {
+  return { loaded: false, summary: UNLOADED };
+}
+function planSummary(json) {
+  try {
+    if (json === null || typeof json !== "object") return unloaded();
+    const record = json;
+    const target = record.target;
+    if (target !== "lux-assistant" && target !== "nopilot") return unloaded();
+    if (!Array.isArray(record.bindings)) return unloaded();
+    return {
+      loaded: true,
+      summary: `Target ${target} \xB7 ${record.bindings.length} module(s)`
+    };
+  } catch {
+    return unloaded();
+  }
+}
+
+// src/desk/translate.ts
+var SETTINGS_BLOCK = /\/\*\s*@settings[\s\S]*?\*\//g;
+var PHRASE_LIST = [
+  ["\u6BDB\u73BB\u7483", "Frosted glass"],
+  ["\u5F3A\u8C03\u8272", "Accent color"],
+  ["\u4E3B\u9898\u989C\u8272", "Theme color"],
+  ["\u80CC\u666F\u989C\u8272", "Background color"],
+  ["\u524D\u666F\u989C\u8272", "Foreground color"],
+  ["\u4E3B\u8272", "Primary color"],
+  ["\u8F85\u8272", "Secondary color"],
+  ["\u5B57\u4F53\u5927\u5C0F", "Font size"],
+  ["\u5B57\u53F7", "Font size"],
+  ["\u5B57\u4F53", "Font"],
+  ["\u884C\u9AD8", "Line height"],
+  ["\u884C\u8DDD", "Line spacing"],
+  ["\u5706\u89D2", "Corner radius"],
+  ["\u8FB9\u6846", "Border"],
+  ["\u9634\u5F71", "Shadow"],
+  ["\u900F\u660E\u5EA6", "Opacity"],
+  ["\u6A21\u7CCA", "Blur"],
+  ["\u95F4\u8DDD", "Spacing"],
+  ["\u5BBD\u5EA6", "Width"],
+  ["\u9AD8\u5EA6", "Height"],
+  ["\u6807\u9898\u680F", "Title bar"],
+  ["\u72B6\u6001\u680F", "Status bar"],
+  ["\u529F\u80FD\u533A", "Ribbon"],
+  ["\u4FA7\u8FB9\u680F", "Sidebar"],
+  ["\u6587\u4EF6\u5217\u8868", "File list"],
+  ["\u7F16\u8F91\u5668", "Editor"],
+  ["\u6807\u9898", "Heading"],
+  ["\u6B63\u6587", "Body text"],
+  ["\u80CC\u666F", "Background"],
+  ["\u524D\u666F", "Foreground"],
+  ["\u989C\u8272", "Color"],
+  ["\u8272\u5F69", "Color"],
+  ["\u754C\u9762", "Interface"],
+  ["\u56FE\u8C31", "Graph"],
+  ["\u6807\u7B7E\u9875", "Tab"],
+  ["\u6807\u7B7E", "Tag"],
+  ["\u94FE\u63A5", "Link"],
+  ["\u5F15\u7528\u5757", "Callout"],
+  ["\u5F15\u7528", "Quote"],
+  ["\u4EE3\u7801\u5757", "Code block"],
+  ["\u4EE3\u7801", "Code"],
+  ["\u8868\u683C", "Table"],
+  ["\u56FE\u7247", "Image"],
+  ["\u52A8\u753B", "Animation"],
+  ["\u73BB\u7483", "Glass"],
+  ["\u9884\u8BBE", "Preset"],
+  ["\u81EA\u5B9A\u4E49", "Custom"],
+  ["\u9ED8\u8BA4", "Default"],
+  ["\u5F53\u524D", "Current"],
+  ["\u5168\u90E8", "All"],
+  ["\u8BBE\u7F6E", "Settings"],
+  ["\u9009\u9879", "Option"],
+  ["\u542F\u7528", "Enable"],
+  ["\u7981\u7528", "Disable"],
+  ["\u6697\u8272", "Dark"],
+  ["\u4EAE\u8272", "Light"],
+  ["\u6DF1\u8272", "Dark"],
+  ["\u6D45\u8272", "Light"],
+  ["\u6210\u529F", "Success"],
+  ["\u8B66\u544A", "Warning"],
+  ["\u9519\u8BEF", "Error"],
+  ["\u4FE1\u606F", "Info"],
+  ["\u641C\u7D22", "Search"],
+  ["\u56FE\u6807", "Icon"],
+  ["\u5BF9\u9F50", "Alignment"],
+  ["\u5C45\u4E2D", "Center"],
+  ["\u7C97\u4F53", "Bold"],
+  ["\u659C\u4F53", "Italic"],
+  ["\u4E0B\u5212\u7EBF", "Underline"],
+  ["\u9875\u7B7E", "Tab"],
+  ["\u7B14\u8BB0", "Note"],
+  ["\u6587\u4EF6\u5939", "Folder"],
+  ["\u57FA\u7840", "Baseline"],
+  ["\u4F5C\u66F2", "Composer"],
+  ["\u53D1\u5149", "Glow"],
+  ["\u7EB8\u611F", "Paper"],
+  ["\u4F59\u70EC", "Ember"],
+  ["\u5149\u6655", "Lumin"],
+  ["\u86CB\u767D\u77F3", "Opal"],
+  ["\u5B66\u8005", "Scholar"],
+  ["\u65E0", "None"],
+  ["\u5F00", "On"],
+  ["\u5173", "Off"],
+  ["\u5DE6", "Left"],
+  ["\u53F3", "Right"],
+  ["\u4E0A", "Top"],
+  ["\u4E0B", "Bottom"],
+  ["\u548C", "and"],
+  ["\u4E0E", "and"],
+  ["\u6216", "or"],
+  ["\u7684", ""],
+  ["\u4E3A", "for"],
+  ["\u5728", "in"]
+];
+var PHRASES = [...PHRASE_LIST].sort((a, b) => b[0].length - a[0].length);
+function translateFragment(text) {
+  let next = text;
+  for (const [from, to] of PHRASES) {
+    if (next.includes(from)) next = next.split(from).join(to);
+  }
+  return next;
+}
+function translateSettingsCss(css) {
+  if (typeof css !== "string" || !css.includes("@settings")) {
+    return { text: typeof css === "string" ? css : "", changed: false };
+  }
+  let changed = false;
+  const text = css.replace(SETTINGS_BLOCK, (block) => {
+    const next = translateFragment(block);
+    if (next !== block) changed = true;
+    return next;
+  });
+  if (!changed) return { text: css, changed: false };
+  return { text, changed: true };
+}
+
+// src/desk/vault.ts
+var PLAN_PATHS = [
+  ".obsidian/plugins/nopilot/.kirby/active/nopilot-plan.json",
+  ".obsidian/plugins/lux-assistant/.kirby/active/lux-assistant-plan.json"
+];
+async function loadPlanSummary(files) {
+  for (const planPath of PLAN_PATHS) {
+    try {
+      if (!await files.exists(planPath)) continue;
+      const summary = planSummary(JSON.parse(await files.read(planPath)));
+      if (summary.loaded) return summary.summary;
+    } catch {
+      continue;
+    }
+  }
+  return "No activation plan loaded.";
+}
+async function translateNamedTheme(files, themeName) {
+  const themePath = `.obsidian/themes/${themeName}/theme.css`;
+  if (!await files.exists(themePath)) {
+    return { theme: themeName, missing: true, changed: false };
+  }
+  const original = await files.read(themePath);
+  const translated = translateSettingsCss(original);
+  if (translated.changed) await files.write(themePath, translated.text);
+  return { theme: themeName, missing: false, changed: translated.changed };
+}
+async function translateCurrentTheme(files) {
+  let theme = "";
+  try {
+    const appearance = JSON.parse(await files.read(".obsidian/appearance.json"));
+    theme = typeof appearance.cssTheme === "string" ? appearance.cssTheme : "";
+  } catch {
+    theme = "";
+  }
+  if (!theme) return { theme: "", missing: true, changed: false };
+  return translateNamedTheme(files, theme);
+}
+async function translateEveryTheme(files) {
+  let names = [];
+  try {
+    const listed = await files.list(".obsidian/themes");
+    names = (listed.folders ?? []).map((folder) => folder.split("/").filter(Boolean).pop() ?? "").filter((name) => name.length > 0).sort();
+  } catch {
+    names = [];
+  }
+  const results = [];
+  for (const name of names) results.push(await translateNamedTheme(files, name));
+  return results;
+}
+function themeNotice(result) {
+  if (result.missing) {
+    return result.theme.length > 0 ? `No theme.css found for ${result.theme}.` : "No active theme to translate.";
+  }
+  if (!result.changed) return `${result.theme}: @settings block already translated.`;
+  return `${result.theme}: translated CJK phrases in @settings.`;
+}
+
+// src/settings-tab.ts
+var KEY_WARNING = "Your API key is stored in this vault's plugin data (data.json), not in the OS keychain. Do not sync that file if the vault is shared.";
+var AGENT_WARNING = "CLI backends run only in the desktop app. The executable is one path, shell is off, and the vault packet is a file, not a shell string.";
+function parseTemperature(value) {
+  const trimmed = value.trim();
+  if (trimmed === "") return null;
+  const parsed = Number(trimmed);
+  if (!Number.isFinite(parsed) || parsed < 0 || parsed > 2) return null;
+  return parsed;
+}
+function parseContextTurns(value) {
+  const trimmed = value.trim();
+  if (trimmed === "") return null;
+  const parsed = Number(trimmed);
+  if (!Number.isFinite(parsed) || !Number.isInteger(parsed) || parsed < 1 || parsed > 50) return null;
+  return parsed;
+}
+function parsePasses(value) {
+  const trimmed = value.trim();
+  if (trimmed === "") return null;
+  const parsed = Number(trimmed);
+  if (!Number.isFinite(parsed) || !Number.isInteger(parsed) || parsed < 1 || parsed > 3) return null;
+  return parsed;
+}
+var NopilotSettingTab = class extends import_obsidian5.PluginSettingTab {
+  constructor(app, plugin, get, set) {
+    super(app, plugin);
+    this.get = get;
+    this.set = set;
+  }
+  display() {
+    const { containerEl } = this;
+    containerEl.empty();
+    containerEl.addClass("nopilot-settings");
+    const settings = this.get();
+    new import_obsidian5.Setting(containerEl).setName("Nopilot").setHeading();
+    containerEl.createDiv({ cls: "nopilot-key-warning", text: KEY_WARNING });
+    this.backendSection(settings);
+    this.moduleSection(settings);
+    if (settings.modules.byok) this.byokSection(settings);
+    this.workflowSection(settings);
+    this.vaultSection(settings);
+    this.folderSection(settings);
+    this.legacyAgentSection(settings);
+    this.deskSection();
+  }
+  backendSection(settings) {
+    new import_obsidian5.Setting(this.containerEl).setName("Backend").setDesc("Chat sends to this module. CLI backends ignore the HTTP key and run the local agent.").addDropdown((dropdown) => {
+      this.addEnabledBackends(dropdown, settings);
+      dropdown.setValue(settings.backend);
+      dropdown.onChange(async (value) => {
+        if (!this.isEnabledBackend(value, settings)) return;
+        await this.commit("backend", value, true);
+      });
+    });
+  }
+  moduleSection(settings) {
+    const wrap = this.containerEl.createDiv({ cls: "nopilot-module" });
+    new import_obsidian5.Setting(wrap).setName("Modules").setDesc("Turn a module off to remove it from the backend list.").setHeading();
+    this.moduleToggle(wrap, settings, "byok", "Bring your own key", "HTTP module. OpenAI-compatible or Anthropic.");
+    this.moduleToggle(wrap, settings, "hermes", "Hermes", "Quiet oneshot. Does not rewrite your Hermes theme files.");
+    this.moduleToggle(wrap, settings, "opencode", "OpenCode", "opencode run with the vault packet attached.");
+    this.moduleToggle(wrap, settings, "pi", "Pi", "pi --print. No interactive TUI.");
+    if (settings.modules.hermes) this.commandField(wrap, "Hermes command", "hermesCommand", settings.hermesCommand);
+    if (settings.modules.opencode) this.commandField(wrap, "OpenCode command", "opencodeCommand", settings.opencodeCommand);
+    if (settings.modules.pi) this.commandField(wrap, "Pi command", "piCommand", settings.piCommand);
+  }
+  byokSection(settings) {
+    const wrap = this.containerEl.createDiv({ cls: "nopilot-module" });
+    new import_obsidian5.Setting(wrap).setName("Bring your own key").setHeading();
+    new import_obsidian5.Setting(wrap).setName("Provider").addDropdown((dropdown) => {
+      dropdown.addOption("openai-compatible", "OpenAI-compatible");
+      dropdown.addOption("anthropic", "Anthropic");
+      dropdown.setValue(settings.provider);
+      dropdown.onChange(async (value) => {
+        if (value !== "openai-compatible" && value !== "anthropic") return;
+        await this.commit("provider", value);
+      });
+    });
+    this.textField(wrap, "Base URL", "baseUrl", settings.baseUrl);
+    new import_obsidian5.Setting(wrap).setName("API key").addText((text) => {
+      text.inputEl.type = "password";
+      text.inputEl.autocomplete = "off";
+      text.inputEl.spellcheck = false;
+      text.setPlaceholder("Paste key");
+      text.setValue(settings.apiKey);
+      text.onChange(async (value) => {
+        await this.commit("apiKey", value);
+      });
+    });
+    this.textField(wrap, "Model", "model", settings.model);
+    new import_obsidian5.Setting(wrap).setName("Temperature").setDesc("0 to 2. Invalid values are ignored. Anthropic requests omit this.").addText((text) => {
+      text.inputEl.inputMode = "decimal";
+      text.setPlaceholder("0.7");
+      text.setValue(String(settings.temperature));
+      text.onChange(async (value) => {
+        const parsed = parseTemperature(value);
+        if (parsed === null) return;
+        await this.commit("temperature", parsed);
+      });
+    });
+    new import_obsidian5.Setting(wrap).setName("System prompt").addTextArea((text) => {
+      text.setValue(settings.systemPrompt);
+      text.onChange(async (value) => {
+        await this.commit("systemPrompt", value);
+      });
+    });
+  }
+  workflowSection(settings) {
+    const wrap = this.containerEl.createDiv({ cls: "nopilot-module" });
+    new import_obsidian5.Setting(wrap).setName("Agent workflow").setDesc("A subagent is another CLI pass over the same vault packet plus the prior answer.").setHeading();
+    new import_obsidian5.Setting(wrap).setName("Subagents").addToggle((toggle) => {
+      toggle.setValue(settings.subagentEnabled);
+      toggle.onChange(async (value) => {
+        await this.commit("subagentEnabled", value, true);
+      });
+    });
+    if (!settings.subagentEnabled) return;
+    new import_obsidian5.Setting(wrap).setName("Subagent backend").addDropdown((dropdown) => {
+      this.addCliOptions(dropdown, settings);
+      dropdown.setValue(settings.subagentBackend);
+      dropdown.onChange(async (value) => {
+        if (value !== "hermes" && value !== "opencode" && value !== "pi") return;
+        await this.commit("subagentBackend", value);
+      });
+    });
+    new import_obsidian5.Setting(wrap).setName("Subagent passes").setDesc("1 to 3. Each pass has a different job: missing facts, unsupported claims, then a final cut.").addText((text) => {
+      text.inputEl.type = "number";
+      text.inputEl.min = "1";
+      text.inputEl.max = "3";
+      text.setValue(String(settings.maxSubagents));
+      text.onChange(async (value) => {
+        const parsed = parsePasses(value);
+        if (parsed === null) return;
+        await this.commit("maxSubagents", parsed);
+      });
+    });
+  }
+  vaultSection(settings) {
+    const wrap = this.containerEl.createDiv({ cls: "nopilot-module" });
+    new import_obsidian5.Setting(wrap).setName("Vault context").setHeading();
+    this.toggleField(wrap, "Include active note", "includeActiveNote", settings.includeActiveNote);
+    this.toggleField(wrap, "Include selection", "includeSelection", settings.includeSelection);
+    this.toggleField(wrap, "Include directory list", "includeDirectory", settings.includeDirectory);
+    new import_obsidian5.Setting(wrap).setName("Context turns").setDesc("How many recent chat turns go into the packet. 1 to 50.").addText((text) => {
+      text.inputEl.type = "number";
+      text.inputEl.min = "1";
+      text.inputEl.max = "50";
+      text.setValue(String(settings.contextTurns));
+      text.onChange(async (value) => {
+        const parsed = parseContextTurns(value);
+        if (parsed === null) return;
+        await this.commit("contextTurns", parsed);
+      });
+    });
+  }
+  folderSection(settings) {
+    const wrap = this.containerEl.createDiv({ cls: "nopilot-module" });
+    new import_obsidian5.Setting(wrap).setName("Vault folders").setDesc("Relative paths only. Drive letters and .. are rejected.").setHeading();
+    this.folderField(wrap, "Conversations folder", "conversationsFolder", settings.conversationsFolder);
+    this.folderField(wrap, "Prompts folder", "promptsFolder", settings.promptsFolder);
+    this.folderField(wrap, "Skills folder", "skillsFolder", settings.skillsFolder);
+    this.folderField(wrap, "Memory folder", "memoryFolder", settings.memoryFolder);
+  }
+  deskSection() {
+    const wrap = this.containerEl.createDiv({ cls: "nopilot-module" });
+    new import_obsidian5.Setting(wrap).setName("Vault desk").setHeading();
+    const status = wrap.createDiv({ text: "Reading plan\u2026" });
+    const files = this.app.vault.adapter;
+    void loadPlanSummary(files).then((summary) => {
+      status.setText(summary);
+    });
+    this.deskButton(wrap, "Storage check", "nopilot:storage-check");
+    this.deskButton(wrap, "Open Island tree", "nopilot:open-island-tree");
+    this.deskButton(wrap, "Translate current theme", "nopilot:translate-theme");
+  }
+  deskButton(parent, name, commandId) {
+    new import_obsidian5.Setting(parent).setName(name).addButton((button) => {
+      button.setButtonText("Run").onClick(() => {
+        const commands = this.app.commands;
+        commands?.executeCommandById?.(commandId);
+      });
+    });
+  }
+  legacyAgentSection(settings) {
+    const wrap = this.containerEl.createDiv({ cls: "nopilot-module" });
+    wrap.createDiv({ cls: "nopilot-agent-warning", text: AGENT_WARNING });
+    new import_obsidian5.Setting(wrap).setName("Palette agent").setDesc("The Run agent command. Chat already follows the backend above.").addToggle((toggle) => {
+      toggle.setValue(settings.agentEnabled);
+      toggle.onChange(async (value) => {
+        await this.commit("agentEnabled", value, true);
+      });
+    });
+    if (!settings.agentEnabled) return;
+    this.commandField(wrap, "Fallback command", "agentCommand", settings.agentCommand);
+  }
+  moduleToggle(parent, settings, key, name, desc) {
+    new import_obsidian5.Setting(parent).setName(name).setDesc(desc).addToggle((toggle) => {
+      toggle.setValue(settings.modules[key]);
+      toggle.onChange(async (value) => {
+        const modules = { ...this.get().modules, [key]: value };
+        await this.commit("modules", modules, true);
+      });
+    });
+  }
+  commandField(parent, name, key, value) {
+    new import_obsidian5.Setting(parent).setName(name).setDesc("Executable name or absolute path. No shell syntax.").addText((text) => {
+      text.setValue(value);
+      text.onChange(async (next) => {
+        await this.commit(key, next);
+      });
+    });
+  }
+  textField(parent, name, key, value) {
+    new import_obsidian5.Setting(parent).setName(name).addText((text) => {
+      text.setValue(value);
+      text.onChange(async (next) => {
+        await this.commit(key, next);
+      });
+    });
+  }
+  toggleField(parent, name, key, value) {
+    new import_obsidian5.Setting(parent).setName(name).addToggle((toggle) => {
+      toggle.setValue(value);
+      toggle.onChange(async (next) => {
+        await this.commit(key, next);
+      });
+    });
+  }
+  folderField(parent, name, key, value) {
+    new import_obsidian5.Setting(parent).setName(name).addText((text) => {
+      text.setValue(value);
+      text.onChange(async (next) => {
+        await this.commit(key, next);
+      });
+    });
+  }
+  addEnabledBackends(dropdown, settings) {
+    if (settings.modules.byok) dropdown.addOption("byok", "Bring your own key");
+    if (settings.modules.hermes) dropdown.addOption("hermes", "Hermes");
+    if (settings.modules.opencode) dropdown.addOption("opencode", "OpenCode");
+    if (settings.modules.pi) dropdown.addOption("pi", "Pi");
+  }
+  addCliOptions(dropdown, settings) {
+    if (settings.modules.hermes) dropdown.addOption("hermes", "Hermes");
+    if (settings.modules.opencode) dropdown.addOption("opencode", "OpenCode");
+    if (settings.modules.pi) dropdown.addOption("pi", "Pi");
+  }
+  isEnabledBackend(value, settings) {
+    if (value === "byok") return settings.modules.byok;
+    if (value === "hermes" || value === "opencode" || value === "pi") return settings.modules[value];
+    return false;
+  }
+  async commit(key, value, redraw = false) {
+    const next = { ...this.get(), [key]: value };
+    await this.set(next);
+    if (redraw) this.display();
+  }
+};
+
+// src/desk/island.ts
+var ISLAND_OPEN = "island-tree:open";
+var ISLAND_SIDEBAR = "island-tree:open-in-sidebar";
+function islandCommand(where) {
+  return where === "sidebar" ? ISLAND_SIDEBAR : ISLAND_OPEN;
+}
+
+// src/desk/storage.ts
+function storageStatus() {
+  return [
+    {
+      ok: false,
+      dormant: true,
+      adapter: "S3",
+      message: "S3 adapter is dormant."
+    },
+    {
+      ok: false,
+      dormant: true,
+      adapter: "Google Drive",
+      message: "Google Drive adapter is dormant."
+    }
+  ];
+}
+
+// src/desk/trigger.ts
+function isActionName(value) {
+  return value === "storage-check" || value === "open-island-tree" || value === "translate" || value === "translate-all";
+}
+function themeRejected(theme) {
+  return theme.length === 0 || theme.includes("/") || theme.includes("\\") || theme.includes("..");
+}
+function parseTriggerLine(line) {
+  if (typeof line !== "string") return null;
+  const text = line.replace(/^\uFEFF/, "").trim();
+  if (!text) return null;
+  const parts = text.split("|");
+  if (parts.length > 2) return null;
+  const name = parts[0].trim();
+  if (!isActionName(name)) return null;
+  const hasArg = parts.length === 2;
+  const arg = hasArg ? parts[1].trim() : "";
+  if (name === "storage-check" || name === "translate-all") {
+    if (hasArg) return null;
+    return { action: name };
+  }
+  if (name === "open-island-tree") {
+    if (!hasArg) return { action: name, where: "main" };
+    if (arg === "sidebar") return { action: name, where: "sidebar" };
+    return null;
+  }
+  if (!hasArg) return { action: "translate" };
+  if (themeRejected(arg)) return null;
+  return { action: "translate", theme: arg };
+}
+
+// src/modules/backends.ts
+var SHELL_LINE = /[&|<>;$`\n\r"']/;
+function isCliBackend(value) {
+  return value === "hermes" || value === "opencode" || value === "pi";
+}
+function assertExecutable(command) {
+  const trimmed = command.trim();
+  if (trimmed.length === 0) {
+    throw new Error("Backend command is empty.");
+  }
+  if (trimmed.length > 260 || SHELL_LINE.test(trimmed) || trimmed.split(/[\\/]/).includes("..")) {
+    throw new Error("Backend command must be one executable, not a shell line.");
+  }
+  return trimmed;
+}
+function buildSpawn(backend, options) {
+  const command = assertExecutable(options.command);
+  const cwd = options.cwd.trim();
+  const queryFile = options.queryFile.trim();
+  if (cwd.length === 0 || queryFile.length === 0) {
+    throw new Error("Backend needs a directory and a packet file.");
+  }
+  if (backend === "hermes") {
+    const args = ["chat", "--query-file", queryFile, "--oneshot", "-Q", "--format", "text", "--in", cwd];
+    if (options.bare === true) args.push("--ignore-user-config");
+    return { command, args, cwd, stdin: false };
+  }
+  if (backend === "opencode") {
+    return {
+      command,
+      args: ["run", "-f", queryFile, "Follow the attached Nopilot packet and answer the task."],
+      cwd,
+      stdin: false
+    };
+  }
+  return {
+    command,
+    args: ["--print", `Read this Nopilot packet and answer the task. Reply with the answer only: ${queryFile}`],
+    cwd,
+    stdin: false
+  };
+}
+
+// src/modules/packet.ts
+var SUBAGENT_TASKS = [
+  "Check the prior answer against the file list. Add only missing vault facts.",
+  "Remove any claim the packet does not support. Keep the useful remainder.",
+  "Write the final answer the user should keep. Do not repeat the whole trail."
+];
+function subagentTask(pass) {
+  const index = Math.max(0, Math.min(SUBAGENT_TASKS.length - 1, pass));
+  return SUBAGENT_TASKS[index] ?? SUBAGENT_TASKS[0];
+}
+function renderPacket(input) {
+  const files = input.files.slice(0, 80);
+  const lines = [
+    "# Nopilot packet",
+    `role: ${input.role}`,
+    `backend: ${input.backend}`,
+    `vault: ${input.vault}`,
+    `note: ${input.notePath ?? "none"}`,
+    "",
+    "## Note",
+    input.noteBody ?? "(none)",
+    "",
+    "## Selection",
+    input.selection ?? "(none)",
+    "",
+    "## Memory",
+    input.memory ?? "(none)",
+    "",
+    "## Files",
+    files.length > 0 ? files.map((file) => `- ${file}`).join("\n") : "(none)",
+    "",
+    "## Task",
+    input.task.trim()
+  ];
+  if (input.prior && input.prior.trim().length > 0) {
+    lines.push("", "## Prior", input.prior.trim());
+  }
+  return `${lines.join("\n").slice(0, 1e5)}
+`;
+}
+
+// src/shared/executable.ts
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var SHELL_META = /[&|<>;$`"'\u000a\u000d]/;
+var MAX_COMMAND_LENGTH = 260;
+var EXE_LAUNCH = /^"%(?:~dp0|dp0%)[/\\]([^"]+\.exe)"(?:\s+%\*)?\s*$/i;
+var NODE_LAUNCH = /^node\s+"%(?:~dp0|dp0%)([^"]+\.js)"(?:\s+%\*)?\s*$/i;
+function assertExecutable2(command) {
+  const trimmed = command.trim();
+  if (trimmed.length === 0) {
+    throw new Error("Command is empty");
+  }
+  if (trimmed.length > MAX_COMMAND_LENGTH) {
+    throw new Error("Command is too long");
+  }
+  if (SHELL_META.test(trimmed)) {
+    throw new Error("Command contains shell metacharacters");
+  }
+  if (trimmed.split(/[\\/]/).some((segment) => segment === "..")) {
+    throw new Error("Command contains a parent path segment");
+  }
+  return trimmed;
+}
+function resolveInstalled(command, pathEnv = process.env.PATH ?? "") {
+  return resolveFromPath(command, {
+    pathEnv,
+    readFile(filePath) {
+      try {
+        return import_node_fs.default.readFileSync(filePath, "utf8");
+      } catch {
+        return null;
+      }
+    },
+    isFile(filePath) {
+      try {
+        return import_node_fs.default.statSync(filePath).isFile();
+      } catch {
+        return false;
+      }
+    }
+  });
+}
+function resolveFromPath(command, options) {
+  const name = assertExecutable2(command);
+  if (/[\\/]/.test(name)) {
+    return resolveDirect(name, options.isFile, options.readFile);
+  }
+  const dirs = options.pathEnv.split(";").map((entry) => entry.trim().replace(/^"|"$/g, "")).filter((entry) => entry.length > 0);
+  for (const ext of [".exe", ".cmd", ".bat"]) {
+    for (const dir of dirs) {
+      const candidate = import_node_path.default.win32.join(dir, name + ext);
+      if (!options.isFile(candidate)) {
+        continue;
+      }
+      if (ext === ".exe") {
+        return { file: candidate, argsPrefix: [] };
+      }
+      return parseShim(candidate, options.readFile);
+    }
+  }
+  throw new Error("Executable not found: " + name);
+}
+function resolveDirect(file, isFile, readFile) {
+  const lower = file.toLowerCase();
+  if (lower.endsWith(".cmd") || lower.endsWith(".bat") || lower.endsWith(".ps1")) {
+    return parseShim(file, readFile);
+  }
+  if (isFile(file)) {
+    return { file, argsPrefix: [] };
+  }
+  throw new Error("Executable not found: " + file);
+}
+function parseShim(shimPath, readFile) {
+  const baseName = import_node_path.default.win32.basename(shimPath);
+  const text = readFile(shimPath);
+  if (text == null) {
+    throw new Error("Executable not found: " + shimPath);
+  }
+  let launch = null;
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0 || isBoilerplate(trimmed)) {
+      continue;
+    }
+    const parsed = parseLaunchLine(trimmed, shimPath);
+    if (parsed == null || launch != null) {
+      throw new Error("Refusing to run a shell shim: " + baseName);
+    }
+    launch = parsed;
+  }
+  if (launch == null) {
+    throw new Error("Refusing to run a shell shim: " + baseName);
+  }
+  return launch;
+}
+function isBoilerplate(line) {
+  return /^@?echo(\s+off)?$/i.test(line) || /^@?goto\s+[A-Za-z0-9_-]+$/i.test(line) || /^:[A-Za-z0-9_-]+$/.test(line) || /^@?setlocal$/i.test(line) || /^@?endlocal$/i.test(line) || /^@?exit\s+\/b(?:\s+\d+)?$/i.test(line) || /^@?call\s+:[A-Za-z0-9_-]+$/i.test(line) || /^@?set\s+dp0=%~dp0$/i.test(line) || /^@?rem(\s|$)/i.test(line) || line.startsWith("::");
+}
+function parseLaunchLine(line, shimPath) {
+  const exe = EXE_LAUNCH.exec(line);
+  const exeRelative = exe?.[1];
+  if (exeRelative != null) {
+    return { file: siblingPath(shimPath, exeRelative), argsPrefix: [] };
+  }
+  const node = NODE_LAUNCH.exec(line);
+  const jsRelative = node?.[1];
+  if (jsRelative != null) {
+    return { file: "node", argsPrefix: [siblingPath(shimPath, jsRelative)] };
+  }
+  return null;
+}
+function siblingPath(shimPath, relative) {
+  const baseName = import_node_path.default.win32.basename(shimPath);
+  if (/[&|<>;$`"'%\r\n]/.test(relative)) {
+    throw new Error("Refusing to run a shell shim: " + baseName);
+  }
+  const parts = relative.split(/[/\\]+/).filter((part) => part.length > 0);
+  if (parts.length === 0 || parts.some((part) => part === "." || part === ".." || part.includes(":"))) {
+    throw new Error("Refusing to run a shell shim: " + baseName);
+  }
+  const baseDir = import_node_path.default.win32.resolve(import_node_path.default.win32.dirname(shimPath));
+  const resolved = import_node_path.default.win32.resolve(baseDir, ...parts);
+  const rel = import_node_path.default.win32.relative(baseDir, resolved);
+  if (rel.length === 0 || rel.split(/[/\\]+/).includes("..") || import_node_path.default.win32.isAbsolute(rel)) {
+    throw new Error("Refusing to run a shell shim: " + baseName);
+  }
+  return resolved;
+}
+
+// src/main.ts
+var AGENT_OFF = "Agent is off. Enable it in Nopilot settings.";
+var AGENT_DESKTOP_ONLY = "Local agent is desktop-only.";
+var AGENT_FINISHED = "Agent finished.";
+var AGENT_FAILED = "Agent failed.";
+var NO_SELECTION = "No selection.";
+var NO_ACTIVE_NOTE = "No active note.";
+var NOTICE_LIMIT = 240;
+var NopilotPlugin = class extends import_obsidian6.Plugin {
+  constructor() {
+    super(...arguments);
+    this.settings = DEFAULT_SETTINGS;
+  }
+  async onload() {
+    this.settings = mergeSettings(DEFAULT_SETTINGS, await this.loadData());
+    this.registerView(VIEW_TYPE_CHAT, (leaf) => new NopilotChatView(leaf, this));
+    this.addRibbonIcon("message-square", "Open Nopilot", () => {
+      void this.activateView().catch((error) => {
+        new import_obsidian6.Notice(clip2(redactKey(errorText(error, "Could not open chat."), this.settings.apiKey)));
+      });
+    });
+    this.addSettingTab(
+      new NopilotSettingTab(this.app, this, () => this.settings, (s) => this.saveSettings(s))
+    );
+    registerNopilotCommands(this, this.commandActions());
+    this.registerObsidianProtocolHandler("nopilot", (params) => {
+      const action = typeof params.action === "string" ? params.action : "";
+      const extra = typeof params.theme === "string" ? params.theme : typeof params.where === "string" ? params.where : "";
+      const line = extra.length > 0 ? `${action}|${extra}` : action;
+      void this.runDesk(parseTriggerLine(line));
+    });
+    this.registerInterval(window.setInterval(() => {
+      void this.pollTrigger();
+    }, 1500));
+  }
+  onunload() {
+    this.app.workspace.detachLeavesOfType(VIEW_TYPE_CHAT);
+  }
+  async saveSettings(next) {
+    if (next) {
+      this.settings = next;
+    }
+    await this.saveData(this.settings);
+    this.existingChat()?.refreshLabel();
+  }
+  async complete(messages) {
+    if (!isCliBackend(this.settings.backend)) {
+      return completeChat({ messages, settings: this.settings });
+    }
+    return this.runWorkflow(messages);
+  }
+  async saveConversation(messages) {
+    return saveConversation(this.app, this.settings.conversationsFolder, messages);
+  }
+  async readContext() {
+    return readVaultContext(this.app, this.settings);
+  }
+  async activateView() {
+    const { workspace } = this.app;
+    let leaf = workspace.getLeavesOfType(VIEW_TYPE_CHAT)[0] ?? null;
+    if (!leaf) {
+      leaf = workspace.getRightLeaf(false);
+      if (!leaf) {
+        return null;
+      }
+      await leaf.setViewState({ type: VIEW_TYPE_CHAT, active: true });
+    }
+    await workspace.revealLeaf(leaf);
+    return leaf.view instanceof NopilotChatView ? leaf.view : null;
+  }
+  async chat() {
+    return this.activateView();
+  }
+  commandActions() {
+    return {
+      openChat: () => this.openChat(),
+      newChat: () => this.newChat(),
+      saveChat: () => this.saveChat(),
+      addActiveNote: () => this.addActiveNote(),
+      addSelection: () => this.addSelection(),
+      summarizeSelection: () => this.summarizeSelection(),
+      countSelection: () => this.countSelection(),
+      runAgent: () => this.runAgent(),
+      checkStorage: () => this.checkStorage(),
+      openIslandTree: () => this.openIsland("main"),
+      openIslandTreeSidebar: () => this.openIsland("sidebar"),
+      translateTheme: () => this.translateOne(),
+      translateAllThemes: () => this.translateAll()
+    };
+  }
+  async openChat() {
+    await this.activateView();
+  }
+  async newChat() {
+    await (await this.chat())?.newChat();
+  }
+  async saveChat() {
+    const view = this.existingChat();
+    if (!view) {
+      new import_obsidian6.Notice("No chat open.");
+      return;
+    }
+    const messages = this.transcript(view);
+    if (!messages) {
+      new import_obsidian6.Notice("Could not read the chat.");
+      return;
+    }
+    if (messages.length === 0) {
+      new import_obsidian6.Notice("Nothing to save.");
+      return;
+    }
+    try {
+      const path2 = await this.saveConversation(messages);
+      new import_obsidian6.Notice(path2);
+    } catch (error) {
+      new import_obsidian6.Notice(errorText(error, "Could not save chat."));
+    }
+  }
+  async addActiveNote() {
+    const context = await this.readContext();
+    const body = context.activeNoteBody;
+    if (!body) {
+      new import_obsidian6.Notice(NO_ACTIVE_NOTE);
+      return;
+    }
+    const view = await this.chat();
+    if (!view) {
+      new import_obsidian6.Notice("Could not open chat.");
+      return;
+    }
+    const file = this.app.workspace.getActiveFile();
+    const label = context.activeNoteTitle || context.activeNotePath || (file instanceof import_obsidian6.TFile ? file.basename : "Note");
+    await view.addContext(label, body);
+  }
+  async addSelection() {
+    const selection = this.selectionText();
+    if (!selection) {
+      new import_obsidian6.Notice(NO_SELECTION);
+      return;
+    }
+    const view = await this.chat();
+    if (!view) {
+      new import_obsidian6.Notice("Could not open chat.");
+      return;
+    }
+    await view.addContext("Selection", selection);
+  }
+  async summarizeSelection() {
+    const selection = this.selectionText();
+    if (!selection) {
+      new import_obsidian6.Notice(NO_SELECTION);
+      return;
+    }
+    const view = await this.activateView();
+    if (!view) {
+      new import_obsidian6.Notice("Could not open chat.");
+      return;
+    }
+    await view.sendText("Summarize this selection. Keep it short.\n\n" + selection);
+  }
+  async countSelection() {
+    const selection = this.selectionText();
+    if (!selection) {
+      new import_obsidian6.Notice(NO_SELECTION);
+      return;
+    }
+    new import_obsidian6.Notice(`About ${approximateTokens(selection)} tokens (${selection.length} characters).`);
+  }
+  async runAgent() {
+    if (!this.settings.agentEnabled) {
+      new import_obsidian6.Notice(AGENT_OFF);
+      return;
+    }
+    const cwd = this.vaultCwd();
+    if (!cwd) {
+      new import_obsidian6.Notice(AGENT_DESKTOP_ONLY);
+      return;
+    }
+    const prompt = this.agentPrompt();
+    if (!prompt) {
+      new import_obsidian6.Notice("Nothing to send to the agent.");
+      return;
+    }
+    try {
+      const key = this.settings.apiKey;
+      const result = isCliBackend(this.settings.backend) ? await this.spawnBackend(this.settings.backend, cwd, await this.makePacket(this.settings.backend, "primary", prompt)) : await runLocalAgent({
+        command: this.settings.agentCommand,
+        prompt,
+        cwd,
+        enabled: true
+      });
+      if (result.ok) {
+        const preview = redactKey(result.stdout, key).slice(0, NOTICE_LIMIT);
+        new import_obsidian6.Notice(preview.length > 0 ? preview : AGENT_FINISHED);
+        return;
+      }
+      new import_obsidian6.Notice(clip2(redactKey(result.reason || result.stderr || AGENT_FAILED, key)));
+    } catch (error) {
+      new import_obsidian6.Notice(clip2(redactKey(errorText(error, AGENT_FAILED), this.settings.apiKey)));
+    }
+  }
+  transcript(view) {
+    const source = view;
+    if (typeof source.getMessages === "function") {
+      return source.getMessages().slice();
+    }
+    if (Array.isArray(source.messages)) {
+      return source.messages.slice();
+    }
+    return null;
+  }
+  existingChat() {
+    const leaves = this.app.workspace.getLeavesOfType(VIEW_TYPE_CHAT);
+    for (const leaf of leaves) {
+      if (leaf.view instanceof NopilotChatView) {
+        return leaf.view;
+      }
+    }
+    return null;
+  }
+  selectionText() {
+    const view = this.app.workspace.getActiveViewOfType(import_obsidian6.MarkdownView);
+    if (!view) {
+      return null;
+    }
+    const text = view.editor.getSelection();
+    return text.length > 0 ? text : null;
+  }
+  agentPrompt() {
+    const draft = this.existingChat()?.draft().trim() ?? "";
+    return draft.length > 0 ? draft : null;
+  }
+  async runWorkflow(messages) {
+    const backend = this.settings.backend;
+    if (!isCliBackend(backend)) {
+      return completeChat({ messages, settings: this.settings });
+    }
+    if (!this.settings.modules[backend]) {
+      throw new Error("That backend module is off.");
+    }
+    const cwd = this.vaultCwd();
+    if (!cwd) {
+      throw new Error(AGENT_DESKTOP_ONLY);
+    }
+    const task = messages.filter((message) => message.role !== "system").map((message) => message.content).join("\n\n");
+    const packet = await this.makePacket(backend, "primary", task);
+    const primary = await this.spawnBackend(backend, cwd, packet);
+    if (!primary.ok) {
+      throw new Error(redactKey(primary.reason || primary.stderr || AGENT_FAILED, this.settings.apiKey));
+    }
+    let text = redactKey(primary.stdout.trim() || AGENT_FINISHED, this.settings.apiKey);
+    if (this.settings.subagentEnabled && this.settings.modules[this.settings.subagentBackend]) {
+      const passes = Math.max(1, Math.min(3, this.settings.maxSubagents));
+      for (let pass = 0; pass < passes; pass += 1) {
+        const brief = await this.makePacket(this.settings.subagentBackend, "subagent", subagentTask(pass), text);
+        const result = await this.spawnBackend(this.settings.subagentBackend, cwd, brief);
+        const piece = result.ok ? result.stdout.trim() || AGENT_FINISHED : result.reason || result.stderr || "Subagent failed.";
+        text = `${text}
+
+--- subagent ${pass + 1} (${this.settings.subagentBackend}) ---
+${redactKey(piece, this.settings.apiKey)}`;
+      }
+    }
+    return { text, model: backend, provider: this.settings.provider };
+  }
+  async makePacket(backend, role, task, prior) {
+    const context = await this.readContext();
+    const files = this.settings.includeDirectory ? this.markdownPaths() : [];
+    return renderPacket({
+      role,
+      backend,
+      vault: this.vaultCwd() ?? "vault",
+      notePath: context.activeNotePath,
+      noteTitle: context.activeNoteTitle,
+      noteBody: context.activeNoteBody,
+      selection: context.selection,
+      memory: context.memory,
+      files,
+      task,
+      prior
+    });
+  }
+  markdownPaths() {
+    try {
+      return this.app.vault.getMarkdownFiles().map((file) => file.path).sort().slice(0, 80);
+    } catch {
+      return [];
+    }
+  }
+  commandFor(backend) {
+    if (backend === "hermes") return this.settings.hermesCommand;
+    if (backend === "opencode") return this.settings.opencodeCommand;
+    return this.settings.piCommand;
+  }
+  async spawnBackend(backend, cwd, packet) {
+    const file = await writeQueryFile(packet);
+    try {
+      const plan = buildSpawn(backend, { command: this.commandFor(backend), cwd, queryFile: file });
+      const resolved = resolveInstalled(plan.command);
+      return await runLocalAgent({
+        command: resolved.file,
+        args: [...resolved.argsPrefix, ...plan.args],
+        prompt: packet,
+        cwd,
+        enabled: true,
+        sendStdin: plan.stdin
+      });
+    } finally {
+      await removeQueryFile(file);
+    }
+  }
+  async checkStorage() {
+    const lines = storageStatus().map((item) => item.message);
+    new import_obsidian6.Notice(lines.join(" "));
+  }
+  async openIsland(where) {
+    const host = this.app;
+    if (host.plugins?.enabledPlugins?.has?.("island-tree") !== true) {
+      new import_obsidian6.Notice("Enable the Island tree plugin, then open the dashboard again.");
+      return;
+    }
+    const commandId = islandCommand(where);
+    const commands = host.commands ?? {};
+    if (commands.executeCommandById?.(commandId) === false) {
+      new import_obsidian6.Notice(`Island tree did not provide ${commandId}.`);
+    }
+  }
+  async translateOne() {
+    const result = await translateCurrentTheme(this.vaultFiles());
+    new import_obsidian6.Notice(themeNotice(result));
+  }
+  async translateAll() {
+    const results = await translateEveryTheme(this.vaultFiles());
+    const changed = results.filter((item) => item.changed).length;
+    new import_obsidian6.Notice(`Theme audit finished. ${changed} of ${results.length} themes changed.`);
+  }
+  async runDesk(action) {
+    if (!action) {
+      new import_obsidian6.Notice("Nopilot does not recognize that action.");
+      return;
+    }
+    if (action.action === "storage-check") return this.checkStorage();
+    if (action.action === "open-island-tree") return this.openIsland(action.where);
+    if (action.action === "translate-all") return this.translateAll();
+    if (action.theme) {
+      new import_obsidian6.Notice(themeNotice(await translateNamedTheme(this.vaultFiles(), action.theme)));
+      return;
+    }
+    return this.translateOne();
+  }
+  async pollTrigger() {
+    const files = this.vaultFiles();
+    const trigger = ".obsidian/plugins/nopilot/.trigger";
+    try {
+      if (!await files.exists(trigger)) return;
+      const raw = await files.read(trigger);
+      const line = raw.replace(/^\uFEFF/, "").trim();
+      if (!line) return;
+      await files.write(trigger, "");
+      await this.runDesk(parseTriggerLine(line));
+    } catch {
+      return;
+    }
+  }
+  vaultFiles() {
+    const adapter = this.app.vault.adapter;
+    return adapter;
+  }
+  vaultCwd() {
+    try {
+      const adapter = this.app.vault.adapter;
+      if (!("getBasePath" in adapter)) {
+        return null;
+      }
+      const getBasePath = adapter.getBasePath;
+      if (typeof getBasePath !== "function") {
+        return null;
+      }
+      const cwd = getBasePath.call(adapter);
+      return typeof cwd === "string" && cwd.length > 0 ? cwd : null;
+    } catch {
+      return null;
+    }
+  }
+};
+function clip2(text) {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) {
+    return AGENT_FAILED;
+  }
+  return trimmed.slice(0, NOTICE_LIMIT);
+}
+function errorText(error, fallback) {
+  if (error instanceof Error && error.message.length > 0) {
+    return error.message;
+  }
+  return fallback;
+}
+function redactKey(text, apiKey) {
+  if (apiKey.length === 0 || !text.includes(apiKey)) return text;
+  return text.split(apiKey).join("[redacted]");
+}