vibe-coding-master 0.2.8 → 0.2.10

package/README.md

@@ -210,7 +210,7 @@ The left sidebar is intentionally compact and collapsible:
 - `Repository Path`: path input on one row; `Recent` and `Connect` on the next row.
 - `Connected Repository`: connected base repo path, branch, upstream/ahead-behind status, commit hash, working tree state, and a `Pull` button.
 - `Settings`: `Theme`, `Flow pause alert`, `Try alert`, `Messages`, and `Events`.
-- `Gateway`: Weixin iLink binding, Gateway on/off, Gateway translation, QR login, and recent Gateway status.
+- `Gateway`: Weixin iLink binding, Gateway on/off, Gateway translation, and QR login.
 - `VCM Harness`: fixed-install status, bootstrap completion checks, and the bootstrap terminal when one is running.
 - `New Task`: one `task name` input.
 - `Tasks`: task list and task status.
@@ -236,6 +236,8 @@ Gateway rules:
 - One phone identity binds to one desktop VCM instance.
 - The phone can manage projects and tasks available to that desktop VCM instance.
 - When the desktop UI has an active task selected, Gateway uses that task automatically.
+- After binding, VCM keeps a lightweight Gateway connection for `/start` and read-only commands even when the `Gateway` toggle is off.
+- VCM caches the latest PM reply for each task locally, so `/start` can immediately return the current task's latest PM status when available.
 - Plain text messages go only to the current task's `project-manager`.
 - Gateway never sends directly to `architect`, `coder`, or `reviewer`.
 - Gateway credentials and audit logs stay in local app state, not in connected repositories.
@@ -254,12 +256,12 @@ Gateway state is stored locally under:
 3. Click `Start QR Login`.
 4. VCM opens a global `Weixin Gateway Login` dialog with a QR code.
 5. Scan the QR code with Weixin and confirm login on the phone.
-6. Click `Check QR` in the dialog.
+6. Click `Confirm` in the dialog.
 7. After binding succeeds, close the dialog and turn `Gateway` on in the sidebar.
 
-`Start QR Login` creates a new Tencent iLink QR login session. `Check QR` asks iLink whether the QR code has been scanned and confirmed. If the QR code expires, click `Start QR Login` again.
+`Start QR Login` is shown only when Gateway is not bound. It creates a new Tencent iLink QR login session and opens the QR dialog. The dialog `Confirm` button asks iLink whether the QR code has been scanned and confirmed. After binding succeeds, the sidebar shows `Reset Binding` instead of `Start QR Login`.
 
-The `Gateway` toggle is disabled until a QR login has produced a usable iLink token. `Reset Binding` clears the stored token and bound Weixin identity so the desktop VCM can bind again.
+The `Gateway` toggle is disabled until a QR login has produced a usable iLink token. After binding, VCM keeps receiving `/help`, `/start`, `/status`, `/projects`, and `/tasks` even when the toggle is off. Turning `Gateway` on, either from desktop or by sending `/start`, enables PM messages, task-changing commands, and PM reply push. `Reset Binding` clears the stored token and bound Weixin identity so the desktop VCM can bind again.
 
 When Gateway is turned on, VCM automatically turns off the browser `Flow pause alert` and disables `Try alert`. Gateway becomes the notification path, so the browser should not show blocking flow-pause dialogs while the user is managing the task from Weixin.
 
@@ -273,15 +275,30 @@ When Gateway translation is on:
 - The prompt sent to PM includes only the translated English text with a `[VCM Gateway]` marker.
 - The original Chinese text is not included in the PM prompt.
 - PM replies are translated back to Chinese before VCM sends them to Weixin.
+- If PM reply translation fails or times out, VCM sends a translation failure notice instead of the English source. The user can send `/retry` to retry the latest failed Gateway output translation.
 
 When Gateway translation is off, plain Weixin text is sent to PM as-is.
 
 ### Commands
 
-After Gateway is bound and turned on, send commands in the bound Weixin DM:
+After Gateway is bound, send commands in the bound Weixin DM.
+
+When `Gateway` is off, only these commands are accepted:
+
+```text
+/help
+/start
+/status
+/projects
+/tasks
+```
+
+When `Gateway` is on, the full command set is accepted:
 
 ```text
 /help
+/start
+/retry
 /status
 /projects
 /use-project <index-or-path>
@@ -295,7 +312,7 @@ After Gateway is bound and turned on, send commands in the bound Weixin DM:
 /translate off
 ```
 
