vibe-coding-master 0.9.4 → 0.9.5

package/dist/backend/server.js

@@ -320,7 +320,8 @@ export function createDefaultServerDeps(options = {}) {
         fs,
         projectService,
         taskService,
-        sessionService
+        sessionService,
+        workflowControlService
     });
     const messageService = createMessageService({
         fs,

package/dist/backend/services/gate-review-service.js

@@ -7,6 +7,7 @@ import { resolveRepoPath } from "../adapters/filesystem.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
 import { parseGateReviewReportArtifact } from "./managed-artifact-validation.js";
+import { collectFlowRouteMessages, renderRouteMessages } from "./route-message-evidence.js";
 const REVIEWER_AGENT_PATH = ".claude/agents/reviewer.md";
 const GATE_REVIEW_DIR = ".ai/vcm/gate-reviews";
 const REQUESTS_DIR = ".ai/vcm/gate-reviews/requests";
@@ -39,10 +40,7 @@ const CODE_DIFF_SOURCE_ARTIFACTS = {
         ".ai/vcm/handoffs/architecture-plan.md",
         ".ai/vcm/handoffs/coder-completion.md"
     ],
-    "architect-debug": [
-        ".ai/vcm/handoffs/role-commands/architect.md",
-        ".ai/vcm/handoffs/architect-debug.md"
-    ],
+    "architect-debug": [".ai/vcm/handoffs/architect-debug.md"],
     "architect-diagnosis": [
         ".ai/vcm/handoffs/architecture-diagnosis.md"
     ]
@@ -438,6 +436,9 @@ export function createGateReviewService(deps) {
         const promptPath = path.posix.join(REQUESTS_DIR, `${requestId}.prompt.md`);
         const requestReportPath = reportPathForRequest(requestId);
         const inputSnapshots = await captureGateInputSnapshots(deps.fs, context.taskRepoRoot, requestId, getSourceArtifacts(gate, codeDiffSources));
+        if (gate === "code-diff" && codeDiffSources) {
+            inputSnapshots.push(await captureRouteMessageSnapshot(deps, context, requestId, codeDiffSources));
+        }
         const nextRecord = {
             ...record,
             status: "running",
@@ -1487,7 +1488,12 @@ function splitLines(value) {
 function buildGatePrompt(context, gate, requestId, codeDiffInput, codeDiffSources, inputSnapshots = []) {
     const reportPath = reportPathForRequest(requestId);
     const absoluteReportPath = resolveRepoPath(context.taskRepoRoot, reportPath);
-    const evidence = getSourceArtifacts(gate, codeDiffSources)
+    const evidence = [
+        ...getSourceArtifacts(gate, codeDiffSources),
+        ...(gate === "code-diff"
+            ? [`${path.posix.join(context.stateRoot, "messages", `${context.taskSlug}.jsonl`)} (PM route messages for the reviewed flow)`]
+            : [])
+    ]
         .map((relativePath) => `- ${relativePath}`)
         .join("\n");
     const capturedEvidence = inputSnapshots.length > 0
@@ -1561,6 +1567,19 @@ async function captureGateInputSnapshots(fs, taskRepoRoot, requestId, sourcePath
     }
     return snapshots;
 }
+// The reviewer judges authorization and scope against the flow's PM route
+// messages, captured like any other immutable Gate input.
+async function captureRouteMessageSnapshot(deps, context, requestId, codeDiffSources) {
+    const sourcePath = path.posix.join(context.stateRoot, "messages", `${context.taskSlug}.jsonl`);
+    const roles = new Set(codeDiffSources.map((source) => source === "coder" ? "coder" : "architect"));
+    const flow = await collectFlowRouteMessages(deps.fs, deps.workflowControlService, context, roles);
+    if (flow.messages.length === 0) {
+        return { sourcePath, status: "missing" };
+    }
+    const snapshotPath = inputSnapshotPathForRequest(requestId, ".ai/vcm/messages/route-messages.md");
+    await deps.fs.writeText(resolveRepoPath(context.taskRepoRoot, snapshotPath), renderRouteMessages(context.taskSlug, [`Code sources: ${codeDiffSources.join(" -> ")}`], flow));
+    return { sourcePath, snapshotPath, status: "captured" };
+}
 function isTaskEvidencePath(sourcePath) {
     return sourcePath.startsWith(".ai/vcm/handoffs/")
         || sourcePath.startsWith(".ai/vcm/gate-reviews/");

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

@@ -527,6 +527,11 @@ function arraysEqual(left, right) {
     }
     return left.every((value, index) => value === right[index]);
 }
+// Reads the task's message log outside the service's task lock, for consumers
+// that only need a point-in-time view, such as Gate Review evidence capture.
+export function readTaskMessages(fs, input) {
+    return readLatestMessages(fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
+}
 async function readLatestMessages(fs, messagesPath) {
     if (!(await fs.pathExists(messagesPath))) {
         return [];

package/dist/backend/services/role-context-restart-service.js

@@ -2,6 +2,7 @@ import path from "node:path";
 import { VCM_ROLE_NAMES } from "../../shared/constants.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { toVcmError, VcmError } from "../errors.js";
+import { collectFlowRouteMessages, renderRouteMessages } from "./route-message-evidence.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
 const STATE_DIR = "restart-with-context";
 export function createRoleContextRestartService(deps) {
@@ -126,7 +127,11 @@ export function createRoleContextRestartService(deps) {
         ]);
         const handoffDir = task.handoffDir;
         const stateRoot = config.stateRoot;
-        const files = roleContextFiles(role, handoffDir, stateRoot);
+        const routeMessagesPath = await writeRouteMessages(repoRoot, task, stateRoot, role);
+        const files = [
+            ...(routeMessagesPath ? [routeMessagesPath] : []),
+            ...roleContextFiles(role, handoffDir, stateRoot)
+        ];
         return {
             system: [
                 `This fresh ${role} session continues the current VCM task after Restart With Context.`,
@@ -140,6 +145,28 @@ export function createRoleContextRestartService(deps) {
             user: `[VCM RESTART WITH CONTEXT]\nRestore the current ${role} work from the listed task artifacts and continue the accepted assignment.`
         };
     }
+    // A delivery role's assignment lives only in the PM route messages, so render
+    // the current flow run's messages to that role for the fresh session.
+    async function writeRouteMessages(repoRoot, task, stateRoot, role) {
+        if (role !== "architect" && role !== "coder" && role !== "tester") {
+            return undefined;
+        }
+        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+        const context = {
+            repoRoot,
+            taskRepoRoot,
+            stateRoot,
+            handoffDir: task.handoffDir,
+            taskSlug: task.taskSlug
+        };
+        const flow = await collectFlowRouteMessages(deps.fs, deps.workflowControlService, context, new Set([role]));
+        if (flow.messages.length === 0) {
+            return undefined;
+        }
+        const relativePath = path.posix.join(stateRoot, STATE_DIR, `${role}-route-messages.md`);
+        await deps.fs.writeText(resolveRepoPath(taskRepoRoot, relativePath), renderRouteMessages(task.taskSlug, [`Role: ${role}`], flow));
+        return relativePath;
+    }
     async function persist(repoRoot, state) {
         await deps.fs.writeJsonAtomic(await statePath(repoRoot, state.taskSlug, state.role), state);
         pending.set(restartKey(repoRoot, state.taskSlug, state.role), state);
@@ -205,7 +232,6 @@ function roleContextFiles(role, handoffDir, stateRoot) {
             ];
         case "architect":
             return [
-                `${handoffDir}/role-commands/architect.md`,
                 `${handoffDir}/architecture-brief.md`,
                 `${handoffDir}/architecture-evidence.md`,
                 `${handoffDir}/planning-progress.md`,
@@ -216,14 +242,12 @@ function roleContextFiles(role, handoffDir, stateRoot) {
             ];
         case "coder":
             return [
-                `${handoffDir}/role-commands/coder.md`,
                 `${handoffDir}/architecture-plan.md`,
                 `${handoffDir}/coder-completion.md`,
                 ".ai/vcm/coder-workers/"
             ];
         case "tester":
             return [
-                `${handoffDir}/role-commands/tester.md`,
                 `${handoffDir}/architecture-plan.md`,
                 `${handoffDir}/coder-completion.md`,
                 `${handoffDir}/test-report.md`

package/dist/backend/services/route-message-evidence.js

@@ -0,0 +1,83 @@
+import { readTaskMessages } from "./message-service.js";
+// PM route messages are the operative instructions for a role: the dispatch
+// that started the current flow run and every later relay of a user decision.
+// They exist only in the task message log, so callers render this slice of it.
+export async function collectFlowRouteMessages(fs, workflowControlService, context, roles) {
+    const messages = await readTaskMessages(fs, {
+        repoRoot: context.repoRoot,
+        stateRepoRoot: context.taskRepoRoot,
+        stateRoot: context.stateRoot,
+        taskSlug: context.taskSlug
+    });
+    const flowRunStart = await findFlowRunStart(workflowControlService, context);
+    const acceptedPmMessages = messages
+        .filter((message) => message.fromRole === "project-manager" && message.acceptedAt)
+        .sort((left, right) => left.acceptedAt.localeCompare(right.acceptedAt));
+    // A PM message is accepted immediately before Workflow Progress confirms its
+    // dispatch, so the flow's starting message is the last one accepted at or
+    // before the first confirmation of the flow run.
+    const windowStart = flowRunStart
+        ? acceptedPmMessages.filter((message) => message.acceptedAt <= flowRunStart).at(-1)?.acceptedAt ?? flowRunStart
+        : undefined;
+    return {
+        windowStart,
+        messages: messages
+            .filter((message) => message.fromRole === "user"
+            ? !windowStart || message.createdAt >= windowStart
+            : message.fromRole === "project-manager"
+                && roles.has(message.toRole)
+                && Boolean(message.acceptedAt)
+                && (!windowStart || message.acceptedAt >= windowStart))
+            .sort((left, right) => messageTime(left).localeCompare(messageTime(right)))
+    };
+}
+export function renderRouteMessages(taskSlug, header, flow) {
+    return [
+        "# PM Route Messages",
+        "",
+        `Task: ${taskSlug}`,
+        ...header,
+        flow.windowStart
+            ? `Scope: messages since the current flow run started at ${flow.windowStart}`
+            : "Scope: the whole task message log; the current flow run start was unavailable",
+        "",
+        "PM route messages to the listed roles and user messages to PM, oldest first.",
+        "A later message overrides an earlier one where they conflict.",
+        ...flow.messages.flatMap((message, index) => [
+            "",
+            `## ${index + 1}. ${message.fromRole} -> ${message.toRole} (${message.type})`,
+            "",
+            `Message: ${message.id}`,
+            `Time: ${messageTime(message)}`,
+            ...(message.artifactRefs.length > 0 ? [`Artifacts: ${message.artifactRefs.join(", ")}`] : []),
+            "",
+            message.body.trimEnd()
+        ]),
+        ""
+    ].join("\n");
+}
+async function findFlowRunStart(workflowControlService, context) {
+    if (!workflowControlService) {
+        return undefined;
+    }
+    try {
+        const workflowContext = {
+            taskRepoRoot: context.taskRepoRoot,
+            stateRoot: context.stateRoot,
+            handoffDir: context.handoffDir,
+            taskSlug: context.taskSlug
+        };
+        const [state, progress] = await Promise.all([
+            workflowControlService.getState(workflowContext),
+            workflowControlService.getProgress(workflowContext)
+        ]);
+        const startedAtSequence = state.flowRun?.startedAtSequence;
+        return progress.history.find((entry) => entry.sequence === startedAtSequence)?.confirmedAt;
+    }
+    catch {
+        return undefined;
+    }
+}
+function messageTime(message) {
+    return message.acceptedAt ?? message.createdAt;
+}

package/dist/backend/templates/harness/gate-review.js

@@ -334,6 +334,13 @@ Treat every production and test hunk introduced by \`architect-debug\` or
 review to confirming that the reported symptom disappeared or that the recorded
 root cause was addressed; apply the complete code-diff checks to every repair.
 
+When the VCM prompt captures PM route messages, they are the operative
+instructions for the reviewed flow: the dispatch that started it and every
+later PM relay of a user decision, oldest first. A later message, such as a user grant, a narrowed scope, or a
+changed acceptance target, overrides the plan or an earlier message where they
+conflict. Judge authorization and scope against them, and record under Code
+Diff Analysis any change they neither request nor permit.
+
 Before deciding:
 
 - Inspect every changed file and diff hunk. Read the complete implementation of
@@ -351,7 +358,7 @@ Before deciding:
   Do not satisfy review by repeating a generic checklist.
 
 For \`coder\`, compare the commits with the approved architecture plan,
-scaffold, and coder completion evidence. Verify that the complete planned
+scaffold, coder completion evidence, and the captured PM route messages. Verify that the complete planned
 behavior is implemented without changing architect-owned boundaries or
 contracts.
 
@@ -362,8 +369,8 @@ the Tester role, the repair or coverage evidence, and
 because it is not a Coder scaffold item. Verify that Tester changes remain
 test-only, preserve real behavior paths, and are committed and validated.
 
-For \`architect-debug\`, compare the commits with the current Architect route
-command and \`.ai/vcm/handoffs/architect-debug.md\`. Verify that the confirmed
+For \`architect-debug\`, compare the commits with the captured PM route messages
+to Architect and \`.ai/vcm/handoffs/architect-debug.md\`. Verify that the confirmed
 root cause is supported by the code, the implementation fixes that cause rather
 than only its surface symptom, temporary diagnostics are removed, and affected
 callers, contracts, and tests are updated. Verify that the Debug evidence records
@@ -372,7 +379,8 @@ when an applicable check was not run, did not pass, or does not exercise that
 failure path.
 
 For \`architect-diagnosis\`, compare the commits with
-\`.ai/vcm/handoffs/architecture-diagnosis.md\`, and verify that the commits implement the diagnosed
+\`.ai/vcm/handoffs/architecture-diagnosis.md\` and the captured PM route messages
+to Architect, and verify that the commits implement the diagnosed
 ownership, data flow, lifecycle, boundaries, invariants, and failure model.
 Request changes when the architecture problem remains, the required direction
 is contradicted, or the implementation is only a local workaround for the surface failure.
@@ -599,10 +607,7 @@ const CODE_DIFF_SOURCE_ARTIFACTS = {
     ".ai/vcm/handoffs/architecture-plan.md",
     ".ai/vcm/handoffs/coder-completion.md"
   ],
-  "architect-debug": [
-    ".ai/vcm/handoffs/role-commands/architect.md",
-    ".ai/vcm/handoffs/architect-debug.md"
-  ],
+  "architect-debug": [".ai/vcm/handoffs/architect-debug.md"],
   "architect-diagnosis": [".ai/vcm/handoffs/architecture-diagnosis.md"]
 };
 const CORE_INPUT_ARTIFACTS = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibe-coding-master",
-  "version": "0.9.4",
+  "version": "0.9.5",
   "description": "Local GUI session cockpit for Claude Code role sessions.",
   "type": "module",
   "files": [