vibe-coding-master 0.8.1 → 0.8.2

package/dist/backend/gateway/gateway-service.js

@@ -1,3 +1,4 @@
+import { getRoleDefinition, isVcmRoleName, VCM_ROLE_NAMES } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
@@ -14,7 +15,7 @@ const DEFAULT_POLL_TIMEOUT_MS = 35_000;
 const LARK_REGISTRATION_CONFIRM_TIMEOUT_MS = 15_000;
 const GATEWAY_ROUND_FINAL_WAIT_MS = 12_000;
 const GATEWAY_ROUND_FINAL_POLL_MS = 250;
-const GATEWAY_TRANSLATION_FAILURE_TEXT = "PM 回复已收到，但翻译失败。\n发送 /retry 重新翻译。";
+const GATEWAY_TRANSLATION_FAILURE_TEXT = "角色回复已收到，但翻译失败。\n发送 /retry 重新翻译。";
 const COMMANDS_ALLOWED_WHEN_DISABLED = new Set([
     "help",
     "start",
@@ -33,7 +34,7 @@ export function createGatewayService(deps) {
     let qrLogin = null;
     let larkRegistrationState = null;
     let lastFailedTranslation = null;
-    let lastPmInputMessageId = null;
+    let lastGatewayInputMessageId = null;
     // Runtime channel-connection arming switch. Not persisted: every process starts
     // disarmed. `ensurePolling` is the single chokepoint that reads it, so no
     // self-heal path can connect the channel while this is false.
@@ -257,7 +258,7 @@ export function createGatewayService(deps) {
     }
     async function handlePlainInbound(update, text) {
         try {
-            const target = await resolvePlainTextPmTarget(text);
+            const target = await resolvePlainTextRoleTarget(text);
             if (typeof target === "string") {
                 await reply(await deps.settings.loadSettings(), update.fromUserId, target);
                 await recordInbound(update, "ok", "plain");
@@ -267,16 +268,16 @@ export function createGatewayService(deps) {
                 await reply(await deps.settings.loadSettings(), update.fromUserId, "已收到，正在翻译...");
             }
             else {
-                await reply(await deps.settings.loadSettings(), update.fromUserId, "已收到，正在发送给 PM...");
+                await reply(await deps.settings.loadSettings(), update.fromUserId, `已收到，正在发送给 ${roleLabel(target.role)}...`);
             }
             const englishText = target.settings.translationEnabled
-                ? await translatePlainTextForPm(target, text, update)
+                ? await translatePlainTextForRole(target, text, update)
                 : text;
             await submitTerminalInput(deps.runtime, target.session.id, englishText);
-            lastPmInputMessageId = update.messageId;
+            lastGatewayInputMessageId = update.messageId;
             await reply(await deps.settings.loadSettings(), update.fromUserId, target.settings.translationEnabled
-                ? formatGatewayInputTranslationSuccess(englishText)
-                : "已发送给 PM。");
+                ? formatGatewayInputTranslationSuccess(target.role, englishText)
+                : `已发送给 ${roleLabel(target.role)}。`);
             await recordInbound(update, "ok", "plain");
         }
         catch (error) {
@@ -288,13 +289,13 @@ export function createGatewayService(deps) {
             await recordInbound(update, "error", "plain", message);
         }
     }
-    async function translatePlainTextForPm(target, text, update) {
+    async function translatePlainTextForRole(target, text, update) {
         try {
             return (await deps.translationService.translateUserInput({
                 repoRoot: target.project.repoRoot,
                 taskRepoRoot: getTaskRuntimeRepoRoot(target.task),
                 taskSlug: target.task.taskSlug,
-                role: "project-manager",
+                role: target.role,
                 text,
                 useContext: false,
                 send: false
@@ -302,7 +303,7 @@ export function createGatewayService(deps) {
         }
         catch (error) {
             const message = errorMessage(error);
-            await reply(await deps.settings.loadSettings(), update.fromUserId, formatGatewayInputTranslationFailure(message));
+            await reply(await deps.settings.loadSettings(), update.fromUserId, formatGatewayInputTranslationFailure(target.role, message));
             await recordInbound(update, "error", "plain", message);
             throw new HandledGatewayInboundError();
         }
@@ -357,7 +358,7 @@ export function createGatewayService(deps) {
             return [
                 "Gateway is connected but off.",
                 "Available commands while off: /help, /start, /status, /projects, /tasks.",
-                "Turn Gateway on in desktop VCM to send PM messages or run task-changing commands."
+                "Turn Gateway on in desktop VCM to send role messages or run task-changing commands."
             ].join("\n");
         }
         switch (command.kind) {
@@ -387,8 +388,10 @@ export function createGatewayService(deps) {
                 return closeTaskConfirm(command.taskSlug);
             case "translate":
                 return setGatewayTranslation(command.enabled);
+            case "role":
+                return command.role ? setGatewayTargetRole(command.role) : gatewayRoleText(settings);
             case "plain":
-                return sendPlainTextToPm(command.text);
+                return sendPlainTextToRole(command.text);
             case "unknown":
                 return `Unknown command: ${command.name}. Send /help for available commands.`;
         }
@@ -410,6 +413,8 @@ export function createGatewayService(deps) {
             await deps.settings.saveSettings({
                 ...settings,
                 currentProjectId: project.repoRoot,
+                currentTaskSlug: null,
+                targetRole: "project-manager",
                 updatedAt: now()
             });
         }
@@ -433,6 +438,7 @@ export function createGatewayService(deps) {
             ...settings,
             currentProjectId: project.repoRoot,
             currentTaskSlug: nextTaskSlug,
+            targetRole: "project-manager",
             updatedAt: now()
         });
     }
@@ -461,6 +467,7 @@ export function createGatewayService(deps) {
             ...settings,
             currentProjectId: project.repoRoot,
             currentTaskSlug: null,
+            targetRole: "project-manager",
             updatedAt: now()
         });
         return `Selected project:\n${project.repoRoot}\nbranch: ${project.branch}\ncommit: ${project.shortHeadCommit ?? project.headCommit ?? "unknown"}`;
@@ -501,6 +508,7 @@ export function createGatewayService(deps) {
         await deps.settings.saveSettings({
             ...settings,
             currentTaskSlug: task.taskSlug,
+            targetRole: "project-manager",
             updatedAt: now()
         });
         return `Selected task: ${task.taskSlug}\nstatus: ${task.status}\nbranch: ${task.branch}`;
@@ -520,6 +528,7 @@ export function createGatewayService(deps) {
                 ...settings,
                 currentProjectId: project.repoRoot,
                 currentTaskSlug: task.taskSlug,
+                targetRole: "project-manager",
                 translationEnabled: preferences.translationEnabled,
                 updatedAt: now()
             });
@@ -608,12 +617,13 @@ export function createGatewayService(deps) {
         }
         const result = await deps.taskCloseService.closeTask(project.repoRoot, taskSlug);
         clearFailedTranslation(project.repoRoot, taskSlug);
-        const latestPmReplies = { ...settings.latestPmReplies };
-        delete latestPmReplies[latestPmReplyKey(project.repoRoot, taskSlug)];
+        const latestRoleReplies = Object.fromEntries(Object.entries(settings.latestRoleReplies)
+            .filter(([, reply]) => reply.repoRoot !== project.repoRoot || reply.taskSlug !== taskSlug));
         await deps.settings.saveSettings({
             ...settings,
             currentTaskSlug: null,
-            latestPmReplies,
+            targetRole: "project-manager",
+            latestRoleReplies,
             pendingConfirmations: {
                 ...settings.pendingConfirmations,
                 closeTask: null
@@ -673,19 +683,20 @@ export function createGatewayService(deps) {
         await ensurePolling();
         const lines = [
             "Gateway started.",
-            "Full mobile commands and PM messages are now enabled.",
+            "Full mobile commands and role messages are now enabled.",
             `Project: ${enabled.currentProjectId ?? "none"}`,
-            `Task: ${enabled.currentTaskSlug ?? "none"}`
+            `Task: ${enabled.currentTaskSlug ?? "none"}`,
+            `Role: ${roleLabel(enabled.targetRole)}`
         ];
-        const latestReply = getLatestPmReply(enabled);
+        const latestReply = getLatestRoleReply(enabled);
         if (latestReply) {
-            const rendered = await renderLatestPmReply(enabled, latestReply);
-            lines.push("", "Latest PM reply:", rendered.text);
+            const rendered = await renderLatestRoleReply(enabled, latestReply);
+            lines.push("", `Latest ${roleLabel(enabled.targetRole)} reply:`, rendered.text);
         }
         return lines.join("\n");
     }
-    async function sendPlainTextToPm(text) {
-        const target = await resolvePlainTextPmTarget(text);
+    async function sendPlainTextToRole(text) {
+        const target = await resolvePlainTextRoleTarget(text);
         if (typeof target === "string") {
             return target;
         }
@@ -694,16 +705,16 @@ export function createGatewayService(deps) {
                 repoRoot: target.project.repoRoot,
                 taskRepoRoot: getTaskRuntimeRepoRoot(target.task),
                 taskSlug: target.task.taskSlug,
-                role: "project-manager",
+                role: target.role,
                 text,
                 useContext: false,
                 send: false
             })).englishPreview
             : text;
         await submitTerminalInput(deps.runtime, target.session.id, englishText);
-        return "Sent to PM.";
+        return `Sent to ${roleLabel(target.role)}.`;
     }
-    async function resolvePlainTextPmTarget(text) {
+    async function resolvePlainTextRoleTarget(text) {
         if (!text.trim()) {
             return "Empty message ignored.";
         }
@@ -717,18 +728,51 @@ export function createGatewayService(deps) {
             });
         }
         const task = await deps.taskService.loadTask(project.repoRoot, settings.currentTaskSlug);
-        const session = await deps.sessionService.getRoleSession(project.repoRoot, task.taskSlug, "project-manager");
+        const role = settings.targetRole;
+        const session = await deps.sessionService.getRoleSession(project.repoRoot, task.taskSlug, role);
         if (!session || session.status !== "running") {
             throw new VcmError({
-                code: "PM_SESSION_NOT_RUNNING",
-                message: "The current task's PM session is not running.",
+                code: "GATEWAY_TARGET_SESSION_NOT_RUNNING",
+                message: `The current task's ${roleLabel(role)} session is not running.`,
                 statusCode: 409
             });
         }
         if (session.activityStatus === "running") {
-            return "PM is still working on the current turn. Please wait and send again later.";
+            return `${roleLabel(role)} is still working on the current turn. Please wait and send again later.`;
         }
-        return { project, task, session, settings };
+        return { project, task, session, role, settings };
+    }
+    async function setGatewayTargetRole(role) {
+        const project = await ensureProject();
+        const settings = await syncDesktopContext(await deps.settings.loadSettings());
+        if (!settings.currentTaskSlug) {
+            throw new VcmError({
+                code: "TASK_NOT_SELECTED",
+                message: "No task is selected. Use /tasks and /use-task first.",
+                statusCode: 409
+            });
+        }
+        await deps.taskService.loadTask(project.repoRoot, settings.currentTaskSlug);
+        const updated = await deps.settings.updateSettings({ targetRole: role });
+        return `Gateway role: ${roleLabel(updated.targetRole)}.`;
+    }
+    async function gatewayRoleText(settings) {
+        const synced = await syncDesktopContext(settings);
+        const lines = [`Current Gateway role: ${roleLabel(synced.targetRole)}.`, "Available roles:"];
+        for (const role of VCM_ROLE_NAMES) {
+            let status = "not started";
+            if (synced.currentProjectId && synced.currentTaskSlug) {
+                try {
+                    const session = await deps.sessionService.getRoleSession(synced.currentProjectId, synced.currentTaskSlug, role);
+                    status = session?.status ?? status;
+                }
+                catch {
+                    status = "missing";
+                }
+            }
+            lines.push(`- ${gatewayRoleCommandName(role)} [${status}]`);
+        }
+        return lines.join("\n");
     }
     async function reply(settings, userId, text) {
         await sendGatewayText(settings, userId, text);
@@ -766,9 +810,20 @@ export function createGatewayService(deps) {
     }
     async function exposeStatus(settings) {
         const preferences = await deps.appSettings.getPreferences();
+        let targetRoleSessionStatus = null;
+        if (settings.currentProjectId && settings.currentTaskSlug) {
+            try {
+                const session = await deps.sessionService.getRoleSession(settings.currentProjectId, settings.currentTaskSlug, settings.targetRole);
+                targetRoleSessionStatus = session?.status ?? "not_started";
+            }
+            catch {
+                targetRoleSessionStatus = "missing";
+            }
+        }
         return {
             ...deps.settings.expose(settings, isRunning(), connectionEnabled),
-            lastPmInputMessageId,
+            targetRoleSessionStatus,
+            lastGatewayInputMessageId,
             pauseAlertSoundEnabled: preferences.flowPauseAlerts
         };
     }
@@ -784,6 +839,7 @@ export function createGatewayService(deps) {
             `Translation: ${synced.translationEnabled ? "on" : "off"}`,
             `Project: ${project?.repoRoot ?? synced.currentProjectId ?? "none"}`,
             `Task: ${synced.currentTaskSlug ?? "none"}`,
+            `Role: ${roleLabel(synced.targetRole)}`,
             `Last poll: ${synced.lastPollStatus.state}${synced.lastPollStatus.error ? ` (${synced.lastPollStatus.error})` : ""}`
         ].join("\n");
     }
@@ -803,7 +859,10 @@ export function createGatewayService(deps) {
             return exposeStatus(settings);
         },
         async updateSettings(input) {
-            const currentSettings = await deps.settings.loadSettings();
+            let currentSettings = await deps.settings.loadSettings();
+            if (input.enabled === true || currentSettings.enabled) {
+                currentSettings = await syncDesktopContext(currentSettings);
+            }
             const enablingGateway = input.enabled === true && !currentSettings.enabled;
             const gatewayStartInput = input.enabled === true
                 ? { ...input, translationEnabled: true }
@@ -818,9 +877,6 @@ export function createGatewayService(deps) {
                 await enableGatewayTranslationRuntime({ disablePauseAlertSound: enablingGateway });
             }
             let settings = await deps.settings.updateSettings(updateInput);
-            if (settings.enabled) {
-                settings = await syncDesktopContext(settings);
-            }
             if (toAccount(settings)) {
                 await ensurePolling();
             }
@@ -1095,8 +1151,15 @@ export function createGatewayService(deps) {
                 gatewayStatus: status
             };
         },
-        async handlePmStop(input) {
-            if (input.session.role !== "project-manager") {
+        async handleRoleStop(input) {
+            if (!isVcmRoleName(input.session.role)) {
+                return;
+            }
+            const role = input.session.role;
+            const settings = await syncDesktopContext(await deps.settings.loadSettings());
+            if (settings.currentProjectId !== input.repoRoot
+                || settings.currentTaskSlug !== input.taskSlug
+                || settings.targetRole !== role) {
                 return;
             }
             const transcriptPath = resolveExistingClaudeTranscriptPath(input.session);
@@ -1104,46 +1167,52 @@ export function createGatewayService(deps) {
                 return;
             }
             const events = await readTranscriptTextEvents(transcriptPath);
-            const round = await waitForGatewayRoundFinal(input.repoRoot, input.taskSlug);
+            const round = await waitForGatewayRoundFinal(input.repoRoot, input.taskSlug, role);
             if (!round) {
                 return;
             }
-            const cursorKey = `${input.taskSlug}:project-manager:${input.session.claudeSessionId}`;
-            const settings = await deps.settings.loadSettings();
-            const cursor = settings.pushCursors[cursorKey];
+            const latestSettings = await syncDesktopContext(await deps.settings.loadSettings());
+            if (latestSettings.currentProjectId !== input.repoRoot
+                || latestSettings.currentTaskSlug !== input.taskSlug
+                || latestSettings.targetRole !== role) {
+                return;
+            }
+            const cursorKey = `${input.taskSlug}:${role}:${input.session.claudeSessionId}`;
+            const cursor = latestSettings.pushCursors[cursorKey];
             const nextEvents = selectEventsAfterCursor(events, cursor?.lastTranscriptEventId)
                 .filter(isFinalTurnTextEvent);
             if (nextEvents.length === 0) {
                 return;
             }
-            const latestReply = toGatewayPmReply(nextEvents[nextEvents.length - 1]);
+            const latestReply = toGatewayRoleReply(nextEvents[nextEvents.length - 1]);
             const text = latestReply.text.trim();
             if (!text) {
                 return;
             }
-            await saveLatestPmReply(input, latestReply);
-            const account = toAccount(settings);
-            const boundUserId = settings.binding.boundUserId;
+            await saveLatestRoleReply(input, latestReply);
+            const account = toAccount(latestSettings);
+            const boundUserId = latestSettings.binding.boundUserId;
             // A disarmed gateway never touches the channel: skip the outbound push.
-            // The round-final PM reply was already cached above and replays on the next /start.
-            if (!connectionEnabled || !settings.enabled || !account || !boundUserId) {
+            // The selected role's round-final reply was already cached above and replays on the next /start.
+            if (!connectionEnabled || !latestSettings.enabled || !account || !boundUserId) {
                 return;
             }
             const roundNotice = formatGatewayRoundNotice(round);
-            const originalMessage = formatGatewayPmOriginalReply(text, roundNotice);
-            await sendGatewayText(settings, boundUserId, originalMessage);
+            const originalMessage = formatGatewayRoleOriginalReply(role, text, roundNotice);
+            await sendGatewayText(latestSettings, boundUserId, originalMessage);
             let output;
-            if (settings.translationEnabled) {
-                output = await renderGatewayPmOutput({
-                    settings,
+            if (latestSettings.translationEnabled) {
+                output = await renderGatewayRoleOutput({
+                    settings: latestSettings,
                     repoRoot: input.repoRoot,
                     taskSlug: input.taskSlug,
+                    role,
                     sourceText: text,
                     sourceEntryIds: latestReply.transcriptEventId ? [latestReply.transcriptEventId] : undefined
                 });
-                await sendGatewayText(settings, boundUserId, output.translationFailed
-                    ? formatGatewayPmTranslationFailure(output.translationError)
-                    : formatGatewayPmTranslatedReply(output.text));
+                await sendGatewayText(latestSettings, boundUserId, output.translationFailed
+                    ? formatGatewayRoleTranslationFailure(role, output.translationError)
+                    : formatGatewayRoleTranslatedReply(role, output.text));
             }
             else {
                 clearFailedTranslation(input.repoRoot, input.taskSlug);
@@ -1162,16 +1231,16 @@ export function createGatewayService(deps) {
                     checkedAt: now(),
                     direction: "outbound",
                     result: output?.translationFailed ? "error" : "ok",
-                    command: "pm-stop",
+                    command: `${role}-stop`,
                     preview: (output?.text ?? originalMessage).slice(0, 160),
                     error: output?.translationError
                 },
                 updatedAt: now()
             });
             await deps.audit.record({
-                type: "gateway.pm_push",
+                type: "gateway.role_push",
                 result: output?.translationFailed ? "error" : "ok",
-                command: "pm-stop",
+                command: `${role}-stop`,
                 preview: output ? `${originalMessage}\n\n${output.text}` : originalMessage,
                 error: output?.translationError
             });
@@ -1216,17 +1285,17 @@ export function createGatewayService(deps) {
             };
         }
     };
-    function getLatestPmReply(settings) {
+    function getLatestRoleReply(settings) {
         if (!settings.currentProjectId || !settings.currentTaskSlug) {
             return undefined;
         }
-        return settings.latestPmReplies[latestPmReplyKey(settings.currentProjectId, settings.currentTaskSlug)];
+        return settings.latestRoleReplies[latestRoleReplyKey(settings.currentProjectId, settings.currentTaskSlug, settings.targetRole)];
     }
-    async function waitForGatewayRoundFinal(repoRoot, taskSlug) {
+    async function waitForGatewayRoundFinal(repoRoot, taskSlug, role) {
         const startedAt = Date.now();
         while (Date.now() - startedAt <= GATEWAY_ROUND_FINAL_WAIT_MS) {
             const round = await getGatewayRoundState(repoRoot, taskSlug);
-            if (round && isGatewayRoundFinal(round)) {
+            if (round && isGatewayRoundFinal(round) && round.activeRole === role) {
                 return round;
             }
             if (round && isGatewayNonFinalTerminalRound(round)) {
@@ -1295,47 +1364,48 @@ export function createGatewayService(deps) {
         const trimmed = value.trim();
         return trimmed.length > 600 ? `${trimmed.slice(0, 600)}...` : trimmed;
     }
-    function formatGatewayPmOriginalReply(text, roundNotice) {
+    function formatGatewayRoleOriginalReply(role, text, roundNotice) {
         return [
-            "PM final reply 原文：",
+            `${roleLabel(role)} Round Final Reply 原文：`,
             "",
             text.trim(),
             roundNotice ? "" : undefined,
             roundNotice ? `Round: ${roundNotice}` : undefined
         ].filter((line) => line !== undefined).join("\n");
     }
-    function formatGatewayPmTranslatedReply(text) {
+    function formatGatewayRoleTranslatedReply(role, text) {
         return [
-            "PM final reply 翻译：",
+            `${roleLabel(role)} Round Final Reply 翻译：`,
             "",
             text.trim()
         ].join("\n");
     }
-    function formatGatewayPmTranslationFailure(error) {
+    function formatGatewayRoleTranslationFailure(role, error) {
         return [
-            GATEWAY_TRANSLATION_FAILURE_TEXT,
+            `${roleLabel(role)} ${GATEWAY_TRANSLATION_FAILURE_TEXT}`,
             error ? `原因：${error}` : undefined
         ].filter((line) => line !== undefined).join("\n");
     }
-    function formatGatewayInputTranslationSuccess(englishText) {
+    function formatGatewayInputTranslationSuccess(role, englishText) {
         return [
-            "翻译完成，已发送给 PM：",
+            `翻译完成，已发送给 ${roleLabel(role)}：`,
             "",
             englishText.trim()
         ].join("\n");
     }
-    function formatGatewayInputTranslationFailure(error) {
+    function formatGatewayInputTranslationFailure(role, error) {
         return [
-            "翻译失败，消息未发送给 PM。",
+            `翻译失败，消息未发送给 ${roleLabel(role)}。`,
             `原因：${error}`,
             "请重新输入后再试。"
         ].join("\n");
     }
-    async function renderLatestPmReply(settings, reply) {
-        const rendered = await renderGatewayPmOutput({
+    async function renderLatestRoleReply(settings, reply) {
+        const rendered = await renderGatewayRoleOutput({
             settings,
             repoRoot: reply.repoRoot,
             taskSlug: reply.taskSlug,
+            role: reply.role,
             sourceText: reply.text,
             sourceEntryIds: reply.transcriptEventId ? [reply.transcriptEventId] : undefined
         });
@@ -1344,7 +1414,7 @@ export function createGatewayService(deps) {
             text: reply.truncated && !rendered.translationFailed ? `${rendered.text}\n\n[truncated]` : rendered.text
         };
     }
-    async function renderGatewayPmOutput(input) {
+    async function renderGatewayRoleOutput(input) {
         if (!input.settings.translationEnabled) {
             clearFailedTranslation(input.repoRoot, input.taskSlug);
             return {
@@ -1356,7 +1426,7 @@ export function createGatewayService(deps) {
             const text = await deps.translationService.translateGatewayOutput({
                 repoRoot: input.repoRoot,
                 taskSlug: input.taskSlug,
-                role: "project-manager",
+                role: input.role,
                 text: input.sourceText,
                 sourceEntryIds: input.sourceEntryIds
             });
@@ -1371,7 +1441,7 @@ export function createGatewayService(deps) {
             lastFailedTranslation = {
                 repoRoot: input.repoRoot,
                 taskSlug: input.taskSlug,
-                role: "project-manager",
+                role: input.role,
                 sourceText: input.sourceText,
                 failedAt: now(),
                 error: message,
@@ -1415,7 +1485,7 @@ export function createGatewayService(deps) {
             lastFailedTranslation = null;
         }
     }
-    function toGatewayPmReply(event) {
+    function toGatewayRoleReply(event) {
         return {
             text: event.text,
             truncated: false,
@@ -1423,16 +1493,20 @@ export function createGatewayService(deps) {
             transcriptTimestamp: event.timestamp
         };
     }
-    async function saveLatestPmReply(input, reply) {
+    async function saveLatestRoleReply(input, reply) {
+        if (!isVcmRoleName(input.session.role)) {
+            return;
+        }
         const settings = await deps.settings.loadSettings();
-        const key = latestPmReplyKey(input.repoRoot, input.taskSlug);
+        const key = latestRoleReplyKey(input.repoRoot, input.taskSlug, input.session.role);
         await deps.settings.saveSettings({
             ...settings,
-            latestPmReplies: {
-                ...settings.latestPmReplies,
+            latestRoleReplies: {
+                ...settings.latestRoleReplies,
                 [key]: {
                     repoRoot: input.repoRoot,
                     taskSlug: input.taskSlug,
+                    role: input.session.role,
                     sessionId: input.session.id,
                     claudeSessionId: input.session.claudeSessionId,
                     transcriptEventId: reply.transcriptEventId,
@@ -1459,8 +1533,8 @@ function selectEventsAfterCursor(events, cursorId) {
     }
     return events.slice(index + 1);
 }
-function latestPmReplyKey(repoRoot, taskSlug) {
-    return JSON.stringify([repoRoot, taskSlug]);
+function latestRoleReplyKey(repoRoot, taskSlug, role) {
+    return JSON.stringify([repoRoot, taskSlug, role]);
 }
 function projectsText(projects) {
     if (projects.length === 0) {
@@ -1478,7 +1552,7 @@ function helpText(enabled) {
             "/status",
             "/projects",
             "/tasks",
-            "Send /start to enable PM messages and task-changing commands."
+            "Send /start to enable role messages and task-changing commands."
         ].join("\n");
     }
     return [
@@ -1487,6 +1561,8 @@ function helpText(enabled) {
         "/start",
         "/retry",
         "/status",
+        "/role",
+        "/role <pm|architect|coder|tester|reviewer>",
         "/projects",
         "/use-project <index-or-path>",
         "/pull-current",
@@ -1499,6 +1575,12 @@ function helpText(enabled) {
         "/translate off"
     ].join("\n");
 }
+function roleLabel(role) {
+    return role === "project-manager" ? "PM" : getRoleDefinition(role).label;
+}
+function gatewayRoleCommandName(role) {
+    return role === "project-manager" ? "pm" : role;
+}
 function formatAheadBehind(project) {
     if (!project.upstreamBranch) {
         return "no upstream";