@opengsd/gsd-pi 1.0.2-dev.235ebf3 → 1.0.2-dev.2c204d3

package/dist/resources/extensions/gsd/commands-handlers.js

@@ -17,6 +17,7 @@ import { isAutoActive, checkRemoteAutoSession } from "./auto.js";
 import { getAutoWorktreePath } from "./auto-worktree.js";
 import { currentDirectoryRoot, projectRoot } from "./commands/context.js";
 import { loadPrompt } from "./prompt-loader.js";
+import { isPnpmInstall } from "../../shared/package-manager-detection.js";
 import { buildDoctorHealIssuePayload, buildDoctorHealSummary, buildWorkflowDispatchContent, } from "./workflow-protocol.js";
 import { restoreGsdWorkflowTools, scopeGsdWorkflowToolsForDispatch, } from "./bootstrap/register-hooks.js";
 const UPDATE_REGISTRY_URL = "https://registry.npmjs.org/@opengsd%2fgsd-pi/latest";
@@ -42,6 +43,8 @@ function isBunInstall(argv1 = process.argv[1]) {
 function resolveInstallCommand(pkg) {
     if (isBunInstall())
         return `bun add -g ${pkg}`;
+    if (isPnpmInstall())
+        return `pnpm add -g ${pkg}`;
     return `npm install -g ${pkg}`;
 }
 async function fetchLatestVersionForCommand() {

package/dist/resources/extensions/gsd/git-conflict-state.js

@@ -2,7 +2,7 @@
 // File Purpose: Detect and reconcile unresolved Git conflict state before automation runs.
 import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { autoResolveSafeConflictPaths } from "./git-conflict-resolve.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { abortAndReset } from "./git-self-heal.js";
@@ -10,6 +10,23 @@ import { logWarning } from "./workflow-logger.js";
 function splitZeroDelimited(output) {
     return output.split("\0").filter(Boolean);
 }
+function hasGitMarker(basePath) {
+    try {
+        let dir = resolve(basePath);
+        for (let i = 0; i < 30; i++) {
+            if (existsSync(join(dir, ".git")))
+                return true;
+            const parent = dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch {
+        // Fall through to the git probes, which will report unknown on failure.
+    }
+    return false;
+}
 export function listUnmergedGitPaths(basePath) {
     try {
         const output = spawnSync("git", ["diff", "--name-only", "--diff-filter=U", "-z"], {
@@ -57,6 +74,14 @@ export function listMergeStateBlockers(basePath) {
     return MERGE_STATE_MARKERS.filter((marker) => existsSync(join(gitDir, marker)));
 }
 export function probeGitConflictState(basePath) {
+    if (!hasGitMarker(basePath)) {
+        return {
+            status: "clean",
+            unmerged: [],
+            checkFailures: [],
+            mergeStateBlockers: [],
+        };
+    }
     const unmerged = listUnmergedGitPaths(basePath);
     if (unmerged === null) {
         return {

package/dist/resources/extensions/gsd/tools/complete-task.js

@@ -116,6 +116,15 @@ export async function handleCompleteTask(params, basePath) {
     if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
         return { error: "milestoneId is required and must be a non-empty string" };
     }
+    if (!params.oneLiner || typeof params.oneLiner !== "string" || params.oneLiner.trim() === "") {
+        return { error: "oneLiner is required and must be a non-empty string" };
+    }
+    if (!params.narrative || typeof params.narrative !== "string" || params.narrative.trim() === "") {
+        return { error: "narrative is required and must be a non-empty string" };
+    }
+    if (!params.verification || typeof params.verification !== "string" || params.verification.trim() === "") {
+        return { error: "verification is required and must be a non-empty string" };
+    }
     const artifactBasePath = resolveCanonicalMilestoneRoot(basePath, params.milestoneId);
     // ── Ownership check (opt-in: only enforced when claim file exists) ──────
     const ownershipErr = checkOwnership(artifactBasePath, taskUnitKey(params.milestoneId, params.sliceId, params.taskId), params.actorName);

package/dist/resources/extensions/gsd/tools/workflow-tool-executors.js

@@ -238,6 +238,24 @@ export async function executeSummarySave(params, basePath = process.cwd()) {
         };
     }
 }
+function normalizeVerificationEvidence(evidence) {
+    return (evidence ?? []).map((entry) => typeof entry === "string"
+        ? { command: entry, exitCode: -1, verdict: "unknown (coerced from string)", durationMs: 0 }
+        : entry);
+}
+function deriveVerificationSummary(evidence) {
+    if (evidence.length === 0)
+        return null;
+    const rendered = evidence.slice(0, 3).map((entry) => {
+        const command = entry.command.trim() || "(unspecified command)";
+        const verdict = entry.verdict.trim() || "recorded";
+        return `\`${command}\` exited ${entry.exitCode} (${verdict})`;
+    });
+    const suffix = evidence.length > rendered.length
+        ? `; ${evidence.length - rendered.length} more check(s) recorded`
+        : "";
+    return `Verification evidence recorded: ${rendered.join("; ")}${suffix}.`;
+}
 export async function executeTaskComplete(params, basePath = process.cwd()) {
     const dbAvailable = await ensureDbOpen(basePath);
     if (!dbAvailable) {
@@ -249,7 +267,28 @@ export async function executeTaskComplete(params, basePath = process.cwd()) {
     }
     try {
         const coerced = { ...params };
-        coerced.verificationEvidence = (params.verificationEvidence ?? []).map((v) => typeof v === "string" ? { command: v, exitCode: -1, verdict: "unknown (coerced from string)", durationMs: 0 } : v);
+        const verificationEvidence = normalizeVerificationEvidence(params.verificationEvidence);
+        coerced.verificationEvidence = verificationEvidence;
+        const verification = typeof params.verification === "string" ? params.verification.trim() : "";
+        if (verification.length === 0) {
+            const derived = deriveVerificationSummary(verificationEvidence);
+            if (derived) {
+                coerced.verification = derived;
+            }
+            else if (params.blockerDiscovered === true) {
+                coerced.verification = "Not run: blocker discovered before verification.";
+            }
+            else {
+                return {
+                    content: [{
+                            type: "text",
+                            text: "Error completing task: verification is required unless verificationEvidence is provided or blockerDiscovered is true.",
+                        }],
+                    details: { operation: "complete_task", error: "verification_required" },
+                    isError: true,
+                };
+            }
+        }
         const result = await handleCompleteTask(coerced, basePath);
         if ("error" in result) {
             return {

package/dist/resources/extensions/gsd/worktree-lifecycle.js

@@ -203,7 +203,7 @@ function validateMilestoneId(milestoneId) {
  *   - emits worktree-created telemetry on successful entry
  *   - notifies the caller via `ctx.notify` for every user-visible outcome
  */
-export function _enterMilestoneCore(s, deps, milestoneId, ctx) {
+export function _enterMilestoneCore(s, deps, milestoneId, ctx, opts = {}) {
     if (!isValidMilestoneId(milestoneId)) {
         debugLog("WorktreeLifecycle", {
             action: "enterMilestone",
@@ -305,7 +305,7 @@ export function _enterMilestoneCore(s, deps, milestoneId, ctx) {
     // Handles the case where originalBasePath is falsy and basePath is itself
     // a worktree path — prevents double-nested worktree paths (#3729).
     const basePath = resolveWorktreeProjectRoot(s.basePath, s.originalBasePath);
-    const mode = getIsolationMode(basePath);
+    const mode = opts.modeOverride ?? getIsolationMode(basePath);
     if (s.isolationDegraded) {
         if (mode === "worktree") {
             try {
@@ -841,7 +841,8 @@ export function mergeMilestoneStandalone(deps, mctx) {
             pushed: false,
         };
     }
-    const mode = getIsolationMode(originalBasePath || worktreeBasePath);
+    const mode = mctx.isolationModeOverride ??
+        getIsolationMode(originalBasePath || worktreeBasePath);
     debugLog("WorktreeLifecycle", {
         action: "mergeAndExit",
         milestoneId,
@@ -1137,6 +1138,7 @@ export class WorktreeLifecycle {
                 originalBasePath: this.s.originalBasePath,
                 worktreeBasePath: this.s.basePath,
                 milestoneId,
+                isolationModeOverride: this.s.strandedRecoveryIsolationMode ?? undefined,
                 isolationDegraded: this.s.isolationDegraded,
                 notify: ctx.notify,
             });
@@ -1223,6 +1225,7 @@ export class WorktreeLifecycle {
             // Rebuild GitService after merge (branch HEAD changed)
             rebuildGitService(this.s, this.deps);
         }
+        this.s.strandedRecoveryIsolationMode = null;
         return result;
     }
     // ── Removed: _mergeWorktreeMode / _mergeBranchMode bodies ────────────
@@ -1345,6 +1348,24 @@ export class WorktreeLifecycle {
     resumeFromPausedSession(base, persistedWorktreePath) {
         this.s.basePath = resolvePausedResumeBasePath(base, persistedWorktreePath);
     }
+    /**
+     * Adopt in-progress stranded work during bootstrap.
+     *
+     * Unlike completed-orphan recovery, this does not merge, delete, or commit.
+     * It only moves the live session onto the branch/worktree proven by the
+     * audit evidence, while preserving that mode for the eventual merge.
+     */
+    adoptStrandedMilestone(milestoneId, base, ctx, opts) {
+        this.adoptSessionRoot(base);
+        this.s.strandedRecoveryIsolationMode = opts.mode;
+        const result = _enterMilestoneCore(this.s, this.deps, milestoneId, ctx, {
+            modeOverride: opts.mode,
+        });
+        if (!result.ok) {
+            this.s.strandedRecoveryIsolationMode = null;
+        }
+        return result;
+    }
     /**
      * Adopt an orphan worktree for a bootstrap-time merge (ADR-016 phase 2 / B4,
      * issue #5622).

package/dist/resources/extensions/gsd/worktree-post-create-hook.js

@@ -0,0 +1,117 @@
+// Project/App: gsd-pi
+// File Purpose: Lightweight worktree post-create hook runner.
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { gsdHome } from "./gsd-home.js";
+import { gsdRoot } from "./paths.js";
+function readPreferencesObject(path) {
+    if (!existsSync(path))
+        return null;
+    const content = readFileSync(path, "utf-8");
+    try {
+        const startMarker = content.startsWith("---\r\n") ? "---\r\n" : "---\n";
+        if (content.startsWith(startMarker)) {
+            const searchStart = startMarker.length;
+            const endIdx = content.indexOf("\n---", searchStart);
+            if (endIdx === -1)
+                return null;
+            const parsed = parseYaml(content.slice(searchStart, endIdx).replace(/\r/g, ""));
+            return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+                ? parsed
+                : null;
+        }
+        const gitLines = [];
+        let inGitSection = false;
+        for (const rawLine of content.split("\n")) {
+            const line = rawLine.replace(/\r$/, "");
+            const heading = line.match(/^##\s+(.+)$/);
+            if (heading) {
+                inGitSection = heading[1].trim().toLowerCase().replace(/\s+/g, "_") === "git";
+                continue;
+            }
+            if (inGitSection && line.trim() && !line.trimStart().startsWith("#")) {
+                gitLines.push(line.replace(/^\s*-\s*/, ""));
+            }
+        }
+        if (gitLines.length === 0)
+            return null;
+        const parsed = parseYaml(gitLines.join("\n"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? { git: parsed }
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function extractHookPath(preferences) {
+    const git = preferences?.git;
+    if (!git || typeof git !== "object" || Array.isArray(git))
+        return null;
+    const hookPath = git.worktree_post_create;
+    return typeof hookPath === "string" && hookPath.trim() ? hookPath : null;
+}
+function resolveConfiguredHookPath(sourceDir) {
+    const paths = [
+        join(homedir(), ".pi", "agent", "gsd-preferences.md"),
+        join(gsdHome(), "preferences.md"),
+        join(gsdHome(), "PREFERENCES.md"),
+        join(gsdRoot(sourceDir), "preferences.md"),
+        join(gsdRoot(sourceDir), "PREFERENCES.md"),
+    ];
+    let hookPath = null;
+    for (const path of paths) {
+        hookPath = extractHookPath(readPreferencesObject(path)) ?? hookPath;
+    }
+    return hookPath;
+}
+/**
+ * Run the user-configured post-create hook script after worktree creation.
+ * The script receives SOURCE_DIR and WORKTREE_DIR as environment variables.
+ * Failure is non-fatal -- returns the error message or null on success.
+ *
+ * Reads git.worktree_post_create from effective global/project preferences
+ * unless hookPath is provided directly.
+ */
+export function runWorktreePostCreateHook(sourceDir, worktreeDir, hookPath) {
+    if (hookPath === undefined) {
+        hookPath = resolveConfiguredHookPath(sourceDir) ?? undefined;
+    }
+    if (!hookPath)
+        return null;
+    let resolved = isAbsolute(hookPath) ? hookPath : join(sourceDir, hookPath);
+    if (!existsSync(resolved)) {
+        return `Worktree post-create hook not found: ${resolved}`;
+    }
+    if (process.platform === "win32") {
+        try {
+            resolved = realpathSync.native(resolved);
+        }
+        catch {
+            // Keep the original path; the exec error below will include the failure.
+        }
+    }
+    try {
+        const needsShell = process.platform === "win32" && /\.(bat|cmd)$/i.test(resolved);
+        execFileSync(resolved, [], {
+            cwd: worktreeDir,
+            env: {
+                ...process.env,
+                SOURCE_DIR: sourceDir,
+                WORKTREE_DIR: worktreeDir,
+            },
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+            timeout: 30_000,
+            shell: needsShell,
+        });
+        return null;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return `Worktree post-create hook failed: ${msg}`;
+    }
+}

package/dist/resources/extensions/search-the-web/native-search.js

@@ -12,6 +12,45 @@ export const BRAVE_TOOL_NAMES = ["search-the-web", "search_and_read"];
 export const CUSTOM_SEARCH_TOOL_NAMES = ["search-the-web", "search_and_read", "google_search"];
 /** Thinking block types that require signature validation by the API */
 const THINKING_TYPES = new Set(["thinking", "redacted_thinking"]);
+const NATIVE_SERVER_TOOL_USE_TYPES = new Set([
+    "server_tool_use",
+    "serverToolUse",
+]);
+const NATIVE_WEB_SEARCH_RESULT_TYPES = new Set([
+    "web_search_tool_result",
+    "webSearchResult",
+]);
+function nativeServerToolId(block) {
+    if (!NATIVE_SERVER_TOOL_USE_TYPES.has(block?.type))
+        return undefined;
+    return typeof block.id === "string" ? block.id : undefined;
+}
+function nativeWebSearchResultId(block) {
+    if (!NATIVE_WEB_SEARCH_RESULT_TYPES.has(block?.type))
+        return undefined;
+    const id = block.type === "webSearchResult" ? block.toolUseId : block.tool_use_id;
+    return typeof id === "string" ? id : undefined;
+}
+function hasCompleteNativeServerToolReplay(content) {
+    const pendingToolUseIds = new Set();
+    let sawNativeServerToolUse = false;
+    for (const block of content) {
+        const toolUseId = nativeServerToolId(block);
+        if (toolUseId !== undefined) {
+            if (pendingToolUseIds.has(toolUseId))
+                return false;
+            sawNativeServerToolUse = true;
+            pendingToolUseIds.add(toolUseId);
+            continue;
+        }
+        const resultId = nativeWebSearchResultId(block);
+        if (resultId !== undefined) {
+            if (!pendingToolUseIds.delete(resultId))
+                return false;
+        }
+    }
+    return sawNativeServerToolUse && pendingToolUseIds.size === 0;
+}
 /**
  * Providers whose Anthropic-Messages endpoint is known to accept the native
  * `web_search_20250305` server tool. Anthropic-shaped transports NOT in this
@@ -30,6 +69,10 @@ const NATIVE_WEB_SEARCH_PROVIDERS = new Set([
     "anthropic-vertex",
     "vercel-ai-gateway",
 ]);
+function looksLikeAnthropicModelName(modelName) {
+    const normalized = modelName.trim().toLowerCase();
+    return normalized.startsWith("claude-") || normalized.startsWith("anthropic/claude-");
+}
 /**
  * True when the model is an Anthropic-shaped transport AND the provider is
  * known to accept the native `web_search_20250305` tool. Gate both on api
@@ -74,11 +117,10 @@ export function preferBraveSearch() {
  * those blocks. The Anthropic API detects the modification and rejects the
  * request with "thinking blocks cannot be modified."
  *
- * Fix: Remove thinking blocks from all assistant messages in the history.
- * In Anthropic's Messages API, the messages array always ends with a user
- * message, so every assistant message is from a previous turn that has been
- * through a store/replay cycle. The model generates fresh thinking for the
- * current turn regardless.
+ * Fix: Remove thinking blocks only from assistant messages that do not carry
+ * native server-tool blocks. Complete native server-tool histories can be
+ * replayed as-is; stripping thinking from those messages is itself a latest
+ * assistant message modification.
  */
 export function stripThinkingFromHistory(messages) {
     for (const msg of messages) {
@@ -87,6 +129,9 @@ export function stripThinkingFromHistory(messages) {
         const content = msg.content;
         if (!Array.isArray(content))
             continue;
+        if (hasCompleteNativeServerToolReplay(content)) {
+            continue;
+        }
         msg.content = content.filter((block) => !THINKING_TYPES.has(block?.type));
     }
 }
@@ -152,6 +197,8 @@ export function registerNativeSearchHooks(pi) {
         // The model name heuristic is needed for session restores where
         // modelsAreEqual suppresses model_select AND the SDK doesn't pass model.
         const eventModel = event.model;
+        const payloadModelName = typeof payload.model === "string" ? payload.model : "";
+        const payloadLooksAnthropic = payloadModelName ? looksLikeAnthropicModelName(payloadModelName) : undefined;
         let isAnthropic;
         if (eventModel?.api || eventModel?.provider) {
             // Preferred path: gate on api shape + provider allowlist. Both fields
@@ -161,13 +208,15 @@ export function registerNativeSearchHooks(pi) {
             isAnthropic = supportsNativeWebSearch(eventModel);
         }
         else if (modelSelectFired) {
-            isAnthropic = isAnthropicProvider;
+            // The model_select flag can be stale if the next request omits event.model
+            // after a provider switch. A concrete non-Claude payload must win so an
+            // Anthropic-only tool never leaks into OpenAI Responses requests.
+            isAnthropic = isAnthropicProvider && payloadLooksAnthropic !== false;
         }
         else {
             // Last resort: session-restore paths where the SDK doesn't pass model.
             // The model-name prefix is best-effort and assumes direct Anthropic.
-            const modelName = typeof payload.model === "string" ? payload.model : "";
-            isAnthropic = modelName.startsWith("claude-");
+            isAnthropic = payloadLooksAnthropic === true;
         }
         if (!isAnthropic)
             return;

package/dist/resources/shared/package-manager-detection.js

@@ -0,0 +1,36 @@
+import { homedir } from 'node:os';
+import { join, resolve as resolvePath, sep } from 'node:path';
+function hasPnpmPath(value) {
+    if (!value)
+        return false;
+    const normalized = value.replace(/\\/g, '/').toLowerCase();
+    return (normalized.includes('/.pnpm/') ||
+        normalized.endsWith('/pnpm') ||
+        normalized.endsWith('/pnpm.cjs') ||
+        normalized.endsWith('/pnpm.js'));
+}
+function pathStartsWith(pathValue, dir) {
+    if (!pathValue)
+        return false;
+    const resolvedPath = resolvePath(pathValue);
+    const resolvedDir = resolvePath(dir);
+    return resolvedPath === resolvedDir || resolvedPath.startsWith(resolvedDir + sep);
+}
+// Shared by update-check.ts and gsd command handlers. The JS installer keeps a
+// parallel copy because it runs before TypeScript output exists.
+export function isPnpmInstall(argv1 = process.argv[1], env = process.env) {
+    if (env.npm_config_user_agent?.startsWith('pnpm/'))
+        return true;
+    if (hasPnpmPath(env.npm_execpath))
+        return true;
+    if (hasPnpmPath(argv1))
+        return true;
+    if (!argv1)
+        return false;
+    const pnpmBinDirs = [];
+    if (env.PNPM_HOME)
+        pnpmBinDirs.push(env.PNPM_HOME);
+    pnpmBinDirs.push(join(homedir(), 'Library', 'pnpm'));
+    pnpmBinDirs.push(join(homedir(), '.local', 'share', 'pnpm'));
+    return pnpmBinDirs.some((dir) => pathStartsWith(argv1, dir) || pathStartsWith(env.npm_execpath, dir));
+}

package/dist/update-check.d.ts

@@ -1,3 +1,5 @@
+import { isPnpmInstall } from './resources/shared/package-manager-detection.js';
+export { isPnpmInstall };
 interface UpdateCheckCache {
     lastCheck: number;
     latestVersion: string;
@@ -22,7 +24,10 @@ export declare function fetchLatestVersionFromRegistry(registryUrl?: string, fet
  * (PR #4147) misses this path. Inspect the unresolved invocation path instead.
  */
 export declare function isBunInstall(argv1?: string | undefined): boolean;
-export declare function resolveInstallCommand(pkg: string): string;
+export declare function resolveInstallCommand(pkg: string, options?: {
+    argv1?: string;
+    env?: NodeJS.ProcessEnv;
+}): string;
 export interface UpdateCheckOptions {
     currentVersion?: string;
     cachePath?: string;
@@ -45,4 +50,3 @@ export declare function checkForUpdates(options?: UpdateCheckOptions): Promise<v
  * Returns true if an update was performed, false otherwise.
  */
 export declare function checkAndPromptForUpdates(options?: UpdateCheckOptions): Promise<boolean>;
-export {};

package/dist/update-check.js

@@ -1,9 +1,11 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { execSync } from 'node:child_process';
 import { dirname, join, resolve as resolvePath, sep } from 'node:path';
 import { homedir } from 'node:os';
 import chalk from 'chalk';
 import { appRoot } from './app-paths.js';
-import { execSync } from 'node:child_process';
+import { isPnpmInstall } from './resources/shared/package-manager-detection.js';
+export { isPnpmInstall };
 const CACHE_FILE = join(appRoot, '.update-check');
 const NPM_PACKAGE_NAME = '@opengsd/gsd-pi';
 const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
@@ -91,9 +93,11 @@ export function isBunInstall(argv1 = process.argv[1]) {
     const resolved = resolvePath(argv1);
     return bunBinDirs.some((dir) => resolved.startsWith(resolvePath(dir) + sep));
 }
-export function resolveInstallCommand(pkg) {
-    if (isBunInstall())
+export function resolveInstallCommand(pkg, options = {}) {
+    if (isBunInstall(options.argv1))
         return `bun add -g ${pkg}`;
+    if (isPnpmInstall(options.argv1, options.env))
+        return `pnpm add -g ${pkg}`;
     return `npm install -g ${pkg}`;
 }
 function printUpdateBanner(current, latest) {

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

@@ -1 +1 @@
--P554bKh56nzavKUmvFM2
+mijI90BL1BdUcMUnhC0HU

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

@@ -1,27 +1,27 @@
 {
   "/_not-found/page": "/_not-found",
   "/_global-error/page": "/_global-error",
-  "/api/bridge-terminal/resize/route": "/api/bridge-terminal/resize",
   "/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/browse-directories/route": "/api/browse-directories",
+  "/api/cleanup/route": "/api/cleanup",
   "/api/captures/route": "/api/captures",
   "/api/dev-mode/route": "/api/dev-mode",
-  "/api/cleanup/route": "/api/cleanup",
-  "/api/browse-directories/route": "/api/browse-directories",
-  "/api/bridge-terminal/input/route": "/api/bridge-terminal/input",
   "/api/doctor/route": "/api/doctor",
   "/api/export-data/route": "/api/export-data",
-  "/api/experimental/route": "/api/experimental",
   "/api/forensics/route": "/api/forensics",
   "/api/git/route": "/api/git",
+  "/api/experimental/route": "/api/experimental",
   "/api/history/route": "/api/history",
   "/api/hooks/route": "/api/hooks",
   "/api/inspect/route": "/api/inspect",
   "/api/knowledge/route": "/api/knowledge",
   "/api/live-state/route": "/api/live-state",
-  "/api/files/route": "/api/files",
   "/api/mcp-connections/route": "/api/mcp-connections",
   "/api/notifications/route": "/api/notifications",
+  "/api/files/route": "/api/files",
   "/api/onboarding/route": "/api/onboarding",
   "/api/preferences/route": "/api/preferences",
   "/api/recovery/route": "/api/recovery",
@@ -29,8 +29,8 @@
   "/api/session/browser/route": "/api/session/browser",
   "/api/session/command/route": "/api/session/command",
   "/api/session/events/route": "/api/session/events",
-  "/api/settings-data/route": "/api/settings-data",
   "/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/remote-questions/route": "/api/remote-questions",

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

@@ -4,8 +4,8 @@
   ],
   "devFiles": [],
   "lowPriorityFiles": [
-    "static/-P554bKh56nzavKUmvFM2/_buildManifest.js",
-    "static/-P554bKh56nzavKUmvFM2/_ssgManifest.js"
+    "static/mijI90BL1BdUcMUnhC0HU/_buildManifest.js",
+    "static/mijI90BL1BdUcMUnhC0HU/_ssgManifest.js"
   ],
   "rootMainFiles": [
     "static/chunks/webpack-41a6d3c17ba63b62.js",

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

@@ -78,8 +78,8 @@
   "dynamicRoutes": {},
   "notFoundRoutes": [],
   "preview": {
-    "previewModeId": "8509b2b059764aaca9a314862c495677",
-    "previewModeSigningKey": "111025ead699007f28945705063708efd3c1f4282efe22060d5caa54f48f8410",
-    "previewModeEncryptionKey": "c74a2da9c40cae424b15ebea096385efbbe45b67de04619cb672f968f2d3aa1c"
+    "previewModeId": "b0c8967ff02bb3be0998b3c2be0d6bec",
+    "previewModeSigningKey": "6e4615d1d87113363594bc054198319a74821f3b9e5242aad52e96e18261e56c",
+    "previewModeEncryptionKey": "5658cf050af19d64a3d3d918a64d88f5d24b6eaaec39c243ab405d032f435c0b"
   }
 }