vibe-coding-master 0.8.4 → 0.8.6

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));
+}

package/dist/backend/services/workflow-control-service.js

@@ -317,6 +317,8 @@ export function createWorkflowControlService(deps) {
         },
         requestUserInput,
         resolveUserInput,
+        completeUserQuestion,
+        runWhileNotAwaitingUser,
         submitProgress,
         assertDocsArtifactAllowed,
         assertRouteAuthorized,
@@ -409,6 +411,37 @@ export function createWorkflowControlService(deps) {
             return next;
         });
     }
+    async function runWhileNotAwaitingUser(input, run) {
+        return withLock(statePath(input), async () => {
+            const state = await getState(input);
+            failWhileAwaitingUser(state);
+            return run();
+        });
+    }
+    async function completeUserQuestion(input, turn) {
+        return withLock(statePath(input), async () => {
+            const state = await getState(input);
+            failOnStateWarnings(state);
+            const question = state.awaitingUser;
+            if (!question)
+                return undefined;
+            const replies = state.userQuestionReplies ?? [];
+            const existing = replies.find((reply) => reply.requestedAt === question.requestedAt);
+            if (existing)
+                return existing.sessionId === turn.sessionId ? existing : undefined;
+            if (question.requestedAt > turn.endedAt)
+                return undefined;
+            const reply = {
+                ...question,
+                id: `user-question:${turn.sessionId}:${question.requestedAt}`,
+                sessionId: turn.sessionId,
+                turnStartedAt: turn.startedAt,
+                completedAt: turn.endedAt
+            };
+            await saveState(input, { ...state, userQuestionReplies: [...replies, reply], updatedAt: now() });
+            return reply;
+        });
+    }
     async function saveState(input, state) {
         await deps.fs.writeJsonAtomic(statePath(input), state);
     }
