vibe-coding-master 0.8.3 → 0.8.5

package/README.md

@@ -192,10 +192,18 @@ artifacts, Gate Review state, Round/Turn state, and the role rules remain
 authoritative.
 
 Whenever Project Manager asks the user a question, it first uses
-`vcm-ask-user`. VCM records the wait and cancels any pending role dispatch in
-one state update. Stop Hook then ends the PM turn without route scanning. Only
+`vcm-ask-user` with the complete question and necessary context. VCM records the
+wait and cancels any pending role dispatch in one state update. Stop Hook then
+ends the PM turn without route scanning and records the question as the official
+reply. The existing Pause Alert displays it even when translation is off; the
+translation panel and Gateway reuse that same reply instead of PM's separate
+closing text. While waiting, new dispatches, Gate requests/retries, and workflow
+completion are blocked; already-running roles may still return results. Only
 a new direct user message clears the wait, and the next role dispatch requires
-a fresh Workflow Review.
+a fresh Workflow Review. PM treats text emitted while a Round continues as
+intermediate output, not as delivered user communication. When the Round pauses
+or completes, its Round Final Reply contains the complete user-facing result or
+registered question without relying on earlier PM output.
 
 Typical flow:
 

package/dist/backend/api/task-routes.js

@@ -65,6 +65,12 @@ export function registerTaskRoutes(app, deps) {
                     taskSlug
                 }) ?? Promise.resolve(degradedWorkflowState(taskSlug))
             ]);
