vibe-coding-master 0.6.23 → 0.7.0

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

@@ -118,61 +118,130 @@ export function createTaskService(deps) {
             await this.saveTask(repoRoot, updated);
             return updated;
         },
-        async cleanupTask(repoRoot, taskSlug, options = {}) {
-            assertValidTaskSlug(taskSlug);
-            if (!deps.fs.removePath) {
-                throw new VcmError({
-                    code: "FILESYSTEM_REMOVE_UNAVAILABLE",
-                    message: "This VCM runtime cannot remove task files.",
-                    statusCode: 500
-                });
-            }
-            const config = await deps.projectService.loadConfig(repoRoot);
+        async markTaskCleaned(repoRoot, taskSlug) {
             const task = await this.loadTask(repoRoot, taskSlug);
+            if (task.cleanupStatus === "cleaned" && task.cleanedAt) {
+                return task;
+            }
+            const timestamp = now();
+            const updated = {
+                ...task,
+                status: "stopped",
+                cleanupStatus: "cleaned",
+                cleanedAt: timestamp,
+                updatedAt: timestamp
+            };
+            await this.saveTask(repoRoot, updated);
+            return updated;
+        },
+        async cleanupTask(repoRoot, taskSlug) {
+            assertValidTaskSlug(taskSlug);
+            const task = await this.markTaskCleaned(repoRoot, taskSlug);
             const taskRepoRoot = getTaskRuntimeRepoRoot(task);
             const taskStoreRoot = deps.projectService.getProjectDataRoot(repoRoot);
             const taskPath = getTaskPath(taskStoreRoot, taskSlug);
-            const statePaths = getTaskStatePaths(taskStoreRoot, taskRepoRoot, config.stateRoot, config.handoffRoot, taskSlug);
-            const removedStatePaths = [];
             const warnings = [];
-            const cleanedAt = now();
-            assertTaskWorktreePath(repoRoot, task.worktreePath);
-            await removeTaskWorktreeIdempotent(deps.fs, deps.git, repoRoot, task.worktreePath, options.force ?? true, warnings);
-            await deleteTaskBranchIdempotent(deps.git, repoRoot, task.branch, options.forceDeleteBranch ?? true);
+            if (!deps.fs.removePath) {
+                warnings.push("This VCM runtime cannot remove task files; the task remains logically closed.");
+            }
+            let stateRoot = ".ai/vcm";
+            let handoffRoot = task.handoffDir;
+            try {
+                const config = await deps.projectService.loadConfig(repoRoot);
+                stateRoot = config.stateRoot;
+                handoffRoot = config.handoffRoot;
+            }
+            catch (error) {
+                warnings.push(`Unable to load project cleanup paths; using task defaults: ${describeError(error)}`);
+            }
+            const statePaths = getTaskStatePaths(taskStoreRoot, taskRepoRoot, stateRoot, handoffRoot, taskSlug);
+            const removedStatePaths = [];
+            let worktreeRemoved = false;
+            try {
+                assertTaskWorktreePath(repoRoot, task.worktreePath);
+                worktreeRemoved = await removeTaskWorktreeBestEffort(deps.fs, deps.git, repoRoot, task.worktreePath, warnings);
+            }
+            catch (error) {
+                warnings.push(`Skipped unsafe task worktree path ${task.worktreePath}: ${describeError(error)}`);
+            }
+            const branchCleanup = await deleteTaskBranchBestEffort(deps.git, repoRoot, task.branch, warnings);
             for (const statePath of statePaths.filter((candidate) => candidate !== taskPath)) {
                 await removeWorktreeStatePathBestEffort(deps.fs, statePath, removedStatePaths, warnings);
             }
-            await deps.fs.removePath(taskPath, { recursive: true, force: true });
-            removedStatePaths.push(taskPath);
+            let stateRemoved = false;
+            if (worktreeRemoved && branchCleanup.resolved) {
+                try {
+                    await deps.fs.removePath?.(taskPath, { recursive: true, force: true });
+                    stateRemoved = !(await deps.fs.pathExists(taskPath));
+                    if (stateRemoved) {
+                        removedStatePaths.push(taskPath);
+                    }
+                    else {
+                        warnings.push(`Task state remained after cleanup: ${taskPath}`);
+                    }
+                }
+                catch (error) {
+                    warnings.push(`Unable to remove cleaned task state ${taskPath}: ${describeError(error)}`);
+                }
+            }
+            else {
+                warnings.push("Retained cleaned task state so unresolved resource cleanup can be retried later.");
+            }
             return {
                 taskSlug,
-                removedWorktreePath: task.worktreePath,
+                taskClosed: true,
+                worktreeRemoved,
+                branchDeleted: branchCleanup.resolved,
+                stateRemoved,
+                removedWorktreePath: worktreeRemoved ? task.worktreePath : null,
                 removedStatePaths,
-                deletedBranch: task.branch,
-                cleanedAt,
+                deletedBranch: branchCleanup.deleted ? task.branch : null,
+                cleanedAt: task.cleanedAt ?? now(),
                 warnings: warnings.length > 0 ? warnings : undefined
             };
         }
     };
 }
