vibe-coding-master 0.0.16 → 0.2.0

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

@@ -8,25 +8,11 @@ import { renderMessageEnvelope } from "../templates/message-envelope.js";
 const PM_ROLE = "project-manager";
 const PM_TO_ROLE_TYPES = new Set(["task", "question", "review-request", "revise", "cancel"]);
 const ROLE_TO_PM_TYPES = new Set(["result", "question", "blocked", "finding"]);
-const OPEN_MESSAGE_STATUSES = new Set([
-    "pending_approval",
-    "queued",
-    "delivering",
-    "submitted",
-    "failed",
-    "delivery_failed",
-    "response_ready_missing_result"
-]);
-const MUTABLE_ROUTE_MESSAGE_STATUSES = new Set([
-    "pending_approval",
-    "queued",
-    "failed",
-    "delivery_failed",
-    "response_ready_missing_result"
-]);
+const DEFAULT_PRE_DISPATCH_SWITCH_DELAY_MS = 500;
 export function createMessageService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     const id = deps.id ?? (() => `msg_${randomUUID()}`);
+    const preDispatchSwitchDelayMs = deps.preDispatchSwitchDelayMs ?? DEFAULT_PRE_DISPATCH_SWITCH_DELAY_MS;
     const taskLocks = new Map();
     async function getOrchestrationState(input) {
         const statePath = getOrchestrationStatePath(getStateRepoRoot(input), input.stateRoot, input.taskSlug);
@@ -49,32 +35,17 @@ export function createMessageService(deps) {
         const timestamp = now();
         const base = toRouteContext(input);
         const state = await getOrchestrationState(input);
-        const messagesPath = getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug);
-        let messages = await readLatestMessages(deps.fs, messagesPath);
-        const updates = [];
-        if (input.stoppedRole) {
-            const acknowledged = acknowledgeActiveMessages(messages, input.stoppedRole, timestamp);
-            for (const message of acknowledged) {
-                await appendMessageSnapshot(deps.fs, input, message);
-                await clearRouteFileIfStillMatchesMessage(deps.fs, input, message);
-            }
-            updates.push(...acknowledged);
-            messages = applyMessageSnapshots(messages, acknowledged);
-        }
         const pendingFiles = (await listRouteFiles(deps.fs, base)).filter((routeFile) => routeFile.pending);
         const candidates = selectDispatchCandidates(pendingFiles, input.stoppedRole);
         const results = [];
-        const deliveredTargets = new Set();
         for (const routeFile of candidates) {
-            if (deliveredTargets.has(routeFile.toRole)) {
-                continue;
-            }
-            const result = await dispatchRouteFile(input, routeFile, messages, state, timestamp);
+            const result = await dispatchRouteFile(input, routeFile, state, timestamp);
             results.push(result);
-            await appendMessageSnapshot(deps.fs, input, result.message);
-            messages = applyMessageSnapshots(messages, [result.message]);
+            if (result.message) {
+                await appendMessageSnapshot(deps.fs, input, result.message);
+            }
             if (result.delivered) {
-                deliveredTargets.add(routeFile.toRole);
+                break;
             }
         }
         return results;
@@ -84,73 +55,56 @@ export function createMessageService(deps) {
         const all = await listRouteFiles(deps.fs, context);
         return all.filter((routeFile) => routeFile.pending);
     }
-    async function dispatchRouteFile(input, routeFile, existingMessages, state, timestamp) {
+    async function dispatchRouteFile(input, routeFile, state, timestamp) {
         validateMessagePolicy(routeFile.fromRole, routeFile.toRole, routeFile.type);
-        const existingOpen = findOpenMessageForRoute(existingMessages, routeFile.path);
-        const message = {
-            ...(existingOpen ?? {
-                id: id(),
-                taskSlug: input.taskSlug,
-                createdAt: timestamp
-            }),
-            fromRole: routeFile.fromRole,
-            toRole: routeFile.toRole,
-            type: routeFile.type,
-            body: routeFile.body,
-            artifactRefs: routeFile.artifactRefs,
-            bodyPath: routeFile.path,
-            routePath: routeFile.path,
-            status: "queued",
-            queuedBehindMessageId: undefined,
-            failureReason: undefined
-        };
         const session = await deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, routeFile.toRole);
         if (!session || session.status !== "running") {
             return {
-                message: {
-                    ...message,
-                    status: "queued",
-                    failureReason: `${routeFile.toRole} session is not running.`
-                },
                 delivered: false,
                 requiresUserApproval: false,
-                clearedRouteFile: false
+                clearedRouteFile: false,
+                failureReason: `${routeFile.toRole} session is not running.`
             };
         }
         if (state.mode === "manual") {
             return {
-                message: {
-                    ...message,
-                    status: "pending_approval"
-                },
                 delivered: false,
                 requiresUserApproval: true,
                 clearedRouteFile: false
             };
         }
-        const activeMessage = findActiveMessageForRole(existingMessages, routeFile.toRole);
-        if (activeMessage) {
+        if (session.activityStatus === "running") {
             return {
-                message: {
-                    ...message,
-                    status: "queued",
-                    queuedBehindMessageId: activeMessage.id,
-                    failureReason: `${routeFile.toRole} is still handling VCM message ${activeMessage.id}.`
-                },
                 delivered: false,
                 requiresUserApproval: false,
-                clearedRouteFile: false
+                clearedRouteFile: false,
+                failureReason: `${routeFile.toRole} is still running.`
             };
         }
-        const delivering = {
+        const message = {
+            id: id(),
+            taskSlug: input.taskSlug,
+            createdAt: timestamp,
+            fromRole: routeFile.fromRole,
+            toRole: routeFile.toRole,
+            type: routeFile.type,
+            body: routeFile.body,
+            artifactRefs: routeFile.artifactRefs,
+            bodyPath: routeFile.path,
+            routePath: routeFile.path,
+            dispatchingAt: timestamp,
+            failureReason: undefined
+        };
+        await appendMessageSnapshot(deps.fs, input, message);
+        await delay(preDispatchSwitchDelayMs);
+        const delivered = {
             ...message,
-            status: "delivering",
             deliveredAt: timestamp
         };
-        await submitTerminalInput(deps.runtime, session.id, renderMessageEnvelope(delivering));
+        await submitTerminalInput(deps.runtime, session.id, renderMessageEnvelope(delivered));
         await deps.sessionService.markRoleActivityRunning(input.repoRoot, input.taskSlug, routeFile.toRole);
         return {
-            message: delivering,
+            message: delivered,
             delivered: true,
             requiresUserApproval: false,
             clearedRouteFile: false
@@ -174,48 +128,46 @@ export function createMessageService(deps) {
                 if (!messageId) {
                     return undefined;
                 }
-                const message = findDeliveringMessageForPrompt(messages, input.role, messageId);
+                const message = findDeliveredMessageForPrompt(messages, input.role, messageId);
                 if (!message) {
                     return undefined;
                 }
-                const submitted = {
+                const accepted = {
                     ...message,
-                    status: "submitted",
-                    submittedAt: timestamp,
-                    queuedBehindMessageId: undefined,
+                    acceptedAt: timestamp,
                     failureReason: undefined
                 };
-                await appendMessageSnapshot(deps.fs, input, submitted);
-                await clearRouteFileIfStillMatchesMessage(deps.fs, input, submitted);
-                return submitted;
+                await appendMessageSnapshot(deps.fs, input, accepted);
+                await clearRouteFileIfStillMatchesMessage(deps.fs, input, accepted);
+                return accepted;
             });
         },
         async markAllDone(input) {
             return withTaskLock(taskLocks, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), async () => {
-                const timestamp = now();
                 const messages = await readLatestMessages(deps.fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
-                const updated = messages
-                    .filter((message) => OPEN_MESSAGE_STATUSES.has(message.status))
-                    .map((message) => ({
-                    ...message,
-                    status: "acknowledged",
-                    acknowledgedAt: timestamp,
-                    queuedBehindMessageId: undefined,
-                    failureReason: undefined
-                }));
-                for (const message of updated) {
-                    await appendMessageSnapshot(deps.fs, input, message);
-                }
+                let clearedCount = 0;
                 if (input.clearRouteFiles) {
                     for (const routeFile of await listPendingRouteFiles(input)) {
                         await deps.fs.writeText(resolveRepoPath(input.taskRepoRoot ?? input.repoRoot, routeFile.path), "");
+                        clearedCount += 1;
                     }
                 }
-                const latest = applyMessageSnapshots(messages, updated);
                 return {
                     taskSlug: input.taskSlug,
-                    updatedCount: updated.length,
-                    messages: latest
+                    updatedCount: clearedCount,
+                    messages
+                };
+            });
+        },
+        async deleteMessageHistory(input) {
+            return withTaskLock(taskLocks, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), async () => {
+                const messagesPath = getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug);
+                const messages = await readLatestMessages(deps.fs, messagesPath);
+                await writeMessageSnapshots(deps.fs, messagesPath, []);
+                return {
+                    taskSlug: input.taskSlug,
+                    deletedCount: messages.length,
+                    messages: []
                 };
             });
         },
@@ -401,31 +353,11 @@ async function withTaskLock(locks, key, run) {
         }
     }
 }
