vibe-coding-master 0.0.13 → 0.0.14

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

@@ -57,6 +57,7 @@ export function createSessionService(deps) {
             taskSlug,
             role,
             status: runtimeSession.status,
+            activityStatus: "idle",
             command: startCommand.display,
             permissionMode,
             cwd: taskRepoRoot,
@@ -99,6 +100,7 @@ export function createSessionService(deps) {
             const updated = {
                 ...existing,
                 status: "exited",
+                activityStatus: "idle",
                 updatedAt: now()
             };
             deps.registry.upsert(updated);
@@ -139,6 +141,7 @@ export function createSessionService(deps) {
             return {
                 ...record,
                 status: runtimeSession.status,
+                activityStatus: record.activityStatus ?? "idle",
                 pid: runtimeSession.pid,
                 lastOutputAt: runtimeSession.lastOutputAt,
                 exitCode: runtimeSession.exitCode
@@ -153,9 +156,45 @@ export function createSessionService(deps) {
                 }
             }
             return sessions;
+        },
+        async recordClaudeHookEvent(repoRoot, input) {
+            const current = await this.getRoleSession(repoRoot, input.taskSlug, input.role);
+            if (!current || !matchesClaudeHookSession(current, input)) {
+                return undefined;
+            }
+            const timestamp = now();
+            const updated = {
+                ...current,
+                activityStatus: input.eventName === "UserPromptSubmit" ? "running" : "idle",
+                lastHookEventAt: timestamp,
+                lastPromptSubmittedAt: input.eventName === "UserPromptSubmit"
+                    ? timestamp
+                    : current.lastPromptSubmittedAt,
+                lastStopAt: input.eventName === "Stop"
+                    ? timestamp
+                    : current.lastStopAt,
+                updatedAt: timestamp
+            };
+            deps.registry.upsert(updated);
+            const config = await deps.projectService.loadConfig(repoRoot);
+            const task = await deps.taskService.loadTask(repoRoot, input.taskSlug);
+            await persistTaskSession(deps.fs, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
+            return updated;
         }
     };
 }
+function matchesClaudeHookSession(record, input) {
+    if (input.claudeSessionId && record.claudeSessionId === input.claudeSessionId) {
+        return true;
+    }
+    if (input.transcriptPath && record.transcriptPath === input.transcriptPath) {
+        return true;
+    }
+    if (!input.claudeSessionId && !input.transcriptPath) {
+        return true;
+    }
+    return false;
+}
 function getRecoverableStatus(record) {
     if (!record.claudeSessionId) {
         return record.status === "running" ? "missing" : record.status;

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

@@ -16,84 +16,8 @@ export function createStatusService(deps) {
                 task,
                 sessions,
                 artifacts,
-                workflow: buildWorkflowReport(artifacts, sessions),
                 warnings
             };
         }
     };
 }
