vibe-coding-master 0.7.42 → 0.7.44

package/README.md

@@ -190,6 +190,12 @@ restart, but it does not infer transitions or choose the next role. Current
 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
+a new direct user message clears the wait, and the next role dispatch requires
+a fresh Workflow Review.
+
 Typical flow:
 
 ```text
@@ -329,7 +335,8 @@ strict `workflow-progress.md` transition through `vcm-workflow-review`. VCM
 checks the confirmed dispatch history and current task artifacts, then grants
 one matching route. The target role's `UserPromptSubmit` consumes that approval
 and appends the confirmed transition. A rejected transition can be bypassed
-only by an exact one-time user authorization recorded through the VCM dialog.
+only by the user's exact one-time authorization recorded in the next Workflow
+Progress submission.
 
 If the flow stops, VCM always shows a blocking pause alert. `Pause alert sound`
 only controls the looping sound. Enabling Gateway turns that preference off once;
@@ -474,14 +481,22 @@ Use it to:
 - merge task harness commits back to the connected repository branch when
   appropriate
 
-VCM bundles the Claude Code LSP bridge and loads it for Architect, Coder, and
-Reviewer sessions, including CCR launches. The project environment must still
+VCM bundles the Claude Code LSP bridge and loads it only for Architect sessions,
+including CCR launches. The project environment must still
 provide the language server for each detected language: `rust-analyzer`,
 `typescript-language-server`, `pyright-langserver`, `gopls`, `clangd`, or
-`jdtls`. Their Agent definitions preload `vcm-code-navigation`. Architect,
-Coder, and Reviewer use LSP for semantic relationships. Harness Studio reports
+`jdtls`. Architect preloads `vcm-code-navigation` and uses LSP for semantic
+relationships. Accessors, backing fields, trait items, implementations, wrappers,
+and aliases are queried as separate symbols; a bounded source-text fallback may
+only locate candidates after the correct LSP query is demonstrably partial.
+Other roles use generated context and ordinary source reads.
+Harness Studio reports
 whether the server executable and plugin can run; the role Session performs the
-real workspace warm-up and semantic query retries.
+real workspace indexing and semantic query retries. VCM uses Claude Code progress
+hooks to detect a model response, tool call, subagent, or compaction that may be
+stalled. Detection only opens a warning; it does not interrupt the Session or
+change the Round. The user can ignore that warning or explicitly stop and resume
+the same Claude Session from the warning dialog.
 
 Harness Engineer is task-scoped and runs from the active task worktree. The
 backend automatically starts a fresh Harness Engineer for each active task or
@@ -493,10 +508,11 @@ files.
 `Auto memory` is the switch for the entire automated memory workflow. During
 Review Task Harness after Final Acceptance, Project Manager, Architect, Coder,
 Tester, and an enabled Reviewer submit proposals in sequence through
-`vcm-propose-memory`. Harness Engineer verifies and consolidates them before VCM
-records the result as part of the same Task Harness Retrospective. Workflow roles
-cannot edit active memory directly; Harness Engineer edits it only during the
-assigned Auto Memory Retrospective.
+`vcm-propose-memory`. Harness Engineer verifies and consolidates them, commits
+the reviewed memory, and writes the assigned machine-readable review result as
+part of the same Task Harness Retrospective. Workflow roles cannot edit active
+memory directly; Harness Engineer edits it only during the assigned Auto Memory
+Retrospective.
 
 When Auto Memory is enabled, the planning Architect writes a provisional memory
 candidate before its post-planning Session restart. VCM snapshots that candidate
@@ -523,7 +539,10 @@ Final Acceptance
        -> Review pending Harness Feedback
        -> Review Auto Memory proposals, when Auto Memory is enabled
        -> Harness Engineer updates and commits memory, when Auto Memory is enabled
-  -> VCM records the committed memory result
+       -> Harness Engineer writes review-result.json, when Auto Memory is enabled
+  -> VCM validates and records the committed memory result
+  -> VCM dispatches durable-document assignments one at a time
+  -> Complete Task Harness Retrospective after every assignment completes
 ```
 
 Memory proposal prompts sent to Project Manager, Architect, Coder, Tester, and
