@kenkaiiii/ggcoder 5.26.1 → 5.26.3

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";
@@ -33,7 +34,7 @@ import { parseAutopilotVerdict } from "./core/autopilot-verdict.js";
 import { isWorkflowCommandText, countAssistantMessages, shouldStartAutopilotCycle, extractTurnToolCalls, isMechanicalOnlyTurn, } from "./core/autopilot-gate.js";
 import { driveAutopilotCycle, frameAutopilotInjection } from "./core/autopilot-cycle.js";
 import { validateKenModelPref, effectiveKenModel } from "./core/ken-model.js";
-import { normalizeAutopilotMarkersForHistory, normalizeAppMarkersForHistory, normalizeKenTurnsForHistory, restoreUserRow, restoreAssistantTexts, autopilotMarkerCopySeed, } from "./core/session-history.js";
+import { normalizeAutopilotMarkersForHistory, normalizeAppMarkersForHistory, normalizeKenTurnsForHistory, restoreUserRow, restoreAssistantTexts, resolveRestoredCommand, 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";
@@ -363,30 +364,6 @@ function detectHookKind(text) {
         return "regrounding";
     return null;
 }
-// Separator AgentSession.prompt() inserts between a command's prompt body and
-// the user's trailing args. Must stay in sync with the expansion there.
-const COMMAND_ARGS_SEP = "\n\n## User Instructions\n\n";
-/**
- * Reverse a prompt-template command's expansion. When a `/name` command runs,
- * the agent persists the FULL expanded prompt body as the user message — so on
- * resume the raw body would render instead of the short `/name` chip the user
- * saw live. Given the candidate commands (built-in + custom) and a restored
- * message body, recover the original `/name [args]` invocation. Returns null
- * when the text isn't a known command body (an ordinary user message).
- */
-function detectPromptCommand(text, candidates) {
-    for (const c of candidates) {
-        if (!c.prompt)
-            continue;
-        if (text === c.prompt)
-            return `/${c.name}`;
-        if (text.startsWith(c.prompt + COMMAND_ARGS_SEP)) {
-            const args = text.slice(c.prompt.length + COMMAND_ARGS_SEP.length).trim();
-            return args ? `/${c.name} ${args}` : `/${c.name}`;
-        }
-    }
-    return null;
-}
 /** A short transport summary for display (URL for http/sse, command+args for stdio). */
 function mcpRowSummary(config) {
     if (config.url)
@@ -1532,6 +1509,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 +1558,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 +1898,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());
         }
     }
