@prestyj/cli 5.9.0 → 5.10.0

package/README.md

@@ -69,7 +69,7 @@ Switch mid-conversation with `/model`. Not locked to anyone.
 
 | Provider | Models | Auth |
 |---|---|---|
-| **Anthropic** | Claude Opus 4.8, Sonnet 5, Haiku 4.5 | OAuth |
+| **Anthropic** | Claude Opus 5, Sonnet 5, Haiku 4.5 | OAuth |
 | **OpenAI** | GPT-5.5, GPT-5.5 Pro, GPT-5.4, GPT-5.3 Codex | OAuth |
 | **Moonshot** | Kimi K3, Kimi K2.7 Code | OAuth or API key |
 | **Z.AI (GLM)** | GLM-5.1, GLM-4.7, GLM-4.7 Flash | API key |

package/assets/skills/evidence-led-ui/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: evidence-led-ui
-description: Use for web/mobile UI changes or evaluation: pages, components, dashboards, design systems, responsiveness, accessibility, or visual polish, even without explicit design request. Exclude database/API schemas, CLI output, copy-only work, standalone image/SVG generation, and description-only tasks.
+description: Use for broad or design-sensitive web/mobile UI work: net-new pages/screens, redesigns, design-system work, visual polish, responsive or accessibility overhauls, and UI quality review/critique. Do NOT use for small UI edits that follow existing patterns (bug fixes, minor styling tweaks, wiring, copy changes, small component additions matching neighbors); just match the surrounding code for those. Also exclude database/API schemas, CLI output, standalone image/SVG generation, and description-only tasks.
 license: See LICENSES.md
 compatibility: Full review requires filesystem inspection and rendered screenshots; web research and browser/device tooling are optional and unavailable checks must be reported honestly.
 ---

package/dist/app-sidecar.js

@@ -21,6 +21,7 @@ import { parseArgs } from "node:util";
 import { environmentSecrets, formatError, redactValue } from "@prestyj/ai";
 import { runJsonMode } from "./modes/json-mode.js";
 import { runSubagentWorkerMode } from "./modes/subagent-worker-mode.js";
+import { setStreamDiagnostic } from "@prestyj/agent";
 import { AgentSession } from "./core/agent-session.js";
 import { RunLifecycle } from "./core/run-lifecycle.js";
 import { CHAT_AGENT_IDS, chatAgentSessionsDir, createChatAgent, parseChatAgentId, switchChatAgent, } from "./chat-agents/index.js";
