vibe-coding-master 0.0.5 → 0.0.7

package/README.md

@@ -2,41 +2,32 @@
 
 VibeCodingMaster is a local GUI workspace for managing multiple Claude Code role sessions around one engineering task.
 
-It is designed for long-running coding work where one Claude Code conversation is not enough. VCM gives the user a task workspace with four role sessions:
+VCM is designed for long-running coding work where one Claude Code conversation is not enough. It gives the user a task workspace with four embedded Claude Code sessions:
 
 - `project-manager`
 - `architect`
 - `coder`
 - `reviewer`
 
-Each role runs as a real Claude Code process inside an embedded terminal. The GUI lets the user start, stop, resume, switch, inspect, and manually intervene in those sessions without juggling several terminal windows.
+Each role runs as a real Claude Code process inside an embedded terminal. The GUI lets the user start, stop, resume, restart, switch, observe, and manually intervene in those sessions without juggling separate terminal windows.
 
-## What It Does
-
-```text
-Open local GUI
-  -> connect a Git repository
-  -> create a task
-  -> start Claude Code role sessions
-  -> talk to Claude Code through embedded terminals
-  -> let project-manager coordinate architect / coder / reviewer
-  -> approve or automate role-to-role messages
-  -> resume interrupted role sessions later
-```
-
-Current V1 capabilities:
+## Current V1 Capabilities
 
 - GUI-first task workspace.
-- Embedded Claude Code terminals powered by `node-pty`.
-- One Claude Code session per role.
-- Role session recovery with persisted Claude session ids and `claude --resume`.
-- Permission mode selection before start/restart:
-  - default
+- Collapsible sidebar with repository connection, workflow, settings, harness status, task creation, and task list.
+- Recent repository path dropdown, stored locally with the five most recent paths.
+- Embedded Claude Code terminals powered by `node-pty` and `xterm.js`.
+- One Claude Code session per role, with role tabs in the task header.
+- Role session recovery through persisted Claude session ids and `claude --resume`.
+- Permission mode selection before start, resume, or restart:
+  - `default`
   - `bypassPermissions`
   - `--dangerously-skip-permissions`
 - PM-mediated role messaging through `vcmctl`.
 - Manual and automatic orchestration modes.
-- Durable task state, session state, raw logs, handoff artifacts, and message history.
+- VCM harness installer for `CLAUDE.md` and `.claude/agents/*.md`.
+- Translation panel powered by an OpenAI-compatible low-cost model.
+- Durable task state, session state, raw terminal logs, handoff artifacts, and message history.
 
 ## Requirements
 
@@ -56,20 +47,16 @@ From npm:
 
 ```bash
 npm install -g vibe-coding-master
-```
-
-Then start the packaged app:
-
-```bash
 vcm
 ```
 
-The published package also installs `vcmctl`, which Claude Code role sessions use internally for VCM message bus commands.
+The package also installs `vcmctl`, which Claude Code role sessions use internally to send VCM messages.
 
 From source:
 
 ```bash
 npm install
+npm run dev
 ```
 
 ## Run Locally
@@ -107,7 +94,7 @@ Then open:
 http://127.0.0.1:4173/
 ```
 
-If installed globally from npm, `vcm` runs the production-style app and serves the GUI from the backend port:
+The global `vcm` command runs the production-style app and serves the GUI from the backend port:
 
 ```text
 http://127.0.0.1:4173/
@@ -115,7 +102,7 @@ http://127.0.0.1:4173/
 
 ## Run In VS Code Dev Containers
 
-VCM works well inside a VS Code `devContainer` as long as VCM, Claude Code, and the target repository are all inside the same container filesystem.
+VCM works inside a VS Code `devContainer` when VCM, Claude Code, and the target repository all run inside the same container filesystem.
 
 Add port forwarding to `.devcontainer/devcontainer.json`:
 
