vibe-coding-master 0.6.12 → 0.6.13

package/dist/backend/adapters/git-adapter.js

@@ -223,6 +223,35 @@ export function createGitAdapter(runner) {
                 hint: result.stderr
             });
         },
+        async isWorktreeRegistered(repoRoot, worktreePath) {
+            const result = await runGit(runner, repoRoot, ["worktree", "list", "--porcelain"]);
+            if (result.exitCode !== 0) {
+                throw new VcmError({
+                    code: "GIT_ERROR",
+                    message: "Unable to list Git worktrees.",
+                    statusCode: 400,
+                    hint: result.stderr
+                });
+            }
+            const expectedPath = await normalizeWorktreePath(worktreePath);
+            for (const candidate of parseWorktreePaths(result.stdout)) {
+                if (await normalizeWorktreePath(candidate) === expectedPath) {
+                    return true;
+                }
+            }
+            return false;
+        },
+        async pruneWorktrees(repoRoot) {
+            const result = await runGit(runner, repoRoot, ["worktree", "prune"]);
+            if (result.exitCode !== 0) {
+                throw new VcmError({
+                    code: "GIT_WORKTREE_PRUNE_FAILED",
+                    message: "Unable to prune Git worktree metadata.",
+                    statusCode: 400,
+                    hint: result.stderr
+                });
+            }
+        },
         async mergeBranchFastForward(repoRoot, branch) {
             const result = await runGit(runner, repoRoot, ["merge", "--ff-only", branch]);
             if (result.exitCode !== 0) {
@@ -387,6 +416,21 @@ async function pathExists(targetPath) {
 async function runGit(runner, repoRoot, args) {
     return runner.run("git", [...await buildSafeDirectoryArgs(repoRoot), ...args], { cwd: repoRoot });
 }
+function parseWorktreePaths(output) {
+    return output
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith("worktree "))
+        .map((line) => line.slice("worktree ".length).trim())
+        .filter(Boolean);
+}
+async function normalizeWorktreePath(worktreePath) {
+    try {
+        return path.resolve(await fs.realpath(worktreePath));
+    }
+    catch {
+        return path.resolve(worktreePath);
+    }
+}
 async function buildSafeDirectoryArgs(repoRoot) {
     const safeDirs = new Set([repoRoot]);
     try {

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

@@ -627,12 +627,16 @@ export function createGatewayService(deps) {
             },
             updatedAt: now()
         });
-        return [
+        const lines = [
             `Closed task: ${result.taskSlug}`,
             result.removedWorktreePath ? `removed worktree: ${result.removedWorktreePath}` : "removed worktree: none",
             result.deletedBranch ? `deleted branch: ${result.deletedBranch}` : "deleted branch: none",
             `removed state paths: ${result.removedStatePaths.length}`
-        ].join("\n");
+        ];
+        if (result.warnings?.length) {
+            lines.push("warnings:", ...result.warnings.map((warning) => `- ${warning}`));
+        }
+        return lines.join("\n");
     }
     async function stopRunningRoleSessions(repoRoot, taskSlug) {
         const sessions = await deps.sessionService.listRoleSessions(repoRoot, taskSlug);

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

@@ -26,6 +26,7 @@ const SESSION_READY_QUIESCENT_POLLS = 3;
 const SESSION_READY_MAX_POLLS = 60;
 export function createSessionService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
+    const isProcessAlive = deps.isProcessAlive ?? defaultIsProcessAlive;
     async function readCurrentHarnessRevision(repoRoot) {
         return (await readHarnessRevisionState(deps.fs, repoRoot)).revision;
     }
@@ -221,7 +222,13 @@ export function createSessionService(deps) {
                 await clearPersistedTranslatorSession(deps.fs, repoRoot);
                 return launchProjectTranslatorSession(repoRoot, input, "fresh");
             }
-            return withHarnessRevisionView(repoRoot, await migrateRunningProjectToolSessionCwd(repoRoot, record, taskContext.taskRepoRoot, { alreadyReady: true }));
+            const migrated = await migrateRunningProjectToolSessionCwd(repoRoot, record, taskContext.taskRepoRoot, { alreadyReady: true });
+            if (migrated.status !== "running") {
+                deps.registry.remove(record.id);
+                await clearPersistedTranslatorSession(deps.fs, repoRoot);
+                return launchProjectTranslatorSession(repoRoot, input, "fresh");
+            }
+            return withHarnessRevisionView(repoRoot, migrated);
         }
         return withHarnessRevisionView(repoRoot, await migrateRunningProjectToolSessionCwd(repoRoot, record, taskContext.taskRepoRoot));
     }