-Plain text that does not start with `/` is sent as a message to the current task's PM session.
+Plain text that does not start with `/` is sent as a message to the current task's PM session only when `Gateway` is on.
 
 In normal use, VCM runs one project and one task at a time. If the desktop UI has a task selected, turning Gateway on syncs that project/task into Gateway automatically. `/status` also refreshes this context, so the phone usually does not need to run `/tasks` and `/use-task` before sending a PM message.
 
@@ -316,6 +333,8 @@ Typical mobile flow:
 
 - `/status`: shows Gateway, binding, translation, current project, current task, and last poll status.
 - `/status` also adopts the current desktop project/task when one is selected.
+- `/start`: turns Gateway on from the bound Weixin DM so full mobile task operations and PM messages are allowed. If the current task has a cached latest PM reply, `/start` includes it in the response.
+- `/retry`: retries the latest failed Gateway output translation in the current VCM process.
 - `/projects`: lists the current/recent repositories known by the desktop VCM.
 - `/use-project <index-or-path>`: selects the Gateway's current project context.
 - `/pull-current`: runs the same fast-forward-only connected repository pull as the desktop `Pull` button.
@@ -335,12 +354,14 @@ Typical mobile flow:
 ### Troubleshooting
 
 - If the QR dialog does not appear, refresh the page and click `Start QR Login` again.
-- If the QR status stays `wait`, confirm the login on the phone and click `Check QR` again.
+- If the QR status stays `wait`, confirm the login on the phone and click `Confirm` again.
 - If the QR code expires, start a new QR login.
 - If `Gateway` cannot be enabled, bind Weixin first.
-- If messages are not received, check that Gateway is on, the iLink token has not expired, and the Weixin DM is the bound identity.
+- If `/start` or read-only commands do not receive replies, check that the iLink token has not expired and the Weixin DM is the bound identity.
+- If PM messages or task-changing commands are rejected, check that Gateway is on.
 - If plain text cannot be sent to PM, select a project and task first, and make sure the task's PM session is running and idle.
 - If PM replies are not pushed, check that Gateway is on and the PM session is producing normal Claude transcript output.
+- If PM reply translation fails, send `/retry` from the bound Weixin DM. Retry state is memory-only and is cleared when VCM restarts.
 
 ## Translation
 
@@ -505,7 +526,7 @@ Each directed role route has exactly one message file. Route messages are the on
 
 ## Orchestration Modes
 
-VCM has a task-level `Auto orchestration` switch in the role console toolbar.
+VCM has a task-level `Auto orchestration` switch in the role console toolbar. New tasks default to auto orchestration.
 
 When it is off, VCM is in manual mode:
 
@@ -527,6 +548,7 @@ When it is on, VCM is in auto mode:
 - Just before terminal submission, VCM records `dispatchingAt`, waits briefly for the GUI to switch tabs, then writes to the embedded terminal.
 - After successful terminal write, VCM snapshots the delivered body as message history.
 - Claude Code `UserPromptSubmit` confirms that the prompt was accepted; VCM stores `acceptedAt` and clears the source route file if it still contains the same message.
+- If `UserPromptSubmit` does not confirm the auto-delivered message, VCM retries Enter from the backend PTY and finally records `failureReason` on the message if submission is still not confirmed.
 - When the GUI observes a newly dispatching auto message, it switches the active role tab to that message's target role before the message is submitted.
 - VCM enforces sequential turn-taking from hook state: a role that has accepted a prompt is busy until its `Stop` hook fires.
 - Additional pending files to a busy target role remain non-empty and are not written to that terminal.

package/dist/backend/gateway/gateway-command-parser.js