@@ -537,16 +556,29 @@ impact, and durable-document disposition, then evaluates every proposal item
 independently. Each Add or Update decision records why the memory is necessary,
 what happens if it is absent, whether it belongs in memory or a durable
 document, and the exact final memory content when retained. VCM validates that
-the commit changes only assigned memory host files and only their
-`<VCM-memory>` blocks; it does not parse or apply Harness Engineer's semantic
-decisions. Harness Engineer review and retrospective work remain tool role
-activity and do not participate in Round completion.
+every existing entry and proposal has one structurally valid decision, every
+move decision has one durable-document assignment, moved content has already
+been removed from memory, and the commit changes only assigned memory host
+files and only their `<VCM-memory>` blocks. VCM does not decide whether the
+Harness Engineer's semantic judgment is correct. Harness Engineer review and
+retrospective work remain tool role activity and do not participate in Round
+completion.
+
+For `move-to-durable-doc`, memory is removed in the Harness Engineer commit
+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.
 
 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
 review requests collect proposals before starting the retrospective. A failed
-proposal collection or combined retrospective memory review must be retried
-from Harness Studio.
+proposal collection, combined retrospective memory review, or durable-document
+assignment must be retried from Harness Studio.
 
 ## Closing a Task
 

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

@@ -144,6 +144,9 @@ function artifactNameToPath(paths, artifactName) {
     if (artifactName === "test-report.md") {
         return paths.testReportPath;
     }
+    if (artifactName === "docs-update-report.md") {
+        return paths.docsUpdateReportPath;
+    }
     if (artifactName === "docs-sync-report.md") {
         return paths.docsSyncReportPath;
     }

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

@@ -208,6 +208,22 @@ export function registerHarnessRoutes(app, deps) {
         const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
         return deps.autoMemoryService.retryFailedReview(project.repoRoot, task.worktreePath);
     });
+    app.post("/api/projects/harness/memory/assignments/retry", async (request) => {
+        const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
+        return deps.autoMemoryService.retryDurableDocAssignment(project.repoRoot, task.worktreePath, request.body?.assignmentId ?? "");
+    });
+    app.post("/api/projects/harness/memory/assignments/owner", async (request) => {
+        const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
+        const owner = request.body?.owner;
+        if (owner !== "architect" && owner !== "coder" && owner !== "tester") {
+            throw new VcmError({
+                code: "DURABLE_DOC_OWNER_INVALID",
+                message: "Durable-document owner must be architect, coder, or tester.",
+                statusCode: 400
+            });
+        }
+        return deps.autoMemoryService.resolveDurableDocAssignmentOwner(project.repoRoot, task.worktreePath, request.body?.assignmentId ?? "", owner);
+    });
 }
 async function persistHarnessEngineerDefaults(appSettings, session) {
     const defaults = createDefaultToolSessionDefaults()["harness-engineer"];

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

@@ -71,7 +71,8 @@ export function registerTaskRoutes(app, deps) {
                 orchestration,
                 roundState,
                 workflowState,
-                architectRestart: deps.architectRestartService.getState(project.repoRoot, taskSlug)
+                architectRestart: deps.architectRestartService.getState(project.repoRoot, taskSlug),
+                roleStallWarning: deps.roleStallDetector.getWarning(project.repoRoot, taskSlug)
             };
         }
         catch (error) {
@@ -86,12 +87,30 @@ export function registerTaskRoutes(app, deps) {
                     },
                     roundState: degradedRoundState(taskSlug),
                     workflowState: degradedWorkflowState(taskSlug),
-                    architectRestart: deps.architectRestartService.getState(repoRoot, taskSlug)
+                    architectRestart: deps.architectRestartService.getState(repoRoot, taskSlug),
+                    roleStallWarning: deps.roleStallDetector.getWarning(repoRoot, taskSlug)
                 };
             }
             throw error;
         }
     });
