@kenkaiiii/ggcoder 5.8.0 → 5.8.2

package/dist/app-sidecar.js

@@ -27,6 +27,7 @@ import { parseAutopilotVerdict } from "./core/autopilot-verdict.js";
 import { isWorkflowCommandText, countAssistantMessages, shouldStartAutopilotCycle, extractTurnToolCalls, isMechanicalOnlyTurn, } from "./core/autopilot-gate.js";
 import { driveAutopilotCycle } 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 { AuthStorage } from "./core/auth-storage.js";
 import { MOONSHOT_OAUTH_KEY, XIAOMI_CREDITS_KEY } from "@kenkaiiii/gg-core";
 import { loginAnthropic } from "./core/oauth/anthropic.js";
@@ -811,6 +812,16 @@ async function createSession(deps, opts) {
             ...(f.statusCode != null ? { statusCode: f.statusCode } : {}),
             ...(f.resetsAt != null ? { resetsAt: f.resetsAt } : {}),
         });
+        // Persist the error row (display-only marker) so a resumed session shows
+        // the same headline/message/guidance the live run did. Best-effort.
+        void session
+            .persistAppMarker("error", {
+            scope: type,
+            headline: f.headline,
+            ...(f.message ? { message: f.message } : {}),
+            guidance: f.guidance,
+        })
+            .catch(() => { });
     }
     // The session file path to resume (passed by the daemon's POST /session);
     // empty/unset starts a fresh session.