@@ -8,6 +8,10 @@ export function parseGatewayCommand(input) {
     switch (name) {
         case "/help":
             return { kind: "help" };
+        case "/start":
+            return { kind: "start" };
+        case "/retry":
+            return { kind: "retry" };
         case "/status":
             return { kind: "status" };
         case "/projects":

package/dist/backend/gateway/gateway-service.js

@@ -12,17 +12,27 @@ const POLL_ERROR_BACKOFF_MS = 2_000;
 const POLL_LONG_BACKOFF_MS = 30_000;
 const MAX_FAILURES_BEFORE_LONG_BACKOFF = 3;
 const DEFAULT_POLL_TIMEOUT_MS = 35_000;
+const MAX_LATEST_PM_REPLY_CHARS = 8_000;
+const GATEWAY_TRANSLATION_FAILURE_TEXT = "PM 回复已收到，但翻译失败。\n发送 /retry 重新翻译。";
+const COMMANDS_ALLOWED_WHEN_DISABLED = new Set([
+    "help",
+    "start",
+    "status",
+    "projects",
+    "tasks"
+]);
 export function createGatewayService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     let pollAbort = null;
     let pollLoopPromise = null;
     let qrLogin = null;
+    let lastFailedTranslation = null;
     function isRunning() {
         return Boolean(pollAbort && !pollAbort.signal.aborted);
     }
     async function ensurePolling() {
         const settings = await deps.settings.loadSettings();
-        if (!settings.enabled || !settings.binding.token || isRunning()) {
+        if (!settings.binding.token || isRunning()) {
             return;
         }
         pollAbort = new AbortController();
@@ -55,7 +65,7 @@ export function createGatewayService(deps) {
         while (!signal.aborted) {
             const settings = await deps.settings.loadSettings();
             const account = toAccount(settings);
-            if (!settings.enabled || !account) {
+            if (!account) {
                 await savePollStatus("idle");
                 return;
             }
@@ -99,6 +109,13 @@ export function createGatewayService(deps) {
                 await deps.settings.saveSettings({
                     ...settingsAfterError,
                     enabled: expired ? false : settingsAfterError.enabled,
+                    binding: expired
+                        ? {
+                            ...settingsAfterError.binding,
+                            token: null,
+                            getUpdatesBuf: ""
+                        }
+                        : settingsAfterError.binding,
                     lastPollStatus: {
                         state: expired ? "expired" : "error",
                         checkedAt: now(),
@@ -169,7 +186,7 @@ export function createGatewayService(deps) {
         }
         const command = parseGatewayCommand(update.text);
         try {
-            const output = await executeCommand(command);
+            const output = await executeCommand(command, settings);
             await reply(await deps.settings.loadSettings(), update.fromUserId, output);
             await recordMessageStatus("inbound", "ok", update.text, undefined, command.kind);
             await deps.audit.record({
@@ -196,10 +213,21 @@ export function createGatewayService(deps) {
             });
         }
     }
-    async function executeCommand(command) {
+    async function executeCommand(command, settings) {
+        if (!settings.enabled && !COMMANDS_ALLOWED_WHEN_DISABLED.has(command.kind)) {
+            return [
+                "Gateway is connected but off.",
+                "Available commands while off: /help, /start, /status, /projects, /tasks.",
+                "Turn Gateway on in desktop VCM to send PM messages or run task-changing commands."
+            ].join("\n");
+        }
         switch (command.kind) {
             case "help":
-                return helpText();
+                return helpText(settings.enabled);
+            case "start":
+                return startGateway();
+            case "retry":
+                return retryFailedTranslation();
             case "status":
                 return statusText(await deps.settings.loadSettings());
             case "projects":
@@ -473,9 +501,13 @@ export function createGatewayService(deps) {
             deleteBranch: Boolean(task.worktreePath),
             forceDeleteBranch: true
         });
+        clearFailedTranslation(project.repoRoot, taskSlug);
+        const latestPmReplies = { ...settings.latestPmReplies };
+        delete latestPmReplies[latestPmReplyKey(project.repoRoot, taskSlug)];
         await deps.settings.saveSettings({
             ...settings,
             currentTaskSlug: null,
+            latestPmReplies,
             pendingConfirmations: {
                 ...settings.pendingConfirmations,
                 closeTask: null
@@ -501,6 +533,30 @@ export function createGatewayService(deps) {
         const settings = await deps.settings.updateSettings({ translationEnabled: enabled });
         return `Gateway translation ${settings.translationEnabled ? "on" : "off"}.`;
     }
+    async function startGateway() {
+        const settings = await deps.settings.loadSettings();
+        if (!settings.binding.token) {
+            return "Gateway is not bound. Start QR login from desktop VCM first.";
+        }
+        if (settings.enabled) {
+            return "Gateway is already on.";
+        }
+        const enabled = await syncDesktopContext(await deps.settings.updateSettings({ enabled: true }));
+        await ensurePolling();
+        await deps.appSettings.updatePreferences({ flowPauseAlerts: false });
+        const lines = [
+            "Gateway started.",
+            "Full mobile commands and PM messages are now enabled.",
+            `Project: ${enabled.currentProjectId ?? "none"}`,
+            `Task: ${enabled.currentTaskSlug ?? "none"}`
+        ];
+        const latestReply = getLatestPmReply(enabled);
+        if (latestReply) {
+            const rendered = await renderLatestPmReply(enabled, latestReply);
+            lines.push("", "Latest PM reply:", rendered.text);
+        }
+        return lines.join("\n");
+    }
     async function sendPlainTextToPm(text) {
         if (!text.trim()) {
             return "Empty message ignored.";
@@ -589,14 +645,16 @@ export function createGatewayService(deps) {
             void stopPolling();
         },
         async getStatus() {
-            return deps.settings.expose(await syncDesktopContext(await deps.settings.loadSettings()), isRunning());
+            const settings = await syncDesktopContext(await deps.settings.loadSettings());
+            await ensurePolling();
+            return deps.settings.expose(settings, isRunning());
         },
         async updateSettings(input) {
             let settings = await deps.settings.updateSettings(input);
             if (settings.enabled) {
                 settings = await syncDesktopContext(settings);
             }
-            if (settings.enabled) {
+            if (settings.binding.token) {
                 await ensurePolling();
             }
             else {
@@ -606,6 +664,7 @@ export function createGatewayService(deps) {
         },
         async resetBinding() {
             await stopPolling();
+            lastFailedTranslation = null;
             const settings = await deps.settings.resetBinding();
             return deps.settings.expose(settings, isRunning());
         },
@@ -662,6 +721,7 @@ export function createGatewayService(deps) {
                         updatedAt: now()
                     });
                     qrLogin = null;
+                    await ensurePolling();
                 }
             }
             return {
@@ -676,19 +736,23 @@ export function createGatewayService(deps) {
             if (input.session.role !== "project-manager") {
                 return;
             }
+            const transcriptPath = resolveExistingClaudeTranscriptPath(input.session);
+            if (!transcriptPath) {
+                return;
+            }
+            const events = await readTranscriptTextEvents(transcriptPath);
+            const latestReply = selectLatestTurnReply(events, input.session);
+            if (latestReply) {
+                await saveLatestPmReply(input, latestReply);
+            }
             const settings = await deps.settings.loadSettings();
             const account = toAccount(settings);
             const boundUserId = settings.binding.boundUserId;
             if (!settings.enabled || !account || !boundUserId) {
                 return;
             }
-            const transcriptPath = resolveExistingClaudeTranscriptPath(input.session);
-            if (!transcriptPath) {
-                return;
-            }
             const cursorKey = `${input.taskSlug}:project-manager:${input.session.claudeSessionId}`;
             const cursor = settings.pushCursors[cursorKey];
-            const events = await readTranscriptTextEvents(transcriptPath);
             const nextEvents = selectEventsAfterCursor(events, cursor?.lastTranscriptEventId);
             if (nextEvents.length === 0) {
                 return;
@@ -697,25 +761,17 @@ export function createGatewayService(deps) {
             if (!text) {
                 return;
             }
-            let output = text;
-            if (settings.translationEnabled) {
-                try {
-                    output = await deps.translationService.translateGatewayOutput({
-                        repoRoot: input.repoRoot,
-                        taskSlug: input.taskSlug,
-                        role: "project-manager",
-                        text
-                    });
-                }
-                catch {
-                    output = `${text}\n\n[Translation failed; original PM reply shown.]`;
-                }
-            }
+            const output = await renderGatewayPmOutput({
+                settings,
+                repoRoot: input.repoRoot,
+                taskSlug: input.taskSlug,
+                sourceText: text
+            });
             await deps.channel.sendText({
                 account,
                 toUserId: boundUserId,
                 contextToken: settings.binding.contextTokens[boundUserId],
-                text: output
+                text: output.text
             });
             const lastEvent = nextEvents.at(-1);
             const current = await deps.settings.loadSettings();
@@ -731,20 +787,131 @@ export function createGatewayService(deps) {
                 lastMessageStatus: {
                     checkedAt: now(),
                     direction: "outbound",
-                    result: "ok",
+                    result: output.translationFailed ? "error" : "ok",
                     command: "pm-stop",
-                    preview: output.slice(0, 160)
+                    preview: output.text.slice(0, 160),
+                    error: output.translationError
                 },
                 updatedAt: now()
             });
             await deps.audit.record({
                 type: "gateway.pm_push",
-                result: "ok",
+                result: output.translationFailed ? "error" : "ok",
                 command: "pm-stop",
-                preview: output
+                preview: output.text,
+                error: output.translationError
             });
         }
     };
+    function getLatestPmReply(settings) {
+        if (!settings.currentProjectId || !settings.currentTaskSlug) {
+            return undefined;
+        }
+        return settings.latestPmReplies[latestPmReplyKey(settings.currentProjectId, settings.currentTaskSlug)];
+    }
+    async function renderLatestPmReply(settings, reply) {
+        const rendered = await renderGatewayPmOutput({
+            settings,
+            repoRoot: reply.repoRoot,
+            taskSlug: reply.taskSlug,
+            sourceText: reply.text
+        });
+        return {
+            ...rendered,
+            text: reply.truncated && !rendered.translationFailed ? `${rendered.text}\n\n[truncated]` : rendered.text
+        };
+    }
+    async function renderGatewayPmOutput(input) {
+        if (!input.settings.translationEnabled) {
+            clearFailedTranslation(input.repoRoot, input.taskSlug);
+            return {
+                text: input.sourceText,
+                translationFailed: false
+            };
+        }
+        try {
+            const text = await deps.translationService.translateGatewayOutput({
+                repoRoot: input.repoRoot,
+                taskSlug: input.taskSlug,
+                role: "project-manager",
+                text: input.sourceText
+            });
+            clearFailedTranslation(input.repoRoot, input.taskSlug);
+            return {
+                text,
+                translationFailed: false
+            };
+        }
+        catch (error) {
+            const message = errorMessage(error);
+            lastFailedTranslation = {
+                repoRoot: input.repoRoot,
+                taskSlug: input.taskSlug,
+                role: "project-manager",
+                sourceText: input.sourceText,
+                failedAt: now(),
+                error: message,
+                retryCount: 0
+            };
+            return {
+                text: GATEWAY_TRANSLATION_FAILURE_TEXT,
+                translationFailed: true,
+                translationError: message
+            };
+        }
+    }
+    async function retryFailedTranslation() {
+        if (!lastFailedTranslation) {
+            return "没有可重试的翻译失败内容。";
+        }
+        const failed = lastFailedTranslation;
+        try {
+            const text = await deps.translationService.translateGatewayOutput({
+                repoRoot: failed.repoRoot,
+                taskSlug: failed.taskSlug,
+                role: failed.role,
+                text: failed.sourceText
+            });
+            lastFailedTranslation = null;
+            return `重新翻译成功：\n\n${text}`;
+        }
+        catch (error) {
+            lastFailedTranslation = {
+                ...failed,
+                failedAt: now(),
+                error: errorMessage(error),
+                retryCount: failed.retryCount + 1
+            };
+            return "重新翻译失败。\n稍后可继续发送 /retry。";
+        }
+    }
+    function clearFailedTranslation(repoRoot, taskSlug) {
+        if (lastFailedTranslation?.repoRoot === repoRoot && lastFailedTranslation.taskSlug === taskSlug) {
+            lastFailedTranslation = null;
+        }
+    }
+    async function saveLatestPmReply(input, reply) {
+        const settings = await deps.settings.loadSettings();
+        const key = latestPmReplyKey(input.repoRoot, input.taskSlug);
+        await deps.settings.saveSettings({
+            ...settings,
+            latestPmReplies: {
+                ...settings.latestPmReplies,
+                [key]: {
+                    repoRoot: input.repoRoot,
+                    taskSlug: input.taskSlug,
+                    sessionId: input.session.id,
+                    claudeSessionId: input.session.claudeSessionId,
+                    transcriptEventId: reply.transcriptEventId,
+                    transcriptTimestamp: reply.transcriptTimestamp,
+                    capturedAt: now(),
+                    text: reply.text,
+                    truncated: reply.truncated
+                }
+            },
+            updatedAt: now()
+        });
+    }
 }
 async function readTranscriptTextEvents(transcriptPath) {
     const raw = await readFile(transcriptPath, "utf8");
@@ -778,15 +945,79 @@ function selectEventsAfterCursor(events, cursorId) {
     }
     return events.slice(index + 1);
 }
+function selectLatestTurnReply(events, session) {
+    if (events.length === 0) {
+        return undefined;
+    }
+    const startMs = timestampMs(session.lastTurnStartedAt);
+    const endMs = timestampMs(session.lastTurnEndedAt);
+    const selected = startMs === undefined
+        ? events.slice(-1)
+        : events.filter((event) => {
+            const eventMs = timestampMs(event.timestamp);
+            return eventMs !== undefined
+                && eventMs >= startMs - 1_000
+                && (endMs === undefined || eventMs <= endMs + 1_000);
+        });
+    if (selected.length === 0) {
+        return undefined;
+    }
+    const text = selected.map((event) => event.text).join("\n\n").trim();
+    if (!text) {
+        return undefined;
+    }
+    const limited = limitLatestPmReply(text);
+    const lastEvent = selected.at(-1);
+    return {
+        transcriptEventId: lastEvent?.id ?? null,
+        transcriptTimestamp: lastEvent?.timestamp ?? null,
+        text: limited.text,
+        truncated: limited.truncated
+    };
+}
+function latestPmReplyKey(repoRoot, taskSlug) {
+    return JSON.stringify([repoRoot, taskSlug]);
+}
+function limitLatestPmReply(text) {
+    if (text.length <= MAX_LATEST_PM_REPLY_CHARS) {
+        return { text, truncated: false };
+    }
+    return {
+        text: text.slice(0, MAX_LATEST_PM_REPLY_CHARS).trimEnd(),
+        truncated: true
+    };
+}
+function timestampMs(value) {
+    if (!value) {
+        return undefined;
+    }
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
 function projectsText(projects) {
     if (projects.length === 0) {
         return "No recent projects. Connect a repository from desktop VCM first.";
     }
     return projects.map((repoPath, index) => `${index + 1}. ${repoPath}`).join("\n");
 }
-function helpText() {
+function helpText(enabled) {
+    if (!enabled) {
+        return [
+            "VCM Gateway is connected but off.",
+            "Available commands:",
+            "/help",
+            "/start",
+            "/status",
+            "/projects",
+            "/tasks",
+            "Send /start to enable PM messages and task-changing commands."
+        ].join("\n");
+    }
     return [
         "VCM Gateway commands:",
+        "/help",
+        "/start",
+        "/retry",
         "/status",
         "/projects",
         "/use-project <index-or-path>",

package/dist/backend/gateway/gateway-settings-service.js

@@ -48,6 +48,7 @@ export function createGatewaySettingsService(deps) {
                     recentInboundMessageIds: []
                 },
                 pushCursors: {},
+                latestPmReplies: current.latestPmReplies,
                 lastPollStatus: {
                     state: "idle"
                 },
@@ -92,6 +93,9 @@ export function normalizeSettings(input, timestamp) {
         ? input.pendingConfirmations
         : {};
     const pushCursors = isObject(input.pushCursors) ? input.pushCursors : {};
+    const latestPmReplies = isObject(input.latestPmReplies)
+        ? input.latestPmReplies
+        : {};
     return {
         version: 1,
         enabled: input.enabled === true,
@@ -120,6 +124,7 @@ export function normalizeSettings(input, timestamp) {
             closeTask: normalizeCloseTaskConfirmation(pendingInput.closeTask)
         },
         pushCursors: normalizePushCursors(pushCursors),
+        latestPmReplies: normalizeLatestPmReplies(latestPmReplies),
         lastPollStatus: normalizePollStatus(input.lastPollStatus),
         lastMessageStatus: normalizeMessageStatus(input.lastMessageStatus),
         updatedAt: typeof input.updatedAt === "string" ? input.updatedAt : timestamp
@@ -161,6 +166,35 @@ function normalizePushCursors(input) {
     }
     return out;
 }
+function normalizeLatestPmReplies(input) {
+    const out = {};
+    for (const [key, value] of Object.entries(input)) {
+        if (!isObject(value)) {
+            continue;
+        }
+        const repoRoot = normalizeNullableString(value.repoRoot);
+        const taskSlug = normalizeNullableString(value.taskSlug);
+        const sessionId = normalizeNullableString(value.sessionId);
+        const claudeSessionId = normalizeNullableString(value.claudeSessionId);
+        const capturedAt = normalizeNullableString(value.capturedAt);
+        const text = normalizeNullableString(value.text);
+        if (!repoRoot || !taskSlug || !sessionId || !claudeSessionId || !capturedAt || !text) {
+            continue;
+        }
+        out[key] = {
+            repoRoot,
+            taskSlug,
+            sessionId,
+            claudeSessionId,
+            transcriptEventId: normalizeNullableString(value.transcriptEventId),
+            transcriptTimestamp: normalizeNullableString(value.transcriptTimestamp),
+            capturedAt,
+            text,
+            truncated: value.truncated === true
+        };
+    }
+    return out;
+}
 function normalizePollStatus(input) {
     if (!isObject(input)) {
         return { state: "idle" };