-function buildWorkflowReport(artifacts, sessions) {
-    const isComplete = (kind) => artifacts.checks.find((check) => check.kind === kind)?.status === "ok";
-    const roleIsRunning = (role) => sessions.some((session) => session.role === role && session.status === "running");
-    const architectureComplete = isComplete("architecture-plan");
-    const implementationComplete = isComplete("implementation-log") && isComplete("validation-log");
-    const reviewComplete = isComplete("review-report");
-    const docsSyncComplete = isComplete("docs-sync-report");
-    const steps = [
-        {
-            id: "architecture-plan",
-            label: "Architecture",
-            role: "architect",
-            artifactPaths: [artifacts.paths.architecturePlanPath],
-            status: architectureComplete ? "complete" : "ready",
-            detail: architectureComplete
-                ? "architecture-plan.md is ready."
-                : roleIsRunning("architect")
-                    ? "Architect is running; produce architecture-plan.md before coder work."
-                    : "Start architect and produce architecture-plan.md before coder work."
-        },
-        {
-            id: "implementation",
-            label: "Implementation",
-            role: "coder",
-            artifactPaths: [artifacts.paths.implementationLogPath, artifacts.paths.validationLogPath],
-            status: implementationComplete ? "complete" : architectureComplete ? "ready" : "blocked",
-            detail: implementationComplete
-                ? "implementation-log.md and validation-log.md are ready."
-                : architectureComplete
-                    ? "Start coder, then update implementation-log.md and validation-log.md."
-                    : "Blocked until architecture-plan.md is complete."
-        },
-        {
-            id: "review",
-            label: "Review",
-            role: "reviewer",
-            artifactPaths: [artifacts.paths.reviewReportPath],
-            status: reviewComplete ? "complete" : implementationComplete ? "ready" : "blocked",
-            detail: reviewComplete
-                ? "review-report.md is ready."
-                : implementationComplete
-                    ? "Start reviewer for independent review and final test adequacy."
-                    : "Blocked until implementation-log.md and validation-log.md are complete."
-        },
-        {
-            id: "docs-sync",
-            label: "Docs Sync",
-            role: "architect",
-            artifactPaths: [artifacts.paths.docsSyncReportPath],
-            status: docsSyncComplete ? "complete" : reviewComplete ? "ready" : "blocked",
-            detail: docsSyncComplete
-                ? "docs-sync-report.md is ready."
-                : reviewComplete
-                    ? "Send architect a docs-sync / architecture drift check task."
-                    : "Blocked until review-report.md is complete."
-        },
-        {
-            id: "final-acceptance",
-            label: "PM Final",
-            role: "project-manager",
-            artifactPaths: [],
-            status: docsSyncComplete ? "ready" : "blocked",
-            detail: docsSyncComplete
-                ? "Project Manager can prepare final acceptance, commit, and PR."
-                : "Blocked until architect docs sync is complete."
-        }
-    ];
-    const current = steps.find((step) => step.status !== "complete") ?? steps[steps.length - 1];
-    return {
-        currentStepId: current.id,
-        nextAction: current.detail,
-        blocked: current.status === "blocked",
-        steps
-    };
-}

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

@@ -9,5 +9,9 @@ export function renderArchitectHarnessRules() {
 - Write docs-sync-report.md with docs changed, docs intentionally left unchanged, remaining documentation risks, and decision.
 - Stop and reply to project-manager if implementation drift changes architecture, public contracts, dependency direction, schema, auth, permission, payment, or design assumptions.
 - Reply to project-manager once per received VCM message when complete, blocked, or unclear; do not send fragmented progress updates unless project-manager explicitly requested them.
+- If you need to send a VCM message, send at most one message to any single target role in the current Claude Code turn, then end the turn.
+- After a successful vcmctl reply or vcmctl result, end the turn immediately. Do not run vcmctl inbox, poll, loop, or keep working while waiting for project-manager to answer.
+- Do not wait in a loop for another role to answer. VCM will deliver later replies in a new turn.
+- Do not use Claude Code Task/Subagent for VCM role delegation; communicate through vcmctl only.
 `;
 }

package/dist/backend/templates/harness/claude-root.js

@@ -10,6 +10,9 @@ export function renderRootClaudeHarnessRules() {
 - Non-PM roles only reply to project-manager; they do not message other roles directly.
 - Role messaging is turn-based: do not send more than one active message to the same target role.
 - After sending a message to a role, wait for that role to reply with vcmctl reply or vcmctl result before sending another message to the same role.
+- After any successful vcmctl send, vcmctl reply, or vcmctl result, end the current Claude Code turn. Treat the command as the final coordination action of this turn.
+- Do not run vcmctl inbox, poll files, start shell loops, or keep the turn open waiting for another role's answer. VCM will deliver replies in a later turn.
+- Do not use Claude Code Task/Subagent for VCM role delegation; VCM owns the four role sessions and the message queue.
 - If new information arrives while a role is still processing, update the relevant handoff artifact or wait; do not spam the target role's terminal.
 - High-risk decisions involving schema, auth, permissions, payment, billing, security, data deletion, or unclear user intent must stop for project-manager/user approval.
 - Required workflow gates: architect plan -> coder implementation/validation -> reviewer review -> architect docs sync -> project-manager final acceptance/commit/PR.

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

@@ -8,5 +8,9 @@ export function renderCoderHarnessRules() {
 - Do not change module boundaries, public contracts, dependency direction, or test strategy without project-manager/architect replan.
 - Stop and reply to project-manager when blocked, unclear, or when the plan no longer matches reality.
 - Reply to project-manager once per received VCM message when complete, blocked, or unclear; do not send fragmented progress updates unless project-manager explicitly requested them.
+- If you need to send a VCM message, send at most one message to any single target role in the current Claude Code turn, then end the turn.
+- After a successful vcmctl reply or vcmctl result, end the turn immediately. Do not run vcmctl inbox, poll, loop, or keep working while waiting for project-manager to answer.
+- Do not wait in a loop for another role to answer. VCM will deliver later replies in a new turn.
+- Do not use Claude Code Task/Subagent for VCM role delegation; communicate through vcmctl only.
 `;
 }

