vibe-coding-master 0.7.38 → 0.7.40

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

@@ -25,6 +25,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 +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 },
@@ -137,6 +138,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,9 +207,9 @@ const HARNESS_FILES = [
         path: ".claude/agents/reviewer.md",
         title: "Reviewer Agent",
         memoryBlock: true,
-        requiredTools: ["LSP"],
-        forbiddenTools: ["Grep"],
-        frontmatter: renderAgentFrontmatter("reviewer", "VCM independent gate review role for architecture plans, validation adequacy, and code diffs.", { tools: "Read, Glob, Bash, Write, LSP" }),
+        requiredTools: ["Grep", "LSP"],
+        requiredSkills: ["vcm-code-navigation"],
+        frontmatter: renderAgentFrontmatter("reviewer", "VCM independent gate review role for architecture plans, validation adequacy, and code diffs.", { tools: "Read, Grep, Glob, Bash, Write, LSP", skills: ["vcm-code-navigation"] }),
         renderRules: renderReviewerAgentRules
     },
     {
@@ -273,10 +282,10 @@ const HARNESS_FILES = [
         path: ".claude/agents/architect.md",
         title: "Architect Agent",
         memoryBlock: true,
-        requiredTools: ["Agent", "LSP"],
-        forbiddenTools: ["Grep"],
+        requiredTools: ["Grep", "Agent", "LSP"],
+        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" }),
+        frontmatter: renderAgentFrontmatter("architect", "VCM architecture role for plans, module boundaries, public contracts, verifiable behavior, and docs sync.", { tools: "Read, Grep, Glob, Bash, Edit, Write, Agent, LSP", skills: ["vcm-code-navigation"] }),
         renderRules: renderArchitectHarnessRules
     },
     {
@@ -284,9 +293,9 @@ const HARNESS_FILES = [
         path: ".claude/agents/coder.md",
         title: "Coder Agent",
         memoryBlock: true,
-        requiredTools: ["Agent", "LSP"],
-        forbiddenTools: ["Grep"],
-        frontmatter: renderAgentFrontmatter("coder", "VCM implementation role for scoped code changes and focused tests.", { tools: "Read, Glob, Bash, Edit, Write, Agent, LSP" }),
+        requiredTools: ["Grep", "Agent", "LSP"],
+        requiredSkills: ["vcm-code-navigation"],
+        frontmatter: renderAgentFrontmatter("coder", "VCM implementation role for scoped code changes and focused tests.", { tools: "Read, Grep, Glob, Bash, Edit, Write, Agent, LSP", skills: ["vcm-code-navigation"] }),
         renderRules: renderCoderHarnessRules
     },
     {
@@ -1224,7 +1233,7 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
         const migratedContent = migrateLegacyHarnessFile(definition, currentContent, expectedBlock);
         if (migratedContent) {
             const memoryUpdatedContent = definition.memoryBlock ? ensureVcmMemoryBlock(migratedContent) : migratedContent;
-            const nextContent = normalizeAgentTools(memoryUpdatedContent, definition.requiredTools, definition.forbiddenTools);
+            const nextContent = normalizeAgentFrontmatter(memoryUpdatedContent, definition);
             return {
                 definition,
                 status: {
@@ -1243,7 +1252,7 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
             };
         }
         const insertedContent = `${currentContent.trimEnd()}\n\n${expectedBlock}\n`;
-        const nextContent = normalizeAgentTools(insertedContent, definition.requiredTools, definition.forbiddenTools);
+        const nextContent = normalizeAgentFrontmatter(insertedContent, definition);
         return {
             definition,
             status: {
@@ -1265,7 +1274,7 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
     const currentBlock = match[0];
     const blockUpdatedContent = currentContent.replace(managedBlockPattern, expectedBlock);
     const memoryUpdatedContent = definition.memoryBlock ? ensureVcmMemoryBlock(blockUpdatedContent) : blockUpdatedContent;
-    const nextContent = normalizeAgentTools(memoryUpdatedContent, definition.requiredTools, definition.forbiddenTools);
+    const nextContent = normalizeAgentFrontmatter(memoryUpdatedContent, definition);
     const action = currentContent === nextContent ? "ok" : "update";
     return {
         definition,
@@ -1396,25 +1405,29 @@ function ensureAgentTool(content, requiredTool) {
 function ensureAgentTools(content, requiredTools) {
     return (requiredTools ?? []).reduce(ensureAgentTool, content);
 }
-function removeAgentTool(content, forbiddenTool) {
+function normalizeAgentFrontmatter(content, definition) {
+    const toolsUpdated = ensureAgentTools(content, definition.requiredTools);
+    return (definition.requiredSkills ?? []).reduce(ensureAgentSkill, toolsUpdated);
+}
+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((skill) => Boolean(skill));
+    if (listedSkills.includes(requiredSkill)) {
         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 nextSkills = `${skillsMatch[0].trimEnd()}\n  - ${requiredSkill}`;
+    return content.replace(frontmatter, frontmatter.replace(skillsMatch[0], nextSkills));
 }
 function migrateLegacyHarnessFile(definition, currentContent, block) {
     const legacyContent = definition.legacyWholeFile?.trimEnd();
@@ -1548,7 +1561,10 @@ function renderAgentFrontmatter(name, description, options = {}) {
     const tools = options.tools ?? "Read, Grep, Glob, Bash, Edit, Write";
     const model = options.model ? `\nmodel: ${options.model}` : "";
     const effort = options.effort ? `\neffort: ${options.effort}` : "";
-    return `---\nname: ${name}\ndescription: ${description}\ntools: ${tools}${model}${effort}\n---`;
+    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---`;
 }
 function renderSkillFrontmatter(name, description) {
     return `---\nname: ${name}\ndescription: ${description}\n---`;

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: []