-function findOpenMessageForRoute(messages, routePath) {
-    return [...messages]
-        .reverse()
-        .find((message) => (message.routePath ?? message.bodyPath) === routePath && MUTABLE_ROUTE_MESSAGE_STATUSES.has(message.status));
-}
-function findActiveMessageForRole(messages, role) {
-    return messages.find((message) => message.toRole === role &&
-        (message.status === "delivering" || message.status === "submitted"));
-}
-function acknowledgeActiveMessages(messages, role, timestamp) {
-    return messages
-        .filter((message) => message.toRole === role && (message.status === "delivering" || message.status === "submitted"))
-        .map((message) => ({
-        ...message,
-        status: "acknowledged",
-        submittedAt: message.submittedAt ?? message.deliveredAt ?? timestamp,
-        acknowledgedAt: timestamp,
-        failureReason: undefined
-    }));
-}
-function findDeliveringMessageForPrompt(messages, role, messageId) {
-    const delivering = messages.filter((message) => message.toRole === role &&
-        message.status === "delivering" &&
-        message.id === messageId);
-    return delivering.sort((left, right) => getMessageDeliveryTime(left).localeCompare(getMessageDeliveryTime(right))).at(-1);
+function findDeliveredMessageForPrompt(messages, role, messageId) {
+    const delivered = messages.filter((message) => message.toRole === role &&
+        message.id === messageId &&
+        message.deliveredAt);
+    return delivered.sort((left, right) => getMessageDeliveryTime(left).localeCompare(getMessageDeliveryTime(right))).at(-1);
 }
 function extractVcmMessageId(prompt) {
     return prompt?.match(/^\s*id:\s*(\S+)\s*$/m)?.[1];
@@ -455,16 +387,6 @@ function arraysEqual(left, right) {
     }
     return left.every((value, index) => value === right[index]);
 }
-function applyMessageSnapshots(messages, snapshots) {
-    if (snapshots.length === 0) {
-        return messages;
-    }
-    const latest = new Map(messages.map((message) => [message.id, message]));
-    for (const snapshot of snapshots) {
-        latest.set(snapshot.id, snapshot);
-    }
-    return [...latest.values()].sort((left, right) => left.createdAt.localeCompare(right.createdAt));
-}
 async function readLatestMessages(fs, messagesPath) {
     if (!(await fs.pathExists(messagesPath))) {
         return [];
@@ -480,6 +402,12 @@ async function readLatestMessages(fs, messagesPath) {
 async function appendMessageSnapshot(fs, input, message) {
     await fs.appendText(getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), `${JSON.stringify(message)}\n`);
 }
+async function writeMessageSnapshots(fs, messagesPath, messages) {
+    const content = messages.length > 0
+        ? `${messages.map((message) => JSON.stringify(message)).join("\n")}\n`
+        : "";
+    await fs.writeText(messagesPath, content);
+}
 function getMessagesPath(repoRoot, stateRoot, taskSlug) {
     return path.join(repoRoot, stateRoot, "messages", `${taskSlug}.jsonl`);
 }
@@ -489,3 +417,9 @@ function getOrchestrationStatePath(repoRoot, stateRoot, taskSlug) {
 function getStateRepoRoot(input) {
     return input.stateRepoRoot ?? input.repoRoot;
 }
+function delay(ms) {
+    if (ms <= 0) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

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

@@ -30,7 +30,7 @@ export function createProjectService(deps) {
             }
             const config = await this.loadConfig(repoRoot);
             await deps.fs.ensureDir(path.join(repoRoot, config.handoffRoot));
-            await deps.fs.ensureDir(path.join(repoRoot, config.stateRoot, "tasks"));
+            await deps.fs.ensureDir(path.join(this.getProjectDataRoot(repoRoot), "tasks"));
             await deps.fs.ensureDir(path.join(repoRoot, ".claude", "worktrees"));
             await this.saveConfig(config, true);
             const warnings = [];
@@ -87,6 +87,9 @@ export function createProjectService(deps) {
         },
         getConfigPath(repoRoot) {
             return deps.appSettings.getProjectConfigPath(repoRoot);
+        },
+        getProjectDataRoot(repoRoot) {
+            return path.dirname(deps.appSettings.getProjectConfigPath(repoRoot));
         }
     };
 }

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

@@ -4,21 +4,15 @@ export function createRoundService(deps = {}) {
     return {
         getTaskRoundState(input) {
             const roleStates = ROLE_NAMES.map((role) => toRoleTurnState(role, input.sessions));
-            const latestDelivered = getLatestDeliveredMessage(input.messages);
-            const queuedMessageCount = input.messages.filter((message) => message.status === "queued").length;
-            const pendingMessageCount = input.messages.filter((message) => message.status === "pending_approval").length;
             const state = evaluateTaskRoundState({
                 taskSlug: input.taskSlug,
-                messages: input.messages,
+                pendingRouteCount: input.pendingRouteCount,
                 roleStates,
                 updatedAt: now()
             });
             return {
                 ...state,
-                latestMessageId: latestDelivered?.id,
-                latestMessageDeliveredAt: getMessageDeliveredAt(latestDelivered),
-                queuedMessageCount,
-                pendingMessageCount
+                pendingRouteCount: input.pendingRouteCount
             };
         },
         stopSession() { },
@@ -26,35 +20,22 @@ export function createRoundService(deps = {}) {
     };
 }
 export function evaluateTaskRoundState(input) {
-    const latestDelivered = getLatestDeliveredMessage(input.messages);
-    const hasQueuedOrPending = input.messages.some((message) => message.status === "queued" || message.status === "pending_approval");
-    if (latestDelivered) {
-        const deliveredAt = getMessageDeliveredAt(latestDelivered);
-        const targetState = input.roleStates.find((roleState) => roleState.role === latestDelivered.toRole);
-        const completedAt = targetState && deliveredAt
-            ? getCompletedAtForDelivery(targetState, deliveredAt)
-            : undefined;
-        if (completedAt && !hasQueuedOrPending) {
-            return {
-                taskSlug: input.taskSlug,
-                status: "completed",
-                activeRole: latestDelivered.toRole,
-                completionId: `${latestDelivered.id}:${completedAt}`,
-                completedAt,
-                roles: input.roleStates,
-                updatedAt: input.updatedAt
-            };
-        }
+    const activeRole = input.roleStates.find((roleState) => roleState.status === "answering" ||
+        roleState.status === "using_tools" ||
+        roleState.status === "waiting_user" ||
+        roleState.status === "abnormal");
+    if (activeRole) {
         return {
             taskSlug: input.taskSlug,
-            status: targetState?.status === "waiting_user" ? "waiting_user" : "active",
-            activeRole: latestDelivered.toRole,
+            status: activeRole.status === "waiting_user" ? "waiting_user" : "active",
+            activeRole: activeRole.role,
             roles: input.roleStates,
             updatedAt: input.updatedAt
         };
     }
-    const latestIdleRole = !hasQueuedOrPending ? getLatestIdleRole(input.roleStates) : undefined;
-    if (latestIdleRole?.lastAnswerEndedAt) {
+    const latestIdleRole = getLatestIdleRole(input.roleStates);
+    const hasPendingRoutes = input.pendingRouteCount > 0;
+    if (latestIdleRole?.lastAnswerEndedAt && !hasPendingRoutes) {
         return {
             taskSlug: input.taskSlug,
             status: "completed",
@@ -65,14 +46,10 @@ export function evaluateTaskRoundState(input) {
             updatedAt: input.updatedAt
         };
     }
-    const activeRole = input.roleStates.find((roleState) => roleState.status === "answering" ||
-        roleState.status === "using_tools" ||
-        roleState.status === "waiting_user" ||
-        roleState.status === "abnormal");
     return {
         taskSlug: input.taskSlug,
-        status: activeRole?.status === "waiting_user" ? "waiting_user" : activeRole ? "active" : "idle",
-        activeRole: activeRole?.role,
+        status: hasPendingRoutes ? "active" : "idle",
+        activeRole: latestIdleRole?.role,
         roles: input.roleStates,
         updatedAt: input.updatedAt
     };
@@ -94,21 +71,6 @@ function toRoleTurnState(role, sessions) {
             : undefined
     };
 }
-function getLatestDeliveredMessage(messages) {
-    return messages
-        .filter((message) => message.status === "delivering" || message.status === "submitted")
-        .sort((left, right) => getMessageDeliveredAt(left).localeCompare(getMessageDeliveredAt(right)))
-        .at(-1);
-}
-function getMessageDeliveredAt(message) {
-    return message?.submittedAt ?? message?.deliveredAt ?? message?.createdAt ?? "";
-}
-function getCompletedAtForDelivery(roleState, deliveredAt) {
-    if (roleState.status !== "idle" || !roleState.lastAnswerEndedAt) {
-        return undefined;
-    }
-    return roleState.lastAnswerEndedAt >= deliveredAt ? roleState.lastAnswerEndedAt : undefined;
-}
 function getLatestIdleRole(roleStates) {
     return roleStates
         .filter((roleState) => roleState.status === "idle" && roleState.lastAnswerEndedAt)

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

@@ -41,6 +41,7 @@ export function createSessionService(deps) {
             cwd: taskRepoRoot,
             env: {
                 VCM_API_URL: deps.apiUrl,
+                VCM_TASK_REPO_ROOT: taskRepoRoot,
                 VCM_TASK_SLUG: taskSlug,
                 VCM_ROLE: role,
                 VCM_SESSION_ID: claudeSessionId
@@ -224,9 +225,6 @@ function getHandoffArtifactPath(paths, role) {
     if (role === "architect") {
         return paths.architecturePlanPath;
     }
-    if (role === "coder") {
-        return paths.implementationLogPath;
-    }
     if (role === "reviewer") {
         return paths.reviewReportPath;
     }

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

@@ -7,7 +7,8 @@ export function createTaskService(deps) {
         async createTask(repoRoot, input) {
             assertValidTaskSlug(input.taskSlug);
             const config = await deps.projectService.loadConfig(repoRoot);
-            const taskPath = getTaskPath(repoRoot, config.stateRoot, input.taskSlug);
+            const taskStoreRoot = deps.projectService.getProjectDataRoot(repoRoot);
+            const taskPath = getTaskPath(taskStoreRoot, input.taskSlug);
             const shouldCreateWorktree = input.createWorktree !== false;
             const taskBranch = shouldCreateWorktree
                 ? `feature/${input.taskSlug}`
@@ -22,7 +23,7 @@ export function createTaskService(deps) {
                     statusCode: 409
                 });
             }
-            if (!(await deps.git.isIgnored(repoRoot, `${config.stateRoot}/tasks/.probe`))) {
+            if (!(await deps.git.isIgnored(repoRoot, `${config.stateRoot}/.probe`))) {
                 throw new VcmError({
                     code: "VCM_STATE_NOT_IGNORED",
                     message: `${config.stateRoot}/ is not ignored by Git.`,
@@ -39,7 +40,7 @@ export function createTaskService(deps) {
                 });
             }
             if (!shouldCreateWorktree) {
-                const activeInlineTask = await findActiveInlineTask(deps.fs, repoRoot, config.stateRoot);
+                const activeInlineTask = await findActiveInlineTask(deps.fs, taskStoreRoot);
                 if (activeInlineTask) {
                     throw new VcmError({
                         code: "INLINE_TASK_EXISTS",
@@ -108,14 +109,14 @@ export function createTaskService(deps) {
             await deps.artifactService.createArtifactTemplates({
                 repoRoot: taskRepoRoot,
                 taskSlug: input.taskSlug,
-                handoffDir: task.handoffDir
+                handoffDir: task.handoffDir,
+                branch: task.branch
             });
             await this.saveTask(repoRoot, task);
             return task;
         },
         async listTasks(repoRoot) {
-            const config = await deps.projectService.loadConfig(repoRoot);
-            const tasksDir = path.join(repoRoot, config.stateRoot, "tasks");
+            const tasksDir = path.join(deps.projectService.getProjectDataRoot(repoRoot), "tasks");
             if (!(await deps.fs.pathExists(tasksDir))) {
                 return [];
             }
@@ -128,8 +129,7 @@ export function createTaskService(deps) {
         },
         async loadTask(repoRoot, taskSlug) {
             assertValidTaskSlug(taskSlug);
-            const config = await deps.projectService.loadConfig(repoRoot);
-            const taskPath = getTaskPath(repoRoot, config.stateRoot, taskSlug);
+            const taskPath = getTaskPath(deps.projectService.getProjectDataRoot(repoRoot), taskSlug);
             if (!(await deps.fs.pathExists(taskPath))) {
                 throw new VcmError({
                     code: "TASK_MISSING",
@@ -140,8 +140,7 @@ export function createTaskService(deps) {
             return deps.fs.readJson(taskPath);
         },
         async saveTask(repoRoot, task) {
-            const config = await deps.projectService.loadConfig(repoRoot);
-            await deps.fs.writeJsonAtomic(getTaskPath(repoRoot, config.stateRoot, task.taskSlug), task);
+            await deps.fs.writeJsonAtomic(getTaskPath(deps.projectService.getProjectDataRoot(repoRoot), task.taskSlug), task);
         },
         async updateTaskStatus(repoRoot, taskSlug, status) {
             const task = await this.loadTask(repoRoot, taskSlug);
@@ -165,7 +164,7 @@ export function createTaskService(deps) {
             const config = await deps.projectService.loadConfig(repoRoot);
             const task = await this.loadTask(repoRoot, taskSlug);
             const taskRepoRoot = getTaskRuntimeRepoRoot(task);
-            const statePaths = getTaskStatePaths(repoRoot, taskRepoRoot, config.stateRoot, config.handoffRoot, taskSlug);
+            const statePaths = getTaskStatePaths(deps.projectService.getProjectDataRoot(repoRoot), taskRepoRoot, config.stateRoot, config.handoffRoot, taskSlug);
             const removedStatePaths = [];
             const cleanedAt = now();
             if (task.worktreePath) {
@@ -194,8 +193,8 @@ export function createTaskService(deps) {
 export function getTaskRuntimeRepoRoot(task) {
     return task.worktreePath ?? task.repoRoot;
 }
-function getTaskPath(repoRoot, stateRoot, taskSlug) {
-    return path.join(repoRoot, stateRoot, "tasks", `${taskSlug}.json`);
+function getTaskPath(taskStoreRoot, taskSlug) {
+    return path.join(taskStoreRoot, "tasks", `${taskSlug}.json`);
 }
 function getTaskWorktreePath(repoRoot, taskSlug) {
     return path.join(repoRoot, ".claude", "worktrees", taskSlug);
@@ -206,8 +205,8 @@ async function ensureTaskRuntimeStateDirs(fs, taskRepoRoot, stateRoot) {
     await fs.ensureDir(path.join(taskRepoRoot, stateRoot, "orchestration"));
     await fs.ensureDir(path.join(taskRepoRoot, stateRoot, "translation"));
 }
-async function findActiveInlineTask(fs, repoRoot, stateRoot) {
-    const tasksDir = path.join(repoRoot, stateRoot, "tasks");
+async function findActiveInlineTask(fs, taskStoreRoot) {
+    const tasksDir = path.join(taskStoreRoot, "tasks");
     if (!(await fs.pathExists(tasksDir))) {
         return undefined;
     }
@@ -220,9 +219,9 @@ async function findActiveInlineTask(fs, repoRoot, stateRoot) {
     }
     return undefined;
 }
-function getTaskStatePaths(baseRepoRoot, taskRepoRoot, stateRoot, handoffRoot, taskSlug) {
+function getTaskStatePaths(taskStoreRoot, taskRepoRoot, stateRoot, handoffRoot, taskSlug) {
     return [
-        path.join(baseRepoRoot, stateRoot, "tasks", `${taskSlug}.json`),
+        getTaskPath(taskStoreRoot, taskSlug),
         path.join(taskRepoRoot, stateRoot, "sessions", `${taskSlug}.json`),
         path.join(taskRepoRoot, stateRoot, "messages", `${taskSlug}.jsonl`),
         path.join(taskRepoRoot, stateRoot, "orchestration", `${taskSlug}.json`),

package/dist/backend/templates/handoff.js

@@ -22,36 +22,16 @@ TBD
 TBD
 `;
 }
-export function renderImplementationLogTemplate(taskSlug) {
-    return `# Implementation Log: ${taskSlug}
+export function renderKnownIssuesTemplate(taskSlug) {
+    return `# Known Issues: ${taskSlug}
 
-## Summary
-
-TBD
-
-## Files Changed
-
-TBD
-
-## Validation
+## Task Issues
 
-TBD
-
-## Deviations From Architecture Plan
-
-TBD
+No unresolved task issues recorded yet.
 
-## Follow-ups
+## Escalation To Docs
 
-TBD
-`;
-}
-export function renderValidationLogTemplate(taskSlug) {
-    return `# Validation Log: ${taskSlug}
-
-## Validation
-
-Not run yet.
+At task close, promote still-relevant confirmed issues to \`docs/known-issues.md\`; delete this task-local file with the rest of \`.ai/vcm/\` runtime state.
 `;
 }
 export function renderReviewReportTemplate(taskSlug) {
@@ -101,8 +81,66 @@ TBD
 
 TBD
 
+## Known Issues Disposition
+
+TBD
+
 ## Decision
 
+TBD
+`;
+}
+export function renderFinalAcceptanceTemplate(taskSlug) {
+    return `# Final Acceptance: ${taskSlug}
+
+## Decision
+
+TBD
+
+## Evidence Reviewed
+
+TBD
+
+## Scope Traceability
+
+### Expected Changes
+
+TBD
+
+### Supporting Changes
+
+TBD
+
+### Approved Deviations
+
+TBD
+
+### Unexplained Changes
+
+TBD
+
+### High-Risk Unexpected Changes
+
+TBD
+
+## Validation Summary
+
+TBD
+
+## Review And Docs Sync
+
+TBD
+
+## Known Issues Disposition
+
+TBD
+
+## Cleanup Readiness
+
+TBD
+
+## Final User Summary
+
 TBD
 `;
 }