package/dist/backend/templates/harness/project-manager-agent.js

@@ -7,6 +7,10 @@ export function renderProjectManagerHarnessRules() {
 - Send role work as durable instructions with artifact refs when possible.
 - Enforce per-role turn-taking: keep at most one in-flight message per target role.
 - Before sending another task, question, revise, or review-request to the same role, wait for that role's vcmctl reply or vcmctl result.
+- In one Claude Code turn, send at most one VCM message to any single target role.
+- After a successful vcmctl send, end the turn immediately. Do not send another VCM message, run vcmctl inbox, poll for the target role's response, or keep the conversation open waiting for another agent.
+- Continue orchestration only in a later turn after VCM delivers that role's vcmctl reply or vcmctl result.
+- Do not use Claude Code Task/Subagent for VCM role delegation; VCM manages the four role sessions.
 - Use cancel only for urgent supersession; include what is superseded.
 - Track the workflow gates: architecture plan, implementation/validation, review, docs sync, final acceptance.
 - Request architect post-review docs sync after reviewer completes.

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

@@ -10,5 +10,9 @@ export function renderReviewerHarnessRules() {
 - Escalate architecture, public contract, design, or documentation drift issues to project-manager for architect follow-up.
 - Do not take over broad implementation and do not weaken tests to pass validation.
 - Reply to project-manager once per received VCM message when complete, blocked, or unclear; do not send fragmented progress updates unless project-manager explicitly requested them.
+- If you need to send a VCM message, send at most one message to any single target role in the current Claude Code turn, then end the turn.
+- After a successful vcmctl reply or vcmctl result, end the turn immediately. Do not run vcmctl inbox, poll, loop, or keep working while waiting for project-manager to answer.
+- Do not wait in a loop for another role to answer. VCM will deliver later replies in a new turn.
+- Do not use Claude Code Task/Subagent for VCM role delegation; communicate through vcmctl only.
 `;
 }

package/dist/backend/templates/message-envelope.js

@@ -17,7 +17,9 @@ ${artifactRefs}
 
 Instructions:
 - Read the message and execute only within this VCM task.
-- Reply to project-manager with vcmctl reply when complete, blocked, or unclear.
+- Reply to project-manager with vcmctl result when complete, or vcmctl reply when blocked or unclear.
+- After a successful vcmctl reply or vcmctl result, end this Claude Code turn immediately.
+- Do not run vcmctl inbox, poll, loop, or wait for project-manager in this turn. VCM will deliver later replies in a new turn.
 [/VCM MESSAGE]
 `;
 }

package/dist/cli/vcmctl.js

@@ -33,6 +33,10 @@ async function main(argv = process.argv.slice(2)) {
         console.log(JSON.stringify(response, null, 2));
         return;
     }
+    if (command === "hook-event") {
+        await sendHookEvent(await readStdinJson());
+        return;
+    }
     if (command === "ready") {
         console.log("ready: VCM readiness signaling is planned for a later phase.");
         return;
@@ -49,6 +53,31 @@ async function sendMessage(input) {
     });
     console.log(JSON.stringify(result, null, 2));
 }
+async function sendHookEvent(event) {
+    const input = {
+        taskSlug: getTaskSlug(),
+        role: getEnvRole(),
+        event
+    };
+    await fetchJson(`${getApiUrl()}/api/hooks/claude-code`, {
+        method: "POST",
+        body: JSON.stringify(input),
+        headers: {
+            "content-type": "application/json"
+        }
+    });
+}
+async function readStdinJson() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const raw = Buffer.concat(chunks).toString("utf8").trim();
+    if (!raw) {
+        return {};
+    }
+    return JSON.parse(raw);
+}
 function parseOptions(args) {
     const options = {
         artifactRefs: []
@@ -133,6 +162,7 @@ Usage:
   vcmctl reply --type blocked --body "Need clarification."
   vcmctl result --body-file /tmp/result.md --artifact .ai/vcm/handoffs/implementation-log.md
   vcmctl inbox
+  vcmctl hook-event < hook-payload.json
 `);
 }
 main().catch((error) => {

package/dist/shared/types/claude-hook.js

@@ -0,0 +1 @@
+export {};