vibe-coding-master 0.6.18 → 0.6.19

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

@@ -6,6 +6,7 @@ import process from "node:process";
 import { fileURLToPath } from "node:url";
 import { renderArchitectHarnessRules } from "../templates/harness/architect-agent.js";
 import { renderCoderHarnessRules } from "../templates/harness/coder-agent.js";
+import { renderCoderWorkerHarnessRules } from "../templates/harness/coder-worker-agent.js";
 import { renderGateReviewerAgentRules, renderRequestGateReviewTool, renderTranslatorAgentRules, renderVcmGateReviewSkillRules } from "../templates/harness/gate-review.js";
 import { renderHarnessEngineerHarnessRules } from "../templates/harness/harness-engineer-agent.js";
 import { renderRootClaudeHarnessRules } from "../templates/harness/claude-root.js";
@@ -52,7 +53,8 @@ const AGENT_FRONTMATTER = {
         description: "VCM architecture role for plans, module boundaries, public contracts, verifiable behavior, and docs sync."
     },
     coder: {
-        description: "VCM implementation role for scoped code changes and focused tests."
+        description: "VCM implementation role for scoped code changes and focused tests.",
+        tools: "Read, Grep, Glob, Bash, Edit, Write, Agent"
     },
     reviewer: {
         description: "VCM independent review role for acceptance, test adequacy, scope checks, and risk findings."
@@ -65,6 +67,10 @@ const AGENT_FRONTMATTER = {
     },
     "harness-engineer": {
         description: "VCM project-scoped harness maintenance role for harness diagnosis, diff proposals, and VCM issue drafts."
+    },
+    "vcm-coder-worker": {
+        description: "Bounded VCM implementation worker for assigned modules, files, and VCM:CODE markers from Coder.",
+        model: "inherit"
     }
 };
 const MANAGED_FILES = [
@@ -146,6 +152,14 @@ const MANAGED_FILES = [
         commentStyle: "html",
         category: "agent-harness-engineer",
         content: renderHarnessEngineerHarnessRules()
+    },
+    {
+        path: ".claude/agents/vcm-coder-worker.md",
+        title: "VCM Coder Worker Agent",
+        agentName: "vcm-coder-worker",
+        commentStyle: "html",
+        category: "agent-coder-worker",
+        content: renderCoderWorkerHarnessRules()
     }
 ];
 const DURABLE_DOC_TEMPLATES = [
@@ -528,7 +542,9 @@ function renderManagedBlock(definition) {
 function renderNewManagedFile(definition, block) {
     if (definition.agentName) {
         const frontmatter = AGENT_FRONTMATTER[definition.agentName];
-        return `---\nname: ${definition.agentName}\ndescription: ${frontmatter.description}\ntools: Read, Grep, Glob, Bash, Edit, Write\n---\n\n# ${definition.title}\n\n${block}\n`;
+        const tools = frontmatter.tools ?? "Read, Grep, Glob, Bash, Edit, Write";
+        const model = frontmatter.model ? `\nmodel: ${frontmatter.model}` : "";
+        return `---\nname: ${definition.agentName}\ndescription: ${frontmatter.description}\ntools: ${tools}${model}\n---\n\n# ${definition.title}\n\n${block}\n`;
     }
     return `# ${definition.title}\n\n${block}\n`;
 }

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

@@ -3,6 +3,7 @@ import path from "node:path";
 import { promisify } from "node:util";
 import { renderArchitectHarnessRules } from "../templates/harness/architect-agent.js";
 import { renderCoderHarnessRules } from "../templates/harness/coder-agent.js";
+import { renderCoderWorkerHarnessRules } from "../templates/harness/coder-worker-agent.js";
 import { renderGateReviewerAgentRules, renderRequestGateReviewTool, renderTranslatorAgentRules, renderVcmGateReviewSkillRules } from "../templates/harness/gate-review.js";
 import { renderHarnessEngineerHarnessRules } from "../templates/harness/harness-engineer-agent.js";
 import { renderRootClaudeHarnessRules } from "../templates/harness/claude-root.js";
@@ -135,6 +136,13 @@ const HARNESS_FILES = [
         frontmatter: renderAgentFrontmatter("harness-engineer", "VCM project-scoped harness maintenance role for harness diagnosis, diff proposals, and VCM issue drafts."),
         renderRules: renderHarnessEngineerHarnessRules
     },
+    {
+        kind: "agent-coder-worker",
+        path: ".claude/agents/vcm-coder-worker.md",
+        title: "VCM Coder Worker Agent",
+        frontmatter: renderAgentFrontmatter("vcm-coder-worker", "Bounded VCM implementation worker for assigned modules, files, and VCM:CODE markers from Coder.", { model: "inherit" }),
+        renderRules: renderCoderWorkerHarnessRules
+    },
     {
         kind: "tool-request-gate-review",
         path: ".ai/tools/request-gate-review",
@@ -161,7 +169,7 @@ const HARNESS_FILES = [
         kind: "agent-coder",
         path: ".claude/agents/coder.md",
         title: "Coder Agent",
-        frontmatter: renderAgentFrontmatter("coder", "VCM implementation role for scoped code changes and focused tests."),
+        frontmatter: renderAgentFrontmatter("coder", "VCM implementation role for scoped code changes and focused tests.", { tools: "Read, Grep, Glob, Bash, Edit, Write, Agent" }),
         renderRules: renderCoderHarnessRules
     },
     {
@@ -1279,8 +1287,10 @@ function isVcmHookMatcher(value) {
 function isPlainObject(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function renderAgentFrontmatter(name, description) {
-    return `---\nname: ${name}\ndescription: ${description}\ntools: Read, Grep, Glob, Bash, Edit, Write\n---`;
+function renderAgentFrontmatter(name, description, options = {}) {
+    const tools = options.tools ?? "Read, Grep, Glob, Bash, Edit, Write";
+    const model = options.model ? `\nmodel: ${options.model}` : "";
+    return `---\nname: ${name}\ndescription: ${description}\ntools: ${tools}${model}\n---`;
 }
 function renderSkillFrontmatter(name, description) {
     return `---\nname: ${name}\ndescription: ${description}\n---`;

package/dist/backend/services/job-guard-service.js

@@ -1,6 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 const ACTIVE_JOB_STATUSES = new Set(["queued", "starting", "running"]);
+const ACTIVE_CODER_WORKER_STATUSES = new Set(["planned", "running", "completed", "failed"]);
 const QUEUED_JOB_FRESH_MS = 120_000;
 export const MAX_CONSECUTIVE_STOP_BLOCKS = 3;
 export function createJobGuardService(deps = {}) {
@@ -73,19 +74,26 @@ export function createJobGuardService(deps = {}) {
         async evaluateStop(input) {
             const key = stateKey(input);
             const jobs = await findActiveJobs(input.taskRepoRoot);
-            if (jobs.length === 0) {
+            const coderWorkerTasks = input.role === "coder"
+                ? await findActiveCoderWorkerTasks(input.taskRepoRoot)
+                : [];
+            if (jobs.length === 0 && coderWorkerTasks.length === 0) {
                 blockStates.delete(key);
                 return { behavior: "allow" };
             }
-            const leaseMtimeMs = jobs.reduce((latest, job) => job.leaseMtimeMs !== undefined && (latest === undefined || job.leaseMtimeMs > latest)
+            const jobProgressMtimeMs = jobs.reduce((latest, job) => job.leaseMtimeMs !== undefined && (latest === undefined || job.leaseMtimeMs > latest)
                 ? job.leaseMtimeMs
                 : latest, undefined);
+            const workerProgressMtimeMs = coderWorkerTasks.reduce((latest, task) => task.stateMtimeMs !== undefined && (latest === undefined || task.stateMtimeMs > latest)
+                ? task.stateMtimeMs
+                : latest, undefined);
+            const progressMtimeMs = latestMtime(jobProgressMtimeMs, workerProgressMtimeMs);
             let state = blockStates.get(key) ?? { count: 0 };
-            const watcherProgressed = state.count > 0
-                && leaseMtimeMs !== undefined
-                && state.lastLeaseMtimeMs !== undefined
-                && leaseMtimeMs > state.lastLeaseMtimeMs;
-            if (watcherProgressed) {
+            const progressChanged = state.count > 0
+                && progressMtimeMs !== undefined
+                && state.lastProgressMtimeMs !== undefined
+                && progressMtimeMs > state.lastProgressMtimeMs;
+            if (progressChanged) {
                 state = { count: 0 };
             }
             if (state.count >= MAX_CONSECUTIVE_STOP_BLOCKS) {
@@ -94,24 +102,88 @@ export function createJobGuardService(deps = {}) {
                 blockStates.delete(key);
                 return { behavior: "allow" };
             }
-            blockStates.set(key, { count: state.count + 1, lastLeaseMtimeMs: leaseMtimeMs });
-            return { behavior: "block", reason: buildBlockReason(jobs) };
+            blockStates.set(key, { count: state.count + 1, lastProgressMtimeMs: progressMtimeMs });
+            return { behavior: "block", reason: buildBlockReason(jobs, coderWorkerTasks) };
         },
         notePromptSubmitted(input) {
             blockStates.delete(stateKey(input));
         }
     };
 }
+async function findActiveCoderWorkerTasks(taskRepoRoot) {
+    const tasksRoot = path.join(taskRepoRoot, ".ai/vcm/coder-workers/tasks");
+    let entries;
+    try {
+        entries = await fs.readdir(tasksRoot);
+    }
+    catch {
+        return [];
+    }
+    const tasks = [];
+    for (const entry of entries.sort()) {
+        if (!entry.endsWith(".json")) {
+            continue;
+        }
+        const statePath = path.join(tasksRoot, entry);
+        let state;
+        try {
+            state = JSON.parse(await fs.readFile(statePath, "utf8"));
+        }
+        catch {
+            continue;
+        }
+        const status = typeof state.status === "string" ? state.status : "";
+        if (state.handled === true || !ACTIVE_CODER_WORKER_STATUSES.has(status)) {
+            continue;
+        }
+        let stateMtimeMs;
+        try {
+            stateMtimeMs = (await fs.stat(statePath)).mtimeMs;
+        }
+        catch {
+            stateMtimeMs = undefined;
+        }
+        tasks.push({
+            workerId: typeof state.workerId === "string" ? state.workerId : path.basename(entry, ".json"),
+            status,
+            reportPath: typeof state.reportPath === "string" ? state.reportPath : undefined,
+            error: typeof state.error === "string" ? state.error : undefined,
+            stateMtimeMs
+        });
+    }
+    return tasks;
+}
 function stateKey(input) {
     return `${input.repoRoot}::${input.taskSlug}::${input.role}`;
 }
-function buildBlockReason(jobs) {
+function buildBlockReason(jobs, coderWorkerTasks) {
+    if (jobs.length > 0 && coderWorkerTasks.length === 0) {
+        return buildValidationJobBlockReason(jobs);
+    }
+    if (jobs.length === 0) {
+        return buildCoderWorkerBlockReason(coderWorkerTasks);
+    }
+    return `${buildValidationJobBlockReason(jobs)}\n${buildCoderWorkerBlockReason(coderWorkerTasks)}`;
+}
+function buildValidationJobBlockReason(jobs) {
     const first = jobs[0];
     const listing = jobs.map((job) => `${job.jobId} (${job.status})`).join(", ");
     return `VCM: validation job ${listing} is still running. Do not end the turn while a validation job is running. `
         + `Run \`.ai/tools/watch-job ${first.jobId}\` again now and keep watching until it reports a terminal result `
         + `(success, failed, timeout, or orphaned), then record the result.`;
 }
+function buildCoderWorkerBlockReason(tasks) {
+    const listing = tasks.map((task) => `${task.workerId} (${task.status})`).join(", ");
+    const reports = tasks
+        .map((task) => task.reportPath)
+        .filter((reportPath) => Boolean(reportPath));
+    const reportHint = reports.length > 0 ? ` Review report(s): ${reports.join(", ")}.` : "";
+    return `VCM: coder worker task ${listing} is still unhandled. Do not end the Coder turn while worker tasks are unhandled. `
+        + `Wait for worker subagents, review reports and commits, resolve failed or incomplete workers, set \`handled: true\` in each worker state, and continue.${reportHint}`;
+}
+function latestMtime(...values) {
+    return values.reduce((latest, value) => value !== undefined && (latest === undefined || value > latest) ? value : latest, undefined);
+}
 function numberOrUndefined(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }

package/dist/backend/services/runtime-recovery-service.js

@@ -5,6 +5,7 @@ const TRANSLATOR_SESSION_PATH = ".ai/vcm/translations/session.json";
 const HARNESS_ENGINEER_SESSION_PATH = ".ai/vcm/harness-engineer/session.json";
 const BOOTSTRAP_SESSION_PATH = ".ai/vcm/bootstrap/session.json";
 const HARNESS_FEEDBACK_STATE_PATH = ".ai/vcm/harness-feedback/state.json";
+const CODER_WORKERS_RUNTIME_DIR = ".ai/vcm/coder-workers";
 const RECOVERABLE_FEEDBACK_STATES = new Set(["analyzing", "applying"]);
 export function createRuntimeRecoveryService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
@@ -28,6 +29,7 @@ export function createRuntimeRecoveryService(deps) {
                     const roundRecovered = await recoverRound(taskRepoRoot, config.stateRoot, task.taskSlug, recoveredAt, context);
                     await recoverMessages(taskRepoRoot, config.stateRoot, task.taskSlug, recoveredAt, context);
                     await recoverGateReview(taskRepoRoot, recoveredAt, context);
+                    await cleanupCoderWorkers(taskRepoRoot, context);
                     if ((roundRecovered || task.status === "running") && !hasLiveTaskSession(task.taskSlug)) {
                         await deps.taskService.updateTaskStatus(repoRoot, task.taskSlug, "stopped");
                     }
@@ -230,6 +232,17 @@ export function createRuntimeRecoveryService(deps) {
         });
         context.changedPaths.add(relativePath);
     }
+    async function cleanupCoderWorkers(taskRepoRoot, context) {
+        const absolutePath = path.join(taskRepoRoot, CODER_WORKERS_RUNTIME_DIR);
+        if (!(await deps.fs.pathExists(absolutePath))) {
+            return;
+        }
+        if (!deps.fs.removePath) {
+            return;
+        }
+        await deps.fs.removePath(absolutePath, { recursive: true, force: true });
+        context.changedPaths.add(CODER_WORKERS_RUNTIME_DIR);
+    }
     async function recoverHarnessBootstrap(repoRoot, _timestamp, context) {
         const absolutePath = path.join(repoRoot, BOOTSTRAP_SESSION_PATH);
         const state = await readJsonIfExists(absolutePath);

package/dist/backend/templates/harness/architect-agent.js

@@ -71,7 +71,9 @@ export function renderArchitectHarnessRules() {
 
 In Architecture Diagnosis Mode, treat the current failure as a signal that the architecture may be wrong or incomplete. Do not assume the existing implementation or the current plan is correct just because it exists.
 
-Your job is to diagnose the architecture behind the failure before proposing implementation work.
+First define the diagnosis boundary: the affected feature or module. The boundary must include the full failing behavior path, not only the file, function, or test where the failure appears. Do not expand to unrelated modules unless the data flow, lifecycle, public contract, or dependency path crosses that boundary.
+
+Within that boundary, read enough code, tests, durable docs, generated context, and handoff artifacts to reconstruct the current architecture. Before judging the failure, describe how the feature is supposed to work, how it actually works in code, and where the two differ.
 
 Analyze the problem from these angles:
 
@@ -83,16 +85,19 @@ Analyze the problem from these angles:
 - **Failure Model:** Identify how the architecture should behave when the operation fails, is interrupted, retries, resumes, restarts, receives duplicate events, receives events out of order, or observes partial output. Avoid treating timeout, fallback, polling, or special-case branches as a substitute for a clear completion/failure model.
 - **Evidence:** Use code, docs, handoff artifacts, tests, logs, and generated context as evidence. Existing code is evidence, not authority. If the code contradicts the intended architecture, say so directly.
 
-Your diagnosis must answer:
+Treat "local implementation bug" as an exception that must be proven. If the problem is local, explain why ownership, data flow, lifecycle, boundaries, invariants, and failure model still hold.
+
+Your diagnosis should identify:
 
-1. What is the surface failure?
-2. What architecture assumption is broken?
-3. What current ownership, data flow, lifecycle, boundary, invariant, or failure model is wrong or missing?
-4. Why would a local patch fail or create more patches?
-5. What architecture direction should replace it?
-6. What bounded refactor direction or replan scope should follow?
+1. The diagnosis boundary.
+2. How the feature is supposed to work.
+3. How it actually works in code.
+4. Where the two differ.
+5. Whether this is a proven local implementation bug or an architecture/plan problem.
+6. If local, why the architecture still holds.
+7. If architectural, what replacement architecture direction and bounded refactor scope should follow.
 
-Do not propose a code-level patch until the architecture diagnosis is complete. If the problem is truly only a local implementation bug, say that explicitly, explain why no architecture change is needed, and keep the follow-up scope local.
+Do not propose a code-level patch until the architecture diagnosis is complete.
 
 ### Replan And Drift
 

package/dist/backend/templates/harness/coder-agent.js

@@ -5,6 +5,7 @@ export function renderCoderHarnessRules() {
 ### Role Scope
 
 - Own implementation and baseline implementation tests inside the approved task scope, role message, and architecture plan.
+- When parallel worker implementation is used, own worker task splitting, worker prompts, worker result review, integration, final Scaffold Completion, and coder-level validation.
 - Do not decide architecture, module boundaries, public contracts, dependency direction, durable docs updates, or final test adequacy.
 
 ### Coder Implementation Discipline
@@ -51,6 +52,18 @@ export function renderCoderHarnessRules() {
 - Do not stop incomplete work because of workload, session length, context size, or task size.
 - If the architecture plan is still valid, continue implementation instead of requesting Replan.
 
+### Parallel Worker Implementation
+
+- Coder may use Claude Code subagents to invoke \`vcm-coder-worker\` for parallel implementation.
+- Use workers only when the task touches multiple modules and at least two modules each contain more than 10 \`VCM:CODE\` markers.
+- Before invoking workers, count \`VCM:CODE\` markers by module and create one runtime state file per worker under \`.ai/vcm/coder-workers/tasks/<worker-id>.json\`.
+- Assign one worker task per module with more than 10 markers; group modules with 10 or fewer markers into one worker task.
+- Each worker prompt must include task worktree, architecture plan path, worker state path, report path, assigned modules/files/markers, allowed implementation scope, validation scope, and commit requirement.
+- Invoke worker subagents in parallel only through \`vcm-coder-worker\`.
+- Stay in the same Coder turn until all worker subagents finish and Coder has reviewed and integrated their reports and commits. Do not end the turn to wait for worker callbacks.
+- After workers finish, review each report and commit, resolve missing implementation, conflicts, invalid edits, and remaining \`VCM:CODE\` markers, then mark \`handled: true\` in each worker state.
+- Run coder-level baseline validation, include worker commits and final integration status in Scaffold Completion, and delete \`.ai/vcm/coder-workers/\`.
+
 ### Handoff
 
 - In the route message back to project-manager, include a \`Scaffold Completion\` section when the architecture plan contains a Scaffold Manifest.

package/dist/backend/templates/harness/coder-worker-agent.js

@@ -0,0 +1,72 @@
+export function renderCoderWorkerHarnessRules() {
+    return `
+## VCM Coder Worker Rules
+
+You are \`vcm-coder-worker\`, a bounded implementation worker invoked by Coder.
+
+### Scope
+
+- Implement only the module, files, Scaffold Manifest IDs, and \`VCM:CODE\` markers assigned by Coder.
+- Stay inside the current task worktree.
+- Do not change unassigned modules, files, durable docs, generated context, workflow files, role definitions, or project configuration unless Coder explicitly assigns them.
+- Do not decide architecture, module boundaries, public contracts, dependency direction, validation strategy, Replan, or final acceptance.
+- If the assigned implementation conflicts with the architecture plan or code reality, stop and report the conflict to Coder.
+
+### Worker Runtime State
+
+- Coder assigns a worker state path and report path.
+- Before editing, read the assigned worker state file and update only that file from \`planned\` to \`running\`.
+- After implementation, write the assigned report file, update only the assigned worker state to \`completed\`, and set \`commitHash\` after committing.
+- If blocked or failed, update only the assigned worker state to \`failed\`, write the reason in \`error\`, and write the report with remaining work.
+- Do not set \`handled: true\`; only Coder may do that after reviewing and integrating the worker result.
+
+### Inputs
+
+- Read Coder's delegation message.
+- Read \`.ai/vcm/handoffs/architecture-plan.md\`.
+- Read assigned source files and tests.
+- Read relevant module architecture docs only when referenced by the architecture plan or delegation message.
+- Read \`.ai/generated/module-index.json\` and \`.ai/generated/public-surface.json\` when needed to confirm module or public surface boundaries.
+- Stop before editing if the assigned module, files, \`VCM:CODE\` markers, behavior contract, validation expectation, worker state path, or report path is unclear.
+
+### Implementation Discipline
+
+- Implement the assigned \`VCM:CODE\` markers completely and remove those markers before completion.
+- Preserve architect-defined file responsibilities, callable-surface signatures, visibility, exports, contracts, and error boundaries.
+- Do not add or change cross-file callable surface unless the architecture plan explicitly defines it.
+- Do not fake completion: no hardcoded success, disabled logic, swallowed errors, test-only shortcuts, or silent fallback that hides failure.
+- Implement behavior from the approved architecture, existing domain model, real inputs, and project runtime flow.
+- Keep changes limited to the assigned module or files.
+- Preserve existing behavior unless the architecture plan explicitly changes it.
+- Keep source comments durable: behavior, contracts, invariants, error boundaries, or non-obvious logic only.
+- Do not copy task context, handoff instructions, temporary rationale, or coder guidance into source comments.
+
+### Tests
+
+- Run only L0/L1 checks relevant to the assigned module or files.
+- Add or update unit tests only for the assigned module when needed for baseline coverage.
+- Do not run integration, E2E, smoke, full-suite, browser, multi-service, or final validation checks.
+- Do not weaken, delete, or skip tests to make validation pass.
+- If assigned-module tests cannot run, report the exact reason to Coder.
+
+### Git
+
+- Commit the worker's completed changes before returning to Coder.
+- Commit only changes made for the assigned module or files.
+- Stage only assigned files; do not use \`git add -A\`, \`git add .\`, \`git commit -a\`, or broad path staging.
+- Use a concise commit message that identifies the assigned module or implementation scope.
+- If committing fails because the worktree changed concurrently, report the failure to Coder and do not attempt broad conflict resolution.
+
+### Output To Coder
+
+Return a concise completion report with:
+
+- assigned module/files
+- completed Scaffold Manifest IDs or \`VCM:CODE\` markers
+- files changed
+- tests/checks run
+- commit hash
+- remaining risks or skipped checks
+- any architecture-plan/code-reality conflict
+`;
+}

package/package.json

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