@ashx-j/lunr 0.2.25 → 0.2.27

package/dist/node-runtime/{package-manager-cli-VYZM5WHN.js → package-manager-cli-CYM262SI.js}

@@ -2,51 +2,52 @@ import { createRequire as __lunrRequire } from "node:module"; const require = __
 import {
   createProjectTrustContext,
   resolveProjectTrusted
-} from "./chunk-7S3T6YEA.js";
-import "./chunk-2HHLJWGD.js";
+} from "./chunk-R4WSB2MQ.js";
+import "./chunk-IHHTWSXN.js";
 import "./chunk-YPHAIRZT.js";
 import {
   DefaultResourceLoader
-} from "./chunk-YCUZEGJG.js";
+} from "./chunk-DQSCFU7R.js";
 import {
   DefaultPackageManager
-} from "./chunk-LQP3RB67.js";
+} from "./chunk-UYRKUKFE.js";
 import "./chunk-OBMWP3I5.js";
 import "./chunk-DVGWF6A2.js";
-import "./chunk-QFWG2RVL.js";
+import "./chunk-IXG6F4NT.js";
 import {
   SettingsManager
-} from "./chunk-6XL67VVY.js";
-import "./chunk-UOEDI7RP.js";
-import "./chunk-2HMIRK7W.js";
+} from "./chunk-HUD2RFJW.js";
+import "./chunk-4KNKQGHM.js";
+import "./chunk-LHV3V67B.js";
 import {
   ProjectTrustStore,
   hasTrustRequiringProjectResources
-} from "./chunk-HTFRRDSF.js";
+} from "./chunk-F2SMQ6ES.js";
 import "./chunk-URD2SLIT.js";
-import "./chunk-GJ2RDBRL.js";
+import "./chunk-BYC6RKCN.js";
 import "./chunk-CGBXPL3E.js";
-import "./chunk-M3LZLQW2.js";
+import "./chunk-BDRGN3L2.js";
+import "./chunk-FY4A63RK.js";
 import "./chunk-UJOCPOMX.js";
 import "./chunk-IMLCWLPI.js";
-import "./chunk-5EFIU3OM.js";
+import "./chunk-FTKEZL27.js";
 import "./chunk-PVCDKGR6.js";
-import "./chunk-B4HP6ZWM.js";
-import "./chunk-QH6YL7VK.js";
-import "./chunk-HMBGROQK.js";
+import "./chunk-RHCGYWO7.js";
+import "./chunk-252ZVPPF.js";
+import "./chunk-GLDXBBL6.js";
 import "./chunk-I6R76AG7.js";
 import {
   DynamicBorder
-} from "./chunk-6VYZ5UFP.js";
+} from "./chunk-FLGEEH27.js";
 import {
   keyHint,
   rawKeyHint
-} from "./chunk-GS42T6MX.js";
+} from "./chunk-QW3AAHWN.js";
 import {
   initTheme,
   stopThemeWatcher,
   theme
-} from "./chunk-RDDAZOMU.js";
+} from "./chunk-JL4HYQXK.js";
 import {
   APP_NAME,
   CONFIG_DIR_NAME,
@@ -54,7 +55,7 @@ import {
   getAgentDir,
   isLocalPath,
   resolvePath
-} from "./chunk-FQMM2EZ2.js";
+} from "./chunk-64XTQNLA.js";
 import "./chunk-Q4Q6D4IY.js";
 import "./chunk-BRJX2PRC.js";
 

package/dist/node-runtime/{parallel-AI2MNSCU.js → parallel-X724NCNU.js}

@@ -1,7 +1,7 @@
 import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
 import {
   activityMonitor
-} from "./chunk-DAPBPCBP.js";
+} from "./chunk-IPP5BIV5.js";
 import {
   getWebSearchConfigPath
 } from "./chunk-VRB2IYGG.js";

package/dist/node-runtime/{perplexity-QVJW3I35.js → perplexity-RDHQHVMK.js}