@@ -1343,18 +1376,24 @@ function normalizeState(value, taskSlug, timestamp) {
     const awaitingUser = value.awaitingUser === undefined || value.awaitingUser === null
         ? null
         : isAwaitingUser(value.awaitingUser) ? value.awaitingUser : undefined;
+    const validQuestionReplies = value.userQuestionReplies === undefined
+        || (Array.isArray(value.userQuestionReplies) && value.userQuestionReplies.every(isUserQuestionReply));
     if (pendingDispatch === undefined
         || activeDispatch === undefined
         || flowRun === undefined
         || userAuthorizations === undefined
         || userApprovedFollowUps === undefined
-        || awaitingUser === undefined) {
+        || awaitingUser === undefined
+        || !validQuestionReplies) {
         return { ...emptyState(taskSlug, timestamp), warnings: ["Workflow control state has an unsupported shape."] };
     }
     return {
         version: 1,
         taskSlug,
         awaitingUser,
+        ...(Array.isArray(value.userQuestionReplies) ? {
+            userQuestionReplies: value.userQuestionReplies
+        } : {}),
         pendingDispatch,
         activeDispatch,
         flowRun,
@@ -1364,6 +1403,13 @@ function normalizeState(value, taskSlug, timestamp) {
         updatedAt: typeof value.updatedAt === "string" ? value.updatedAt : timestamp
     };
 }
+function isUserQuestionReply(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const reply = value;
+    return [reply.id, reply.sessionId, reply.question, reply.requestedAt, reply.turnStartedAt, reply.completedAt]
+        .every((field) => typeof field === "string" && field.length > 0);
+}
 function emptyState(taskSlug, timestamp) {
     return {
         version: 1,

package/dist/backend/templates/harness/architect-agent.js

@@ -301,7 +301,8 @@ Each rewritten \`architecture-diagnosis.md\` must be a complete, self-contained
 - For a \`[VCM Durable Documentation Assignment]\`, update the assigned durable
   document and directly related documentation, run applicable documentation
   checks, commit the result, and submit \`docs-update-report.md\` with the exact
-  assigned Assignment ID. This backend assignment does not start Docs-Only Flow.
+  assigned Assignment ID. Use \`vcm-artifact docs-update-report --path <assigned-report-path>\`;
+  do not use the shared Docs-Only report path. This backend assignment does not start Docs-Only Flow.
 
 - In Docs-Only Flow, verify claims against current code and durable docs, update the PM-assigned project documents and related documentation needed for consistency, run applicable documentation checks, commit the changes, and submit \`.ai/vcm/handoffs/docs-update-report.md\` through \`vcm-artifact\` before reporting to PM.
 - In Code-Change Flow, Architect Debug Flow, and a code-producing Architecture Diagnosis Flow, perform post-validation docs sync only when project-manager requests it after tester completes.

package/dist/backend/templates/harness/coder-agent.js

@@ -82,7 +82,8 @@ ${renderRoleMemoryRules("coder")}
 - For a \`[VCM Durable Documentation Assignment]\`, verify and update the assigned
   durable document and directly related documentation, run applicable checks,
   commit the result, and submit \`docs-update-report.md\` with the exact assigned
-  Assignment ID. This backend assignment does not start Docs-Only Flow.
+  Assignment ID. Use \`vcm-artifact docs-update-report --path <assigned-report-path>\`;
+  do not use the shared Docs-Only report path. This backend assignment does not start Docs-Only Flow.
 
 - In Docs-Only Flow, commit the documentation changes and submit \`.ai/vcm/handoffs/docs-update-report.md\` through \`vcm-artifact\` with the decision, changed and reviewed documents, evidence, checks, commit, and remaining documentation issues. Do not submit \`coder-completion.md\` for Docs-Only work.
 - Submit \`.ai/vcm/handoffs/coder-completion.md\` before routing back to project-manager: write a candidate outside \`.ai/vcm\`, then run \`.ai/tools/vcm-artifact coder-completion --file <candidate> --mode draft|final\`. This file is the complete, self-contained current implementation completion evidence, not a log. Each revision must restate every Scaffold Manifest disposition, changed file, helper, deviation, generated-context result, baseline-test change, L0/L1 command and result, worker result, commit, and objective failure still needed to review the current implementation without a prior revision. Replace stale content instead of appending history.

package/dist/backend/templates/harness/project-manager-agent.js

@@ -21,7 +21,7 @@ ${renderRoleMemoryRules("project-manager")}
 - Assistant text emitted before a tool call or role dispatch while the current Round continues is not user communication. Do not use intermediate text to deliver status, findings, decisions, questions, or required actions to the user.
 - The user is informed only by PM's Round Final Reply when the Round pauses for user input or reaches a terminal result.
 - The Round Final Reply must be self-contained. Restate every result, blocker, decision, risk, and required user action needed to understand the current state. Never rely on earlier PM text in the same Round.
-- When asking the user a question, register it through \`vcm-ask-user\`, make the complete question and its necessary context the final reply, and end the turn.
+- When asking the user a question, submit the complete user-facing question and its necessary context through \`vcm-ask-user\`, then end the turn. VCM delivers the registered question as the Round Final Reply; do not rely on a separate final message to supply missing context.
 - Explain task status, blockers, role results, and decisions in user-facing language.
 - Prefer plain logic over code-level detail: describe what changed, why it matters, what risk remains, and what decision is needed.
 - Exclude irrelevant implementation detail, but retain the technical facts needed to explain the cause, evidence, impact, and unresolved state. Plain language means translating technical detail, not deleting it.

package/dist/backend/templates/harness/tester-agent.js

@@ -42,8 +42,8 @@ ${renderRoleMemoryRules("tester")}
 - For a \`[VCM Durable Documentation Assignment]\`, verify and update the assigned
   durable document and directly related documentation, run applicable
   documentation checks, commit the result, and submit \`docs-update-report.md\`
-  with the exact assigned Assignment ID. This backend assignment does not start
-  Docs-Only Flow.
+  with the exact assigned Assignment ID. Use \`vcm-artifact docs-update-report --path <assigned-report-path>\`;
+  do not use the shared Docs-Only report path. This backend assignment does not start Docs-Only Flow.
 
 - Verify the assigned documentation against current project evidence, update the required documentation, run applicable documentation checks, and commit the changes.
 - Submit \`.ai/vcm/handoffs/docs-update-report.md\` through \`vcm-artifact\` with the decision, changed and reviewed documents, evidence, checks, commit, and remaining documentation issues.

package/dist/backend/templates/harness/vcm-ask-user-skill.js

@@ -5,13 +5,13 @@ Use this skill whenever Project Manager asks the user a question.
 
 ## Ask And Wait
 
-Register the exact question before asking it:
+Submit the complete user-facing question, including the context needed to answer:
 
 \`\`\`bash
 .ai/tools/vcm-ask-user --question "<exact question>"
 \`\`\`
 
-After the tool returns \`awaiting_user\`, ask that question and end the turn. Do not request Workflow Review, write a route message, run a Gate, or advance the workflow in the same turn.
+After the tool returns \`awaiting_user\`, end the turn. VCM delivers the registered question as the Round Final Reply through the existing display, translation, and Gateway paths. Do not rely on a separate final message to supply missing context. Do not request Workflow Review, write a route message, run a Gate, or advance the workflow in the same turn.
 
 Every question pauses the workflow. PM may defer a question by not asking it; once PM asks, only a new direct user message resumes the workflow. The previous workflow approval is canceled, so request a fresh approval before the next dispatch.
 `;

package/dist/backend/templates/harness/vcm-workflow-review-skill.js

@@ -52,7 +52,7 @@ Only the user's explicit instruction may authorize a rejected transition.
 
 If the current user instruction already explicitly authorizes the exact rejected transition, reuse that instruction verbatim as \`Authorization Text\`. Do not ask the user to confirm it again.
 
-If no such instruction exists, use \`vcm-ask-user\` with the exact authorization question, ask it, and wait.
+If no such instruction exists, use \`vcm-ask-user\` with the complete authorization question and end the turn.
 
 Resubmit the unchanged transition with: