vibe-coding-master 0.8.2 → 0.8.3

package/README.md

@@ -506,14 +506,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, {
@@ -351,10 +349,6 @@ export function createDefaultServerDeps(options = {}) {
         sessionService
     });
     const transcripts = createClaudeTranscriptService();
-    const roleStallDetector = createRoleStallDetectorService({
-        sessionService,
-        roundService
-    });
     const translationService = createTranslationService({
         runtime,
         sessionRegistry: registry,
@@ -432,7 +426,6 @@ export function createDefaultServerDeps(options = {}) {
         translationWorkerService,
         architectRestartService,
         roleContextRestartService,
-        roleStallDetector,
         workflowControlService
     });
     const runtimeCoordinator = createRuntimeCoordinatorService({
@@ -445,7 +438,6 @@ export function createDefaultServerDeps(options = {}) {
         harnessFeedbackService,
         autoMemoryService,
         roundService,
-        roleStallDetector,
         gatewayService,
         async getStateRoot(repoRoot) {
             return (await projectService.loadConfig(repoRoot)).stateRoot;
@@ -487,7 +479,6 @@ export function createDefaultServerDeps(options = {}) {
         autoMemoryService,
         commandDispatcher,
         claudeHookService,
-        roleStallDetector,
         messageService,
         taskLaunchService,
         gateReviewService,

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

@@ -257,12 +257,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({
@@ -360,12 +354,6 @@ export function createClaudeHookService(deps) {
                 }
             }
         }
-        await deps.roleStallDetector?.recordHook({
-            ...createStallContext(context),
-            role: input.role,
-            eventName,
-            event: input.event
-        });
         if (pmAwaitingUser) {
             return recordTurnEnd(input, context, eventName, {
                 dispatchRouteFiles: false,
@@ -417,12 +405,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 +478,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 +611,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 +835,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 +877,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 +893,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 +931,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 +941,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"

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/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) {