vibe-coding-master 0.0.13 → 0.0.14

package/README.md

@@ -14,7 +14,7 @@ Each role runs as a real Claude Code process inside an embedded terminal. The GU
 ## Current V1 Capabilities
 
 - GUI-first task workspace.
-- Collapsible sidebar with repository connection, workflow, settings, harness status, task creation, and task list.
+- Collapsible sidebar with repository connection, 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.
@@ -156,8 +156,6 @@ project-manager
   -> 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.
-
 ## Task Worktree Management
 
 VCM uses task-level worktree management by default:
@@ -189,8 +187,7 @@ 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`: `Theme`, `Round alert`, `Messages`, and `Events`.
+- `Settings`: `Theme`, `Round alert`, `Try alert`, `Messages`, and `Events`.
 - `VCM Harness`: status for `CLAUDE.md`, role agent files, and `.gitignore`.
 - `New Task`: one `task name` input.
 - `Tasks`: task list and task status.
@@ -211,7 +208,7 @@ The same file stores recent repository paths. The translation API key is stored
 
 The sidebar `Settings` section also stores the UI theme preference in this file. The default is `system`, which follows the OS/browser color-scheme preference; users can cycle between `System`, `Light`, and `Dark`.
 
-The same sidebar also has a `Round alert` toggle. It is on by default and controls the in-app prompt plus short sound that fires when VCM detects that the current full conversation round is complete.
+The same sidebar also has a `Round alert` toggle. It is on by default and controls the in-app prompt plus short sound that fires when VCM detects that the current full conversation round is complete. The `Try alert` button triggers the same local prompt and sound for testing.
 
 Translation behavior:
 
@@ -263,6 +260,8 @@ For `.gitignore`, VCM uses a gitignore-native managed block:
 
 `.ai/vcm/` is the active VCM local control area, and `.claude/worktrees/` is the Claude-compatible task worktree area. The base repo keeps the task index; each task runtime repo keeps its own session, message, orchestration, and translation state.
 
+VCM also JSON-merges `.claude/settings.json` to install Claude Code `UserPromptSubmit` and `Stop` hooks. Those hooks call `vcmctl hook-event` through the session-provided `VCM_CTL_COMMAND`, so users do not need to configure hook commands manually.
+
 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.
@@ -311,7 +310,8 @@ When it is off, VCM is in manual mode:
 - Roles may send messages through `vcmctl`.
 - Messages appear in the `Messages` modal.
 - The user can inspect them.
-- The current GUI shows sequence, timestamp, status, body preview, path, and a `Copy` button for each message.
+- The current GUI shows sequence, timestamp, status, body preview, path, `Copy`, and `Mark All Done`.
+- `Mark All Done` marks open message records as `acknowledged` after the user manually copied or handled stuck queued/in-flight messages.
 - The user decides what to do next by copying or manually acting on the message.
 - VCM does not write to the target terminal or press Enter for the user.
 
@@ -320,11 +320,15 @@ 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 has no active delivered message, VCM writes a `[VCM MESSAGE]` envelope to the target terminal and submits it.
-- When the GUI observes a newly delivered auto message, it switches the active role tab to that message's target role so the user can watch the next step.
-- VCM enforces per-role turn-taking: each target role can have at most one in-flight delivered message.
+- If the target role session is running and has no active message, VCM writes a `[VCM MESSAGE]` envelope to the target terminal and submits it as `delivering`.
+- Claude Code `UserPromptSubmit` confirms the prompt really entered the target role session; VCM then marks the message `submitted`.
+- When the GUI observes a newly submitted auto message, it switches the active role tab to that message's target role so the user can watch the next step.
+- VCM enforces per-role turn-taking: each target role can have at most one in-flight `delivering`, `submitted`, `delivered`, or `staged` message.
 - Additional messages to a busy target role are kept as `queued` and are not written to that terminal.
 - When a role sends `vcmctl reply` or `vcmctl result`, VCM acknowledges that role's active message and delivers the next queued message for that role.
+- If auto orchestration gets stuck after a manual copy/paste recovery, `Mark All Done` clears open `pending_approval`, `queued`, `staged`, `delivering`, `submitted`, `delivered`, and failed message records to `acknowledged`.
+
+VCM Harness injects Claude Code `UserPromptSubmit` and `Stop` hooks into `.claude/settings.json`. Role tabs show `running` after `UserPromptSubmit` and `idle` after `Stop`; the terminal process status is still tracked separately. The injected role rules also require a role to end its turn after any successful `vcmctl send`, `vcmctl reply`, or `vcmctl result`, rather than running `vcmctl inbox`, looping, polling, or waiting for another role inside the same Claude Code turn.
 
 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.
 
@@ -332,9 +336,9 @@ The backend still exposes stage/approve/reject compatibility APIs for automation
 
 ## Round Completion Alerts
 
-VCM detects conversation completion from Claude Code transcript JSONL events, not PTY silence. The backend watches each running role session and treats `stop_reason === "end_turn"` as a candidate end only after pending tool uses have finished and a short debounce passes.
+VCM detects conversation completion from the hook-driven role activity state, not PTY silence. `UserPromptSubmit` marks a role `running`, and `Stop` marks that role `idle` with a stop timestamp.
 
-For role chains, VCM waits for the latest delivered message's target role. For example, if PM sends work to Coder and Coder sends a result back to PM, the round is not complete when Coder finishes; it is complete only after PM finishes the final response. If no VCM role message is involved, the latest direct role answer can complete the round.
+For role chains, VCM waits for the latest active message's target role to reach hook `Stop`. For example, if PM sends work to Coder and Coder sends a result back to PM, the round is not complete when Coder finishes; it is complete only after PM reaches `Stop` for the final response. If no VCM role message is involved, the latest direct role `Stop` can complete the round.
 
 When `Round alert` is enabled, the frontend polls the task round state, deduplicates each completion id, shows a small `Round complete` prompt, and plays a short local sound.
 

package/dist/backend/api/claude-hook-routes.js

@@ -0,0 +1,5 @@
+export function registerClaudeHookRoutes(app, deps) {
+    app.post("/api/hooks/claude-code", async (request) => {
+        return deps.claudeHookService.handleHook(request.body);
+    });
+}

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

@@ -12,6 +12,10 @@ export function registerMessageRoutes(app, deps) {
             ...request.body
         });
     });
+    app.post("/api/tasks/:taskSlug/messages/mark-all-done", async (request) => {
+        const context = await getRouteContext(deps, request.params.taskSlug);
+        return deps.messageService.markAllDone(context);
+    });
     app.post("/api/tasks/:taskSlug/messages/:messageId/stage", async (request) => {
         const context = await getRouteContext(deps, request.params.taskSlug);
         return deps.messageService.stageMessage({

package/dist/backend/server.js

@@ -7,6 +7,7 @@ import { createArtifactService } from "./services/artifact-service.js";
 import { createClaudeAdapter } from "./adapters/claude-adapter.js";
 import { createCommandRunner } from "./adapters/command-runner.js";
 import { createCommandDispatcher } from "./services/command-dispatcher.js";
+import { createClaudeHookService } from "./services/claude-hook-service.js";
 import { createGitAdapter } from "./adapters/git-adapter.js";
 import { createAppSettingsService } from "./services/app-settings-service.js";
 import { createClaudeTranscriptService } from "./services/claude-transcript-service.js";
@@ -24,6 +25,7 @@ import { createTaskService } from "./services/task-service.js";
 import { createTranslationService } from "./services/translation-service.js";
 import { registerAppSettingsRoutes } from "./api/app-settings-routes.js";
 import { registerArtifactRoutes } from "./api/artifact-routes.js";
+import { registerClaudeHookRoutes } from "./api/claude-hook-routes.js";
 import { registerHarnessRoutes } from "./api/harness-routes.js";
 import { registerMessageRoutes } from "./api/message-routes.js";
 import { registerProjectRoutes } from "./api/project-routes.js";
@@ -48,6 +50,7 @@ export async function createServer(deps, options = {}) {
         });
     });
     registerAppSettingsRoutes(app, { appSettings: deps.appSettings });
+    registerClaudeHookRoutes(app, { claudeHookService: deps.claudeHookService });
     registerProjectRoutes(app, { projectService: deps.projectService });
     registerHarnessRoutes(app, {
         projectService: deps.projectService,
@@ -157,10 +160,14 @@ export function createDefaultServerDeps(options = {}) {
         sessionService,
         taskService
     });
-    const transcripts = createClaudeTranscriptService();
-    const roundService = createRoundService({
-        transcripts
+    const claudeHookService = createClaudeHookService({
+        projectService,
+        taskService,
+        sessionService,
+        messageService
     });
+    const transcripts = createClaudeTranscriptService();
+    const roundService = createRoundService();
     const translationService = createTranslationService({
         runtime,
         sessionRegistry: registry,
@@ -179,6 +186,7 @@ export function createDefaultServerDeps(options = {}) {
         artifactService,
         harnessService,
         commandDispatcher,
+        claudeHookService,
         messageService,
         roundService,
         statusService,

package/dist/backend/services/claude-hook-service.js

@@ -0,0 +1,70 @@
+import { isRoleName } from "../../shared/constants.js";
+import { VcmError } from "../errors.js";
+import { getTaskRuntimeRepoRoot } from "./task-service.js";
+export function createClaudeHookService(deps) {
+    return {
+        async handleHook(input) {
+            if (!isRoleName(input.role)) {
+                throw new VcmError({
+                    code: "HOOK_ROLE_INVALID",
+                    message: `Unknown hook role: ${input.role}`,
+                    statusCode: 400
+                });
+            }
+            const eventName = parseHookEventName(input.event.hook_event_name);
+            const project = await deps.projectService.getCurrentProject();
+            if (!project) {
+                throw new VcmError({
+                    code: "PROJECT_NOT_CONNECTED",
+                    message: "Connect a repository before accepting Claude Code hooks.",
+                    statusCode: 409
+                });
+            }
+            const session = await deps.sessionService.recordClaudeHookEvent(project.repoRoot, {
+                taskSlug: input.taskSlug,
+                role: input.role,
+                eventName,
+                claudeSessionId: stringOrUndefined(input.event.session_id),
+                transcriptPath: stringOrUndefined(input.event.transcript_path),
+                cwd: stringOrUndefined(input.event.cwd)
+            });
+            let submittedMessageId;
+            if (eventName === "UserPromptSubmit" && typeof input.event.prompt === "string") {
+                const config = await deps.projectService.loadConfig(project.repoRoot);
+                const task = await deps.taskService.loadTask(project.repoRoot, input.taskSlug);
+                const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+                const submitted = await deps.messageService.confirmPromptSubmitted({
+                    repoRoot: project.repoRoot,
+                    stateRepoRoot: taskRepoRoot,
+                    stateRoot: config.stateRoot,
+                    taskSlug: input.taskSlug,
+                    role: input.role,
+                    prompt: input.event.prompt
+                });
+                submittedMessageId = submitted?.id;
+            }
+            return {
+                ok: true,
+                eventName,
+                taskSlug: input.taskSlug,
+                role: input.role,
+                sessionUpdated: Boolean(session),
+                submittedMessageId
+            };
+        }
+    };
+}
+function parseHookEventName(value) {
+    if (value === "UserPromptSubmit" || value === "Stop") {
+        return value;
+    }
+    throw new VcmError({
+        code: "HOOK_EVENT_UNSUPPORTED",
+        message: `Unsupported Claude Code hook event: ${String(value)}`,
+        statusCode: 400,
+        hint: "VCM currently accepts UserPromptSubmit and Stop hooks only."
+    });
+}
+function stringOrUndefined(value) {
+    return typeof value === "string" ? value : undefined;
+}

package/dist/backend/services/harness-service.js

@@ -8,6 +8,9 @@ import { renderReviewerHarnessRules } from "../templates/harness/reviewer-agent.
 export const VCM_HARNESS_VERSION = 1;
 const MANAGED_BLOCK_PATTERN = /<!-- VCM:BEGIN(?:\s+version=(\d+))? -->[\s\S]*?<!-- VCM:END -->/m;
 const HASH_MANAGED_BLOCK_PATTERN = /# VCM:BEGIN(?:\s+version=(\d+))?\n[\s\S]*?# VCM:END/m;
+const CLAUDE_SETTINGS_PATH = ".claude/settings.json";
+const VCM_HOOK_COMMAND = "sh -c 'if [ -n \"${VCM_CTL_COMMAND:-}\" ]; then eval \"$VCM_CTL_COMMAND hook-event\"; else vcmctl hook-event; fi'";
+const VCM_HOOK_EVENTS = ["UserPromptSubmit", "Stop"];
 const HARNESS_FILES = [
     {
         kind: "root-claude",
@@ -84,6 +87,7 @@ async function analyzeHarnessFiles(fs, repoRoot) {
     for (const definition of HARNESS_FILES) {
         analyses.push(await analyzeHarnessFile(fs, repoRoot, definition));
     }
+    analyses.push(await analyzeClaudeSettingsFile(fs, repoRoot));
     return analyses;
 }
 async function analyzeHarnessFile(fs, repoRoot, definition) {
@@ -188,6 +192,97 @@ function renderNewHarnessFile(definition, block) {
         : "";
     return `${frontmatter}# ${definition.title}\n\n${block}\n`;
 }
