vibe-coding-master 0.7.38 → 0.7.40

package/README.md

@@ -324,6 +324,13 @@ Automatic mode:
 - the UI switches to the target role before dispatch
 - Claude Code hooks confirm whether the prompt was accepted
 
+Before Project Manager can dispatch Architect, Coder, or Tester, it submits a
+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.
+
 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;
 it can be turned back on afterward. A new Gateway command closes an open pause
@@ -455,7 +462,7 @@ Harness Studio is the UI for VCM harness maintenance.
 Use it to:
 
 - inspect fixed harness status
-- inspect detected project languages and verified language-server readiness
+- inspect detected project languages and language-server availability
 - run bootstrap
 - open Harness Engineer
 - review harness files
@@ -471,11 +478,10 @@ VCM bundles the Claude Code LSP bridge and loads it for Architect, Coder, and
 Reviewer 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`. Architect, Coder, and Reviewer do not receive the Grep tool, and the
-Harness guard rejects shell text-search commands for those roles so unresolved
-semantic relationships cannot be hidden by textual fallback. Harness Studio
-reports a missing executable or failed readiness probe
-with the backend diagnostic.
+`jdtls`. Their Agent definitions preload `vcm-code-navigation`. Architect,
+Coder, and Reviewer use LSP for semantic relationships. Harness Studio reports
+whether the server executable and plugin can run; the role Session performs the
+real workspace warm-up and semantic query retries.
 
 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

package/dist/backend/adapters/claude-adapter.js

@@ -20,6 +20,7 @@ export function createClaudeAdapter(runner) {
         },
         buildRoleStartCommand(role, command = "claude", permissionMode = "default", claudeSessionId, resume = false, model = "default", effort = "default", settingsOverride, appendSystemPrompt, pluginDirs = []) {
             const args = pluginDirs.flatMap((pluginDir) => ["--plugin-dir", pluginDir]);
+            args.push("--allowedTools", "Glob,Grep");
             args.push("--agent", role);
             const sessionSettings = { ...settingsOverride };
             if (claudeSessionId) {

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

@@ -1,4 +1,4 @@
-import { isDispatchableRole } from "../../shared/constants.js";
+import { isDispatchableRole, isRoleName } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
 export function registerArtifactRoutes(app, deps) {
@@ -52,6 +52,59 @@ export function registerArtifactRoutes(app, deps) {
         });
         return { ok: true };
     });
+    app.post("/api/tasks/:taskSlug/artifacts/submit", 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 body = request.body;
+        if (!body || !isRoleName(body.role)) {
+            throw new VcmError({
+                code: "ARTIFACT_ROLE_INVALID",
+                message: `Unknown artifact role: ${body?.role ?? "missing"}`,
+                statusCode: 400
+            });
+        }
+        if (body.mode !== "draft" && body.mode !== "final") {
+            throw new VcmError({
+                code: "ARTIFACT_MODE_INVALID",
+                message: "Artifact mode must be draft or final.",
+                statusCode: 400
+            });
+        }
+        if (typeof body.content !== "string") {
+            throw new VcmError({
+                code: "ARTIFACT_CONTENT_INVALID",
+                message: "Artifact content must be text.",
+                statusCode: 400
+            });
+        }
+        const session = body.role === "translator"
+            ? await deps.sessionService.getProjectTranslatorSession(project.repoRoot)
+            : body.role === "harness-engineer"
+                ? await deps.sessionService.getRoleSession(project.repoRoot, task.taskSlug, body.role)
+                    ?? await deps.sessionService.getProjectHarnessEngineerSession(project.repoRoot)
+                : await deps.sessionService.getRoleSession(project.repoRoot, task.taskSlug, body.role);
+        if (!session || !session.runtimeSessionToken || session.runtimeSessionToken !== body.runtimeSessionToken) {
+            throw new VcmError({
+                code: "ARTIFACT_SESSION_INVALID",
+                message: `${body.role} does not have the active VCM Session that owns this artifact submission.`,
+                statusCode: 409,
+                hint: "Submit from the active role terminal with .ai/tools/vcm-artifact."
+            });
+        }
+        return deps.artifactService.submitArtifact({
+            repoRoot: getTaskRuntimeRepoRoot(task),
+            baseRepoRoot: project.repoRoot,
+            stateRoot: config.stateRoot,
+            handoffDir: task.handoffDir,
+            taskSlug: task.taskSlug,
+            kind: body.kind,
+            mode: body.mode,
+            role: body.role,
+            content: body.content,
+            artifactPath: body.path
+        });
+    });
 }
 function parseDispatchableRole(role) {
     if (!isDispatchableRole(role)) {
@@ -67,18 +120,36 @@ function artifactNameToPath(paths, artifactName) {
     if (artifactName === "architecture-brief.md") {
         return paths.architectureBriefPath;
     }
+    if (artifactName === "architecture-evidence.md") {
+        return paths.architectureEvidencePath;
+    }
+    if (artifactName === "planning-progress.md") {
+        return paths.planningProgressPath;
+    }
     if (artifactName === "architecture-plan.md") {
         return paths.architecturePlanPath;
     }
     if (artifactName === "known-issues.md") {
         return paths.knownIssuesPath;
     }
+    if (artifactName === "coder-completion.md") {
+        return paths.coderCompletionPath;
+    }
+    if (artifactName === "architect-debug.md") {
+        return paths.architectDebugPath;
+    }
+    if (artifactName === "architecture-diagnosis.md") {
+        return paths.architectureDiagnosisPath;
+    }
     if (artifactName === "test-report.md") {
         return paths.testReportPath;
     }
     if (artifactName === "docs-sync-report.md") {
         return paths.docsSyncReportPath;
     }
+    if (artifactName === "workflow-progress.md") {
+        return paths.workflowProgressPath;
+    }
     if (artifactName === "final-acceptance.md") {
         return paths.finalAcceptancePath;
     }

package/dist/backend/api/runtime-state-routes.js

@@ -23,15 +23,25 @@ export function registerRuntimeStateRoutes(app, deps) {
                 harnessBootstrapStatus: null,
                 harnessFeedbackState,
                 autoMemoryState: null,
-                gatewayStatus: coordinated.gatewayStatus
+                gatewayStatus: coordinated.gatewayStatus,
+                workflowControlState: null
             };
         }
         try {
             const task = await deps.taskService.loadTask(project.repoRoot, taskSlug);
-            const [harnessStatus, harnessBootstrapStatus, autoMemoryState] = await Promise.all([
+            const config = deps.workflowControlService
+                ? await deps.projectService.loadConfig(project.repoRoot)
+                : null;
+            const [harnessStatus, harnessBootstrapStatus, autoMemoryState, workflowControlState] = await Promise.all([
                 withOpenFileLimitFallback(() => deps.harnessService.getHarnessStatus(task.worktreePath), (error) => degradedHarnessStatus(error)),
                 withOpenFileLimitFallback(() => deps.harnessService.getBootstrapStatus(project.repoRoot, task.worktreePath, task.taskSlug), (error) => degradedBootstrapStatus(error)),
-                deps.autoMemoryService.getState(project.repoRoot, task.worktreePath)
+                deps.autoMemoryService.getState(project.repoRoot, task.worktreePath),
+                deps.workflowControlService && config ? deps.workflowControlService.getState({
+                    taskRepoRoot: task.worktreePath,
+                    stateRoot: config.stateRoot,
+                    handoffDir: task.handoffDir,
+                    taskSlug: task.taskSlug
+                }) : Promise.resolve(null)
             ]);
             return {
                 translatorSession,
@@ -41,7 +51,8 @@ export function registerRuntimeStateRoutes(app, deps) {
                 harnessBootstrapStatus,
                 harnessFeedbackState,
                 autoMemoryState,
-                gatewayStatus: coordinated.gatewayStatus
+                gatewayStatus: coordinated.gatewayStatus,
+                workflowControlState
             };
         }
         catch (error) {
@@ -54,7 +65,8 @@ export function registerRuntimeStateRoutes(app, deps) {
                     harnessBootstrapStatus: degradedBootstrapStatus(error),
                     harnessFeedbackState,
                     autoMemoryState: null,
-                    gatewayStatus: coordinated.gatewayStatus
+                    gatewayStatus: coordinated.gatewayStatus,
+                    workflowControlState: null
                 };
             }
             throw error;

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

@@ -198,10 +198,16 @@ function degradedArtifactSummary(handoffDir) {
             roleCommandPaths: Object.fromEntries(DISPATCHABLE_ROLES.map((role) => [role, `${roleCommandsDir}/${role}.md`])),
             messageRoutePaths: {},
             architectureBriefPath: `${handoffDir}/architecture-brief.md`,
+            architectureEvidencePath: `${handoffDir}/architecture-evidence.md`,
+            planningProgressPath: `${handoffDir}/planning-progress.md`,
             architecturePlanPath: `${handoffDir}/architecture-plan.md`,
             knownIssuesPath: `${handoffDir}/known-issues.md`,
+            coderCompletionPath: `${handoffDir}/coder-completion.md`,
+            architectDebugPath: `${handoffDir}/architect-debug.md`,
+            architectureDiagnosisPath: `${handoffDir}/architecture-diagnosis.md`,
             testReportPath: `${handoffDir}/test-report.md`,
             docsSyncReportPath: `${handoffDir}/docs-sync-report.md`,
+            workflowProgressPath: `${handoffDir}/workflow-progress.md`,
             finalAcceptancePath: `${handoffDir}/final-acceptance.md`
         },
         checks: []

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

@@ -0,0 +1,56 @@
+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) {
+            throw new VcmError({
+                code: "WORKFLOW_OVERRIDE_AUTHORIZATION_REQUIRED",
+                message: "Enter the exact workflow exception that the user authorizes.",
+                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;
+    });
+}
+async function getContext(deps, taskSlug) {
+    const project = await deps.projectService.getCurrentProject();
+    if (!project) {
+        throw new VcmError({ code: "PROJECT_NOT_CONNECTED", message: "Connect a repository first.", statusCode: 409 });
+    }
+    const [config, task] = await Promise.all([
+        deps.projectService.loadConfig(project.repoRoot),
+        deps.taskService.loadTask(project.repoRoot, taskSlug)
+    ]);
+    return {
+        repoRoot: project.repoRoot,
+        taskRepoRoot: getTaskRuntimeRepoRoot(task),
+        stateRoot: config.stateRoot,
+        handoffDir: task.handoffDir,
+        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,6 +28,7 @@ import { renderVcmProposeMemorySkillRules } from "../templates/harness/vcm-propo
 import { renderVcmReportHarnessIssueSkillRules } from "../templates/harness/vcm-report-harness-issue-skill.js";
 import { renderVcmRouteMessageSkillRules } from "../templates/harness/vcm-route-message-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 { readVcmPackageVersion } from "../app-version.js";
@@ -53,7 +54,7 @@ const VCM_BASH_DEFAULT_TIMEOUT_MS = "600000";
 const VCM_AUTO_MEMORY_ENABLED = false;
 const VCM_HOOK_DEFINITIONS = [
     { eventName: "PreToolUse", matcher: "Bash", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
-    { eventName: "PreToolUse", matcher: "Grep", 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: "Stop", command: VCM_STOP_HOOK_COMMAND, timeout: 10 },
     { eventName: "StopFailure", command: VCM_HOOK_COMMAND, timeout: 5 },
@@ -66,18 +67,21 @@ const AGENT_FRONTMATTER = {
     },
     architect: {
         description: "VCM architecture role for plans, module boundaries, public contracts, verifiable behavior, and docs sync.",
-        tools: "Read, Glob, Bash, Edit, Write, Agent, LSP"
+        tools: "Read, Grep, Glob, Bash, Edit, Write, Agent, LSP",
+        skills: ["vcm-code-navigation"]
     },
     coder: {
         description: "VCM implementation role for scoped code changes and focused tests.",
-        tools: "Read, Glob, Bash, Edit, Write, Agent, LSP"
+        tools: "Read, Grep, Glob, Bash, Edit, Write, Agent, LSP",
+        skills: ["vcm-code-navigation"]
     },
     tester: {
         description: "VCM testing role for validation, test adequacy, approved-scope validation, and risk findings."
     },
     reviewer: {
         description: "VCM independent gate review role for architecture plans, validation adequacy, and code diffs.",
-        tools: "Read, Glob, Bash, Write, LSP"
+        tools: "Read, Grep, Glob, Bash, Write, LSP",
+        skills: ["vcm-code-navigation"]
     },
     translator: {
         description: "VCM task-scoped translation tool role for conversation translation, file translation, bootstrap, and memory updates."
@@ -96,14 +100,14 @@ const AGENT_FRONTMATTER = {
     }
 };
 const REQUIRED_AGENT_TOOLS = {
-    architect: ["Agent", "LSP"],
-    coder: ["Agent", "LSP"],
-    reviewer: ["LSP"]
+    architect: ["Grep", "Agent", "LSP"],
+    coder: ["Grep", "Agent", "LSP"],
+    reviewer: ["Grep", "LSP"]
 };
-const FORBIDDEN_AGENT_TOOLS = {
-    architect: ["Grep"],
-    coder: ["Grep"],
-    reviewer: ["Grep"]
+const REQUIRED_AGENT_SKILLS = {
+    architect: ["vcm-code-navigation"],
+    coder: ["vcm-code-navigation"],
+    reviewer: ["vcm-code-navigation"]
 };
 const MANAGED_FILES = [
     {
@@ -304,6 +308,12 @@ const WHOLE_FILES = [
         mode: 0o644,
         content: renderSkillFile("VCM Task State Skill", "vcm-task-state", "Use only as project-manager to declare the current task workflow checkpoint to VCM.", renderVcmTaskStateSkillRules())
     },
+    {
+        path: ".claude/skills/vcm-workflow-review/SKILL.md",
+        category: "skill",
+        mode: 0o644,
+        content: renderSkillFile("VCM Workflow Review Skill", "vcm-workflow-review", "Use before every project-manager dispatch to Architect, Coder, or Tester so VCM can approve the workflow transition.", renderVcmWorkflowReviewSkillRules())
+    },
     {
         path: ".claude/skills/vcm-gate-review/SKILL.md",
         category: "skill",
@@ -369,6 +379,12 @@ const WHOLE_FILES = [
         category: "runtime-tool",
         mode: 0o755,
         templatePath: "scripts/harness-tools/vcm-bash-guard"
+    },
+    {
+        path: ".ai/tools/vcm-artifact",
+        category: "runtime-tool",
+        mode: 0o755,
+        templatePath: "scripts/harness-tools/vcm-artifact"
     }
 ];
 const LEGACY_FLAT_SKILL_FILES = [
@@ -611,6 +627,7 @@ function fixedDirectories() {
         ".claude/skills/vcm-long-running-validation/",
         ".claude/skills/vcm-route-message/",
         ".claude/skills/vcm-task-state/",
+        ".claude/skills/vcm-workflow-review/",
         ".claude/skills/vcm-gate-review/",
         ".claude/skills/vcm-report-harness-issue/",
         ".claude/skills/vcm-propose-memory/",
@@ -678,8 +695,8 @@ async function installManagedFile({ projectRoot, definition, dryRun, operations
     for (const requiredTool of REQUIRED_AGENT_TOOLS[definition.agentName] ?? []) {
         nextContent = ensureAgentTool(nextContent, requiredTool);
     }
-    for (const forbiddenTool of FORBIDDEN_AGENT_TOOLS[definition.agentName] ?? []) {
-        nextContent = removeAgentTool(nextContent, forbiddenTool);
+    for (const requiredSkill of REQUIRED_AGENT_SKILLS[definition.agentName] ?? []) {
+        nextContent = ensureAgentSkill(nextContent, requiredSkill);
     }
     await writeIfChanged({
         targetPath,
@@ -723,7 +740,10 @@ function renderNewManagedFile(definition, block) {
         const tools = frontmatter.tools ?? "Read, Grep, Glob, Bash, Edit, Write";
         const model = frontmatter.model ? `\nmodel: ${frontmatter.model}` : "";
         const effort = frontmatter.effort ? `\neffort: ${frontmatter.effort}` : "";
-        return `---\nname: ${definition.agentName}\ndescription: ${frontmatter.description}\ntools: ${tools}${model}${effort}\n---\n\n# ${definition.title}\n\n${block}${suffix ? `\n\n${suffix}` : ""}\n`;
+        const skills = frontmatter.skills?.length
+            ? `\nskills:\n${frontmatter.skills.map((skill) => `  - ${skill}`).join("\n")}`
+            : "";
+        return `---\nname: ${definition.agentName}\ndescription: ${frontmatter.description}\ntools: ${tools}${model}${effort}${skills}\n---\n\n# ${definition.title}\n\n${block}${suffix ? `\n\n${suffix}` : ""}\n`;
     }
     return `# ${definition.title}\n\n${block}${suffix ? `\n\n${suffix}` : ""}\n`;
 }
