vibe-coding-master 0.7.47 → 0.7.49

package/README.md

@@ -221,8 +221,15 @@ Controls:
 - `Start`: start a new Claude Code role session
 - `Resume`: resume a saved Claude Code session
 - `Restart`: stop current process and start fresh
+- `Restart With Context`: restart a VCM workflow role and continue from its current task artifacts
 - `Stop`: stop the embedded terminal process
 
+`Restart With Context` is available only for Project Manager, Architect, Coder,
+Tester, and Reviewer. It reuses their existing handoffs, workflow state, Gate
+requests, worktree, and Git state; it does not create a separate context file.
+Translator and Harness Engineer are tool Agents and do not use this workflow-role
+recovery path.
+
 Permission modes:
 
 ```text

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

@@ -1,4 +1,4 @@
-import { isDispatchableRole, isRoleName } from "../../shared/constants.js";
+import { isDispatchableRole, isRoleName, isVcmRoleName } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 export function registerSessionRoutes(app, deps) {
     app.get("/api/tasks/:taskSlug/sessions", async (request) => {
@@ -8,6 +8,9 @@ export function registerSessionRoutes(app, deps) {
     app.post("/api/tasks/:taskSlug/sessions/:role/start", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const role = parseRole(request.params.role);
+        if (isVcmRoleName(role)) {
+            await deps.roleContextRestartService.clearRole(project.repoRoot, request.params.taskSlug, role);
+        }
         return deps.sessionService.startRoleSession(project.repoRoot, request.params.taskSlug, role, request.body);
     });
     app.post("/api/tasks/:taskSlug/sessions/architect/restart-after-planning", async (request, reply) => {
@@ -18,14 +21,38 @@ export function registerSessionRoutes(app, deps) {
     app.post("/api/tasks/:taskSlug/sessions/:role/stop", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const role = parseRole(request.params.role);
+        if (isVcmRoleName(role)) {
+            await deps.roleContextRestartService.clearRole(project.repoRoot, request.params.taskSlug, role);
+        }
         const session = await deps.sessionService.stopRoleSession(project.repoRoot, request.params.taskSlug, role);
         await deps.translationService.stopSession(session.id);
         deps.roundService.stopSession(session.id);
         return session;
     });
+    app.post("/api/tasks/:taskSlug/sessions/:role/restart-with-context", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const role = parseVcmRole(request.params.role);
+        if (role === "architect" && deps.architectRestartService.getState(project.repoRoot, request.params.taskSlug)) {
+            throw new VcmError({
+                code: "ARCHITECT_RESTART_CONFLICT",
+                message: "Architect already has a pending post-planning restart.",
+                statusCode: 409
+            });
+        }
+        const existing = await deps.sessionService.getRoleSession(project.repoRoot, request.params.taskSlug, role);
+        await deps.sessionService.assertModelLaunchReady(request.body?.model ?? existing?.model);
+        if (existing) {
+            await deps.translationService.stopSession(existing.id, { clearCache: true });
+            deps.roundService.stopSession(existing.id);
+        }
+        return deps.roleContextRestartService.restart(project.repoRoot, request.params.taskSlug, role, request.body);
+    });
     app.post("/api/tasks/:taskSlug/sessions/:role/restart", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const role = parseRole(request.params.role);
+        if (isVcmRoleName(role)) {
+            await deps.roleContextRestartService.clearRole(project.repoRoot, request.params.taskSlug, role);
+        }
         const existing = await deps.sessionService.getRoleSession(project.repoRoot, request.params.taskSlug, role);
         await deps.sessionService.assertModelLaunchReady(request.body?.model ?? existing?.model);
         if (existing) {
@@ -37,6 +64,9 @@ export function registerSessionRoutes(app, deps) {
     app.post("/api/tasks/:taskSlug/sessions/:role/resume", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const role = parseRole(request.params.role);
+        if (isVcmRoleName(role)) {
+            await deps.roleContextRestartService.clearRole(project.repoRoot, request.params.taskSlug, role);
+        }
         return deps.sessionService.resumeRoleSession(project.repoRoot, request.params.taskSlug, role, request.body);
     });
     app.post("/api/tasks/:taskSlug/sessions/:role/notify-harness", async (request) => {
@@ -70,6 +100,16 @@ function parseRole(role) {
     }
     return role;
 }
+function parseVcmRole(role) {
+    if (!isVcmRoleName(role)) {
+        throw new VcmError({
+            code: "ROLE_CONTEXT_RESTART_UNSUPPORTED",
+            message: `Restart With Context is available only for VCM workflow roles: ${role}`,
+            statusCode: 400
+        });
+    }
+    return role;
+}
 async function requireCurrentProject(projectService) {
     const project = await projectService.getCurrentProject();
     if (!project) {

package/dist/backend/server.js

@@ -13,6 +13,7 @@ import { createAppSettingsService } from "./services/app-settings-service.js";
 import { createCodexBridgeIntegrationService } from "./services/codex-bridge-integration-service.js";
 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";
@@ -144,7 +145,8 @@ export async function createServer(deps, options = {}) {
         commandDispatcher: deps.commandDispatcher,
         translationService: deps.translationService,
         roundService: deps.roundService,
-        architectRestartService: deps.architectRestartService
+        architectRestartService: deps.architectRestartService,
+        roleContextRestartService: deps.roleContextRestartService
     });
     registerArtifactRoutes(app, {
         projectService: deps.projectService,
@@ -297,9 +299,16 @@ export function createDefaultServerDeps(options = {}) {
     const architectRestartService = createArchitectRestartService({
         fs,
         taskService,
+        projectService,
         sessionService,
         appSettings
     });
+    const roleContextRestartService = createRoleContextRestartService({
+        fs,
+        projectService,
+        taskService,
+        sessionService
+    });
     const messageService = createMessageService({
         fs,
         runtime,
@@ -377,7 +386,8 @@ export function createDefaultServerDeps(options = {}) {
         roundService,
         projectService,
         taskWorkflowService,
-        architectRestartService
+        architectRestartService,
+        roleContextRestartService
     });
     const gatewayService = createGatewayService({
         fs,
@@ -399,7 +409,9 @@ export function createDefaultServerDeps(options = {}) {
         runtime,
         projectService,
         taskService,
-        translationWorkerService
+        translationWorkerService,
+        architectRestartService,
+        roleContextRestartService
     });
     const claudeHookService = createClaudeHookService({
         projectService,
@@ -417,6 +429,7 @@ export function createDefaultServerDeps(options = {}) {
         jobGuard: createJobGuardService(),
         translationWorkerService,
         architectRestartService,
+        roleContextRestartService,
         roleStallDetector,
         workflowControlService
     });
@@ -464,6 +477,7 @@ export function createDefaultServerDeps(options = {}) {
         taskCloseService,
         taskWorkflowService,
         architectRestartService,
+        roleContextRestartService,
         sessionService,
         artifactService,
         harnessService,

package/dist/backend/services/architect-restart-service.js

@@ -17,55 +17,61 @@ Before performing any assigned work, read:
 - the latest Gate Review report when present
 
 Treat the current artifacts and worktree as the source of truth. The architecture-plan Gate has accepted the current planning artifacts or VCM recorded an explicit Gate exception. Do not repeat the completed interview or planning work unless a later route explicitly reopens it.`;