@@ -319,7 +326,13 @@ export function createSessionService(deps) {
                 await clearPersistedHarnessEngineerSession(deps.fs, repoRoot);
                 return launchProjectHarnessEngineerSession(repoRoot, input, "fresh");
             }
-            return withHarnessRevisionView(repoRoot, await migrateRunningProjectToolSessionCwd(repoRoot, record, taskContext.taskRepoRoot, { alreadyReady: true }));
+            const migrated = await migrateRunningProjectToolSessionCwd(repoRoot, record, taskContext.taskRepoRoot, { alreadyReady: true });
+            if (migrated.status !== "running") {
+                deps.registry.remove(record.id);
+                await clearPersistedHarnessEngineerSession(deps.fs, repoRoot);
+                return launchProjectHarnessEngineerSession(repoRoot, input, "fresh");
+            }
+            return withHarnessRevisionView(repoRoot, migrated);
         }
         return withHarnessRevisionView(repoRoot, await migrateRunningProjectToolSessionCwd(repoRoot, record, taskContext.taskRepoRoot));
     }
@@ -354,7 +367,7 @@ export function createSessionService(deps) {
         let quietPolls = 0;
         for (let poll = 0; poll < SESSION_READY_MAX_POLLS; poll += 1) {
             const live = deps.runtime.getSession(sessionId);
-            if (!live || isExitedStatus(live.status)) {
+            if (!isRuntimeSessionAlive(live)) {
                 return "exited";
             }
             if (live.lastOutputAt) {
@@ -379,21 +392,29 @@ export function createSessionService(deps) {
             && session.role !== HARNESS_ENGINEER_ROLE) {
             return session;
         }
-        if (samePath(session.cwd, targetCwd)) {
-            return session;
-        }
         const runtimeSession = deps.runtime.getSession(session.id);
-        if (!runtimeSession || runtimeSession.status !== "running") {
+        if (!isRuntimeSessionAlive(runtimeSession)) {
+            return markProjectToolRuntimeUnavailable(repoRoot, session);
+        }
+        if (samePath(session.cwd, targetCwd)) {
             return session;
         }
         if (!options.alreadyReady && (await waitForSessionInputReady(session.id)) === "exited") {
-            return session;
+            return markProjectToolRuntimeUnavailable(repoRoot, session);
         }
         assertSafeCwdTarget(targetCwd);
         const timestamp = now();
-        await submitTerminalInput(deps.runtime, session.id, formatClaudeCdCommand(targetCwd), {
-            enterDelayMs: PROJECT_TOOL_CD_ENTER_DELAY_MS
-        });
+        try {
+            await submitTerminalInput(deps.runtime, session.id, formatClaudeCdCommand(targetCwd), {
+                enterDelayMs: PROJECT_TOOL_CD_ENTER_DELAY_MS
+            });
+        }
+        catch (error) {
+            if (isSessionMissingError(error) || !isRuntimeSessionAlive(deps.runtime.getSession(session.id))) {
+                return markProjectToolRuntimeUnavailable(repoRoot, session);
+            }
+            throw error;
+        }
         // `cwd` tracks the logical `/cd` target only. The transcript stays anchored at
         // the first-launch cwd (repoRoot for project tools), so transcriptPath must
         // not be recomputed from targetCwd here.
@@ -407,6 +428,19 @@ export function createSessionService(deps) {
         await persistProjectScopedToolSession(repoRoot, updated);
         return updated;
     }
+    async function markProjectToolRuntimeUnavailable(repoRoot, session) {
+        const updated = {
+            ...session,
+            status: getRecoverableStatus(session),
+            activityStatus: "idle",
+            pid: undefined,
+            exitCode: session.exitCode ?? null,
+            updatedAt: now()
+        };
+        deps.registry.remove(session.id);
+        await persistProjectScopedToolSession(repoRoot, updated);
+        return updated;
+    }
     async function resumeProjectToolSessionAtCwd(repoRoot, session, targetCwd) {
         const live = toRoleSessionRecordView(session.role === TRANSLATOR_ROLE
             ? getRegisteredProjectTranslatorSession(deps.registry, deps.runtime)
@@ -443,6 +477,24 @@ export function createSessionService(deps) {
                 VCM_SESSION_ID: session.claudeSessionId
             }
         });
+        if ((await waitForSessionInputReady(runtimeSession.id)) === "exited") {
+            deps.registry.remove(runtimeSession.id);
+            return markProjectToolRuntimeUnavailable(repoRoot, {
+                ...session,
+                id: runtimeSession.id,
+                status: "crashed",
+                activityStatus: "idle",
+                command: startCommand.display,
+                permissionMode,
+                model,
+                effort,
+                pid: runtimeSession.pid,
+                startedAt: runtimeSession.startedAt,
+                updatedAt: now(),
+                lastOutputAt: runtimeSession.lastOutputAt,
+                exitCode: runtimeSession.exitCode ?? 1
+            });
+        }
         const timestamp = now();
         const resumed = {
             ...session,
@@ -466,6 +518,12 @@ export function createSessionService(deps) {
         await persistProjectScopedToolSession(repoRoot, resumed);
         return migrateRunningProjectToolSessionCwd(repoRoot, resumed, targetCwd);
     }
+    function isRuntimeSessionAlive(session) {
+        if (!session || isExitedStatus(session.status) || session.pid === undefined) {
+            return false;
+        }
+        return isProcessAlive(session.pid);
+    }
     async function persistProjectScopedToolSession(repoRoot, session) {
         if (session.role === TRANSLATOR_ROLE) {
             await persistTranslatorSession(deps.fs, repoRoot, session);
@@ -1116,6 +1174,33 @@ function getRecoverableStatus(record) {
     }
     return "resumable";
 }
+function isSessionMissingError(error) {
+    if (error instanceof VcmError && error.code === "SESSION_MISSING") {
+        return true;
+    }
+    return typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "SESSION_MISSING";
+}
+function withoutRuntimeOnlySessionFields(session) {
+    const { pid: _pid, ...persisted } = session;
+    return persisted;
+}
+function defaultIsProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return getErrorCode(error) === "EPERM";
+    }
+}
+function getErrorCode(error) {
+    return typeof error === "object" && error !== null && "code" in error
+        ? String(error.code)
+        : undefined;
+}
 function samePath(left, right) {
     return path.resolve(left) === path.resolve(right);
 }
@@ -1290,7 +1375,7 @@ async function persistTaskSession(fs, repoRoot, stateRoot, session) {
                 claudeSessionId: session.claudeSessionId,
                 transcriptPath: session.transcriptPath,
                 status: session.status,
-                record
+                record: withoutRuntimeOnlySessionFields(record)
             }
         }
     });
@@ -1332,7 +1417,7 @@ async function persistTranslatorSession(fs, repoRoot, session) {
         role: session.role,
         updatedAt: session.updatedAt,
         record: {
-            ...session,
+            ...withoutRuntimeOnlySessionFields(session),
             taskSlug: PROJECT_TRANSLATOR_SCOPE
         }
     });
@@ -1349,7 +1434,7 @@ async function persistHarnessEngineerSession(fs, repoRoot, session) {
         role: session.role,
         updatedAt: session.updatedAt,
         record: {
-            ...session,
+            ...withoutRuntimeOnlySessionFields(session),
             taskSlug: PROJECT_HARNESS_ENGINEER_SCOPE
         }
     });

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