@@ -133,39 +120,106 @@ Add port forwarding to `.devcontainer/devcontainer.json`:
 }
 ```
 
-Use:
-
-```bash
-npm install
-npm run dev
-```
-
-Open the forwarded `5173` port for development mode. If you run `npm run build && npm start`, only `4173` is required.
+Use the path as seen from inside the container, for example `/workspace`.
 
 Important container notes:
 
-- Install Claude Code inside the container, or make the `claude` command available in the container PATH.
+- Install Claude Code inside the container, or make `claude` available in the container `PATH`.
 - Make sure Claude Code authentication works inside the container.
-- Make sure the container has network access to Claude services.
-- Use the path as seen from inside the container, for example `/workspace`.
-- VCM accepts normal repositories by checking `/workspace/.git` directly; it does not require global Git `safe.directory` config to connect.
-- Keep the user project, `.vcm`, and `.ai/handoffs` on the same mounted workspace so paths are consistent.
+- Make sure the container has network access to Claude services and to the translation provider if translation is enabled.
+- VCM accepts normal Git repositories by checking `.git` directly. It also supports `.git` files that point to worktree gitdirs.
+- VCM uses per-command `git -c safe.directory=...` for Git metadata reads and does not require global `git config --global --add safe.directory`.
 - Treat the container as the sandbox boundary, especially when using relaxed Claude Code permission modes.
 
 ## Basic Usage
 
 1. Start VCM.
 2. Open the GUI.
-3. Connect a Git repository.
-4. Create a task.
-5. Select a role tab.
-6. Choose the Claude Code permission mode for that role.
-7. Click `Start`.
-8. Talk to `project-manager` first.
-9. Let PM delegate to `architect`, `coder`, or `reviewer`.
-10. Inspect and approve role messages in the `Messages` panel.
+3. In the sidebar, open `Repository Path`, enter a repository path or choose one from `Recent`, then click `Connect`.
+4. Review `VCM Harness`; if files need install/update, click `Install / Update`.
+5. Review any changed harness files and commit them if they look right.
+6. Create a task from `New Task` with a single task name.
+7. Select the task from `Tasks`.
+8. Use the role tabs in the task header to switch between `Project Manager`, `Architect`, `Coder`, and `Reviewer`.
+9. Choose the permission mode for the active role.
+10. Click `Start`, `Resume`, `Restart`, or `Stop` as needed.
+11. Talk mostly to `project-manager`; let PM coordinate the other roles through VCM messaging.
+
+The recommended flow is:
+
+```text
+project-manager
+  -> architect architecture plan
+  -> coder implementation and validation
+  -> reviewer independent review
+  -> architect docs sync / architecture drift check
+  -> project-manager final acceptance, commit, and PR
+```
+
+The workflow status is shown in the sidebar `Workflow` section. It is a soft guide in V1: VCM highlights missing or incomplete handoff artifacts and suggests the next step, but it does not hard-block the user from manually starting or switching roles.
+
+## Sidebar UI
+
+The left sidebar is intentionally compact and collapsible:
+
+- `Repository Path`: path input on one row; `Recent` and `Connect` on the next row.
+- `Repository`: connected path, branch, and working tree state. `Working tree: uncommitted changes` means `git status --porcelain` is not empty.
+- `Workflow`: current soft gate and five workflow steps.
+- `Settings`: `Messages`, `Events`, and the `Auto orchestration` on/off toggle.
+- `VCM Harness`: status for `CLAUDE.md` and role agent files.
+- `New Task`: one `task name` input.
+- `Tasks`: task list and task status.
+
+All sidebar sections are collapsed by default. When no task is selected, `Repository Path` opens by default.
+
+## Translation
+
+The `Translate` button in the role toolbar opens a translation panel beside the embedded terminal. The terminal and translation panel split the available width evenly.
+
+Translation settings are local and stored in:
+
+```text
+~/.vcm/settings.json
+```
+
+The same file stores recent repository paths. The translation API key is stored locally under `translation.secrets.apiKey`; it is not written to the connected repository, `.ai/handoffs`, raw terminal logs, or git diffs.
+
+Translation behavior:
+
+- Provider type is OpenAI-compatible chat completions.
+- Prompt slots are `zh-to-en`, `zh-to-en-with-context`, and `en-to-zh`.
+- The settings modal shows default prompts and allows per-slot overrides.
+- Claude Code output translation reads semantic Claude transcript JSONL files under `~/.claude/projects`, not raw PTY output.
+- Assistant prose is shown as English source while translating, then replaced by the translated Chinese result.
+- Tool calls and tool results are preserved as dim one-line rows such as `● Bash({"command":"npm test"})`.
+- User input uses one textarea. Press `Enter` to translate or send the current English draft; press `Shift+Enter` for a newline.
+- After user input is translated, the English draft replaces the original text in the same textarea.
+- `Send English` writes the current English draft to the active embedded terminal and submits it.
+- The translation panel `Auto-send` toggle sends the translated draft automatically when translation succeeds without warnings.
 
-The recommended flow is to mostly talk to `project-manager`. The PM role should coordinate the other roles through VCM messaging instead of asking the user to copy prompts between terminals.
+## Project Harness
+
+VCM works best when the connected repository contains VCM collaboration rules as normal project files. On first connect, VCM checks:
+
+```text
+CLAUDE.md
+.claude/agents/project-manager.md
+.claude/agents/architect.md
+.claude/agents/coder.md
+.claude/agents/reviewer.md
+```
+
+If a file is missing, VCM can create a recommended default. If a file already exists, VCM preserves user-authored content and only inserts or replaces a managed block:
+
+```md
+<!-- VCM:BEGIN version=1 -->
+VCM-managed rules live here.
+<!-- VCM:END -->
+```
+
+After applying harness changes, VCM reports the exact files changed and reminds the user to review and commit them before starting long-running work.
+
+Role sessions learn VCM rules from `CLAUDE.md` and `.claude/agents/*.md`. VCM does not paste a long context block into the terminal at session start.
 
 ## Message Bus
 
@@ -175,9 +229,9 @@ Role communication works like this:
 
 ```text
 Claude Code role
-  -> runs vcmctl send / vcmctl reply
+  -> runs vcmctl send / vcmctl reply / vcmctl result
   -> vcmctl calls VCM backend API
-  -> backend validates policy and persists the message
+  -> backend validates message policy and persists the message
   -> backend writes to the target embedded terminal when allowed
 ```
 
@@ -190,7 +244,7 @@ vcmctl result --body-file /tmp/result.md --artifact .ai/handoffs/task/implementa
 vcmctl inbox
 ```
 
-Files are still used for durability and auditability:
+Durable message and handoff files:
 
 ```text
 .vcm/messages/<task>.jsonl
@@ -200,16 +254,18 @@ Files are still used for durability and auditability:
 .ai/handoffs/<task>/logs/
 ```
 
+The backend also keeps a compatibility role-command dispatch endpoint, but the primary workflow is PM-mediated `vcmctl` messaging.
+
 ## Orchestration Modes
 
-VCM has a task-level `Auto orchestration` switch.
+VCM has a task-level `Auto orchestration` switch in the sidebar `Settings` section.
 
 When it is off, VCM is in manual mode:
 
 - Roles may send messages through `vcmctl`.
-- Messages appear in the GUI.
+- Messages appear in the `Messages` modal.
 - The user can inspect them.
-- Clicking `Stage` writes the message prompt into the target embedded terminal input line.
+- Clicking `Stage` writes a prompt into the target embedded terminal input line.
 - VCM does not press Enter for the user.
 
 When it is on, VCM is in auto mode:
@@ -217,13 +273,61 @@ When it is on, VCM is in auto mode:
 - Backend policy still applies.
 - PM can send work to `architect`, `coder`, or `reviewer`.
 - Non-PM roles can reply only to `project-manager`.
-- If the target role session is running and orchestration is not paused, VCM can deliver the message directly to the target terminal.
+- If the target role session is running, VCM writes a `[VCM MESSAGE]` envelope to the target terminal and submits it.
 
-High-risk work should still stop for human review.
+The backend state model still contains a `paused` field for compatibility with existing API routes, but the current GUI exposes only a single on/off orchestration toggle.
 
 ## Resume Behavior
 
-Each role session stores a Claude session id under `.vcm/sessions`. If VCM exits or a task is interrupted, reopen the task and use `Resume` for the role. VCM starts Claude Code with `claude --resume <session-id>` where supported by Claude Code.
+Each role session stores its Claude session id and transcript path under:
+
+```text
+.vcm/sessions/<task>.json
+```
+
+Session buttons behave as follows:
+
+- `Start`: creates a fresh UUID, builds `claude --agent <role> --session-id <uuid>`, and stores the transcript path.
+- `Resume`: reuses the persisted Claude session id and builds `claude --agent <role> --resume <uuid>`.
+- `Restart`: stops the current process if needed, creates a new UUID, and starts a fresh Claude session.
+- `Stop`: stops the embedded terminal process and leaves the persisted Claude session id resumable.
+
+## Local Project Files
+
+For a connected repository, VCM uses:
+
+```text
+.vcm/config.json
+.vcm/tasks/<task>.json
+.vcm/sessions/<task>.json
+.vcm/messages/<task>.jsonl
+.vcm/orchestration/<task>.json
+.ai/handoffs/<task>/architecture-plan.md
+.ai/handoffs/<task>/implementation-log.md
+.ai/handoffs/<task>/validation-log.md
+.ai/handoffs/<task>/review-report.md
+.ai/handoffs/<task>/docs-sync-report.md
+.ai/handoffs/<task>/role-commands/{architect,coder,reviewer}.md
+.ai/handoffs/<task>/logs/{project-manager,architect,coder,reviewer}.log
+```
+
+## Packaging
+
+The npm package publishes built output, not raw TypeScript entry files. `package.json` includes:
+
+- `bin.vcm`: `dist/main.js`
+- `bin.vcmctl`: `dist/cli/vcmctl.js`
+- `files`: `dist`, `dist-frontend`, `docs`, `scripts`, `README.md`
+- `prepack`: `npm run build && npm run verify:package`
+
+Use this before publishing:
+
+```bash
+npm run typecheck
+npm test
+npm run build
+npm run verify:package
+```
 
 ## Validation
 
@@ -237,8 +341,9 @@ npm run build
 
 - VCM does not use tmux.
 - VCM does not auto-confirm Claude Code permission prompts.
-- VCM does not deeply parse Claude Code output.
 - VCM does not isolate roles with separate worktrees in V1.
+- VCM does not translate Claude output from raw PTY output; translation reads Claude transcript JSONL files.
+- VCM does not write translation output into handoff artifacts unless a user or role explicitly copies it there.
 - File writes still happen in the connected repository environment.
 - The safest sandbox today is a container or VM boundary controlled by the user.
 
@@ -247,4 +352,4 @@ See also:
 - `docs/product-design.md`
 - `docs/v1-architecture-design.md`
 - `docs/v1-implementation-plan.md`
-- `docs/v1-message-bus-orchestration-design.md`
+- `docs/cc-best-practices.md`

package/dist/backend/adapters/translation-provider.js

@@ -0,0 +1,145 @@
+export class TranslationProviderError extends Error {
+    code;
+    elapsedMs;
+    constructor(message, code, elapsedMs = 0) {
+        super(message);
+        this.name = "TranslationProviderError";
+        this.code = code;
+        this.elapsedMs = elapsedMs;
+    }
+}
+export function createOpenAiCompatibleTranslationProvider(fetchImpl = fetch) {
+    return {
+        async testConnection(settings, secrets) {
+            const startedAt = performance.now();
+            try {
+                await this.translate({
+                    settings,
+                    secrets,
+                    systemPrompt: "Reply with exactly: ok",
+                    userPrompt: "ok"
+                });
+                return {
+                    ok: true,
+                    model: settings.model,
+                    elapsedMs: Math.round(performance.now() - startedAt)
+                };
+            }
+            catch (error) {
+                return {
+                    ok: false,
+                    model: settings.model,
+                    elapsedMs: Math.round(performance.now() - startedAt),
+                    error: error instanceof Error ? error.message : "Translation provider failed."
+                };
+            }
+        },
+        async translate(input) {
+            const apiKey = input.secrets.apiKey?.trim();
+            if (!apiKey) {
+                throw new TranslationProviderError("Translation API key is not configured.", "config");
+            }
+            const startedAt = performance.now();
+            const elapsed = () => Math.round(performance.now() - startedAt);
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), input.settings.requestTimeoutMs);
+            const externalAbort = () => controller.abort();
+            if (input.signal) {
+                if (input.signal.aborted) {
+                    controller.abort();
+                }
+                else {
+                    input.signal.addEventListener("abort", externalAbort, { once: true });
+                }
+            }
+            try {
+                const response = await fetchImpl(buildChatCompletionsUrl(input.settings.baseUrl), {
+                    method: "POST",
+                    headers: {
+                        "content-type": "application/json",
+                        authorization: `Bearer ${apiKey}`
+                    },
+                    body: JSON.stringify({
+                        model: input.settings.model,
+                        messages: [
+                            { role: "system", content: input.systemPrompt },
+                            { role: "user", content: input.userPrompt }
+                        ],
+                        temperature: input.settings.temperature,
+                        stream: false
+                    }),
+                    signal: controller.signal
+                });
+                const rawText = await response.text();
+                let payload = null;
+                try {
+                    payload = rawText ? JSON.parse(rawText) : null;
+                }
+                catch {
+                    if (!response.ok) {
+                        throw new TranslationProviderError(rawText || response.statusText, `HTTP ${response.status}`, elapsed());
+                    }
+                    throw new TranslationProviderError("Translation provider returned invalid JSON.", "parse", elapsed());
+                }
+                if (!response.ok) {
+                    throw new TranslationProviderError(extractErrorMessage(payload) ?? response.statusText, `HTTP ${response.status}`, elapsed());
+                }
+                const content = extractContent(payload);
+                if (!content) {
+                    throw new TranslationProviderError("Translation provider returned empty content.", "parse", elapsed());
+                }
+                return {
+                    text: content,
+                    elapsedMs: elapsed(),
+                    tokenUsage: parseOpenAiUsage(payload?.usage)
+                };
+            }
+            catch (error) {
+                if (error instanceof TranslationProviderError) {
+                    throw error;
+                }
+                const message = error instanceof Error ? error.message : String(error);
+                const code = message.toLowerCase().includes("abort") ? "timeout" : "network";
+                throw new TranslationProviderError(message, code, elapsed());
+            }
+            finally {
+                clearTimeout(timeout);
+                input.signal?.removeEventListener("abort", externalAbort);
+            }
+        }
+    };
+}
+export function buildChatCompletionsUrl(baseUrl) {
+    return `${baseUrl.replace(/\/$/, "")}/chat/completions`;
+}
+export function parseOpenAiUsage(raw) {
+    if (!raw || typeof raw !== "object") {
+        return undefined;
+    }
+    const usage = raw;
+    const input = typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : 0;
+    const output = typeof usage.completion_tokens === "number" ? usage.completion_tokens : 0;
+    const total = typeof usage.total_tokens === "number" ? usage.total_tokens : input + output;
+    if (input === 0 && output === 0 && total === 0) {
+        return undefined;
+    }
+    return { input, output, total };
+}
+function extractContent(payload) {
+    const choices = payload?.choices;
+    if (!Array.isArray(choices) || choices.length === 0) {
+        return null;
+    }
+    const content = choices[0].message?.content;
+    return typeof content === "string" ? content.trim() : null;
+}
+function extractErrorMessage(payload) {
+    const error = payload?.error;
+    if (!error) {
+        return null;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    return error.message ?? JSON.stringify(error);
+}

package/dist/backend/api/artifact-routes.js

@@ -90,6 +90,9 @@ function artifactNameToPath(paths, artifactName) {
     if (artifactName === "review-report.md") {
         return paths.reviewReportPath;
     }
+    if (artifactName === "docs-sync-report.md") {
+        return paths.docsSyncReportPath;
+    }
     throw new VcmError({
         code: "ARTIFACT_UNKNOWN",
         message: `Unknown artifact: ${artifactName}`,

package/dist/backend/api/harness-routes.js

@@ -0,0 +1,22 @@
+import { VcmError } from "../errors.js";
+export function registerHarnessRoutes(app, deps) {
+    app.get("/api/projects/harness", async () => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.harnessService.getHarnessStatus(project.repoRoot);
+    });
+    app.post("/api/projects/harness/apply", async () => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.harnessService.applyHarness(project.repoRoot);
+    });
+}
+async function requireCurrentProject(projectService) {
+    const project = await projectService.getCurrentProject();
+    if (!project) {
+        throw new VcmError({
+            code: "PROJECT_NOT_CONNECTED",
+            message: "Connect a repository first.",
+            statusCode: 409
+        });
+    }
+    return project;
+}

package/dist/backend/api/project-routes.js

@@ -1,17 +1,12 @@
 export function registerProjectRoutes(app, deps) {
     app.get("/api/health", async () => ({ ok: true }));
+    app.get("/api/projects/recent", async () => {
+        return deps.projectService.getRecentRepositoryPaths();
+    });
     app.post("/api/projects/connect", async (request) => {
         return deps.projectService.connectProject(request.body);
     });
     app.get("/api/projects/current", async () => {
         return deps.projectService.getCurrentProject();
     });
-    app.get("/api/projects/harness", async () => ({
-        checks: [
-            {
-                name: "local-gui",
-                status: "ok"
-            }
-        ]
-    }));
 }

package/dist/backend/api/translation-routes.js

@@ -0,0 +1,70 @@
+import { isRoleName } from "../../shared/constants.js";
+import { VcmError } from "../errors.js";
+export function registerTranslationRoutes(app, deps) {
+    app.get("/api/translation/settings", async () => {
+        return deps.translationService.getSettings();
+    });
+    app.put("/api/translation/settings", async (request) => {
+        const { apiKey, ...settings } = request.body ?? {};
+        return deps.translationService.updateSettings(settings, apiKey !== undefined ? { apiKey } : undefined);
+    });
+    app.get("/api/translation/prompts", async () => {
+        return deps.translationService.getPromptPreviews();
+    });
+    app.post("/api/translation/test", async () => {
+        return deps.translationService.testProvider();
+    });
+    app.post("/api/tasks/:taskSlug/sessions/:role/translation/input", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const role = parseRole(request.params.role);
+        await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        return deps.translationService.translateUserInput({
+            repoRoot: project.repoRoot,
+            taskSlug: request.params.taskSlug,
+            role,
+            ...(request.body ?? { text: "" })
+        });
+    });
+    app.post("/api/tasks/:taskSlug/sessions/:role/translation/send", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const role = parseRole(request.params.role);
+        await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        await deps.translationService.sendTranslatedInput({
+            repoRoot: project.repoRoot,
+            taskSlug: request.params.taskSlug,
+            role,
+            englishText: request.body?.englishText ?? ""
+        });
+        return { ok: true };
+    });
+    app.post("/api/translation/sessions/:sessionId/clear", async (request) => {
+        await requireCurrentProject(deps.projectService);
+        deps.translationService.clearSession(request.params.sessionId);
+        return { ok: true };
+    });
+    app.post("/api/translation/sessions/:sessionId/retry/:translationId", async (request) => {
+        await requireCurrentProject(deps.projectService);
+        return deps.translationService.retryTranslation(request.params.sessionId, request.params.translationId);
+    });
+}
+function parseRole(role) {
+    if (!isRoleName(role)) {
+        throw new VcmError({
+            code: "UNKNOWN_ROLE",
+            message: `Unknown role: ${role}`,
+            statusCode: 400
+        });
+    }
+    return role;
+}
+async function requireCurrentProject(projectService) {
+    const project = await projectService.getCurrentProject();
+    if (!project) {
+        throw new VcmError({
+            code: "PROJECT_NOT_CONNECTED",
+            message: "Connect a repository first.",
+            statusCode: 409
+        });
+    }
+    return project;
+}

package/dist/backend/runtime/node-pty-runtime.js

@@ -109,27 +109,29 @@ export function createNodePtyTerminalRuntime(deps) {
             entry.process.kill();
             return create(entry.input, sessionId);
         },
-        subscribe(sessionId, listener) {
+        subscribe(sessionId, listener, options = {}) {
             const entry = getEntry(entries, sessionId);
             entry.listeners.add(listener);
-            void deps.fs.readText(entry.input.logPath)
-                .then((data) => {
-                if (!data || !entry.listeners.has(listener)) {
-                    return;
-                }
-                listener({
-                    id: `evt_${Date.now()}_${Math.random().toString(16).slice(2)}`,
-                    sessionId,
-                    taskSlug: entry.session.taskSlug,
-                    role: entry.session.role,
-                    type: "output",
-                    timestamp: now(),
-                    data
+            if (options.replay !== false) {
+                void deps.fs.readText(entry.input.logPath)
+                    .then((data) => {
+                    if (!data || !entry.listeners.has(listener)) {
+                        return;
+                    }
+                    listener({
+                        id: `evt_${Date.now()}_${Math.random().toString(16).slice(2)}`,
+                        sessionId,
+                        taskSlug: entry.session.taskSlug,
+                        role: entry.session.role,
+                        type: "output",
+                        timestamp: now(),
+                        data
+                    });
+                })
+                    .catch(() => {
+                    // The log file may not exist yet for a brand-new session.
                 });
-            })
-                .catch(() => {
-                // The log file may not exist yet for a brand-new session.
-            });
+            }
             return () => {
                 entry.listeners.delete(listener);
             };