@@ -743,21 +763,25 @@ function ensureAgentTool(content, requiredTool) {
     const nextTools = [...tools, requiredTool].join(", ");
     return content.replace(frontmatterMatch[0], frontmatterMatch[0].replace(toolsMatch[0], `tools: ${nextTools}`));
 }
-function removeAgentTool(content, forbiddenTool) {
+function ensureAgentSkill(content, requiredSkill) {
     const frontmatterMatch = content.match(/^---\r?\n[\s\S]*?\r?\n---/);
     if (!frontmatterMatch) {
         return content;
     }
-    const toolsMatch = frontmatterMatch[0].match(/^tools:\s*(.*)$/m);
-    if (!toolsMatch) {
-        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.replace(frontmatter, frontmatter.replace(/\r?\n---$/, `\nskills:\n  - ${requiredSkill}\n---`));
     }
-    const tools = toolsMatch[1].split(",").map((tool) => tool.trim()).filter(Boolean);
-    const nextTools = tools.filter((tool) => tool !== forbiddenTool);
-    if (nextTools.length === tools.length) {
+    const listedSkills = (skillsMatch[1] ?? "")
+        .split(/\r?\n/)
+        .map((line) => line.match(/^\s+-\s+(.+)$/)?.[1]?.trim())
+        .filter(Boolean);
+    if (listedSkills.includes(requiredSkill)) {
         return content;
     }
-    return content.replace(frontmatterMatch[0], frontmatterMatch[0].replace(toolsMatch[0], `tools: ${nextTools.join(", ")}`));
+    const nextSkills = `${skillsMatch[0].trimEnd()}\n  - ${requiredSkill}`;
+    return content.replace(frontmatter, frontmatter.replace(skillsMatch[0], nextSkills));
 }
 function migrateLegacyManagedFile(definition, currentContent, block) {
     const legacyContent = definition.legacyWholeFile?.trimEnd();

package/dist/backend/server.js

@@ -45,6 +45,7 @@ import { createTerminalInterruptService } from "./services/terminal-interrupt-se
 import { createTerminalProcessExitService } from "./services/terminal-process-exit-service.js";
 import { createTranslationService } from "./services/translation-service.js";
 import { createUsageAnalyticsService } from "./services/usage-analytics-service.js";
+import { createWorkflowControlService } from "./services/workflow-control-service.js";
 import { createDiagnosticsService } from "./services/diagnostics-service.js";
 import { registerAppSettingsRoutes } from "./api/app-settings-routes.js";
 import { registerArtifactRoutes } from "./api/artifact-routes.js";
@@ -60,6 +61,7 @@ import { registerSessionRoutes } from "./api/session-routes.js";
 import { registerTaskRoutes } from "./api/task-routes.js";
 import { registerTranslationRoutes } from "./api/translation-routes.js";
 import { registerUsageAnalyticsRoutes } from "./api/usage-analytics-routes.js";
+import { registerWorkflowControlRoutes } from "./api/workflow-control-routes.js";
 import { registerTerminalWs } from "./ws/terminal-ws.js";
 import { toVcmError } from "./errors.js";
 import { readVcmPackageVersion } from "./app-version.js";
@@ -120,7 +122,8 @@ export async function createServer(deps, options = {}) {
         harnessService: deps.harnessService,
         harnessFeedbackService: deps.harnessFeedbackService,
         autoMemoryService: deps.autoMemoryService,
-        runtimeCoordinator: deps.runtimeCoordinator
+        runtimeCoordinator: deps.runtimeCoordinator,
+        workflowControlService: deps.workflowControlService
     });
     registerTaskRoutes(app, {
         projectService: deps.projectService,
@@ -144,8 +147,18 @@ export async function createServer(deps, options = {}) {
     registerArtifactRoutes(app, {
         projectService: deps.projectService,
         taskService: deps.taskService,
-        artifactService: deps.artifactService
-    });
+        artifactService: deps.artifactService,
+        sessionService: deps.sessionService
+    });
+    if (deps.workflowControlService) {
+        registerWorkflowControlRoutes(app, {
+            projectService: deps.projectService,
+            taskService: deps.taskService,
+            sessionService: deps.sessionService,
+            workflowControlService: deps.workflowControlService,
+            runtime: deps.runtime
+        });
+    }
     registerMessageRoutes(app, {
         projectService: deps.projectService,
         taskService: deps.taskService,
@@ -228,7 +241,8 @@ export function createDefaultServerDeps(options = {}) {
     });
     const runtime = createNodePtyTerminalRuntime({ fs });
     const registry = createSessionRegistry();
-    const artifactService = createArtifactService(fs);
+    const workflowControlService = createWorkflowControlService({ fs });
+    const artifactService = createArtifactService(fs, { workflowControlService });
     const projectService = createProjectService({ fs, git, appSettings });
     const taskService = createTaskService({ fs, git, artifactService, projectService });
     const taskWorkflowService = createTaskWorkflowService({ fs });
@@ -292,6 +306,7 @@ export function createDefaultServerDeps(options = {}) {
         sessionService,
         taskService,
         taskWorkflowService,
+        workflowControlService,
         onRouteDelivered: ({ repoRoot, taskSlug, message }) => architectRestartService.recordRouteDelivered(repoRoot, taskSlug, message)
     });
     const taskLaunchService = createTaskLaunchService({
@@ -462,7 +477,8 @@ export function createDefaultServerDeps(options = {}) {
         terminalProcessExitService,
         runtime,
         diagnosticsService,
-        usageAnalyticsService
+        usageAnalyticsService,
+        workflowControlService
     };
 }
 export function getDefaultStaticDir() {