gsd-pi 2.58.0 → 2.59.0-dev.023bd39

package/dist/resources/extensions/ollama/ollama-tool.js

@@ -0,0 +1,184 @@
+// GSD2 — LLM-callable Ollama management tool
+/**
+ * Registers an ollama_manage tool that the LLM can call to interact
+ * with the local Ollama instance — list models, pull new ones, check status.
+ */
+import { Text } from "@gsd/pi-tui";
+import { Type } from "@sinclair/typebox";
+import * as client from "./ollama-client.js";
+import { discoverModels, formatModelForDisplay } from "./ollama-discovery.js";
+import { formatModelSize } from "./model-capabilities.js";
+export function registerOllamaTool(pi) {
+    pi.registerTool({
+        name: "ollama_manage",
+        label: "Ollama",
+        description: "Manage local Ollama models. List available models, pull new ones, " +
+            "check Ollama status, or see running models and resource usage. " +
+            "Use this when you need a specific local model that isn't available yet.",
+        promptSnippet: "Manage local Ollama models (list, pull, status, ps)",
+        promptGuidelines: [
+            "Use 'list' to see what models are available locally before trying to use one.",
+            "Use 'pull' to download a model that isn't available yet.",
+            "Use 'status' to check if Ollama is running.",
+            "Use 'ps' to see which models are loaded in memory and VRAM usage.",
+            "Common models: llama3.1:8b, qwen2.5-coder:7b, deepseek-r1:8b, codestral:22b",
+        ],
+        parameters: Type.Object({
+            action: Type.Union([
+                Type.Literal("list"),
+                Type.Literal("pull"),
+                Type.Literal("status"),
+                Type.Literal("ps"),
+            ], { description: "Action to perform" }),
+            model: Type.Optional(Type.String({ description: "Model name (required for pull)" })),
+        }),
+        async execute(_toolCallId, params, signal, onUpdate, _ctx) {
+            const startTime = Date.now();
+            const { action, model } = params;
+            try {
+                switch (action) {
+                    case "status": {
+                        const running = await client.isRunning();
+                        if (!running) {
+                            return {
+                                content: [{ type: "text", text: "Ollama is not running. It needs to be started with 'ollama serve'." }],
+                                details: { action, durationMs: Date.now() - startTime },
+                            };
+                        }
+                        const version = await client.getVersion();
+                        return {
+                            content: [{ type: "text", text: `Ollama${version ? ` v${version}` : ""} is running at ${client.getOllamaHost()}` }],
+                            details: { action, durationMs: Date.now() - startTime },
+                        };
+                    }
+                    case "list": {
+                        const running = await client.isRunning();
+                        if (!running) {
+                            return {
+                                content: [{ type: "text", text: "Ollama is not running." }],
+                                isError: true,
+                                details: { action, durationMs: Date.now() - startTime, error: "not_running" },
+                            };
+                        }
+                        const models = await discoverModels();
+                        if (models.length === 0) {
+                            return {
+                                content: [{ type: "text", text: "No models available. Pull one with action='pull'." }],
+                                details: { action, modelCount: 0, durationMs: Date.now() - startTime },
+                            };
+                        }
+                        const lines = models.map((m) => formatModelForDisplay(m));
+                        return {
+                            content: [{ type: "text", text: `Available models:\n${lines.join("\n")}` }],
+                            details: { action, modelCount: models.length, durationMs: Date.now() - startTime },
+                        };
+                    }
+                    case "pull": {
+                        if (!model) {
+                            return {
+                                content: [{ type: "text", text: "Error: 'model' parameter is required for pull action." }],
+                                isError: true,
+                                details: { action, durationMs: Date.now() - startTime, error: "missing_model" },
+                            };
+                        }
+                        const running = await client.isRunning();
+                        if (!running) {
+                            return {
+                                content: [{ type: "text", text: "Ollama is not running." }],
+                                isError: true,
+                                details: { action, model, durationMs: Date.now() - startTime, error: "not_running" },
+                            };
+                        }
+                        let lastStatus = "";
+                        await client.pullModel(model, (progress) => {
+                            if (progress.total && progress.completed) {
+                                const pct = Math.floor((progress.completed / progress.total) * 100);
+                                const status = `Pulling ${model}... ${pct}%`;
+                                if (status !== lastStatus) {
+                                    lastStatus = status;
+                                    onUpdate?.({ content: [{ type: "text", text: status }], details: { action, model, durationMs: Date.now() - startTime } });
+                                }
+                            }
+                            else if (progress.status && progress.status !== lastStatus) {
+                                lastStatus = progress.status;
+                                onUpdate?.({ content: [{ type: "text", text: `${model}: ${progress.status}` }], details: { action, model, durationMs: Date.now() - startTime } });
+                            }
+                        }, signal);
+                        return {
+                            content: [{ type: "text", text: `Successfully pulled ${model}` }],
+                            details: { action, model, durationMs: Date.now() - startTime },
+                        };
+                    }
+                    case "ps": {
+                        const running = await client.isRunning();
+                        if (!running) {
+                            return {
+                                content: [{ type: "text", text: "Ollama is not running." }],
+                                isError: true,
+                                details: { action, durationMs: Date.now() - startTime, error: "not_running" },
+                            };
+                        }
+                        const ps = await client.getRunningModels();
+                        if (!ps.models || ps.models.length === 0) {
+                            return {
+                                content: [{ type: "text", text: "No models currently loaded in memory." }],
+                                details: { action, modelCount: 0, durationMs: Date.now() - startTime },
+                            };
+                        }
+                        const lines = ps.models.map((m) => {
+                            const vram = m.size_vram > 0 ? `${formatModelSize(m.size_vram)} VRAM` : "CPU";
+                            return `${m.name} — ${formatModelSize(m.size)} total, ${vram}`;
+                        });
+                        return {
+                            content: [{ type: "text", text: `Loaded models:\n${lines.join("\n")}` }],
+                            details: { action, modelCount: ps.models.length, durationMs: Date.now() - startTime },
+                        };
+                    }
+                    default:
+                        return {
+                            content: [{ type: "text", text: `Unknown action: ${action}` }],
+                            isError: true,
+                            details: { action, durationMs: Date.now() - startTime, error: "unknown_action" },
+                        };
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return {
+                    content: [{ type: "text", text: `Ollama error: ${msg}` }],
+                    isError: true,
+                    details: { action, model, durationMs: Date.now() - startTime, error: msg },
+                };
+            }
+        },
+        renderCall(args, theme) {
+            let text = theme.fg("toolTitle", theme.bold("ollama "));
+            text += theme.fg("accent", args.action);
+            if (args.model) {
+                text += theme.fg("dim", ` ${args.model}`);
+            }
+            return new Text(text, 0, 0);
+        },
+        renderResult(result, { isPartial, expanded }, theme) {
+            const d = result.details;
+            if (isPartial)
+                return new Text(theme.fg("warning", "Working..."), 0, 0);
+            if (result.isError || d?.error) {
+                return new Text(theme.fg("error", `Error: ${d?.error ?? "unknown"}`), 0, 0);
+            }
+            let text = theme.fg("success", d?.action ?? "done");
+            if (d?.modelCount !== undefined) {
+                text += theme.fg("dim", ` (${d.modelCount} models)`);
+            }
+            text += theme.fg("dim", ` ${d?.durationMs ?? 0}ms`);
+            if (expanded) {
+                const content = result.content[0];
+                if (content?.type === "text") {
+                    const preview = content.text.split("\n").slice(0, 10).join("\n");
+                    text += "\n\n" + theme.fg("dim", preview);
+                }
+            }
+            return new Text(text, 0, 0);
+        },
+    });
+}

package/dist/resources/extensions/ollama/types.js

@@ -0,0 +1,2 @@
+// GSD2 — Ollama API response types
+export {};

package/dist/resources/extensions/search-the-web/extension-manifest.json

@@ -8,6 +8,6 @@
   "provides": {
     "tools": ["search-the-web", "fetch_page", "search_and_read", "web_search"],
     "commands": ["search-provider"],
-    "hooks": ["model_select", "before_provider_request"]
+    "hooks": ["session_start", "model_select", "before_provider_request"]
   }
 }