@@ -130,26 +130,91 @@ export function createTaskService(deps) {
             const config = await deps.projectService.loadConfig(repoRoot);
             const task = await this.loadTask(repoRoot, taskSlug);
             const taskRepoRoot = getTaskRuntimeRepoRoot(task);
-            const statePaths = getTaskStatePaths(deps.projectService.getProjectDataRoot(repoRoot), taskRepoRoot, config.stateRoot, config.handoffRoot, taskSlug);
+            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 deps.git.removeWorktree(repoRoot, task.worktreePath, { force: options.force ?? true });
-            await deps.git.deleteBranch(repoRoot, task.branch, { force: options.forceDeleteBranch ?? true });
-            for (const statePath of statePaths) {
-                await deps.fs.removePath(statePath, { recursive: true, force: true });
-                removedStatePaths.push(statePath);
+            await removeTaskWorktreeIdempotent(deps.fs, deps.git, repoRoot, task.worktreePath, options.force ?? true, warnings);
+            await deleteTaskBranchIdempotent(deps.git, repoRoot, task.branch, options.forceDeleteBranch ?? true);
+            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);
             return {
                 taskSlug,
                 removedWorktreePath: task.worktreePath,
                 removedStatePaths,
                 deletedBranch: task.branch,
-                cleanedAt
+                cleanedAt,
+                warnings: warnings.length > 0 ? warnings : undefined
             };
         }
     };
 }