@@ -33,10 +34,12 @@ import { isWorkflowCommandText, countAssistantMessages, shouldStartAutopilotCycl
 import { driveAutopilotCycle, frameAutopilotInjection } from "./core/autopilot-cycle.js";
 import { validateNolanModelPref, effectiveNolanModel, } from "./core/nolan-model.js";
 import { normalizeAutopilotMarkersForHistory, normalizeAppMarkersForHistory, normalizeNolanTurnsForHistory, restoreUserRow, restoreAssistantTexts, autopilotMarkerCopySeed, } from "./core/session-history.js";
+import { sessionToMarkdown, defaultExportFilename, } from "./core/session-export.js";
 import { AuthStorage } from "./core/auth-storage.js";
 import { cleanupToolOutputs } from "./tools/overflow.js";
 import { readCappedBody } from "./utils/http-body.js";
-import { fetchSubscriptionUsage, MOONSHOT_OAUTH_KEY, SubscriptionUsageError, XIAOMI_CREDITS_KEY, } from "@prestyj/core";
+import { fetchSubscriptionUsage, MOONSHOT_OAUTH_KEY, SubscriptionUsageError, XIAOMI_CREDITS_KEY, discoverLocalModels, findProbedModel, formatLocalModelId, parseLocalModelId, probeEndpoint, toModelInfo as localModelInfo, } from "@prestyj/core";
+import { LocalEndpointError, addCustomEndpoint, listAllEndpoints, removeCustomEndpoint, syncEndpointCredentials, } from "./core/local-endpoint-store.js";
 import { loginAnthropic } from "./core/oauth/anthropic.js";
 import { loginOpenAI } from "./core/oauth/openai.js";
 import { loginGemini } from "./core/oauth/gemini.js";
@@ -44,9 +47,10 @@ import { loginKimi } from "./core/oauth/kimi.js";
 import { AUTH_PROVIDERS } from "./core/auth-providers.js";
 import { ensureAppDirs, loadSavedSettings } from "./config.js";
 import { SettingsManager } from "./core/settings-manager.js";
-import { getModel, getDefaultThinkingLevel, getContextWindow, MODELS, } from "./core/model-registry.js";
+import { getModel, getDefaultThinkingLevel, getContextWindow, getAllModels, clearRuntimeModels, registerRuntimeModels, } from "./core/model-registry.js";
 import { resolveStartOrFallback } from "./core/resolve-start.js";
 import { getGitBranch, getGitDirtyFileCount, isGitRepo } from "./utils/git.js";
+import { getGitHubOpenCounts, getGitHubRepoSlug } from "./utils/github.js";
 import { extractPlanSteps } from "./utils/plan-steps.js";
 import { getNextThinkingLevel, getSupportedThinkingLevels, isThinkingLevelSupported, } from "./core/thinking-level.js";
 import { PROMPT_COMMANDS } from "./core/prompt-commands.js";
@@ -344,6 +348,11 @@ async function searchProjectFiles(cwd, rawQuery) {
  * hook prompt, by its distinctive opening phrase. Returns the hook kind so the
  * webview can render the short notice line instead of the full prompt body.
  */
+/** `?tools=` on /export. Anything unrecognised (including absent) falls back to
+ *  the human-facing `summary` default rather than dumping every payload. */
+function parseToolDetail(value) {
+    return value === "none" || value === "full" ? value : "summary";
+}
 function detectHookKind(text) {
     const t = text.trimStart();
     if (t.startsWith("Ideal? Review the actual work"))
@@ -451,6 +460,7 @@ async function runJsonModeIfRequested() {
             "max-turns": { type: "string" },
             "system-prompt": { type: "string" },
             tools: { type: "string" },
+            "mcp-servers": { type: "string" },
             "prompt-cache-key": { type: "string" },
         },
         allowPositionals: true,
@@ -467,14 +477,24 @@ async function runJsonModeIfRequested() {
             .filter(Boolean)
         : [];
     const allowedTools = parsedTools.length > 0 ? parsedTools : undefined;
+    // MCP servers the agent definition asked for. Without forwarding these, an
+    // allow-listed child connects no MCP at all and loses live code search.
+    const parsedMcpServers = values["mcp-servers"]
+        ? values["mcp-servers"]
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean)
+        : [];
+    const allowedMcpServers = parsedMcpServers.length > 0 ? parsedMcpServers : undefined;
     await runJsonMode({
         message: positionals[0] ?? "",
         provider: (values.provider ?? "anthropic"),
-        model: values.model ?? "claude-opus-4-8",
+        model: values.model ?? "claude-opus-5",
         cwd: process.cwd(),
         systemPrompt: values["system-prompt"],
         maxTurns: maxTurnsRaw ? parseInt(maxTurnsRaw, 10) : undefined,
         allowedTools,
+        allowedMcpServers,
         promptCacheKey: values["prompt-cache-key"],
     }).catch(async (err) => {
         captureSidecarError(err, "app-sidecar.json-mode", {
@@ -518,6 +538,31 @@ async function main() {
     // ~/.ezcoder/debug.log (initLogger truncates on each start).
     const sidecarLog = path.join(paths.agentDir, "ezcoder-app-sidecar.log");
     initLogger(sidecarLog);
+    // The desktop sidecar previously omitted the stream diagnostic hook used by
+    // the CLI, leaving device-specific provider stalls impossible to distinguish from
+    // event-loop starvation or a broken streaming network path. Keep routine
+    // phases lightweight; timeout phases include non-sensitive runtime context.
+    setStreamDiagnostic((phase, data) => {
+        const includeRuntime = phase === "idle_timeout_fired" ||
+            phase === "hard_timeout_fired" ||
+            phase === "stall_exhausted";
+        log("INFO", "stream", phase, {
+            ...(data ?? {}),
+            ...(includeRuntime
+                ? {
+                    platform: process.platform,
+                    arch: process.arch,
+                    osRelease: os.release(),
+                    node: process.version,
+                    logicalCpus: os.cpus().length,
+                    totalMemoryMb: Math.round(os.totalmem() / 1024 / 1024),
+                    freeMemoryMb: Math.round(os.freemem() / 1024 / 1024),
+                    rssMb: Math.round(process.memoryUsage().rss / 1024 / 1024),
+                    processUptimeSec: Math.round(process.uptime()),
+                }
+                : {}),
+        });
+    });
     // Global last-resort guards, installed as early as the logger allows so they
     // cover the WHOLE lifecycle — including startup/initialize, the phase the
     // "sidecar did not start in time" bug lives in. The sidecar is a long-lived
@@ -1072,6 +1117,25 @@ async function createSession(deps, opts) {
             // /help
             .replaceAll(/see \/help/gi, "check the help menu"));
     }
+    /**
+     * Guidance for a connection failure against the ACTIVE local endpoint, or
+     * undefined when that isn't the situation (so the generic wording stands).
+     * "Disable your VPN / allow us through the firewall" is useless advice for a
+     * server running on this machine — name what the user has to restart.
+     */
+    function localNetworkGuidance(source) {
+        if (source !== "network")
+            return undefined;
+        const state = session.getState();
+        if (state.provider !== "local")
+            return undefined;
+        const parsed = parseLocalModelId(state.model);
+        const probe = localProbes.find((p) => p.endpoint.id === parsed?.endpointId);
+        if (!probe)
+            return undefined;
+        return (`${probe.endpoint.label} stopped responding at ${probe.endpoint.baseUrl}. ` +
+            "Start it again and retry, or pick another model.");
+    }
     // Turn any thrown value into the same clear headline/message/guidance shape
     // the TUI shows (see gg-ai's formatError) instead of a bare `err.message`, log
     // the full detail, and broadcast it under `type` ("error" or "nolan_error").
@@ -1081,7 +1145,7 @@ async function createSession(deps, opts) {
     function broadcastError(type, logLabel, err) {
         const f = formatError(err);
         const message = f.message ? desktopGuidance(f.message) : undefined;
-        const guidance = desktopGuidance(f.guidance);
+        const guidance = localNetworkGuidance(f.source) ?? desktopGuidance(f.guidance);
         captureSidecarError(err, `app-sidecar.${logLabel.replaceAll(" ", "-")}`, {
             scope: type,
             ...(f.provider ? { provider: f.provider } : {}),
@@ -1197,17 +1261,116 @@ async function createSession(deps, opts) {
         }
     }
     log("INFO", "app-sidecar", "session ready", { provider, model, mode, chatAgent, cwd });
+    // ── Local models (Ollama / LM Studio / llama.cpp / vLLM) ──
+    // Probing four HTTP endpoints must never delay readiness, so this runs in the
+    // background (same shape as backgroundMcpConnect) and pushes a models_change
+    // frame when it lands.
+    let localProbes = [];
+    async function scanLocalModels(force) {
+        const endpoints = await listAllEndpoints();
+        const { probes, models } = await discoverLocalModels(endpoints, { force });
+        localProbes = probes;
+        // Only endpoints that answered get a credential: writing one for a server
+        // that isn't running would make `hasProviderAuth("local")` true forever.
+        await syncEndpointCredentials(probes.filter((probe) => probe.reachable).map((probe) => probe.endpoint));
+        clearRuntimeModels((m) => m.provider === "local");
+        registerRuntimeModels(models);
+        log("INFO", "app-sidecar", "local model scan", {
+            reachable: probes.filter((p) => p.reachable).length + "/" + probes.length,
+            models: String(models.length),
+        });
+        return probes;
+    }
+    /** Endpoint rows + models, in the shape the Local models UI renders. */
+    function localStatePayload() {
+        return {
+            endpoints: localProbes.map((probe) => ({
+                id: probe.endpoint.id,
+                label: probe.endpoint.label,
+                baseUrl: probe.endpoint.baseUrl,
+                kind: probe.endpoint.kind,
+                custom: probe.endpoint.custom === true,
+                reachable: probe.reachable,
+                ...(probe.reason ? { reason: probe.reason } : {}),
+                models: probe.models.map((m) => ({
+                    id: formatLocalModelId(probe.endpoint.id, m.rawId),
+                    rawId: m.rawId,
+                    contextWindow: m.contextWindow,
+                    contextWindowKnown: m.contextWindowKnown,
+                    supportsTools: m.supportsTools,
+                    supportsImages: m.supportsImages,
+                    supportsThinking: m.supportsThinking,
+                    ...(m.loaded === undefined ? {} : { loaded: m.loaded }),
+                })),
+            })),
+        };
+    }
+    /**
+     * Why `modelId` can't be selected right now, or `undefined` when it can.
+     * Two real footguns get a clear answer instead of a mid-run provider error:
+     * a model with no tool calling (can't drive the agent at all), and a server
+     * that has since been shut down.
+     */
+    async function localModelBlocker(modelId) {
+        const parsed = parseLocalModelId(modelId);
+        if (!parsed)
+            return undefined;
+        const endpoints = await listAllEndpoints();
+        const endpoint = endpoints.find((e) => e.id === parsed.endpointId);
+        if (!endpoint)
+            return `Unknown local endpoint "${parsed.endpointId}" — re-scan for local models.`;
+        const probe = await probeEndpoint(endpoint);
+        // Keep the cached view honest: this probe is fresher than the last scan.
+        localProbes = localProbes.map((p) => (p.endpoint.id === endpoint.id ? probe : p));
+        if (!probe.reachable) {
+            return `${endpoint.label} isn't running at ${endpoint.baseUrl}. Start it and scan again.`;
+        }
+        const model = probe.models.find((m) => m.rawId === parsed.rawId);
+        if (!model) {
+            return `${endpoint.label} no longer serves "${parsed.rawId}".`;
+        }
+        if (!model.supportsTools) {
+            return `${parsed.rawId} has no tool calling, so it can't run the agent. Pick a tool-capable model.`;
+        }
+        registerRuntimeModels(probe.models.map((m) => localModelInfo(m, endpoint)));
+        return undefined;
+    }
+    /**
+     * A restored per-project pref can ask for thinking on a local model that
+     * turns out not to reason (capabilities are only known after a probe). Drop
+     * the level once we know, so the first prompt doesn't carry a
+     * `reasoning_effort` the server rejects.
+     */
+    function clampLocalThinking() {
+        const st = session.getState();
+        const level = session.getThinkingLevel();
+        if (!level || st.provider !== "local")
+            return;
+        if (isThinkingLevelSupported(st.provider, st.model, level))
+            return;
+        session.setThinkingLevel(undefined);
+        broadcast("thinking_change", {
+            thinkingLevel: null,
+            supportedThinkingLevels: getSupportedThinkingLevels(st.provider, st.model),
+        });
+    }
     // Workspace extras (context window, git status, background tasks). Git state
     // is resolved once at startup and refreshed after every run; the context
     // window follows the active model.
-    const [initialGitBranch, initialGitIsRepo, initialDirtyFileCount] = await Promise.all([
+    const [initialGitBranch, initialGitIsRepo, initialDirtyFileCount, initialGitHubSlug] = await Promise.all([
         getGitBranch(cwd).catch(() => null),
         isGitRepo(cwd).catch(() => false),
         getGitDirtyFileCount(cwd).catch(() => 0),
+        getGitHubRepoSlug(cwd).catch(() => null),
     ]);
     let gitBranch = initialGitBranch;
     let gitIsRepo = initialGitIsRepo;
     let gitDirtyFileCount = initialDirtyFileCount;
+    // Open issue/PR counts for the origin repo's GitHub slug, via the `gh` CLI's
+    // auth. null = unknown (gh missing/unauthed, non-GitHub origin) → chips hidden.
+    const gitHubSlug = initialGitHubSlug;
+    let gitHubIssues = null;
+    let gitHubPRs = null;
     function currentContextWindow() {
         const st = session.getState();
         return getContextWindow(st.model, { provider: st.provider, accountId: st.accountId });
@@ -1220,9 +1383,41 @@ async function createSession(deps, opts) {
             gitBranch,
             isGitRepo: gitIsRepo,
             gitDirtyFileCount,
+            gitHubIssues,
+            gitHubPRs,
+            gitHubRepoUrl: gitHubSlug ? `https://github.com/${gitHubSlug}` : null,
             tasks: session.listBackgroundProcesses(),
+            // Roots added with /add-dir — the header shows a badge when non-empty.
+            additionalRoots: session.getAdditionalRoots(),
         };
     }
+    void scanLocalModels(false)
+        .then(() => {
+        clampLocalThinking();
+        broadcast("extras", footerExtras());
+    })
+        .then(() => broadcast("models_change", { local: localStatePayload() }))
+        .catch((err) => {
+        // A discovery failure is never fatal — the user simply has no local
+        // models. Log it; don't push an error row into the transcript.
+        log("WARN", "app-sidecar", "local model scan failed", {
+            error: err instanceof Error ? err.message : String(err),
+        });
+    });
+    // Refresh the GitHub counts and broadcast only on change. Transient failures
+    // keep the last-known numbers so the chips don't flicker off on a timeout.
+    async function refreshGitHubCounts() {
+        if (!gitHubSlug)
+            return;
+        const counts = await getGitHubOpenCounts(gitHubSlug);
+        if (!counts)
+            return;
+        if (counts.issues !== gitHubIssues || counts.prs !== gitHubPRs) {
+            gitHubIssues = counts.issues;
+            gitHubPRs = counts.prs;
+            broadcast("extras", footerExtras());
+        }
+    }
     // tool_call_end carries no tool name (only the id), so remember each call's
     // name from tool_call_start to log a useful line on completion. Mirrors the
     // CLI's logging so the app sidecar's ~/.ezcoder/ezcoder-app-sidecar.log records tool
@@ -1664,6 +1859,9 @@ async function createSession(deps, opts) {
                 isGitRepo(cwd).catch(() => gitIsRepo),
                 getGitDirtyFileCount(cwd).catch(() => gitDirtyFileCount),
             ]);
+            // A run may have opened/closed issues or PRs — refresh fire-and-forget so
+            // teardown isn't delayed by the network. Broadcasts itself on change.
+            void refreshGitHubCounts();
             // Serialize behind any marker/tool-triggered refresh so the terminal
             // progress snapshot uses the live plan file. Once every canonical step
             // is complete, remove the approved plan from future system prompts and
@@ -2136,6 +2334,20 @@ async function createSession(deps, opts) {
         gitPoll.unref?.();
     };
     scheduleGitPoll(5000);
+    // GitHub issue/PR counts change outside the app (web UI, teammates), so poll
+    // on a slow cadence. Network-bound, so keep it well under the search API's
+    // rate budget (2 calls per tick). No-op when the origin isn't a GitHub repo.
+    let gitHubPoll;
+    let gitHubPollStopped = false;
+    const scheduleGitHubPoll = (delay) => {
+        if (gitHubPollStopped)
+            return;
+        gitHubPoll = setTimeout(() => {
+            void refreshGitHubCounts().finally(() => scheduleGitHubPoll(60_000));
+        }, delay);
+        gitHubPoll.unref?.();
+    };
+    scheduleGitHubPoll(2000);
     function readBody(req, res) {
         return readCappedBody(req, res);
     }
@@ -2386,6 +2598,30 @@ async function createSession(deps, opts) {
             });
             return;
         }
+        // Markdown transcript export for the app's download button. Serialized
+        // here rather than in the webview because the webview's transcript model
+        // deliberately keeps tool activity in the LiveToolPanel — exporting from
+        // there would hand the user a coding session with the coding missing.
+        // `?name=1` asks for the suggested filename only (the save dialog needs it
+        // before there is a path), so the markdown never crosses IPC twice.
+        if (method === "GET" && (url === "/export" || url.startsWith("/export?"))) {
+            const query = new URLSearchParams(url.slice(url.indexOf("?") + 1));
+            const st = session.getState();
+            const filename = defaultExportFilename(mode);
+            if (query.get("name") === "1") {
+                json(res, 200, { filename });
+                return;
+            }
+            const markdown = sessionToMarkdown({
+                mode,
+                cwd,
+                provider: st.provider,
+                model: st.model,
+                ...(st.sessionId ? { sessionId: st.sessionId } : {}),
+            }, session.getMessages(), { toolDetail: parseToolDetail(query.get("tools")) });
+            json(res, 200, { filename, markdown });
+            return;
+        }
         if (method === "GET" && url === "/history") {
             // Reconstruct the transcript from persisted messages so resume is 1:1 with
             // the live SSE stream. Walks ALL message types (not just user/assistant):
@@ -2705,16 +2941,34 @@ async function createSession(deps, opts) {
                     description: c.description,
                     source: "built-in",
                 }));
+                // Desktop-safe registry actions belong in the same picker as workflows.
+                // Most registry commands have dedicated app controls or TUI-only flows;
+                // multi-root management has no other affordance, so expose only these.
+                const workspaceActions = [
+                    {
+                        name: "add-dir",
+                        aliases: ["adddir"],
+                        description: "Add another project folder to this workspace",
+                        source: "built-in",
+                    },
+                    {
+                        name: "remove-dir",
+                        aliases: ["removedir"],
+                        description: "Remove an added project folder from this workspace",
+                        source: "built-in",
+                    },
+                ];
                 const custom = (await loadCustomCommands(cwd))
-                    // A custom command can't shadow a built-in name.
-                    .filter((c) => !PROMPT_COMMANDS.some((b) => b.name === c.name))
+                    // A custom command can't shadow a built-in name or app action.
+                    .filter((c) => !PROMPT_COMMANDS.some((b) => b.name === c.name) &&
+                    !workspaceActions.some((action) => action.name === c.name))
                     .map((c) => ({
                     name: c.name,
                     aliases: [],
                     description: c.description,
                     source: "custom",
                 }));
-                json(res, 200, { commands: [...builtins, ...custom] });
+                json(res, 200, { commands: [...workspaceActions, ...builtins, ...custom] });
             })();
             return;
         }
@@ -3173,12 +3427,30 @@ async function createSession(deps, opts) {
                         loggedIn.push(p);
                 }
                 // Just the names, grouped by provider in registry order — the UI shows
-                // a clean multi-column list of model ids.
-                const models = MODELS.filter((m) => loggedIn.includes(m.provider)).map((m) => ({
-                    id: m.id,
-                    name: m.name,
-                    provider: m.provider,
-                }));
+                // a clean multi-column list of model ids. Local models come from the
+                // runtime registry (populated by the background scan) and are always
+                // listed: their "login" is the endpoint answering a probe.
+                const models = getAllModels()
+                    .filter((m) => m.provider === "local" || loggedIn.includes(m.provider))
+                    .map((m) => {
+                    if (m.provider !== "local") {
+                        return { id: m.id, name: m.name, provider: m.provider };
+                    }
+                    const probed = findProbedModel(localProbes, m.id);
+                    return {
+                        id: m.id,
+                        name: m.name,
+                        provider: m.provider,
+                        local: true,
+                        endpoint: probed?.endpoint.label ?? parseLocalModelId(m.id)?.endpointId,
+                        // A local model that can't call tools can't run the agent — the UI
+                        // renders it disabled rather than hiding it, so the user learns why.
+                        supportsTools: probed?.model.supportsTools ?? true,
+                        contextWindow: m.contextWindow,
+                        contextWindowKnown: probed?.model.contextWindowKnown ?? false,
+                        supportsThinking: m.supportsThinking,
+                    };
+                });
                 json(res, 200, { models });
             })();
             return;
@@ -3207,6 +3479,13 @@ async function createSession(deps, opts) {
                 // Pick up any natively-written keys (desktop app) before resolving the
                 // new model's credentials, so switching to a just-added provider works.
                 await auth.reload();
+                if (target.provider === "local") {
+                    const problem = await localModelBlocker(target.id);
+                    if (problem) {
+                        json(res, 409, { error: problem });
+                        return;
+                    }
+                }
                 await session.switchModel(target.provider, target.id);
                 // Nolan follows EZ Coder's model only while un-pinned; a user-set Nolan
                 // override survives EZ Coder model switches untouched.
@@ -3632,6 +3911,84 @@ async function createSession(deps, opts) {
             });
             return;
         }
+        // ── Local models ──────────────────────────────────────
+        // GET returns the last scan (cheap, no probing) so opening the modal is
+        // instant; POST /local/scan is the explicit refresh.
+        if (method === "GET" && url === "/local") {
+            json(res, 200, localStatePayload());
+            return;
+        }
+        if (method === "POST" && url === "/local/scan") {
+            void scanLocalModels(true)
+                .then(() => {
+                broadcast("models_change", { local: localStatePayload() });
+                json(res, 200, localStatePayload());
+            })
+                .catch((err) => {
+                broadcastError("error", "local model scan failed", err);
+                json(res, 500, { error: "Local model scan failed — see the sidecar log." });
+            });
+            return;
+        }
+        if (method === "POST" && url === "/local/endpoints") {
+            void readBody(req, res).then(async (raw) => {
+                if (raw === null)
+                    return;
+                let body;
+                try {
+                    body = JSON.parse(raw);
+                }
+                catch {
+                    json(res, 400, { error: "invalid JSON body" });
+                    return;
+                }
+                try {
+                    const endpoint = await addCustomEndpoint({
+                        baseUrl: body.baseUrl ?? "",
+                        ...(body.label ? { label: body.label } : {}),
+                        ...(body.apiKey ? { apiKey: body.apiKey } : {}),
+                    });
+                    await scanLocalModels(true);
+                    broadcast("models_change", { local: localStatePayload() });
+                    json(res, 200, {
+                        endpoint: { id: endpoint.id, label: endpoint.label },
+                        ...localStatePayload(),
+                    });
+                }
+                catch (err) {
+                    // Validation errors are the user's typo, not a system fault — 400 with
+                    // the exact reason, and nothing in the transcript.
+                    if (err instanceof LocalEndpointError) {
+                        json(res, 400, { error: err.message });
+                        return;
+                    }
+                    broadcastError("error", "add local endpoint failed", err);
+                    json(res, 500, { error: "Could not save the endpoint — see the sidecar log." });
+                }
+            });
+            return;
+        }
+        if (method === "DELETE" && url.startsWith("/local/endpoints/")) {
+            const id = decodeURIComponent(url.slice("/local/endpoints/".length));
+            void (async () => {
+                try {
+                    await removeCustomEndpoint(id);
+                    clearRuntimeModels((m) => m.provider === "local" && parseLocalModelId(m.id)?.endpointId === id);
+                    await scanLocalModels(true);
+                    broadcast("models_change", { local: localStatePayload() });
+                    json(res, 200, localStatePayload());
+                }
+                catch (err) {
+                    if (err instanceof LocalEndpointError) {
+                        json(res, 400, { error: err.message });
+                        return;
+                    }
+                    broadcastError("error", "remove local endpoint failed", err);
+                    json(res, 500, { error: "Could not remove the endpoint — see the sidecar log." });
+                }
+            })();
+            return;
+        }
         // ── Telegram config (mirrors `ezcoder telegram`) ─────────
         if (method === "GET" && url === "/telegram") {
             void loadTelegramConfig().then((cfg) => {
@@ -3919,6 +4276,9 @@ async function createSession(deps, opts) {
         gitPollStopped = true;
         if (gitPoll)
             clearTimeout(gitPoll);
+        gitHubPollStopped = true;
+        if (gitHubPoll)
+            clearTimeout(gitHubPoll);
         // Stop the Telegram serve loop + dispose its per-chat sessions.
         if (serveController)
             await serveController.stop().catch(() => { });