package/dist/resources/extensions/search-the-web/url-utils.js

@@ -18,12 +18,29 @@ const PRIVATE_IP_PATTERNS = [
     /^fd/i,
     /^fe80:/i,
 ];
+/**
+ * Hostnames exempted from SSRF blocking. Set via setFetchAllowedUrls()
+ * from global settings.json or GSD_FETCH_ALLOWED_URLS env var.
+ */
+let fetchAllowedHostnames = new Set();
+/**
+ * Replace the fetch URL allowlist (hostnames exempted from SSRF checks).
+ */
+export function setFetchAllowedUrls(hostnames) {
+    fetchAllowedHostnames = new Set(hostnames.map((h) => h.toLowerCase()));
+}
+/** Get the currently active fetch URL allowlist. */
+export function getFetchAllowedUrls() {
+    return [...fetchAllowedHostnames];
+}
 export function isBlockedUrl(url) {
     try {
         const parsed = new URL(url);
         if (parsed.protocol !== "https:" && parsed.protocol !== "http:")
             return true;
         const hostname = parsed.hostname.toLowerCase();
+        if (fetchAllowedHostnames.has(hostname))
+            return false;
         if (BLOCKED_HOSTNAMES.has(hostname))
             return true;
         for (const pattern of PRIVATE_IP_PATTERNS) {

package/dist/resources/extensions/shared/interview-ui.js

@@ -28,7 +28,7 @@ import { Editor, Key, matchesKey, truncateToWidth, } from "@gsd/pi-tui";
 import { makeUI, INDENT } from "./ui.js";
 // ─── Constants ────────────────────────────────────────────────────────────────
 const OTHER_OPTION_LABEL = "None of the above";
-const OTHER_OPTION_DESCRIPTION = "Press TAB to add optional notes.";
+const OTHER_OPTION_DESCRIPTION = "Select to type your own answer.";
 // ─── Wrap-up screen ───────────────────────────────────────────────────────────
 export async function showWrapUpScreen(opts, ctx) {
     return ctx.ui.custom((tui, theme, _kb, done) => {
@@ -199,6 +199,16 @@ export async function showInterviewRound(questions, opts, ctx) {
             if (!isMultiSelect(currentIdx)) {
                 states[currentIdx].committedIndex = states[currentIdx].cursorIndex;
             }
+            // Auto-open the notes field when "None of the above" is selected
+            // so the user can immediately provide a free-text explanation
+            // instead of being trapped in a re-asking loop (bug #2715).
+            if (!isMultiSelect(currentIdx) && states[currentIdx].cursorIndex === noneOrDoneIdx(currentIdx)) {
+                states[currentIdx].notesVisible = true;
+                focusNotes = true;
+                loadStateToEditor();
+                refresh();
+                return;
+            }
             if (isMultiQuestion && currentIdx < questions.length - 1) {
                 let next = currentIdx + 1;
                 for (let i = 0; i < questions.length; i++) {

package/dist/resources/skills/btw/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: btw
+description: Ask a quick side question about your current work without derailing the main task. Answers from existing conversation context only — no tool calls, no file reads, single concise response. Use when you need a fast answer from what is already in this session.
+---
+
+<objective>
+Answer a quick side question using only what is already present in the current conversation context. Do not read files, run commands, search, or use any tools. Give a single, concise response and return focus to the main work.
+</objective>
+
+<behavior>
+**This is a side question, not a task.**
+
+- Answer only from information already in the conversation (files read, decisions made, code seen, context established)
+- Do NOT use any tools — no Read, no Bash, no Grep, no Search
+- If the answer requires reading something new, say so briefly and suggest the user ask as a normal prompt instead
+- Keep the response short and direct — one to a few sentences unless the question genuinely needs more
+- Do not summarize the main work, ask follow-up questions, or offer to do anything else
+- After answering, stop — do not prompt for next steps
+</behavior>
+
+<quick_start>
+Parse the argument after `/btw` as the question. Answer it directly from context.
+
+If no argument is provided, ask: "What did you want to know?"
+
+If the question cannot be answered from current context (requires reading a file, running a command, or information not yet in the session), respond with:
+"I'd need to [read X / run Y / look up Z] to answer that — ask it as a normal prompt when you're ready."
+</quick_start>
+
+<examples>
+**Good uses of /btw:**
+- `/btw what was the name of that config file again?` → answers from files already read in session
+- `/btw which branch are we on?` → answers from git context already established
+- `/btw did we already handle the null case in that function?` → answers from code already reviewed
+- `/btw what model does this use?` → answers from code or config already in context
+
+**Not a good fit for /btw (suggest normal prompt):**
+- Questions requiring reading a file not yet seen
+- Questions requiring running a command
+- Questions needing a multi-step answer or follow-up
+- Starting a new task or changing direction
+</examples>

package/dist/resources/skills/create-gsd-extension/SKILL.md

@@ -7,9 +7,11 @@ description: Create, debug, and iterate on GSD extensions (TypeScript modules th
 
 **Extensions are TypeScript modules** that hook into GSD's runtime (built on pi). They export a default function receiving `ExtensionAPI` and use it to subscribe to events, register tools/commands/shortcuts, and interact with the session.
 
-**GSD extension paths:**
-- Global extensions: `~/.gsd/agent/extensions/*.ts` or `~/.gsd/agent/extensions/*/index.ts`
-- Project-local extensions: `.gsd/extensions/*.ts` or `.gsd/extensions/*/index.ts`
+**GSD extension paths (community/user-installed extensions):**
+- Global: `~/.pi/agent/extensions/*.ts` or `~/.pi/agent/extensions/*/index.ts`
+- Project-local: `.gsd/extensions/*.ts` or `.gsd/extensions/*/index.ts`
+
+Note: `~/.gsd/agent/extensions/` is reserved for bundled extensions synced from the gsd-pi package. Community extensions placed there are silently ignored by the loader.
 
 **The three primitives:**
 1. **Events** — Listen and react (`pi.on("event", handler)`). Can block tool calls, modify messages, inject context.

package/dist/resources/skills/create-gsd-extension/references/key-rules-gotchas.md

@@ -26,11 +26,12 @@ Non-negotiable rules and common gotchas when building GSD extensions.
 </common_patterns>
 
 <gsd_paths>
-**GSD extension paths:**
-- Global: `~/.gsd/agent/extensions/*.ts`
-- Global (subdir): `~/.gsd/agent/extensions/*/index.ts`
+**GSD extension paths (community/user-installed extensions):**
+- Global: `~/.pi/agent/extensions/*.ts`
+- Global (subdir): `~/.pi/agent/extensions/*/index.ts`
 - Project-local: `.gsd/extensions/*.ts`
 - Project-local (subdir): `.gsd/extensions/*/index.ts`
 
-The upstream pi docs reference `~/.pi` paths — GSD uses `~/.gsd` everywhere instead.
+Note: `~/.gsd/agent/extensions/` is reserved for bundled extensions synced from the gsd-pi package.
+Community extensions placed there are silently ignored by the loader.
 </gsd_paths>

package/dist/resources/skills/create-gsd-extension/workflows/add-capability.md

@@ -14,7 +14,7 @@ Read the reference file for the specific capability being added:
 ## Step 1: Identify the Extension
 
 Locate the existing extension file. Check:
-- `~/.gsd/agent/extensions/` (global)
+- `~/.pi/agent/extensions/` (global community extensions)
 - `.gsd/extensions/` (project-local)
 
 Read the current extension code to understand its structure.
@@ -28,7 +28,7 @@ If the extension needs new imports, add them at the top of the file.
 ## Step 3: Handle Structural Changes
 
 **Single file → Directory**: If the extension is outgrowing a single file:
-1. Create `~/.gsd/agent/extensions/my-extension/`
+1. Create `~/.pi/agent/extensions/my-extension/`
 2. Move the file to `index.ts`
 3. Extract helpers to separate files
 

package/dist/resources/skills/create-gsd-extension/workflows/create-extension.md

@@ -12,7 +12,7 @@
 ## Step 1: Determine Scope and Placement
 
 Ask the user:
-- **Global** (`~/.gsd/agent/extensions/`) — Available in all GSD sessions
+- **Global** (`~/.pi/agent/extensions/`) — Available in all GSD sessions
 - **Project-local** (`.gsd/extensions/`) — Available only in this project
 
 ## Step 2: Determine Extension Capabilities
@@ -36,12 +36,12 @@ Identify what the extension needs from the user's description:
 
 **Single file** — for small extensions (1-2 tools/commands, simple hooks):
 ```
-~/.gsd/agent/extensions/my-extension.ts
+~/.pi/agent/extensions/my-extension.ts
 ```
 
 **Directory with index.ts** — for multi-file extensions:
 ```
-~/.gsd/agent/extensions/my-extension/
+~/.pi/agent/extensions/my-extension/
 ├── index.ts
 ├── tools.ts
 └── utils.ts
@@ -49,7 +49,7 @@ Identify what the extension needs from the user's description:
 
 **Package with dependencies** — when npm packages are needed:
 ```
-~/.gsd/agent/extensions/my-extension/
+~/.pi/agent/extensions/my-extension/
 ├── package.json
 ├── src/index.ts
 └── node_modules/

package/dist/resources/skills/create-gsd-extension/workflows/debug-extension.md

@@ -32,12 +32,14 @@ gsd -e ./path/to/extension.ts
 
 ## Step 3: Verify File Location
 
-Extensions must be in auto-discovery paths:
-- `~/.gsd/agent/extensions/*.ts`
-- `~/.gsd/agent/extensions/*/index.ts`
+Community extensions must be in auto-discovery paths:
+- `~/.pi/agent/extensions/*.ts`
+- `~/.pi/agent/extensions/*/index.ts`
 - `.gsd/extensions/*.ts`
 - `.gsd/extensions/*/index.ts`
 
+Note: `~/.gsd/agent/extensions/` is reserved for bundled extensions synced from the gsd-pi package.
+
 The file must `export default function(pi: ExtensionAPI) { ... }`.
 
 ## Step 4: Check for Common Mistakes

package/dist/security-overrides.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Apply user-configured security overrides from global settings.json and env vars.
+ *
+ * Both overrides are global-only (not project-level) because the threat model is
+ * malicious project-level config in cloned repos. Global settings and env vars
+ * represent the user's own authority on their machine.
+ *
+ * Precedence: env var > settings.json > built-in defaults
+ */
+import { type SettingsManager } from '@gsd/pi-coding-agent';
+export declare function applySecurityOverrides(settingsManager: SettingsManager): void;

package/dist/security-overrides.js

@@ -0,0 +1,41 @@
+/**
+ * Apply user-configured security overrides from global settings.json and env vars.
+ *
+ * Both overrides are global-only (not project-level) because the threat model is
+ * malicious project-level config in cloned repos. Global settings and env vars
+ * represent the user's own authority on their machine.
+ *
+ * Precedence: env var > settings.json > built-in defaults
+ */
+import { setAllowedCommandPrefixes } from '@gsd/pi-coding-agent';
+import { setFetchAllowedUrls } from './resources/extensions/search-the-web/url-utils.js';
+export function applySecurityOverrides(settingsManager) {
+    // --- Command prefix allowlist ---
+    const envPrefixes = process.env.GSD_ALLOWED_COMMAND_PREFIXES;
+    if (envPrefixes) {
+        const prefixes = envPrefixes.split(',').map(s => s.trim()).filter(Boolean);
+        if (prefixes.length > 0) {
+            setAllowedCommandPrefixes(prefixes);
+        }
+    }
+    else {
+        const settingsPrefixes = settingsManager.getAllowedCommandPrefixes();
+        if (settingsPrefixes && settingsPrefixes.length > 0) {
+            setAllowedCommandPrefixes(settingsPrefixes);
+        }
+    }
+    // --- Fetch URL allowlist (SSRF exemptions) ---
+    const envUrls = process.env.GSD_FETCH_ALLOWED_URLS;
+    if (envUrls) {
+        const urls = envUrls.split(',').map(s => s.trim()).filter(Boolean);
+        if (urls.length > 0) {
+            setFetchAllowedUrls(urls);
+        }
+    }
+    else {
+        const settingsUrls = settingsManager.getFetchAllowedUrls();
+        if (settingsUrls && settingsUrls.length > 0) {
+            setFetchAllowedUrls(settingsUrls);
+        }
+    }
+}

package/dist/startup-model-validation.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Startup model validation — extracted from cli.ts so it can be called
+ * AFTER extensions register their models in the ModelRegistry.
+ *
+ * Before this extraction (bug #2626), the validation ran before
+ * createAgentSession(), meaning extension-provided models (e.g.
+ * claude-code/claude-sonnet-4-6) were not yet in the registry.
+ * configuredExists was always false for extension models, causing the
+ * user's valid choice to be silently overwritten with a built-in fallback.
+ */
+interface MinimalModel {
+    provider: string;
+    id: string;
+}
+interface MinimalModelRegistry {
+    getAll(): MinimalModel[];
+    getAvailable(): MinimalModel[];
+}
+type ThinkingLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+interface MinimalSettingsManager {
+    getDefaultProvider(): string | undefined;
+    getDefaultModel(): string | undefined;
+    getDefaultThinkingLevel(): ThinkingLevel | undefined;
+    setDefaultModelAndProvider(provider: string, modelId: string): void;
+    setDefaultThinkingLevel(level: ThinkingLevel): void;
+}
+/**
+ * Validate the configured default model against the registry.
+ *
+ * If the configured model exists in the registry, this is a no-op — the
+ * user's choice is preserved.  If it does not exist (stale settings from a
+ * prior install, or genuinely removed model), a fallback is selected and
+ * written to settings.
+ *
+ * IMPORTANT: Call this AFTER createAgentSession() so that extension-
+ * provided models have been registered in the ModelRegistry.
+ */
+export declare function validateConfiguredModel(modelRegistry: MinimalModelRegistry, settingsManager: MinimalSettingsManager): void;
+export {};

package/dist/startup-model-validation.js

@@ -0,0 +1,50 @@
+/**
+ * Startup model validation — extracted from cli.ts so it can be called
+ * AFTER extensions register their models in the ModelRegistry.
+ *
+ * Before this extraction (bug #2626), the validation ran before
+ * createAgentSession(), meaning extension-provided models (e.g.
+ * claude-code/claude-sonnet-4-6) were not yet in the registry.
+ * configuredExists was always false for extension models, causing the
+ * user's valid choice to be silently overwritten with a built-in fallback.
+ */
+import { getPiDefaultModelAndProvider } from './pi-migration.js';
+/**
+ * Validate the configured default model against the registry.
+ *
+ * If the configured model exists in the registry, this is a no-op — the
+ * user's choice is preserved.  If it does not exist (stale settings from a
+ * prior install, or genuinely removed model), a fallback is selected and
+ * written to settings.
+ *
+ * IMPORTANT: Call this AFTER createAgentSession() so that extension-
+ * provided models have been registered in the ModelRegistry.
+ */
+export function validateConfiguredModel(modelRegistry, settingsManager) {
+    const configuredProvider = settingsManager.getDefaultProvider();
+    const configuredModel = settingsManager.getDefaultModel();
+    const allModels = modelRegistry.getAll();
+    const availableModels = modelRegistry.getAvailable();
+    const configuredExists = configuredProvider && configuredModel &&
+        allModels.some((m) => m.provider === configuredProvider && m.id === configuredModel);
+    if (!configuredModel || !configuredExists) {
+        // Model not configured at all, or removed from registry — pick a fallback.
+        // Only fires when the model is genuinely unknown (not just temporarily unavailable).
+        const piDefault = getPiDefaultModelAndProvider();
+        const preferred = (piDefault
+            ? availableModels.find((m) => m.provider === piDefault.provider && m.id === piDefault.model)
+            : undefined) ||
+            availableModels.find((m) => m.provider === 'openai' && m.id === 'gpt-5.4') ||
+            availableModels.find((m) => m.provider === 'openai') ||
+            availableModels.find((m) => m.provider === 'anthropic' && m.id === 'claude-opus-4-6') ||
+            availableModels.find((m) => m.provider === 'anthropic' && m.id.includes('opus')) ||
+            availableModels.find((m) => m.provider === 'anthropic') ||
+            availableModels[0];
+        if (preferred) {
+            settingsManager.setDefaultModelAndProvider(preferred.provider, preferred.id);
+        }
+    }
+    if (settingsManager.getDefaultThinkingLevel() !== 'off' && !configuredExists) {
+        settingsManager.setDefaultThinkingLevel('off');
+    }
+}

package/dist/web/standalone/.next/BUILD_ID

@@ -1 +1 @@
-IoheXIe-5DH7ieX8AUo8U
+QlWL-8CXgQpzV3ehkNMzh

package/dist/web/standalone/.next/app-path-routes-manifest.json

@@ -4,43 +4,43 @@
   "/api/boot/route": "/api/boot",
   "/api/bridge-terminal/input/route": "/api/bridge-terminal/input",
   "/api/bridge-terminal/resize/route": "/api/bridge-terminal/resize",
-  "/api/bridge-terminal/stream/route": "/api/bridge-terminal/stream",
   "/api/dev-mode/route": "/api/dev-mode",
-  "/api/cleanup/route": "/api/cleanup",
-  "/api/captures/route": "/api/captures",
+  "/api/browse-directories/route": "/api/browse-directories",
   "/api/doctor/route": "/api/doctor",
+  "/api/cleanup/route": "/api/cleanup",
   "/api/export-data/route": "/api/export-data",
-  "/api/browse-directories/route": "/api/browse-directories",
+  "/api/bridge-terminal/stream/route": "/api/bridge-terminal/stream",
   "/api/forensics/route": "/api/forensics",
+  "/api/captures/route": "/api/captures",
   "/api/history/route": "/api/history",
   "/api/git/route": "/api/git",
   "/api/hooks/route": "/api/hooks",
-  "/api/knowledge/route": "/api/knowledge",
   "/api/inspect/route": "/api/inspect",
   "/api/experimental/route": "/api/experimental",
+  "/api/knowledge/route": "/api/knowledge",
   "/api/live-state/route": "/api/live-state",
-  "/api/preferences/route": "/api/preferences",
   "/api/recovery/route": "/api/recovery",
   "/api/onboarding/route": "/api/onboarding",
+  "/api/preferences/route": "/api/preferences",
   "/api/projects/route": "/api/projects",
   "/api/session/browser/route": "/api/session/browser",
   "/api/session/command/route": "/api/session/command",
-  "/api/session/events/route": "/api/session/events",
   "/api/session/manage/route": "/api/session/manage",
   "/api/settings-data/route": "/api/settings-data",
   "/api/shutdown/route": "/api/shutdown",
-  "/api/skill-health/route": "/api/skill-health",
+  "/api/session/events/route": "/api/session/events",
   "/api/steer/route": "/api/steer",
+  "/api/skill-health/route": "/api/skill-health",
   "/api/terminal/input/route": "/api/terminal/input",
-  "/api/terminal/resize/route": "/api/terminal/resize",
-  "/api/files/route": "/api/files",
   "/api/switch-root/route": "/api/switch-root",
-  "/api/terminal/sessions/route": "/api/terminal/sessions",
-  "/api/terminal/upload/route": "/api/terminal/upload",
+  "/api/terminal/resize/route": "/api/terminal/resize",
   "/api/terminal/stream/route": "/api/terminal/stream",
-  "/api/undo/route": "/api/undo",
+  "/api/remote-questions/route": "/api/remote-questions",
+  "/api/terminal/upload/route": "/api/terminal/upload",
+  "/api/terminal/sessions/route": "/api/terminal/sessions",
   "/api/visualizer/route": "/api/visualizer",
   "/api/update/route": "/api/update",
-  "/api/remote-questions/route": "/api/remote-questions",
+  "/api/files/route": "/api/files",
+  "/api/undo/route": "/api/undo",
   "/page": "/"
 }

package/dist/web/standalone/.next/build-manifest.json

@@ -4,14 +4,14 @@
   ],
   "devFiles": [],
   "lowPriorityFiles": [
-    "static/IoheXIe-5DH7ieX8AUo8U/_buildManifest.js",
-    "static/IoheXIe-5DH7ieX8AUo8U/_ssgManifest.js"
+    "static/QlWL-8CXgQpzV3ehkNMzh/_buildManifest.js",
+    "static/QlWL-8CXgQpzV3ehkNMzh/_ssgManifest.js"
   ],
   "rootMainFiles": [
-    "static/chunks/webpack-61d3afac6d0f0ce7.js",
+    "static/chunks/webpack-a1c1e452c6b32d04.js",
     "static/chunks/4bd1b696-e5d7c65570c947b7.js",
     "static/chunks/3794-337d1ca25ad99a89.js",
-    "static/chunks/main-app-d3d4c336195465f9.js"
+    "static/chunks/main-app-fdab67f7802d7832.js"
   ],
   "rootMainFilesTree": {},
   "pages": {

package/dist/web/standalone/.next/prerender-manifest.json

@@ -78,8 +78,8 @@
   "dynamicRoutes": {},
   "notFoundRoutes": [],
   "preview": {
-    "previewModeId": "cfd305d0ba0974dc452e5957b205f5aa",
-    "previewModeSigningKey": "9e421b86649471d70168737defec8a7ff046164716d15e496e41c9f5f2b7ae02",
-    "previewModeEncryptionKey": "35460424da4dbaa1c9ca1fe6cc28113bdae7dcd85c6a9930e824e9cb4d80a926"
+    "previewModeId": "95b27bc40d911a0949384288bd0c9837",
+    "previewModeSigningKey": "7da4c1df68d61aee6752746deccd6eec23916dc8e28f2e882392e06ca4f038f8",
+    "previewModeEncryptionKey": "0e5222c8809d87fc9487fec2b8dc3c314aa6f536d924ae94e21b34a8fe0203c8"
   }
 }