+    app.post("/api/tasks/:taskSlug/role-stall/ignore", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.roleStallDetector.ignoreWarning(project.repoRoot, request.params.taskSlug, requireWarningId(request.body?.warningId));
+    });
+    app.post("/api/tasks/:taskSlug/role-stall/recover", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const config = await deps.projectService.loadConfig(project.repoRoot);
+        const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+        return deps.roleStallDetector.recoverWarning({
+            repoRoot: project.repoRoot,
+            taskRepoRoot,
+            stateRoot: config.stateRoot,
+            taskSlug: task.taskSlug,
+            warningId: requireWarningId(request.body?.warningId)
+        });
+    });
     app.post("/api/tasks/:taskSlug/workflow-state", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const config = await deps.projectService.loadConfig(project.repoRoot);
@@ -117,6 +136,16 @@ export function registerTaskRoutes(app, deps) {
         return deps.taskCloseService.closeTask(project.repoRoot, request.params.taskSlug);
     });
 }
+function requireWarningId(value) {
+    if (typeof value === "string" && value.trim()) {
+        return value.trim();
+    }
+    throw new VcmError({
+        code: "ROLE_STALL_WARNING_ID_REQUIRED",
+        message: "A role stall warning id is required.",
+        statusCode: 400
+    });
+}
 async function requireCurrentProject(projectService) {
     const project = await projectService.getCurrentProject();
     if (!project) {
@@ -206,6 +235,7 @@ function degradedArtifactSummary(handoffDir) {
             architectDebugPath: `${handoffDir}/architect-debug.md`,
             architectureDiagnosisPath: `${handoffDir}/architecture-diagnosis.md`,
             testReportPath: `${handoffDir}/test-report.md`,
+            docsUpdateReportPath: `${handoffDir}/docs-update-report.md`,
             docsSyncReportPath: `${handoffDir}/docs-sync-report.md`,
             workflowProgressPath: `${handoffDir}/workflow-progress.md`,
             finalAcceptancePath: `${handoffDir}/final-acceptance.md`

package/dist/backend/api/workflow-control-routes.js

@@ -1,30 +1,21 @@
 import { VcmError } from "../errors.js";
-import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
 export function registerWorkflowControlRoutes(app, deps) {
     app.get("/api/tasks/:taskSlug/workflow-control", async (request) => {
         const context = await getContext(deps, request.params.taskSlug);
         return deps.workflowControlService.getState(context);
     });
-    app.post("/api/tasks/:taskSlug/workflow-overrides/:overrideId/approve", async (request) => {
-        const authorizationText = request.body?.authorizationText?.trim();
-        if (!authorizationText) {
+    app.post("/api/tasks/:taskSlug/ask-user", async (request) => {
+        const context = await getContext(deps, request.params.taskSlug);
+        const question = typeof request.body?.question === "string" ? request.body.question.trim() : "";
+        if (!question) {
             throw new VcmError({
-                code: "WORKFLOW_OVERRIDE_AUTHORIZATION_REQUIRED",
-                message: "Enter the exact workflow exception that the user authorizes.",
+                code: "WORKFLOW_USER_QUESTION_REQUIRED",
+                message: "A non-empty user question is required.",
                 statusCode: 400
             });
         }
-        const context = await getContext(deps, request.params.taskSlug);
-        const state = await deps.workflowControlService.approveOverride(context, request.params.overrideId, authorizationText);
-        await notifyProjectManager(deps, context, request.params.overrideId, "approved", authorizationText);
-        return state;
-    });
-    app.post("/api/tasks/:taskSlug/workflow-overrides/:overrideId/reject", async (request) => {
-        const context = await getContext(deps, request.params.taskSlug);
-        const state = await deps.workflowControlService.rejectOverride(context, request.params.overrideId);
-        await notifyProjectManager(deps, context, request.params.overrideId, "rejected");
-        return state;
+        return deps.workflowControlService.requestUserInput(context, question);
     });
 }
 async function getContext(deps, taskSlug) {
@@ -44,13 +35,3 @@ async function getContext(deps, taskSlug) {
         taskSlug: task.taskSlug
     };
 }
-async function notifyProjectManager(deps, context, overrideId, decision, authorizationText) {
-    const session = await deps.sessionService.getRoleSession(context.repoRoot, context.taskSlug, "project-manager");
-    if (!session || session.status !== "running" || session.activityStatus === "running")
-        return;
-    const prompt = decision === "approved"
-        ? `[VCM Workflow Override Decision]\nDecision: approved\nAuthorization ID: ${overrideId}\nAuthorization Text: ${authorizationText}\n\nResubmit workflow-progress.md with this Authorization ID and exact Authorization Text.`
-        : `[VCM Workflow Override Decision]\nDecision: rejected\nAuthorization ID: ${overrideId}\n\nKeep the current workflow and choose a legal next dispatch.`;
-    await submitTerminalInput(deps.runtime, session.id, prompt);
-    await deps.sessionService.markRoleActivityRunning(context.repoRoot, context.taskSlug, "project-manager", session.id);
-}

package/dist/backend/cli/install-vcm-harness.js

@@ -28,10 +28,12 @@ import { renderVcmLongRunningValidationSkillRules } from "../templates/harness/v
 import { renderVcmProposeMemorySkillRules } from "../templates/harness/vcm-propose-memory-skill.js";
 import { renderVcmReportHarnessIssueSkillRules } from "../templates/harness/vcm-report-harness-issue-skill.js";
 import { renderVcmRouteMessageSkillRules } from "../templates/harness/vcm-route-message-skill.js";
+import { renderAskUserTool, renderVcmAskUserSkillRules } from "../templates/harness/vcm-ask-user-skill.js";
 import { renderUpdateTaskStateTool, renderVcmTaskStateSkillRules } from "../templates/harness/vcm-task-state-skill.js";
 import { renderVcmWorkflowReviewSkillRules } from "../templates/harness/vcm-workflow-review-skill.js";
 import { renderCheckScaffoldLedgerTool } from "../templates/harness/check-scaffold-ledger.js";
 import { renderRequestArchitectRestartTool, renderRestartArchitectSkillRules } from "../templates/harness/restart-architect-skill.js";
+import { renderResolveDurableDocAssignmentTool } from "../templates/harness/resolve-durable-doc-assignment.js";
 import { readVcmPackageVersion } from "../app-version.js";
 const CLI_DIR = path.dirname(fileURLToPath(import.meta.url));
 const APP_ROOT = path.resolve(CLI_DIR, "../../..");
@@ -57,8 +59,15 @@ const VCM_HOOK_DEFINITIONS = [
     { eventName: "PreToolUse", matcher: "Bash", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
     { eventName: "PreToolUse", matcher: "Write|Edit", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
     { eventName: "UserPromptSubmit", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "PreToolUse", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "PostToolUse", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "PostToolUseFailure", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "PostToolBatch", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "SubagentStart", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "SubagentStop", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "Stop", command: VCM_STOP_HOOK_COMMAND, timeout: 10 },
     { eventName: "StopFailure", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "PreCompact", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "PostCompact", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "PermissionRequest", command: VCM_PERMISSION_REQUEST_HOOK_COMMAND, timeout: 5 }
 ];
@@ -74,8 +83,7 @@ const AGENT_FRONTMATTER = {
     },
     coder: {
         description: "VCM implementation role for scoped code changes and focused tests.",
-        disallowedTools: CODE_ROLE_DISALLOWED_TOOLS.join(", "),
-        skills: ["vcm-code-navigation"]
+        disallowedTools: CODE_ROLE_DISALLOWED_TOOLS.join(", ")
     },
     tester: {
         description: "VCM testing role for validation, test adequacy, approved-scope validation, and risk findings.",
@@ -83,8 +91,7 @@ const AGENT_FRONTMATTER = {
     },
     reviewer: {
         description: "VCM independent gate review role for architecture plans, validation adequacy, and code diffs.",
-        disallowedTools: REVIEWER_DISALLOWED_TOOLS.join(", "),
-        skills: ["vcm-code-navigation"]
+        disallowedTools: REVIEWER_DISALLOWED_TOOLS.join(", ")
     },
     translator: {
         description: "VCM task-scoped translation tool role for conversation translation, file translation, bootstrap, and memory updates."
@@ -114,7 +121,9 @@ const REQUIRED_AGENT_TOOLS = {
     "harness-engineer": ["Skill"]
 };
 const REQUIRED_AGENT_SKILLS = {
-    architect: ["vcm-code-navigation"],
+    architect: ["vcm-code-navigation"]
+};
+const REMOVED_AGENT_SKILLS = {
     coder: ["vcm-code-navigation"],
     reviewer: ["vcm-code-navigation"]
 };
@@ -285,7 +294,7 @@ const WHOLE_FILES = [
         path: ".claude/skills/vcm-code-navigation/SKILL.md",
         category: "skill",
         mode: 0o644,
-        content: renderSkillFile("VCM Code Navigation Skill", "vcm-code-navigation", "Use when Architect, Coder, or Reviewer must resolve code symbols, references, implementations, call hierarchies, or bounded dependency paths.", renderVcmCodeNavigationSkillRules())
+        content: renderSkillFile("VCM Code Navigation Skill", "vcm-code-navigation", "Use when Architect must resolve code symbols, references, implementations, call hierarchies, or bounded dependency paths.", renderVcmCodeNavigationSkillRules())
     },
     {
         path: ".claude/skills/vcm-final-acceptance/SKILL.md",
@@ -311,6 +320,12 @@ const WHOLE_FILES = [
         mode: 0o644,
         content: renderSkillFile("VCM Route Message Skill", "vcm-route-message", "Use when project-manager dispatches a VCM role or when a VCM role reports a question, result, blocker, or finding back to project-manager.", renderVcmRouteMessageSkillRules())
     },
+    {
+        path: ".claude/skills/vcm-ask-user/SKILL.md",
+        category: "skill",
+        mode: 0o644,
+        content: renderSkillFile("VCM Ask User Skill", "vcm-ask-user", "Use whenever project-manager asks the user a question and must pause the workflow.", renderVcmAskUserSkillRules())
+    },
     {
         path: ".claude/skills/vcm-task-state/SKILL.md",
         category: "skill",
@@ -353,6 +368,12 @@ const WHOLE_FILES = [
         mode: 0o755,
         content: renderRequestGateReviewTool()
     },
+    {
+        path: ".ai/tools/vcm-ask-user",
+        category: "runtime-tool",
+        mode: 0o755,
+        content: renderAskUserTool()
+    },
     {
         path: ".ai/tools/update-task-state",
         category: "runtime-tool",
@@ -371,6 +392,12 @@ const WHOLE_FILES = [
         mode: 0o755,
         content: renderRequestArchitectRestartTool()
     },
+    {
+        path: ".ai/tools/resolve-durable-doc-assignment",
+        category: "runtime-tool",
+        mode: 0o755,
+        content: renderResolveDurableDocAssignmentTool()
+    },
     {
         path: ".ai/tools/run-long-check",
         category: "runtime-tool",
@@ -635,6 +662,7 @@ function fixedDirectories() {
         ".claude/skills/vcm-harness-bootstrap/",
         ".claude/skills/vcm-long-running-validation/",
         ".claude/skills/vcm-route-message/",
+        ".claude/skills/vcm-ask-user/",
         ".claude/skills/vcm-task-state/",
         ".claude/skills/vcm-workflow-review/",
         ".claude/skills/vcm-gate-review/",
@@ -711,6 +739,9 @@ async function installManagedFile({ projectRoot, definition, dryRun, operations
     for (const requiredSkill of REQUIRED_AGENT_SKILLS[definition.agentName] ?? []) {
         nextContent = ensureAgentSkill(nextContent, requiredSkill);
     }
+    for (const removedSkill of REMOVED_AGENT_SKILLS[definition.agentName] ?? []) {
+        nextContent = removeAgentSkill(nextContent, removedSkill);
+    }
     await writeIfChanged({
         targetPath,
         relativePath: definition.path,
@@ -829,6 +860,30 @@ function ensureAgentSkill(content, requiredSkill) {
     const nextSkills = `${skillsMatch[0].trimEnd()}\n  - ${requiredSkill}`;
     return content.replace(frontmatter, frontmatter.replace(skillsMatch[0], nextSkills));
 }
+function removeAgentSkill(content, removedSkill) {
+    const frontmatterMatch = content.match(/^---\r?\n[\s\S]*?\r?\n---/);
+    if (!frontmatterMatch) {
+        return content;
+    }
+    const frontmatter = frontmatterMatch[0];
+    const skillsMatch = frontmatter.match(/^skills:[ \t]*(?:\r?\n((?:\s+-\s+[^\r\n]+\r?\n?)*))?/m);
+    if (!skillsMatch) {
+        return content;
+    }
+    const listedSkills = (skillsMatch[1] ?? "")
+        .split(/\r?\n/)
+        .map((line) => line.match(/^\s+-\s+(.+)$/)?.[1]?.trim())
+        .filter(Boolean);
+    const remainingSkills = listedSkills.filter((skill) => skill !== removedSkill);
+    if (remainingSkills.length === listedSkills.length) {
+        return content;
+    }
+    const lineEnding = skillsMatch[0].includes("\r\n") ? "\r\n" : "\n";
+    const replacement = remainingSkills.length > 0
+        ? `skills:${lineEnding}${remainingSkills.map((skill) => `  - ${skill}`).join(lineEnding)}${lineEnding}`
+        : "";
+    return content.replace(frontmatter, frontmatter.replace(skillsMatch[0], replacement));
+}
 function migrateLegacyManagedFile(definition, currentContent, block) {
     const legacyContent = definition.legacyWholeFile?.trimEnd();
     if (!legacyContent) {

package/dist/backend/role-tool-policy.js

@@ -44,7 +44,7 @@ export const REVIEWER_RUNTIME_DISALLOWED_TOOLS = [
     "Edit",
     ...NON_VCM_ROLE_RUNTIME_TOOLS
 ];
-const LSP_ROLE_NAMES = new Set(["architect", "coder", "reviewer"]);
+const LSP_ROLE_NAMES = new Set(["architect"]);
 export function roleUsesLsp(role) {
     return LSP_ROLE_NAMES.has(role);
 }

package/dist/backend/server.js

@@ -13,6 +13,7 @@ import { createAppSettingsService } from "./services/app-settings-service.js";
 import { createCcrIntegrationService } from "./services/ccr-integration-service.js";
 import { createAutoMemoryService } from "./services/auto-memory-service.js";
 import { createArchitectRestartService } from "./services/architect-restart-service.js";
+import { createRoleStallDetectorService } from "./services/role-stall-detector-service.js";
 import { createClaudeTranscriptService } from "./services/claude-transcript-service.js";
 import { createGateReviewService } from "./services/gate-review-service.js";
 import { createHarnessFeedbackService } from "./services/harness-feedback-service.js";
@@ -134,7 +135,8 @@ export async function createServer(deps, options = {}) {
         taskLaunchService: deps.taskLaunchService,
         roundService: deps.roundService,
         taskWorkflowService: deps.taskWorkflowService,
-        architectRestartService: deps.architectRestartService
+        architectRestartService: deps.architectRestartService,
+        roleStallDetector: deps.roleStallDetector
     });
     registerSessionRoutes(app, {
         projectService: deps.projectService,
@@ -154,9 +156,7 @@ export async function createServer(deps, options = {}) {
         registerWorkflowControlRoutes(app, {
             projectService: deps.projectService,
             taskService: deps.taskService,
-            sessionService: deps.sessionService,
-            workflowControlService: deps.workflowControlService,
-            runtime: deps.runtime
+            workflowControlService: deps.workflowControlService
         });
     }
     registerMessageRoutes(app, {
@@ -332,6 +332,7 @@ export function createDefaultServerDeps(options = {}) {
         appSettings,
         sessionService,
         roundService,
+        workflowControlService,
         onArchitecturePlanDisposition: ({ repoRoot, taskSlug, accepted }) => architectRestartService.recordArchitectureGateDisposition(repoRoot, taskSlug, accepted)
     });
     const translationWorkerService = createTranslationWorkerService({
@@ -340,6 +341,10 @@ export function createDefaultServerDeps(options = {}) {
         sessionService
     });
     const transcripts = createClaudeTranscriptService();
+    const roleStallDetector = createRoleStallDetectorService({
+        sessionService,
+        roundService
+    });
     const translationService = createTranslationService({
         runtime,
         sessionRegistry: registry,
@@ -411,7 +416,9 @@ export function createDefaultServerDeps(options = {}) {
         gatewayService,
         jobGuard: createJobGuardService(),
         translationWorkerService,
-        architectRestartService
+        architectRestartService,
+        roleStallDetector,
+        workflowControlService
     });
     const runtimeCoordinator = createRuntimeCoordinatorService({
         appSettings,
@@ -423,6 +430,7 @@ export function createDefaultServerDeps(options = {}) {
         harnessFeedbackService,
         autoMemoryService,
         roundService,
+        roleStallDetector,
         gatewayService,
         async getStateRoot(repoRoot) {
             return (await projectService.loadConfig(repoRoot)).stateRoot;
@@ -463,6 +471,7 @@ export function createDefaultServerDeps(options = {}) {
         autoMemoryService,
         commandDispatcher,
         claudeHookService,
+        roleStallDetector,
         messageService,
         taskLaunchService,
         gateReviewService,

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

@@ -4,9 +4,10 @@ import { checkMarkdownArtifact } from "../../shared/validation/artifact-check.js
 import { getArtifactDefinition, isArtifactKind } from "../../shared/validation/artifact-registry.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
-import { renderArchitectureBriefTemplate, renderArchitectureDiagnosisTemplate, renderArchitectureEvidenceTemplate, renderArchitecturePlanTemplate, renderArchitectDebugTemplate, renderCoderCompletionTemplate, renderDocsSyncReportTemplate, renderFinalAcceptanceTemplate, renderKnownIssuesTemplate, renderPlanningProgressTemplate, renderMessageRouteTemplate, renderTestReportTemplate, renderWorkflowProgressTemplate } from "../templates/handoff.js";
+import { renderArchitectureBriefTemplate, renderArchitectureDiagnosisTemplate, renderArchitectureEvidenceTemplate, renderArchitecturePlanTemplate, renderArchitectDebugTemplate, renderCoderCompletionTemplate, renderDocsUpdateReportTemplate, renderDocsSyncReportTemplate, renderFinalAcceptanceTemplate, renderKnownIssuesTemplate, renderPlanningProgressTemplate, renderMessageRouteTemplate, renderTestReportTemplate, renderWorkflowProgressTemplate } from "../templates/handoff.js";
 import { renderRoleCommandTemplate } from "../templates/role-command.js";
 import { validateMemoryProposal } from "./memory-proposal-validation.js";
+import { isMemoryProposalSubmissionPath } from "./memory-review-paths.js";
 const ARTIFACT_PATH_KEYS = [
     ["architecture-brief", "architectureBriefPath"],
     ["architecture-evidence", "architectureEvidencePath"],
@@ -17,6 +18,7 @@ const ARTIFACT_PATH_KEYS = [
     ["architect-debug", "architectDebugPath"],
     ["architecture-diagnosis", "architectureDiagnosisPath"],
     ["test-report", "testReportPath"],
+    ["docs-update-report", "docsUpdateReportPath"],
     ["docs-sync-report", "docsSyncReportPath"],
     ["workflow-progress", "workflowProgressPath"],
     ["final-acceptance", "finalAcceptancePath"]
@@ -54,6 +56,7 @@ export function createArtifactService(fs, deps = {}) {
                 architectDebugPath: path.posix.join(handoffDir, "architect-debug.md"),
                 architectureDiagnosisPath: path.posix.join(handoffDir, "architecture-diagnosis.md"),
                 testReportPath: path.posix.join(handoffDir, "test-report.md"),
+                docsUpdateReportPath: path.posix.join(handoffDir, "docs-update-report.md"),
                 docsSyncReportPath: path.posix.join(handoffDir, "docs-sync-report.md"),
                 workflowProgressPath: path.posix.join(handoffDir, "workflow-progress.md"),
                 finalAcceptancePath: path.posix.join(handoffDir, "final-acceptance.md")
@@ -84,6 +87,7 @@ export function createArtifactService(fs, deps = {}) {
                 [paths.architectDebugPath, renderArchitectDebugTemplate(input.taskSlug)],
                 [paths.architectureDiagnosisPath, renderArchitectureDiagnosisTemplate(input.taskSlug)],
                 [paths.testReportPath, renderTestReportTemplate(input.taskSlug)],
+                [paths.docsUpdateReportPath, renderDocsUpdateReportTemplate(input.taskSlug)],
                 [paths.docsSyncReportPath, renderDocsSyncReportTemplate(input.taskSlug)],
                 [paths.workflowProgressPath, renderWorkflowProgressTemplate(input.taskSlug)],
                 [paths.finalAcceptancePath, renderFinalAcceptanceTemplate(input.taskSlug)],
@@ -189,10 +193,11 @@ export function createArtifactService(fs, deps = {}) {
             }
             if (isArtifactKind(input.kind)) {
                 const definition = getArtifactDefinition(input.kind);
-                if (definition.owner !== input.role) {
+                const owners = Array.isArray(definition.owner) ? definition.owner : [definition.owner];
+                if (!owners.includes(input.role)) {
                     throw new VcmError({
                         code: "ARTIFACT_OWNER_MISMATCH",
-                        message: `${input.kind} is owned by ${definition.owner}, not ${input.role}.`,
+                        message: `${input.kind} is owned by ${owners.join("|")}, not ${input.role}.`,
                         statusCode: 403
                     });
                 }
@@ -314,8 +319,8 @@ async function validateDynamicArtifact(fs, input, content, workflowControlServic
         if (!VCM_ROLE_NAMES.includes(input.role)) {
             throw artifactRejected(input.kind, ["Only a VCM workflow role may submit a Memory Proposal."]);
         }
-        if (!/^\.ai\/vcm\/memory-review\/(?:runs\/[A-Za-z0-9._-]+\/drafts|candidates)\/[A-Za-z0-9._-]+\.md$/.test(artifactPath)) {
-            throw artifactRejected(input.kind, ["Memory proposal path is outside the VCM memory-review draft locations."]);
+        if (!isMemoryProposalSubmissionPath(artifactPath, input.role)) {
+            throw artifactRejected(input.kind, ["Memory proposal path is not assigned to the submitting role."]);
         }
         const memoryError = validateMemoryProposal(content);
         if (memoryError) {
@@ -333,39 +338,12 @@ async function validateDynamicArtifact(fs, input, content, workflowControlServic
         validateHarnessFeedback(content);
         return { kind: input.kind, root: input.baseRepoRoot, path: artifactPath };
     }
-    if (input.kind === "retrospective-report") {
-        if (input.role !== "harness-engineer") {
-            throw artifactRejected(input.kind, ["Only Harness Engineer may submit a retrospective report."]);
-        }
-        if (!/^\.ai\/vcm\/harness-feedback\/task-retrospectives\/[A-Za-z0-9._-]+\.md$/.test(artifactPath)) {
-            throw artifactRejected(input.kind, ["Retrospective report path must be under .ai/vcm/harness-feedback/task-retrospectives/."]);
-        }
-        validateRetrospectiveReport(content);
-        return { kind: input.kind, root: input.baseRepoRoot, path: artifactPath };
-    }
     throw new VcmError({
         code: "ARTIFACT_KIND_INVALID",
         message: `Unknown managed artifact kind: ${input.kind}`,
         statusCode: 400
     });
 }
-function validateRetrospectiveReport(content) {
-    const errors = getRetrospectiveReportErrors(content);
-    if (errors.length > 0)
-        throw artifactRejected("retrospective-report", errors);
-}
-export function getRetrospectiveReportErrors(content) {
-    const errors = [];
-    if (!/^# Task Harness Retrospective(?::\s*.+)?\s*$/m.test(content)) {
-        errors.push("Retrospective report requires '# Task Harness Retrospective: <task>'.");
-    }
-    for (const heading of ["Findings", "Feedback Dispositions", "Recommended Harness Changes", "VCM Issue Drafts"]) {
-        if (!new RegExp(`^## ${escapeRegExp(heading)}\\s*$`, "m").test(content)) {
-            errors.push(`Missing required section: ${heading}.`);
-        }
-    }
-    return errors;
-}
 function validateCoderWorkerReport(content) {
     const errors = [];
     if (!/^# Coder Worker Report:\s*\S.+$/m.test(content)) {