vibe-coding-master 0.8.4 → 0.8.6

package/README.md

@@ -192,13 +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. 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 restates the complete user-facing result or
-question without relying on earlier PM output.
+or completes, its Round Final Reply contains the complete user-facing result or
+registered question without relying on earlier PM output.
 
 Typical flow:
 
@@ -584,10 +589,20 @@ before documentation work starts. VCM assigns architecture and known-issues
 documents to Architect and testing documentation to Tester. For another target,
 PM selects Architect, Coder, or Tester and asks the user only when ownership
 cannot be determined. These assignments are backend-dispatched work rather than
-a Docs-Only Flow. Each owner updates and commits the document, submits the exact
-assignment ID in `docs-update-report.md`, and finishes before the next assignment
-starts. Harness Studio shows assignment status and allows failed work to be
-retried.
+a Docs-Only Flow. Each owner submits `docs-update-report` through `vcm-artifact`
+with the exact assigned `--path` and Assignment ID. Reports are isolated under
+`.ai/vcm/memory-review/runs/<run-id>/assignments/<assignment-id>/report.md`.
+The reported commit must modify the target document within the assignment's
+original commit range; unrelated later commits do not invalidate it. Existing
+correct documentation can be reported as `unchanged` without a new commit.
+
+Assignments run one at a time. A failed assignment does not block later items.
+After the remaining items finish, unresolved failures are reported in Harness
+Studio with their causes and individual Retry buttons. Retry preserves earlier
+committed work and the original baseline, including after a backend restart.
+Migration content and review snapshots remain in the task-local run directory;
+failures do not automatically restore removed memory. Turning Auto Memory off
+does not discard or cancel already-applied document migrations.
 
 When Auto Memory is disabled, Review Task Harness does not collect proposals or
 ask Harness Engineer to update memory. When enabled, both automatic and manual

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,
@@ -245,7 +246,7 @@ export function createDefaultServerDeps(options = {}) {
     const workflowControlService = createWorkflowControlService({ fs });
     const artifactService = createArtifactService(fs, {
         workflowControlService,
-        isRoleMemoryTurn: (taskRepoRoot, role) => autoMemoryService.isRoleMemoryTurn(taskRepoRoot, role)
+        getDurableDocAssignment: (taskRepoRoot, role) => autoMemoryService.getDurableDocAssignment(taskRepoRoot, role)
     });
     const projectService = createProjectService({ fs, git, appSettings });
     const taskService = createTaskService({ fs, git, artifactService, projectService });
@@ -353,6 +354,7 @@ export function createDefaultServerDeps(options = {}) {
     });
     const transcripts = createClaudeTranscriptService();
     const translationService = createTranslationService({
+        workflowControlService,
         runtime,
         sessionRegistry: registry,
         transcripts,
@@ -388,6 +390,7 @@ export function createDefaultServerDeps(options = {}) {
         roleContextRestartService
     });
     const gatewayService = createGatewayService({
+        workflowControlService,
         fs,
         settings: gatewaySettings,
         audit: gatewayAudit,

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

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { DISPATCHABLE_ROLES } from "../../shared/constants.js";
-import { checkMarkdownArtifact } from "../../shared/validation/artifact-check.js";
+import { checkMarkdownArtifact, readArtifactSectionValue } from "../../shared/validation/artifact-check.js";
 import { getManagedArtifactDefinition, isArtifactKind, isManagedArtifactKind } from "../../shared/validation/artifact-registry.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
@@ -208,10 +208,21 @@ export function createArtifactService(fs, deps = {}) {
                 });
             }
             if (isArtifactKind(input.kind)) {
-                if (input.artifactPath?.trim()) {
+                const assignment = input.kind === "docs-update-report"
+                    ? await deps.getDurableDocAssignment?.(input.repoRoot, input.role)
+                    : undefined;
+                if (assignment) {
+                    if (input.artifactPath !== assignment.reportPath) {
+                        throw artifactRejected(input.kind, [`Use the assigned --path ${assignment.reportPath}.`]);
+                    }
+                    if (readArtifactSectionValue(normalized, "Assignment ID")?.trim() !== assignment.id) {
+                        throw artifactRejected(input.kind, [`Assignment ID must be exactly ${assignment.id}.`]);
+                    }
+                }
+                else if (input.artifactPath?.trim()) {
                     throw artifactRejected(input.kind, ["--path is not allowed for fixed artifact kinds."]);
                 }
-                const artifactPath = path.posix.join(input.handoffDir, definition.fileName ?? "");
+                const artifactPath = assignment?.reportPath ?? path.posix.join(input.handoffDir, definition.fileName ?? "");
                 const validation = validateManagedArtifactContent(input.kind, normalized, {
                     path: artifactPath,
                     mode: input.mode
@@ -222,9 +233,7 @@ export function createArtifactService(fs, deps = {}) {
                 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) {
+                    if (!assignment) {
                         await deps.workflowControlService.assertDocsArtifactAllowed({
                             taskRepoRoot: input.repoRoot,
                             stateRoot: input.stateRoot ?? ".ai/vcm",

package/dist/backend/services/auto-memory-service.js

@@ -5,7 +5,7 @@ import { resolveRepoPath } from "../adapters/filesystem.js";
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { readVcmMemoryHostFrame, readVcmMemoryBlock, replaceVcmMemoryBlock } from "../templates/harness/memory-block.js";
-import { ARCHITECT_PLANNING_MEMORY_CANDIDATE_PATH, architectPlanningCandidateSnapshotPath, memoryReviewRoleDraftPath, MEMORY_REVIEW_RUNS_ROOT, MEMORY_REVIEW_STATE_PATH } from "./memory-review-paths.js";
+import { ARCHITECT_PLANNING_MEMORY_CANDIDATE_PATH, architectPlanningCandidateSnapshotPath, durableDocAssignmentReportPath, memoryReviewRoleDraftPath, MEMORY_REVIEW_RUNS_ROOT, MEMORY_REVIEW_STATE_PATH } from "./memory-review-paths.js";
 import { parseMemoryProposal, validateMemoryProposal } from "./memory-proposal-validation.js";
 const MEMORY_FILE_DEFINITIONS = [
     { path: "CLAUDE.md", title: "Shared Memory" },
@@ -18,6 +18,20 @@ const MEMORY_FILE_DEFINITIONS = [
 ];
 export function createAutoMemoryService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
+    const taskLocks = new Map();
+    async function withTaskLock(taskRepoRoot, operation) {
+        const previous = taskLocks.get(taskRepoRoot) ?? Promise.resolve();
+        const current = previous.catch(() => undefined).then(operation);
+        taskLocks.set(taskRepoRoot, current);
+        try {
+            return await current;
+        }
+        finally {
+            if (taskLocks.get(taskRepoRoot) === current) {
+                taskLocks.delete(taskRepoRoot);
+            }
+        }
+    }
     async function readMemorySet(repoRoot) {
         const memory = {};
         for (const definition of MEMORY_FILE_DEFINITIONS) {
@@ -151,7 +165,7 @@ export function createAutoMemoryService(deps) {
             else if (active?.status === "reviewing" && active.reviewPromptDispatchedAt) {
                 return getState(input.baseRepoRoot, input.taskRepoRoot);
             }
-            else if (active) {
+            else if (active && !preserveDisabledReview(active)) {
                 await discardActiveReview(input.taskRepoRoot, active);
             }
             return getState(input.baseRepoRoot, input.taskRepoRoot);
@@ -361,6 +375,11 @@ export function createAutoMemoryService(deps) {
         }
         return assignment.status === "running" && assignment.owner === role;
     }
+    async function getDurableDocAssignment(taskRepoRoot, role) {
+        const state = await loadActiveState(taskRepoRoot);
+        const assignment = state?.status === "documenting" ? currentDurableDocAssignment(state) : undefined;
+        return assignment?.status === "running" && assignment.owner === role ? assignment : undefined;
+    }
     async function handleRoleHook(input) {
         const state = await loadActiveState(input.taskRepoRoot);
         if (!(await deps.appSettings.getPreferences()).autoMemoryEnabled && !preserveDisabledReview(state)) {
@@ -522,12 +541,19 @@ export function createAutoMemoryService(deps) {
                 statusCode: 409
             });
         }
+        if (state.assignments.length > 0) {
+            throw new VcmError({
+                code: "DURABLE_DOC_ASSIGNMENTS_FAILED",
+                message: "Memory was already applied. Retry the failed durable-document assignments individually.",
+                statusCode: 409
+            });
+        }
         await clearActiveState(taskRepoRoot);
         return getState(baseRepoRoot, taskRepoRoot);
     }
     async function retryDurableDocAssignment(baseRepoRoot, taskRepoRoot, assignmentId) {
         const state = await loadActiveState(taskRepoRoot);
-        const assignment = state?.status === "documenting"
+        const assignment = state && (state.status === "documenting" || state.status === "failed")
             ? state.assignments.find((candidate) => candidate.id === assignmentId)
             : undefined;
         if (!state || !assignment || assignment.status !== "failed") {
@@ -539,11 +565,10 @@ export function createAutoMemoryService(deps) {
         }
         assignment.status = assignment.owner ? "pending" : "waiting-owner";
         assignment.updatedAt = now();
-        delete assignment.error;
         delete assignment.requestedOwner;
         delete assignment.dispatchedAt;
-        delete assignment.baseCommit;
-        delete assignment.reportHashBefore;
+        state.status = "documenting";
+        delete state.error;
         await persistMemoryAssignmentState(taskRepoRoot, state);
         await dispatchCurrentDurableDocAssignment(baseRepoRoot, taskRepoRoot, state);
         return getState(baseRepoRoot, taskRepoRoot);
@@ -620,6 +645,7 @@ export function createAutoMemoryService(deps) {
             assignment.error = `${input.role} durable-document assignment turn failed.`;
             assignment.updatedAt = now();
             await persistMemoryAssignmentState(input.taskRepoRoot, state);
+            await dispatchCurrentDurableDocAssignment(input.baseRepoRoot, input.taskRepoRoot, state);
             return true;
         }
         if (input.eventName !== "Stop") {
@@ -644,13 +670,6 @@ export function createAutoMemoryService(deps) {
             assignment.updatedAt = assignment.completedAt;
             delete assignment.error;
             await persistMemoryAssignmentState(input.taskRepoRoot, state);
-            const next = currentDurableDocAssignment(state);
-            if (next) {
-                await dispatchCurrentDurableDocAssignment(input.baseRepoRoot, input.taskRepoRoot, state);
-            }
-            else {
-                await clearActiveState(input.taskRepoRoot);
-            }
         }
         catch (error) {
             assignment.status = "failed";
@@ -658,11 +677,13 @@ export function createAutoMemoryService(deps) {
             assignment.updatedAt = now();
             await persistMemoryAssignmentState(input.taskRepoRoot, state);
         }
+        await dispatchCurrentDurableDocAssignment(input.baseRepoRoot, input.taskRepoRoot, state);
         return true;
     }
     async function dispatchCurrentDurableDocAssignment(baseRepoRoot, taskRepoRoot, state) {
-        const assignment = currentDurableDocAssignment(state);
-        if (!assignment || assignment.status === "failed") {
+        let assignment = currentDurableDocAssignment(state);
+        if (!assignment) {
+            await finishDurableDocAssignments(taskRepoRoot, state);
             return;
         }
         if (assignment.status === "running" || assignment.status === "resolving-owner") {
@@ -678,28 +699,50 @@ export function createAutoMemoryService(deps) {
             assignment.updatedAt = now();
             await persistMemoryAssignmentState(taskRepoRoot, state);
         }
-        const role = assignment.owner ?? "project-manager";
-        try {
-            const session = await ensureWorkflowRoleSession(baseRepoRoot, state.taskSlug, role);
-            if (session.activityStatus === "running") {
+        while (assignment) {
+            try {
+                await dispatchDurableDocAssignment(baseRepoRoot, taskRepoRoot, state, assignment);
                 return;
             }
-            assignment.status = assignment.owner ? "running" : "resolving-owner";
+            catch (error) {
+                assignment.status = "failed";
+                assignment.error = `Unable to dispatch durable-document assignment: ${errorMessage(error)}`;
+                assignment.updatedAt = now();
+                await persistMemoryAssignmentState(taskRepoRoot, state);
+                assignment = currentDurableDocAssignment(state);
+            }
+        }
+        await finishDurableDocAssignments(taskRepoRoot, state);
+    }
+    async function dispatchDurableDocAssignment(baseRepoRoot, taskRepoRoot, state, assignment) {
+        const session = await ensureWorkflowRoleSession(baseRepoRoot, state.taskSlug, assignment.owner ?? "project-manager");
+        if (session.activityStatus === "running") {
+            return;
+        }
+        assignment.status = assignment.owner ? "running" : "resolving-owner";
+        assignment.reportPath = durableDocAssignmentReportPath(assignment.runId, assignment.id);
+        if (!assignment.baseCommit) {
             assignment.baseCommit = await deps.git.getHeadCommit(taskRepoRoot);
             assignment.reportHashBefore = await hashOptionalFile(taskRepoRoot, assignment.reportPath);
-            assignment.dispatchedAt = now();
-            assignment.updatedAt = assignment.dispatchedAt;
-            await persistMemoryAssignmentState(taskRepoRoot, state);
-            await submitTerminalInput(deps.runtime, session.id, assignment.owner
-                ? buildDurableDocAssignmentPrompt(taskRepoRoot, assignment)
-                : buildDurableDocOwnerPrompt(taskRepoRoot, assignment));
         }
-        catch (error) {
-            assignment.status = "failed";
-            assignment.error = `Unable to dispatch durable-document assignment: ${errorMessage(error)}`;
-            assignment.updatedAt = now();
+        assignment.dispatchedAt = now();
+        assignment.updatedAt = assignment.dispatchedAt;
+        await persistMemoryAssignmentState(taskRepoRoot, state);
+        await submitTerminalInput(deps.runtime, session.id, assignment.owner
+            ? buildDurableDocAssignmentPrompt(taskRepoRoot, assignment)
+            : buildDurableDocOwnerPrompt(taskRepoRoot, assignment));
+    }
+    async function finishDurableDocAssignments(taskRepoRoot, state) {
+        const failed = state.assignments.filter((assignment) => assignment.status === "failed");
+        if (failed.length > 0) {
+            state.status = "failed";
+            state.error = `Memory was applied, but ${failed.length} durable-document assignment(s) failed: ${failed.map((assignment) => assignment.targetPath).join(", ")}. Retry the failed assignments; their content is retained in the memory review run.`;
             await persistMemoryAssignmentState(taskRepoRoot, state);
+            return;
         }
+        delete state.error;
+        await persistMemoryAssignmentState(taskRepoRoot, state);
+        await clearActiveState(taskRepoRoot);
     }
     async function validateDurableDocAssignmentCompletion(taskRepoRoot, assignment) {
         const reportAbsolutePath = resolveRepoPath(taskRepoRoot, assignment.reportPath);
@@ -727,22 +770,36 @@ export function createAutoMemoryService(deps) {
         if (decision !== "synced" && decision !== "unchanged") {
             throw new Error("Decision must be synced or unchanged");
         }
+        if (!(await deps.fs.pathExists(resolveRepoPath(taskRepoRoot, assignment.targetPath)))) {
+            throw new Error(`target document is missing: ${assignment.targetPath}`);
+        }
         const currentHead = await deps.git.getHeadCommit(taskRepoRoot);
         if (decision === "synced") {
-            if (!assignment.baseCommit || currentHead === assignment.baseCommit) {
-                throw new Error("documentation changes were not committed");
-            }
-            const changedPaths = await deps.git.getChangedPaths(taskRepoRoot, assignment.baseCommit, currentHead);
-            if (!changedPaths.includes(assignment.targetPath)) {
-                throw new Error(`documentation commit does not include ${assignment.targetPath}`);
-            }
-            const reportedCommit = readArtifactSectionValue(reportContent, "Commit")?.trim();
-            if (!reportedCommit || reportedCommit === "TBD" || !currentHead.startsWith(reportedCommit)) {
-                throw new Error(`Commit must identify the current documentation commit ${currentHead}`);
-            }
+            return validateDurableDocCommit(taskRepoRoot, assignment, reportContent, currentHead);
         }
         return currentHead;
     }
+    async function validateDurableDocCommit(taskRepoRoot, assignment, reportContent, currentHead) {
+        if (!assignment.baseCommit || currentHead === assignment.baseCommit) {
+            throw new Error("documentation changes were not committed");
+        }
+        const changedPaths = await deps.git.getChangedPaths(taskRepoRoot, assignment.baseCommit, currentHead);
+        if (!changedPaths.includes(assignment.targetPath)) {
+            throw new Error(`documentation commit does not include ${assignment.targetPath}`);
+        }
+        const reportedCommit = readArtifactSectionValue(reportContent, "Commit")?.trim();
+        const commits = await deps.git.getCommitList(taskRepoRoot, `${assignment.baseCommit}..${currentHead}`);
+        const matches = reportedCommit ? commits.filter((commit) => commit.sha.startsWith(reportedCommit)) : [];
+        if (matches.length !== 1) {
+            throw new Error(`Commit must uniquely identify a documentation commit in ${assignment.baseCommit}..${currentHead}; received ${reportedCommit || "empty"}`);
+        }
+        const commit = matches[0].sha;
+        const commitPaths = await deps.git.getChangedPaths(taskRepoRoot, `${commit}^`, commit);
+        if (!commitPaths.includes(assignment.targetPath)) {
+            throw new Error(`reported commit ${commit} does not modify ${assignment.targetPath}`);
+        }
+        return commit;
+    }
     async function hashOptionalFile(taskRepoRoot, relativePath) {
         const absolutePath = resolveRepoPath(taskRepoRoot, relativePath);
         return await deps.fs.pathExists(absolutePath)
@@ -756,6 +813,7 @@ export function createAutoMemoryService(deps) {
         await persistRun(taskRepoRoot, {
             ...run,
             assignments: state.assignments,
+            error: state.error,
             updatedAt: state.updatedAt
         });
     }
@@ -897,7 +955,7 @@ export function createAutoMemoryService(deps) {
                 evidence: assignment.evidence,
                 ...(owner ? { owner } : {}),
                 status: owner ? "pending" : "waiting-owner",
-                reportPath: ".ai/vcm/handoffs/docs-update-report.md",
+                reportPath: durableDocAssignmentReportPath(state.runId, `${state.runId}-doc-${index + 1}`),
                 createdAt: timestamp,
                 updatedAt: timestamp
             };
@@ -1317,20 +1375,21 @@ export function createAutoMemoryService(deps) {
         return `sha256:${sha256(content)}`;
     }
     return {
-        reconcileTask,
+        reconcileTask: (input) => withTaskLock(input.taskRepoRoot, () => reconcileTask(input)),
         getState,
         getTaskRetrospectiveReadiness,
         getFile,
         updateFile,
         revertRun,
         retryFailedReview,
-        retryDurableDocAssignment,
-        resolveDurableDocAssignmentOwner,
+        retryDurableDocAssignment: (base, task, id) => withTaskLock(task, () => retryDurableDocAssignment(base, task, id)),
+        resolveDurableDocAssignmentOwner: (base, task, id, owner) => withTaskLock(task, () => resolveDurableDocAssignmentOwner(base, task, id, owner)),
         prepareTaskRetrospectiveReview,
         cancelTaskRetrospectiveReview,
         isRoleMemoryTurn,
-        handleRoleHook,
-        handleHarnessEngineerHook,
+        getDurableDocAssignment,
+        handleRoleHook: (input) => withTaskLock(input.taskRepoRoot, () => handleRoleHook(input)),
+        handleHarnessEngineerHook: (input) => withTaskLock(input.taskRepoRoot, () => handleHarnessEngineerHook(input)),
         assertHarnessEngineerAvailable
     };
 }
@@ -1350,11 +1409,12 @@ function currentDraft(state) {
     return state.drafts.find((draft) => draft.status !== "completed");
 }
 function preserveDisabledReview(state) {
-    return state?.status === "documenting"
+    return Boolean(state?.assignments.length)
         || (state?.status === "reviewing" && Boolean(state.reviewPromptDispatchedAt));
 }
 function currentDurableDocAssignment(state) {
-    return state.assignments.find((assignment) => assignment.status !== "completed");
+    return state.assignments.find((assignment) => assignment.status === "running" || assignment.status === "resolving-owner")
+        ?? state.assignments.find((assignment) => assignment.status === "pending" || assignment.status === "waiting-owner");
 }
 function toReviewCandidates(source, currentRole, items) {
     return items.map((item) => ({
@@ -1435,7 +1495,11 @@ function buildDurableDocAssignmentPrompt(taskRepoRoot, assignment) {
         ...assignment.evidence.map((item) => `- ${item}`),
         "",
         "Verify the content, update the target and any directly related durable documentation, run applicable documentation checks, and commit the documentation changes.",
-        "Submit .ai/vcm/handoffs/docs-update-report.md through vcm-artifact. Set its Assignment ID to the exact ID above and record the final commit.",
+        `Assigned report path: ${assignment.reportPath}`,
+        `Submit with .ai/tools/vcm-artifact docs-update-report --file <candidate> --path ${assignment.reportPath} --mode final`,
+        "Set Assignment ID to the exact ID above.",
+        "For synced, record the commit that changed the target document; it need not be HEAD. If the document already preserves the content, use unchanged with evidence; do not create a redundant commit.",
+        ...(assignment.error ? [`Previous failure: ${assignment.error}`] : []),
         "End the turn after VCM accepts the report."
     ].join("\n");
 }

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

@@ -160,6 +160,7 @@ export function createClaudeHookService(deps) {
                 taskSlug: activeTask.taskSlug,
                 eventName,
                 memoryReviewStatus: memoryState?.status ?? "idle",
+                memoryReviewHasAssignments: Boolean(memoryState?.active?.assignments.length),
                 memoryReviewError: memoryState?.active?.error
             })
             : false;
@@ -352,7 +353,7 @@ export function createClaudeHookService(deps) {
                         dispatchedCount: 0,
                         stopDecision: {
                             behavior: "block",
-                            reason: `Possible unregistered user question: ${JSON.stringify(question.slice(0, 600))}. If you are asking the user, use vcm-ask-user with the exact question, then ask it and end the turn without advancing or routing the workflow. 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.`
+                            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.`
                         }
                     };
                 }
@@ -507,6 +508,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({

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/harness-feedback-service.js

@@ -164,6 +164,7 @@ export function createHarnessFeedbackService(deps) {
             await persistTaskRetrospectiveMarker(repoRoot, {
                 ...processedMarker,
                 status: "failed",
+                durableDocFailure: input.memoryReviewHasAssignments,
                 failedAt: timestamp,
                 updatedAt: timestamp,
                 error: input.memoryReviewError
@@ -185,17 +186,26 @@ export function createHarnessFeedbackService(deps) {
     }
     async function completeWaitingTaskRetrospective(repoRoot, taskSlug, memoryStatus) {
         const marker = await loadTaskRetrospectiveMarker(repoRoot, taskSlug);
-        if (!marker || marker.status !== "waiting-docs") {
+        if (!marker || (marker.status !== "waiting-docs" && !(marker.status === "failed" && marker.durableDocFailure))) {
             return false;
         }
         if (memoryStatus === "documenting") {
+            if (marker.status === "failed") {
+                await persistTaskRetrospectiveMarker(repoRoot, {
+                    ...marker, status: "waiting-docs", updatedAt: now(), error: undefined, failedAt: undefined
+                });
+            }
             return true;
         }
         if (memoryStatus === "failed") {
+            if (marker.status === "failed") {
+                return true;
+            }
             const timestamp = now();
             await persistTaskRetrospectiveMarker(repoRoot, {
                 ...marker,
                 status: "failed",
+                durableDocFailure: true,
                 failedAt: timestamp,
                 updatedAt: timestamp,
                 error: "Task Harness Retrospective durable-document assignment failed."
@@ -214,6 +224,9 @@ export function createHarnessFeedbackService(deps) {
         await persistTaskRetrospectiveMarker(repoRoot, {
             ...processedMarker,
             status: "completed",
+            durableDocFailure: undefined,
+            error: undefined,
+            failedAt: undefined,
             completedAt: timestamp,
             updatedAt: timestamp
         });

package/dist/backend/services/memory-review-paths.js

@@ -6,6 +6,9 @@ const MEMORY_REVIEW_ROLE_DRAFT_PATTERN = new RegExp(`^${escapeRegExp(MEMORY_REVI
 export function memoryReviewRoleDraftPath(runId, role) {
     return `${MEMORY_REVIEW_RUNS_ROOT}/${runId}/drafts/${role}.md`;
 }
+export function durableDocAssignmentReportPath(runId, assignmentId) {
+    return `${MEMORY_REVIEW_RUNS_ROOT}/${runId}/assignments/${assignmentId}/report.md`;
+}
 export function isMemoryProposalSubmissionPath(artifactPath, role) {
     if (artifactPath === ARCHITECT_PLANNING_MEMORY_CANDIDATE_PATH) {
         return role === "architect";