+            if (roundState.flowPause?.paused && deps.workflowControlService) {
+                const workflow = await deps.workflowControlService.getState(context);
+                const reply = workflow.userQuestionReplies?.find((item) => item.requestedAt === workflow.awaitingUser?.requestedAt);
+                if (reply)
+                    roundState.flowPause = { ...roundState.flowPause, message: reply.question };
+            }
             const displayedRoundState = await delayFlowPauseForTranslation(deps, {
                 repoRoot: project.repoRoot,
                 taskRepoRoot,

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

@@ -2,6 +2,7 @@ import { getRoleDefinition, isVcmRoleName, VCM_ROLE_NAMES } from "../../shared/c
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
+import { findUserQuestionReply } from "../services/user-question-reply.js";
 import { resolveExistingClaudeTranscriptPath } from "../services/claude-transcript-service.js";
 import { isFinalTurnTextEvent, readTranscriptTextEvents } from "../services/claude-transcript-reply.js";
 import { parseGatewayCommand } from "./gateway-command-parser.js";
@@ -1162,11 +1163,16 @@ export function createGatewayService(deps) {
                 || settings.targetRole !== role) {
                 return;
             }
+            const questionReply = role === "project-manager" && deps.workflowControlService
+                ? await readRegisteredQuestionReply(input)
+                : undefined;
             const transcriptPath = resolveExistingClaudeTranscriptPath(input.session);
-            if (!transcriptPath) {
+            if (!questionReply && !transcriptPath)
                 return;
-            }
-            const events = await readTranscriptTextEvents(transcriptPath);
+            const events = questionReply ? [{
+                    id: questionReply.id, timestamp: questionReply.completedAt,
+                    text: questionReply.question, stopReason: "end_turn"
+                }] : await readTranscriptTextEvents(transcriptPath);
             const round = await waitForGatewayRoundFinal(input.repoRoot, input.taskSlug, role);
             if (!round) {
                 return;
@@ -1285,6 +1291,15 @@ export function createGatewayService(deps) {
             };
         }
     };
+    async function readRegisteredQuestionReply(input) {
+        const task = await deps.taskService.loadTask(input.repoRoot, input.taskSlug);
+        const config = await deps.projectService.loadConfig(input.repoRoot);
+        const state = await deps.workflowControlService.getState({
+            taskRepoRoot: getTaskRuntimeRepoRoot(task), taskSlug: input.taskSlug,
+            stateRoot: config.stateRoot, handoffDir: task.handoffDir
+        });
+        return findUserQuestionReply(state, input.session.id, input.session.lastTurnEndedAt ?? input.session.updatedAt);
+    }
     function getLatestRoleReply(settings) {
         if (!settings.currentProjectId || !settings.currentTaskSlug) {
             return undefined;

package/dist/backend/server.js

@@ -136,7 +136,8 @@ export async function createServer(deps, options = {}) {
         roundService: deps.roundService,
         taskWorkflowService: deps.taskWorkflowService,
         architectRestartService: deps.architectRestartService,
-        translationService: deps.translationService
+        translationService: deps.translationService,
+        workflowControlService: deps.workflowControlService
     });
     registerSessionRoutes(app, {
         projectService: deps.projectService,
@@ -243,7 +244,10 @@ export function createDefaultServerDeps(options = {}) {
     const runtime = createNodePtyTerminalRuntime({ fs });
     const registry = createSessionRegistry();
     const workflowControlService = createWorkflowControlService({ fs });
-    const artifactService = createArtifactService(fs, { workflowControlService });
+    const artifactService = createArtifactService(fs, {
+        workflowControlService,
+        isRoleMemoryTurn: (taskRepoRoot, role) => autoMemoryService.isRoleMemoryTurn(taskRepoRoot, role)
+    });
     const projectService = createProjectService({ fs, git, appSettings });
     const taskService = createTaskService({ fs, git, artifactService, projectService });
     const taskWorkflowService = createTaskWorkflowService({ fs });
@@ -350,6 +354,7 @@ export function createDefaultServerDeps(options = {}) {
     });
     const transcripts = createClaudeTranscriptService();
     const translationService = createTranslationService({
+        workflowControlService,
         runtime,
         sessionRegistry: registry,
         transcripts,
@@ -385,6 +390,7 @@ export function createDefaultServerDeps(options = {}) {
         roleContextRestartService
     });
     const gatewayService = createGatewayService({
+        workflowControlService,
         fs,
         settings: gatewaySettings,
         audit: gatewayAudit,

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

@@ -219,6 +219,20 @@ export function createArtifactService(fs, deps = {}) {
                 if (validation.errors.length > 0) {
                     throw artifactRejected(input.kind, validation.errors);
                 }
+                if ((input.kind === "docs-update-report" || input.kind === "docs-sync-report")
+                    && deps.workflowControlService) {
+                    // Memory-owned documentation work is independent of PM's active dispatch.
+                    const memoryUpdate = input.kind === "docs-update-report"
+                        && await deps.isRoleMemoryTurn?.(input.repoRoot, input.role);
+                    if (!memoryUpdate) {
+                        await deps.workflowControlService.assertDocsArtifactAllowed({
+                            taskRepoRoot: input.repoRoot,
+                            stateRoot: input.stateRoot ?? ".ai/vcm",
+                            handoffDir: input.handoffDir,
+                            taskSlug: input.taskSlug
+                        }, input.kind, input.role);
+                    }
+                }
                 if (input.kind === "workflow-progress") {
                     if (input.mode !== "final") {
                         throw artifactRejected(input.kind, ["Workflow Progress must be submitted in final mode."]);

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

@@ -1,6 +1,7 @@
 import { isHarnessEngineerToolRoleName, isReviewerRoleName, isTranslatorToolRoleName, isVcmRoleName } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { readTranscriptTurnEvidence } from "./claude-transcript-reply.js";
+import { findPmUserQuestion } from "./pm-user-question.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { matchesRoleHookSession } from "./session-service.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
@@ -338,7 +339,10 @@ export function createClaudeHookService(deps) {
             }
             else {
                 const lastAssistantMessage = stringOrUndefined(input.event.last_assistant_message);
-                if (options.allowBlock && lastAssistantMessage && asksUserQuestion(lastAssistantMessage)) {
+                const question = options.allowBlock && lastAssistantMessage
+                    ? findPmUserQuestion(lastAssistantMessage)
+                    : undefined;
+                if (question) {
                     return {
                         ok: true,
                         eventName,
@@ -348,7 +352,7 @@ export function createClaudeHookService(deps) {
                         dispatchedCount: 0,
                         stopDecision: {
                             behavior: "block",
-                            reason: "You asked the user a question without registering the wait. Use vcm-ask-user with the exact question, then ask that question and stop. Do not advance or route the workflow."
+                            reason: `Possible unregistered user question: ${JSON.stringify(question.slice(0, 600))}. If you are asking the user, use vcm-ask-user with the complete question and necessary context, then end the turn without advancing or routing the workflow. VCM delivers the registered question. If this only reports or quotes another question, clarify that context and end normally; do not invent a user question or register a false wait.`
                         }
                     };
                 }
@@ -503,6 +507,21 @@ export function createClaudeHookService(deps) {
         if (!session) {
             return completedHookResult(input, eventName);
         }
+        if (eventName === "Stop" && input.role === "project-manager") {
+            const reply = await deps.workflowControlService?.completeUserQuestion?.(createWorkflowControlContext(context), {
+                sessionId: session.id,
+                startedAt: session.lastTurnStartedAt ?? session.updatedAt,
+                endedAt: session.lastTurnEndedAt ?? session.updatedAt
+            });
+            if (reply) {
+                await deps.translationService.recordUserQuestionReply?.({
+                    repoRoot: context.project.repoRoot,
+                    taskRepoRoot: context.taskRepoRoot,
+                    taskSlug: context.taskSlug,
+                    reply
+                });
+            }
+        }
         const boundToTask = await isHookSessionBoundToTask(context, input.role);
         if (boundToTask) {
             await deps.roundService.recordClaudeHookEvent({
@@ -1003,14 +1022,3 @@ function isDirectUserPrompt(prompt) {
     const normalized = prompt.trim();
     return normalized.length > 0 && !/^\[VCM(?:\s|\])/i.test(normalized);
 }
-function asksUserQuestion(message) {
-    const withoutCodeBlocks = message.replace(/```[\s\S]*?```/g, "");
-    const lines = withoutCodeBlocks
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter(Boolean);
-    return lines.some((line) => /[?？]/.test(line)
-        || /^(?:please\s+(?:answer|choose|confirm|decide|provide|select|tell)|(?:can|could|do|does|is|are|should|will|would)\s+you\b)/i.test(line)
-        || /\b(?:please\s+(?:reply|respond|choose|confirm|decide|provide|select|tell|give)|i\s+need\s+your\s+(?:decision|choice|confirmation|answer)|let\s+me\s+know|your\s+(?:decision|choice|confirmation|answer)\s+is\s+required|waiting\s+for\s+your)\b/i.test(line)
-        || /(?:请(?:回答|回复|选择|确认|决定|提供|告知|给出|说明)|你(?:是否|能否|要不要|可否)|是否需要你|需要你(?:选择|确认|决定|提供|告知)|需要您的(?:选择|确认|决定|回复)|等待您的(?:选择|确认|决定|回复)|告诉我|告知我)/.test(line));
-}

package/dist/backend/services/gate-review-service.js

@@ -72,7 +72,10 @@ export function createGateReviewService(deps) {
     }
     async function requestReviewGateInternal(repoRoot, taskSlug, gate, options = {}) {
         const context = await getContext(repoRoot, taskSlug);
-        return withGateStateLock(context, () => requestReviewGateLocked(context, gate, options));
+        const run = () => withGateStateLock(context, () => requestReviewGateLocked(context, gate, options));
+        return deps.workflowControlService?.runWhileNotAwaitingUser
+            ? deps.workflowControlService.runWhileNotAwaitingUser(context, run)
+            : run();
     }
     async function requestReviewGateLocked(context, gate, options) {
         let index = await loadIndex(deps.fs, context, now());

package/dist/backend/services/pm-user-question.js

@@ -0,0 +1,62 @@
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+const markdown = unified().use(remarkParse).use(remarkGfm).freeze();
+// Match direct requests, not punctuation or requests mentioned inside a report.
+const DIRECT_REQUESTS = [
+    /^(?:can|could|do|did|are|have|should|will|would)\s+you\b/i,
+    /^(?:should|shall|may|can|could)\s+(?:i|we)\b/i,
+    /^(?:which|what|how|where|when|who)\b[^.!?]*\b(?:you|your|(?:should|shall|can|may)\s+(?:i|we))\b/i,
+    /^(?:which|what)\s+(?:option|approach|behavior|behaviour|choice)\b[^.!?]*\bshould\s+be\b/i,
+    /^(?:please\s+)?(?:answer|reply|respond|choose|confirm|decide|provide|select|tell\s+me|let\s+me\s+know|give\s+(?:me|your))\b/i,
+    /^i\s+need\s+your\s+(?:decision|choice|confirmation|answer|approval)\b/i,
+    /^your\s+(?:decision|choice|confirmation|answer|approval)\s+is\s+required\b/i,
+    /^(?:(?:i\s+am|i'm|we\s+are|we're)\s+)?waiting\s+for\s+your\s+(?:decision|choice|confirmation|answer|reply|approval)\b/i,
+    /^(?:请(?:您|你)?(?:回答|回复|选择|确认|决定|提供|告知|给出|说明)|[你您](?:是否|能否|要不要|可否|希望|想要)|是否需要[你您]|需要[你您](?:选择|确认|决定|提供|告知)|(?:需要|等待)[你您]的(?:选择|确认|决定|回复)|告诉我|告知我)/
+];
+export function findPmUserQuestion(message) {
+    return findQuestion(markdown.parse(message));
+}
+function findQuestion(node) {
+    // Quoted evidence and code are not PM addressing the user. Headings and table
+    // cells remain eligible: a real request does not stop being one when formatted.
+    if (["blockquote", "code", "html", "definition", "footnoteDefinition", "delete"].includes(node.type)) {
+        return undefined;
+    }
+    if (node.type === "paragraph" || node.type === "heading" || node.type === "tableCell") {
+        const prose = removeQuotedText(proseText(node)).replace(/\s+/g, " ");
+        for (const sentence of prose.split(/(?<=[.!?。！？；])\s*/)) {
+            const request = sentence.trim().replace(/^(?:(?:question(?:\s+for\s+you)?|your\s+decision|问题|请问)\s*[:：]\s*|before\s+(?:i|we)\s+(?:continue|proceed),?\s+)/i, "");
+            if (DIRECT_REQUESTS.some((pattern) => pattern.test(request))) {
+                return sentence.trim();
+            }
+        }
+        return undefined;
+    }
+    if ("children" in node) {
+        for (const child of node.children) {
+            const question = findQuestion(child);
+            if (question)
+                return question;
+        }
+    }
+    return undefined;
+}
+function proseText(node) {
+    if (node.type === "text")
+        return node.value;
+    if (node.type === "break")
+        return "\n";
+    if (["inlineCode", "html", "image", "imageReference", "delete", "footnoteReference"].includes(node.type))
+        return " ";
+    if (node.type === "link") {
+        const label = node.children.map(proseText).join("");
+        return label === node.url || /^(?:https?:\/\/|www\.)/i.test(label) ? " " : label;
+    }
+    if ("children" in node)
+        return node.children.map(proseText).join("");
+    return " ";
+}
+function removeQuotedText(text) {
+    return text.replace(/"[^"]*"|“[^”]*”|‘[^’]*’|「[^」]*」|『[^』]*』|(?<!\w)'[^']+'(?!\w)/g, " ");
+}

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

@@ -5,6 +5,7 @@ import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { readLatestRoleTurnReply } from "./claude-transcript-reply.js";
 import { createTranslationQueueRegistry } from "./translation-queue.js";
+import { findUserQuestionReply, isPendingUserQuestion } from "./user-question-reply.js";
 const TRANSLATION_SOURCE_LANGUAGE = "auto";
 const TRANSLATION_INPUT_MODE = "review-before-send";
 const TRANSLATION_CONTEXT_ENABLED = false;
@@ -25,6 +26,7 @@ export function createTranslationService(deps) {
     async function loadConfig() {
         const preferences = await deps.appSettings.getPreferences();
         return {
+            enabled: preferences.translationEnabled,
             sourceLanguage: TRANSLATION_SOURCE_LANGUAGE,
             targetLanguage: preferences.translationTargetLanguage,
             inputMode: TRANSLATION_INPUT_MODE,
@@ -239,6 +241,22 @@ export function createTranslationService(deps) {
             return;
         }
         const config = await loadConfig();
+        if (state.role === "project-manager" && event.kind === "text" && event.stopReason === "end_turn"
+            && !event.isSidechain && state.repoRoot && state.taskSlug && deps.workflowControlService && deps.projectService) {
+            const projectConfig = await deps.projectService.loadConfig(state.baseRepoRoot ?? state.repoRoot);
+            const workflow = await deps.workflowControlService.getState({
+                taskRepoRoot: state.repoRoot, taskSlug: state.taskSlug,
+                stateRoot: projectConfig.stateRoot, handoffDir: projectConfig.handoffRoot
+            });
+            const reply = findUserQuestionReply(workflow, sessionId, event.timestamp);
+            if (reply) {
+                publishUserQuestionReply(reply, config);
+                state.seenTranscriptIds.add(event.id);
+                return;
+            }
+            if (isPendingUserQuestion(workflow, event.timestamp))
+                return;
+        }
         let displayed = false;
         if (event.kind === "text") {
             const shouldTranslate = shouldTranslateTextTranscriptEvent(state, event, config);
@@ -281,6 +299,20 @@ export function createTranslationService(deps) {
         }
         return true;
     }
+    function publishUserQuestionReply(reply, config) {
+        const state = getState(reply.sessionId);
+        if (state.seenTranscriptIds.has(reply.id))
+            return;
+        const metadata = { transcriptStopReason: "end_turn", transcriptTimestamp: reply.completedAt };
+        // Claim before scheduling translation so Stop and transcript replay share one entry/job.
+        state.seenTranscriptIds.add(reply.id);
+        if (config.enabled === false || config.outputMode === "round-final") {
+            pushPreservedProseEntry(reply.sessionId, reply.id, reply.question, config, metadata);
+        }
+        else {
+            processClaudeOutputText(reply.sessionId, reply.question, config, reply.id, { flushImmediately: true, metadata });
+        }
+    }
     function processClaudeOutputText(sessionId, rawText, config, entryId, options = {}) {
         return startClaudeOutputTranslation(sessionId, rawText, config, {
             entryId,
@@ -647,6 +679,12 @@ export function createTranslationService(deps) {
         return state;
     }
     return {
+        async recordUserQuestionReply(input) {
+            await prepareCache({ repoRoot: input.taskRepoRoot, baseRepoRoot: input.repoRoot,
+                taskSlug: input.taskSlug, role: "project-manager", sessionId: input.reply.sessionId });
+            publishUserQuestionReply(input.reply, await loadConfig());
+            await persistEvents(getState(input.reply.sessionId));
+        },
         async startSession(input) {
             const roleSession = await deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, input.role);
             if (!roleSession || roleSession.status !== "running") {
@@ -720,6 +758,16 @@ export function createTranslationService(deps) {
                     status: state.status
                 });
             }
+            if (deps.workflowControlService && deps.projectService) {
+                const projectConfig = await deps.projectService.loadConfig(input.repoRoot);
+                const workflow = await deps.workflowControlService.getState({ ...input,
+                    stateRoot: projectConfig.stateRoot, handoffDir: projectConfig.handoffRoot });
+                for (const reply of workflow.userQuestionReplies ?? []) {
+                    if (feedSessions.some((session) => session.role === "project-manager" && session.sessionId === reply.sessionId)) {
+                        publishUserQuestionReply(reply, config);
+                    }
+                }
+            }
             if (config.outputMode === "round-final") {
                 await translateRoundFinalReplyIfReady(input, config);
             }
@@ -1173,7 +1221,7 @@ export function createTranslationService(deps) {
         }
     };
     async function translateRoundFinalReplyIfReady(input, config) {
-        if (!deps.roundService || !deps.projectService) {
+        if (config.enabled === false || !deps.roundService || !deps.projectService) {
             return;
         }
         const projectConfig = await deps.projectService.loadConfig(input.repoRoot);

package/dist/backend/services/user-question-reply.js

@@ -0,0 +1,10 @@
+// Use the recorded turn window, not the current wait flag: replies must survive
+// the user's answer and transcript replay without becoming a second message.
+export function findUserQuestionReply(state, sessionId, timestamp) {
+    return state.userQuestionReplies?.slice().reverse().find((reply) => reply.sessionId === sessionId
+        && timestamp >= reply.turnStartedAt && timestamp <= reply.completedAt);
+}
+export function isPendingUserQuestion(state, timestamp) {
+    return Boolean(state.awaitingUser && timestamp >= state.awaitingUser.requestedAt
+        && !state.userQuestionReplies?.some((reply) => reply.requestedAt === state.awaitingUser?.requestedAt));
+}