vibe-coding-master 0.0.11 → 0.0.13

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

@@ -0,0 +1,227 @@
+import { ROLE_NAMES } from "../../shared/constants.js";
+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 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;
+            const state = evaluateTaskRoundState({
+                taskSlug: input.taskSlug,
+                messages: input.messages,
+                roleStates,
+                updatedAt: now()
+            });
+            return {
+                ...state,
+                latestMessageId: latestDelivered?.id,
+                latestMessageDeliveredAt: getMessageDeliveredAt(latestDelivered),
+                queuedMessageCount,
+                pendingMessageCount
+            };
+        },
+        stopSession,
+        stopTask(taskSlug) {
+            for (const [sessionId, tracker] of trackers) {
+                if (tracker.taskSlug === taskSlug) {
+                    stopSession(sessionId);
+                }
+            }
+        }
+    };
+}
+export function evaluateTaskRoundState(input) {
+    const latestDelivered = getLatestDeliveredMessage(input.messages);
+    const hasQueuedOrPending = input.messages.some((message) => message.status === "queued" || message.status === "pending_approval");
+    if (latestDelivered) {
+        const deliveredAt = getMessageDeliveredAt(latestDelivered);
+        const targetState = input.roleStates.find((roleState) => roleState.role === latestDelivered.toRole);
+        const completedAt = targetState && deliveredAt
+            ? getCompletedAtForDelivery(targetState, deliveredAt)
+            : undefined;
+        if (completedAt && !hasQueuedOrPending) {
+            return {
+                taskSlug: input.taskSlug,
+                status: "completed",
+                activeRole: latestDelivered.toRole,
+                completionId: `${latestDelivered.id}:${completedAt}`,
+                completedAt,
+                roles: input.roleStates,
+                updatedAt: input.updatedAt
+            };
+        }
+        return {
+            taskSlug: input.taskSlug,
+            status: targetState?.status === "waiting_user" ? "waiting_user" : "active",
+            activeRole: latestDelivered.toRole,
+            roles: input.roleStates,
+            updatedAt: input.updatedAt
+        };
+    }
+    const latestIdleRole = !hasQueuedOrPending ? getLatestIdleRole(input.roleStates) : undefined;
+    if (latestIdleRole?.lastAnswerEndedAt) {
+        return {
+            taskSlug: input.taskSlug,
+            status: "completed",
+            activeRole: latestIdleRole.role,
+            completionId: `direct:${latestIdleRole.role}:${latestIdleRole.lastAnswerEndedAt}`,
+            completedAt: latestIdleRole.lastAnswerEndedAt,
+            roles: input.roleStates,
+            updatedAt: input.updatedAt
+        };
+    }
+    const activeRole = input.roleStates.find((roleState) => roleState.status === "answering" ||
+        roleState.status === "using_tools" ||
+        roleState.status === "waiting_user" ||
+        roleState.status === "abnormal");
+    return {
+        taskSlug: input.taskSlug,
+        status: activeRole?.status === "waiting_user" ? "waiting_user" : activeRole ? "active" : "idle",
+        activeRole: activeRole?.role,
+        roles: input.roleStates,
+        updatedAt: input.updatedAt
+    };
+}
+function toRoleTurnState(role, sessions, trackers) {
+    const session = sessions.find((candidate) => candidate.role === role && candidate.status === "running");
+    const tracker = session ? trackers.get(session.id) : undefined;
+    return {
+        role,
+        sessionId: session?.id,
+        status: tracker?.status ?? "unknown",
+        pendingToolUseCount: tracker?.pendingToolUseIds.size ?? 0,
+        lastActivityAt: tracker?.lastActivityAt,
+        lastAnswerEndedAt: tracker?.lastAnswerEndedAt,
+        reason: tracker?.reason
+    };
+}
+function getLatestDeliveredMessage(messages) {
+    return messages
+        .filter((message) => message.status === "delivered" || message.status === "staged")
+        .sort((left, right) => getMessageDeliveredAt(left).localeCompare(getMessageDeliveredAt(right)))
+        .at(-1);
+}
+function getMessageDeliveredAt(message) {
+    return message?.deliveredAt ?? message?.stagedAt ?? message?.createdAt ?? "";
+}
+function getCompletedAtForDelivery(roleState, deliveredAt) {
+    if (roleState.status !== "idle" || !roleState.lastAnswerEndedAt) {
+        return undefined;
+    }
+    return roleState.lastAnswerEndedAt >= deliveredAt ? roleState.lastAnswerEndedAt : undefined;
+}
+function getLatestIdleRole(roleStates) {
+    return roleStates
+        .filter((roleState) => roleState.status === "idle" && roleState.lastAnswerEndedAt)
+        .sort((left, right) => (left.lastAnswerEndedAt ?? "").localeCompare(right.lastAnswerEndedAt ?? ""))
+        .at(-1);
+}

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

