vibe-coding-master 0.7.4 → 0.7.6

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

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { randomUUID } from "node:crypto";
-import { isUserFacingRole } from "../../shared/constants.js";
+import { isVcmRoleName } from "../../shared/constants.js";
 const DEFAULT_SETTLE_MS = 10_000;
 const setGlobalTimeout = globalThis.setTimeout.bind(globalThis);
 const clearGlobalTimeout = globalThis.clearTimeout.bind(globalThis);
@@ -52,7 +52,7 @@ export function createRoundService(deps) {
             return undefined;
         }
         const active = sessions
-            .filter((session) => session.status === "running" && session.activityStatus === "running")
+            .filter((session) => isVcmRoleName(session.role) && session.status === "running" && session.activityStatus === "running")
             .sort((left, right) => timestampMs(roleActivityTimestamp(right, timestamp)) - timestampMs(roleActivityTimestamp(left, timestamp)))[0];
         if (!active) {
             return undefined;
@@ -109,8 +109,6 @@ export function createRoundService(deps) {
             ...state,
             currentRound: stopped,
             lastStoppedRound: stopped,
-            awaitingUser: resolveAwaitingUserOnStop(state.awaitingUser, current.activeRole, stopped.stoppedAt ?? timestamp, state.pendingUserReply),
-            pendingUserReply: undefined,
             updatedAt: timestamp
         };
         await save(input, next);
@@ -205,17 +203,15 @@ export function createRoundService(deps) {
                 roundId: shouldStartNewRound ? id() : current?.id ?? "",
                 settleMs
             });
-            const answered = clearAwaitingUserIfAnswered(recorded, input.eventName, input.role);
-            const next = applyPendingUserReplyStash(answered, input, timestamp);
-            await save(input, next);
+            await save(input, recorded);
             if (input.eventName === "UserPromptSubmit") {
                 clearSettleTimer(input);
                 await updateSessionStatus(input, "running");
             }
-            else if (next.currentRound) {
-                scheduleSettleTimer(input, next.currentRound, timestamp, input.settleGuard);
+            else if (recorded.currentRound) {
+                scheduleSettleTimer(input, recorded.currentRound, timestamp, input.settleGuard);
             }
-            return toSessionRoundState(next, timestamp);
+            return toSessionRoundState(recorded, timestamp);
         });
     }
     async function withTaskLock(input, run) {
@@ -425,7 +421,6 @@ function applyManualInterrupt(input) {
         lastStoppedRound: stopped,
         totalCompletedTurnCount: input.state.totalCompletedTurnCount + 1,
         totalCcActiveMs: input.state.totalCcActiveMs + activeDurationMs,
-        pendingUserReply: undefined,
         updatedAt: input.timestamp
     };
 }
@@ -450,7 +445,7 @@ function toSessionRoundState(state, updatedAt) {
             totalCcActiveMs: state.totalCcActiveMs,
             currentRoundCcActiveMs: 0,
             roleRecovery: state.roleRecovery,
-            flowPause: computeFlowPause(undefined, state.roleRecovery, state.awaitingUser),
+            flowPause: computeFlowPause(undefined, state.roleRecovery),
             roles: [],
             updatedAt
         };
@@ -480,7 +475,7 @@ function toSessionRoundState(state, updatedAt) {
         totalCcActiveMs: state.totalCcActiveMs + activeDurationMs,
         currentRoundCcActiveMs,
         roleRecovery: state.roleRecovery,
-        flowPause: computeFlowPause(current, state.roleRecovery, state.awaitingUser),
+        flowPause: computeFlowPause(current, state.roleRecovery),
         roles: current.roles,
         updatedAt
     };