+const ARCHITECT_RESTART_STATE_FILE = "architect-restart.json";
 export function createArchitectRestartService(deps) {
     const pendingByTask = new Map();
+    const operationsByTask = new Map();
     return {
         async schedule(repoRoot, taskSlug) {
-            const session = await requireRunningArchitect(repoRoot, taskSlug);
-            await requireCompletePlan(repoRoot, taskSlug);
             const key = taskKey(repoRoot, taskSlug);
-            const existing = pendingByTask.get(key);
-            if (existing?.sessionId === session.id) {
-                if (existing.status === "blocked") {
-                    existing.status = "pending";
-                    existing.blocker = undefined;
-                    await tryRestart(existing);
+            return withTaskLock(key, async () => {
+                const session = await requireRunningArchitect(repoRoot, taskSlug);
+                await requireCompletePlan(repoRoot, taskSlug);
+                const existing = pendingByTask.get(key);
+                if (existing?.status === "executing") {
                     return {
                         taskSlug,
-                        sessionId: session.id,
-                        status: "scheduled",
+                        sessionId: existing.replacementSessionId ?? existing.sourceSessionId,
+                        status: "already_scheduled",
                         ...(existing.memoryCandidatePath
                             ? { memoryCandidatePath: existing.memoryCandidatePath }
                             : {})
                     };
                 }
-                return {
+                if (existing && isSourceSession(existing, session)) {
+                    if (existing.status === "blocked") {
+                        existing.status = "pending";
+                        existing.blocker = undefined;
+                        existing.sourceSessionId = session.id;
+                        existing.updatedAt = timestamp();
+                        await persistPending(existing);
+                        await tryRestart(existing);
+                        return scheduleResult(existing, "scheduled");
+                    }
+                    return scheduleResult(existing, "already_scheduled");
+                }
+                const memoryCandidatePath = (await deps.appSettings.getPreferences()).autoMemoryEnabled
+                    ? ARCHITECT_PLANNING_MEMORY_CANDIDATE_PATH
+                    : undefined;
+                const pending = {
+                    version: 1,
+                    repoRoot,
                     taskSlug,
-                    sessionId: session.id,
-                    status: "already_scheduled",
-                    ...(existing.memoryCandidatePath
-                        ? { memoryCandidatePath: existing.memoryCandidatePath }
-                        : {})
+                    sourceSessionId: session.id,
+                    ...(session.claudeSessionId ? { sourceClaudeSessionId: session.claudeSessionId } : {}),
+                    stopped: false,
+                    gateAccepted: false,
+                    status: "pending",
+                    permissionMode: session.permissionMode,
+                    model: session.model,
+                    effort: session.effort,
+                    memoryCandidatePath: existing?.memoryCandidatePath ?? memoryCandidatePath,
+                    updatedAt: timestamp()
                 };
-            }
-            const memoryCandidatePath = (await deps.appSettings.getPreferences()).autoMemoryEnabled
-                ? ARCHITECT_PLANNING_MEMORY_CANDIDATE_PATH
-                : undefined;
-            pendingByTask.set(key, {
-                repoRoot,
-                taskSlug,
-                sessionId: session.id,
-                stopped: false,
-                gateAccepted: false,
-                status: "pending",
-                memoryCandidatePath
+                pendingByTask.set(key, pending);
+                await persistPending(pending);
+                return scheduleResult(pending, "scheduled");
             });
-            return {
-                taskSlug,
-                sessionId: session.id,
-                status: "scheduled",
-                ...(memoryCandidatePath ? { memoryCandidatePath } : {})
-            };
         },
         getState(repoRoot, taskSlug) {
             const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
@@ -74,7 +80,7 @@ export function createArchitectRestartService(deps) {
             }
             return {
                 taskSlug: pending.taskSlug,
-                sessionId: pending.sessionId,
+                sessionId: pending.replacementSessionId ?? pending.sourceSessionId,
                 status: pending.status,
                 ...(pending.memoryCandidatePath
                     ? { memoryCandidatePath: pending.memoryCandidatePath }
@@ -82,46 +88,128 @@ export function createArchitectRestartService(deps) {
                 ...(pending.blocker ? { blocker: { ...pending.blocker } } : {})
             };
         },
+        async recoverTask(repoRoot, taskSlug) {
+            const key = taskKey(repoRoot, taskSlug);
+            await withTaskLock(key, async () => {
+                const stored = await loadPending(repoRoot, taskSlug);
+                if (!stored) {
+                    pendingByTask.delete(key);
+                    return;
+                }
+                const pending = { ...stored, repoRoot };
+                pendingByTask.set(key, pending);
+                const session = await deps.sessionService.getRoleSession(repoRoot, taskSlug, ARCHITECT_ROLE);
+                if (pending.status === "executing") {
+                    if (isConfirmedReplacement(pending, session)) {
+                        await removePending(pending);
+                        return;
+                    }
+                    if (session?.status === "running"
+                        && pending.replacementSessionId === session.id) {
+                        return;
+                    }
+                    await launchReplacement(pending);
+                    return;
+                }
+                if (pending.status === "pending" && restartPrerequisitesMet(pending)) {
+                    if (session?.status === "running") {
+                        await tryRestart(pending);
+                    }
+                    else {
+                        await launchReplacement(pending);
+                    }
+                }
+            });
+        },
         async recordArchitectStop(repoRoot, taskSlug, sessionId) {
-            const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
-            if (!pending || pending.sessionId !== sessionId || pending.status === "blocked") {
-                return;
-            }
-            pending.stopped = true;
-            await tryRestart(pending);
+            const key = taskKey(repoRoot, taskSlug);
+            await withTaskLock(key, async () => {
+                const pending = pendingByTask.get(key);
+                if (!pending || pending.status !== "pending") {
+                    return;
+                }
+                const session = await deps.sessionService.getRoleSession(repoRoot, taskSlug, ARCHITECT_ROLE);
+                if (!session || session.id !== sessionId || !isSourceSession(pending, session)) {
+                    return;
+                }
+                pending.sourceSessionId = session.id;
+                pending.stopped = true;
+                pending.updatedAt = timestamp();
+                await persistPending(pending);
+                await tryRestart(pending);
+            });
         },
         async recordRouteDelivered(repoRoot, taskSlug, message) {
             if (!isArchitectToPm(message)) {
                 return;
             }
-            const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
-            if (!pending || pending.status === "blocked") {
-                return;
-            }
-            pending.deliveredMessageId = message.id;
-            await tryRestart(pending);
+            const key = taskKey(repoRoot, taskSlug);
+            await withTaskLock(key, async () => {
+                const pending = pendingByTask.get(key);
+                if (!pending || pending.status !== "pending") {
+                    return;
+                }
+                pending.deliveredMessageId = message.id;
+                pending.updatedAt = timestamp();
+                await persistPending(pending);
+                await tryRestart(pending);
+            });
         },
         async recordRouteAccepted(repoRoot, taskSlug, message) {
             if (!isArchitectToPm(message)) {
                 return;
             }
-            const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
-            if (!pending || pending.status === "blocked") {
-                return;
-            }
-            pending.acceptedMessageId = message.id;
-            await tryRestart(pending);
+            const key = taskKey(repoRoot, taskSlug);
+            await withTaskLock(key, async () => {
+                const pending = pendingByTask.get(key);
+                if (!pending || pending.status !== "pending") {
+                    return;
+                }
+                pending.acceptedMessageId = message.id;
+                pending.updatedAt = timestamp();
+                await persistPending(pending);
+                await tryRestart(pending);
+            });
         },
         async recordArchitectureGateDisposition(repoRoot, taskSlug, accepted) {
-            const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
-            if (!pending || pending.status === "blocked") {
-                return;
-            }
-            pending.gateAccepted = accepted;
-            await tryRestart(pending);
+            const key = taskKey(repoRoot, taskSlug);
+            await withTaskLock(key, async () => {
+                const pending = pendingByTask.get(key);
+                if (!pending || pending.status !== "pending") {
+                    return;
+                }
+                pending.gateAccepted = accepted;
+                pending.updatedAt = timestamp();
+                await persistPending(pending);
+                await tryRestart(pending);
+            });
+        },
+        async recordReplacementPromptSubmitted(repoRoot, taskSlug, sessionId) {
+            const key = taskKey(repoRoot, taskSlug);
+            await withTaskLock(key, async () => {
+                const pending = pendingByTask.get(key);
+                if (!pending || pending.status !== "executing") {
+                    return;
+                }
+                const session = await deps.sessionService.getRoleSession(repoRoot, taskSlug, ARCHITECT_ROLE);
+                if (!session
+                    || session.id !== sessionId
+                    || !session.claudeSessionId
+                    || (pending.replacementSessionId && pending.replacementSessionId !== session.id)) {
+                    return;
+                }
+                await removePending(pending);
+            });
         },
-        clear(repoRoot, taskSlug) {
-            pendingByTask.delete(taskKey(repoRoot, taskSlug));
+        async clear(repoRoot, taskSlug) {
+            const key = taskKey(repoRoot, taskSlug);
+            await withTaskLock(key, async () => {
+                const pending = pendingByTask.get(key) ?? await loadPending(repoRoot, taskSlug);
+                pendingByTask.delete(key);
+                if (pending) {
+                    await removePending({ ...pending, repoRoot });
+                }
+            });
         }
     };
     async function requireRunningArchitect(repoRoot, taskSlug) {
@@ -147,17 +235,12 @@ export function createArchitectRestartService(deps) {
         }
     }
     async function tryRestart(pending) {
-        if (pending.status !== "pending"
-            || !pending.stopped
-            || !pending.deliveredMessageId
-            || pending.deliveredMessageId !== pending.acceptedMessageId
-            || !pending.gateAccepted) {
+        if (pending.status !== "pending" || !restartPrerequisitesMet(pending)) {
             return;
         }
         const session = await deps.sessionService.getRoleSession(pending.repoRoot, pending.taskSlug, ARCHITECT_ROLE);
-        if (!session
-            || session.id !== pending.sessionId) {
-            blockPending(pending, new VcmError({
+        if (!session || !isSourceSession(pending, session)) {
+            await blockPending(pending, new VcmError({
                 code: "ARCHITECT_RESTART_SESSION_UNAVAILABLE",
                 message: "Architect restart is blocked because the scheduled Architect session no longer exists.",
                 statusCode: 409
@@ -165,7 +248,7 @@ export function createArchitectRestartService(deps) {
             return;
         }
         if (session.status !== "running") {
-            blockPending(pending, new VcmError({
+            await blockPending(pending, new VcmError({
                 code: "ARCHITECT_RESTART_SESSION_NOT_RUNNING",
                 message: "Architect restart is blocked because the scheduled Architect session is not running.",
                 statusCode: 409
@@ -175,31 +258,121 @@ export function createArchitectRestartService(deps) {
         if (session.activityStatus !== "idle") {
             return;
         }
+        pending.sourceSessionId = session.id;
+        await launchReplacement(pending);
+    }
+    async function launchReplacement(pending) {
         pending.status = "executing";
+        pending.blocker = undefined;
+        pending.updatedAt = timestamp();
+        await persistPending(pending);
         try {
             await requireCompletePlan(pending.repoRoot, pending.taskSlug);
             await requirePlanningMemoryCandidate(pending);
-            await deps.sessionService.restartRoleSession(pending.repoRoot, pending.taskSlug, ARCHITECT_ROLE, {
-                permissionMode: session.permissionMode,
-                model: session.model,
-                effort: session.effort,
+            const replacement = await deps.sessionService.restartRoleSession(pending.repoRoot, pending.taskSlug, ARCHITECT_ROLE, {
+                permissionMode: pending.permissionMode,
+                model: pending.model,
+                effort: pending.effort,
                 appendSystemPrompt: ARCHITECT_RESTORE_PROMPT
             });
-            pendingByTask.delete(taskKey(pending.repoRoot, pending.taskSlug));
+            pending.replacementSessionId = replacement.id;
+            pending.updatedAt = timestamp();
+            await persistPending(pending);
         }
         catch (error) {
-            blockPending(pending, error);
+            await blockPending(pending, error);
         }
     }
-    function blockPending(pending, error) {
+    async function blockPending(pending, error) {
         const normalized = toVcmError(error);
         pending.status = "blocked";
         pending.blocker = {
             code: normalized.code,
             message: normalized.message,
-            blockedAt: new Date().toISOString()
+            blockedAt: timestamp()
+        };
+        pending.updatedAt = timestamp();
+        await persistPending(pending);
+    }
+    function restartPrerequisitesMet(pending) {
+        return Boolean(pending.stopped
+            && pending.deliveredMessageId
+            && pending.deliveredMessageId === pending.acceptedMessageId
+            && pending.gateAccepted);
+    }
+    function isSourceSession(pending, session) {
+        return session.id === pending.sourceSessionId
+            || Boolean(pending.sourceClaudeSessionId
+                && session.claudeSessionId
+                && pending.sourceClaudeSessionId === session.claudeSessionId);
+    }
+    function isConfirmedReplacement(pending, session) {
+        return Boolean(session?.claudeSessionId
+            && ((pending.replacementSessionId && session.id === pending.replacementSessionId)
+                || !pending.sourceClaudeSessionId
+                || session.claudeSessionId !== pending.sourceClaudeSessionId));
+    }
+    function scheduleResult(pending, status) {
+        return {
+            taskSlug: pending.taskSlug,
+            sessionId: pending.replacementSessionId ?? pending.sourceSessionId,
+            status,
+            ...(pending.memoryCandidatePath ? { memoryCandidatePath: pending.memoryCandidatePath } : {})
         };
     }
+    async function persistPending(pending) {
+        const { repoRoot: _repoRoot, ...stored } = pending;
+        await deps.fs.writeJsonAtomic(await statePath(pending.repoRoot, pending.taskSlug), stored);
+        pendingByTask.set(taskKey(pending.repoRoot, pending.taskSlug), pending);
+    }
+    async function loadPending(repoRoot, taskSlug) {
+        const target = await statePath(repoRoot, taskSlug);
+        if (!(await deps.fs.pathExists(target))) {
+            return undefined;
+        }
+        const stored = await deps.fs.readJson(target);
+        if (stored.version !== 1
+            || stored.taskSlug !== taskSlug
+            || !stored.sourceSessionId
+            || !["pending", "executing", "blocked"].includes(stored.status)) {
+            throw new VcmError({
+                code: "ARCHITECT_RESTART_STATE_INVALID",
+                message: `Architect restart state is invalid for task ${taskSlug}.`,
+                statusCode: 500
+            });
+        }
+        return stored;
+    }
+    async function removePending(pending) {
+        pendingByTask.delete(taskKey(pending.repoRoot, pending.taskSlug));
+        const target = await statePath(pending.repoRoot, pending.taskSlug);
+        if (await deps.fs.pathExists(target)) {
+            await deps.fs.removePath?.(target, { force: true });
+        }
+    }
+    async function statePath(repoRoot, taskSlug) {
+        const [config, task] = await Promise.all([
+            deps.projectService.loadConfig(repoRoot),
+            deps.taskService.loadTask(repoRoot, taskSlug)
+        ]);
+        return resolveRepoPath(getTaskRuntimeRepoRoot(task), path.posix.join(config.stateRoot, ARCHITECT_RESTART_STATE_FILE));
+    }
+    async function withTaskLock(key, run) {
+        const previous = operationsByTask.get(key) ?? Promise.resolve();
+        const current = previous.catch(() => undefined).then(run);
+        operationsByTask.set(key, current);
+        try {
+            return await current;
+        }
+        finally {
+            if (operationsByTask.get(key) === current) {
+                operationsByTask.delete(key);
+            }
+        }
+    }
+    function timestamp() {
+        return new Date().toISOString();
+    }
     async function requirePlanningMemoryCandidate(pending) {
         if (!pending.memoryCandidatePath) {
             return;