@kenkaiiii/ggcoder 5.26.0 → 5.26.2

package/dist/app-sidecar.js

@@ -24,6 +24,7 @@ import { runSubagentWorkerMode } from "./modes/subagent-worker-mode.js";
 import { setStreamDiagnostic } from "@kenkaiiii/gg-agent";
 import { AgentSession } from "./core/agent-session.js";
 import { RunLifecycle } from "./core/run-lifecycle.js";
+import { RunClaim } from "./core/run-claim.js";
 import { CHAT_AGENT_IDS, chatAgentSessionsDir, createChatAgent, parseChatAgentId, switchChatAgent, } from "./chat-agents/index.js";
 import { buildJiwaTools, JiwaStore } from "./chat-agents/jiwa.js";
 import { buildMemoryTools, MemoryStore } from "./chat-agents/memory.js";
@@ -1532,6 +1533,10 @@ async function createSession(deps, opts) {
         recordApprovedPlanMarkers(d.text);
     });
     session.eventBus.on("thinking_delta", (d) => broadcast("thinking_delta", d));
+    // The agent consumed queued steering at a turn boundary. Re-broadcast as the
+    // usual `queued` depth update so the webview drops the pending affordance the
+    // moment the message lands in the loop, not at run_end.
+    session.eventBus.on("queue_drained", (d) => broadcast("queued", { count: d.count, messages: session.listQueuedMessages() }));
     session.eventBus.on("tool_call_start", (d) => {
         toolCallNames.set(d.toolCallId, d.name);
         broadcast("tool_call_start", d);
@@ -1577,6 +1582,10 @@ async function createSession(deps, opts) {
     session.eventBus.on("compaction_start", (d) => broadcast("compaction_start", d));
     session.eventBus.on("compaction_end", (d) => broadcast("compaction_end", d));
     let running = false;
+    // Closes the window between `/prompt` deciding to start a run and `runAgent`
+    // flipping `running` — that stretch awaits, so Node yields inside it. See
+    // RunClaim.
+    const runClaim = new RunClaim();
     const runLifecycle = new RunLifecycle((runState) => {
         running = runState !== "idle";
         if (runState === "cancelling")
@@ -1913,7 +1922,10 @@ async function createSession(deps, opts) {
             // runAutopilotCycle), NOT from this shared finally — that keeps injected
             // runs from recursively entering the same review loop.
             broadcast("tasks_list", { tasks: pruneDoneTasksSync(cwd) });
-            broadcast("queued", { count: session.getQueuedCount() });
+            broadcast("queued", {
+                count: session.getQueuedCount(),
+                messages: session.listQueuedMessages(),
+            });
             broadcast("extras", footerExtras());
         }
     }
@@ -2159,7 +2171,10 @@ async function createSession(deps, opts) {
                 const next = session.takeNextQueuedMessage();
                 if (!next)
                     return;
-                broadcast("queued", { count: session.getQueuedCount() });
+                broadcast("queued", {
+                    count: session.getQueuedCount(),
+                    messages: session.listQueuedMessages(),
+                });
                 if (!next.text.trim() && next.attachments.length === 0)
                     continue;
                 // A queued message draining as a fresh turn supersedes any pending
@@ -2402,50 +2417,6 @@ async function createSession(deps, opts) {
             });
             return;
         }
-        // Durable per-project journal (.gg/memory.md). Distinct from /memories,
-        // which is the personal chat-memory store shared by the chat agents.
-        if (method === "GET" && url === "/project-memory") {
-            void (async () => {
-                try {
-                    const sm = new SettingsManager(paths.settingsFile);
-                    await sm.load();
-                    json(res, 200, { enabled: sm.get("memoryEnabled") });
-                }
-                catch (error) {
-                    captureSidecarError(error, "app-sidecar.project-memory.get");
-                    json(res, 500, { error: error instanceof Error ? error.message : String(error) });
-                }
-            })();
-            return;
-        }
-        if (method === "POST" && url === "/project-memory") {
-            void readBody(req, res).then(async (raw) => {
-                if (raw === null)
-                    return;
-                let enabled;
-                try {
-                    enabled = JSON.parse(raw).enabled === true;
-                }
-                catch {
-                    json(res, 400, { error: "invalid JSON body" });
-                    return;
-                }
-                try {
-                    const sm = new SettingsManager(paths.settingsFile);
-                    await sm.load();
-                    await sm.set("memoryEnabled", enabled);
-                    // Applies from the next session: the journal handle is built during
-                    // AgentSession.initialize(), so a live run keeps its current behaviour
-                    // rather than half-applying the change mid-task.
-                    json(res, 200, { enabled });
-                }
-                catch (error) {
-                    captureSidecarError(error, "app-sidecar.project-memory.set");
-                    json(res, 500, { error: error instanceof Error ? error.message : String(error) });
-                }
-            });
-            return;
-        }
         if (method === "GET" && url === "/jiwa") {
             void jiwaStore
                 .snapshot()
@@ -3009,7 +2980,12 @@ async function createSession(deps, opts) {
             return;
         }
         if (method === "POST" && url === "/prompt") {
-            void readBody(req, res).then(async (raw) => {
+            // Per-request: only the prompt that actually claimed the start may release
+            // it. A bare release would let an early-returning request (bad JSON, or a
+            // prompt that queued) clear a claim another request is still holding.
+            let claimedStart = false;
+            void readBody(req, res)
+                .then(async (raw) => {
                 if (raw === null)
                     return;
                 let text;
@@ -3029,14 +3005,17 @@ async function createSession(deps, opts) {
                     json(res, 400, { error: "empty prompt" });
                     return;
                 }
-                if (runLifecycle.running && runLifecycle.isCancellationRequested(runLifecycle.generation)) {
+                if (runLifecycle.running &&
+                    runLifecycle.isCancellationRequested(runLifecycle.generation)) {
                     json(res, 409, {
                         error: runLifecycle.state === "cancelling" ? "run_cancelling" : "cancel_failed",
                         runState: runLifecycle.state,
                     });
                     return;
                 }
-                if (running || autopilotActive) {
+                // `runClaim` covers the gap before `runAgent` flips `running`: a
+                // prompt arriving in that window must queue, not start a second run.
+                if (running || runClaim.active || autopilotActive) {
                     // Queue prompts as mid-run steering (mirrors the CLI). Also queue while
                     // an autopilot cycle is active but between injected runs (build idle,
                     // Ken reviewing) so the message never starts a run that collides with
@@ -3045,10 +3024,13 @@ async function createSession(deps, opts) {
                     // path as a non-queued attachment prompt when it drains.
                     const prepared = attachments.length > 0 ? await prepareAttachments(cwd, attachments) : [];
                     const count = session.queueMessage(text, prepared);
-                    broadcast("queued", { count });
+                    broadcast("queued", { count, messages: session.listQueuedMessages() });
                     json(res, 202, { queued: true, count });
                     return;
                 }
+                // Claim the run NOW, synchronously. Everything below this line may
+                // yield, and `running` does not flip until runAgent begins.
+                claimedStart = runClaim.claim();
                 json(res, 202, { accepted: true });
                 // Webview display hint for this prompt's user bubble (kenSent shimmer
                 // label / enhancer highlight segments). Anchored +1 so it attaches to
@@ -3074,7 +3056,8 @@ async function createSession(deps, opts) {
                 // how many assistant messages the run actually adds. Computed even when
                 // autopilot is currently off — the toggle can flip ON mid-run, and the
                 // gate reads the post-run value.
-                const workflowCommand = attachments.length === 0 && isWorkflowCommandText(text, await loadWorkflowCommandSpecs());
+                const workflowCommand = attachments.length === 0 &&
+                    isWorkflowCommandText(text, await loadWorkflowCommandSpecs());
                 const assistantsBefore = countAssistantMessages(session.getMessages());
                 const messagesBefore = session.getMessages().length;
                 await runAgent(text, async () => {
@@ -3126,6 +3109,10 @@ async function createSession(deps, opts) {
                 // A prompt sent while Ken was reviewing (build idle) queued but had no
                 // run to steer into — run it now as a fresh turn so it never strands.
                 await runStrandedQueue();
+            })
+                .finally(() => {
+                if (claimedStart)
+                    runClaim.release();
             });
             return;
         }
@@ -3529,6 +3516,38 @@ async function createSession(deps, opts) {
             });
             return;
         }
+        // Pending queued steering, for the composer's cancel affordance.
+        if (method === "GET" && url === "/queued") {
+            json(res, 200, { queued: session.listQueuedMessages() });
+            return;
+        }
+        // Cancel one pending queued message by id.
+        if (method === "POST" && url === "/queued/cancel") {
+            void readBody(req, res).then((raw) => {
+                if (raw === null)
+                    return;
+                let id;
+                try {
+                    id = JSON.parse(raw).id ?? "";
+                }
+                catch {
+                    json(res, 400, { error: "invalid JSON body" });
+                    return;
+                }
+                if (!id.trim()) {
+                    json(res, 400, { error: "missing queued message id" });
+                    return;
+                }
+                // `false` means it already drained into the run between render and
+                // click. That is a race, not an error, so report it as a normal result
+                // and let the client reconcile from the fresh list.
+                const cancelled = session.cancelQueuedMessage(id);
+                const queued = session.listQueuedMessages();
+                broadcast("queued", { count: queued.length, messages: queued });
+                json(res, 200, { cancelled, queued });
+            });
+            return;
+        }
         if (method === "POST" && url === "/kill") {
             void readBody(req, res).then(async (raw) => {
                 if (raw === null)
@@ -3586,7 +3605,7 @@ async function createSession(deps, opts) {
                 const generation = runLifecycle.generation;
                 if (!pendingCancelDrain || pendingCancelDrain.generation !== generation) {
                     pendingCancelDrain = { generation, text: session.drainQueue() };
-                    broadcast("queued", { count: 0 });
+                    broadcast("queued", { count: 0, messages: [] });
                 }
                 const result = await runLifecycle.cancel(CANCEL_TIMEOUT_MS);
                 const drained = pendingCancelDrain.text;