@@ -489,14 +484,11 @@ function toSessionRoundState(state, updatedAt) {
  * Authoritative flow-pause predicate (single source of truth). The frontend
  * consumes this instead of re-deriving the pause decision.
  *
- * Reason precedence: `role-recovery-failed` > `awaiting-user` > `stopped-no-next-turn`.
- * - `awaiting-user` is emitted whenever `awaitingUser` is set and recovery has not
- *   failed. It is STICKY: it stays paused regardless of round status (the round may
- *   auto-continue under another role while the user's decision is still pending).
+ * Reason precedence: `role-recovery-failed` > `stopped-no-next-turn`.
  * - `stopped-no-next-turn` is emitted only when a real round has ended and the auto
  *   flow has not advanced and we are not mid active-recovery.
  */
-function computeFlowPause(current, roleRecovery, awaitingUser) {
+function computeFlowPause(current, roleRecovery) {
     const recovering = roleRecovery?.status === "waiting" || roleRecovery?.status === "retrying";
     if (recovering) {
         return undefined;
@@ -514,16 +506,6 @@ function computeFlowPause(current, roleRecovery, awaitingUser) {
             }
             : undefined;
     }
-    if (awaitingUser) {
-        return {
-            paused: true,
-            reason: "awaiting-user",
-            role: awaitingUser.role,
-            since: awaitingUser.since,
-            message: awaitingUser.message,
-            messageTruncated: awaitingUser.messageTruncated
-        };
-    }
     if (roundStopped && !nonAlertingStop) {
         return {
             paused: true,
@@ -534,97 +516,6 @@ function computeFlowPause(current, roleRecovery, awaitingUser) {
     }
     return undefined;
 }
-/**
- * Sticky await-user resolution on settle->stopped: keep any existing anchor
- * untouched, and only set a new one when the settling role addresses the human
- * operator. Non-user-facing roles never raise an await-user anchor.
- */
-function resolveAwaitingUserOnStop(existing, role, since, pendingReply) {
-    if (existing) {
-        return existing;
-    }
-    if (!isUserFacingRole(role)) {
-        return undefined;
-    }
-    if (pendingReply && pendingReply.role === role) {
-        return {
-            role,
-            since,
-            capturedAt: pendingReply.capturedAt,
-            message: pendingReply.text,
-            messageTruncated: pendingReply.truncated
-        };
-    }
-    return { role, since };
-}
-/**
- * Maintain the transient `pendingUserReply` stash. A user-facing role's Stop with
- * a captured reply records it until settle promotes it to `awaitingUser.message`.
- * The same role's next UserPromptSubmit obsoletes the stash (turn answered/resumed),
- * so stale text can never attach to a later anchor.
- */
-function applyPendingUserReplyStash(state, input, timestamp) {
-    if (input.eventName === "Stop" && isUserFacingRole(input.role) && input.userFacingReply) {
-        return {
-            ...state,
-            pendingUserReply: {
-                role: input.role,
-                text: input.userFacingReply.text,
-                truncated: input.userFacingReply.truncated,
-                capturedAt: timestamp
-            }
-        };
-    }
-    if (input.eventName === "UserPromptSubmit"
-        && state.pendingUserReply?.role === input.role) {
-        return { ...state, pendingUserReply: undefined };
-    }
-    return state;
-}
-/**
- * Clear the await-user anchor only when the awaiting role itself receives its
- * next UserPromptSubmit (the user answered / that role resumed). Other roles,
- * other events, and round auto-continuation never clear it.
- */
-function clearAwaitingUserIfAnswered(state, eventName, role) {
-    if (eventName !== "UserPromptSubmit" || state.awaitingUser?.role !== role) {
-        return state;
-    }
-    return { ...state, awaitingUser: undefined };
-}
-function normalizeAwaitingUser(input) {
-    if (!input || typeof input !== "object") {
-        return undefined;
-    }
-    const record = input;
-    if (typeof record.role !== "string" || typeof record.since !== "string") {
-        return undefined;
-    }
-    return {
-        role: record.role,
-        since: record.since,
-        capturedAt: typeof record.capturedAt === "string" ? record.capturedAt : undefined,
-        message: typeof record.message === "string" ? record.message : undefined,
-        messageTruncated: record.messageTruncated === true ? true : undefined
-    };
-}
-function normalizePendingUserReply(input) {
-    if (!input || typeof input !== "object") {
-        return undefined;
-    }
-    const record = input;
-    if (typeof record.role !== "string"
-        || typeof record.text !== "string"
-        || typeof record.capturedAt !== "string") {
-        return undefined;
-    }
-    return {
-        role: record.role,
-        text: record.text,
-        truncated: record.truncated === true,
-        capturedAt: record.capturedAt
-    };
-}
 function normalizeRoundFile(input, taskSlug, updatedAt) {
     const legacy = input;
     return {
@@ -637,8 +528,6 @@ function normalizeRoundFile(input, taskSlug, updatedAt) {
         totalCompletedTurnCount: normalizeNumber(input.totalCompletedTurnCount ?? legacy.totalStopCount),
         totalCcActiveMs: normalizeNumber(input.totalCcActiveMs),
         roleRecovery: normalizeRoleRecovery(input.roleRecovery),
-        awaitingUser: normalizeAwaitingUser(input.awaitingUser),
-        pendingUserReply: normalizePendingUserReply(input.pendingUserReply),
         updatedAt: typeof input.updatedAt === "string" ? input.updatedAt : updatedAt
     };
 }

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

@@ -111,12 +111,11 @@ export function createRuntimeCoordinatorService(deps) {
         return activeTasks[0] ?? null;
     }
     async function reconcileHarnessEngineer(repoRoot, task) {
-        const existing = await deps.sessionService.getProjectHarnessEngineerSession(repoRoot);
-        if (!shouldAutoEnsureProjectToolSession(existing)) {
+        const existing = await deps.sessionService.getRoleSession(repoRoot, task.taskSlug, "harness-engineer");
+        if (!shouldAutoEnsureTaskToolSession(existing)) {
             return;
         }
-        await deps.sessionService.ensureProjectHarnessEngineerSession(repoRoot, {
-            taskSlug: task.taskSlug,
+        await ensureTaskToolRoleSession(repoRoot, task.taskSlug, "harness-engineer", {
             permissionMode: existing?.permissionMode,
             model: existing?.model,
             effort: existing?.effort
@@ -126,22 +125,31 @@ export function createRuntimeCoordinatorService(deps) {
         if (!enabled) {
             return;
         }
-        const existing = await deps.sessionService.getProjectTranslatorSession(repoRoot);
-        if (!shouldAutoEnsureProjectToolSession(existing)) {
+        const existing = await deps.sessionService.getRoleSession(repoRoot, task.taskSlug, "translator");
+        if (!shouldAutoEnsureTaskToolSession(existing)) {
             return;
         }
-        await deps.sessionService.ensureProjectTranslatorSession(repoRoot, {
-            taskSlug: task.taskSlug,
+        await ensureTaskToolRoleSession(repoRoot, task.taskSlug, "translator", {
             permissionMode: existing?.permissionMode,
             model: existing?.model,
             effort: existing?.effort
         });
     }
-    function shouldAutoEnsureProjectToolSession(session) {
+    function shouldAutoEnsureTaskToolSession(session) {
         return Boolean(session && (session.status === "running" || session.claudeSessionId));
     }
+    async function ensureTaskToolRoleSession(repoRoot, taskSlug, role, input) {
+        const existing = await deps.sessionService.getRoleSession(repoRoot, taskSlug, role);
+        if (existing?.status === "running") {
+            return existing;
+        }
+        if (existing?.claudeSessionId) {
+            return deps.sessionService.resumeRoleSession(repoRoot, taskSlug, role, input);
+        }
+        return deps.sessionService.startRoleSession(repoRoot, taskSlug, role, input);
+    }
     async function startConversationTranslationListeners(repoRoot, task) {
-        const translator = await deps.sessionService.getProjectTranslatorSession(repoRoot);
+        const translator = await deps.sessionService.getRoleSession(repoRoot, task.taskSlug, "translator");
         if (translator?.status !== "running") {
             return;
         }

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

@@ -17,7 +17,7 @@ export function createRuntimeRecoveryService(deps) {
             };
             await runStep(context, "cleanup translation runtime", () => deps.translationWorkerService?.cleanupStartupRuntime(repoRoot) ?? Promise.resolve());
             const config = await deps.projectService.loadConfig(repoRoot);
-            await runStep(context, "recover project tool sessions", () => recoverProjectToolSessions(repoRoot, recoveredAt, context));
+            await runStep(context, "recover legacy project tool sessions", () => recoverProjectToolSessions(repoRoot, recoveredAt, context));
             await runStep(context, "recover harness bootstrap", () => recoverHarnessBootstrap(repoRoot, recoveredAt, context));
             await runStep(context, "cleanup legacy harness feedback state", () => cleanupLegacyHarnessFeedback(repoRoot, context));
             const tasks = await deps.taskService.listTasks(repoRoot);
@@ -156,7 +156,6 @@ export function createRuntimeRecoveryService(deps) {
             state.lastStoppedRound = current;
             state.totalCompletedTurnCount = (state.totalCompletedTurnCount ?? 0) + completedIncrement;
             state.totalCcActiveMs = (state.totalCcActiveMs ?? 0) + activeDurationMs;
-            state.pendingUserReply = undefined;
         }
         if (state.roleRecovery?.status === "waiting" || state.roleRecovery?.status === "retrying") {
             state.roleRecovery = undefined;

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

@@ -1,9 +1,8 @@
 import path from "node:path";
-import { VCM_ROLE_NAMES, isDispatchableRole } from "../../shared/constants.js";
+import { ROLE_NAMES, isDispatchableRole } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
-import { ensureTaskMemorySnapshot } from "./auto-memory-service.js";
 import { claudeTranscriptPath } from "./claude-transcript-service.js";
 import { readHarnessRevisionState } from "./harness-revision.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
@@ -50,7 +49,6 @@ export function createSessionService(deps) {
         const config = await deps.projectService.loadConfig(repoRoot);
         const task = await deps.taskService.loadTask(repoRoot, taskSlug);
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
-        await ensureTaskMemorySnapshot(deps.fs, repoRoot, taskRepoRoot);
         const paths = deps.artifactService.getHandoffPaths(taskRepoRoot, task.handoffDir);
         const persisted = await loadPersistedRoleRecordForRole(deps.fs, repoRoot, taskRepoRoot, config.stateRoot, taskSlug, role);
         const permissionMode = normalizeClaudePermissionMode(input.permissionMode ?? persisted?.permissionMode);
@@ -124,8 +122,31 @@ export function createSessionService(deps) {
         };
         deps.registry.upsert(record);
         await persistRoleSessionRecord(deps.fs, repoRoot, taskRepoRoot, config.stateRoot, record);
+        if (role === "project-manager") {
+            await restoreProjectManagerWorkflowContext(record, taskRepoRoot, config.stateRoot);
+        }
         return withHarnessRevisionView(repoRoot, record);
     }
+    async function restoreProjectManagerWorkflowContext(record, taskRepoRoot, stateRoot) {
+        if (!deps.taskWorkflowService || record.status !== "running") {
+            return;
+        }
+        try {
+            const state = await deps.taskWorkflowService.getState({
+                taskRepoRoot,
+                stateRoot,
+                taskSlug: record.taskSlug
+            });
+            const context = deps.taskWorkflowService.renderPmResumeContext(state);
+            if (!context || await waitForSessionInputReady(record.id) === "exited") {
+                return;
+            }
+            await submitTerminalInput(deps.runtime, record.id, context);
+        }
+        catch {
+            // Workflow context is advisory; restore failures cannot fail session launch.
+        }
+    }
     async function launchProjectTranslatorSession(repoRoot, input, launchMode) {
         const taskContext = await resolveProjectToolTaskContext(repoRoot, input, "Translator");
         const live = toRoleSessionRecordView(getRegisteredProjectTranslatorSession(deps.registry, deps.runtime), deps.runtime);
@@ -237,7 +258,6 @@ export function createSessionService(deps) {
     }
     async function launchProjectHarnessEngineerSession(repoRoot, input, launchMode) {
         const taskContext = await resolveProjectToolTaskContext(repoRoot, input, "Harness Engineer");
-        await ensureTaskMemorySnapshot(deps.fs, repoRoot, taskContext.taskRepoRoot);
         const live = toRoleSessionRecordView(getRegisteredProjectHarnessEngineerSession(deps.registry, deps.runtime), deps.runtime);
         if (live && live.status === "running") {
             return withHarnessRevisionView(repoRoot, await migrateRunningProjectToolSessionCwd(repoRoot, live, taskContext.taskRepoRoot));
@@ -881,32 +901,12 @@ export function createSessionService(deps) {
             return notifyHarnessUpdatedForSession(repoRoot, current);
         },
         startRoleSession(repoRoot, taskSlug, role, input = {}) {
-            if (role === TRANSLATOR_ROLE) {
-                return this.startProjectTranslatorSession(repoRoot, { ...input, taskSlug });
-            }
-            if (role === HARNESS_ENGINEER_ROLE) {
-                return this.startProjectHarnessEngineerSession(repoRoot, { ...input, taskSlug });
-            }
             return launchRoleSession(repoRoot, taskSlug, role, input, "fresh");
         },
         resumeRoleSession(repoRoot, taskSlug, role, input = {}) {
-            if (role === TRANSLATOR_ROLE) {
-                return this.resumeProjectTranslatorSession(repoRoot, { ...input, taskSlug });
-            }
-            if (role === HARNESS_ENGINEER_ROLE) {
-                return this.resumeProjectHarnessEngineerSession(repoRoot, { ...input, taskSlug });
-            }
             return launchRoleSession(repoRoot, taskSlug, role, input, "resume");
         },
         async stopRoleSession(repoRoot, taskSlug, role) {
-            if (role === TRANSLATOR_ROLE) {
-                void taskSlug;
-                return this.stopProjectTranslatorSession(repoRoot);
-            }
-            if (role === HARNESS_ENGINEER_ROLE) {
-                void taskSlug;
-                return this.stopProjectHarnessEngineerSession(repoRoot);
-            }
             const existing = await this.getRoleSession(repoRoot, taskSlug, role);
             if (!existing) {
                 throw new VcmError({
@@ -931,12 +931,6 @@ export function createSessionService(deps) {
             return updated;
         },
         async restartRoleSession(repoRoot, taskSlug, role, input = {}) {
-            if (role === TRANSLATOR_ROLE) {
-                return this.restartProjectTranslatorSession(repoRoot, { ...input, taskSlug });
-            }
-            if (role === HARNESS_ENGINEER_ROLE) {
-                return this.restartProjectHarnessEngineerSession(repoRoot, { ...input, taskSlug });
-            }
             const existing = await this.getRoleSession(repoRoot, taskSlug, role);
             if (!existing) {
                 return launchRoleSession(repoRoot, taskSlug, role, input, "fresh");
@@ -951,14 +945,6 @@ export function createSessionService(deps) {
             return launchRoleSession(repoRoot, taskSlug, role, input, "fresh");
         },
         async getRoleSession(repoRoot, taskSlug, role) {
-            if (role === TRANSLATOR_ROLE) {
-                void taskSlug;
-                return this.getProjectTranslatorSession(repoRoot);
-            }
-            if (role === HARNESS_ENGINEER_ROLE) {
-                void taskSlug;
-                return this.getProjectHarnessEngineerSession(repoRoot);
-            }
             const config = await deps.projectService.loadConfig(repoRoot);
             const task = await deps.taskService.loadTask(repoRoot, taskSlug);
             const taskRepoRoot = getTaskRuntimeRepoRoot(task);
@@ -976,7 +962,7 @@ export function createSessionService(deps) {
             const task = await deps.taskService.loadTask(repoRoot, taskSlug);
             const taskRepoRoot = getTaskRuntimeRepoRoot(task);
             const persistedTaskSession = await loadPersistedTaskSessionRecord(deps.fs, taskRepoRoot, config.stateRoot, taskSlug);
-            for (const role of VCM_ROLE_NAMES) {
+            for (const role of ROLE_NAMES) {
                 const record = deps.registry.getByRole(taskSlug, role)
                     ?? normalizePersistedRoleRecord(persistedTaskSession?.roles[role]?.record);
                 const session = toRoleSessionRecordView(record, deps.runtime);
@@ -998,24 +984,6 @@ export function createSessionService(deps) {
             return notifyHarnessUpdatedForSession(repoRoot, current);
         },
         async recordRoleHookEvent(repoRoot, input) {
-            if (input.role === TRANSLATOR_ROLE) {
-                void input.taskSlug;
-                return this.recordProjectTranslatorHookEvent(repoRoot, {
-                    eventName: input.eventName,
-                    sessionId: input.sessionId,
-                    transcriptPath: input.transcriptPath,
-                    cwd: input.cwd
-                });
-            }
-            if (input.role === HARNESS_ENGINEER_ROLE) {
-                void input.taskSlug;
-                return this.recordProjectHarnessEngineerHookEvent(repoRoot, {
-                    eventName: input.eventName,
-                    sessionId: input.sessionId,
-                    transcriptPath: input.transcriptPath,
-                    cwd: input.cwd
-                });
-            }
             const current = await this.getRoleSession(repoRoot, input.taskSlug, input.role);
             if (!current || (!input.allowSessionMismatch && !matchesRoleHookSession(current, input))) {
                 return undefined;
@@ -1060,13 +1028,13 @@ export function createSessionService(deps) {
             if (!role || !taskSlug) {
                 return undefined;
             }
-            if (role === TRANSLATOR_ROLE) {
+            if (role === TRANSLATOR_ROLE && taskSlug === PROJECT_TRANSLATOR_SCOPE) {
                 const current = await getProjectToolSessionView(repoRoot, TRANSLATOR_ROLE);
                 return current?.id === sessionId
                     ? markProjectToolActivityIdle(repoRoot, current, persistTranslatorSession)
                     : undefined;
             }
-            if (role === HARNESS_ENGINEER_ROLE) {
+            if (role === HARNESS_ENGINEER_ROLE && taskSlug === PROJECT_HARNESS_ENGINEER_SCOPE) {
                 const current = await getProjectToolSessionView(repoRoot, HARNESS_ENGINEER_ROLE);
                 return current?.id === sessionId
                     ? markProjectToolActivityIdle(repoRoot, current, persistHarnessEngineerSession)
@@ -1094,15 +1062,13 @@ export function createSessionService(deps) {
             return updated;
         },
         async markRoleActivityIdle(repoRoot, taskSlug, role) {
-            if (role === TRANSLATOR_ROLE) {
-                void taskSlug;
+            if (role === TRANSLATOR_ROLE && taskSlug === PROJECT_TRANSLATOR_SCOPE) {
                 const current = await getProjectToolSessionView(repoRoot, TRANSLATOR_ROLE);
                 return current
                     ? markProjectToolActivityIdle(repoRoot, current, persistTranslatorSession)
                     : undefined;
             }
-            if (role === HARNESS_ENGINEER_ROLE) {
-                void taskSlug;
+            if (role === HARNESS_ENGINEER_ROLE && taskSlug === PROJECT_HARNESS_ENGINEER_SCOPE) {
                 const current = await getProjectToolSessionView(repoRoot, HARNESS_ENGINEER_ROLE);
                 return current
                     ? markProjectToolActivityIdle(repoRoot, current, persistHarnessEngineerSession)
@@ -1227,15 +1193,8 @@ function getHandoffArtifactPath(paths, role) {
     return undefined;
 }
 function getRegisteredRoleSession(registry, runtime, taskSlug, role) {
-    if (role !== TRANSLATOR_ROLE && role !== HARNESS_ENGINEER_ROLE) {
-        return registry.getByRole(taskSlug, role);
-    }
-    const candidates = registry.list().filter((session) => session.role === role);
-    const live = candidates.find((session) => runtime.getSession(session.id)?.status === "running");
-    const scoped = live
-        ?? candidates.find((session) => session.taskSlug === taskSlug)
-        ?? candidates.sort(compareSessionUpdatedAtDesc)[0];
-    return scopeProjectRoleSession(scoped, taskSlug);
+    void runtime;
+    return registry.getByRole(taskSlug, role);
 }
 function getRegisteredProjectTranslatorSession(registry, runtime) {
     const candidates = registry.list().filter((session) => session.role === TRANSLATOR_ROLE);
@@ -1250,24 +1209,8 @@ function getRegisteredProjectHarnessEngineerSession(registry, runtime) {
 function compareSessionUpdatedAtDesc(left, right) {
     return (right.updatedAt ?? "").localeCompare(left.updatedAt ?? "");
 }
-function scopeProjectRoleSession(record, taskSlug) {
-    if (!record || (record.role !== TRANSLATOR_ROLE && record.role !== HARNESS_ENGINEER_ROLE)) {
-        return record;
-    }
-    return {
-        ...record,
-        taskSlug
-    };
-}
 async function loadPersistedRoleRecordForRole(fs, baseRepoRoot, taskRepoRoot, stateRoot, taskSlug, role) {
-    if (role === TRANSLATOR_ROLE) {
-        void taskSlug;
-        return loadPersistedTranslatorSession(fs, baseRepoRoot);
-    }
-    if (role === HARNESS_ENGINEER_ROLE) {
-        void taskSlug;
-        return loadPersistedHarnessEngineerSession(fs, baseRepoRoot);
-    }
+    void baseRepoRoot;
     return loadPersistedRoleRecord(fs, taskRepoRoot, stateRoot, taskSlug, role);
 }
 async function loadPersistedTranslatorSession(fs, repoRoot) {
@@ -1350,10 +1293,12 @@ function normalizeHarnessRevision(value) {
 }
 function buildHarnessRefreshPrompt(role) {
     return [
+        "[VCM HARNESS UPDATED]",
         "VCM harness was updated.",
         "Before continuing, re-read the current project `CLAUDE.md`, your agent definition, and any relevant VCM skills from disk.",
         `Your agent definition is \`.claude/agents/${role}.md\` when that file exists.`,
-        "Follow the latest rules from disk. Briefly acknowledge when ready."
+        "Follow the latest rules from disk. Briefly acknowledge when ready.",
+        "[/VCM HARNESS UPDATED]"
     ].join("\n");
 }
 async function persistTaskSession(fs, repoRoot, stateRoot, session) {
@@ -1402,14 +1347,7 @@ async function clearPersistedRoleSessionRecord(fs, repoRoot, stateRoot, taskSlug
     });
 }
 async function persistRoleSessionRecord(fs, baseRepoRoot, taskRepoRoot, stateRoot, session) {
-    if (session.role === TRANSLATOR_ROLE) {
-        await persistTranslatorSession(fs, baseRepoRoot, session);
-        return;
-    }
-    if (session.role === HARNESS_ENGINEER_ROLE) {
-        await persistHarnessEngineerSession(fs, baseRepoRoot, session);
-        return;
-    }
+    void baseRepoRoot;
     await persistTaskSession(fs, taskRepoRoot, stateRoot, session);
 }
 async function persistTranslatorSession(fs, repoRoot, session) {

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

@@ -50,6 +50,7 @@ function degradedArtifactSummary(handoffDir) {
             messagesDir,
             roleCommandPaths: Object.fromEntries(DISPATCHABLE_ROLES.map((role) => [role, `${roleCommandsDir}/${role}.md`])),
             messageRoutePaths: {},
+            architectureBriefPath: `${handoffDir}/architecture-brief.md`,
             architecturePlanPath: `${handoffDir}/architecture-plan.md`,
             knownIssuesPath: `${handoffDir}/known-issues.md`,
             testReportPath: `${handoffDir}/test-report.md`,

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

@@ -1,5 +1,4 @@
-import { VCM_ROLE_NAMES } from "../../shared/constants.js";
-import { VcmError } from "../errors.js";
+import { ROLE_NAMES } from "../../shared/constants.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
 export function createTaskCloseService(deps) {
     return {
@@ -7,10 +6,18 @@ export function createTaskCloseService(deps) {
             const task = await deps.taskService.markTaskCleaned(repoRoot, taskSlug);
             const warnings = [];
             await stopTaskRoleSessions(repoRoot, taskSlug, warnings);
-            await moveOrStopProjectToolSession("Translator", () => deps.sessionService.moveProjectTranslatorSessionToSafeCwd(repoRoot), () => deps.sessionService.stopProjectTranslatorSession(repoRoot), warnings);
-            await moveOrStopProjectToolSession("Harness Engineer", () => deps.sessionService.moveProjectHarnessEngineerSessionToSafeCwd(repoRoot), () => deps.sessionService.stopProjectHarnessEngineerSession(repoRoot), warnings);
             await bestEffort("Unable to stop task translation runtime", () => deps.translationService.stopTask(getTaskRuntimeRepoRoot(task), taskSlug, { clearCache: true }), warnings);
             await bestEffort("Unable to clear task round runtime", () => deps.roundService.stopTask(taskSlug), warnings);
+            if (deps.projectService && deps.taskWorkflowService) {
+                await bestEffort("Unable to clear task workflow state", async () => {
+                    const config = await deps.projectService.loadConfig(repoRoot);
+                    await deps.taskWorkflowService.clearState({
+                        taskRepoRoot: getTaskRuntimeRepoRoot(task),
+                        stateRoot: config.stateRoot,
+                        taskSlug
+                    });
+                }, warnings);
+            }
             try {
                 const result = await deps.taskService.cleanupTask(repoRoot, taskSlug);
                 const combinedWarnings = [...warnings, ...(result.warnings ?? [])];
@@ -46,32 +53,13 @@ export function createTaskCloseService(deps) {
             return;
         }
         for (const session of sessions) {
-            if (session.status !== "running" || !VCM_ROLE_NAMES.some((role) => role === session.role)) {
+            if (session.status !== "running" || !ROLE_NAMES.some((role) => role === session.role)) {
                 continue;
             }
             await bestEffort(`Unable to stop ${session.role} session`, () => deps.sessionService.stopRoleSession(repoRoot, taskSlug, session.role), warnings);
         }
     }
 }
-async function moveOrStopProjectToolSession(label, move, stop, warnings) {
-    try {
-        await move();
-    }
-    catch (error) {
-        if (isMissingSession(error)) {
-            return;
-        }
-        warnings.push(`Unable to move ${label} session to the base repository: ${describeError(error)}`);
-        try {
-            await stop();
-        }
-        catch (stopError) {
-            if (!isMissingSession(stopError)) {
-                warnings.push(`Unable to stop ${label} session after cwd migration failed: ${describeError(stopError)}`);
-            }
-        }
-    }
-}
 async function bestEffort(message, operation, warnings) {
     try {
         await operation();
@@ -80,9 +68,6 @@ async function bestEffort(message, operation, warnings) {
         warnings.push(`${message}: ${describeError(error)}`);
     }
 }
-function isMissingSession(error) {
-    return error instanceof VcmError && error.code === "SESSION_MISSING";
-}
 function describeError(error) {
     return error instanceof Error ? error.message : String(error);
 }