vibe-coding-master 0.6.23 → 0.7.0

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

@@ -1,4 +1,4 @@
-import { DISPATCHABLE_ROLES, VCM_ROLE_NAMES } from "../../shared/constants.js";
+import { DISPATCHABLE_ROLES } from "../../shared/constants.js";
 import { isOpenFileLimitError, VcmError } from "../errors.js";
 import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
 export function registerTaskRoutes(app, deps) {
@@ -92,39 +92,9 @@ export function registerTaskRoutes(app, deps) {
     });
     app.post("/api/tasks/:taskSlug/cleanup", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
-        const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
-        await stopRunningRoleSessions(deps, project.repoRoot, request.params.taskSlug);
-        await moveProjectToolSessionsToSafeCwd(deps, project.repoRoot);
-        await deps.translationService.stopTask(getTaskRuntimeRepoRoot(task), request.params.taskSlug, { clearCache: true });
-        deps.roundService.stopTask(request.params.taskSlug);
-        return deps.taskService.cleanupTask(project.repoRoot, request.params.taskSlug, request.body ?? {});
+        return deps.taskCloseService.closeTask(project.repoRoot, request.params.taskSlug);
     });
 }
-async function stopRunningRoleSessions(deps, repoRoot, taskSlug) {
-    const sessions = await deps.sessionService.listRoleSessions(repoRoot, taskSlug);
-    for (const session of sessions) {
-        if (session.status === "running" && VCM_ROLE_NAMES.some((role) => role === session.role)) {
-            await deps.sessionService.stopRoleSession(repoRoot, taskSlug, session.role);
-        }
-    }
-}
-async function moveProjectToolSessionsToSafeCwd(deps, repoRoot) {
-    await Promise.all([
-        ignoreMissingSession(deps.sessionService.moveProjectTranslatorSessionToSafeCwd(repoRoot)),
-        ignoreMissingSession(deps.sessionService.moveProjectHarnessEngineerSessionToSafeCwd(repoRoot))
-    ]);
-}
-async function ignoreMissingSession(operation) {
-    try {
-        await operation;
-    }
-    catch (error) {
-        if (error instanceof VcmError && error.code === "SESSION_MISSING") {
-            return;
-        }
-        throw error;
-    }
-}
 async function requireCurrentProject(projectService) {
     const project = await projectService.getCurrentProject();
     if (!project) {

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

@@ -36,7 +36,7 @@ const LEGACY_CODEX_HARNESS_PATHS = [
     ".ai/tools/request-codex-review"
 ];
 const VCM_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --max-time 2 -X POST "\${VCM_API_URL}/api/hooks/claude-code" -H "content-type: application/json" --data-binary @- >/dev/null || true'`;
-const VCM_STOP_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --max-time 5 -X POST "\${VCM_API_URL}/api/hooks/claude-code/stop" -H "content-type: application/json" --data-binary @- || true'`;
+const VCM_STOP_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --retry 2 --retry-delay 1 --retry-all-errors --connect-timeout 1 --max-time 2 -X POST "\${VCM_API_URL}/api/hooks/claude-code/stop" -H "content-type: application/json" --data-binary @- || true'`;
 const VCM_PERMISSION_REQUEST_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --max-time 5 -X POST "\${VCM_API_URL}/api/hooks/claude-code/permission-request" -H "content-type: application/json" --data-binary @- || true'`;
 const VCM_BASH_GUARD_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ]; then exit 0; fi; guard=""; repo="$(git rev-parse --show-toplevel 2>/dev/null || true)"; if [ -n "$repo" ] && [ -f "$repo/.ai/tools/vcm-bash-guard" ]; then guard="$repo/.ai/tools/vcm-bash-guard"; else cwd="$(pwd -P 2>/dev/null || pwd)"; dir="$cwd"; while [ -n "$dir" ] && [ "$dir" != "/" ]; do if [ -f "$dir/.ai/tools/vcm-bash-guard" ]; then guard="$dir/.ai/tools/vcm-bash-guard"; break; fi; dir="$(dirname "$dir")"; done; if [ -z "$guard" ] && [ -n "\${CLAUDE_PROJECT_DIR:-}" ] && [ -f "\${CLAUDE_PROJECT_DIR}/.ai/tools/vcm-bash-guard" ]; then guard="\${CLAUDE_PROJECT_DIR}/.ai/tools/vcm-bash-guard"; fi; fi; [ -n "$guard" ] || exit 0; python3 "$guard" || exit 0'`;
 const VCM_BASH_DEFAULT_TIMEOUT_MS = "600000";

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

@@ -1,4 +1,3 @@
-import { VCM_ROLE_NAMES } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
@@ -605,15 +604,7 @@ export function createGatewayService(deps) {
                 hint: settings.currentTaskSlug ? `Use /close-task confirm ${settings.currentTaskSlug}` : undefined
             });
         }