@@ -13,7 +13,7 @@ export function createTaskService(deps) {
                 ? `feature/${input.taskSlug}`
                 : await deps.git.getCurrentBranch(repoRoot);
             const worktreePath = shouldCreateWorktree
-                ? getTaskWorktreePath(repoRoot, config.stateRoot, input.taskSlug)
+                ? getTaskWorktreePath(repoRoot, input.taskSlug)
                 : undefined;
             if (await deps.fs.pathExists(taskPath)) {
                 throw new VcmError({
@@ -30,6 +30,25 @@ export function createTaskService(deps) {
                     hint: "Apply VCM Harness first so .gitignore contains the VCM managed block."
                 });
             }
+            if (shouldCreateWorktree && !(await deps.git.isIgnored(repoRoot, ".claude/worktrees/.probe"))) {
+                throw new VcmError({
+                    code: "VCM_WORKTREES_NOT_IGNORED",
+                    message: ".claude/worktrees/ is not ignored by Git.",
+                    statusCode: 409,
+                    hint: "Apply VCM Harness first so .gitignore ignores Claude-compatible task worktrees."
+                });
+            }
+            if (!shouldCreateWorktree) {
+                const activeInlineTask = await findActiveInlineTask(deps.fs, repoRoot, config.stateRoot);
+                if (activeInlineTask) {
+                    throw new VcmError({
+                        code: "INLINE_TASK_EXISTS",
+                        message: `An inline task already exists: ${activeInlineTask.taskSlug}`,
+                        statusCode: 409,
+                        hint: "Close the existing inline task first, or enable Create worktree and branch for this task."
+                    });
+                }
+            }
             if (shouldCreateWorktree && worktreePath) {
                 if (await deps.git.branchExists(repoRoot, taskBranch)) {
                     throw new VcmError({
@@ -75,7 +94,7 @@ export function createTaskService(deps) {
                 repoRoot,
                 worktreePath,
                 branch: taskBranch,
-                handoffDir: path.posix.join(config.handoffRoot, input.taskSlug),
+                handoffDir: config.handoffRoot,
                 status: "created",
                 specPath: input.specPath,
                 cleanupStatus: "active"
@@ -146,11 +165,11 @@ export function createTaskService(deps) {
             const config = await deps.projectService.loadConfig(repoRoot);
             const task = await this.loadTask(repoRoot, taskSlug);
             const taskRepoRoot = getTaskRuntimeRepoRoot(task);
-            const statePaths = getTaskStatePaths(repoRoot, taskRepoRoot, config.stateRoot, taskSlug);
+            const statePaths = getTaskStatePaths(repoRoot, taskRepoRoot, config.stateRoot, config.handoffRoot, taskSlug);
             const removedStatePaths = [];
             const cleanedAt = now();
             if (task.worktreePath) {
-                assertTaskWorktreePath(repoRoot, config.stateRoot, task.worktreePath);
+                assertTaskWorktreePath(repoRoot, task.worktreePath);
                 await deps.git.removeWorktree(repoRoot, task.worktreePath, { force: options.force ?? true });
             }
             let deletedBranch;
@@ -178,8 +197,8 @@ export function getTaskRuntimeRepoRoot(task) {
 function getTaskPath(repoRoot, stateRoot, taskSlug) {
     return path.join(repoRoot, stateRoot, "tasks", `${taskSlug}.json`);
 }
-function getTaskWorktreePath(repoRoot, stateRoot, taskSlug) {
-    return path.join(repoRoot, stateRoot, "worktrees", taskSlug);
+function getTaskWorktreePath(repoRoot, taskSlug) {
+    return path.join(repoRoot, ".claude", "worktrees", taskSlug);
 }
 async function ensureTaskRuntimeStateDirs(fs, taskRepoRoot, stateRoot) {
     await fs.ensureDir(path.join(taskRepoRoot, stateRoot, "sessions"));
@@ -187,17 +206,32 @@ async function ensureTaskRuntimeStateDirs(fs, taskRepoRoot, stateRoot) {
     await fs.ensureDir(path.join(taskRepoRoot, stateRoot, "orchestration"));
     await fs.ensureDir(path.join(taskRepoRoot, stateRoot, "translation"));
 }
-function getTaskStatePaths(baseRepoRoot, taskRepoRoot, stateRoot, taskSlug) {
+async function findActiveInlineTask(fs, repoRoot, stateRoot) {
+    const tasksDir = path.join(repoRoot, stateRoot, "tasks");
+    if (!(await fs.pathExists(tasksDir))) {
+        return undefined;
+    }
+    const entries = await fs.readDir(tasksDir);
+    for (const entry of entries.filter((candidate) => candidate.endsWith(".json"))) {
+        const task = await fs.readJson(path.join(tasksDir, entry));
+        if (!task.worktreePath && task.cleanupStatus !== "cleaned") {
+            return task;
+        }
+    }
+    return undefined;
+}
+function getTaskStatePaths(baseRepoRoot, taskRepoRoot, stateRoot, handoffRoot, taskSlug) {
     return [
         path.join(baseRepoRoot, stateRoot, "tasks", `${taskSlug}.json`),
         path.join(taskRepoRoot, stateRoot, "sessions", `${taskSlug}.json`),
         path.join(taskRepoRoot, stateRoot, "messages", `${taskSlug}.jsonl`),
         path.join(taskRepoRoot, stateRoot, "orchestration", `${taskSlug}.json`),
-        path.join(taskRepoRoot, stateRoot, "translation", taskSlug)
+        path.join(taskRepoRoot, stateRoot, "translation", taskSlug),
+        path.join(taskRepoRoot, handoffRoot)
     ];
 }
-function assertTaskWorktreePath(repoRoot, stateRoot, worktreePath) {
-    const worktreeRoot = path.resolve(repoRoot, stateRoot, "worktrees");
+function assertTaskWorktreePath(repoRoot, worktreePath) {
+    const worktreeRoot = path.resolve(repoRoot, ".claude", "worktrees");
     const resolvedWorktreePath = path.resolve(worktreePath);
     const relative = path.relative(worktreeRoot, resolvedWorktreePath);
     if (relative.startsWith("..") || path.isAbsolute(relative) || relative === "") {

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

@@ -8,5 +8,6 @@ export function renderArchitectHarnessRules() {
 - Update stale architecture/module/testing/security/dependency docs when the final code made them stale.
 - 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.
 `;
 }

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

@@ -3,11 +3,14 @@ export function renderRootClaudeHarnessRules() {
 
 - This repository uses VibeCodingMaster for multi-session Claude Code work.
 - User-facing work starts with the project-manager role.
-- Canonical task handoffs live under .ai/handoffs/<task-slug>/.
+- 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 .ai/handoffs/<other-task>/ for the current task.
+- 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.
 - 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.
+- 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

@@ -7,5 +7,6 @@ export function renderCoderHarnessRules() {
 - Maintain implementation-log.md and validation-log.md under the current task handoff directory.
 - 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.
 `;
 }

package/dist/backend/templates/harness/gitignore.js

@@ -1,6 +1,7 @@
 export function renderGitignoreHarnessRules() {
     return [
         "# VCM local app state, task metadata, session records, and task worktrees.",
-        ".ai/vcm/"
+        ".ai/vcm/",
+        ".claude/worktrees/"
     ].join("\n");
 }

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

@@ -5,6 +5,9 @@ export function renderProjectManagerHarnessRules() {
 - 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.
+- 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.
+- 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.
 - Prepare final acceptance, commit, and PR only after reviewer and docs-sync gates pass or an explicit exception is approved.

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

@@ -9,5 +9,6 @@ export function renderReviewerHarnessRules() {
 - Escalate larger implementation issues to project-manager for coder follow-up.
 - 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.
 `;
 }

package/dist/backend/ws/terminal-ws.js

@@ -41,7 +41,9 @@ function bindTerminalSocket(ws, sessionId, runtime) {
                 runtime.write(sessionId, message.data);
             }
             else if (message.type === "resize") {
-                runtime.resize(sessionId, message.cols, message.rows);
+                if (isSafeTerminalResize(message.cols, message.rows)) {
+                    runtime.resize(sessionId, message.cols, message.rows);
+                }
             }
         }
         catch (error) {
@@ -53,6 +55,18 @@ function bindTerminalSocket(ws, sessionId, runtime) {
         unsubscribe();
     });
 }
+export function isSafeTerminalResize(cols, rows) {
+    return (Number.isInteger(cols) &&
+        Number.isInteger(rows) &&
+        cols >= MIN_TERMINAL_COLS &&
+        rows >= MIN_TERMINAL_ROWS &&
+        cols <= MAX_TERMINAL_COLS &&
+        rows <= MAX_TERMINAL_ROWS);
+}
+const MIN_TERMINAL_COLS = 20;
+const MIN_TERMINAL_ROWS = 5;
+const MAX_TERMINAL_COLS = 1000;
+const MAX_TERMINAL_ROWS = 200;
 function send(ws, message) {
     if (ws.readyState === ws.OPEN) {
         ws.send(JSON.stringify(message));

package/dist/cli/vcmctl.js

@@ -131,7 +131,7 @@ function printHelp() {
 Usage:
   vcmctl send --to coder --type task --body-file /tmp/message.md
   vcmctl reply --type blocked --body "Need clarification."
-  vcmctl result --body-file /tmp/result.md --artifact .ai/handoffs/task/implementation-log.md
+  vcmctl result --body-file /tmp/result.md --artifact .ai/vcm/handoffs/implementation-log.md
   vcmctl inbox
 `);
 }

package/dist/shared/types/round.js

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