@zerwiz/ymir 0.1.33 → 0.1.35

package/apps/sessrumnir/out/preload/index.js

@@ -0,0 +1,722 @@
+"use strict";
+const electron = require("electron");
+const BASE = "";
+const WS_BASE = "";
+function createHttpBridge() {
+  const subscriptions = /* @__PURE__ */ new Map();
+  async function invoke(channel, ...args) {
+    const body = args.length === 1 ? args[0] : args;
+    const res = await fetch(`${BASE}/api/${channel}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`HTTP ${res.status}: ${text}`);
+    }
+    return res.json();
+  }
+  function subscribe(channel, callback) {
+    const ws = new WebSocket(`${WS_BASE}/ws/${channel}`);
+    const handler = (event) => {
+      const data = typeof event.data === "string" ? JSON.parse(event.data) : event.data;
+      callback(data);
+    };
+    ws.addEventListener("message", handler);
+    const entry = { ws, handler };
+    const existing = subscriptions.get(channel) || [];
+    existing.push(entry);
+    subscriptions.set(channel, existing);
+    return () => {
+      const subs = subscriptions.get(channel);
+      if (subs) {
+        const idx = subs.indexOf(entry);
+        if (idx >= 0) subs.splice(idx, 1);
+        ws.close();
+      }
+    };
+  }
+  const pi = {
+    start: (options) => invoke("pi:start", options),
+    stop: () => invoke("pi:stop"),
+    restart: (options) => invoke("pi:restart", options),
+    getStatus: () => invoke("pi:status"),
+    detectInstallations: (options) => invoke("pi:detect-installations", options)
+  };
+  const commands = {
+    prompt: (message, options) => invoke("pi:prompt", message, options),
+    steer: (message, images) => invoke("pi:steer", message, images),
+    followUp: (message) => invoke("pi:follow-up", message),
+    abort: () => invoke("pi:abort"),
+    bash: (command) => invoke("pi:bash", command),
+    abortBash: () => invoke("pi:abort-bash")
+  };
+  const session = {
+    createNew: () => invoke("session:new"),
+    launchTask: (options) => invoke("session:launch-task", options),
+    closeRuntime: (runtimeId) => invoke("session:close-runtime", runtimeId),
+    switch: (sessionPath, cwd) => invoke("session:switch", sessionPath, cwd),
+    listRuntimes: () => invoke("session:list-runtimes"),
+    fork: (entryId) => invoke("session:fork", entryId),
+    clone: () => invoke("session:clone"),
+    list: (cwd) => invoke("session:list", cwd),
+    listAll: (cwd) => invoke("session:list-all", cwd),
+    getState: () => invoke("session:get-state"),
+    getMessages: () => invoke("session:get-messages"),
+    getStats: () => invoke("session:get-stats"),
+    setName: (name) => invoke("session:set-name", name),
+    exportHtml: (outputPath) => invoke("session:export-html", outputPath),
+    getForkMessages: () => invoke("session:get-fork-messages"),
+    delete: (sessionPath) => invoke("session:delete", sessionPath),
+    archive: (sessionId) => invoke("session:archive", sessionId),
+    unarchive: (sessionId) => invoke("session:unarchive", sessionId),
+    listArchived: () => invoke("session:list-archived"),
+    getLineage: () => invoke("session:get-lineage"),
+    compact: (customInstructions) => invoke("session:compact", customInstructions)
+  };
+  const model = {
+    set: (provider, modelId) => invoke("model:set", provider, modelId),
+    cycle: () => invoke("model:cycle"),
+    listAvailable: () => invoke("model:list-available")
+  };
+  const thinking = {
+    setLevel: (level) => invoke("thinking:set-level", level),
+    cycleLevel: () => invoke("thinking:cycle-level")
+  };
+  const settings = {
+    getAll: () => invoke("settings:get-all"),
+    save: (s) => invoke("settings:save", s)
+  };
+  const permissionRules = {
+    get: (scope) => invoke("permission-rules:get", scope),
+    set: (scope, rules) => invoke("permission-rules:set", scope, rules),
+    importFromFile: () => invoke("permission-rules:import"),
+    exportToFile: (rules) => invoke("permission-rules:export", rules),
+    workspaceStatus: () => invoke("permission-rules:workspace-status"),
+    removeWorkspace: () => invoke("permission-rules:remove-workspace"),
+    setWorkspaceTrust: (trusted) => invoke("permission-rules:set-workspace-trust", trusted)
+  };
+  const themes = {
+    list: () => invoke("themes:list"),
+    save: (file, existingId) => invoke("themes:save", file, existingId),
+    delete: (id) => invoke("themes:delete", id),
+    installFromUrl: (url) => invoke("themes:install-from-url", url),
+    export: (file) => invoke("themes:export", file),
+    import: () => invoke("themes:import"),
+    gallery: () => invoke("themes:gallery-list"),
+    galleryImage: (url) => invoke("themes:gallery-image", url)
+  };
+  const workspace = {
+    list: () => invoke("workspace:list"),
+    create: (name, path) => invoke("workspace:create", name, path),
+    createTab: (options) => invoke("workspace:create-tab", options),
+    remove: (workspaceId) => invoke("workspace:remove", workspaceId),
+    rename: (workspaceId, name) => invoke("workspace:rename", workspaceId, name),
+    changePath: (workspaceId, newPath) => invoke("workspace:change-path", workspaceId, newPath),
+    pathExists: () => invoke("workspace:path-exists"),
+    setActive: (workspaceId) => invoke("workspace:set-active", workspaceId),
+    getActive: () => invoke("workspace:get-active"),
+    startPi: (workspaceId, options) => invoke("workspace:start-pi", workspaceId, options),
+    stopPi: (workspaceId) => invoke("workspace:stop-pi", workspaceId),
+    getActivity: () => invoke("workspace:activity"),
+    takePendingActivation: () => invoke("workspace:take-pending-activation")
+  };
+  const packages = {
+    listInstalled: () => invoke("package:list-installed"),
+    install: (spec) => invoke("package:install", spec),
+    remove: (spec) => invoke("package:remove", spec),
+    update: (spec) => invoke("package:update", spec),
+    updateAll: () => invoke("package:update-all"),
+    checkUpdates: () => invoke("package:check-updates"),
+    fetchCatalog: (query) => invoke("package:catalog-fetch", query)
+  };
+  const models = {
+    read: () => invoke("models:read"),
+    write: (config) => invoke("models:write", config)
+  };
+  const council = {
+    detect: () => invoke("council:detect"),
+    runConsultants: (payload) => invoke("council:run-consultants", payload),
+    arbiter: (payload) => invoke("council:arbiter", payload),
+    onProgress: (callback) => subscribe("event:council-progress", callback)
+  };
+  const skills = { list: () => invoke("skills:list") };
+  const piCommands = { list: () => invoke("commands:list") };
+  const mcpServers = { list: () => invoke("mcp:servers-list") };
+  const tags = {
+    get: (sessionId) => invoke("tag:get", sessionId),
+    set: (sessionId, tags2) => invoke("tag:set", sessionId, tags2),
+    add: (sessionId, tag) => invoke("tag:add", sessionId, tag),
+    remove: (sessionId, tag) => invoke("tag:remove", sessionId, tag),
+    getAll: () => invoke("tag:get-all"),
+    getAllUsed: () => invoke("tag:get-all-used"),
+    autoGetAll: () => invoke("tag:auto-get-all"),
+    autoEnsure: (sessions) => invoke("tag:auto-ensure", sessions),
+    autoRemove: (sessionId) => invoke("tag:auto-remove", sessionId)
+  };
+  const git = {
+    status: () => invoke("git:conveyor-status"),
+    commit: (options) => invoke("git:conveyor-commit", options),
+    push: () => invoke("git:conveyor-push"),
+    createPullRequest: (options) => invoke("git:conveyor-create-pr", options)
+  };
+  const notes = {
+    list: () => invoke("notes:list"),
+    create: (input) => invoke("notes:create", input),
+    update: (id, patch) => invoke("notes:update", id, patch),
+    remove: (id) => invoke("notes:remove", id)
+  };
+  const files = {
+    getTree: (maxDepth) => invoke("file:tree", maxDepth),
+    search: (query) => invoke("file:search", query),
+    searchContent: (query) => invoke("file:search-content", query),
+    read: (path) => invoke("file:read", path),
+    readAttachment: (path) => invoke("file:read-attachment", path),
+    write: (path, content) => invoke("file:write", path, content),
+    getDiff: (filePath) => invoke("file:diff", filePath),
+    getStagedDiff: (filePath) => invoke("file:staged-diff", filePath),
+    getGitStatus: () => invoke("git:status"),
+    getGitBranch: () => invoke("git:branch")
+  };
+  const system = {
+    openDialog: (options) => invoke("system:open-dialog", options),
+    getPath: (name) => invoke("system:get-path", name),
+    getPathForFile: (_file) => "",
+    // NOT PORTABLE: requires webUtils.getPathForFile
+    pathKind: (path) => invoke("system:path-kind", path),
+    openExternal: (url) => invoke("system:open-external", url),
+    hallUrl: () => invoke("system:hall-url"),
+    getVersion: () => invoke("system:get-version"),
+    get platform() {
+      return "linux";
+    }
+    // stub: web has no process.platform
+  };
+  const activity = {
+    getStats: () => invoke("activity:get-stats")
+  };
+  const workflows = {
+    list: () => invoke("workflow:list"),
+    getRun: (workspaceId, runId) => invoke("workflow:get-run", workspaceId, runId),
+    control: (workspaceId, runId, action) => invoke("workflow:control", workspaceId, runId, action),
+    setPersistAgentSessions: (enabled) => invoke("workflow:set-persistence", enabled)
+  };
+  const diagnostics = {
+    get: () => invoke("diagnostics:get")
+  };
+  const updates = {
+    check: () => invoke("update:check")
+  };
+  const i18n = {
+    getEnvironment: () => invoke("i18n:get-environment")
+  };
+  const terminal = {
+    start: (options) => invoke("terminal:start", options),
+    input: (data) => invoke("terminal:input", data),
+    resize: (cols, rows) => invoke("terminal:resize", { cols, rows }),
+    stop: () => invoke("terminal:stop"),
+    onData: (callback) => subscribe("event:terminal-data", callback),
+    onExit: (callback) => subscribe("event:terminal-exit", callback)
+  };
+  const ui = {
+    respondSelect: (id, value) => invoke("ui:select-response", id, value),
+    respondConfirm: (id, confirmed) => invoke("ui:confirm-response", id, confirmed),
+    respondInput: (id, value) => invoke("ui:input-response", id, value),
+    respondEditor: (id, value) => invoke("ui:editor-response", id, value),
+    flushPendingPrompts: (workspaceId) => invoke("ui:pending-flush", workspaceId),
+    getPendingPrompts: () => invoke("ui:pending-get"),
+    setEditorDirty: (_dirty, _fileName) => {
+    }
+  };
+  const onEvent = (callback) => subscribe("event:pi", callback);
+  const onPendingPrompts = (callback) => subscribe("event:pending-prompts", callback);
+  const onWorkspaceActivity = (callback) => subscribe("event:workspace-activity", callback);
+  const onSessionRuntime = (callback) => subscribe("event:session-runtime", callback);
+  const onActivateWorkspace = (callback) => subscribe("event:activate-workspace", callback);
+  const onFileChange = (callback) => subscribe("event:file-change", callback);
+  const onMenuAction = (_callback) => {
+    return () => {
+    };
+  };
+  return {
+    pi,
+    commands,
+    session,
+    model,
+    thinking,
+    settings,
+    permissionRules,
+    themes,
+    workspace,
+    packages,
+    models,
+    council,
+    skills,
+    piCommands,
+    mcpServers,
+    tags,
+    git,
+    notes,
+    files,
+    system,
+    activity,
+    workflows,
+    diagnostics,
+    updates,
+    i18n,
+    terminal,
+    ui,
+    onEvent,
+    onPendingPrompts,
+    onWorkspaceActivity,
+    onSessionRuntime,
+    onActivateWorkspace,
+    onFileChange,
+    onMenuAction
+  };
+}
+const IPC_CHANNELS = {
+  /** The live fleet, read from herdr's panes - the same source the control plane uses. */
+  FLEET_LIST: "fleet:list",
+  // Pi process lifecycle
+  PI_START: "pi:start",
+  PI_STOP: "pi:stop",
+  PI_RESTART: "pi:restart",
+  PI_STATUS: "pi:status",
+  PI_DETECT_INSTALLATIONS: "pi:detect-installations",
+  // Pi commands
+  PI_PROMPT: "pi:prompt",
+  PI_STEER: "pi:steer",
+  PI_FOLLOW_UP: "pi:follow-up",
+  PI_ABORT: "pi:abort",
+  PI_BASH: "pi:bash",
+  PI_ABORT_BASH: "pi:abort-bash",
+  // Session management
+  SESSION_NEW: "session:new",
+  SESSION_LAUNCH_TASK: "session:launch-task",
+  SESSION_CLOSE_RUNTIME: "session:close-runtime",
+  SESSION_SWITCH: "session:switch",
+  SESSION_LIST_RUNTIMES: "session:list-runtimes",
+  SESSION_FORK: "session:fork",
+  SESSION_CLONE: "session:clone",
+  SESSION_LIST: "session:list",
+  SESSION_LIST_ALL: "session:list-all",
+  SESSION_GET_STATE: "session:get-state",
+  SESSION_GET_MESSAGES: "session:get-messages",
+  SESSION_GET_STATS: "session:get-stats",
+  SESSION_SET_NAME: "session:set-name",
+  SESSION_EXPORT_HTML: "session:export-html",
+  SESSION_GET_FORK_MESSAGES: "session:get-fork-messages",
+  SESSION_DELETE: "session:delete",
+  SESSION_ARCHIVE: "session:archive",
+  SESSION_UNARCHIVE: "session:unarchive",
+  SESSION_LIST_ARCHIVED: "session:list-archived",
+  SESSION_GET_LINEAGE: "session:get-lineage",
+  SESSION_COMPACT: "session:compact",
+  // Model management
+  MODEL_SET: "model:set",
+  MODEL_CYCLE: "model:cycle",
+  MODEL_LIST_AVAILABLE: "model:list-available",
+  THINKING_SET_LEVEL: "thinking:set-level",
+  THINKING_CYCLE_LEVEL: "thinking:cycle-level",
+  // Settings
+  SETTINGS_GET_ALL: "settings:get-all",
+  SETTINGS_SAVE: "settings:save",
+  I18N_GET_ENVIRONMENT: "i18n:get-environment",
+  // Permission rules
+  PERMISSION_RULES_GET: "permission-rules:get",
+  PERMISSION_RULES_SET: "permission-rules:set",
+  PERMISSION_RULES_IMPORT: "permission-rules:import",
+  PERMISSION_RULES_EXPORT: "permission-rules:export",
+  PERMISSION_RULES_WORKSPACE_STATUS: "permission-rules:workspace-status",
+  PERMISSION_RULES_REMOVE_WORKSPACE: "permission-rules:remove-workspace",
+  PERMISSION_RULES_SET_WORKSPACE_TRUST: "permission-rules:set-workspace-trust",
+  // UI
+  UI_SELECT_RESPONSE: "ui:select-response",
+  UI_CONFIRM_RESPONSE: "ui:confirm-response",
+  UI_INPUT_RESPONSE: "ui:input-response",
+  UI_EDITOR_RESPONSE: "ui:editor-response",
+  UI_PENDING_FLUSH: "ui:pending-flush",
+  UI_PENDING_GET: "ui:pending-get",
+  UI_EDITOR_DIRTY_SET: "ui:editor-dirty-set",
+  // System
+  SYSTEM_OPEN_DIALOG: "system:open-dialog",
+  SYSTEM_GET_PATH: "system:get-path",
+  SYSTEM_PATH_KIND: "system:path-kind",
+  SYSTEM_OPEN_EXTERNAL: "system:open-external",
+  SYSTEM_HALL_URL: "system:hall-url",
+  SYSTEM_GET_VERSION: "system:get-version",
+  UPDATE_CHECK: "update:check",
+  // Activity
+  ACTIVITY_GET_STATS: "activity:get-stats",
+  // Workflow run monitoring
+  WORKFLOW_LIST: "workflow:list",
+  WORKFLOW_GET_RUN: "workflow:get-run",
+  WORKFLOW_CONTROL: "workflow:control",
+  WORKFLOW_SET_PERSISTENCE: "workflow:set-persistence",
+  // Diagnostics
+  DIAGNOSTICS_GET: "diagnostics:get",
+  // Workspaces
+  WORKSPACE_LIST: "workspace:list",
+  WORKSPACE_CREATE: "workspace:create",
+  WORKSPACE_REMOVE: "workspace:remove",
+  WORKSPACE_RENAME: "workspace:rename",
+  WORKSPACE_SET_ACTIVE: "workspace:set-active",
+  WORKSPACE_GET_ACTIVE: "workspace:get-active",
+  WORKSPACE_CHANGE_PATH: "workspace:change-path",
+  WORKSPACE_PATH_EXISTS: "workspace:path-exists",
+  WORKSPACE_START_PI: "workspace:start-pi",
+  WORKSPACE_STOP_PI: "workspace:stop-pi",
+  WORKSPACE_CREATE_TAB: "workspace:create-tab",
+  WORKSPACE_ACTIVITY_GET: "workspace:activity",
+  WORKSPACE_TAKE_PENDING_ACTIVATION: "workspace:take-pending-activation",
+  // Packages
+  PACKAGE_LIST_INSTALLED: "package:list-installed",
+  PACKAGE_INSTALL: "package:install",
+  PACKAGE_REMOVE: "package:remove",
+  PACKAGE_UPDATE: "package:update",
+  PACKAGE_UPDATE_ALL: "package:update-all",
+  PACKAGE_CHECK_UPDATES: "package:check-updates",
+  PACKAGE_CATALOG_FETCH: "package:catalog-fetch",
+  // Skills
+  SKILLS_LIST: "skills:list",
+  COMMANDS_LIST: "commands:list",
+  MCP_SERVERS_LIST: "mcp:servers-list",
+  // Models config
+  MODELS_READ: "models:read",
+  MODELS_WRITE: "models:write",
+  // Council planning
+  COUNCIL_DETECT: "council:detect",
+  COUNCIL_RUN_CONSULTANTS: "council:run-consultants",
+  COUNCIL_ARBITER: "council:arbiter",
+  // File operations
+  FILE_TREE: "file:tree",
+  FILE_SEARCH: "file:search",
+  FILE_SEARCH_CONTENT: "file:search-content",
+  FILE_READ: "file:read",
+  FILE_READ_ATTACHMENT: "file:read-attachment",
+  FILE_WRITE: "file:write",
+  FILE_DIFF: "file:diff",
+  FILE_STAGED_DIFF: "file:staged-diff",
+  GIT_STATUS: "git:status",
+  GIT_BRANCH: "git:branch",
+  GIT_CONVEYOR_STATUS: "git:conveyor-status",
+  GIT_CONVEYOR_COMMIT: "git:conveyor-commit",
+  GIT_CONVEYOR_PUSH: "git:conveyor-push",
+  GIT_CONVEYOR_CREATE_PR: "git:conveyor-create-pr",
+  // Terminal
+  TERMINAL_START: "terminal:start",
+  TERMINAL_INPUT: "terminal:input",
+  TERMINAL_RESIZE: "terminal:resize",
+  TERMINAL_STOP: "terminal:stop",
+  // Session tags
+  TAG_GET: "tag:get",
+  TAG_SET: "tag:set",
+  TAG_ADD: "tag:add",
+  TAG_REMOVE: "tag:remove",
+  TAG_GET_ALL: "tag:get-all",
+  TAG_GET_ALL_USED: "tag:get-all-used",
+  TAG_AUTO_GET_ALL: "tag:auto-get-all",
+  TAG_AUTO_ENSURE: "tag:auto-ensure",
+  TAG_AUTO_REMOVE: "tag:auto-remove",
+  // Notes (reusable prompts / commands)
+  NOTES_LIST: "notes:list",
+  NOTES_CREATE: "notes:create",
+  NOTES_UPDATE: "notes:update",
+  NOTES_REMOVE: "notes:remove",
+  // Themes (user-created theme storage)
+  THEMES_LIST: "themes:list",
+  THEMES_SAVE: "themes:save",
+  THEMES_DELETE: "themes:delete",
+  THEMES_INSTALL_URL: "themes:install-from-url",
+  THEMES_EXPORT: "themes:export",
+  THEMES_IMPORT: "themes:import",
+  THEMES_GALLERY_LIST: "themes:gallery-list",
+  THEMES_GALLERY_IMAGE: "themes:gallery-image",
+  // Events (main → renderer)
+  EVENT_PI: "event:pi",
+  EVENT_PENDING_PROMPTS: "event:pending-prompts",
+  EVENT_WORKSPACE_ACTIVITY: "event:workspace-activity",
+  EVENT_SESSION_RUNTIME: "event:session-runtime",
+  EVENT_ACTIVATE_WORKSPACE: "event:activate-workspace",
+  EVENT_FILE_CHANGE: "event:file-change",
+  EVENT_TERMINAL_DATA: "event:terminal-data",
+  EVENT_TERMINAL_EXIT: "event:terminal-exit",
+  EVENT_COUNCIL_PROGRESS: "event:council-progress"
+};
+const IS_ELECTRON = typeof electron.contextBridge !== "undefined" && typeof electron.ipcRenderer !== "undefined";
+function createBridge() {
+  if (IS_ELECTRON) {
+    const api = {
+      pi: {
+        start: (options) => electron.ipcRenderer.invoke(IPC_CHANNELS.PI_START, options),
+        stop: () => electron.ipcRenderer.invoke(IPC_CHANNELS.PI_STOP),
+        restart: (options) => electron.ipcRenderer.invoke(IPC_CHANNELS.PI_RESTART, options),
+        getStatus: () => electron.ipcRenderer.invoke(IPC_CHANNELS.PI_STATUS),
+        detectInstallations: (options) => electron.ipcRenderer.invoke(IPC_CHANNELS.PI_DETECT_INSTALLATIONS, options)
+      },
+      commands: {
+        prompt: (message, options) => electron.ipcRenderer.invoke(IPC_CHANNELS.PI_PROMPT, message, options),
+        steer: (message, images) => electron.ipcRenderer.invoke(IPC_CHANNELS.PI_STEER, message, images),
+        followUp: (message) => electron.ipcRenderer.invoke(IPC_CHANNELS.PI_FOLLOW_UP, message),
+        abort: () => electron.ipcRenderer.invoke(IPC_CHANNELS.PI_ABORT),
+        bash: (command) => electron.ipcRenderer.invoke(IPC_CHANNELS.PI_BASH, command),
+        abortBash: () => electron.ipcRenderer.invoke(IPC_CHANNELS.PI_ABORT_BASH)
+      },
+      session: {
+        createNew: () => electron.ipcRenderer.invoke(IPC_CHANNELS.SESSION_NEW),
+        launchTask: (options) => electron.ipcRenderer.invoke(IPC_CHANNELS.SESSION_LAUNCH_TASK, options),
+        closeRuntime: (runtimeId) => electron.ipcRenderer.invoke(IPC_CHANNELS.SESSION_CLOSE_RUNTIME, runtimeId),
+        switch: (sessionPath, cwd) => electron.ipcRenderer.invoke(IPC_CHANNELS.SESSION_SWITCH, sessionPath, cwd),
+        listRuntimes: () => electron.ipcRenderer.invoke(IPC_CHANNELS.SESSION_LIST_RUNTIMES),
+        fork: (entryId) => electron.ipcRenderer.invoke(IPC_CHANNELS.SESSION_FORK, entryId),
+        clone: () => electron.ipcRenderer.invoke(IPC_CHANNELS.SESSION_CLONE),
+        list: (cwd) => electron.ipcRenderer.invoke(IPC_CHANNELS.SESSION_LIST, cwd),
+        listAll: (cwd) => electron.ipcRenderer.invoke(IPC_CHANNELS.SESSION_LIST_ALL, cwd),
+        getState: () => electron.ipcRenderer.invoke(IPC_CHANNELS.SESSION_GET_STATE),
+        getMessages: () => electron.ipcRenderer.invoke(IPC_CHANNELS.SESSION_GET_MESSAGES),
+        getStats: () => electron.ipcRenderer.invoke(IPC_CHANNELS.SESSION_GET_STATS),
+        setName: (name) => electron.ipcRenderer.invoke(IPC_CHANNELS.SESSION_SET_NAME, name),
+        exportHtml: (outputPath) => electron.ipcRenderer.invoke(IPC_CHANNELS.SESSION_EXPORT_HTML, outputPath),
+        getForkMessages: () => electron.ipcRenderer.invoke(IPC_CHANNELS.SESSION_GET_FORK_MESSAGES),
+        getLineage: () => electron.ipcRenderer.invoke(IPC_CHANNELS.SESSION_GET_LINEAGE),
+        compact: (customInstructions) => electron.ipcRenderer.invoke(IPC_CHANNELS.SESSION_COMPACT, customInstructions),
+        delete: (sessionPath) => electron.ipcRenderer.invoke(IPC_CHANNELS.SESSION_DELETE, sessionPath),
+        archive: (sessionId) => electron.ipcRenderer.invoke(IPC_CHANNELS.SESSION_ARCHIVE, sessionId),
+        unarchive: (sessionId) => electron.ipcRenderer.invoke(IPC_CHANNELS.SESSION_UNARCHIVE, sessionId),
+        listArchived: () => electron.ipcRenderer.invoke(IPC_CHANNELS.SESSION_LIST_ARCHIVED)
+      },
+      model: {
+        set: (provider, modelId) => electron.ipcRenderer.invoke(IPC_CHANNELS.MODEL_SET, provider, modelId),
+        cycle: () => electron.ipcRenderer.invoke(IPC_CHANNELS.MODEL_CYCLE),
+        listAvailable: () => electron.ipcRenderer.invoke(IPC_CHANNELS.MODEL_LIST_AVAILABLE)
+      },
+      thinking: {
+        setLevel: (level) => electron.ipcRenderer.invoke(IPC_CHANNELS.THINKING_SET_LEVEL, level),
+        cycleLevel: () => electron.ipcRenderer.invoke(IPC_CHANNELS.THINKING_CYCLE_LEVEL)
+      },
+      settings: {
+        getAll: () => electron.ipcRenderer.invoke(IPC_CHANNELS.SETTINGS_GET_ALL),
+        save: (settings) => electron.ipcRenderer.invoke(IPC_CHANNELS.SETTINGS_SAVE, settings)
+      },
+      permissionRules: {
+        get: (scope) => electron.ipcRenderer.invoke(IPC_CHANNELS.PERMISSION_RULES_GET, scope),
+        set: (scope, rules) => electron.ipcRenderer.invoke(IPC_CHANNELS.PERMISSION_RULES_SET, scope, rules),
+        importFromFile: () => electron.ipcRenderer.invoke(IPC_CHANNELS.PERMISSION_RULES_IMPORT),
+        exportToFile: (rules) => electron.ipcRenderer.invoke(IPC_CHANNELS.PERMISSION_RULES_EXPORT, rules),
+        workspaceStatus: () => electron.ipcRenderer.invoke(IPC_CHANNELS.PERMISSION_RULES_WORKSPACE_STATUS),
+        removeWorkspace: () => electron.ipcRenderer.invoke(IPC_CHANNELS.PERMISSION_RULES_REMOVE_WORKSPACE),
+        setWorkspaceTrust: (trusted) => electron.ipcRenderer.invoke(IPC_CHANNELS.PERMISSION_RULES_SET_WORKSPACE_TRUST, trusted)
+      },
+      themes: {
+        list: () => electron.ipcRenderer.invoke(IPC_CHANNELS.THEMES_LIST),
+        save: (file, existingId) => electron.ipcRenderer.invoke(IPC_CHANNELS.THEMES_SAVE, file, existingId),
+        delete: (id) => electron.ipcRenderer.invoke(IPC_CHANNELS.THEMES_DELETE, id),
+        installFromUrl: (url) => electron.ipcRenderer.invoke(IPC_CHANNELS.THEMES_INSTALL_URL, url),
+        export: (file) => electron.ipcRenderer.invoke(IPC_CHANNELS.THEMES_EXPORT, file),
+        import: () => electron.ipcRenderer.invoke(IPC_CHANNELS.THEMES_IMPORT),
+        gallery: () => electron.ipcRenderer.invoke(IPC_CHANNELS.THEMES_GALLERY_LIST),
+        galleryImage: (url) => electron.ipcRenderer.invoke(IPC_CHANNELS.THEMES_GALLERY_IMAGE, url)
+      },
+      workspace: {
+        list: () => electron.ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_LIST),
+        create: (name, path) => electron.ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_CREATE, name, path),
+        remove: (workspaceId) => electron.ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_REMOVE, workspaceId),
+        rename: (workspaceId, name) => electron.ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_RENAME, workspaceId, name),
+        changePath: (workspaceId, newPath) => electron.ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_CHANGE_PATH, workspaceId, newPath),
+        pathExists: () => electron.ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_PATH_EXISTS),
+        setActive: (workspaceId) => electron.ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_SET_ACTIVE, workspaceId),
+        getActive: () => electron.ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_GET_ACTIVE),
+        startPi: (workspaceId, options) => electron.ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_START_PI, workspaceId, options),
+        stopPi: (workspaceId) => electron.ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_STOP_PI, workspaceId),
+        createTab: (options) => electron.ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_CREATE_TAB, options),
+        getActivity: () => electron.ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_ACTIVITY_GET),
+        takePendingActivation: () => electron.ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_TAKE_PENDING_ACTIVATION)
+      },
+      packages: {
+        listInstalled: () => electron.ipcRenderer.invoke(IPC_CHANNELS.PACKAGE_LIST_INSTALLED),
+        install: (spec) => electron.ipcRenderer.invoke(IPC_CHANNELS.PACKAGE_INSTALL, spec),
+        remove: (spec) => electron.ipcRenderer.invoke(IPC_CHANNELS.PACKAGE_REMOVE, spec),
+        update: (spec) => electron.ipcRenderer.invoke(IPC_CHANNELS.PACKAGE_UPDATE, spec),
+        updateAll: () => electron.ipcRenderer.invoke(IPC_CHANNELS.PACKAGE_UPDATE_ALL),
+        checkUpdates: () => electron.ipcRenderer.invoke(IPC_CHANNELS.PACKAGE_CHECK_UPDATES),
+        fetchCatalog: (query) => electron.ipcRenderer.invoke(IPC_CHANNELS.PACKAGE_CATALOG_FETCH, query)
+      },
+      models: {
+        read: () => electron.ipcRenderer.invoke(IPC_CHANNELS.MODELS_READ),
+        write: (config) => electron.ipcRenderer.invoke(IPC_CHANNELS.MODELS_WRITE, config)
+      },
+      council: {
+        detect: () => electron.ipcRenderer.invoke(IPC_CHANNELS.COUNCIL_DETECT),
+        runConsultants: (payload) => electron.ipcRenderer.invoke(IPC_CHANNELS.COUNCIL_RUN_CONSULTANTS, payload),
+        arbiter: (payload) => electron.ipcRenderer.invoke(IPC_CHANNELS.COUNCIL_ARBITER, payload),
+        onProgress: (callback) => {
+          const handler = (_event, data) => callback(data);
+          electron.ipcRenderer.on(IPC_CHANNELS.EVENT_COUNCIL_PROGRESS, handler);
+          return () => electron.ipcRenderer.removeListener(IPC_CHANNELS.EVENT_COUNCIL_PROGRESS, handler);
+        }
+      },
+      skills: {
+        list: () => electron.ipcRenderer.invoke(IPC_CHANNELS.SKILLS_LIST)
+      },
+      piCommands: {
+        list: () => electron.ipcRenderer.invoke(IPC_CHANNELS.COMMANDS_LIST)
+      },
+      mcpServers: {
+        list: () => electron.ipcRenderer.invoke(IPC_CHANNELS.MCP_SERVERS_LIST)
+      },
+      tags: {
+        get: (sessionId) => electron.ipcRenderer.invoke(IPC_CHANNELS.TAG_GET, sessionId),
+        set: (sessionId, tags) => electron.ipcRenderer.invoke(IPC_CHANNELS.TAG_SET, sessionId, tags),
+        add: (sessionId, tag) => electron.ipcRenderer.invoke(IPC_CHANNELS.TAG_ADD, sessionId, tag),
+        remove: (sessionId, tag) => electron.ipcRenderer.invoke(IPC_CHANNELS.TAG_REMOVE, sessionId, tag),
+        getAll: () => electron.ipcRenderer.invoke(IPC_CHANNELS.TAG_GET_ALL),
+        getAllUsed: () => electron.ipcRenderer.invoke(IPC_CHANNELS.TAG_GET_ALL_USED),
+        autoGetAll: () => electron.ipcRenderer.invoke(IPC_CHANNELS.TAG_AUTO_GET_ALL),
+        autoEnsure: (sessions) => electron.ipcRenderer.invoke(IPC_CHANNELS.TAG_AUTO_ENSURE, sessions),
+        autoRemove: (sessionId) => electron.ipcRenderer.invoke(IPC_CHANNELS.TAG_AUTO_REMOVE, sessionId)
+      },
+      git: {
+        status: () => electron.ipcRenderer.invoke(IPC_CHANNELS.GIT_CONVEYOR_STATUS),
+        commit: (options) => electron.ipcRenderer.invoke(IPC_CHANNELS.GIT_CONVEYOR_COMMIT, options),
+        push: () => electron.ipcRenderer.invoke(IPC_CHANNELS.GIT_CONVEYOR_PUSH),
+        createPullRequest: (options) => electron.ipcRenderer.invoke(IPC_CHANNELS.GIT_CONVEYOR_CREATE_PR, options)
+      },
+      notes: {
+        list: () => electron.ipcRenderer.invoke(IPC_CHANNELS.NOTES_LIST),
+        create: (input) => electron.ipcRenderer.invoke(IPC_CHANNELS.NOTES_CREATE, input),
+        update: (id, patch) => electron.ipcRenderer.invoke(IPC_CHANNELS.NOTES_UPDATE, id, patch),
+        remove: (id) => electron.ipcRenderer.invoke(IPC_CHANNELS.NOTES_REMOVE, id)
+      },
+      files: {
+        getTree: (maxDepth) => electron.ipcRenderer.invoke(IPC_CHANNELS.FILE_TREE, maxDepth),
+        search: (query) => electron.ipcRenderer.invoke(IPC_CHANNELS.FILE_SEARCH, query),
+        searchContent: (query) => electron.ipcRenderer.invoke(IPC_CHANNELS.FILE_SEARCH_CONTENT, query),
+        read: (path) => electron.ipcRenderer.invoke(IPC_CHANNELS.FILE_READ, path),
+        readAttachment: (path) => electron.ipcRenderer.invoke(IPC_CHANNELS.FILE_READ_ATTACHMENT, path),
+        write: (path, content) => electron.ipcRenderer.invoke(IPC_CHANNELS.FILE_WRITE, path, content),
+        getDiff: (filePath) => electron.ipcRenderer.invoke(IPC_CHANNELS.FILE_DIFF, filePath),
+        getStagedDiff: (filePath) => electron.ipcRenderer.invoke(IPC_CHANNELS.FILE_STAGED_DIFF, filePath),
+        getGitStatus: () => electron.ipcRenderer.invoke(IPC_CHANNELS.GIT_STATUS),
+        getGitBranch: () => electron.ipcRenderer.invoke(IPC_CHANNELS.GIT_BRANCH)
+      },
+      system: {
+        openDialog: (options) => electron.ipcRenderer.invoke(IPC_CHANNELS.SYSTEM_OPEN_DIALOG, options),
+        getPath: (name) => electron.ipcRenderer.invoke(IPC_CHANNELS.SYSTEM_GET_PATH, name),
+        getPathForFile: (file) => electron.webUtils.getPathForFile(file),
+        pathKind: (path) => electron.ipcRenderer.invoke(IPC_CHANNELS.SYSTEM_PATH_KIND, path),
+        platform: process.platform,
+        openExternal: (url) => electron.ipcRenderer.invoke(IPC_CHANNELS.SYSTEM_OPEN_EXTERNAL, url),
+        hallUrl: () => electron.ipcRenderer.invoke(IPC_CHANNELS.SYSTEM_HALL_URL),
+        fleet: () => electron.ipcRenderer.invoke(IPC_CHANNELS.FLEET_LIST),
+        getVersion: () => electron.ipcRenderer.invoke(IPC_CHANNELS.SYSTEM_GET_VERSION)
+      },
+      activity: {
+        getStats: () => electron.ipcRenderer.invoke(IPC_CHANNELS.ACTIVITY_GET_STATS)
+      },
+      workflows: {
+        list: () => electron.ipcRenderer.invoke(IPC_CHANNELS.WORKFLOW_LIST),
+        getRun: (workspaceId, runId) => electron.ipcRenderer.invoke(IPC_CHANNELS.WORKFLOW_GET_RUN, workspaceId, runId),
+        control: (workspaceId, runId, action) => electron.ipcRenderer.invoke(IPC_CHANNELS.WORKFLOW_CONTROL, workspaceId, runId, action),
+        setPersistAgentSessions: (enabled) => electron.ipcRenderer.invoke(IPC_CHANNELS.WORKFLOW_SET_PERSISTENCE, enabled)
+      },
+      diagnostics: {
+        get: () => electron.ipcRenderer.invoke(IPC_CHANNELS.DIAGNOSTICS_GET)
+      },
+      updates: {
+        check: () => electron.ipcRenderer.invoke(IPC_CHANNELS.UPDATE_CHECK)
+      },
+      i18n: {
+        getEnvironment: () => electron.ipcRenderer.invoke(IPC_CHANNELS.I18N_GET_ENVIRONMENT)
+      },
+      terminal: {
+        start: (options) => electron.ipcRenderer.invoke(IPC_CHANNELS.TERMINAL_START, options),
+        input: (data) => electron.ipcRenderer.invoke(IPC_CHANNELS.TERMINAL_INPUT, data),
+        resize: (cols, rows) => electron.ipcRenderer.invoke(IPC_CHANNELS.TERMINAL_RESIZE, { cols, rows }),
+        stop: () => electron.ipcRenderer.invoke(IPC_CHANNELS.TERMINAL_STOP),
+        onData: (callback) => {
+          const handler = (_event, data) => callback(data);
+          electron.ipcRenderer.on(IPC_CHANNELS.EVENT_TERMINAL_DATA, handler);
+          return () => electron.ipcRenderer.removeListener(IPC_CHANNELS.EVENT_TERMINAL_DATA, handler);
+        },
+        onExit: (callback) => {
+          const handler = (_event, data) => callback(data);
+          electron.ipcRenderer.on(IPC_CHANNELS.EVENT_TERMINAL_EXIT, handler);
+          return () => electron.ipcRenderer.removeListener(IPC_CHANNELS.EVENT_TERMINAL_EXIT, handler);
+        }
+      },
+      ui: {
+        respondSelect: (id, value) => electron.ipcRenderer.invoke(IPC_CHANNELS.UI_SELECT_RESPONSE, id, value),
+        respondConfirm: (id, confirmed) => electron.ipcRenderer.invoke(IPC_CHANNELS.UI_CONFIRM_RESPONSE, id, confirmed),
+        respondInput: (id, value) => electron.ipcRenderer.invoke(IPC_CHANNELS.UI_INPUT_RESPONSE, id, value),
+        respondEditor: (id, value) => electron.ipcRenderer.invoke(IPC_CHANNELS.UI_EDITOR_RESPONSE, id, value),
+        flushPendingPrompts: (workspaceId) => electron.ipcRenderer.invoke(IPC_CHANNELS.UI_PENDING_FLUSH, workspaceId),
+        getPendingPrompts: () => electron.ipcRenderer.invoke(IPC_CHANNELS.UI_PENDING_GET),
+        setEditorDirty: (dirty, fileName) => electron.ipcRenderer.send(
+          IPC_CHANNELS.UI_EDITOR_DIRTY_SET,
+          dirty === true,
+          typeof fileName === "string" ? fileName : null
+        )
+      },
+      onEvent: (callback) => {
+        const handler = (_event, data) => callback(data);
+        electron.ipcRenderer.on(IPC_CHANNELS.EVENT_PI, handler);
+        return () => {
+          electron.ipcRenderer.removeListener(IPC_CHANNELS.EVENT_PI, handler);
+        };
+      },
+      onPendingPrompts: (callback) => {
+        const handler = (_event, data) => callback(data);
+        electron.ipcRenderer.on(IPC_CHANNELS.EVENT_PENDING_PROMPTS, handler);
+        return () => {
+          electron.ipcRenderer.removeListener(IPC_CHANNELS.EVENT_PENDING_PROMPTS, handler);
+        };
+      },
+      onWorkspaceActivity: (callback) => {
+        const handler = (_event, data) => callback(data);
+        electron.ipcRenderer.on(IPC_CHANNELS.EVENT_WORKSPACE_ACTIVITY, handler);
+        return () => {
+          electron.ipcRenderer.removeListener(IPC_CHANNELS.EVENT_WORKSPACE_ACTIVITY, handler);
+        };
+      },
+      onSessionRuntime: (callback) => {
+        const handler = (_event, data) => callback(data);
+        electron.ipcRenderer.on(IPC_CHANNELS.EVENT_SESSION_RUNTIME, handler);
+        return () => {
+          electron.ipcRenderer.removeListener(IPC_CHANNELS.EVENT_SESSION_RUNTIME, handler);
+        };
+      },
+      onActivateWorkspace: (callback) => {
+        const handler = (_event, data) => callback(data);
+        electron.ipcRenderer.on(IPC_CHANNELS.EVENT_ACTIVATE_WORKSPACE, handler);
+        return () => {
+          electron.ipcRenderer.removeListener(IPC_CHANNELS.EVENT_ACTIVATE_WORKSPACE, handler);
+        };
+      },
+      onFileChange: (callback) => {
+        const handler = (_event, data) => callback(data);
+        electron.ipcRenderer.on(IPC_CHANNELS.EVENT_FILE_CHANGE, handler);
+        return () => {
+          electron.ipcRenderer.removeListener(IPC_CHANNELS.EVENT_FILE_CHANGE, handler);
+        };
+      },
+      onMenuAction: (callback) => {
+        const handlers = [];
+        const actions = ["menu:new-session", "menu:new-workspace", "menu:open-project"];
+        for (const action of actions) {
+          const handler = () => callback(action);
+          electron.ipcRenderer.on(action, handler);
+          handlers.push(() => electron.ipcRenderer.removeListener(action, handler));
+        }
+        return () => {
+          for (const cleanup of handlers) cleanup();
+        };
+      }
+    };
+    return api;
+  }
+  return createHttpBridge();
+}
+const bridge = createBridge();
+electron.contextBridge.exposeInMainWorld("piDesktop", bridge);