-        const task = await deps.taskService.loadTask(project.repoRoot, taskSlug);
-        await stopRunningRoleSessions(project.repoRoot, taskSlug);
-        await moveProjectToolSessionsToSafeCwd(project.repoRoot);
-        await deps.translationService.stopTask(getTaskRuntimeRepoRoot(task), taskSlug, { clearCache: true });
-        deps.roundService.stopTask(taskSlug);
-        const result = await deps.taskService.cleanupTask(project.repoRoot, taskSlug, {
-            force: true,
-            forceDeleteBranch: true
-        });
+        const result = await deps.taskCloseService.closeTask(project.repoRoot, taskSlug);
         clearFailedTranslation(project.repoRoot, taskSlug);
         const latestPmReplies = { ...settings.latestPmReplies };
         delete latestPmReplies[latestPmReplyKey(project.repoRoot, taskSlug)];
@@ -629,8 +620,9 @@ export function createGatewayService(deps) {
         });
         const lines = [
             `Closed task: ${result.taskSlug}`,
-            result.removedWorktreePath ? `removed worktree: ${result.removedWorktreePath}` : "removed worktree: none",
-            result.deletedBranch ? `deleted branch: ${result.deletedBranch}` : "deleted branch: none",
+            `worktree removed: ${result.worktreeRemoved ? "yes" : "no"}`,
+            `branch deleted: ${result.branchDeleted ? "yes" : "no"}`,
+            `task state removed: ${result.stateRemoved ? "yes" : "no"}`,
             `removed state paths: ${result.removedStatePaths.length}`
         ];
         if (result.warnings?.length) {
@@ -638,31 +630,6 @@ export function createGatewayService(deps) {
         }
         return lines.join("\n");
     }
