vibe-coding-master 0.0.13 → 0.0.15

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

@@ -1,117 +1,9 @@
 import { ROLE_NAMES } from "../../shared/constants.js";
-export function createRoundService(deps) {
+export function createRoundService(deps = {}) {
     const now = deps.now ?? (() => new Date().toISOString());
-    const debounceMs = deps.debounceMs ?? 1500;
-    const trackers = new Map();
-    function ensureTracker(session) {
-        if (session.status !== "running") {
-            stopSession(session.id);
-            return;
-        }
-        if (trackers.has(session.id)) {
-            return;
-        }
-        const tracker = {
-            role: session.role,
-            sessionId: session.id,
-            taskSlug: session.taskSlug,
-            status: "unknown",
-            pendingToolUseIds: new Set(),
-            unsubscribe: () => { }
-        };
-        tracker.unsubscribe = deps.transcripts.subscribeToRoleSession(session, (event) => {
-            handleTranscriptEvent(tracker, event);
-        }, {
-            onError(error) {
-                tracker.status = "unknown";
-                tracker.reason = error.message;
-            }
-        });
-        trackers.set(session.id, tracker);
-    }
-    function handleTranscriptEvent(tracker, event) {
-        tracker.lastActivityAt = event.timestamp;
-        clearIdleTimer(tracker);
-        if (event.kind === "tool_use") {
-            tracker.pendingToolUseIds.add(event.id);
-            tracker.status = "using_tools";
-            tracker.reason = undefined;
-            return;
-        }
-        if (event.kind === "tool_result") {
-            tracker.pendingToolUseIds.delete(event.toolResult.tool_use_id);
-            tracker.status = tracker.pendingToolUseIds.size > 0 ? "using_tools" : "answering";
-            tracker.reason = undefined;
-            return;
-        }
-        if (event.kind === "question") {
-            tracker.status = "waiting_user";
-            tracker.reason = "Claude Code is asking for user input.";
-            return;
-        }
-        if (event.kind === "agent" || event.kind === "todo") {
-            tracker.status = "answering";
-            tracker.reason = undefined;
-            return;
-        }
-        if (event.kind === "thinking") {
-            tracker.status = "answering";
-            tracker.reason = undefined;
-            return;
-        }
-        if (event.kind === "text") {
-            if (event.stopReason === "max_tokens" || event.stopReason === "stop_sequence" || event.stopReason === "refusal") {
-                tracker.status = "abnormal";
-                tracker.reason = `Claude Code stopped with ${event.stopReason}.`;
-                return;
-            }
-            tracker.status = "answering";
-            tracker.reason = undefined;
-            if (event.stopReason === "end_turn" && tracker.pendingToolUseIds.size === 0 && event.text.trim()) {
-                scheduleIdle(tracker, event.timestamp);
-            }
-        }
-    }
-    function scheduleIdle(tracker, endedAt) {
-        tracker.pendingAnswerEndedAt = endedAt;
-        tracker.idleTimer = setTimeout(() => {
-            if (tracker.pendingToolUseIds.size > 0 || tracker.pendingAnswerEndedAt !== endedAt) {
-                return;
-            }
-            tracker.status = "idle";
-            tracker.lastAnswerEndedAt = endedAt;
-            tracker.reason = undefined;
-            tracker.idleTimer = undefined;
-        }, debounceMs);
-    }
-    function clearIdleTimer(tracker) {
-        tracker.pendingAnswerEndedAt = undefined;
-        if (tracker.idleTimer) {
-            clearTimeout(tracker.idleTimer);
-            tracker.idleTimer = undefined;
-        }
-    }
-    function stopSession(sessionId) {
-        const tracker = trackers.get(sessionId);
-        if (!tracker) {
-            return;
-        }
-        clearIdleTimer(tracker);
-        tracker.unsubscribe();
-        trackers.delete(sessionId);
-    }
     return {
         getTaskRoundState(input) {
-            const liveSessionIds = new Set(input.sessions.filter((session) => session.status === "running").map((session) => session.id));
-            for (const session of input.sessions) {
-                ensureTracker(session);
-            }
-            for (const [sessionId, tracker] of trackers) {
-                if (tracker.taskSlug === input.taskSlug && !liveSessionIds.has(sessionId)) {
-                    stopSession(sessionId);
-                }
-            }
-            const roleStates = ROLE_NAMES.map((role) => toRoleTurnState(role, input.sessions, trackers));
+            const roleStates = ROLE_NAMES.map((role) => toRoleTurnState(role, input.sessions));
             const latestDelivered = getLatestDeliveredMessage(input.messages);
             const queuedMessageCount = input.messages.filter((message) => message.status === "queued").length;
             const pendingMessageCount = input.messages.filter((message) => message.status === "pending_approval").length;
@@ -129,14 +21,8 @@ export function createRoundService(deps) {
                 pendingMessageCount
             };
         },
-        stopSession,
-        stopTask(taskSlug) {
-            for (const [sessionId, tracker] of trackers) {
-                if (tracker.taskSlug === taskSlug) {
-                    stopSession(sessionId);
-                }
-            }
-        }
+        stopSession() { },
+        stopTask() { }
     };
 }
 export function evaluateTaskRoundState(input) {
@@ -191,27 +77,31 @@ export function evaluateTaskRoundState(input) {
         updatedAt: input.updatedAt
     };
 }
-function toRoleTurnState(role, sessions, trackers) {
+function toRoleTurnState(role, sessions) {
     const session = sessions.find((candidate) => candidate.role === role && candidate.status === "running");
-    const tracker = session ? trackers.get(session.id) : undefined;
+    const activityStatus = session?.activityStatus ?? "idle";
     return {
         role,
         sessionId: session?.id,
-        status: tracker?.status ?? "unknown",
-        pendingToolUseCount: tracker?.pendingToolUseIds.size ?? 0,
-        lastActivityAt: tracker?.lastActivityAt,
-        lastAnswerEndedAt: tracker?.lastAnswerEndedAt,
-        reason: tracker?.reason
+        status: session ? activityStatus === "running" ? "answering" : "idle" : "unknown",
+        pendingToolUseCount: 0,
+        lastActivityAt: session?.lastPromptSubmittedAt ?? session?.lastHookEventAt,
+        lastAnswerEndedAt: session?.lastStopAt,
+        reason: session
+            ? activityStatus === "running"
+                ? "Claude Code accepted a prompt and has not emitted Stop yet."
+                : "Claude Code emitted Stop or has not started a prompt in this process."
+            : undefined
     };
 }
 function getLatestDeliveredMessage(messages) {
     return messages
-        .filter((message) => message.status === "delivered" || message.status === "staged")
+        .filter((message) => message.status === "submitted")
         .sort((left, right) => getMessageDeliveredAt(left).localeCompare(getMessageDeliveredAt(right)))
         .at(-1);
 }
 function getMessageDeliveredAt(message) {
-    return message?.deliveredAt ?? message?.stagedAt ?? message?.createdAt ?? "";
+    return message?.submittedAt ?? message?.deliveredAt ?? message?.createdAt ?? "";
 }
 function getCompletedAtForDelivery(roleState, deliveredAt) {
     if (roleState.status !== "idle" || !roleState.lastAnswerEndedAt) {

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

@@ -41,9 +41,9 @@ export function createSessionService(deps) {
             cwd: taskRepoRoot,
             env: {
                 VCM_API_URL: deps.apiUrl,
-                VCM_CTL_COMMAND: deps.vcmctlCommand,
                 VCM_TASK_SLUG: taskSlug,
-                VCM_ROLE: role
+                VCM_ROLE: role,
+                VCM_SESSION_ID: claudeSessionId
             },
             cols: input.cols,
             rows: input.rows,
@@ -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,59 @@ 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: "idle",
+                lastHookEventAt: timestamp,
+                lastStopAt: timestamp,
+                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;
+        },
+        async markRoleActivityRunning(repoRoot, taskSlug, role) {
+            const current = await this.getRoleSession(repoRoot, taskSlug, role);
+            if (!current) {
+                return undefined;
+            }
+            const timestamp = now();
+            const updated = {
+                ...current,
+                activityStatus: "running",
+                lastPromptSubmittedAt: timestamp,
+                lastHookEventAt: timestamp,
+                updatedAt: timestamp
+            };
+            deps.registry.upsert(updated);
+            const config = await deps.projectService.loadConfig(repoRoot);
+            const task = await deps.taskService.loadTask(repoRoot, 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/handoff.js

@@ -106,3 +106,6 @@ TBD
 TBD
 `;
 }
+export function renderMessageRouteTemplate() {
+    return "";
+}

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

@@ -9,5 +9,10 @@ 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.
+- Send replies by writing or updating .ai/vcm/handoffs/messages/architect-project-manager.md.
+- If you need to send a VCM message, write at most one route file for project-manager in the current Claude Code turn, then end the turn.
+- After writing the route file, end the turn immediately. Do not 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 VCM route files only.
 `;
 }

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

@@ -6,10 +6,14 @@ export function renderRootClaudeHarnessRules() {
 - Canonical task handoffs live under .ai/vcm/handoffs/ inside the current task runtime repo.
 - Use only the current task's handoff directory for task-specific artifacts.
 - Do not create or write task handoffs outside .ai/vcm/handoffs/ for the current task.
-- Use vcmctl for role-to-role messaging instead of asking the user to copy prompts.
+- Use route files under .ai/vcm/handoffs/messages/ for role-to-role messaging instead of asking the user to copy prompts.
+- A role-to-role call is represented by exactly one file named <from-role>-<to-role>.md, such as project-manager-coder.md or coder-project-manager.md.
+- If you need to revise a not-yet-delivered message to the same target, update that route file instead of creating another message.
 - 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 writing a route file for another role, end the current Claude Code turn. Treat the file write as the final coordination action of this turn.
+- Do not poll files, start shell loops, or keep the turn open waiting for another role's answer. VCM scans pending route files after your Stop hook and delivers later replies in a new 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,10 @@ 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.
+- Send replies by writing or updating .ai/vcm/handoffs/messages/coder-project-manager.md.
+- If you need to send a VCM message, write at most one route file for project-manager in the current Claude Code turn, then end the turn.
+- After writing the route file, end the turn immediately. Do not 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 VCM route files only.
 `;
 }

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

@@ -3,10 +3,14 @@ export function renderProjectManagerHarnessRules() {
 
 - You are the user-facing orchestration hub for the VCM task.
 - Clarify the user's request, classify task risk, and choose the role route.
-- Use vcmctl send to assign work to architect, coder, or reviewer.
-- Send role work as durable instructions with artifact refs when possible.
+- Assign work by writing or updating .ai/vcm/handoffs/messages/project-manager-architect.md, project-manager-coder.md, or project-manager-reviewer.md.
+- Send role work as durable instructions with optional YAML frontmatter, for example type: task and artifact_refs: .ai/vcm/handoffs/architecture-plan.md.
 - 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.
+- Before sending another task, question, revise, or review-request to the same role, wait for that role's reply file to be delivered back by VCM.
+- In one Claude Code turn, send at most one VCM message to any single target role.
+- After writing a route file, end the turn immediately. Do not send another VCM message, 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 result, blocked, question, or finding message.
+- 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,10 @@ 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.
+- Send replies by writing or updating .ai/vcm/handoffs/messages/reviewer-project-manager.md.
+- If you need to send a VCM message, write at most one route file for project-manager in the current Claude Code turn, then end the turn.
+- After writing the route file, end the turn immediately. Do not 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 VCM route files only.
 `;
 }

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

@@ -2,6 +2,9 @@ export function renderMessageEnvelope(message) {
     const artifactRefs = message.artifactRefs.length > 0
         ? message.artifactRefs.map((artifact) => `- ${artifact}`).join("\n")
         : "- none";
+    const routeFileExample = message.toRole === "project-manager"
+        ? ".ai/vcm/handoffs/messages/project-manager-<target-role>.md"
+        : `.ai/vcm/handoffs/messages/${message.toRole}-project-manager.md`;
     return `
 [VCM MESSAGE]
 id: ${message.id}
@@ -17,7 +20,10 @@ ${artifactRefs}
 
 Instructions:
 - Read the message and execute only within this VCM task.
-- Reply to project-manager with vcmctl reply when complete, blocked, or unclear.
+- If you need to send a VCM message after handling this, write or update .ai/vcm/handoffs/messages/<your-role>-<target-role>.md.
+- Non-PM roles reply only to project-manager, for example ${routeFileExample}.
+- After writing a route file, end this Claude Code turn immediately.
+- Do not poll, loop, or wait for another role in this turn. VCM scans route files after your Stop hook and delivers later replies in a new turn.
 [/VCM MESSAGE]
 `;
 }

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

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