vibe-coding-master 0.8.2 → 0.8.4

package/README.md

@@ -195,7 +195,10 @@ Whenever Project Manager asks the user a question, it first uses
 `vcm-ask-user`. VCM records the wait and cancels any pending role dispatch in
 one state update. Stop Hook then ends the PM turn without route scanning. Only
 a new direct user message clears the wait, and the next role dispatch requires
-a fresh Workflow Review.
+a fresh Workflow Review. PM treats text emitted while a Round continues as
+intermediate output, not as delivered user communication. When the Round pauses
+or completes, its Round Final Reply restates the complete user-facing result or
+question without relying on earlier PM output.
 
 Typical flow:
 
@@ -506,14 +509,9 @@ provide the language server for each detected language: `rust-analyzer`,
 relationships. Accessors, backing fields, trait items, implementations, wrappers,
 and aliases are queried as separate symbols; a bounded source-text fallback may
 only locate candidates after the correct LSP query is demonstrably partial.
-Other roles use generated context and ordinary source reads.
-Harness Studio reports
-whether the server executable and plugin can run; the role Session performs the
-real workspace indexing and semantic query retries. VCM uses Claude Code progress
-hooks to detect a model response, tool call, subagent, or compaction that may be
-stalled. Detection only opens a warning; it does not interrupt the Session or
-change the Round. The user can ignore that warning or explicitly stop and resume
-the same Claude Session from the warning dialog.
+Other roles use generated context and ordinary source reads. Harness Studio
+reports whether the server executable and plugin can run; the role Session
+performs the real workspace indexing and semantic query retries.
 
 Harness Engineer is task-scoped and runs from the active task worktree. The
 backend automatically starts a fresh Harness Engineer for each active task or

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

@@ -77,8 +77,7 @@ export function registerTaskRoutes(app, deps) {
                 orchestration,
                 roundState: displayedRoundState,
                 workflowState,
-                architectRestart: deps.architectRestartService.getState(project.repoRoot, taskSlug),
-                roleStallWarning: deps.roleStallDetector.getWarning(project.repoRoot, taskSlug)
+                architectRestart: deps.architectRestartService.getState(project.repoRoot, taskSlug)
             };
         }
         catch (error) {
@@ -93,30 +92,12 @@ export function registerTaskRoutes(app, deps) {
                     },
                     roundState: degradedRoundState(taskSlug),
                     workflowState: degradedWorkflowState(taskSlug),
-                    architectRestart: deps.architectRestartService.getState(repoRoot, taskSlug),
-                    roleStallWarning: deps.roleStallDetector.getWarning(repoRoot, taskSlug)
+                    architectRestart: deps.architectRestartService.getState(repoRoot, taskSlug)
                 };
             }
             throw error;
         }
     });
-    app.post("/api/tasks/:taskSlug/role-stall/ignore", async (request) => {
-        const project = await requireCurrentProject(deps.projectService);
-        return deps.roleStallDetector.ignoreWarning(project.repoRoot, request.params.taskSlug, requireWarningId(request.body?.warningId));
-    });
-    app.post("/api/tasks/:taskSlug/role-stall/recover", async (request) => {
-        const project = await requireCurrentProject(deps.projectService);
-        const config = await deps.projectService.loadConfig(project.repoRoot);
-        const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
-        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
-        return deps.roleStallDetector.recoverWarning({
-            repoRoot: project.repoRoot,
-            taskRepoRoot,
-            stateRoot: config.stateRoot,
-            taskSlug: task.taskSlug,
-            warningId: requireWarningId(request.body?.warningId)
-        });
-    });
     app.post("/api/tasks/:taskSlug/workflow-state", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const config = await deps.projectService.loadConfig(project.repoRoot);
@@ -155,16 +136,6 @@ async function delayFlowPauseForTranslation(deps, input) {
         return input.roundState;
     }
 }