-    async function stopRunningRoleSessions(repoRoot, taskSlug) {
-        const sessions = await deps.sessionService.listRoleSessions(repoRoot, taskSlug);
-        for (const session of sessions) {
-            if (session.status === "running" && VCM_ROLE_NAMES.some((role) => role === session.role)) {
-                await deps.sessionService.stopRoleSession(repoRoot, taskSlug, session.role);
-            }
-        }
-    }
-    async function moveProjectToolSessionsToSafeCwd(repoRoot) {
-        await Promise.all([
-            ignoreMissingSession(deps.sessionService.moveProjectTranslatorSessionToSafeCwd(repoRoot)),
-            ignoreMissingSession(deps.sessionService.moveProjectHarnessEngineerSessionToSafeCwd(repoRoot))
-        ]);
-    }
-    async function ignoreMissingSession(operation) {
-        try {
-            await operation;
-        }
-        catch (error) {
-            if (error instanceof VcmError && error.code === "SESSION_MISSING") {
-                return;
-            }
-            throw error;
-        }
-    }
     async function setGatewayTranslation(enabled) {
         const settings = await deps.settings.updateSettings({ translationEnabled: enabled });
         return `Gateway translation ${settings.translationEnabled ? "on" : "off"}.`;

package/dist/backend/server.js

@@ -35,9 +35,11 @@ import { createRuntimeCoordinatorService } from "./services/runtime-coordinator-
 import { createRuntimeRecoveryService } from "./services/runtime-recovery-service.js";
 import { createStatusService } from "./services/status-service.js";
 import { createTaskService } from "./services/task-service.js";
+import { createTaskCloseService } from "./services/task-close-service.js";
 import { createTaskLaunchService } from "./services/task-launch-service.js";
 import { createTerminalInterruptService } from "./services/terminal-interrupt-service.js";
 import { createTranslationService } from "./services/translation-service.js";
+import { createTurnReconcilerService } from "./services/turn-reconciler-service.js";
 import { createDiagnosticsService } from "./services/diagnostics-service.js";
 import { registerAppSettingsRoutes } from "./api/app-settings-routes.js";
 import { registerArtifactRoutes } from "./api/artifact-routes.js";
@@ -112,11 +114,10 @@ export async function createServer(deps, options = {}) {
     registerTaskRoutes(app, {
         projectService: deps.projectService,
         taskService: deps.taskService,
-        sessionService: deps.sessionService,
+        taskCloseService: deps.taskCloseService,
         statusService: deps.statusService,
         messageService: deps.messageService,
         taskLaunchService: deps.taskLaunchService,
-        translationService: deps.translationService,
         roundService: deps.roundService
     });
     registerSessionRoutes(app, {
@@ -154,9 +155,11 @@ export async function createServer(deps, options = {}) {
     });
     app.addHook("onReady", async () => {
         await cleanupRecentTranslationRuntime(deps);
+        deps.runtimeCoordinator.start();
         await deps.gatewayService.start();
     });
     app.addHook("onClose", async () => {
+        deps.runtimeCoordinator.stop();
         await deps.gatewayService.stop();
     });
     if (options.staticDir) {
@@ -306,6 +309,12 @@ export function createDefaultServerDeps(options = {}) {
         fs,
         auditPath: gatewaySettings.getAuditPath()
     });
+    const taskCloseService = createTaskCloseService({
+        taskService,
+        sessionService,
+        translationService,
+        roundService
+    });
     const gatewayService = createGatewayService({
         fs,
         settings: gatewaySettings,
@@ -313,6 +322,7 @@ export function createDefaultServerDeps(options = {}) {
         channels: gatewayChannels,
         projectService,
         taskService,
+        taskCloseService,
         sessionService,
         taskLaunchService,
         translationService,
@@ -320,20 +330,6 @@ export function createDefaultServerDeps(options = {}) {
         runtime,
         appSettings
     });
-    const runtimeCoordinator = createRuntimeCoordinatorService({
-        appSettings,
-        taskService,
-        sessionService,
-        translationService,
-        harnessService,
-        harnessFeedbackService,
-        autoMemoryService,
-        roundService,
-        gatewayService,
-        async getStateRoot(repoRoot) {
-            return (await projectService.loadConfig(repoRoot)).stateRoot;
-        }
-    });
     const runtimeRecoveryService = createRuntimeRecoveryService({
         fs,
         runtime,
@@ -357,6 +353,28 @@ export function createDefaultServerDeps(options = {}) {
         jobGuard: createJobGuardService(),
         translationWorkerService
     });
+    const turnReconciler = createTurnReconcilerService({
+        sessionService,
+        roundService,
+        claudeHookService,
+        runtime
+    });
+    const runtimeCoordinator = createRuntimeCoordinatorService({
+        appSettings,
+        projectService,
+        taskService,
+        sessionService,
+        translationService,
+        harnessService,
+        harnessFeedbackService,
+        autoMemoryService,
+        roundService,
+        gatewayService,
+        turnReconciler,
+        async getStateRoot(repoRoot) {
+            return (await projectService.loadConfig(repoRoot)).stateRoot;
+        }
+    });
     const terminalInterruptService = createTerminalInterruptService({
         runtime,
         projectService,
@@ -374,6 +392,7 @@ export function createDefaultServerDeps(options = {}) {
         appSettings,
         projectService,
         taskService,
+        taskCloseService,
         sessionService,
         artifactService,
         harnessService,

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

@@ -1,6 +1,6 @@
 import { isGateReviewerRoleName, isHarnessEngineerToolRoleName, isTranslatorToolRoleName, isUserFacingRole, isVcmRoleName } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
-import { readLatestRoleTurnReply } from "./claude-transcript-reply.js";
+import { readLatestRoleTurnReply, readTranscriptTurnEvidence } from "./claude-transcript-reply.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
 const MAX_ROLE_RETRY_ATTEMPTS = 20;
@@ -11,7 +11,9 @@ const NON_RETRYABLE_STOP_FAILURE_ERRORS = new Set([
     "billing_error",
     "invalid_request",
     "model_not_found",
-    "max_output_tokens"
+    "max_output_tokens",
+    "terminal_session_exited",
+    "terminal_session_missing"
 ]);
 const DIAGNOSTIC_SNIPPET_MAX_LENGTH = 2000;
 export function createClaudeHookService(deps) {
@@ -220,6 +222,9 @@ export function createClaudeHookService(deps) {
             throwUnsupportedEvent(eventName);
         }
         const context = await getHookContext(input);
+        if (await isDuplicateCompletedStop(context, input)) {
+            return completedHookResult(input, eventName);
+        }
         const memoryResult = await processAutoMemoryRoleHook(input, context, eventName);
         if (memoryResult) {
             return memoryResult;
@@ -252,6 +257,31 @@ export function createClaudeHookService(deps) {
             settleGuard: true
         });
     }
+    async function isDuplicateCompletedStop(context, input) {
+        const session = await deps.sessionService.getRoleSession(context.project.repoRoot, context.taskSlug, input.role);
+        if (!session || session.activityStatus === "running" || !session.lastTurnEndedAt) {
+            return false;
+        }
+        const evidence = await readTranscriptTurnEvidence(session);
+        if (!evidence.completion) {
+            return false;
+        }
+        const completionAt = Date.parse(evidence.completion.timestamp);
+        const recordedEndAt = Date.parse(session.lastTurnEndedAt);
+        return Number.isFinite(completionAt)
+            && Number.isFinite(recordedEndAt)
+            && completionAt <= recordedEndAt + 1_000;
+    }
+    function completedHookResult(input, eventName) {
+        return {
+            ok: true,
+            eventName,
+            taskSlug: input.taskSlug,
+            role: input.role,
+            sessionUpdated: false,
+            dispatchedCount: 0
+        };
+    }
     async function processStopFailureHook(input) {
         const eventName = parseHookEvent(input.event.hook_event_name);
         if (eventName !== "StopFailure") {
@@ -699,6 +729,16 @@ export function createClaudeHookService(deps) {
             }
             return processStopHook(input, { allowBlock: true });
         },
+        handleReconciledTurnEnd(input) {
+            const eventName = parseHookEvent(input.event.hook_event_name);
+            if (eventName === "Stop") {
+                return processStopHook(input, { allowBlock: false });
+            }
+            if (eventName === "StopFailure") {
+                return processStopFailureHook(input);
+            }
+            throwUnsupportedEvent(eventName);
+        },
         handlePermissionRequestHook
     };
 }

package/dist/backend/services/claude-transcript-reply.js

@@ -1,9 +1,10 @@
-import { readFile } from "node:fs/promises";
+import { open, readFile } from "node:fs/promises";
 import { parseAssistantContent, resolveExistingClaudeTranscriptPath } from "./claude-transcript-service.js";
 /** Default maximum captured-reply length (characters). */
 export const MAX_TURN_REPLY_CHARS = 8_000;
 /** Tolerance applied when matching transcript events to the role's last-turn window. */
 const TURN_WINDOW_TOLERANCE_MS = 1_000;
+const TRANSCRIPT_EVIDENCE_TAIL_BYTES = 2 * 1024 * 1024;
 /**
  * Best-effort read of a role's latest user-facing turn reply.
  *
@@ -48,6 +49,80 @@ export async function readTranscriptTextEvents(transcriptPath) {
     }
     return events;
 }
+/** Read transcript activity and a completed assistant turn after this turn began. */
+export async function readTranscriptTurnEvidence(session) {
+    const transcriptPath = resolveExistingClaudeTranscriptPath(session);
+    if (!transcriptPath) {
+        return {};
+    }
+    let raw;
+    let modifiedAt;
+    let handle;
+    try {
+        handle = await open(transcriptPath, "r");
+        const metadata = await handle.stat();
+        modifiedAt = metadata.mtime.toISOString();
+        const readLength = Math.min(metadata.size, TRANSCRIPT_EVIDENCE_TAIL_BYTES);
+        const readOffset = Math.max(0, metadata.size - readLength);
+        const buffer = Buffer.alloc(readLength);
+        await handle.read(buffer, 0, readLength, readOffset);
+        raw = buffer.toString("utf8");
+        if (readOffset > 0) {
+            const firstNewline = raw.indexOf("\n");
+            raw = firstNewline >= 0 ? raw.slice(firstNewline + 1) : "";
+        }
+    }
+    catch {
+        return {};
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+    const turnStartedAtMs = timestampMs(session.lastTurnStartedAt);
+    let lastActivityAt;
+    let completion;
+    for (const line of raw.split("\n")) {
+        if (!line.trim()) {
+            continue;
+        }
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const timestamp = typeof record.timestamp === "string" ? record.timestamp : undefined;
+        if (timestamp && isLaterTimestamp(timestamp, lastActivityAt)) {
+            lastActivityAt = timestamp;
+        }
+        if (record.type !== "assistant" || !timestamp) {
+            continue;
+        }
+        const message = record.message;
+        if (message?.model === "<synthetic>" || message?.stop_reason !== "end_turn") {
+            continue;
+        }
+        const completionAtMs = timestampMs(timestamp);
+        if (completionAtMs === undefined
+            || (turnStartedAtMs !== undefined && completionAtMs < turnStartedAtMs - TURN_WINDOW_TOLERANCE_MS)) {
+            continue;
+        }
+        if (!completion || isLaterTimestamp(timestamp, completion.timestamp)) {
+            completion = {
+                id: typeof record.uuid === "string" ? record.uuid : null,
+                timestamp
+            };
+        }
+    }
+    if (isLaterTimestamp(modifiedAt, lastActivityAt)) {
+        lastActivityAt = modifiedAt;
+    }
+    return {
+        ...(lastActivityAt ? { lastActivityAt } : {}),
+        ...(completion ? { completion } : {})
+    };
+}
 /** True for a text event that completed a turn (assistant stopped of its own accord). */
 export function isFinalTurnTextEvent(event) {
     return event.stopReason === "end_turn";
@@ -105,3 +180,8 @@ function timestampMs(value) {
     const parsed = Date.parse(value);
     return Number.isFinite(parsed) ? parsed : undefined;
 }
+function isLaterTimestamp(candidate, current) {
+    const candidateMs = timestampMs(candidate);
+    const currentMs = timestampMs(current);
+    return candidateMs !== undefined && (currentMs === undefined || candidateMs > currentMs);
+}

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

@@ -37,7 +37,7 @@ const LEGACY_CODEX_HARNESS_PATHS = [
     ".ai/tools/request-codex-review"
 ];
 const VCM_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --max-time 2 -X POST "\${VCM_API_URL}/api/hooks/claude-code" -H "content-type: application/json" --data-binary @- >/dev/null || true'`;
-const VCM_STOP_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --max-time 5 -X POST "\${VCM_API_URL}/api/hooks/claude-code/stop" -H "content-type: application/json" --data-binary @- || true'`;
+const VCM_STOP_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --retry 2 --retry-delay 1 --retry-all-errors --connect-timeout 1 --max-time 2 -X POST "\${VCM_API_URL}/api/hooks/claude-code/stop" -H "content-type: application/json" --data-binary @- || true'`;
 const VCM_PERMISSION_REQUEST_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --max-time 5 -X POST "\${VCM_API_URL}/api/hooks/claude-code/permission-request" -H "content-type: application/json" --data-binary @- || true'`;
 const VCM_BASH_GUARD_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ]; then exit 0; fi; guard=""; repo="$(git rev-parse --show-toplevel 2>/dev/null || true)"; if [ -n "$repo" ] && [ -f "$repo/.ai/tools/vcm-bash-guard" ]; then guard="$repo/.ai/tools/vcm-bash-guard"; else cwd="$(pwd -P 2>/dev/null || pwd)"; dir="$cwd"; while [ -n "$dir" ] && [ "$dir" != "/" ]; do if [ -f "$dir/.ai/tools/vcm-bash-guard" ]; then guard="$dir/.ai/tools/vcm-bash-guard"; break; fi; dir="$(dirname "$dir")"; done; if [ -z "$guard" ] && [ -n "\${CLAUDE_PROJECT_DIR:-}" ] && [ -f "\${CLAUDE_PROJECT_DIR}/.ai/tools/vcm-bash-guard" ]; then guard="\${CLAUDE_PROJECT_DIR}/.ai/tools/vcm-bash-guard"; fi; fi; [ -n "$guard" ] || exit 0; python3 "$guard" || exit 0'`;
 const VCM_BASH_DEFAULT_TIMEOUT_MS = "600000";

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

@@ -1,6 +1,7 @@
 import { isVcmRoleName } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
+const RUNTIME_RECONCILE_INTERVAL_MS = 10_000;
 const EXPECTED_AUTO_RETROSPECTIVE_SKIP_CODES = new Set([
     "HARNESS_FEEDBACK_ACTIVE",
     "TASK_HARNESS_RETROSPECTIVE_EXISTS",
@@ -11,6 +12,9 @@ const EXPECTED_AUTO_RETROSPECTIVE_SKIP_CODES = new Set([
 ]);
 export function createRuntimeCoordinatorService(deps) {
     const locks = new Map();
+    const setTimer = deps.setInterval ?? ((callback, delayMs) => globalThis.setInterval(callback, delayMs));
+    const clearTimer = deps.clearInterval ?? ((timer) => globalThis.clearInterval(timer));
+    let reconcileTimer;
     async function withRepoLock(repoRoot, run) {
         const previous = locks.get(repoRoot) ?? Promise.resolve({
             activeTask: null,
@@ -31,6 +35,22 @@ export function createRuntimeCoordinatorService(deps) {
         }
     }
     return {
+        start() {
+            if (reconcileTimer !== undefined) {
+                return;
+            }
+            reconcileTimer = setTimer(() => {
+                void reconcileCurrentProject().catch(() => undefined);
+            }, RUNTIME_RECONCILE_INTERVAL_MS);
+            void reconcileCurrentProject().catch(() => undefined);
+        },
+        stop() {
+            if (reconcileTimer === undefined) {
+                return;
+            }
+            clearTimer(reconcileTimer);
+            reconcileTimer = undefined;
+        },
         reconcileProject(repoRoot, input = {}) {
             return withRepoLock(repoRoot, async () => {
                 const [activeTask, gatewayStatus] = await Promise.all([
@@ -42,6 +62,8 @@ export function createRuntimeCoordinatorService(deps) {
                     return { activeTask: null, gatewayStatus };
                 }
                 const taskRepoRoot = getTaskRuntimeRepoRoot(activeTask);
+                const stateRoot = await deps.getStateRoot(repoRoot);
+                await deps.turnReconciler.reconcileTask(repoRoot, activeTask, stateRoot);
                 const harnessInitialized = await deps.harnessService.getHarnessStatus(taskRepoRoot)
                     .then((status) => status.initialized)
                     .catch(() => false);
@@ -66,6 +88,19 @@ export function createRuntimeCoordinatorService(deps) {
             });
         }
     };
+    async function reconcileCurrentProject() {
+        const project = await deps.projectService.getCurrentProject();
+        if (!project) {
+            return;
+        }
+        await withRepoLock(project.repoRoot, async () => {
+            const activeTask = await resolveActiveTask(project.repoRoot);
+            if (activeTask) {
+                await deps.turnReconciler.reconcileTask(project.repoRoot, activeTask, await deps.getStateRoot(project.repoRoot));
+            }
+            return { activeTask, gatewayStatus: null };
+        });
+    }
     async function resolveActiveTask(repoRoot, requestedTaskSlug) {
         const tasks = await deps.taskService.listTasks(repoRoot);
         const activeTasks = tasks.filter((task) => task.cleanupStatus !== "cleaned");

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

@@ -22,6 +22,12 @@ export function createRuntimeRecoveryService(deps) {
             await runStep(context, "recover harness bootstrap", () => recoverHarnessBootstrap(repoRoot, recoveredAt, context));
             await runStep(context, "recover harness feedback", () => recoverHarnessFeedback(repoRoot, recoveredAt, context));
             const tasks = await deps.taskService.listTasks(repoRoot);
+            for (const task of tasks.filter((candidate) => candidate.cleanupStatus === "cleaned")) {
+                await runStep(context, `retry cleaned task ${task.taskSlug}`, async () => {
+                    const result = await deps.taskService.cleanupTask(repoRoot, task.taskSlug);
+                    context.warnings.push(...(result.warnings ?? []).map((warning) => `${task.taskSlug}: ${warning}`));
+                });
+            }
             for (const task of tasks.filter((candidate) => candidate.cleanupStatus !== "cleaned")) {
                 const taskRepoRoot = getTaskRuntimeRepoRoot(task);
                 await runStep(context, `recover task ${task.taskSlug}`, async () => {

package/dist/backend/services/task-close-service.js

@@ -0,0 +1,88 @@
+import { VCM_ROLE_NAMES } from "../../shared/constants.js";
+import { VcmError } from "../errors.js";
+import { getTaskRuntimeRepoRoot } from "./task-service.js";
+export function createTaskCloseService(deps) {
+    return {
+        async closeTask(repoRoot, taskSlug) {
+            const task = await deps.taskService.markTaskCleaned(repoRoot, taskSlug);
+            const warnings = [];
+            await stopTaskRoleSessions(repoRoot, taskSlug, warnings);
+            await moveOrStopProjectToolSession("Translator", () => deps.sessionService.moveProjectTranslatorSessionToSafeCwd(repoRoot), () => deps.sessionService.stopProjectTranslatorSession(repoRoot), warnings);
+            await moveOrStopProjectToolSession("Harness Engineer", () => deps.sessionService.moveProjectHarnessEngineerSessionToSafeCwd(repoRoot), () => deps.sessionService.stopProjectHarnessEngineerSession(repoRoot), warnings);
+            await bestEffort("Unable to stop task translation runtime", () => deps.translationService.stopTask(getTaskRuntimeRepoRoot(task), taskSlug, { clearCache: true }), warnings);
+            await bestEffort("Unable to clear task round runtime", () => deps.roundService.stopTask(taskSlug), warnings);
+            try {
+                const result = await deps.taskService.cleanupTask(repoRoot, taskSlug);
+                const combinedWarnings = [...warnings, ...(result.warnings ?? [])];
+                return {
+                    ...result,
+                    warnings: combinedWarnings.length > 0 ? combinedWarnings : undefined
+                };
+            }
+            catch (error) {
+                warnings.push(`Task was closed, but resource cleanup did not finish: ${describeError(error)}`);
+                return {
+                    taskSlug,
+                    taskClosed: true,
+                    worktreeRemoved: false,
+                    branchDeleted: false,
+                    stateRemoved: false,
+                    removedWorktreePath: null,
+                    removedStatePaths: [],
+                    deletedBranch: null,
+                    cleanedAt: task.cleanedAt ?? task.updatedAt,
+                    warnings
+                };
+            }
+        }
+    };
+    async function stopTaskRoleSessions(repoRoot, taskSlug, warnings) {
+        let sessions;
+        try {
+            sessions = await deps.sessionService.listRoleSessions(repoRoot, taskSlug);
+        }
+        catch (error) {
+            warnings.push(`Unable to list task role sessions during close: ${describeError(error)}`);
+            return;
+        }
+        for (const session of sessions) {
+            if (session.status !== "running" || !VCM_ROLE_NAMES.some((role) => role === session.role)) {
+                continue;
+            }
+            await bestEffort(`Unable to stop ${session.role} session`, () => deps.sessionService.stopRoleSession(repoRoot, taskSlug, session.role), warnings);
+        }
+    }
+}
+async function moveOrStopProjectToolSession(label, move, stop, warnings) {
+    try {
+        await move();
+    }
+    catch (error) {
+        if (isMissingSession(error)) {
+            return;
+        }
+        warnings.push(`Unable to move ${label} session to the base repository: ${describeError(error)}`);
+        try {
+            await stop();
+        }
+        catch (stopError) {
+            if (!isMissingSession(stopError)) {
+                warnings.push(`Unable to stop ${label} session after cwd migration failed: ${describeError(stopError)}`);
+            }
+        }
+    }
+}
+async function bestEffort(message, operation, warnings) {
+    try {
+        await operation();
+    }
+    catch (error) {
+        warnings.push(`${message}: ${describeError(error)}`);
+    }
+}
+function isMissingSession(error) {
+    return error instanceof VcmError && error.code === "SESSION_MISSING";
+}
+function describeError(error) {
+    return error instanceof Error ? error.message : String(error);
+}