-async function removeTaskWorktreeIdempotent(fs, git, repoRoot, worktreePath, force, warnings) {
-    const wasRegistered = await git.isWorktreeRegistered(repoRoot, worktreePath);
-    if (wasRegistered) {
+async function removeTaskWorktreeBestEffort(fs, git, repoRoot, worktreePath, warnings) {
+    let wasRegistered;
+    try {
+        wasRegistered = await git.isWorktreeRegistered(repoRoot, worktreePath);
+    }
+    catch (error) {
+        warnings.push(`Unable to inspect task worktree registration for ${worktreePath}: ${describeError(error)}`);
+    }
+    if (wasRegistered !== false) {
         try {
-            await git.removeWorktree(repoRoot, worktreePath, { force });
+            await git.removeWorktree(repoRoot, worktreePath, { force: true });
         }
         catch (error) {
             await pruneWorktreesBestEffort(git, repoRoot, warnings);
-            if (await git.isWorktreeRegistered(repoRoot, worktreePath)) {
-                throw error;
+            let stillRegistered = true;
+            try {
+                stillRegistered = await git.isWorktreeRegistered(repoRoot, worktreePath);
+            }
+            catch (inspectionError) {
+                warnings.push(`Unable to verify task worktree registration after forced removal: ${describeError(inspectionError)}`);
+            }
+            if (stillRegistered) {
+                warnings.push(`Unable to force-remove Git worktree ${worktreePath}: ${describeError(error)}`);
+            }
+            else {
+                warnings.push(`Git worktree metadata was already cleared for ${worktreePath}; continuing cleanup.`);
             }
-            warnings.push(`Git worktree metadata was already cleared for ${worktreePath}; continuing cleanup.`);
         }
     }
     else {
         await pruneWorktreesBestEffort(git, repoRoot, warnings);
     }
-    if (await fs.pathExists(worktreePath)) {
+    let staleDirectoryExists = true;
+    try {
+        staleDirectoryExists = await fs.pathExists(worktreePath);
+    }
+    catch (error) {
+        warnings.push(`Unable to inspect stale task worktree directory ${worktreePath}: ${describeError(error)}`);
+    }
+    if (staleDirectoryExists) {
         try {
             await fs.removePath?.(worktreePath, { recursive: true, force: true });
         }
@@ -180,19 +249,67 @@ async function removeTaskWorktreeIdempotent(fs, git, repoRoot, worktreePath, for
             warnings.push(`Unable to remove stale task worktree directory ${worktreePath}: ${describeError(error)}`);
         }
     }
+    let pathExists = true;
+    let registered = true;
+    try {
+        pathExists = await fs.pathExists(worktreePath);
+    }
+    catch (error) {
+        warnings.push(`Unable to verify task worktree directory cleanup: ${describeError(error)}`);
+    }
+    try {
+        registered = await git.isWorktreeRegistered(repoRoot, worktreePath);
+    }
+    catch (error) {
+        warnings.push(`Unable to verify task worktree metadata cleanup: ${describeError(error)}`);
+    }
+    return !pathExists && !registered;
 }
-async function deleteTaskBranchIdempotent(git, repoRoot, branch, force) {
-    if (!(await git.branchExists(repoRoot, branch))) {
-        return;
+async function deleteTaskBranchBestEffort(git, repoRoot, branch, warnings) {
+    let branchExists;
+    try {
+        branchExists = await git.branchExists(repoRoot, branch);
+    }
+    catch (error) {
+        warnings.push(`Unable to inspect task branch ${branch}: ${describeError(error)}`);
     }
+    if (branchExists === false) {
+        return { resolved: true, deleted: false };
+    }
+    await warnAboutDiscardedCommits(git, repoRoot, branch, warnings);
     try {
-        await git.deleteBranch(repoRoot, branch, { force });
+        await git.deleteBranch(repoRoot, branch, { force: true });
+        return { resolved: true, deleted: true };
     }
     catch (error) {
-        if (!(await git.branchExists(repoRoot, branch))) {
+        try {
+            if (!(await git.branchExists(repoRoot, branch))) {
+                return { resolved: true, deleted: true };
+            }
+        }
+        catch (inspectionError) {
+            warnings.push(`Unable to verify task branch cleanup for ${branch}: ${describeError(inspectionError)}`);
+        }
+        warnings.push(`Unable to force-delete task branch ${branch}: ${describeError(error)}`);
+        return { resolved: false, deleted: false };
+    }
+}
+async function warnAboutDiscardedCommits(git, repoRoot, branch, warnings) {
+    try {
+        const baseBranch = await git.getCurrentBranch(repoRoot);
+        const commits = await git.getCommitList(repoRoot, `${baseBranch}..${branch}`);
+        if (commits.length === 0) {
             return;
         }
-        throw error;
+        const summary = commits
+            .slice(0, 5)
+            .map((commit) => `${commit.sha.slice(0, 8)} ${commit.subject}`)
+            .join("; ");
+        const remainder = commits.length > 5 ? `; and ${commits.length - 5} more` : "";
+        warnings.push(`${branch} has ${commits.length} commit(s) not contained in ${baseBranch}; close force-deletes the branch: ${summary}${remainder}`);
+    }
+    catch (error) {
+        warnings.push(`Unable to inspect commits before force-deleting ${branch}: ${describeError(error)}`);
     }
 }
 async function pruneWorktreesBestEffort(git, repoRoot, warnings) {

package/dist/backend/services/turn-reconciler-service.js

@@ -0,0 +1,122 @@
+import { readTranscriptTurnEvidence } from "./claude-transcript-reply.js";
+import { getTaskRuntimeRepoRoot } from "./task-service.js";
+export const TURN_STALL_THRESHOLD_MS = 30 * 60_000;
+export const TURN_INTERRUPT_GRACE_MS = 10_000;
+export function createTurnReconcilerService(deps) {
+    const now = deps.now ?? (() => new Date().toISOString());
+    const stallThresholdMs = deps.stallThresholdMs ?? TURN_STALL_THRESHOLD_MS;
+    const interruptGraceMs = deps.interruptGraceMs ?? TURN_INTERRUPT_GRACE_MS;
+    const readEvidence = deps.readTranscriptEvidence ?? readTranscriptTurnEvidence;
+    const pendingInterrupts = new Map();
+    return {
+        async reconcileTask(repoRoot, task, stateRoot) {
+            const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+            const round = await deps.roundService.getSessionRoundState({
+                repoRoot,
+                stateRepoRoot: taskRepoRoot,
+                stateRoot,
+                taskSlug: task.taskSlug
+            });
+            if (round.status !== "running"
+                || !round.activeRole
+                || !round.activeTurnStartedAt
+                || round.roleRecovery) {
+                clearTaskInterrupts(repoRoot, task.taskSlug);
+                return { status: "inactive" };
+            }
+            const role = round.activeRole;
+            const interruptKey = `${repoRoot}:${task.taskSlug}:${role}`;
+            const session = await deps.sessionService.getRoleSession(repoRoot, task.taskSlug, role);
+            const evidence = session
+                ? await readEvidence({ ...session, lastTurnStartedAt: round.activeTurnStartedAt })
+                : {};
+            if (evidence.completion) {
+                pendingInterrupts.delete(interruptKey);
+                await deps.claudeHookService.handleReconciledTurnEnd(buildReconciledHook(task.taskSlug, role, session, "Stop", {
+                    vcm_reconcile_reason: "transcript-end-turn",
+                    vcm_completion_id: evidence.completion.id,
+                    vcm_completion_at: evidence.completion.timestamp
+                }));
+                return { status: "completed", role, reason: "transcript-end-turn" };
+            }
+            if (!session || session.status !== "running") {
+                pendingInterrupts.delete(interruptKey);
+                const reason = session ? "terminal-session-exited" : "terminal-session-missing";
+                await deps.claudeHookService.handleReconciledTurnEnd(buildReconciledHook(task.taskSlug, role, session, "StopFailure", {
+                    error: reason.replaceAll("-", "_"),
+                    error_details: `VCM reconciled an active turn because its ${reason.replaceAll("-", " ")}.`
+                }));
+                return { status: "failed", role, reason };
+            }
+            const lastActivityAt = latestTimestamp([
+                round.activeTurnStartedAt,
+                session.lastHookEventAt,
+                session.lastOutputAt,
+                evidence.lastActivityAt
+            ]);
+            const currentTime = now();
+            if (!isStale(lastActivityAt, currentTime, stallThresholdMs)) {
+                pendingInterrupts.delete(interruptKey);
+                return { status: "active" };
+            }
+            const pendingInterrupt = pendingInterrupts.get(interruptKey);
+            if (!pendingInterrupt || pendingInterrupt.turnStartedAt !== round.activeTurnStartedAt) {
+                deps.runtime.write(session.id, "\u0003");
+                pendingInterrupts.set(interruptKey, {
+                    turnStartedAt: round.activeTurnStartedAt,
+                    requestedAt: currentTime
+                });
+                return { status: "active" };
+            }
+            if (!isStale(pendingInterrupt.requestedAt, currentTime, interruptGraceMs)) {
+                return { status: "active" };
+            }
+            pendingInterrupts.delete(interruptKey);
+            await deps.claudeHookService.handleReconciledTurnEnd(buildReconciledHook(task.taskSlug, role, session, "StopFailure", {
+                error: "turn_stalled",
+                error_details: `No hook, terminal output, or transcript activity was observed for ${stallThresholdMs}ms.`
+            }));
+            return { status: "failed", role, reason: "turn-stalled" };
+        }
+    };
+    function clearTaskInterrupts(repoRoot, taskSlug) {
+        for (const key of pendingInterrupts.keys()) {
+            if (key.startsWith(`${repoRoot}:${taskSlug}:`)) {
+                pendingInterrupts.delete(key);
+            }
+        }
+    }
+}
+function buildReconciledHook(taskSlug, role, session, eventName, evidence) {
+    return {
+        taskSlug,
+        role,
+        event: {
+            hook_event_name: eventName,
+            ...(session?.claudeSessionId ? { session_id: session.claudeSessionId } : {}),
+            ...(session?.transcriptPath ? { transcript_path: session.transcriptPath } : {}),
+            ...(session?.cwd ? { cwd: session.cwd } : {}),
+            vcm_reconciled: true,
+            ...evidence
+        }
+    };
+}
+function latestTimestamp(values) {
+    return values.reduce((latest, value) => {
+        if (!value) {
+            return latest;
+        }
+        const valueMs = Date.parse(value);
+        const latestMs = latest ? Date.parse(latest) : Number.NaN;
+        return Number.isFinite(valueMs) && (!Number.isFinite(latestMs) || valueMs > latestMs)
+            ? value
+            : latest;
+    }, undefined);
+}
+function isStale(lastActivityAt, currentTime, thresholdMs) {
+    const activityMs = lastActivityAt ? Date.parse(lastActivityAt) : Number.NaN;
+    const currentMs = Date.parse(currentTime);
+    return Number.isFinite(activityMs)
+        && Number.isFinite(currentMs)
+        && currentMs - activityMs >= thresholdMs;
+}