+async function analyzeClaudeSettingsFile(fs, repoRoot) {
+    const definition = {
+        kind: "claude-settings",
+        path: CLAUDE_SETTINGS_PATH,
+        title: "Claude Code Settings",
+        renderRules: () => ""
+    };
+    const absolutePath = resolveHarnessPath(repoRoot, CLAUDE_SETTINGS_PATH);
+    const exists = await fs.pathExists(absolutePath);
+    const current = exists
+        ? parseJsonObject(await fs.readText(absolutePath))
+        : {};
+    const next = withVcmClaudeHooks(current);
+    const currentContent = exists
+        ? `${JSON.stringify(current, null, 2)}\n`
+        : "";
+    const nextContent = `${JSON.stringify(next, null, 2)}\n`;
+    const action = exists
+        ? currentContent === nextContent ? "ok" : "update"
+        : "create";
+    return {
+        definition,
+        status: {
+            kind: "claude-settings",
+            path: CLAUDE_SETTINGS_PATH,
+            exists,
+            hasManagedBlock: false,
+            action
+        },
+        plannedChange: action === "ok"
+            ? undefined
+            : {
+                path: CLAUDE_SETTINGS_PATH,
+                action,
+                reason: exists
+                    ? "Claude Code hook settings do not contain the VCM UserPromptSubmit/Stop hook bridge."
+                    : "Claude Code hook settings are missing; VCM will create them."
+            },
+        nextContent: action === "ok" ? undefined : nextContent
+    };
+}
+function parseJsonObject(content) {
+    const parsed = JSON.parse(content);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return {};
+    }
+    return parsed;
+}
+function withVcmClaudeHooks(settings) {
+    const hooks = isPlainObject(settings.hooks)
+        ? { ...settings.hooks }
+        : {};
+    for (const eventName of VCM_HOOK_EVENTS) {
+        const existingMatchers = Array.isArray(hooks[eventName])
+            ? hooks[eventName]
+            : [];
+        hooks[eventName] = [
+            ...existingMatchers.filter((entry) => !isVcmHookMatcher(entry)),
+            createVcmHookMatcher()
+        ];
+    }
+    return {
+        ...settings,
+        hooks
+    };
+}
+function createVcmHookMatcher() {
+    return {
+        hooks: [
+            {
+                type: "command",
+                command: VCM_HOOK_COMMAND,
+                timeout: 5
+            }
+        ]
+    };
+}
+function isVcmHookMatcher(value) {
+    if (!isPlainObject(value) || !Array.isArray(value.hooks)) {
+        return false;
+    }
+    return value.hooks.some((hook) => {
+        if (!isPlainObject(hook)) {
+            return false;
+        }
+        return typeof hook.command === "string" && hook.command.includes("hook-event");
+    });
+}
+function isPlainObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
 function renderAgentFrontmatter(name, description) {
     return `---\nname: ${name}\ndescription: ${description}\ntools: Read, Grep, Glob, Bash, Edit, Write\n---`;
 }