@@ -835,6 +846,8 @@ async function createSession(deps, opts) {
         onEnterPlan: async (reason) => {
             await session.setPlanMode(true);
             broadcast("plan_enter", { reason: reason ?? "" });
+            // Persist the plan-mode banner so a resumed session still shows it.
+            void session.persistAppMarker("plan", { reason: reason ?? "" }).catch(() => { });
         },
         onExitPlan: async (planPath) => {
             await session.setPlanMode(false);
@@ -1371,14 +1384,24 @@ async function createSession(deps, opts) {
                 },
                 runPrompt: (body) => runAgent(body, () => session.prompt(body)),
                 emit: (event) => {
-                    broadcast(event.type, event.data);
                     // Persist the terminal verdict marker so a resumed session renders the
                     // same Ken bubble the live run showed instead of dropping it or
                     // 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).
+                        const seed = autopilotMarkerCopySeed({
+                            version: 1,
+                            phase: "done",
+                            afterMessageCount: session.getMessages().filter((m) => m.role !== "system").length,
+                        });
+                        broadcast(event.type, { ...event.data, copySeed: seed });
                         void session.persistAutopilotMarker("done");
+                        return;
                     }
-                    else if (event.type === "autopilot_human") {
+                    broadcast(event.type, event.data);
+                    if (event.type === "autopilot_human") {
                         void session.persistAutopilotMarker("human", { reason: event.data.reason });
                     }
                     else if (event.type === "autopilot_capped") {
@@ -1481,6 +1504,8 @@ async function createSession(deps, opts) {
         markTaskInProgress(cwd, task.id);
         broadcast("tasks_list", { tasks: loadTasksSync(cwd) });
         broadcast("task_start", { id: task.id, title: task.title });
+        // Persist the task header so a resumed task session shows what ran.
+        void session.persistAppMarker("task", { title: task.title }).catch(() => { });
         const shortId = task.id.slice(0, 8);
         const completionHint = `\n\n---\nWhen you have fully completed this task, call the tasks tool to mark it done:\n` +
             `tasks({ action: "done", id: "${shortId}" })`;
@@ -1771,8 +1796,11 @@ async function createSession(deps, opts) {
                 // they were recorded after, so each lands right after that message. A
                 // turn becomes two wire rows: the `@Ken` question (user) + Ken's reply
                 // (assistant), both flagged `ken` so the webview tints them.
+                // Deduped; stale anchors are clamped to the last message (Ken turns
+                // carry real conversation, so they render at the end instead of
+                // vanishing).
                 const kenByCount = new Map();
-                for (const turn of session.getKenTurns()) {
+                for (const turn of normalizeKenTurnsForHistory(session.getKenTurns(), messages.filter((m) => m.role !== "system").length)) {
                     const list = kenByCount.get(turn.afterMessageCount) ?? [];
                     list.push(turn);
                     kenByCount.set(turn.afterMessageCount, list);
@@ -1790,8 +1818,12 @@ 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.
+                const restoredMessageCount = messages.filter((m) => m.role !== "system").length;
                 const autopilotByCount = new Map();
-                for (const marker of session.getAutopilotMarkers()) {
+                for (const marker of normalizeAutopilotMarkersForHistory(session.getAutopilotMarkers(), restoredMessageCount)) {
                     const list = autopilotByCount.get(marker.afterMessageCount) ?? [];
                     list.push(marker);
                     autopilotByCount.set(marker.afterMessageCount, list);
@@ -1809,15 +1841,77 @@ async function createSession(deps, opts) {
                                 phase: marker.phase,
                                 ...(marker.reason !== undefined ? { reason: marker.reason } : {}),
                                 ...(marker.body !== undefined ? { body: marker.body } : {}),
+                                copySeed: marker.copySeed,
                             },
                         });
                     }
                 };
+                // App transcript markers (plan banner / task header / error rows /
+                // user-bubble hints), same anchor scheme. user_hint markers don't
+                // become rows — they decorate the user row at their anchor instead.
+                const appMarkersByCount = new Map();
+                const userHintByCount = new Map();
+                // Compaction-count markers pair with compacted summary rows in file
+                // order (FIFO), not by anchor — the summary user message is what
+                // positions the notice.
+                const compactionCounts = [];
+                for (const marker of normalizeAppMarkersForHistory(session.getAppMarkers(), restoredMessageCount)) {
+                    if (marker.kind === "user_hint") {
+                        userHintByCount.set(marker.afterMessageCount, marker.data);
+                        continue;
+                    }
+                    if (marker.kind === "compaction") {
+                        const d = marker.data;
+                        if (typeof d.originalCount === "number" && typeof d.newCount === "number") {
+                            compactionCounts.push({ originalCount: d.originalCount, newCount: d.newCount });
+                        }
+                        continue;
+                    }
+                    const list = appMarkersByCount.get(marker.afterMessageCount) ?? [];
+                    list.push(marker);
+                    appMarkersByCount.set(marker.afterMessageCount, list);
+                }
+                const flushAppMarkers = (count) => {
+                    const markers = appMarkersByCount.get(count);
+                    if (!markers)
+                        return;
+                    appMarkersByCount.delete(count);
+                    for (const marker of markers) {
+                        const d = marker.data;
+                        if (marker.kind === "plan") {
+                            history.push({
+                                role: "assistant",
+                                text: "",
+                                plan: { reason: typeof d.reason === "string" ? d.reason : "" },
+                            });
+                        }
+                        else if (marker.kind === "task") {
+                            history.push({
+                                role: "assistant",
+                                text: "",
+                                task: { title: typeof d.title === "string" ? d.title : "" },
+                            });
+                        }
+                        else if (marker.kind === "error" && typeof d.headline === "string") {
+                            history.push({
+                                role: "assistant",
+                                text: "",
+                                error: {
+                                    scope: typeof d.scope === "string" ? d.scope : "error",
+                                    headline: d.headline,
+                                    ...(typeof d.message === "string" ? { message: d.message } : {}),
+                                    ...(typeof d.guidance === "string" ? { guidance: d.guidance } : {}),
+                                },
+                            });
+                        }
+                    }
+                };
                 let nonSystemCount = 0;
                 // Turns/markers recorded before any build message (anchor 0) render at
                 // the top.
                 flushKen(0);
                 flushAutopilot(0);
+                flushAppMarkers(0);
                 for (const msg of messages) {
                     if (msg.role === "system")
                         continue;
@@ -1867,30 +1961,54 @@ async function createSession(deps, opts) {
                         }
                         continue;
                     }
-                    // User or assistant message — existing text/hook/command/compacted
-                    // extraction, plus sub-agent group detection for assistant tool_calls.
-                    const text = typeof msg.content === "string"
-                        ? msg.content
-                        : msg.content
-                            .map((c) => c.type === "text" && "text" in c && typeof c.text === "string" ? c.text : "")
-                            .join("");
-                    const images = typeof msg.content === "string"
-                        ? []
-                        : msg.content.flatMap((c) => c.type === "image" ? [`data:${c.mediaType};base64,${c.data}`] : []);
-                    const hook = msg.role === "user" ? detectHookKind(text) : null;
-                    const compacted = msg.role === "user" && !hook && text.startsWith("[Previous conversation summary]");
-                    const command = msg.role === "user" && !hook && !compacted
-                        ? detectPromptCommand(text, commandCandidates)
-                        : null;
-                    if (text.trim() || images.length > 0) {
-                        history.push({
-                            role: msg.role,
-                            text: command ?? text,
-                            images,
-                            hook,
-                            command: command !== null,
-                            compacted,
-                        });
+                    // User or assistant message — text/hook/command/compacted extraction,
+                    // plus sub-agent group detection for assistant tool_calls.
+                    if (msg.role === "user") {
+                        // Rebuild the live bubble: strip the steering wrapper, drop
+                        // attachment/file notes the model saw but the bubble never showed.
+                        const restored = restoreUserRow(msg.content);
+                        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);
+                            history.push({
+                                role: "user",
+                                text: command ?? text,
+                                images: restored.images,
+                                hook,
+                                command: command !== null,
+                                compacted,
+                                // Markers accumulate across continuation files (each rewrite
+                                // re-persists prior ones) but only the LATEST summary row
+                                // survives compaction — so consume from the newest end.
+                                ...(compacted && compactionCounts.length > 0
+                                    ? { compactionCounts: compactionCounts.pop() }
+                                    : {}),
+                                ...(hint?.kenSent === true ? { kenSent: true } : {}),
+                                ...(Array.isArray(hint?.enhancements) ? { enhancements: hint.enhancements } : {}),
+                            });
+                            // Live showed the video-capability warning right after the bubble.
+                            if (restored.videoWarning) {
+                                history.push({ role: "assistant", text: "", infoKind: "video_warning" });
+                            }
+                        }
+                    }
+                    else {
+                        // Assistant: one wire row per persisted text block — live streaming
+                        // splits bubbles at server_tool_call boundaries, and the persisted
+                        // content keeps those blocks separate.
+                        for (const blockText of restoreAssistantTexts(msg.content)) {
+                            history.push({
+                                role: "assistant",
+                                text: blockText,
+                                images: [],
+                                hook: null,
+                                command: false,
+                                compacted: false,
+                            });
+                        }
                     }
                     // Assistant tool_call blocks: detect sub-agent delegations.
                     if (msg.role === "assistant" && typeof msg.content !== "string") {
@@ -1911,19 +2029,21 @@ async function createSession(deps, opts) {
                             });
                         }
                     }
-                    // Interleave any Ken turns / autopilot markers recorded right after
-                    // this message.
+                    // Interleave any Ken turns / autopilot / app markers recorded right
+                    // after this message.
                     flushKen(nonSystemCount);
                     flushAutopilot(nonSystemCount);
+                    flushAppMarkers(nonSystemCount);
                 }
-                // Flush remaining Ken turns / autopilot markers whose anchor is at/after
-                // the message count (e.g. recorded before any build message, or anchors
-                // beyond the current count after compaction shrank the history) so none
-                // are dropped.
+                // Flush remaining Ken turns whose anchor is at/after the message count so
+                // none are dropped. Autopilot/app markers beyond the restored message
+                // count were already filtered above; any remaining marker here is valid.
                 for (const count of [...kenByCount.keys()].sort((a, b) => a - b))
                     flushKen(count);
                 for (const count of [...autopilotByCount.keys()].sort((a, b) => a - b))
                     flushAutopilot(count);
+                for (const count of [...appMarkersByCount.keys()].sort((a, b) => a - b))
+                    flushAppMarkers(count);
                 json(res, 200, { history });
             })();
             return;
@@ -1956,10 +2076,12 @@ async function createSession(deps, opts) {
             void readBody(req).then(async (raw) => {
                 let text;
                 let attachments;
+                let meta;
                 try {
                     const body = JSON.parse(raw);
                     text = body.text ?? "";
                     attachments = Array.isArray(body.attachments) ? body.attachments : [];
+                    meta = typeof body.meta === "object" && body.meta !== null ? body.meta : undefined;
                 }
                 catch {
                     json(res, 400, { error: "invalid JSON body" });
@@ -1983,6 +2105,18 @@ async function createSession(deps, opts) {
                     return;
                 }
                 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
+                // 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))) {
+                    void session
+                        .persistAppMarker("user_hint", {
+                        ...(meta.kenSent === true ? { kenSent: true } : {}),
+                        ...(Array.isArray(meta.enhancements) ? { enhancements: meta.enhancements } : {}),
+                    }, 1)
+                        .catch(() => { });
+                }
                 // Fresh user turn: clear any cancel flag left from a prior cycle so this
                 // turn's autopilot review can run.
                 autopilotCancelled = false;