vibe-coding-master 0.7.39 → 0.7.41

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

@@ -2,6 +2,7 @@ import { execFile } from "node:child_process";
 import path from "node:path";
 import { promisify } from "node:util";
 import { renderArchitectHarnessRules } from "../templates/harness/architect-agent.js";
+import { CODE_ROLE_DISALLOWED_TOOLS, REVIEWER_DISALLOWED_TOOLS } from "../role-tool-policy.js";
 import { renderCoderHarnessRules } from "../templates/harness/coder-agent.js";
 import { renderCoderWorkerHarnessRules } from "../templates/harness/coder-worker-agent.js";
 import { renderArchitectScaffoldWorkerHarnessRules } from "../templates/harness/architect-scaffold-worker-agent.js";
@@ -25,6 +26,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 { submitTerminalInput } from "../runtime/terminal-submit.js";
@@ -53,7 +55,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 },
@@ -137,6 +139,14 @@ const HARNESS_FILES = [
         ownership: "whole-file",
         renderRules: renderVcmTaskStateSkillRules
     },
+    {
+        kind: "skill-vcm-workflow-review",
+        path: ".claude/skills/vcm-workflow-review/SKILL.md",
+        title: "VCM Workflow Review Skill",
+        frontmatter: renderSkillFrontmatter("vcm-workflow-review", "Use before every project-manager dispatch to Architect, Coder, or Tester so VCM can approve the workflow transition."),
+        ownership: "whole-file",
+        renderRules: renderVcmWorkflowReviewSkillRules
+    },
     {
         kind: "skill-vcm-final-acceptance",
         path: ".claude/skills/vcm-final-acceptance/SKILL.md",
@@ -198,10 +208,9 @@ const HARNESS_FILES = [
         path: ".claude/agents/reviewer.md",
         title: "Reviewer Agent",
         memoryBlock: true,
-        requiredTools: ["LSP"],
-        forbiddenTools: ["Grep"],
+        requiredDisallowedTools: REVIEWER_DISALLOWED_TOOLS,
         requiredSkills: ["vcm-code-navigation"],
-        frontmatter: renderAgentFrontmatter("reviewer", "VCM independent gate review role for architecture plans, validation adequacy, and code diffs.", { tools: "Read, Glob, Bash, Write, LSP", skills: ["vcm-code-navigation"] }),
+        frontmatter: renderAgentFrontmatter("reviewer", "VCM independent gate review role for architecture plans, validation adequacy, and code diffs.", { disallowedTools: REVIEWER_DISALLOWED_TOOLS.join(", "), skills: ["vcm-code-navigation"] }),
         renderRules: renderReviewerAgentRules
     },
     {
@@ -274,11 +283,10 @@ const HARNESS_FILES = [
         path: ".claude/agents/architect.md",
         title: "Architect Agent",
         memoryBlock: true,
-        requiredTools: ["Agent", "LSP"],
-        forbiddenTools: ["Grep"],
+        requiredDisallowedTools: CODE_ROLE_DISALLOWED_TOOLS,
         requiredSkills: ["vcm-code-navigation"],
         blankLineBeforeEnd: true,
-        frontmatter: renderAgentFrontmatter("architect", "VCM architecture role for plans, module boundaries, public contracts, verifiable behavior, and docs sync.", { tools: "Read, Glob, Bash, Edit, Write, Agent, LSP", skills: ["vcm-code-navigation"] }),
+        frontmatter: renderAgentFrontmatter("architect", "VCM architecture role for plans, module boundaries, public contracts, verifiable behavior, and docs sync.", { disallowedTools: CODE_ROLE_DISALLOWED_TOOLS.join(", "), skills: ["vcm-code-navigation"] }),
         renderRules: renderArchitectHarnessRules
     },
     {
@@ -286,10 +294,9 @@ const HARNESS_FILES = [
         path: ".claude/agents/coder.md",
         title: "Coder Agent",
         memoryBlock: true,
-        requiredTools: ["Agent", "LSP"],
-        forbiddenTools: ["Grep"],
+        requiredDisallowedTools: CODE_ROLE_DISALLOWED_TOOLS,
         requiredSkills: ["vcm-code-navigation"],
-        frontmatter: renderAgentFrontmatter("coder", "VCM implementation role for scoped code changes and focused tests.", { tools: "Read, Glob, Bash, Edit, Write, Agent, LSP", skills: ["vcm-code-navigation"] }),
+        frontmatter: renderAgentFrontmatter("coder", "VCM implementation role for scoped code changes and focused tests.", { disallowedTools: CODE_ROLE_DISALLOWED_TOOLS.join(", "), skills: ["vcm-code-navigation"] }),
         renderRules: renderCoderHarnessRules
     },
     {
@@ -1380,47 +1387,28 @@ function renderNewHarnessFile(definition, block, contentAfterBlock = definition.
     const suffix = contentAfterBlock?.trim();
     return `${frontmatter}# ${definition.title}\n\n${block}${suffix ? `\n\n${suffix}` : ""}\n`;
 }
-function ensureAgentTool(content, requiredTool) {
-    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.replace(/^(---\r?\n[\s\S]*?)(\r?\n---)/, `$1\ntools: ${requiredTool}$2`);
-    }
-    const tools = toolsMatch[1].split(",").map((tool) => tool.trim()).filter(Boolean);
-    if (tools.includes(requiredTool)) {
+function ensureAgentDisallowedTools(content, requiredTools) {
+    if (!requiredTools) {
         return content;
     }
-    const nextTools = [...tools, requiredTool].join(", ");
-    return content.replace(frontmatterMatch[0], frontmatterMatch[0].replace(toolsMatch[0], `tools: ${nextTools}`));
-}
-function ensureAgentTools(content, requiredTools) {
-    return (requiredTools ?? []).reduce(ensureAgentTool, content);
-}
-function removeAgentTool(content, forbiddenTool) {
     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 tools = toolsMatch[1].split(",").map((tool) => tool.trim()).filter(Boolean);
-    const nextTools = tools.filter((tool) => tool !== forbiddenTool);
-    if (nextTools.length === tools.length) {
-        return content;
-    }
-    return content.replace(frontmatterMatch[0], frontmatterMatch[0].replace(toolsMatch[0], `tools: ${nextTools.join(", ")}`));
-}
-function normalizeAgentTools(content, requiredTools, forbiddenTools) {
-    const required = ensureAgentTools(content, requiredTools);
-    return (forbiddenTools ?? []).reduce(removeAgentTool, required);
+    const withoutAllowedTools = frontmatterMatch[0].replace(/^tools:\s*.*\r?\n?/m, "");
+    const disallowedMatch = withoutAllowedTools.match(/^disallowedTools:\s*(.*)$/m);
+    const existing = disallowedMatch?.[1]
+        .split(",")
+        .map((tool) => tool.trim())
+        .filter(Boolean) ?? [];
+    const disallowedTools = [...new Set([...existing, ...requiredTools])].join(", ");
+    const nextFrontmatter = disallowedMatch
+        ? withoutAllowedTools.replace(disallowedMatch[0], `disallowedTools: ${disallowedTools}`)
+        : withoutAllowedTools.replace(/\r?\n---$/, `\ndisallowedTools: ${disallowedTools}\n---`);
+    return content.replace(frontmatterMatch[0], nextFrontmatter);
 }
 function normalizeAgentFrontmatter(content, definition) {
-    const toolsUpdated = normalizeAgentTools(content, definition.requiredTools, definition.forbiddenTools);
+    const toolsUpdated = ensureAgentDisallowedTools(content, definition.requiredDisallowedTools);
     return (definition.requiredSkills ?? []).reduce(ensureAgentSkill, toolsUpdated);
 }
 function ensureAgentSkill(content, requiredSkill) {
@@ -1572,13 +1560,15 @@ function isPlainObject(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function renderAgentFrontmatter(name, description, options = {}) {
-    const tools = options.tools ?? "Read, Grep, Glob, Bash, Edit, Write";
+    const toolPolicy = options.disallowedTools
+        ? `disallowedTools: ${options.disallowedTools}`
+        : `tools: ${options.tools ?? "Read, Grep, Glob, Bash, Edit, Write"}`;
     const model = options.model ? `\nmodel: ${options.model}` : "";
     const effort = options.effort ? `\neffort: ${options.effort}` : "";
     const skills = options.skills?.length
         ? `\nskills:\n${options.skills.map((skill) => `  - ${skill}`).join("\n")}`
         : "";
-    return `---\nname: ${name}\ndescription: ${description}\ntools: ${tools}${model}${effort}${skills}\n---`;
+    return `---\nname: ${name}\ndescription: ${description}\n${toolPolicy}${model}${effort}${skills}\n---`;
 }
 function renderSkillFrontmatter(name, description) {
     return `---\nname: ${name}\ndescription: ${description}\n---`;

package/dist/backend/services/lsp-plugin.js

@@ -1,9 +1,6 @@
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+export { roleUsesLsp } from "../role-tool-policy.js";
 export const VCM_LSP_PLUGIN_NAME = "vcm-lsp-bridge";
 export const VCM_LSP_PLUGIN_DIR = fileURLToPath(new URL("../../../scripts/claude-plugins/vcm-lsp-bridge", import.meta.url));
 export const VCM_LSP_PLUGIN_MANIFEST = path.join(VCM_LSP_PLUGIN_DIR, ".claude-plugin", "plugin.json");
-const LSP_ROLES = new Set(["architect", "coder", "reviewer"]);
-export function roleUsesLsp(role) {
-    return LSP_ROLES.has(role);
-}

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

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { CORE_VCM_ROLE_NAMES } from "../../shared/constants.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
@@ -94,8 +94,28 @@ export function createMessageService(deps) {
                 failureReason: `${routeFile.toRole} is still running.`
             };
         }
+        const messageId = id();
+        if (routeFile.fromRole === PM_ROLE && deps.workflowControlService) {
+            try {
+                await deps.workflowControlService.claimDispatch({
+                    ...toWorkflowContext(input),
+                    routePath: routeFile.path,
+                    targetRole: routeFile.toRole,
+                    routeContentHash: routeFile.contentHash ?? "",
+                    messageId
+                });
+            }
+            catch (error) {
+                return {
+                    delivered: false,
+                    requiresUserApproval: false,
+                    clearedRouteFile: false,
+                    failureReason: errorMessage(error)
+                };
+            }
+        }
         const message = {
-            id: id(),
+            id: messageId,
             taskSlug: input.taskSlug,
             createdAt: timestamp,
             fromRole: routeFile.fromRole,
@@ -103,7 +123,6 @@ export function createMessageService(deps) {
             type: routeFile.type,
             body: routeFile.body,
             artifactRefs: routeFile.artifactRefs,
-            workflow: routeFile.fromRole === PM_ROLE ? routeFile.workflow : undefined,
             bodyPath: routeFile.path,
             routePath: routeFile.path,
             dispatchingAt: timestamp,
@@ -115,16 +134,24 @@ export function createMessageService(deps) {
             ...message,
             deliveredAt: timestamp
         };
-        await submitTerminalInput(deps.runtime, session.id, renderMessageEnvelope(delivered), {
-            enterDelayMs: autoDispatchEnterDelayMs
-        });
+        try {
+            await submitTerminalInput(deps.runtime, session.id, renderMessageEnvelope(delivered), {
+                enterDelayMs: autoDispatchEnterDelayMs
+            });
+        }
+        catch (error) {
+            if (routeFile.fromRole === PM_ROLE) {
+                await deps.workflowControlService?.releaseDispatch(toWorkflowContext(input), messageId);
+            }
+            throw error;
+        }
         await deps.sessionService.markRoleActivityRunning(input.repoRoot, input.taskSlug, routeFile.toRole, session.id);
         if (routeFile.fromRole === PM_ROLE) {
             await deps.taskWorkflowService?.recordPmDispatch({
                 taskRepoRoot: input.taskRepoRoot ?? input.repoRoot,
                 stateRoot: input.stateRoot,
                 taskSlug: input.taskSlug
-            }, routeFile.workflow, {
+            }, undefined, {
                 messageId: delivered.id,
                 toRole: delivered.toRole
             }).catch(() => undefined);
@@ -158,7 +185,7 @@ export function createMessageService(deps) {
                 const messages = await readLatestMessages(deps.fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
                 const messageId = extractVcmMessageId(input.prompt);
                 if (!messageId) {
-                    return undefined;
+                    return confirmManualRoute(input, timestamp);
                 }
                 const message = findDeliveredMessageForPrompt(messages, input.role, messageId);
                 if (!message) {
@@ -169,6 +196,9 @@ export function createMessageService(deps) {
                     acceptedAt: timestamp,
                     failureReason: undefined
                 };
+                if (accepted.fromRole === PM_ROLE) {
+                    await deps.workflowControlService?.confirmDispatch(toWorkflowContext(input), accepted.id);
+                }
                 await appendMessageSnapshot(deps.fs, input, accepted);
                 await clearRouteFileIfStillMatchesMessage(deps.fs, input, accepted);
                 return accepted;
@@ -251,6 +281,58 @@ export function createMessageService(deps) {
             return messages.find((message) => message.id === messageId);
         });
     }
+    async function confirmManualRoute(input, timestamp) {
+        if (!input.prompt?.trim() || input.role === PM_ROLE)
+            return undefined;
+        const routes = await listRouteFiles(deps.fs, toRouteContext(input));
+        const routeFile = routes.find((candidate) => candidate.pending
+            && candidate.fromRole === PM_ROLE
+            && candidate.toRole === input.role
+            && candidate.body.trim() === input.prompt.trim());
+        if (!routeFile)
+            return undefined;
+        const messageId = id();
+        await deps.workflowControlService?.claimDispatch({
+            ...toWorkflowContext(input),
+            routePath: routeFile.path,
+            targetRole: routeFile.toRole,
+            routeContentHash: routeFile.contentHash ?? "",
+            messageId
+        });
+        const accepted = {
+            id: messageId,
+            taskSlug: input.taskSlug,
+            createdAt: timestamp,
+            fromRole: routeFile.fromRole,
+            toRole: routeFile.toRole,
+            type: routeFile.type,
+            body: routeFile.body,
+            artifactRefs: routeFile.artifactRefs,
+            bodyPath: routeFile.path,
+            routePath: routeFile.path,
+            dispatchingAt: timestamp,
+            deliveredAt: timestamp,
+            acceptedAt: timestamp
+        };
+        try {
+            await deps.workflowControlService?.confirmDispatch(toWorkflowContext(input), messageId);
+        }
+        catch (error) {
+            await deps.workflowControlService?.releaseDispatch(toWorkflowContext(input), messageId);
+            throw error;
+        }
+        await appendMessageSnapshot(deps.fs, input, accepted);
+        await clearRouteFileIfStillMatchesMessage(deps.fs, input, accepted);
+        await deps.taskWorkflowService?.recordPmDispatch({
+            taskRepoRoot: input.taskRepoRoot ?? input.repoRoot,
+            stateRoot: input.stateRoot,
+            taskSlug: input.taskSlug
+        }, undefined, {
+            messageId: accepted.id,
+            toRole: accepted.toRole
+        }).catch(() => undefined);
+        return accepted;
+    }
     async function markDispatchConfirmationFailure(input, messageId, failureReason) {
         await withTaskLock(taskLocks, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), async () => {
             const messages = await readLatestMessages(deps.fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
@@ -258,6 +340,9 @@ export function createMessageService(deps) {
             if (!current || current.acceptedAt) {
                 return;
             }
+            if (current.fromRole === PM_ROLE) {
+                await deps.workflowControlService?.releaseDispatch(toWorkflowContext(input), messageId);
+            }
             await appendMessageSnapshot(deps.fs, input, {
                 ...current,
                 failureReason
@@ -272,6 +357,14 @@ function toRouteContext(input) {
         handoffDir: input.handoffDir
     };
 }
+function toWorkflowContext(input) {
+    return {
+        taskRepoRoot: input.taskRepoRoot ?? input.repoRoot,
+        stateRoot: input.stateRoot,
+        handoffDir: input.handoffDir,
+        taskSlug: input.taskSlug
+    };
+}
 async function listRouteFiles(fs, input) {
     const repoRoot = input.taskRepoRoot ?? input.repoRoot;
     const routeDir = path.posix.join(input.handoffDir, "messages");
@@ -296,9 +389,9 @@ async function listRouteFiles(fs, input) {
             type: parsed.type,
             body: parsed.body,
             artifactRefs: parsed.artifactRefs,
-            workflow: parsed.workflow,
             exists: true,
-            pending: parsed.body.trim().length > 0
+            pending: parsed.body.trim().length > 0,
+            contentHash: createHash("sha256").update(content).digest("hex")
         });
     }
     return routeFiles;
@@ -320,12 +413,10 @@ function parseRouteFileContent(content, fromRole, toRole) {
     const { frontmatter, body } = splitFrontmatter(content);
     const type = parseMessageType(frontmatter.type) ?? getDefaultMessageType(fromRole, toRole);
     const artifactRefs = parseArtifactRefs(frontmatter);
-    const workflow = fromRole === PM_ROLE ? parseWorkflowDeclaration(frontmatter) : undefined;
     return {
         type,
         body: body.trim(),
-        artifactRefs,
-        workflow
+        artifactRefs
     };
 }
 function splitFrontmatter(content) {
@@ -376,25 +467,6 @@ function parseArtifactRefs(frontmatter) {
         .map((entry) => entry.trim())
         .filter(Boolean);
 }
-function parseWorkflowDeclaration(frontmatter) {
-    const declaration = {
-        flow: frontmatter.workflow_flow,
-        step: frontmatter.workflow_step,
-        branch: frontmatter.workflow_branch,
-        resumePoint: frontmatter.workflow_resume_point,
-        status: frontmatter.workflow_status,
-        evidenceRefs: parseCommaSeparated(frontmatter.workflow_evidence_refs)
-    };
-    return Object.values(declaration).some((value) => Array.isArray(value) ? value.length > 0 : value !== undefined)
-        ? declaration
-        : undefined;
-}
-function parseCommaSeparated(value) {
-    if (value === undefined) {
-        return undefined;
-    }
-    return value.split(",").map((entry) => entry.trim()).filter(Boolean);
-}
 function getDefaultMessageType(fromRole, toRole) {
     if (fromRole === PM_ROLE && toRole !== PM_ROLE) {
         return "task";
@@ -454,14 +526,10 @@ async function clearRouteFileIfStillMatchesMessage(fs, input, message) {
     const parsed = parseRouteFileContent(routeContent, fromRole, message.toRole);
     if (parsed.body.trim() === message.body.trim() &&
         parsed.type === message.type &&
-        arraysEqual(parsed.artifactRefs, message.artifactRefs) &&
-        workflowDeclarationsEqual(parsed.workflow, message.workflow)) {
+        arraysEqual(parsed.artifactRefs, message.artifactRefs)) {
         await fs.writeText(absolutePath, "");
     }
 }
-function workflowDeclarationsEqual(left, right) {
-    return JSON.stringify(left ?? null) === JSON.stringify(right ?? null);
-}
 function isCoreRouteRole(role) {
     return CORE_VCM_ROLE_NAMES.some((candidate) => candidate === role);
 }

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

@@ -51,10 +51,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: []