-function requireWarningId(value) {
-    if (typeof value === "string" && value.trim()) {
-        return value.trim();
-    }
-    throw new VcmError({
-        code: "ROLE_STALL_WARNING_ID_REQUIRED",
-        message: "A role stall warning id is required.",
-        statusCode: 400
-    });
-}
 async function requireCurrentProject(projectService) {
     const project = await projectService.getCurrentProject();
     if (!project) {

package/dist/backend/cli/install-vcm-harness.js

@@ -63,15 +63,8 @@ const VCM_HOOK_DEFINITIONS = [
     { eventName: "PreToolUse", matcher: "Write|Edit", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
     { eventName: "PreToolUse", matcher: "Agent", command: VCM_SUBAGENT_GUARD_HOOK_COMMAND, timeout: 10 },
     { eventName: "UserPromptSubmit", command: VCM_HOOK_COMMAND, timeout: 5 },
-    { eventName: "PreToolUse", command: VCM_HOOK_COMMAND, timeout: 5 },
-    { eventName: "PostToolUse", command: VCM_HOOK_COMMAND, timeout: 5 },
-    { eventName: "PostToolUseFailure", command: VCM_HOOK_COMMAND, timeout: 5 },
-    { eventName: "PostToolBatch", command: VCM_HOOK_COMMAND, timeout: 5 },
-    { eventName: "SubagentStart", command: VCM_HOOK_COMMAND, timeout: 5 },
-    { eventName: "SubagentStop", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "Stop", command: VCM_STOP_HOOK_COMMAND, timeout: 10 },
     { eventName: "StopFailure", command: VCM_HOOK_COMMAND, timeout: 5 },
-    { eventName: "PreCompact", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "PostCompact", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "PermissionRequest", command: VCM_PERMISSION_REQUEST_HOOK_COMMAND, timeout: 5 }
 ];

package/dist/backend/server.js

@@ -14,7 +14,6 @@ import { createCodexBridgeIntegrationService } from "./services/codex-bridge-int
 import { createAutoMemoryService } from "./services/auto-memory-service.js";
 import { createArchitectRestartService } from "./services/architect-restart-service.js";
 import { createRoleContextRestartService } from "./services/role-context-restart-service.js";
-import { createRoleStallDetectorService } from "./services/role-stall-detector-service.js";
 import { createClaudeTranscriptService } from "./services/claude-transcript-service.js";
 import { createGateReviewService } from "./services/gate-review-service.js";
 import { createHarnessFeedbackService } from "./services/harness-feedback-service.js";
@@ -137,7 +136,6 @@ export async function createServer(deps, options = {}) {
         roundService: deps.roundService,
         taskWorkflowService: deps.taskWorkflowService,
         architectRestartService: deps.architectRestartService,
-        roleStallDetector: deps.roleStallDetector,
         translationService: deps.translationService
     });
     registerSessionRoutes(app, {
@@ -245,7 +243,10 @@ export function createDefaultServerDeps(options = {}) {
     const runtime = createNodePtyTerminalRuntime({ fs });
     const registry = createSessionRegistry();
     const workflowControlService = createWorkflowControlService({ fs });
-    const artifactService = createArtifactService(fs, { workflowControlService });
+    const artifactService = createArtifactService(fs, {
+        workflowControlService,
+        isRoleMemoryTurn: (taskRepoRoot, role) => autoMemoryService.isRoleMemoryTurn(taskRepoRoot, role)
+    });
     const projectService = createProjectService({ fs, git, appSettings });
     const taskService = createTaskService({ fs, git, artifactService, projectService });
     const taskWorkflowService = createTaskWorkflowService({ fs });
@@ -351,10 +352,6 @@ export function createDefaultServerDeps(options = {}) {
         sessionService
     });
     const transcripts = createClaudeTranscriptService();
-    const roleStallDetector = createRoleStallDetectorService({
-        sessionService,
-        roundService
-    });
     const translationService = createTranslationService({
         runtime,
         sessionRegistry: registry,
@@ -432,7 +429,6 @@ export function createDefaultServerDeps(options = {}) {
         translationWorkerService,
         architectRestartService,
         roleContextRestartService,
-        roleStallDetector,
         workflowControlService
     });
     const runtimeCoordinator = createRuntimeCoordinatorService({
@@ -445,7 +441,6 @@ export function createDefaultServerDeps(options = {}) {
         harnessFeedbackService,
         autoMemoryService,
         roundService,
-        roleStallDetector,
         gatewayService,
         async getStateRoot(repoRoot) {
             return (await projectService.loadConfig(repoRoot)).stateRoot;
@@ -487,7 +482,6 @@ export function createDefaultServerDeps(options = {}) {
         autoMemoryService,
         commandDispatcher,
         claudeHookService,
-        roleStallDetector,
         messageService,
         taskLaunchService,
         gateReviewService,

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

@@ -219,6 +219,20 @@ export function createArtifactService(fs, deps = {}) {
                 if (validation.errors.length > 0) {
                     throw artifactRejected(input.kind, validation.errors);
                 }
+                if ((input.kind === "docs-update-report" || input.kind === "docs-sync-report")
+                    && deps.workflowControlService) {
+                    // Memory-owned documentation work is independent of PM's active dispatch.
+                    const memoryUpdate = input.kind === "docs-update-report"
+                        && await deps.isRoleMemoryTurn?.(input.repoRoot, input.role);
+                    if (!memoryUpdate) {
+                        await deps.workflowControlService.assertDocsArtifactAllowed({
+                            taskRepoRoot: input.repoRoot,
+                            stateRoot: input.stateRoot ?? ".ai/vcm",
+                            handoffDir: input.handoffDir,
+                            taskSlug: input.taskSlug
+                        }, input.kind, input.role);
+                    }
+                }
                 if (input.kind === "workflow-progress") {
                     if (input.mode !== "final") {
                         throw artifactRejected(input.kind, ["Workflow Progress must be submitted in final mode."]);

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

@@ -1,6 +1,7 @@
 import { isHarnessEngineerToolRoleName, isReviewerRoleName, isTranslatorToolRoleName, isVcmRoleName } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { readTranscriptTurnEvidence } from "./claude-transcript-reply.js";
+import { findPmUserQuestion } from "./pm-user-question.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { matchesRoleHookSession } from "./session-service.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
@@ -257,12 +258,6 @@ export function createClaudeHookService(deps) {
                 role: input.role,
                 eventName
             });
-            await deps.roleStallDetector?.recordHook({
-                ...createStallContext(context),
-                role: input.role,
-                eventName,
-                event: input.event
-            });
         }
         if (session) {
             await deps.translationService.recordConversationBoundary({
@@ -344,7 +339,10 @@ export function createClaudeHookService(deps) {
             }
             else {
                 const lastAssistantMessage = stringOrUndefined(input.event.last_assistant_message);
-                if (options.allowBlock && lastAssistantMessage && asksUserQuestion(lastAssistantMessage)) {
+                const question = options.allowBlock && lastAssistantMessage
+                    ? findPmUserQuestion(lastAssistantMessage)
+                    : undefined;
+                if (question) {
                     return {
                         ok: true,
                         eventName,
@@ -354,18 +352,12 @@ export function createClaudeHookService(deps) {
                         dispatchedCount: 0,
                         stopDecision: {
                             behavior: "block",
-                            reason: "You asked the user a question without registering the wait. Use vcm-ask-user with the exact question, then ask that question and stop. Do not advance or route the workflow."
+                            reason: `Possible unregistered user question: ${JSON.stringify(question.slice(0, 600))}. If you are asking the user, use vcm-ask-user with the exact question, then ask it and end the turn without advancing or routing the workflow. If this only reports or quotes another question, clarify that context and end normally; do not invent a user question or register a false wait.`
                         }
                     };
                 }
             }
         }
-        await deps.roleStallDetector?.recordHook({
-            ...createStallContext(context),
-            role: input.role,
-            eventName,
-            event: input.event
-        });
         if (pmAwaitingUser) {
             return recordTurnEnd(input, context, eventName, {
                 dispatchRouteFiles: false,
@@ -417,12 +409,6 @@ export function createClaudeHookService(deps) {
         if (memoryResult) {
             return memoryResult;
         }
-        await deps.roleStallDetector?.recordHook({
-            ...createStallContext(context),
-            role: input.role,
-            eventName,
-            event: input.event
-        });
         const routeDispatchInput = createRouteDispatchInput(input, context);
         const pending = await deps.messageService.listPendingRouteFiles(routeDispatchInput);
         const hasCompletionEvidence = pending.some((routeFile) => routeFile.fromRole === input.role);
@@ -496,14 +482,6 @@ export function createClaudeHookService(deps) {
             runtimeSessionId: stringOrUndefined(input.event.vcm_runtime_session_id),
             runtimeSessionToken: input.runtimeSessionToken
         });
-        if (session) {
-            await deps.roleStallDetector?.recordHook({
-                ...createStallContext(context),
-                role: input.role,
-                eventName,
-                event: input.event
-            });
-        }
         return {
             ok: true,
             eventName,
@@ -637,14 +615,6 @@ export function createClaudeHookService(deps) {
                 eventName
             });
         }
-        if (boundToTask) {
-            await deps.roleStallDetector?.recordHook({
-                ...createStallContext(context),
-                role: input.role,
-                eventName,
-                event: input.event
-            });
-        }
         await deps.autoMemoryService.handleRoleHook({
             baseRepoRoot: context.project.repoRoot,
             taskRepoRoot: context.taskRepoRoot,
@@ -869,31 +839,6 @@ export function createClaudeHookService(deps) {
             taskSlug: context.taskSlug
         };
     }
-    function createStallContext(context) {
-        return {
-            repoRoot: context.project.repoRoot,
-            taskRepoRoot: context.taskRepoRoot,
-            stateRoot: context.config.stateRoot,
-            taskSlug: context.taskSlug
-        };
-    }
-    async function processProgressHook(input, eventName) {
-        const role = input.role;
-        if (!isVcmRoleName(role)) {
-            return completedHookResult(input, eventName);
-        }
-        const context = await getHookContext(input);
-        if (!(await isCurrentRoleHook(context, input, eventName))) {
-            return completedHookResult(input, eventName);
-        }
-        await deps.roleStallDetector?.recordHook({
-            ...createStallContext(context),
-            role,
-            eventName,
-            event: input.event
-        });
-        return completedHookResult(input, eventName);
-    }
     function renderStopFailureRecoveryPrompt() {
         return [
             "[VCM Recovery]",
@@ -936,17 +881,6 @@ export function createClaudeHookService(deps) {
             });
         }
         const preferences = await deps.appSettings.getPreferences();
-        if (deps.roleStallDetector) {
-            const context = await getHookContext(input);
-            if (await isCurrentRoleHook(context, input, "PermissionRequest")) {
-                await deps.roleStallDetector.recordHook({
-                    ...createStallContext(context),
-                    role: input.role,
-                    eventName: "PermissionRequest",
-                    event: input.event
-                });
-            }
-        }
         if (preferences.permissionRequestMode !== "allowAll") {
             return undefined;
         }
@@ -963,9 +897,6 @@ export function createClaudeHookService(deps) {
         async handleHook(input) {
             return withRoleHookLock(input, async () => {
                 const eventName = parseHookEvent(input.event.hook_event_name);
-                if (isProgressHook(eventName)) {
-                    return processProgressHook(input, eventName);
-                }
                 if (isTranslatorToolRoleName(input.role)) {
                     return processTranslatorHook(input);
                 }
@@ -1004,13 +935,6 @@ function parseHookEvent(value) {
     if (value === "UserPromptSubmit"
         || value === "Stop"
         || value === "StopFailure"
-        || value === "PreToolUse"
-        || value === "PostToolUse"
-        || value === "PostToolUseFailure"
-        || value === "PostToolBatch"
-        || value === "SubagentStart"
-        || value === "SubagentStop"
-        || value === "PreCompact"
         || value === "PostCompact") {
         return value;
     }
@@ -1021,15 +945,6 @@ function parseHookEvent(value) {
         hint: "Use a Claude Code event installed by the VCM Harness."
     });
 }
-function isProgressHook(eventName) {
-    return eventName === "PreToolUse"
-        || eventName === "PostToolUse"
-        || eventName === "PostToolUseFailure"
-        || eventName === "PostToolBatch"
-        || eventName === "SubagentStart"
-        || eventName === "SubagentStop"
-        || eventName === "PreCompact";
-}
 function parseBusinessHookEvent(value) {
     const eventName = parseHookEvent(value);
     if (eventName === "UserPromptSubmit"
@@ -1092,14 +1007,3 @@ function isDirectUserPrompt(prompt) {
     const normalized = prompt.trim();
     return normalized.length > 0 && !/^\[VCM(?:\s|\])/i.test(normalized);
 }
-function asksUserQuestion(message) {
-    const withoutCodeBlocks = message.replace(/```[\s\S]*?```/g, "");
-    const lines = withoutCodeBlocks
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter(Boolean);
-    return lines.some((line) => /[?？]/.test(line)
-        || /^(?:please\s+(?:answer|choose|confirm|decide|provide|select|tell)|(?:can|could|do|does|is|are|should|will|would)\s+you\b)/i.test(line)
-        || /\b(?:please\s+(?:reply|respond|choose|confirm|decide|provide|select|tell|give)|i\s+need\s+your\s+(?:decision|choice|confirmation|answer)|let\s+me\s+know|your\s+(?:decision|choice|confirmation|answer)\s+is\s+required|waiting\s+for\s+your)\b/i.test(line)
-        || /(?:请(?:回答|回复|选择|确认|决定|提供|告知|给出|说明)|你(?:是否|能否|要不要|可否)|是否需要你|需要你(?:选择|确认|决定|提供|告知)|需要您的(?:选择|确认|决定|回复)|等待您的(?:选择|确认|决定|回复)|告诉我|告知我)/.test(line));
-}

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

@@ -63,15 +63,8 @@ const VCM_HOOK_DEFINITIONS = [
     { eventName: "PreToolUse", matcher: "Write|Edit", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
     { eventName: "PreToolUse", matcher: "Agent", command: VCM_SUBAGENT_GUARD_HOOK_COMMAND, timeout: 10 },
     { eventName: "UserPromptSubmit", command: VCM_HOOK_COMMAND, timeout: 5 },
-    { eventName: "PreToolUse", command: VCM_HOOK_COMMAND, timeout: 5 },
-    { eventName: "PostToolUse", command: VCM_HOOK_COMMAND, timeout: 5 },
-    { eventName: "PostToolUseFailure", command: VCM_HOOK_COMMAND, timeout: 5 },
-    { eventName: "PostToolBatch", command: VCM_HOOK_COMMAND, timeout: 5 },
-    { eventName: "SubagentStart", command: VCM_HOOK_COMMAND, timeout: 5 },
-    { eventName: "SubagentStop", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "Stop", command: VCM_STOP_HOOK_COMMAND, timeout: 10 },
     { eventName: "StopFailure", command: VCM_HOOK_COMMAND, timeout: 5 },
-    { eventName: "PreCompact", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "PostCompact", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "PermissionRequest", command: VCM_PERMISSION_REQUEST_HOOK_COMMAND, timeout: 5 }
 ];

package/dist/backend/services/pm-user-question.js

@@ -0,0 +1,62 @@
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+const markdown = unified().use(remarkParse).use(remarkGfm).freeze();
+// Match direct requests, not punctuation or requests mentioned inside a report.
+const DIRECT_REQUESTS = [
+    /^(?:can|could|do|did|are|have|should|will|would)\s+you\b/i,
+    /^(?:should|shall|may|can|could)\s+(?:i|we)\b/i,
+    /^(?:which|what|how|where|when|who)\b[^.!?]*\b(?:you|your|(?:should|shall|can|may)\s+(?:i|we))\b/i,
+    /^(?:which|what)\s+(?:option|approach|behavior|behaviour|choice)\b[^.!?]*\bshould\s+be\b/i,
+    /^(?:please\s+)?(?:answer|reply|respond|choose|confirm|decide|provide|select|tell\s+me|let\s+me\s+know|give\s+(?:me|your))\b/i,
+    /^i\s+need\s+your\s+(?:decision|choice|confirmation|answer|approval)\b/i,
+    /^your\s+(?:decision|choice|confirmation|answer|approval)\s+is\s+required\b/i,
+    /^(?:(?:i\s+am|i'm|we\s+are|we're)\s+)?waiting\s+for\s+your\s+(?:decision|choice|confirmation|answer|reply|approval)\b/i,
+    /^(?:请(?:您|你)?(?:回答|回复|选择|确认|决定|提供|告知|给出|说明)|[你您](?:是否|能否|要不要|可否|希望|想要)|是否需要[你您]|需要[你您](?:选择|确认|决定|提供|告知)|(?:需要|等待)[你您]的(?:选择|确认|决定|回复)|告诉我|告知我)/
+];
+export function findPmUserQuestion(message) {
+    return findQuestion(markdown.parse(message));
+}
+function findQuestion(node) {
+    // Quoted evidence and code are not PM addressing the user. Headings and table
+    // cells remain eligible: a real request does not stop being one when formatted.
+    if (["blockquote", "code", "html", "definition", "footnoteDefinition", "delete"].includes(node.type)) {
+        return undefined;
+    }
+    if (node.type === "paragraph" || node.type === "heading" || node.type === "tableCell") {
+        const prose = removeQuotedText(proseText(node)).replace(/\s+/g, " ");
+        for (const sentence of prose.split(/(?<=[.!?。！？；])\s*/)) {
+            const request = sentence.trim().replace(/^(?:(?:question(?:\s+for\s+you)?|your\s+decision|问题|请问)\s*[:：]\s*|before\s+(?:i|we)\s+(?:continue|proceed),?\s+)/i, "");
+            if (DIRECT_REQUESTS.some((pattern) => pattern.test(request))) {
+                return sentence.trim();
+            }
+        }
+        return undefined;
+    }
+    if ("children" in node) {
+        for (const child of node.children) {
+            const question = findQuestion(child);
+            if (question)
+                return question;
+        }
+    }
+    return undefined;
+}
+function proseText(node) {
+    if (node.type === "text")
+        return node.value;
+    if (node.type === "break")
+        return "\n";
+    if (["inlineCode", "html", "image", "imageReference", "delete", "footnoteReference"].includes(node.type))
+        return " ";
+    if (node.type === "link") {
+        const label = node.children.map(proseText).join("");
+        return label === node.url || /^(?:https?:\/\/|www\.)/i.test(label) ? " " : label;
+    }
+    if ("children" in node)
+        return node.children.map(proseText).join("");
+    return " ";
+}
+function removeQuotedText(text) {
+    return text.replace(/"[^"]*"|“[^”]*”|‘[^’]*’|「[^」]*」|『[^』]*』|(?<!\w)'[^']+'(?!\w)/g, " ");
+}

package/dist/backend/services/runtime-coordinator-service.js

@@ -42,17 +42,9 @@ export function createRuntimeCoordinatorService(deps) {
             ]);
             const preferences = await deps.appSettings.getPreferences();
             if (!activeTask) {
-                deps.roleStallDetector.clearProject(repoRoot);
                 return { activeTask: null, gatewayStatus };
             }
             const taskRepoRoot = getTaskRuntimeRepoRoot(activeTask);
-            const stateRoot = await deps.getStateRoot(repoRoot);
-            await deps.roleStallDetector.reconcileTask({
-                repoRoot,
-                taskRepoRoot,
-                stateRoot,
-                taskSlug: activeTask.taskSlug
-            });
             const harnessInitialized = await deps.harnessService.getHarnessStatus(taskRepoRoot)
                 .then((status) => status.initialized)
                 .catch(() => false);
@@ -86,7 +78,6 @@ export function createRuntimeCoordinatorService(deps) {
             void reconcileCurrentProject().catch(() => undefined);
         },
         stop() {
-            deps.roleStallDetector.stop();
             if (reconcileTimer === undefined) {
                 return;
             }
@@ -98,7 +89,6 @@ export function createRuntimeCoordinatorService(deps) {
     async function reconcileCurrentProject() {
         const project = await deps.projectService.getCurrentProject();
         if (!project) {
-            deps.roleStallDetector.stop();
             return;
         }
         await reconcileProject(project.repoRoot);

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

@@ -721,8 +721,7 @@ export function createSessionService(deps) {
             return undefined;
         }
         const timestamp = now();
-        const turnWasRunning = current.activityStatus === "running"
-            && current.expectedRuntimeExitReason !== "role-stall-recovery";
+        const turnWasRunning = current.activityStatus === "running";
         const updated = {
             ...current,
             status: input.status,
@@ -738,71 +737,6 @@ export function createSessionService(deps) {
         await persistRoleSessionRecord(deps.fs, repoRoot, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
         return { record: updated, turnWasRunning };
     }
-    async function persistTaskRoleRecord(repoRoot, taskSlug, record) {
-        deps.registry.upsert(record);
-        const config = await deps.projectService.loadConfig(repoRoot);
-        const task = await deps.taskService.loadTask(repoRoot, taskSlug);
-        await persistRoleSessionRecord(deps.fs, repoRoot, getTaskRuntimeRepoRoot(task), config.stateRoot, record);
-        return record;
-    }
-    async function recoverRoleSession(repoRoot, taskSlug, input) {
-        const current = await getTaskRoleSessionView(repoRoot, taskSlug, input.role);
-        if (!current
-            || current.id !== input.expectedSessionId
-            || current.runtimeSessionToken !== input.expectedRuntimeSessionToken
-            || current.status !== "running"
-            || current.activityStatus !== "running") {
-            throw new VcmError({
-                code: "ROLE_STALL_SESSION_CHANGED",
-                message: `${input.role} session changed before recovery could begin.`,
-                statusCode: 409
-            });
-        }
-        if (!current.claudeSessionId) {
-            throw new VcmError({
-                code: "CLAUDE_SESSION_MISSING",
-                message: `${input.role} does not have a confirmed Claude session id to resume.`,
-                statusCode: 409
-            });
-        }
-        const prepared = await persistTaskRoleRecord(repoRoot, taskSlug, {
-            ...current,
-            expectedRuntimeExitReason: "role-stall-recovery",
-            updatedAt: now()
-        });
-        if (deps.runtime.getSession(prepared.id)) {
-            await deps.runtime.stop(prepared.id);
-        }
-        await persistTaskRoleRecord(repoRoot, taskSlug, {
-            ...prepared,
-            status: "exited",
-            activityStatus: "idle",
-            pid: undefined,
-            expectedRuntimeExitReason: undefined,
-            updatedAt: now()
-        });
-        const resumed = await launchRoleSession(repoRoot, taskSlug, input.role, {
-            permissionMode: prepared.permissionMode,
-            model: prepared.model,
-            effort: prepared.effort
-        }, "resume");
-        if ((await waitForSessionInputReady(resumed.id)) === "exited") {
-            throw new VcmError({
-                code: "ROLE_STALL_RESUME_FAILED",
-                message: `${input.role} session exited before recovery input could be submitted.`,
-                statusCode: 409
-            });
-        }
-        await submitTerminalInput(deps.runtime, resumed.id, input.recoveryPrompt);
-        return persistTaskRoleRecord(repoRoot, taskSlug, {
-            ...resumed,
-            activityStatus: "running",
-            lastTurnStartedAt: now(),
-            lastHookEventAt: now(),
-            expectedRuntimeExitReason: undefined,
-            updatedAt: now()
-        });
-    }
     return {
         async assertModelLaunchReady(model = "default") {
             await getModelLaunchEnvironment(normalizeClaudeModel(model));
@@ -1307,8 +1241,7 @@ export function createSessionService(deps) {
                     : undefined;
             }
             return markTaskRoleActivityIdle(repoRoot, taskSlug, role);
-        },
-        recoverRoleSession
+        }
     };
 }
 function toRoleSessionRecordView(record, runtime) {
@@ -1398,7 +1331,7 @@ function isSessionMissingError(error) {
         error.code === "SESSION_MISSING";
 }
 function withoutRuntimeOnlySessionFields(session) {
-    const { pid: _pid, runtimeSessionToken: _runtimeSessionToken, expectedRuntimeExitReason: _expectedRuntimeExitReason, ...persisted } = session;
+    const { pid: _pid, runtimeSessionToken: _runtimeSessionToken, ...persisted } = session;
     return persisted;
 }
 function defaultIsProcessAlive(pid) {