vibe-coding-master 0.7.48 → 0.7.50

package/README.md

@@ -124,8 +124,9 @@ If you want VCM app state to survive container rebuilds, set:
 1. Start VCM with `vcm`.
 2. Open the GUI.
 3. In `Repository`, enter a local Git repository path and click `Connect`.
-4. Create or select a task in the `Task` section. VCM creates a task branch and
-   worktree immediately.
+4. Create or select a task in the `Task` section. Before creating a new task,
+   VCM fast-forward pulls the connected branch when it has an upstream, then
+   creates the task branch and worktree from the updated `HEAD`.
 5. In `VCM Harness`, initialize or update fixed harness files if VCM reports
    pending changes. Harness changes are written to the active task worktree.
 6. If bootstrap is incomplete, open Harness Studio and run bootstrap through
@@ -221,8 +222,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
@@ -625,6 +633,7 @@ Make sure:
 
 - the repository is a Git repository
 - the connected base repo is clean
+- the connected branch can be fast-forward pulled when it has an upstream
 - no other task is currently active for this project
 - the derived `feature/<task>` branch does not already exist
 - the derived `.claude/worktrees/<task>` directory does not already exist

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,
@@ -301,6 +303,12 @@ export function createDefaultServerDeps(options = {}) {
         sessionService,
         appSettings
     });