@@ -2109,12 +2097,14 @@ async function createSession(deps, opts) {
                     // falling back to the raw verdict text (e.g. ALL_CLEAR).
                     if (event.type === "autopilot_done") {
                         // Broadcast the SAME copySeed the persisted marker will produce on
-                        // resume, so the live all-clear wording matches the resumed one
-                        // (computed before persist — same synchronous message count).
+                        // resume, so the live all-clear wording matches the resumed one.
+                        // Must use the PERSISTED count — that's what persistAutopilotMarker
+                        // anchors against, and it trails the in-memory list after a run
+                        // whose messages never made it to disk.
                         const seed = autopilotMarkerCopySeed({
                             version: 1,
                             phase: "done",
-                            afterMessageCount: session.getMessages().filter((m) => m.role !== "system").length,
+                            afterMessageCount: session.getPersistedTranscriptCount(),
                         });
                         broadcast(event.type, { ...event.data, copySeed: seed });
                         void session.persistAutopilotMarker("done");
@@ -2159,7 +2149,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
@@ -2683,9 +2676,9 @@ async function createSession(deps, opts) {
                 // Autopilot verdict markers to interleave, same anchor scheme as Ken
                 // turns — each becomes a single assistant row the webview renders
                 // exactly like the live `autopilot` item (never a raw verdict string).
-                // Compact/continuation rewrites can carry old markers whose original
-                // afterMessageCount is beyond the restored message list; dropping those
-                // prevents stale all-clear bubbles from bunching at the bottom on resume.
+                // Normalization pulls anchors left over from an unrebased compaction
+                // back to where the marker was actually written, so stale all-clear
+                // bubbles no longer bunch at the bottom of a reopened session.
                 const restoredMessageCount = messages.filter((m) => m.role !== "system").length;
                 const autopilotByCount = new Map();
                 for (const marker of normalizeAutopilotMarkersForHistory(session.getAutopilotMarkers(), restoredMessageCount)) {
@@ -2835,9 +2828,21 @@ async function createSession(deps, opts) {
                         const text = restored.text;
                         const hook = detectHookKind(text);
                         const compacted = !hook && text.startsWith("[Previous conversation summary]");
-                        const command = !hook && !compacted ? detectPromptCommand(text, commandCandidates) : null;
-                        if (text.trim() || restored.images.length > 0) {
-                            const hint = userHintByCount.get(nonSystemCount);
+                        const hint = userHintByCount.get(nonSystemCount);
+                        // The typed invocation persisted alongside the prompt is
+                        // authoritative. Reversing the expanded body only works while the
+                        // template is byte-identical, and templates drift (edited
+                        // `.gg/commands/*.md`, reworded built-ins, app-vs-CLI phrasing) —
+                        // after which the resumed session dumped the raw multi-KB body
+                        // instead of the `/name` chip. Older sessions have no hint, so the
+                        // body match stays as the fallback.
+                        const command = !hook && !compacted
+                            ? resolveRestoredCommand(typeof hint?.command === "string" ? hint.command : null, text, commandCandidates)
+                            : null;
+                        // Autopilot injected this turn — live showed only the Ken-tinted
+                        // marker for it, never a user bubble. Emitting one here would print
+                        // the injected instruction a second time, unstyled.
+                        if (!restored.autopilotInjected && (text.trim() || restored.images.length > 0)) {
                             history.push({
                                 role: "user",
                                 text: command ?? text,
@@ -2965,7 +2970,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;
@@ -2985,14 +2995,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
@@ -3001,20 +3014,47 @@ 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 });
+                // Gate inputs captured around the run: whether this turn is a workflow
+                // slash command (attachment prompts skip slash expansion entirely), and
+                // 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());
+                // Does this input actually expand into a persisted user message? Asked
+                // of the session itself, because only it knows whether the command
+                // resolves here (name/alias casing, custom `.gg/commands`, non-coder
+                // agents that don't expand at all). A looser guess would anchor the
+                // hint at +1 with no message to land on — decorating an unrelated
+                // later bubble with the wrong `/name`.
+                const expandsToTemplate = attachments.length === 0 && (await session.willExpandPromptTemplate(text));
                 // Webview display hint for this prompt's user bubble (kenSent shimmer
-                // label / enhancer highlight segments). Anchored +1 so it attaches to
-                // the user message the prompt below is about to push. Queued prompts
-                // skip this (their position in the run is unpredictable).
-                if (meta && (meta.kenSent === true || Array.isArray(meta.enhancements))) {
+                // label / enhancer highlight segments / the `/name` a command was typed
+                // as). Anchored +1 so it attaches to the user message the prompt below
+                // is about to push. Queued prompts skip this (their position in the run
+                // is unpredictable).
+                //
+                // Recording the invocation matters because the agent persists the
+                // EXPANDED template as the user message. Resume used to recover
+                // `/name` by matching that body against the current templates, which
+                // silently fails the moment a template is edited or reworded — the
+                // reopened session then rendered the raw multi-KB prompt instead of
+                // the command chip.
+                if (expandsToTemplate ||
+                    (meta && (meta.kenSent === true || Array.isArray(meta.enhancements)))) {
                     void session
                         .persistAppMarker("user_hint", {
-                        ...(meta.kenSent === true ? { kenSent: true } : {}),
-                        ...(Array.isArray(meta.enhancements) ? { enhancements: meta.enhancements } : {}),
+                        ...(expandsToTemplate ? { command: text.trim() } : {}),
+                        ...(meta?.kenSent === true ? { kenSent: true } : {}),
+                        ...(Array.isArray(meta?.enhancements) ? { enhancements: meta.enhancements } : {}),
                     }, 1)
                         .catch(() => { });
                 }
@@ -3025,12 +3065,6 @@ async function createSession(deps, opts) {
                 // feedback, anything) supersedes the pending plan — the bump also
                 // invalidates any in-flight Ken plan review.
                 clearPendingPlan();
-                // Gate inputs captured around the run: whether this turn is a workflow
-                // slash command (attachment prompts skip slash expansion entirely), and
-                // 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 assistantsBefore = countAssistantMessages(session.getMessages());
                 const messagesBefore = session.getMessages().length;
                 await runAgent(text, async () => {
@@ -3082,6 +3116,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;
         }
@@ -3485,6 +3523,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)
@@ -3542,7 +3612,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;