@@ -2,8 +2,8 @@ import { createRequire as __lunrRequire } from "node:module"; const require = __
 import {
   isPerplexityAvailable,
   searchWithPerplexity
-} from "./chunk-XBWPBZBN.js";
-import "./chunk-DAPBPCBP.js";
+} from "./chunk-2SWW7KMW.js";
+import "./chunk-IPP5BIV5.js";
 import "./chunk-VRB2IYGG.js";
 import "./chunk-BRJX2PRC.js";
 export {

package/dist/node-runtime/{pi-intercom-QM53RLTS.js → pi-intercom-NHHEPBMI.js}

@@ -1876,7 +1876,7 @@ ${replyText}${replyAttachments}` }],
   }), nativeSupervisorChannel || pi.registerTool({
     name: "intercom",
     label: "Intercom",
-    description: `Send a message to another pi session running on this machine.
+    description: `Send a message to another lunR session running on this machine.
 Use this to communicate findings, request help, or coordinate work with other sessions.
 
 Usage:
@@ -1886,7 +1886,7 @@ Usage:
   intercom({ action: "reply", message: "..." })                      \u2192 Reply to the active/single pending ask
   intercom({ action: "pending" })                                      \u2192 List unresolved inbound asks
   intercom({ action: "status" })                  \u2192 Show connection status`,
-    promptSnippet: "Use to coordinate with other local pi sessions: list peers, send updates, ask for help, or check intercom connectivity.",
+    promptSnippet: "Use to coordinate with other local lunR sessions: list peers, send updates, ask for help, or check intercom connectivity.",
     parameters: Type.Object({
       action: StringEnum(["list", "send", "ask", "reply", "pending", "status"], {
         description: "Action: 'list', 'send', 'ask', 'reply', 'pending', or 'status'"

package/dist/node-runtime/{pi-mcp-adapter-5UKBZP44.js → pi-mcp-adapter-PP3GQJQ2.js}

@@ -11,8 +11,7 @@ import {
   resolveDirectTools,
   throwIfAborted,
   truncateAtWord
-} from "./chunk-LWYIVUGV.js";
-import "./chunk-4HXHDDCF.js";
+} from "./chunk-B2IBAXNX.js";
 import "./chunk-ARC4KOTI.js";
 import "./chunk-BRJX2PRC.js";
 
@@ -120,13 +119,12 @@ function mcpAdapter(pi) {
   let state = null, initPromise = null, lifecycleGeneration = 0, sessionAbort = new AbortController(), initializingStates = /* @__PURE__ */ new Set(), shutdownPromises = /* @__PURE__ */ new WeakMap(), heavyModules = null, heavyModulesPromise = null, directExecutors = /* @__PURE__ */ new Map();
   function loadHeavyModules() {
     return heavyModules ? Promise.resolve(heavyModules) : (heavyModulesPromise || (heavyModulesPromise = (async () => {
-      let [init, authFlow, commands, proxyModes, directToolExecutor] = await Promise.all([
-        import("./init-HS6NQXSK.js"),
-        import("./mcp-auth-flow-QIXHW6QN.js"),
-        import("./commands-NZLSOHPE.js"),
-        import("./proxy-modes-LGEUYD7R.js"),
-        import("./direct-tool-executor-77GW4F5P.js")
-      ]), loaded = { init, authFlow, commands, proxyModes, directToolExecutor };
+      let [init, commands, proxyModes, directToolExecutor] = await Promise.all([
+        import("./init-JBQJIPYI.js"),
+        import("./commands-D6A6H4TS.js"),
+        import("./proxy-modes-VEGC6QG5.js"),
+        import("./direct-tool-executor-2QJXVQD2.js")
+      ]), loaded = { init, commands, proxyModes, directToolExecutor };
       return heavyModules = loaded, loaded;
     })().catch((error) => {
       throw heavyModulesPromise = null, error;
@@ -139,7 +137,7 @@ function mcpAdapter(pi) {
     if (existing)
       return existing;
     let shutdown = (async () => {
-      currentState.uiServer && (currentState.uiServer.close(reason), currentState.uiServer = null);
+      await currentState.authFlow.shutdown(), currentState.uiServer && (currentState.uiServer.close(reason), currentState.uiServer = null);
       let flushError;
       try {
         heavyModules && heavyModules.init.flushMetadataCache(currentState);
@@ -163,17 +161,10 @@ function mcpAdapter(pi) {
     let pending = [...initializingStates];
     initializingStates.clear(), await Promise.all(pending.map((entry) => shutdownState(entry, "initialization_cancelled")));
   }
-  async function shutdownLoadedRuntime() {
-    heavyModules && await heavyModules.authFlow.shutdownOAuth();
-  }
   async function runInitialize(generation, sessionPi, ctx) {
     let signal = sessionAbort.signal, heavy = await loadHeavyModules();
     if (throwIfAborted(signal), generation !== lifecycleGeneration)
       throw new Error("MCP initialization aborted (session changed)");
-    if (await heavy.authFlow.initializeOAuth().catch((err) => {
-      console.error("MCP OAuth initialization failed:", err);
-    }), generation !== lifecycleGeneration)
-      throw new Error("MCP initialization aborted (session changed)");
     let partial;
     try {
       let initialized = await heavy.init.initializeMcp(sessionPi, ctx, {
@@ -228,7 +219,10 @@ function mcpAdapter(pi) {
   }
   function createLazyDirectToolExecute(spec) {
     return async function(toolCallId, params, incomingSignal, onUpdate, ctx) {
-      let signal = incomingSignal ? AbortSignal.any([incomingSignal, sessionAbort.signal]) : sessionAbort.signal, currentState;
+      let signal = incomingSignal ? AbortSignal.any([incomingSignal, sessionAbort.signal]) : sessionAbort.signal, currentSpec = currentDirectSpecs.get(spec.prefixedName);
+      if (!currentSpec || JSON.stringify(currentSpec) !== JSON.stringify(spec))
+        throw new Error("MCP tool is unavailable in the current trusted configuration");
+      let currentState;
       try {
         currentState = await ensureState(pi, ctx, signal);
       } catch (error) {
@@ -244,19 +238,28 @@ function mcpAdapter(pi) {
       return executor || (executor = heavy.directToolExecutor.createDirectToolExecutor(() => currentState, () => null, spec), directExecutors.set(spec.prefixedName, executor)), executor(toolCallId, params, signal, onUpdate, ctx);
     };
   }
-  let earlyConfigPath = getConfigPathFromArgv(), earlyConfig = loadMcpConfig(earlyConfigPath), earlyCache = loadMetadataCache(), prefix = earlyConfig.settings?.toolPrefix ?? "server", envRaw = process.env.MCP_DIRECT_TOOLS, directSpecs = envRaw === "__none__" ? [] : resolveDirectTools(earlyConfig, earlyCache, prefix, envRaw?.split(",").map((s) => s.trim()).filter(Boolean)), missingConfiguredDirectToolServers = getMissingConfiguredDirectToolServers(earlyConfig, earlyCache), shouldRegisterProxyTool = earlyConfig.settings?.disableProxyTool !== !0 || directSpecs.length === 0 || missingConfiguredDirectToolServers.length > 0;
-  for (let spec of directSpecs)
-    pi.registerTool({
-      name: spec.prefixedName,
-      label: `MCP: ${spec.originalName}`,
-      description: `${spec.description || "(no description)"}
+  let earlyConfigPath = getConfigPathFromArgv(), earlyConfig = loadMcpConfig(earlyConfigPath), earlyCache = loadMetadataCache(), registeredDirectTools = /* @__PURE__ */ new Map(), currentDirectSpecs = /* @__PURE__ */ new Map();
+  function registerConfiguredTools(config, cache) {
+    let prefix = config.settings?.toolPrefix ?? "server", envRaw = process.env.MCP_DIRECT_TOOLS, directSpecs = envRaw === "__none__" ? [] : resolveDirectTools(config, cache, prefix, envRaw?.split(",").map((s) => s.trim()).filter(Boolean));
+    currentDirectSpecs = new Map(directSpecs.map((spec) => [spec.prefixedName, spec]));
+    let missingConfiguredDirectToolServers = getMissingConfiguredDirectToolServers(config, cache), shouldRegisterProxyTool = config.settings?.disableProxyTool !== !0 || directSpecs.length === 0 || missingConfiguredDirectToolServers.length > 0;
+    for (let spec of directSpecs) {
+      let fingerprint = JSON.stringify(spec);
+      registeredDirectTools.get(spec.prefixedName) !== fingerprint && (registeredDirectTools.set(spec.prefixedName, fingerprint), pi.registerTool({
+        name: spec.prefixedName,
+        label: `MCP: ${spec.originalName}`,
+        description: `${spec.description || "(no description)"}
 Unavailable in read-only mode; switch to yolo or auto to call.`,
-      promptSnippet: truncateAtWord(spec.description, 100) || `MCP tool from ${spec.serverName}`,
-      parameters: Type.Unsafe(normalizeDirectToolInputSchema(spec.inputSchema)),
-      execute: createLazyDirectToolExecute(spec),
-      renderCall: createMcpDirectToolCallRenderer(spec.prefixedName),
-      renderResult: renderMcpToolResult
-    });
+        promptSnippet: truncateAtWord(spec.description, 100) || `MCP tool from ${spec.serverName}`,
+        parameters: Type.Unsafe(normalizeDirectToolInputSchema(spec.inputSchema)),
+        execute: createLazyDirectToolExecute(spec),
+        renderCall: createMcpDirectToolCallRenderer(spec.prefixedName),
+        renderResult: renderMcpToolResult
+      }));
+    }
+    return shouldRegisterProxyTool && registerProxyTool(config, cache, directSpecs), { names: directSpecs.map((spec) => spec.prefixedName), proxy: shouldRegisterProxyTool };
+  }
+  registerConfiguredTools(earlyConfig, earlyCache);
   let getPiTools = () => pi.getAllTools();
   pi.registerFlag("mcp-config", {
     description: "Path to MCP config file",
@@ -269,16 +272,15 @@ Unavailable in read-only mode; switch to yolo or auto to call.`,
     try {
       await Promise.all([
         shutdownState(previousState, "session_restart"),
-        shutdownInitializingStates(),
-        shutdownLoadedRuntime()
+        shutdownInitializingStates()
       ]);
     } catch (error) {
       console.error("MCP: failed to shut down previous session state", error);
     }
     if (generation !== lifecycleGeneration)
       return;
-    let configPath = pi.getFlag("mcp-config") ?? earlyConfigPath, sessionConfig = loadMcpConfig(configPath, ctx.cwd), sessionCache = loadMetadataCache();
-    shouldBackgroundAutostart(sessionConfig, sessionCache) && startSessionInit(generation, pi, ctx);
+    let configPath = pi.getFlag("mcp-config") ?? earlyConfigPath, sessionConfig = loadMcpConfig(configPath, ctx.cwd, ctx.isProjectTrusted()), sessionCache = loadMetadataCache(), registered = registerConfiguredTools(sessionConfig, sessionCache), active = pi.getActiveTools().filter((name) => !registeredDirectTools.has(name) && name !== "mcp");
+    pi.setActiveTools([...active, ...registered.names, ...registered.proxy ? ["mcp"] : []]), shouldBackgroundAutostart(sessionConfig, sessionCache) && startSessionInit(generation, pi, ctx);
   }), pi.on("session_shutdown", async () => {
     ++lifecycleGeneration, sessionAbort.abort(new Error("MCP session ended"));
     let currentState = state;
@@ -286,8 +288,7 @@ Unavailable in read-only mode; switch to yolo or auto to call.`,
     try {
       await Promise.all([
         shutdownState(currentState, "session_shutdown"),
-        shutdownInitializingStates(),
-        shutdownLoadedRuntime()
+        shutdownInitializingStates()
       ]);
     } catch (error) {
       console.error("MCP: session shutdown cleanup failed", error);
@@ -359,70 +360,73 @@ Unavailable in read-only mode; switch to yolo or auto to call.`,
         await heavy.commands.openMcpAuthPanel(currentState, pi, ctx, earlyConfigPath);
         return;
       }
-      await heavy.commands.authenticateServer(serverName, currentState.config, ctx);
+      await heavy.commands.authenticateServer(serverName, currentState.config, ctx, currentState.authFlow);
     }
-  }), shouldRegisterProxyTool && pi.registerTool({
-    name: "mcp",
-    label: "MCP",
-    description: buildProxyDescription(earlyConfig, earlyCache, directSpecs),
-    promptSnippet: "MCP gateway - connect to MCP servers and call their tools",
-    renderCall: renderMcpProxyToolCall,
-    parameters: Type.Object({
-      tool: Type.Optional(Type.String({ description: "Tool name to call (e.g., 'xcodebuild_list_sims')" })),
-      args: Type.Optional(Type.String({ description: `Arguments as JSON string (e.g., '{"key": "value"}')` })),
-      connect: Type.Optional(Type.String({ description: "Server name to connect (lazy connect + metadata refresh)" })),
-      describe: Type.Optional(Type.String({ description: "Tool name to describe (shows parameters)" })),
-      search: Type.Optional(Type.String({ description: "Search tools by name/description" })),
-      regex: Type.Optional(Type.Boolean({ description: "Treat search as regex (default: substring match)" })),
-      includeSchemas: Type.Optional(Type.Boolean({ description: "Include parameter schemas in search results (default: true)" })),
-      server: Type.Optional(Type.String({ description: "Filter to specific server (also disambiguates tool calls)" })),
-      action: Type.Optional(Type.String({ description: "Action: 'ui-messages', 'auth-start', or 'auth-complete'" }))
-    }),
-    renderResult: renderMcpToolResult,
-    async execute(_toolCallId, params, incomingSignal, _onUpdate, ctx) {
-      let signal = incomingSignal ? AbortSignal.any([incomingSignal, sessionAbort.signal]) : sessionAbort.signal, parsedArgs;
-      if (params.args)
-        try {
-          if (parsedArgs = JSON.parse(params.args), typeof parsedArgs != "object" || parsedArgs === null || Array.isArray(parsedArgs)) {
-            let gotType = Array.isArray(parsedArgs) ? "array" : parsedArgs === null ? "null" : typeof parsedArgs;
-            throw new Error(`Invalid args: expected a JSON object, got ${gotType}`);
+  });
+  function registerProxyTool(config, cache, specs) {
+    pi.registerTool({
+      name: "mcp",
+      label: "MCP",
+      description: buildProxyDescription(config, cache, specs),
+      promptSnippet: "MCP gateway - connect to MCP servers and call their tools",
+      renderCall: renderMcpProxyToolCall,
+      parameters: Type.Object({
+        tool: Type.Optional(Type.String({ description: "Tool name to call (e.g., 'xcodebuild_list_sims')" })),
+        args: Type.Optional(Type.String({ description: `Arguments as JSON string (e.g., '{"key": "value"}')` })),
+        connect: Type.Optional(Type.String({ description: "Server name to connect (lazy connect + metadata refresh)" })),
+        describe: Type.Optional(Type.String({ description: "Tool name to describe (shows parameters)" })),
+        search: Type.Optional(Type.String({ description: "Search tools by name/description" })),
+        regex: Type.Optional(Type.Boolean({ description: "Treat search as regex (default: substring match)" })),
+        includeSchemas: Type.Optional(Type.Boolean({ description: "Include parameter schemas in search results (default: true)" })),
+        server: Type.Optional(Type.String({ description: "Filter to specific server (also disambiguates tool calls)" })),
+        action: Type.Optional(Type.String({ description: "Action: 'ui-messages', 'auth-start', or 'auth-complete'" }))
+      }),
+      renderResult: renderMcpToolResult,
+      async execute(_toolCallId, params, incomingSignal, _onUpdate, ctx) {
+        let signal = incomingSignal ? AbortSignal.any([incomingSignal, sessionAbort.signal]) : sessionAbort.signal, parsedArgs;
+        if (params.args)
+          try {
+            if (parsedArgs = JSON.parse(params.args), typeof parsedArgs != "object" || parsedArgs === null || Array.isArray(parsedArgs)) {
+              let gotType = Array.isArray(parsedArgs) ? "array" : parsedArgs === null ? "null" : typeof parsedArgs;
+              throw new Error(`Invalid args: expected a JSON object, got ${gotType}`);
+            }
+          } catch (error) {
+            throw error instanceof SyntaxError ? new Error(`Invalid args JSON: ${error.message}`, { cause: error }) : error;
           }
+        let currentState;
+        try {
+          currentState = await ensureState(pi, ctx, signal);
         } catch (error) {
-          throw error instanceof SyntaxError ? new Error(`Invalid args JSON: ${error.message}`, { cause: error }) : error;
-        }
-      let currentState;
-      try {
-        currentState = await ensureState(pi, ctx, signal);
-      } catch (error) {
-        let message = error instanceof Error ? error.message : String(error);
-        return {
-          content: [{ type: "text", text: `MCP initialization failed: ${message}` }],
-          details: { error: "init_failed", message }
-        };
-      }
-      let heavy = await loadHeavyModules();
-      if (throwIfAborted(signal), assertCurrentState(currentState), params.action === "ui-messages")
-        return heavy.proxyModes.executeUiMessages(currentState);
-      if (params.action === "auth-start")
-        return params.server ? heavy.proxyModes.executeAuthStart(currentState, params.server) : {
-          content: [{ type: "text", text: 'auth-start requires `server`. Example: mcp({ action: "auth-start", server: "linear-server" })' }],
-          details: { mode: "auth-start", error: "missing_server" }
-        };
-      if (params.action === "auth-complete") {
-        if (!params.server)
+          let message = error instanceof Error ? error.message : String(error);
           return {
-            content: [{ type: "text", text: "auth-complete requires `server`." }],
-            details: { mode: "auth-complete", error: "missing_server" }
+            content: [{ type: "text", text: `MCP initialization failed: ${message}` }],
+            details: { error: "init_failed", message }
+          };
+        }
+        let heavy = await loadHeavyModules();
+        if (throwIfAborted(signal), assertCurrentState(currentState), params.action === "ui-messages")
+          return heavy.proxyModes.executeUiMessages(currentState);
+        if (params.action === "auth-start")
+          return params.server ? heavy.proxyModes.executeAuthStart(currentState, params.server) : {
+            content: [{ type: "text", text: 'auth-start requires `server`. Example: mcp({ action: "auth-start", server: "linear-server" })' }],
+            details: { mode: "auth-start", error: "missing_server" }
           };
-        let input = parsedArgs?.redirectUrl ?? parsedArgs?.code ?? parsedArgs?.input;
-        return typeof input != "string" || input.trim().length === 0 ? {
-          content: [{ type: "text", text: "auth-complete requires args with `redirectUrl`, `code`, or `input`." }],
-          details: { mode: "auth-complete", error: "missing_input" }
-        } : heavy.proxyModes.executeAuthComplete(currentState, params.server, input);
+        if (params.action === "auth-complete") {
+          if (!params.server)
+            return {
+              content: [{ type: "text", text: "auth-complete requires `server`." }],
+              details: { mode: "auth-complete", error: "missing_server" }
+            };
+          let input = parsedArgs?.redirectUrl ?? parsedArgs?.code ?? parsedArgs?.input;
+          return typeof input != "string" || input.trim().length === 0 ? {
+            content: [{ type: "text", text: "auth-complete requires args with `redirectUrl`, `code`, or `input`." }],
+            details: { mode: "auth-complete", error: "missing_input" }
+          } : heavy.proxyModes.executeAuthComplete(currentState, params.server, input);
+        }
+        return params.tool ? heavy.proxyModes.executeCall(currentState, params.tool, parsedArgs, params.server, getPiTools, signal) : params.connect ? heavy.proxyModes.executeConnect(currentState, params.connect, signal) : params.describe ? heavy.proxyModes.executeDescribe(currentState, params.describe) : params.search ? heavy.proxyModes.executeSearch(currentState, params.search, params.regex, params.server, params.includeSchemas) : params.server ? heavy.proxyModes.executeList(currentState, params.server) : heavy.proxyModes.executeStatus(currentState);
       }
-      return params.tool ? heavy.proxyModes.executeCall(currentState, params.tool, parsedArgs, params.server, getPiTools, signal) : params.connect ? heavy.proxyModes.executeConnect(currentState, params.connect, signal) : params.describe ? heavy.proxyModes.executeDescribe(currentState, params.describe) : params.search ? heavy.proxyModes.executeSearch(currentState, params.search, params.regex, params.server, params.includeSchemas) : params.server ? heavy.proxyModes.executeList(currentState, params.server) : heavy.proxyModes.executeStatus(currentState);
-    }
-  });
+    });
+  }
 }
 export {
   mcpAdapter as default

package/dist/node-runtime/{pi-ollama-cloud-2F3Y2QNM.js → pi-ollama-cloud-4MNWIMFN.js}

@@ -1,7 +1,7 @@
 import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
 import {
   getAgentDir
-} from "./chunk-FQMM2EZ2.js";
+} from "./chunk-64XTQNLA.js";
 import "./chunk-Q4Q6D4IY.js";
 import "./chunk-BRJX2PRC.js";
 
@@ -1301,23 +1301,9 @@ function writeCache(models) {
   } catch {
   }
 }
-function resolveOllamaApiKey() {
-  let envKey = process.env.OLLAMA_API_KEY?.trim();
-  if (envKey)
-    return envKey;
-  try {
-    let raw = readFileSync(join(getAgentDir(), "auth.json"), "utf-8"), cred = JSON.parse(raw)["ollama-cloud"];
-    if (cred?.type === "api_key" && typeof cred.key == "string") {
-      let key = cred.key.trim();
-      if (key)
-        return key;
-    }
-  } catch {
-  }
-}
-async function fetchModelIds(timeoutMs = FETCH_TIMEOUT_MS) {
-  let headers = {}, apiKey = resolveOllamaApiKey();
-  apiKey && (headers.Authorization = `Bearer ${apiKey}`);
+async function fetchModelIds(auth, timeoutMs = FETCH_TIMEOUT_MS) {
+  let headers = { ...auth.headers }, apiKey = auth.apiKey;
+  apiKey && !Object.keys(headers).some((name) => name.toLowerCase() === "authorization") && (headers.Authorization = `Bearer ${apiKey}`);
   let res = await fetchJsonWithTimeout(`${OLLAMA_BASE}/v1/models`, { headers }, timeoutMs);
   if (res.status === 429)
     throw new Error("Ollama Cloud rate limited. Try again shortly.");
@@ -1325,9 +1311,9 @@ async function fetchModelIds(timeoutMs = FETCH_TIMEOUT_MS) {
     throw new Error(`Failed to fetch model list: ${res.status}${res.error ? ` - ${res.error}` : ""}`);
   return res.data.data.map((m) => m.id);
 }
-async function fetchModelDetails(id, timeoutMs = FETCH_TIMEOUT_MS) {
-  let headers = { "Content-Type": "application/json" }, apiKey = resolveOllamaApiKey();
-  apiKey && (headers.Authorization = `Bearer ${apiKey}`);
+async function fetchModelDetails(id, auth, timeoutMs = FETCH_TIMEOUT_MS) {
+  let headers = { "Content-Type": "application/json", ...auth.headers }, apiKey = auth.apiKey;
+  apiKey && !Object.keys(headers).some((name) => name.toLowerCase() === "authorization") && (headers.Authorization = `Bearer ${apiKey}`);
   let res = await fetchJsonWithTimeout(`${OLLAMA_BASE}/api/show`, {
     method: "POST",
     headers,
@@ -1343,14 +1329,14 @@ async function refreshOllamaCloudModels(params) {
   let notify = params.notify ?? (() => {
   }), onProgress = params.onProgress ?? (() => {
   });
-  if (!resolveOllamaApiKey())
+  if (!params.auth?.apiKey && !Object.entries(params.auth?.headers ?? {}).some(([name, value]) => name.toLowerCase() === "authorization" && value))
     return notify("Ollama Cloud skipped (no API key)"), {};
   onProgress({ stage: "list", message: "Fetching model list..." });
-  let modelIds = await fetchModelIds();
+  let modelIds = await fetchModelIds(params.auth ?? {});
   notify(`Found ${modelIds.length} models, fetching details...`), onProgress({ stage: "details", current: 0, total: modelIds.length, failed: 0, message: "Fetching model details" });
   let detailsDone = 0, detailsFailed = 0, detailResults = await concurrentMap(modelIds, params.workers ?? 8, async (id) => {
     try {
-      return [id, await fetchModelDetails(id)];
+      return [id, await fetchModelDetails(id, params.auth ?? {})];
     } catch (error) {
       throw detailsFailed++, error;
     } finally {
@@ -1381,6 +1367,7 @@ async function refreshOllamaCloudModels(params) {
 async function fetchModels(ctx, onProgress) {
   try {
     return await refreshOllamaCloudModels({
+      auth: ctx.auth,
       notify: (message, level) => ctx.ui.notify(message, level),
       onProgress
     });

package/dist/node-runtime/{pi-prompt-template-model-QWTCGLJU.js → pi-prompt-template-model-FTGELLS5.js}

@@ -1,14 +1,15 @@
 import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
 import {
+  getPromptResources,
   parseFrontmatter
-} from "./chunk-QFWG2RVL.js";
+} from "./chunk-IXG6F4NT.js";
 import {
   minimatch
 } from "./chunk-CGBXPL3E.js";
 import {
   CONFIG_DIR_NAME,
   getAgentDir
-} from "./chunk-FQMM2EZ2.js";
+} from "./chunk-64XTQNLA.js";
 import "./chunk-Q4Q6D4IY.js";
 import "./chunk-BRJX2PRC.js";
 
@@ -1059,6 +1060,8 @@ import { homedir } from "node:os";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 var VALID_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"], RESERVED_COMMAND_NAMES = /* @__PURE__ */ new Set([
   "chain-prompts",
+  "chain-workflows",
+  "prompt-workflow",
   "prompt-tool",
   "settings",
   "model",
@@ -1859,8 +1862,8 @@ function loadPromptsWithModelFromConfiguredPath(configuredPath, includePlainProm
   }
   return stats.isDirectory() ? loadPromptsWithModelFromDir(resolvedPath, source, includePlainPrompts, "", /* @__PURE__ */ new Set(), void 0, seenFiles, shouldLoadFile) : !stats.isFile() || !resolvedPath.endsWith(".md") ? (diagnostics.push(createDiagnostic("invalid-prompt-path", resolvedPath, source, `Skipping configured prompt path ${JSON.stringify(rawPath)} from ${settingsPath}: expected a directory or .md file.`)), { prompts: [], diagnostics }) : loadPromptsWithModelFromDir(dirname(resolvedPath), source, includePlainPrompts, "", /* @__PURE__ */ new Set(), basename(resolvedPath), seenFiles, shouldLoadFile);
 }
-function loadPromptsWithModel(cwd, includePlainPrompts = !1) {
-  let agentDir = getAgentDir(), globalDir = join(agentDir, "prompts"), projectBaseDir = resolve(cwd, CONFIG_DIR_NAME), projectDir = join(projectBaseDir, "prompts"), promptMap = /* @__PURE__ */ new Map(), diagnostics = [], seenPromptFiles = /* @__PURE__ */ new Set();
+function loadPromptsWithModel(cwd, includePlainPrompts = !1, view) {
+  let agentDir = view?.agentDir ?? getAgentDir(), globalDir = join(agentDir, "prompts"), projectBaseDir = resolve(cwd, CONFIG_DIR_NAME), projectDir = join(projectBaseDir, "prompts"), promptMap = /* @__PURE__ */ new Map(), diagnostics = [], seenPromptFiles = /* @__PURE__ */ new Set();
   function addPrompt(prompt) {
     let existing = promptMap.get(prompt.name);
     if (!existing) {
@@ -1874,13 +1877,20 @@ function loadPromptsWithModel(cwd, includePlainPrompts = !1) {
     for (let prompt of result.prompts)
       addPrompt(prompt);
   }
-  let projectSettingsPaths = loadConfiguredPromptPaths(join(projectBaseDir, "settings.json"), "project", projectBaseDir, diagnostics), globalSettingsPaths = loadConfiguredPromptPaths(join(agentDir, "settings.json"), "user", agentDir, diagnostics), projectDefaultFilter = createPromptFileFilter(projectSettingsPaths.patterns.filter(isSettingsPromptOverridePattern), projectBaseDir), globalDefaultFilter = createPromptFileFilter(globalSettingsPaths.patterns.filter(isSettingsPromptOverridePattern), agentDir);
-  for (let configuredPath of projectSettingsPaths.paths)
-    addResult(loadPromptsWithModelFromConfiguredPath(configuredPath, includePlainPrompts, seenPromptFiles));
-  addResult(loadPromptsWithModelFromDir(projectDir, "project", includePlainPrompts, "", /* @__PURE__ */ new Set(), void 0, seenPromptFiles, projectDefaultFilter));
-  for (let configuredPath of globalSettingsPaths.paths)
-    addResult(loadPromptsWithModelFromConfiguredPath(configuredPath, includePlainPrompts, seenPromptFiles));
-  return addResult(loadPromptsWithModelFromDir(globalDir, "user", includePlainPrompts, "", /* @__PURE__ */ new Set(), void 0, seenPromptFiles, globalDefaultFilter)), { prompts: promptMap, diagnostics };
+  if (view?.includeDiscovery) {
+    let projectSettingsPaths = view?.projectTrusted ? loadConfiguredPromptPaths(join(projectBaseDir, "settings.json"), "project", projectBaseDir, diagnostics) : { paths: [], patterns: [] }, globalSettingsPaths = loadConfiguredPromptPaths(join(agentDir, "settings.json"), "user", agentDir, diagnostics), projectDefaultFilter = createPromptFileFilter(projectSettingsPaths.patterns.filter(isSettingsPromptOverridePattern), projectBaseDir), globalDefaultFilter = createPromptFileFilter(globalSettingsPaths.patterns.filter(isSettingsPromptOverridePattern), agentDir);
+    for (let configuredPath of projectSettingsPaths.paths)
+      addResult(loadPromptsWithModelFromConfiguredPath(configuredPath, includePlainPrompts, seenPromptFiles));
+    view?.projectTrusted && addResult(loadPromptsWithModelFromDir(projectDir, "project", includePlainPrompts, "", /* @__PURE__ */ new Set(), void 0, seenPromptFiles, projectDefaultFilter));
+    for (let configuredPath of globalSettingsPaths.paths)
+      addResult(loadPromptsWithModelFromConfiguredPath(configuredPath, includePlainPrompts, seenPromptFiles));
+    addResult(loadPromptsWithModelFromDir(globalDir, "user", includePlainPrompts, "", /* @__PURE__ */ new Set(), void 0, seenPromptFiles, globalDefaultFilter));
+  }
+  for (let resource of view?.resources ?? []) {
+    let source = resource.sourceInfo.scope === "project" ? "project" : "user";
+    addResult(loadPromptsWithModelFromDir(dirname(resource.filePath), source, includePlainPrompts, "", /* @__PURE__ */ new Set(), basename(resource.filePath), seenPromptFiles));
+  }
+  return { prompts: promptMap, diagnostics };
 }
 function effectiveLineupCount(slots) {
   return slots?.reduce((total, slot) => total + (slot.count ?? 1), 0) ?? 0;
@@ -1989,7 +1999,7 @@ function createToolManager(pi, deps) {
     toolRegistered || (toolRegistered = !0, pi.registerTool({
       name: "run-prompt",
       label: "Run Prompt",
-      description: "Run a prompt template command. Pass the template name and any arguments. Supports --loop for loops (e.g. 'deslop --loop 5', 'deslop --loop=5', 'deslop --loop' for unlimited until convergence with a 999-iteration cap), --fresh for context collapse between iterations, and --no-converge to disable early stopping for bounded loops. Supports runtime delegation override via --subagent, --subagent=<name>, or --subagent:<name>. Use 'chain-prompts template1 -> template2' for chaining and add --chain-context to pass previous step summaries into delegated steps.",
+      description: "Queue a prompt template command to execute when the current turn ends. Pass the template name and any arguments. A queued result confirms acceptance, not completion. Rejected requests fail without changing the queue; wait for queued or running work to finish before retrying. Supports --loop for loops (e.g. 'deslop --loop 5', 'deslop --loop=5', 'deslop --loop' for unlimited until convergence with a 999-iteration cap), --fresh for context collapse between iterations, and --no-converge to disable early stopping for bounded loops. Supports runtime delegation override via --subagent, --subagent=<name>, or --subagent:<name>. Use 'chain-prompts template1 -> template2' for chaining and add --chain-context to pass previous step summaries into delegated steps.",
       promptSnippet: "Use this to run slash/prompt templates by name with args (including --loop/--fresh and chain-prompts flows) when the user asks to execute a prompt template.",
       parameters: Type.Object({
         command: Type.String({
@@ -1998,33 +2008,19 @@ function createToolManager(pi, deps) {
       }),
       execute: async (_id, params) => {
         if (!toolEnabled)
-          return {
-            content: [{ type: "text", text: "run-prompt tool is disabled. User must run `/prompt-tool on` to enable." }],
-            details: {}
-          };
+          throw new Error("run-prompt tool is disabled. User must run `/prompt-tool on` to enable.");
         if (deps.isActive())
-          return {
-            content: [{ type: "text", text: "A prompt command is already running. Wait for it to complete." }],
-            details: {}
-          };
+          throw new Error("A prompt command is already running. Wait for it to complete.");
         if (!deps.getStoredCtx())
-          return {
-            content: [{ type: "text", text: "No command context. Run any prompt command first to initialize." }],
-            details: {},
-            isError: !0
-          };
+          throw new Error("No command context. Run any prompt command first to initialize.");
         let commandParam = params.command, command = typeof commandParam == "string" ? commandParam.trim() : "";
-        return command ? toolQueuedCommand ? {
-          content: [{ type: "text", text: "A prompt command is already queued. Wait for it to execute." }],
-          details: {},
-          isError: !0
-        } : (toolQueuedCommand = command, {
+        if (!command)
+          throw new Error("No command specified.");
+        if (toolQueuedCommand)
+          throw new Error("A prompt command is already queued. Wait for it to execute.");
+        return toolQueuedCommand = command, {
           content: [{ type: "text", text: `Prompt command queued: "${command}". Will execute when this turn ends.` }],
           details: {}
-        }) : {
-          content: [{ type: "text", text: "No command specified." }],
-          details: {},
-          isError: !0
         };
       }
     }));
@@ -3021,7 +3017,7 @@ function promptModelExtension(pi) {
     });
   }
   function refreshPrompts(cwd, ctx) {
-    let result = loadPromptsWithModel(cwd), chainResult = loadPromptsWithModel(cwd, !0);
+    let resources = getPromptResources(pi.events), result = loadPromptsWithModel(cwd, !1, resources), chainResult = loadPromptsWithModel(cwd, !0, resources);
     prompts = result.prompts, chainPrompts = chainResult.prompts;
     for (let name of prompts.keys())
       registerPromptCommand(name);
@@ -3935,7 +3931,7 @@ You are on ${iterText} of the same prompt. Previous iterations and their results
     await runSharedChainExecution(steps, sharedArgs, loop ? loop.loopCount : 1, loop?.fresh === !0, loop?.converge ?? !0, !0, ctx, subagent.override, runtimeCwd, extracted.chainContext, !1, worktreeExtraction.worktree);
   }
   toolManager.isEnabled() && toolManager.ensureRegistered(), pi.registerCommand("chain-prompts", {
-    description: "Chain prompt templates sequentially [template -> template -> ...]",
+    description: "Chain prompt templates sequentially: /chain-prompts analyze -> fix [--loop N] [--chain-context]",
     handler: async (args, ctx) => {
       await runChainCommand(args, ctx);
     }