package/dist/backend/services/message-service.js

@@ -8,6 +8,17 @@ import { renderManualStagePrompt, renderMessageEnvelope } from "../templates/mes
 const PM_ROLE = "project-manager";
 const PM_TO_ROLE_TYPES = new Set(["task", "question", "review-request", "revise", "cancel"]);
 const ROLE_TO_PM_TYPES = new Set(["result", "question", "blocked", "finding"]);
+const MARK_ALL_DONE_STATUSES = new Set([
+    "pending_approval",
+    "queued",
+    "staged",
+    "delivering",
+    "submitted",
+    "delivered",
+    "failed",
+    "delivery_failed",
+    "response_ready_missing_result"
+]);
 export function createMessageService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     const id = deps.id ?? (() => `msg_${randomUUID()}`);
@@ -117,15 +128,15 @@ export function createMessageService(deps) {
         return delivered;
     }
     async function deliverMessageToSession(sessionId, message, timestamp) {
-        const delivered = {
+        const delivering = {
             ...message,
-            status: "delivered",
+            status: "delivering",
             deliveredAt: timestamp,
             queuedBehindMessageId: undefined,
             failureReason: undefined
         };
-        await submitTerminalInput(deps.runtime, sessionId, renderMessageEnvelope(delivered));
-        return delivered;
+        await submitTerminalInput(deps.runtime, sessionId, renderMessageEnvelope(delivering));
+        return delivering;
     }
     return {
         listMessages(input) {
@@ -134,6 +145,55 @@ export function createMessageService(deps) {
         async sendMessage(input) {
             return withTaskLock(taskLocks, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), () => sendMessageLocked(input));
         },
+        async confirmPromptSubmitted(input) {
+            const messageId = extractSubmittedMessageId(input.prompt);
+            if (!messageId) {
+                return undefined;
+            }
+            const messages = await readLatestMessages(deps.fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
+            const message = messages.find((candidate) => candidate.id === messageId && candidate.toRole === input.role);
+            if (!message) {
+                return undefined;
+            }
+            if (message.status === "submitted" || message.status === "acknowledged") {
+                return message;
+            }
+            if (!isSubmittableMessageStatus(message.status)) {
+                return undefined;
+            }
+            const submitted = {
+                ...message,
+                status: "submitted",
+                submittedAt: now(),
+                failureReason: undefined
+            };
+            await appendMessageSnapshot(deps.fs, input, submitted);
+            return submitted;
+        },
+        async markAllDone(input) {
+            return withTaskLock(taskLocks, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), async () => {
+                const timestamp = now();
+                const messages = await readLatestMessages(deps.fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
+                const updated = messages
+                    .filter((message) => MARK_ALL_DONE_STATUSES.has(message.status))
+                    .map((message) => ({
+                    ...message,
+                    status: "acknowledged",
+                    acknowledgedAt: timestamp,
+                    queuedBehindMessageId: undefined,
+                    failureReason: undefined
+                }));
+                for (const message of updated) {
+                    await appendMessageSnapshot(deps.fs, input, message);
+                }
+                const latest = applyMessageSnapshots(messages, updated);
+                return {
+                    taskSlug: input.taskSlug,
+                    updatedCount: updated.length,
+                    messages: latest
+                };
+            });
+        },
         async stageMessage(input) {
             const message = await getMessageOrThrow(deps.fs, input);
             const session = await deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, message.toRole);
@@ -239,11 +299,11 @@ function isRoleActor(actor) {
     return ROLE_NAMES.includes(actor);
 }
 function findActiveMessageForRole(messages, role) {
-    return messages.find((message) => message.toRole === role && message.status === "delivered");
+    return messages.find((message) => message.toRole === role && isActiveMessageStatus(message.status));
 }
 function acknowledgeActiveMessages(messages, role, timestamp) {
     return messages
-        .filter((message) => message.toRole === role && message.status === "delivered")
+        .filter((message) => message.toRole === role && isActiveMessageStatus(message.status))
         .map((message) => ({
         ...message,
         status: "acknowledged",
@@ -251,6 +311,16 @@ function acknowledgeActiveMessages(messages, role, timestamp) {
         failureReason: undefined
     }));
 }
+function isActiveMessageStatus(status) {
+    return status === "delivering" || status === "submitted" || status === "delivered" || status === "staged";
+}
+function isSubmittableMessageStatus(status) {
+    return status === "delivering" || status === "delivered" || status === "staged" || status === "pending_approval";
+}
+function extractSubmittedMessageId(prompt) {
+    const match = prompt.match(/\bmsg_[A-Za-z0-9_-]+\b/);
+    return match?.[0];
+}
 function applyMessageSnapshots(messages, snapshots) {
     if (snapshots.length === 0) {
         return messages;

package/dist/backend/services/round-service.js

@@ -1,117 +1,9 @@
 import { ROLE_NAMES } from "../../shared/constants.js";
-export function createRoundService(deps) {
+export function createRoundService(deps = {}) {
     const now = deps.now ?? (() => new Date().toISOString());
-    const debounceMs = deps.debounceMs ?? 1500;
-    const trackers = new Map();
-    function ensureTracker(session) {
-        if (session.status !== "running") {
-            stopSession(session.id);
-            return;
-        }
-        if (trackers.has(session.id)) {
-            return;
-        }
-        const tracker = {
-            role: session.role,
-            sessionId: session.id,
-            taskSlug: session.taskSlug,
-            status: "unknown",
-            pendingToolUseIds: new Set(),
-            unsubscribe: () => { }
-        };
-        tracker.unsubscribe = deps.transcripts.subscribeToRoleSession(session, (event) => {
-            handleTranscriptEvent(tracker, event);
-        }, {
-            onError(error) {
-                tracker.status = "unknown";
-                tracker.reason = error.message;
-            }
-        });
-        trackers.set(session.id, tracker);
-    }
-    function handleTranscriptEvent(tracker, event) {
-        tracker.lastActivityAt = event.timestamp;
-        clearIdleTimer(tracker);
-        if (event.kind === "tool_use") {
-            tracker.pendingToolUseIds.add(event.id);
-            tracker.status = "using_tools";
-            tracker.reason = undefined;
-            return;
-        }
-        if (event.kind === "tool_result") {
-            tracker.pendingToolUseIds.delete(event.toolResult.tool_use_id);
-            tracker.status = tracker.pendingToolUseIds.size > 0 ? "using_tools" : "answering";
-            tracker.reason = undefined;
-            return;
-        }
-        if (event.kind === "question") {
-            tracker.status = "waiting_user";
-            tracker.reason = "Claude Code is asking for user input.";
-            return;
-        }
-        if (event.kind === "agent" || event.kind === "todo") {
-            tracker.status = "answering";
-            tracker.reason = undefined;
-            return;
-        }
-        if (event.kind === "thinking") {
-            tracker.status = "answering";
-            tracker.reason = undefined;
-            return;
-        }
-        if (event.kind === "text") {
-            if (event.stopReason === "max_tokens" || event.stopReason === "stop_sequence" || event.stopReason === "refusal") {
-                tracker.status = "abnormal";
-                tracker.reason = `Claude Code stopped with ${event.stopReason}.`;
-                return;
-            }
-            tracker.status = "answering";
-            tracker.reason = undefined;
-            if (event.stopReason === "end_turn" && tracker.pendingToolUseIds.size === 0 && event.text.trim()) {
-                scheduleIdle(tracker, event.timestamp);
-            }
-        }
-    }
-    function scheduleIdle(tracker, endedAt) {
-        tracker.pendingAnswerEndedAt = endedAt;
-        tracker.idleTimer = setTimeout(() => {
-            if (tracker.pendingToolUseIds.size > 0 || tracker.pendingAnswerEndedAt !== endedAt) {
-                return;
-            }
-            tracker.status = "idle";
-            tracker.lastAnswerEndedAt = endedAt;
-            tracker.reason = undefined;
-            tracker.idleTimer = undefined;
-        }, debounceMs);
-    }
-    function clearIdleTimer(tracker) {
-        tracker.pendingAnswerEndedAt = undefined;
-        if (tracker.idleTimer) {
-            clearTimeout(tracker.idleTimer);
-            tracker.idleTimer = undefined;
-        }
-    }
-    function stopSession(sessionId) {
-        const tracker = trackers.get(sessionId);
-        if (!tracker) {
-            return;
-        }
-        clearIdleTimer(tracker);
-        tracker.unsubscribe();
-        trackers.delete(sessionId);
-    }
     return {
         getTaskRoundState(input) {
-            const liveSessionIds = new Set(input.sessions.filter((session) => session.status === "running").map((session) => session.id));
-            for (const session of input.sessions) {
-                ensureTracker(session);
-            }
-            for (const [sessionId, tracker] of trackers) {
-                if (tracker.taskSlug === input.taskSlug && !liveSessionIds.has(sessionId)) {
-                    stopSession(sessionId);
-                }
-            }
-            const roleStates = ROLE_NAMES.map((role) => toRoleTurnState(role, input.sessions, trackers));
+            const roleStates = ROLE_NAMES.map((role) => toRoleTurnState(role, input.sessions));
             const latestDelivered = getLatestDeliveredMessage(input.messages);
             const queuedMessageCount = input.messages.filter((message) => message.status === "queued").length;
             const pendingMessageCount = input.messages.filter((message) => message.status === "pending_approval").length;
@@ -129,14 +21,8 @@ export function createRoundService(deps) {
                 pendingMessageCount
             };
         },
-        stopSession,
-        stopTask(taskSlug) {
-            for (const [sessionId, tracker] of trackers) {
-                if (tracker.taskSlug === taskSlug) {
-                    stopSession(sessionId);
-                }
-            }
-        }
+        stopSession() { },
+        stopTask() { }
     };
 }
 export function evaluateTaskRoundState(input) {
@@ -191,27 +77,31 @@ export function evaluateTaskRoundState(input) {
         updatedAt: input.updatedAt
     };
 }
-function toRoleTurnState(role, sessions, trackers) {
+function toRoleTurnState(role, sessions) {
     const session = sessions.find((candidate) => candidate.role === role && candidate.status === "running");
-    const tracker = session ? trackers.get(session.id) : undefined;
+    const activityStatus = session?.activityStatus ?? "idle";
     return {
         role,
         sessionId: session?.id,
-        status: tracker?.status ?? "unknown",
-        pendingToolUseCount: tracker?.pendingToolUseIds.size ?? 0,
-        lastActivityAt: tracker?.lastActivityAt,
-        lastAnswerEndedAt: tracker?.lastAnswerEndedAt,
-        reason: tracker?.reason
+        status: session ? activityStatus === "running" ? "answering" : "idle" : "unknown",
+        pendingToolUseCount: 0,
+        lastActivityAt: session?.lastPromptSubmittedAt ?? session?.lastHookEventAt,
+        lastAnswerEndedAt: session?.lastStopAt,
+        reason: session
+            ? activityStatus === "running"
+                ? "Claude Code accepted a prompt and has not emitted Stop yet."
+                : "Claude Code emitted Stop or has not started a prompt in this process."
+            : undefined
     };
 }
 function getLatestDeliveredMessage(messages) {
     return messages
-        .filter((message) => message.status === "delivered" || message.status === "staged")
+        .filter((message) => message.status === "delivering" || message.status === "submitted" || message.status === "delivered" || message.status === "staged")
         .sort((left, right) => getMessageDeliveredAt(left).localeCompare(getMessageDeliveredAt(right)))
         .at(-1);
 }
 function getMessageDeliveredAt(message) {
-    return message?.deliveredAt ?? message?.stagedAt ?? message?.createdAt ?? "";
+    return message?.submittedAt ?? message?.deliveredAt ?? message?.stagedAt ?? message?.createdAt ?? "";
 }
 function getCompletedAtForDelivery(roleState, deliveredAt) {
     if (roleState.status !== "idle" || !roleState.lastAnswerEndedAt) {