+async function removeTaskWorktreeIdempotent(fs, git, repoRoot, worktreePath, force, warnings) {
+    const wasRegistered = await git.isWorktreeRegistered(repoRoot, worktreePath);
+    if (wasRegistered) {
+        try {
+            await git.removeWorktree(repoRoot, worktreePath, { force });
+        }
+        catch (error) {
+            await pruneWorktreesBestEffort(git, repoRoot, warnings);
+            if (await git.isWorktreeRegistered(repoRoot, worktreePath)) {
+                throw error;
+            }
+            warnings.push(`Git worktree metadata was already cleared for ${worktreePath}; continuing cleanup.`);
+        }
+    }
+    else {
+        await pruneWorktreesBestEffort(git, repoRoot, warnings);
+    }
+    if (await fs.pathExists(worktreePath)) {
+        try {
+            await fs.removePath?.(worktreePath, { recursive: true, force: true });
+        }
+        catch (error) {
+            warnings.push(`Unable to remove stale task worktree directory ${worktreePath}: ${describeError(error)}`);
+        }
+    }
+}
+async function deleteTaskBranchIdempotent(git, repoRoot, branch, force) {
+    if (!(await git.branchExists(repoRoot, branch))) {
+        return;
+    }
+    try {
+        await git.deleteBranch(repoRoot, branch, { force });
+    }
+    catch (error) {
+        if (!(await git.branchExists(repoRoot, branch))) {
+            return;
+        }
+        throw error;
+    }
+}
+async function pruneWorktreesBestEffort(git, repoRoot, warnings) {
+    try {
+        await git.pruneWorktrees(repoRoot);
+    }
+    catch (error) {
+        warnings.push(`Unable to prune Git worktree metadata: ${describeError(error)}`);
+    }
+}
+async function removeWorktreeStatePathBestEffort(fs, statePath, removedStatePaths, warnings) {
+    try {
+        await fs.removePath?.(statePath, { recursive: true, force: true });
+        removedStatePaths.push(statePath);
+    }
+    catch (error) {
+        warnings.push(`Unable to remove stale task state path ${statePath}: ${describeError(error)}`);
+    }
+}
+function describeError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 async function readStoredTasks(fs, taskStoreRoot) {
     const tasksDir = path.join(taskStoreRoot, "tasks");
     if (!(await fs.pathExists(tasksDir))) {