@kenkaiiii/ggcoder 5.68.1 → 5.70.0

package/dist/app-sidecar.js

@@ -42,6 +42,7 @@ import { sessionToMarkdown, defaultExportFilename, } from "./core/session-export
 import { AuthStorage } from "./core/auth-storage.js";
 import { advancesPhase, explainPullFailure, isGgufShard, isValidHfRepoId, parseOllamaPullLine, pickGgufQuant, SHARDED_MESSAGE, toHfSearchRow, } from "./hf-pull.js";
 import { cleanupToolOutputs } from "./tools/overflow.js";
+import { spawnedTasks } from "./tools/subagent-shared.js";
 import { readCappedBody } from "./utils/http-body.js";
 import { fetchSubscriptionUsage, SubscriptionUsageError, XIAOMI_CREDITS_KEY, dualAuthProvider, oauthStorageKey, discoverLocalModels, findProbedModel, formatLocalModelId, parseLocalModelId, probeEndpoint, toModelInfo as localModelInfo, } from "@kenkaiiii/gg-core";
 import { LocalEndpointError, addCustomEndpoint, listAllEndpoints, removeCustomEndpoint, syncEndpointCredentials, } from "./core/local-endpoint-store.js";
@@ -995,6 +996,11 @@ async function main() {
     const shutdown = installTerminationHandlers({
         scope: "app-sidecar",
         teardown: async () => {
+            // Before any await: background commands live outside the daemon's process
+            // group, and the app force-kills that group after 3 s. If a slow session
+            // teardown is still pending then, these would never be stopped.
+            for (const c of sessions.values())
+                c.stopBackgroundProcesses();
             clearInterval(parentWatch);
             // Radio playback is app-wide (one stream across all windows), so it stops
             // at the daemon level, not per session.
@@ -1993,6 +1999,12 @@ async function createSession(deps, opts) {
     session.eventBus.on("subagent_state", (d) => broadcast("subagent_state", d));
     session.eventBus.on("compaction_start", (d) => broadcast("compaction_start", d));
     session.eventBus.on("compaction_end", (d) => broadcast("compaction_end", d));
+    // Cold-prompt-cache notice: push the fresh TTL anchor + context size whenever
+    // a run or compaction settles. Expiry itself is time-based, so the webview
+    // also re-reads `cacheExpiry` from /state when the user returns or types.
+    for (const ev of ["agent_done", "compaction_end", "model_change"]) {
+        session.eventBus.on(ev, () => broadcast("cache_expiry", session.getCacheExpiryStatus()));
+    }
     // Keep the computer awake while this window's agent works: owned runs and
     // autopilot cycles (RunLifecycle state), Ken replies, and background
     // sub-agents that outlive their parent run. Released on settle (completed,
@@ -2930,6 +2942,7 @@ async function createSession(deps, opts) {
                 supportedThinkingLevels: getSupportedThinkingLevels(st.provider, st.model),
                 supportsVideo: getModel(st.model)?.supportsVideo ?? false,
                 autopilot,
+                cacheExpiry: session.getCacheExpiryStatus(),
                 ...kenStatePayload(),
                 ...footerExtras(),
             });
@@ -3550,18 +3563,25 @@ async function createSession(deps, opts) {
                     if (msg.role === "assistant" && typeof msg.content !== "string") {
                         const subagentCalls = msg.content.filter((c) => c.type === "tool_call" && (c.name === "subagent" || c.name === "spawn_agent"));
                         if (subagentCalls.length > 0) {
-                            const agents = subagentCalls.map((c) => {
+                            const agents = subagentCalls.flatMap((c) => {
                                 const result = toolResultMap.get(c.id);
-                                return {
-                                    agentName: c.name === "spawn_agent" && typeof c.args?.task_name === "string"
-                                        ? c.args.task_name
-                                        : typeof c.args?.agent === "string"
-                                            ? c.args.agent
-                                            : undefined,
-                                    // Async workers are intentionally non-resumable; restored rows are historical.
-                                    status: result?.isError ? "error" : "done",
-                                    toolUseCount: 0,
-                                };
+                                // Async workers are intentionally non-resumable; restored rows are historical.
+                                const status = result?.isError ? "error" : "done";
+                                if (c.name === "spawn_agent") {
+                                    // One row per child: a batch call starts several.
+                                    return spawnedTasks(c.args).map((spawn) => ({
+                                        agentName: spawn.task_name ?? spawn.agent,
+                                        status,
+                                        toolUseCount: 0,
+                                    }));
+                                }
+                                return [
+                                    {
+                                        agentName: typeof c.args?.agent === "string" ? c.args.agent : undefined,
+                                        status,
+                                        toolUseCount: 0,
+                                    },
+                                ];
                             });
                             history.push({
                                 role: "assistant",
@@ -5223,6 +5243,11 @@ async function createSession(deps, opts) {
         await kenAutoSession?.dispose().catch(() => { });
         await session.dispose().catch(() => { });
     }
+    function stopBackgroundProcesses() {
+        session.stopBackgroundProcesses();
+        kenSession?.stopBackgroundProcesses();
+        kenAutoSession?.stopBackgroundProcesses();
+    }
     return {
         id: opts.id,
         mode,
@@ -5236,6 +5261,7 @@ async function createSession(deps, opts) {
         broadcast,
         handle,
         dispose,
+        stopBackgroundProcesses,
     };
 }
 main().catch(async (err) => {