+    const roleContextRestartService = createRoleContextRestartService({
+        fs,
+        projectService,
+        taskService,
+        sessionService
+    });
     const messageService = createMessageService({
         fs,
         runtime,
@@ -378,7 +386,8 @@ export function createDefaultServerDeps(options = {}) {
         roundService,
         projectService,
         taskWorkflowService,
-        architectRestartService
+        architectRestartService,
+        roleContextRestartService
     });
     const gatewayService = createGatewayService({
         fs,
@@ -401,7 +410,8 @@ export function createDefaultServerDeps(options = {}) {
         projectService,
         taskService,
         translationWorkerService,
-        architectRestartService
+        architectRestartService,
+        roleContextRestartService
     });
     const claudeHookService = createClaudeHookService({
         projectService,
@@ -419,6 +429,7 @@ export function createDefaultServerDeps(options = {}) {
         jobGuard: createJobGuardService(),
         translationWorkerService,
         architectRestartService,
+        roleContextRestartService,
         roleStallDetector,
         workflowControlService
     });
@@ -466,6 +477,7 @@ export function createDefaultServerDeps(options = {}) {
         taskCloseService,
         taskWorkflowService,
         architectRestartService,
+        roleContextRestartService,
         sessionService,
         artifactService,
         harnessService,

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

@@ -238,6 +238,9 @@ export function createClaudeHookService(deps) {
         if (input.role === "architect") {
             await deps.architectRestartService?.recordReplacementPromptSubmitted(context.project.repoRoot, context.taskSlug, session.id);
         }
+        if (isVcmRoleName(input.role)) {
+            await deps.roleContextRestartService?.recordPromptSubmitted(context.project.repoRoot, context.taskSlug, input.role, session.id);
+        }
         const boundToTask = await isHookSessionBoundToTask(context, input.role);
         if (boundToTask) {
             deps.jobGuard?.notePromptSubmitted({

package/dist/backend/services/role-context-restart-service.js

@@ -0,0 +1,240 @@
+import path from "node:path";
+import { VCM_ROLE_NAMES } from "../../shared/constants.js";
+import { resolveRepoPath } from "../adapters/filesystem.js";
+import { toVcmError, VcmError } from "../errors.js";
+import { getTaskRuntimeRepoRoot } from "./task-service.js";
+const STATE_DIR = "restart-with-context";
+export function createRoleContextRestartService(deps) {
+    const pending = new Map();
+    const operations = new Map();
+    const now = deps.now ?? (() => new Date().toISOString());
+    return {
+        async restart(repoRoot, taskSlug, role, input = {}) {
+            return withLock(restartKey(repoRoot, taskSlug, role), async () => {
+                const current = await deps.sessionService.getRoleSession(repoRoot, taskSlug, role);
+                if (!current) {
+                    throw new VcmError({
+                        code: "SESSION_MISSING",
+                        message: `${role} session has not been started.`,
+                        statusCode: 404
+                    });
+                }
+                const state = {
+                    version: 1,
+                    taskSlug,
+                    role,
+                    sourceSessionId: current.id,
+                    status: "launching",
+                    permissionMode: input.permissionMode ?? current.permissionMode,
+                    model: input.model ?? current.model,
+                    effort: input.effort ?? current.effort,
+                    cols: input.cols,
+                    rows: input.rows,
+                    updatedAt: now()
+                };
+                await persist(repoRoot, state);
+                return launch(repoRoot, state);
+            });
+        },
+        async recoverTask(repoRoot, taskSlug) {
+            for (const role of VCM_ROLE_NAMES) {
+                await withLock(restartKey(repoRoot, taskSlug, role), async () => {
+                    const state = await load(repoRoot, taskSlug, role);
+                    if (!state) {
+                        return;
+                    }
+                    const session = await deps.sessionService.getRoleSession(repoRoot, taskSlug, role);
+                    if (state.replacementSessionId
+                        && session?.id === state.replacementSessionId
+                        && session.claudeSessionId) {
+                        await remove(repoRoot, state);
+                        return;
+                    }
+                    state.status = "launching";
+                    state.error = undefined;
+                    state.updatedAt = now();
+                    await persist(repoRoot, state);
+                    await launch(repoRoot, state);
+                });
+            }
+        },
+        async recordPromptSubmitted(repoRoot, taskSlug, role, sessionId) {
+            await withLock(restartKey(repoRoot, taskSlug, role), async () => {
+                const state = pending.get(restartKey(repoRoot, taskSlug, role))
+                    ?? await load(repoRoot, taskSlug, role);
+                if (!state
+                    || state.status !== "awaiting_prompt_confirmation"
+                    || state.replacementSessionId !== sessionId) {
+                    return;
+                }
+                await remove(repoRoot, state);
+            });
+        },
+        async clearRole(repoRoot, taskSlug, role) {
+            await withLock(restartKey(repoRoot, taskSlug, role), async () => {
+                pending.delete(restartKey(repoRoot, taskSlug, role));
+                const target = await statePath(repoRoot, taskSlug, role);
+                if (await deps.fs.pathExists(target)) {
+                    await deps.fs.removePath?.(target, { force: true });
+                }
+            });
+        },
+        async clear(repoRoot, taskSlug) {
+            for (const role of VCM_ROLE_NAMES) {
+                pending.delete(restartKey(repoRoot, taskSlug, role));
+            }
+            const target = await stateDirectory(repoRoot, taskSlug);
+            if (await deps.fs.pathExists(target)) {
+                await deps.fs.removePath?.(target, { recursive: true, force: true });
+            }
+        }
+    };
+    async function launch(repoRoot, state) {
+        const prompts = await buildPrompts(repoRoot, state.taskSlug, state.role);
+        try {
+            const replacement = await deps.sessionService.restartRoleSessionForContext(repoRoot, state.taskSlug, state.role, {
+                permissionMode: state.permissionMode,
+                model: state.model,
+                effort: state.effort,
+                cols: state.cols,
+                rows: state.rows,
+                appendSystemPrompt: prompts.system
+            });
+            state.replacementSessionId = replacement.id;
+            state.status = "awaiting_prompt_confirmation";
+            state.updatedAt = now();
+            await persist(repoRoot, state);
+            await deps.sessionService.submitRolePrompt(repoRoot, state.taskSlug, state.role, replacement.id, prompts.user);
+            return replacement;
+        }
+        catch (error) {
+            const normalized = toVcmError(error);
+            state.status = "blocked";
+            state.error = {
+                code: normalized.code,
+                message: normalized.message
+            };
+            state.updatedAt = now();
+            await persist(repoRoot, state);
+            throw error;
+        }
+    }
+    async function buildPrompts(repoRoot, taskSlug, role) {
+        const [config, task] = await Promise.all([
+            deps.projectService.loadConfig(repoRoot),
+            deps.taskService.loadTask(repoRoot, taskSlug)
+        ]);
+        const handoffDir = task.handoffDir;
+        const stateRoot = config.stateRoot;
+        const files = roleContextFiles(role, handoffDir, stateRoot);
+        return {
+            system: [
+                `This fresh ${role} session continues the current VCM task after Restart With Context.`,
+                "",
+                "Before continuing, read the existing files or directories that apply:",
+                ...files.map((file) => `- ${file}`),
+                "- the current worktree and Git state",
+                "",
+                "Treat the current artifacts and worktree as the source of truth. Continue the accepted assignment from the recorded current state. Do not repeat completed work or rely on the previous Session transcript."
+            ].join("\n"),
+            user: `[VCM RESTART WITH CONTEXT]\nRestore the current ${role} work from the listed task artifacts and continue the accepted assignment.`
+        };
+    }
+    async function persist(repoRoot, state) {
+        await deps.fs.writeJsonAtomic(await statePath(repoRoot, state.taskSlug, state.role), state);
+        pending.set(restartKey(repoRoot, state.taskSlug, state.role), state);
+    }
+    async function load(repoRoot, taskSlug, role) {
+        const target = await statePath(repoRoot, taskSlug, role);
+        if (!(await deps.fs.pathExists(target))) {
+            return undefined;
+        }
+        const state = await deps.fs.readJson(target);
+        if (state.version !== 1
+            || state.taskSlug !== taskSlug
+            || state.role !== role
+            || !["launching", "awaiting_prompt_confirmation", "blocked"].includes(state.status)) {
+            throw new VcmError({
+                code: "ROLE_CONTEXT_RESTART_STATE_INVALID",
+                message: `Restart With Context state is invalid for ${role} in task ${taskSlug}.`,
+                statusCode: 500
+            });
+        }
+        pending.set(restartKey(repoRoot, taskSlug, role), state);
+        return state;
+    }
+    async function remove(repoRoot, state) {
+        pending.delete(restartKey(repoRoot, state.taskSlug, state.role));
+        const target = await statePath(repoRoot, state.taskSlug, state.role);
+        if (await deps.fs.pathExists(target)) {
+            await deps.fs.removePath?.(target, { force: true });
+        }
+    }
+    async function stateDirectory(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, STATE_DIR));
+    }
+    async function statePath(repoRoot, taskSlug, role) {
+        return path.join(await stateDirectory(repoRoot, taskSlug), `${role}.json`);
+    }
+    async function withLock(key, operation) {
+        const previous = operations.get(key) ?? Promise.resolve();
+        const current = previous.catch(() => undefined).then(operation);
+        operations.set(key, current);
+        try {
+            return await current;
+        }
+        finally {
+            if (operations.get(key) === current) {
+                operations.delete(key);
+            }
+        }
+    }
+}
+function roleContextFiles(role, handoffDir, stateRoot) {
+    switch (role) {
+        case "project-manager":
+            return [
+                `${handoffDir}/workflow-progress.md`,
+                `${stateRoot}/workflow/state.json`,
+                `${stateRoot}/workflow-control.json`,
+                `${handoffDir}/messages/`
+            ];
+        case "architect":
+            return [
+                `${handoffDir}/role-commands/architect.md`,
+                `${handoffDir}/architecture-brief.md`,
+                `${handoffDir}/architecture-evidence.md`,
+                `${handoffDir}/planning-progress.md`,
+                `${handoffDir}/architecture-plan.md`,
+                `${handoffDir}/architect-debug.md`,
+                `${handoffDir}/architecture-diagnosis.md`,
+                ".ai/vcm/gate-reviews/index.json"
+            ];
+        case "coder":
+            return [
+                `${handoffDir}/role-commands/coder.md`,
+                `${handoffDir}/architecture-plan.md`,
+                `${handoffDir}/coder-completion.md`,
+                ".ai/vcm/coder-workers/"
+            ];
+        case "tester":
+            return [
+                `${handoffDir}/role-commands/tester.md`,
+                `${handoffDir}/architecture-plan.md`,
+                `${handoffDir}/coder-completion.md`,
+                `${handoffDir}/test-report.md`
+            ];
+        case "reviewer":
+            return [
+                ".ai/vcm/gate-reviews/index.json",
+                ".ai/vcm/gate-reviews/requests/"
+            ];
+    }
+}
+function restartKey(repoRoot, taskSlug, role) {
+    return `${repoRoot}\0${taskSlug}\0${role}`;
+}

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

@@ -34,8 +34,9 @@ export function createRuntimeRecoveryService(deps) {
                     const roundRecovered = await recoverRound(taskRepoRoot, config.stateRoot, task.taskSlug, recoveredAt, context);
                     await recoverMessages(taskRepoRoot, config.stateRoot, task.taskSlug, recoveredAt, context);
                     await recoverGateReview(taskRepoRoot, recoveredAt, context);
-                    await cleanupCoderWorkers(taskRepoRoot, context);
+                    await recoverCoderWorkers(taskRepoRoot, task.taskSlug, context);
                     await deps.architectRestartService?.recoverTask(repoRoot, task.taskSlug);
+                    await deps.roleContextRestartService?.recoverTask(repoRoot, task.taskSlug);
                     if ((roundRecovered || task.status === "running") && !hasLiveTaskSession(task.taskSlug)) {
                         await deps.taskService.updateTaskStatus(repoRoot, task.taskSlug, "stopped");
                     }
@@ -237,16 +238,32 @@ export function createRuntimeRecoveryService(deps) {
         });
         context.changedPaths.add(relativePath);
     }
-    async function cleanupCoderWorkers(taskRepoRoot, context) {
-        const absolutePath = path.join(taskRepoRoot, CODER_WORKERS_RUNTIME_DIR);
-        if (!(await deps.fs.pathExists(absolutePath))) {
+    async function recoverCoderWorkers(taskRepoRoot, taskSlug, context) {
+        if (hasLiveRoundRole(taskSlug, "coder") || !deps.fs.removePath) {
             return;
         }
-        if (!deps.fs.removePath) {
+        const tasksPath = path.join(taskRepoRoot, CODER_WORKERS_RUNTIME_DIR, "tasks");
+        if (!(await deps.fs.pathExists(tasksPath))) {
             return;
         }
-        await deps.fs.removePath(absolutePath, { recursive: true, force: true });
-        context.changedPaths.add(CODER_WORKERS_RUNTIME_DIR);
+        for (const entry of await deps.fs.readDir(tasksPath)) {
+            if (!entry.endsWith(".json")) {
+                continue;
+            }
+            const absolutePath = path.join(tasksPath, entry);
+            let state;
+            try {
+                state = await deps.fs.readJson(absolutePath);
+            }
+            catch {
+                continue;
+            }
+            if (state.status !== "running" || state.handled === true) {
+                continue;
+            }
+            await deps.fs.removePath(absolutePath, { force: true });
+            context.changedPaths.add(path.posix.join(CODER_WORKERS_RUNTIME_DIR, "tasks", entry));
+        }
     }
     async function recoverHarnessBootstrap(repoRoot, _timestamp, context) {
         const absolutePath = path.join(repoRoot, BOOTSTRAP_SESSION_PATH);

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

@@ -45,7 +45,7 @@ export function createSessionService(deps) {
             harnessOutdated: sessionRevision < currentRevision
         };
     }
-    async function launchRoleSession(repoRoot, taskSlug, role, input, launchMode) {
+    async function launchRoleSession(repoRoot, taskSlug, role, input, launchMode, options = {}) {
         const config = await deps.projectService.loadConfig(repoRoot);
         const task = await deps.taskService.loadTask(repoRoot, taskSlug);
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
@@ -145,7 +145,7 @@ export function createSessionService(deps) {
         };
         deps.registry.upsert(record);
         await persistRoleSessionRecord(deps.fs, repoRoot, taskRepoRoot, config.stateRoot, record);
-        if (role === "project-manager") {
+        if (role === "project-manager" && options.restoreProjectManagerContext !== false) {
             await restoreProjectManagerWorkflowContext(record, taskRepoRoot, config.stateRoot);
         }
         return withHarnessRevisionView(taskRepoRoot, record);
@@ -1110,6 +1110,43 @@ export function createSessionService(deps) {
             await clearPersistedRoleSessionRecord(deps.fs, getTaskRuntimeRepoRoot(task), config.stateRoot, taskSlug, role, now());
             return launchRoleSession(repoRoot, taskSlug, role, input, "fresh");
         },
+        async restartRoleSessionForContext(repoRoot, taskSlug, role, input = {}) {
+            const existing = await this.getRoleSession(repoRoot, taskSlug, role);
+            if (!existing) {
+                return launchRoleSession(repoRoot, taskSlug, role, input, "fresh", {
+                    restoreProjectManagerContext: false
+                });
+            }
+            await getModelLaunchEnvironment(normalizeClaudeModel(input.model ?? existing.model));
+            if (deps.runtime.getSession(existing.id)) {
+                await deps.runtime.stop(existing.id);
+            }
+            deps.registry.remove(existing.id);
+            const config = await deps.projectService.loadConfig(repoRoot);
+            const task = await deps.taskService.loadTask(repoRoot, taskSlug);
+            await clearPersistedRoleSessionRecord(deps.fs, getTaskRuntimeRepoRoot(task), config.stateRoot, taskSlug, role, now());
+            return launchRoleSession(repoRoot, taskSlug, role, input, "fresh", {
+                restoreProjectManagerContext: false
+            });
+        },
+        async submitRolePrompt(repoRoot, taskSlug, role, expectedSessionId, prompt) {
+            const session = await this.getRoleSession(repoRoot, taskSlug, role);
+            if (!session || session.id !== expectedSessionId || session.status !== "running") {
+                throw new VcmError({
+                    code: "ROLE_SESSION_NOT_RUNNING",
+                    message: `${role} replacement session is not running.`,
+                    statusCode: 409
+                });
+            }
+            if ((await waitForSessionInputReady(session.id)) === "exited") {
+                throw new VcmError({
+                    code: "ROLE_SESSION_START_FAILED",
+                    message: `${role} replacement session exited before it could accept the recovery prompt.`,
+                    statusCode: 409
+                });
+            }
+            await submitTerminalInput(deps.runtime, session.id, prompt);
+        },
         async getRoleSession(repoRoot, taskSlug, role) {
             const config = await deps.projectService.loadConfig(repoRoot);
             const task = await deps.taskService.loadTask(repoRoot, taskSlug);

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

@@ -8,6 +8,9 @@ export function createTaskCloseService(deps) {
             if (deps.architectRestartService) {
                 await bestEffort("Unable to clear Architect restart state", () => deps.architectRestartService.clear(repoRoot, taskSlug), warnings);
             }
+            if (deps.roleContextRestartService) {
+                await bestEffort("Unable to clear Restart With Context state", () => deps.roleContextRestartService.clear(repoRoot, taskSlug), warnings);
+            }
             await stopTaskRoleSessions(repoRoot, taskSlug, 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);

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

@@ -53,6 +53,19 @@ export function createTaskService(deps) {
                     hint: `Commit, stash, or discard these changes before creating a task worktree: ${baseVisibleChanges.slice(0, 12).join(", ")}`
                 });
             }
+            const upstreamBranch = await deps.git.getUpstreamBranch(repoRoot);
+            if (upstreamBranch) {
+                await deps.git.pullFastForward(repoRoot);
+                const postPullVisibleChanges = await getBaseRepoVisibleChanges(deps.git, repoRoot);
+                if (postPullVisibleChanges.length > 0) {
+                    throw new VcmError({
+                        code: "BASE_REPO_DIRTY",
+                        message: "The connected repository has Git-visible changes after pulling its upstream branch.",
+                        statusCode: 409,
+                        hint: `Commit, stash, or discard these changes before creating a task worktree: ${postPullVisibleChanges.slice(0, 12).join(", ")}`
+                    });
+                }
+            }
             const timestamp = now();
             await deps.fs.ensureDir(path.dirname(worktreePath));
             await deps.git.createWorktree({

package/dist/backend/templates/harness/architect-agent.js

@@ -51,7 +51,6 @@ ${renderRoleMemoryRules("architect")}
 - Use \`vcm-architect-validation-worker\` for exact non-interactive commands already selected by Architect. The worker does not select validation scope, modify tests or code, diagnose failures, or decide whether validation is sufficient.
 - Do not rerun a green command already reported by another Architect worker merely to execute it in the main Architect context.
 - Validation workers write reports under \`.ai/vcm/architect-workers/validation/\`. Architect must interpret the raw results and copy required evidence into the owning Architect artifact.
-- Remove \`.ai/vcm/architect-workers/\` after its accepted facts and command results have been consolidated into Architect-owned artifacts.
 
 ### Architecture Interview
 

package/dist/backend/templates/harness/coder-agent.js

@@ -74,7 +74,7 @@ ${renderRoleMemoryRules("coder")}
 - Stay in the same Coder turn until every worker state is \`completed\` and Coder has reviewed and integrated all reports and commits. Do not end the turn to wait for worker callbacks.
 - A completed worker reports \`Implementation Result: success|has_failed_items\`; \`completed\` means the full assigned sweep and handoff finished, not that every item passed.
 - After workers finish, inspect each item disposition and commit, integrate successful work and committed failure scenes, resolve integration conflicts or invalid edits, and verify that every remaining marker corresponds to a failed disposition. Only then mark \`handled: true\` in each worker state.
-- Run coder-level baseline validation, summarize worker reports and commits in \`.ai/vcm/handoffs/coder-completion.md\`, and clean \`.ai/vcm/coder-workers/\`.
+- Run coder-level baseline validation and summarize worker reports and commits in \`.ai/vcm/handoffs/coder-completion.md\`.
 
 ### Handoff
 
@@ -85,6 +85,7 @@ ${renderRoleMemoryRules("coder")}
 
 - In Docs-Only Flow, commit the documentation changes and submit \`.ai/vcm/handoffs/docs-update-report.md\` through \`vcm-artifact\` with the decision, changed and reviewed documents, evidence, checks, commit, and remaining documentation issues. Do not submit \`coder-completion.md\` for Docs-Only work.
 - Submit \`.ai/vcm/handoffs/coder-completion.md\` before routing back to project-manager: write a candidate outside \`.ai/vcm\`, then run \`.ai/tools/vcm-artifact coder-completion --file <candidate> --mode draft|final\`. This file is the complete, self-contained current implementation completion evidence, not a log. Each revision must restate every Scaffold Manifest disposition, changed file, helper, deviation, generated-context result, baseline-test change, L0/L1 command and result, worker result, commit, and objective failure still needed to review the current implementation without a prior revision. Replace stale content instead of appending history.
+- Maintain an incomplete \`coder-completion.md\` draft while implementation is in progress. Replace it after each completed module or worker result and after compile, L0, or L1 results so it always states completed work, remaining scaffold items, current validation, and current commits. The final submission replaces this draft.
 - After committing the actual implementation state and before submitting a final \`coder-completion.md\`, run \`.ai/tools/check-scaffold-ledger --mode completion --completion <candidate>\`; submit the candidate only after it passes. An incomplete draft does not use completion mode.
 - \`coder-completion.md\` must include \`Decision: ready_for_review | incomplete | failed\`.
 - \`coder-completion.md\` must report every Scaffold Manifest item disposition in the fixed Scaffold Completion table, plus changed files, private helpers added, manifest deviations as report-only facts, generated context status, baseline tests added or updated, L0/L1 commands and results, worker commits and integration status when workers were used, and compile/typecheck or L0/L1 failures.

package/dist/backend/templates/harness/tester-agent.js

@@ -151,6 +151,7 @@ Coverage Gap.
 ### Outputs
 
 - Write \`.ai/vcm/handoffs/test-report.md\` with \`Test Result: pass|fail|incomplete\`, evidence reviewed, tests added or updated, coverage mapping, validation progress, commands run or checked, validation results, test-infrastructure status and evidence, failed expectations, reproduction steps, skipped checks with reasons, coverage gaps, blocking validation issues, and user approval evidence.
+- Maintain an incomplete \`test-report.md\` draft while validation is in progress. Replace it after each completed validation level or long-running check and after changing tests or fixtures so it always states completed validation, remaining validation, current results, and current commits. The final submission replaces this draft.
 - \`test-report.md\` must include this test-infrastructure section:
 
 \`\`\`md

package/dist/backend/templates/harness/vcm-long-running-validation-skill.js

@@ -18,7 +18,7 @@ The hard ceiling is 60 minutes per job, enforced by the job worker itself. No ap
 3. If watch-job exits 125, the job is still running and a bounded handoff is active for the next watcher: run \`.ai/tools/watch-job <job-id>\` again immediately. Do not end the turn between windows.
 4. Repeat until watch-job reports a terminal result.
 5. Read the final status and the relevant log tail.
-6. Record command, result, duration, and required follow-up wherever the caller normally records command evidence.
+6. Record job ID, command, result, duration, and required follow-up wherever the caller normally records command evidence.
 
 Example:
 
@@ -71,8 +71,5 @@ On timeout the worker stops the command process group and records \`timeout\` in
 - do not mark the command as passed
 - do not retry in the background
 
-## Cleanup
-
-\`.ai/vcm/jobs/**\` is runtime state. Delete it after the command result and useful log evidence have been recorded where needed.
 `;
 }