vibe-coding-master 0.0.14 → 0.0.15

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

@@ -1,20 +1,24 @@
 import path from "node:path";
 import { randomUUID } from "node:crypto";
-import { ROLE_NAMES } from "../../shared/constants.js";
+import { ROLE_NAMES, isRoleName } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
-import { renderManualStagePrompt, renderMessageEnvelope } from "../templates/message-envelope.js";
+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 MARK_ALL_DONE_STATUSES = new Set([
+const OPEN_MESSAGE_STATUSES = new Set([
     "pending_approval",
     "queued",
-    "staged",
-    "delivering",
     "submitted",
-    "delivered",
+    "failed",
+    "delivery_failed",
+    "response_ready_missing_result"
+]);
+const MUTABLE_ROUTE_MESSAGE_STATUSES = new Set([
+    "pending_approval",
+    "queued",
     "failed",
     "delivery_failed",
     "response_ready_missing_result"
@@ -29,153 +33,145 @@ export function createMessageService(deps) {
             return {
                 taskSlug: input.taskSlug,
                 mode: "manual",
-                paused: false,
                 updatedAt: now()
             };
         }
-        return deps.fs.readJson(statePath);
+        const state = await deps.fs.readJson(statePath);
+        return {
+            taskSlug: state.taskSlug,
+            mode: state.mode,
+            updatedAt: state.updatedAt
+        };
     }
-    async function sendMessageLocked(input) {
+    async function scanLocked(input) {
         await deps.taskService.loadTask(input.repoRoot, input.taskSlug);
-        validateMessagePolicy(input.fromRole, input.toRole, input.type);
         const timestamp = now();
-        const message = {
-            id: id(),
-            taskSlug: input.taskSlug,
-            fromRole: input.fromRole,
-            toRole: input.toRole,
-            type: input.type,
-            body: input.body,
-            artifactRefs: input.artifactRefs ?? [],
-            parentMessageId: input.parentMessageId,
-            status: "queued",
-            createdAt: timestamp
-        };
-        message.bodyPath = await writeMessageBody(deps.fs, input.taskRepoRoot ?? input.repoRoot, input.handoffDir, message);
-        let messages = await readLatestMessages(deps.fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
-        if (isRoleActor(input.fromRole)) {
-            const acknowledged = acknowledgeActiveMessages(messages, input.fromRole, timestamp);
-            for (const acknowledgedMessage of acknowledged) {
-                await appendMessageSnapshot(deps.fs, input, acknowledgedMessage);
+        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);
             }
+            updates.push(...acknowledged);
             messages = applyMessageSnapshots(messages, acknowledged);
         }
-        const state = await getOrchestrationState(input);
-        const result = await routeOutboundMessage(input, message, messages, state, timestamp);
-        await appendMessageSnapshot(deps.fs, input, result.message);
-        if (isRoleActor(input.fromRole)) {
-            await deliverNextQueuedMessage(input, input.fromRole);
+        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);
+            results.push(result);
+            await appendMessageSnapshot(deps.fs, input, result.message);
+            messages = applyMessageSnapshots(messages, [result.message]);
+            if (result.delivered) {
+                deliveredTargets.add(routeFile.toRole);
+            }
         }
-        return result;
+        return results;
+    }
+    async function listPendingRouteFiles(input) {
+        const context = toRouteContext(input);
+        const all = await listRouteFiles(deps.fs, context);
+        return all.filter((routeFile) => routeFile.pending);
     }
-    async function routeOutboundMessage(input, message, existingMessages, state, timestamp) {
-        const session = await deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, input.toRole);
+    async function dispatchRouteFile(input, routeFile, existingMessages, 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") {
-            const queued = {
-                ...message,
-                status: "queued",
-                failureReason: `${input.toRole} session is not running.`
+            return {
+                message: {
+                    ...message,
+                    status: "queued",
+                    failureReason: `${routeFile.toRole} session is not running.`
+                },
+                delivered: false,
+                requiresUserApproval: false,
+                clearedRouteFile: false
             };
-            return { message: queued, delivered: false, requiresUserApproval: false };
         }
         if (state.mode === "manual") {
-            const pending = {
-                ...message,
-                status: "pending_approval"
-            };
-            return { message: pending, delivered: false, requiresUserApproval: true };
-        }
-        if (state.paused) {
-            const queued = {
-                ...message,
-                status: "queued",
-                failureReason: "Auto orchestration is paused."
+            return {
+                message: {
+                    ...message,
+                    status: "pending_approval"
+                },
+                delivered: false,
+                requiresUserApproval: true,
+                clearedRouteFile: false
             };
-            return { message: queued, delivered: false, requiresUserApproval: false };
         }
-        const activeMessage = findActiveMessageForRole(existingMessages, input.toRole);
+        const activeMessage = findActiveMessageForRole(existingMessages, routeFile.toRole);
         if (activeMessage) {
-            const queued = {
-                ...message,
-                status: "queued",
-                queuedBehindMessageId: activeMessage.id,
-                failureReason: `${input.toRole} is still handling VCM message ${activeMessage.id}.`
+            return {
+                message: {
+                    ...message,
+                    status: "queued",
+                    queuedBehindMessageId: activeMessage.id,
+                    failureReason: `${routeFile.toRole} is still handling VCM message ${activeMessage.id}.`
+                },
+                delivered: false,
+                requiresUserApproval: false,
+                clearedRouteFile: false
             };
-            return { message: queued, delivered: false, requiresUserApproval: false };
-        }
-        const delivered = await deliverMessageToSession(session.id, message, timestamp);
-        return { message: delivered, delivered: true, requiresUserApproval: false };
-    }
-    async function deliverNextQueuedMessage(input, targetRole) {
-        const state = await getOrchestrationState(input);
-        if (state.mode !== "auto" || state.paused) {
-            return undefined;
-        }
-        const messages = await readLatestMessages(deps.fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
-        if (findActiveMessageForRole(messages, targetRole)) {
-            return undefined;
-        }
-        const nextMessage = messages.find((message) => message.toRole === targetRole && message.status === "queued");
-        if (!nextMessage) {
-            return undefined;
         }
-        const session = await deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, targetRole);
-        if (!session || session.status !== "running") {
-            return undefined;
-        }
-        const delivered = await deliverMessageToSession(session.id, nextMessage, now());
-        await appendMessageSnapshot(deps.fs, input, delivered);
-        return delivered;
-    }
-    async function deliverMessageToSession(sessionId, message, timestamp) {
-        const delivering = {
+        const submitted = {
             ...message,
-            status: "delivering",
+            status: "submitted",
             deliveredAt: timestamp,
-            queuedBehindMessageId: undefined,
-            failureReason: undefined
+            submittedAt: timestamp
+        };
+        await submitTerminalInput(deps.runtime, session.id, renderMessageEnvelope(submitted));
+        await deps.sessionService.markRoleActivityRunning(input.repoRoot, input.taskSlug, routeFile.toRole);
+        await deps.fs.writeText(resolveRepoPath(input.taskRepoRoot ?? input.repoRoot, routeFile.path), "");
+        return {
+            message: submitted,
+            delivered: true,
+            requiresUserApproval: false,
+            clearedRouteFile: true
         };
-        await submitTerminalInput(deps.runtime, sessionId, renderMessageEnvelope(delivering));
-        return delivering;
     }
     return {
         listMessages(input) {
             return readLatestMessages(deps.fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
         },
-        async sendMessage(input) {
-            return withTaskLock(taskLocks, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), () => sendMessageLocked(input));
+        listPendingRouteFiles(input) {
+            return listPendingRouteFiles(input);
         },
-        async confirmPromptSubmitted(input) {
-            const messageId = extractSubmittedMessageId(input.prompt);
-            if (!messageId) {
-                return undefined;
-            }
-            const messages = await readLatestMessages(deps.fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
-            const message = messages.find((candidate) => candidate.id === messageId && candidate.toRole === input.role);
-            if (!message) {
-                return undefined;
-            }
-            if (message.status === "submitted" || message.status === "acknowledged") {
-                return message;
-            }
-            if (!isSubmittableMessageStatus(message.status)) {
-                return undefined;
-            }
-            const submitted = {
-                ...message,
-                status: "submitted",
-                submittedAt: now(),
-                failureReason: undefined
-            };
-            await appendMessageSnapshot(deps.fs, input, submitted);
-            return submitted;
+        async scanAndDispatchPendingRouteFiles(input) {
+            return withTaskLock(taskLocks, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), () => scanLocked(input));
         },
         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) => MARK_ALL_DONE_STATUSES.has(message.status))
+                    .filter((message) => OPEN_MESSAGE_STATUSES.has(message.status))
                     .map((message) => ({
                     ...message,
                     status: "acknowledged",
@@ -186,6 +182,11 @@ export function createMessageService(deps) {
                 for (const message of updated) {
                     await appendMessageSnapshot(deps.fs, input, message);
                 }
+                if (input.clearRouteFiles) {
+                    for (const routeFile of await listPendingRouteFiles(input)) {
+                        await deps.fs.writeText(resolveRepoPath(input.taskRepoRoot ?? input.repoRoot, routeFile.path), "");
+                    }
+                }
                 const latest = applyMessageSnapshots(messages, updated);
                 return {
                     taskSlug: input.taskSlug,
@@ -194,40 +195,6 @@ export function createMessageService(deps) {
                 };
             });
         },
-        async stageMessage(input) {
-            const message = await getMessageOrThrow(deps.fs, input);
-            const session = await deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, message.toRole);
-            if (!session || session.status !== "running") {
-                throw new VcmError({
-                    code: "MESSAGE_TARGET_NOT_RUNNING",
-                    message: `${message.toRole} session is not running.`,
-                    statusCode: 409,
-                    hint: `Start the ${message.toRole} session before staging this message.`
-                });
-            }
-            const staged = {
-                ...message,
-                status: "staged",
-                stagedAt: now(),
-                failureReason: undefined
-            };
-            deps.runtime.write(session.id, renderManualStagePrompt(staged));
-            await appendMessageSnapshot(deps.fs, input, staged);
-            return staged;
-        },
-        approveMessage(input) {
-            return this.stageMessage(input);
-        },
-        async rejectMessage(input) {
-            const message = await getMessageOrThrow(deps.fs, input);
-            const rejected = {
-                ...message,
-                status: "rejected",
-                failureReason: undefined
-            };
-            await appendMessageSnapshot(deps.fs, input, rejected);
-            return rejected;
-        },
         async getOrchestrationState(input) {
             return getOrchestrationState(input);
         },
@@ -236,7 +203,6 @@ export function createMessageService(deps) {
             const next = {
                 ...current,
                 mode: input.mode ?? current.mode,
-                paused: input.paused ?? current.paused,
                 updatedAt: now()
             };
             await deps.fs.writeJsonAtomic(getOrchestrationStatePath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), next);
@@ -244,6 +210,132 @@ export function createMessageService(deps) {
         }
     };
 }
+function toRouteContext(input) {
+    return {
+        repoRoot: input.repoRoot,
+        taskRepoRoot: input.taskRepoRoot,
+        handoffDir: input.handoffDir
+    };
+}
+async function listRouteFiles(fs, input) {
+    const repoRoot = input.taskRepoRoot ?? input.repoRoot;
+    const routeDir = path.posix.join(input.handoffDir, "messages");
+    const absoluteMessagesDir = resolveRepoPath(repoRoot, routeDir);
+    if (!(await fs.pathExists(absoluteMessagesDir))) {
+        return [];
+    }
+    const entries = await fs.readDir(absoluteMessagesDir);
+    const routeFiles = [];
+    for (const entry of entries.filter((candidate) => candidate.endsWith(".md")).sort()) {
+        const route = parseRouteFileName(entry);
+        if (!route) {
+            continue;
+        }
+        const relativePath = path.posix.join(routeDir, entry);
+        const content = await fs.readText(resolveRepoPath(repoRoot, relativePath));
+        const parsed = parseRouteFileContent(content, route.fromRole, route.toRole);
+        routeFiles.push({
+            path: relativePath,
+            fromRole: route.fromRole,
+            toRole: route.toRole,
+            type: parsed.type,
+            body: parsed.body,
+            artifactRefs: parsed.artifactRefs,
+            exists: true,
+            pending: parsed.body.trim().length > 0
+        });
+    }
+    return routeFiles;
+}
+function parseRouteFileName(fileName) {
+    for (const fromRole of ROLE_NAMES) {
+        for (const toRole of ROLE_NAMES) {
+            if (fromRole === toRole) {
+                continue;
+            }
+            if (fileName === `${fromRole}-${toRole}.md`) {
+                return { fromRole, toRole };
+            }
+        }
+    }
+    return undefined;
+}
+function parseRouteFileContent(content, fromRole, toRole) {
+    const { frontmatter, body } = splitFrontmatter(content);
+    const type = parseMessageType(frontmatter.type) ?? getDefaultMessageType(fromRole, toRole);
+    const artifactRefs = parseArtifactRefs(frontmatter);
+    return {
+        type,
+        body: body.trim(),
+        artifactRefs
+    };
+}
+function splitFrontmatter(content) {
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+    if (!match) {
+        return { frontmatter: {}, body: content };
+    }
+    const frontmatter = {};
+    for (const line of match[1].split(/\r?\n/)) {
+        const delimiter = line.indexOf(":");
+        if (delimiter <= 0) {
+            continue;
+        }
+        const key = line.slice(0, delimiter).trim();
+        const value = line.slice(delimiter + 1).trim();
+        if (key) {
+            frontmatter[key] = value;
+        }
+    }
+    return {
+        frontmatter,
+        body: content.slice(match[0].length)
+    };
+}
+function parseMessageType(value) {
+    const validTypes = [
+        "user-request",
+        "task",
+        "question",
+        "blocked",
+        "result",
+        "finding",
+        "review-request",
+        "revise",
+        "cancel"
+    ];
+    return value && validTypes.includes(value)
+        ? value
+        : undefined;
+}
+function parseArtifactRefs(frontmatter) {
+    const refs = frontmatter.artifact_refs ?? frontmatter.artifactRefs ?? frontmatter.related_artifact;
+    if (!refs) {
+        return [];
+    }
+    return refs
+        .split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+}
+function getDefaultMessageType(fromRole, toRole) {
+    if (fromRole === PM_ROLE && toRole !== PM_ROLE) {
+        return "task";
+    }
+    if (fromRole !== PM_ROLE && toRole === PM_ROLE) {
+        return "result";
+    }
+    return "question";
+}
+function selectDispatchCandidates(routeFiles, stoppedRole) {
+    const candidates = stoppedRole
+        ? routeFiles.filter((routeFile) => routeFile.fromRole === stoppedRole || routeFile.toRole === stoppedRole)
+        : routeFiles;
+    return [...candidates].sort((left, right) => {
+        const updated = (left.updatedAt ?? "").localeCompare(right.updatedAt ?? "");
+        return updated !== 0 ? updated : left.path.localeCompare(right.path);
+    });
+}
 function validateMessagePolicy(fromRole, toRole, type) {
     if (!ROLE_NAMES.includes(toRole)) {
         throw new VcmError({
@@ -252,17 +344,7 @@ function validateMessagePolicy(fromRole, toRole, type) {
             statusCode: 400
         });
     }
-    if (fromRole === "user") {
-        if (toRole === PM_ROLE && type === "user-request") {
-            return;
-        }
-        throw new VcmError({
-            code: "MESSAGE_POLICY_DENIED",
-            message: "User messages can only target project-manager as user-request.",
-            statusCode: 403
-        });
-    }
-    if (!ROLE_NAMES.includes(fromRole)) {
+    if (!isRoleName(String(fromRole))) {
         throw new VcmError({
             code: "MESSAGE_SENDER_UNKNOWN",
             message: `Unknown sender role: ${fromRole}`,
@@ -279,7 +361,7 @@ function validateMessagePolicy(fromRole, toRole, type) {
         code: "MESSAGE_POLICY_DENIED",
         message: `${fromRole} cannot send ${type} messages to ${toRole}.`,
         statusCode: 403,
-        hint: "Use project-manager as the orchestration hub."
+        hint: "Use project-manager as the orchestration hub unless this task explicitly allows a peer route."
     });
 }
 async function withTaskLock(locks, key, run) {
@@ -295,15 +377,18 @@ async function withTaskLock(locks, key, run) {
         }
     }
 }
-function isRoleActor(actor) {
-    return ROLE_NAMES.includes(actor);
+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 && isActiveMessageStatus(message.status));
+    return messages.find((message) => message.toRole === role &&
+        message.status === "submitted");
 }
 function acknowledgeActiveMessages(messages, role, timestamp) {
     return messages
-        .filter((message) => message.toRole === role && isActiveMessageStatus(message.status))
+        .filter((message) => message.toRole === role && message.status === "submitted")
         .map((message) => ({
         ...message,
         status: "acknowledged",
@@ -311,16 +396,6 @@ function acknowledgeActiveMessages(messages, role, timestamp) {
         failureReason: undefined
     }));
 }
-function isActiveMessageStatus(status) {
-    return status === "delivering" || status === "submitted" || status === "delivered" || status === "staged";
-}
-function isSubmittableMessageStatus(status) {
-    return status === "delivering" || status === "delivered" || status === "staged" || status === "pending_approval";
-}
-function extractSubmittedMessageId(prompt) {
-    const match = prompt.match(/\bmsg_[A-Za-z0-9_-]+\b/);
-    return match?.[0];
-}
 function applyMessageSnapshots(messages, snapshots) {
     if (snapshots.length === 0) {
         return messages;
@@ -331,43 +406,6 @@ function applyMessageSnapshots(messages, snapshots) {
     }
     return [...latest.values()].sort((left, right) => left.createdAt.localeCompare(right.createdAt));
 }
-async function writeMessageBody(fs, repoRoot, handoffDir, message) {
-    const bodyPath = path.posix.join(handoffDir, "messages", `${message.id}.md`);
-    await fs.writeText(resolveRepoPath(repoRoot, bodyPath), renderMessageBodyFile(message));
-    return bodyPath;
-}
-function renderMessageBodyFile(message) {
-    const artifactRefs = message.artifactRefs.length > 0
-        ? message.artifactRefs.map((artifact) => `- ${artifact}`).join("\n")
-        : "- none";
-    return `# VCM Message ${message.id}
-
-- Task: ${message.taskSlug}
-- From: ${message.fromRole}
-- To: ${message.toRole}
-- Type: ${message.type}
-
-## Body
-
-${message.body}
-
-## Artifact Refs
-
-${artifactRefs}
-`;
-}
-async function getMessageOrThrow(fs, input) {
-    const messages = await readLatestMessages(fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
-    const message = messages.find((candidate) => candidate.id === input.messageId);
-    if (!message) {
-        throw new VcmError({
-            code: "MESSAGE_MISSING",
-            message: `Message does not exist: ${input.messageId}`,
-            statusCode: 404
-        });
-    }
-    return message;
-}
 async function readLatestMessages(fs, messagesPath) {
     if (!(await fs.pathExists(messagesPath))) {
         return [];

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

@@ -96,12 +96,12 @@ function toRoleTurnState(role, sessions) {
 }
 function getLatestDeliveredMessage(messages) {
     return messages
-        .filter((message) => message.status === "delivering" || message.status === "submitted" || message.status === "delivered" || message.status === "staged")
+        .filter((message) => message.status === "submitted")
         .sort((left, right) => getMessageDeliveredAt(left).localeCompare(getMessageDeliveredAt(right)))
         .at(-1);
 }
 function getMessageDeliveredAt(message) {
-    return message?.submittedAt ?? message?.deliveredAt ?? message?.stagedAt ?? message?.createdAt ?? "";
+    return message?.submittedAt ?? message?.deliveredAt ?? message?.createdAt ?? "";
 }
 function getCompletedAtForDelivery(roleState, deliveredAt) {
     if (roleState.status !== "idle" || !roleState.lastAnswerEndedAt) {

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

@@ -41,9 +41,9 @@ export function createSessionService(deps) {
             cwd: taskRepoRoot,
             env: {
                 VCM_API_URL: deps.apiUrl,
-                VCM_CTL_COMMAND: deps.vcmctlCommand,
                 VCM_TASK_SLUG: taskSlug,
-                VCM_ROLE: role
+                VCM_ROLE: role,
+                VCM_SESSION_ID: claudeSessionId
             },
             cols: input.cols,
             rows: input.rows,
@@ -165,14 +165,9 @@ export function createSessionService(deps) {
             const timestamp = now();
             const updated = {
                 ...current,
-                activityStatus: input.eventName === "UserPromptSubmit" ? "running" : "idle",
+                activityStatus: "idle",
                 lastHookEventAt: timestamp,
-                lastPromptSubmittedAt: input.eventName === "UserPromptSubmit"
-                    ? timestamp
-                    : current.lastPromptSubmittedAt,
-                lastStopAt: input.eventName === "Stop"
-                    ? timestamp
-                    : current.lastStopAt,
+                lastStopAt: timestamp,
                 updatedAt: timestamp
             };
             deps.registry.upsert(updated);
@@ -180,6 +175,25 @@ export function createSessionService(deps) {
             const task = await deps.taskService.loadTask(repoRoot, input.taskSlug);
             await persistTaskSession(deps.fs, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
             return updated;
+        },
+        async markRoleActivityRunning(repoRoot, taskSlug, role) {
+            const current = await this.getRoleSession(repoRoot, taskSlug, role);
+            if (!current) {
+                return undefined;
+            }
+            const timestamp = now();
+            const updated = {
+                ...current,
+                activityStatus: "running",
+                lastPromptSubmittedAt: timestamp,
+                lastHookEventAt: timestamp,
+                updatedAt: timestamp
+            };
+            deps.registry.upsert(updated);
+            const config = await deps.projectService.loadConfig(repoRoot);
+            const task = await deps.taskService.loadTask(repoRoot, taskSlug);
+            await persistTaskSession(deps.fs, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
+            return updated;
         }
     };
 }

package/dist/backend/templates/handoff.js

@@ -106,3 +106,6 @@ TBD
 TBD
 `;
 }
+export function renderMessageRouteTemplate() {
+    return "";
+}