vibe-coding-master 0.0.12 → 0.0.13

package/README.md

@@ -170,7 +170,7 @@ The `Create worktree and branch` option is selected by default when creating a t
 
 - task name: `<task>`
 - branch: `feature/<task>`
-- worktree path: `.ai/vcm/worktrees/<task>` inside the connected base repository
+- worktree path: `.claude/worktrees/<task>` inside the connected base repository
 - role session cwd: that task worktree
 
 VCM will not create worktrees per role. `project-manager`, `architect`, `coder`, and `reviewer` for the same task share the same task worktree.
@@ -179,7 +179,7 @@ The user can turn this option off. In that mode, VCM creates the task metadata a
 
 VCM will not offer a separate `Create task worktree` button after a task exists, and a task should not be switched to another branch/worktree mode after creation.
 
-Because worktrees live under `.ai/vcm/worktrees/`, the connected repository must ignore `.ai/vcm/`. Apply the VCM Harness before creating tasks so `.gitignore` contains the managed ignore block. The base repository must also be clean because the task branch/worktree is created from the connected repo's current `HEAD`.
+Because worktrees live under `.claude/worktrees/`, the connected repository must ignore both `.ai/vcm/` and `.claude/worktrees/`. Apply the VCM Harness before creating tasks so `.gitignore` contains the managed ignore block. The base repository must also be clean because the task branch/worktree is created from the connected repo's current `HEAD`.
 
 When a task is complete, VCM provides a red `Close Task` action. Closing a task shows a destructive confirmation, stops VCM-managed running role sessions for that task, then deletes the task worktree, deletes the task branch by default, removes the base task index entry, and removes task runtime metadata. VCM does not preflight running sessions or uncommitted changes before closing. Tasks created without a worktree only remove VCM metadata because they do not own a separate branch/worktree.
 
@@ -190,7 +190,7 @@ The left sidebar is intentionally compact and collapsible:
 - `Repository Path`: path input on one row; `Recent` and `Connect` on the next row.
 - `Repository`: connected path, branch, and working tree state. `Working tree: uncommitted changes` means `git status --porcelain` is not empty.
 - `Workflow`: current soft gate and five workflow steps.
-- `Settings`: `Theme`, `Messages`, `Events`, and the `Auto orchestration` on/off toggle.
+- `Settings`: `Theme`, `Round alert`, `Messages`, and `Events`.
 - `VCM Harness`: status for `CLAUDE.md`, role agent files, and `.gitignore`.
 - `New Task`: one `task name` input.
 - `Tasks`: task list and task status.
@@ -199,7 +199,7 @@ All sidebar sections are collapsed by default. When no task is selected, `Reposi
 
 ## Translation
 
-The `Translate` button in the role toolbar opens a translation panel beside the embedded terminal. The terminal and translation panel split the available width evenly.
+The role toolbar has an `Auto orchestration` on/off button immediately to the left of the `Translate` button. The `Translate` button opens a translation panel beside the embedded terminal. The terminal and translation panel split the available width evenly.
 
 Translation settings are local and stored in:
 
@@ -211,6 +211,8 @@ The same file stores recent repository paths. The translation API key is stored
 
 The sidebar `Settings` section also stores the UI theme preference in this file. The default is `system`, which follows the OS/browser color-scheme preference; users can cycle between `System`, `Light`, and `Dark`.
 
+The same sidebar also has a `Round alert` toggle. It is on by default and controls the in-app prompt plus short sound that fires when VCM detects that the current full conversation round is complete.
+
 Translation behavior:
 
 - Provider type is OpenAI-compatible chat completions.
@@ -255,10 +257,11 @@ For `.gitignore`, VCM uses a gitignore-native managed block:
 ```gitignore
 # VCM:BEGIN version=1
 .ai/vcm/
+.claude/worktrees/
 # VCM:END
 ```
 
-`.ai/vcm/` is the active VCM local control area. The base repo keeps the task index and nested worktrees; each task runtime repo keeps its own session, message, orchestration, and translation state.
+`.ai/vcm/` is the active VCM local control area, and `.claude/worktrees/` is the Claude-compatible task worktree area. The base repo keeps the task index; each task runtime repo keeps its own session, message, orchestration, and translation state.
 
 After applying harness changes, VCM reports the exact files changed and reminds the user to review and commit them before starting long-running work.
 
@@ -301,7 +304,7 @@ The backend also keeps a compatibility role-command dispatch endpoint, but the p
 
 ## Orchestration Modes
 
-VCM has a task-level `Auto orchestration` switch in the sidebar `Settings` section.
+VCM has a task-level `Auto orchestration` switch in the active role toolbar, immediately to the left of `Translate`.
 
 When it is off, VCM is in manual mode:
 
@@ -317,12 +320,24 @@ When it is on, VCM is in auto mode:
 - Backend policy still applies.
 - PM can send work to `architect`, `coder`, or `reviewer`.
 - Non-PM roles can reply only to `project-manager`.
-- If the target role session is running, VCM writes a `[VCM MESSAGE]` envelope to the target terminal and submits it.
+- If the target role session is running and has no active delivered message, VCM writes a `[VCM MESSAGE]` envelope to the target terminal and submits it.
+- When the GUI observes a newly delivered auto message, it switches the active role tab to that message's target role so the user can watch the next step.
+- VCM enforces per-role turn-taking: each target role can have at most one in-flight delivered message.
+- Additional messages to a busy target role are kept as `queued` and are not written to that terminal.
+- When a role sends `vcmctl reply` or `vcmctl result`, VCM acknowledges that role's active message and delivers the next queued message for that role.
 
 The backend state model still contains a `paused` field for compatibility with existing API routes, but the current GUI exposes only a single on/off orchestration toggle.
 
 The backend still exposes stage/approve/reject compatibility APIs for automation and future UI work. They are not primary controls in the current Messages modal.
 
+## Round Completion Alerts
+
+VCM detects conversation completion from Claude Code transcript JSONL events, not PTY silence. The backend watches each running role session and treats `stop_reason === "end_turn"` as a candidate end only after pending tool uses have finished and a short debounce passes.
+
+For role chains, VCM waits for the latest delivered message's target role. For example, if PM sends work to Coder and Coder sends a result back to PM, the round is not complete when Coder finishes; it is complete only after PM finishes the final response. If no VCM role message is involved, the latest direct role answer can complete the round.
+
+When `Round alert` is enabled, the frontend polls the task round state, deduplicates each completion id, shows a small `Round complete` prompt, and plays a short local sound.
+
 ## Resume Behavior
 
 Each role session stores its Claude session id and transcript path under:
@@ -345,7 +360,7 @@ For a connected repository, VCM uses:
 ```text
 ~/.vcm/projects/<project-id>/config.json
 <baseRepoRoot>/.ai/vcm/tasks/<task>.json
-<baseRepoRoot>/.ai/vcm/worktrees/<task>/
+<baseRepoRoot>/.claude/worktrees/<task>/
 <taskRepoRoot>/.ai/vcm/sessions/<task>.json
 <taskRepoRoot>/.ai/vcm/messages/<task>.jsonl
 <taskRepoRoot>/.ai/vcm/orchestration/<task>.json
@@ -359,7 +374,7 @@ For a connected repository, VCM uses:
 <taskRepoRoot>/.ai/vcm/handoffs/logs/{project-manager,architect,coder,reviewer}.log
 ```
 
-The project config is stored under `~/.vcm` so it is durable local app state and is not hidden inside a Git-ignored repository directory. For worktree-backed tasks, `taskRepoRoot` is `<baseRepoRoot>/.ai/vcm/worktrees/<task>`; for inline tasks, `taskRepoRoot` is the connected base repo.
+The project config is stored under `~/.vcm` so it is durable local app state and is not hidden inside a Git-ignored repository directory. For worktree-backed tasks, `taskRepoRoot` is `<baseRepoRoot>/.claude/worktrees/<task>`; for inline tasks, `taskRepoRoot` is the connected base repo.
 
 Because handoffs are scoped to `taskRepoRoot` without an extra task-name directory, VCM allows only one active inline task per connected repository. Use the default worktree mode for parallel tasks.
 

package/dist/backend/api/round-routes.js

@@ -0,0 +1,33 @@
+import { VcmError } from "../errors.js";
+import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
+export function registerRoundRoutes(app, deps) {
+    app.get("/api/tasks/:taskSlug/round", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const config = await deps.projectService.loadConfig(project.repoRoot);
+        const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+        const sessions = await deps.sessionService.listRoleSessions(project.repoRoot, request.params.taskSlug);
+        const messages = await deps.messageService.listMessages({
+            repoRoot: project.repoRoot,
+            stateRepoRoot: taskRepoRoot,
+            stateRoot: config.stateRoot,
+            taskSlug: request.params.taskSlug
+        });
+        return deps.roundService.getTaskRoundState({
+            taskSlug: request.params.taskSlug,
+            sessions,
+            messages
+        });
+    });
+}
+async function requireCurrentProject(projectService) {
+    const project = await projectService.getCurrentProject();
+    if (!project) {
+        throw new VcmError({
+            code: "PROJECT_NOT_CONNECTED",
+            message: "Connect a repository first.",
+            statusCode: 409
+        });
+    }
+    return project;
+}

package/dist/backend/api/session-routes.js

@@ -15,6 +15,7 @@ export function registerSessionRoutes(app, deps) {
         const role = parseRole(request.params.role);
         const session = await deps.sessionService.stopRoleSession(project.repoRoot, request.params.taskSlug, role);
         await deps.translationService.stopSession(session.id);
+        deps.roundService.stopSession(session.id);
         return session;
     });
     app.post("/api/tasks/:taskSlug/sessions/:role/restart", async (request) => {
@@ -23,6 +24,7 @@ export function registerSessionRoutes(app, deps) {
         const existing = await deps.sessionService.getRoleSession(project.repoRoot, request.params.taskSlug, role);
         if (existing) {
             await deps.translationService.stopSession(existing.id, { clearCache: true });
+            deps.roundService.stopSession(existing.id);
         }
         return deps.sessionService.restartRoleSession(project.repoRoot, request.params.taskSlug, role, request.body);
     });

package/dist/backend/api/task-routes.js

@@ -22,6 +22,7 @@ export function registerTaskRoutes(app, deps) {
         const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
         await stopRunningRoleSessions(deps, project.repoRoot, request.params.taskSlug);
         await deps.translationService.stopTask(getTaskRuntimeRepoRoot(task), request.params.taskSlug, { clearCache: true });
+        deps.roundService.stopTask(request.params.taskSlug);
         return deps.taskService.cleanupTask(project.repoRoot, request.params.taskSlug, request.body ?? {});
     });
 }

package/dist/backend/server.js

@@ -18,6 +18,7 @@ import { createProjectService } from "./services/project-service.js";
 import { createSessionRegistry } from "./runtime/session-registry.js";
 import { createSessionService } from "./services/session-service.js";
 import { createMessageService } from "./services/message-service.js";
+import { createRoundService } from "./services/round-service.js";
 import { createStatusService } from "./services/status-service.js";
 import { createTaskService } from "./services/task-service.js";
 import { createTranslationService } from "./services/translation-service.js";
@@ -26,6 +27,7 @@ import { registerArtifactRoutes } from "./api/artifact-routes.js";
 import { registerHarnessRoutes } from "./api/harness-routes.js";
 import { registerMessageRoutes } from "./api/message-routes.js";
 import { registerProjectRoutes } from "./api/project-routes.js";
+import { registerRoundRoutes } from "./api/round-routes.js";
 import { registerSessionRoutes } from "./api/session-routes.js";
 import { registerTaskRoutes } from "./api/task-routes.js";
 import { registerTranslationRoutes } from "./api/translation-routes.js";
@@ -56,13 +58,15 @@ export async function createServer(deps, options = {}) {
         taskService: deps.taskService,
         sessionService: deps.sessionService,
         statusService: deps.statusService,
-        translationService: deps.translationService
+        translationService: deps.translationService,
+        roundService: deps.roundService
     });
     registerSessionRoutes(app, {
         projectService: deps.projectService,
         sessionService: deps.sessionService,
         commandDispatcher: deps.commandDispatcher,
-        translationService: deps.translationService
+        translationService: deps.translationService,
+        roundService: deps.roundService
     });
     registerArtifactRoutes(app, {
         projectService: deps.projectService,
@@ -74,6 +78,13 @@ export async function createServer(deps, options = {}) {
         taskService: deps.taskService,
         messageService: deps.messageService
     });
+    registerRoundRoutes(app, {
+        projectService: deps.projectService,
+        taskService: deps.taskService,
+        sessionService: deps.sessionService,
+        messageService: deps.messageService,
+        roundService: deps.roundService
+    });
     registerTranslationRoutes(app, {
         projectService: deps.projectService,
         taskService: deps.taskService,
@@ -146,10 +157,14 @@ export function createDefaultServerDeps(options = {}) {
         sessionService,
         taskService
     });
+    const transcripts = createClaudeTranscriptService();
+    const roundService = createRoundService({
+        transcripts
+    });
     const translationService = createTranslationService({
         runtime,
         sessionRegistry: registry,
-        transcripts: createClaudeTranscriptService(),
+        transcripts,
         sessionService,
         fs,
         projectService,
@@ -165,6 +180,7 @@ export function createDefaultServerDeps(options = {}) {
         harnessService,
         commandDispatcher,
         messageService,
+        roundService,
         statusService,
         translationService,
         runtime

package/dist/backend/services/app-settings-service.js

@@ -180,7 +180,8 @@ function normalizeSettingsFile(input) {
 function normalizePreferences(input) {
     const candidate = isObject(input) ? input : {};
     return {
-        themeMode: normalizeThemeMode(candidate.themeMode)
+        themeMode: normalizeThemeMode(candidate.themeMode),
+        roundCompletionAlerts: candidate.roundCompletionAlerts !== false
     };
 }
 function normalizeThemeMode(input) {

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

@@ -11,55 +11,128 @@ const ROLE_TO_PM_TYPES = new Set(["result", "question", "blocked", "finding"]);
 export function createMessageService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     const id = deps.id ?? (() => `msg_${randomUUID()}`);
-    return {
-        listMessages(input) {
-            return readLatestMessages(deps.fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
-        },
-        async sendMessage(input) {
-            await deps.taskService.loadTask(input.repoRoot, input.taskSlug);
-            validateMessagePolicy(input.fromRole, input.toRole, input.type);
-            const timestamp = now();
-            const message = {
-                id: id(),
+    const taskLocks = new Map();
+    async function getOrchestrationState(input) {
+        const statePath = getOrchestrationStatePath(getStateRepoRoot(input), input.stateRoot, input.taskSlug);
+        if (!(await deps.fs.pathExists(statePath))) {
+            return {
                 taskSlug: input.taskSlug,
-                fromRole: input.fromRole,
-                toRole: input.toRole,
-                type: input.type,
-                body: input.body,
-                artifactRefs: input.artifactRefs ?? [],
-                parentMessageId: input.parentMessageId,
-                status: "queued",
-                createdAt: timestamp
+                mode: "manual",
+                paused: false,
+                updatedAt: now()
             };
-            message.bodyPath = await writeMessageBody(deps.fs, input.taskRepoRoot ?? input.repoRoot, input.handoffDir, message);
-            const state = await this.getOrchestrationState(input);
-            const session = await deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, input.toRole);
-            if (!session || session.status !== "running") {
-                message.status = "queued";
-                message.failureReason = `${input.toRole} session is not running.`;
-                await appendMessageSnapshot(deps.fs, input, message);
-                return { message, delivered: false, requiresUserApproval: false };
-            }
-            if (state.mode === "manual") {
-                message.status = "pending_approval";
-                await appendMessageSnapshot(deps.fs, input, message);
-                return { message, delivered: false, requiresUserApproval: true };
-            }
-            if (state.paused) {
-                message.status = "queued";
-                message.failureReason = "Auto orchestration is paused.";
-                await appendMessageSnapshot(deps.fs, input, message);
-                return { message, delivered: false, requiresUserApproval: false };
+        }
+        return deps.fs.readJson(statePath);
+    }
+    async function sendMessageLocked(input) {
+        await deps.taskService.loadTask(input.repoRoot, input.taskSlug);
+        validateMessagePolicy(input.fromRole, input.toRole, input.type);
+        const timestamp = now();
+        const message = {
+            id: id(),
+            taskSlug: input.taskSlug,
+            fromRole: input.fromRole,
+            toRole: input.toRole,
+            type: input.type,
+            body: input.body,
+            artifactRefs: input.artifactRefs ?? [],
+            parentMessageId: input.parentMessageId,
+            status: "queued",
+            createdAt: timestamp
+        };
+        message.bodyPath = await writeMessageBody(deps.fs, input.taskRepoRoot ?? input.repoRoot, input.handoffDir, message);
+        let messages = await readLatestMessages(deps.fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
+        if (isRoleActor(input.fromRole)) {
+            const acknowledged = acknowledgeActiveMessages(messages, input.fromRole, timestamp);
+            for (const acknowledgedMessage of acknowledged) {
+                await appendMessageSnapshot(deps.fs, input, acknowledgedMessage);
             }
-            const delivered = {
+            messages = applyMessageSnapshots(messages, acknowledged);
+        }
+        const state = await getOrchestrationState(input);
+        const result = await routeOutboundMessage(input, message, messages, state, timestamp);
+        await appendMessageSnapshot(deps.fs, input, result.message);
+        if (isRoleActor(input.fromRole)) {
+            await deliverNextQueuedMessage(input, input.fromRole);
+        }
+        return result;
+    }
+    async function routeOutboundMessage(input, message, existingMessages, state, timestamp) {
+        const session = await deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, input.toRole);
+        if (!session || session.status !== "running") {
+            const queued = {
                 ...message,
-                status: "delivered",
-                deliveredAt: timestamp,
-                failureReason: undefined
+                status: "queued",
+                failureReason: `${input.toRole} session is not running.`
             };
-            await submitTerminalInput(deps.runtime, session.id, renderMessageEnvelope(delivered));
-            await appendMessageSnapshot(deps.fs, input, delivered);
-            return { message: delivered, delivered: true, requiresUserApproval: false };
+            return { message: queued, delivered: false, requiresUserApproval: false };
+        }
+        if (state.mode === "manual") {
+            const pending = {
+                ...message,
+                status: "pending_approval"
+            };
+            return { message: pending, delivered: false, requiresUserApproval: true };
+        }
+        if (state.paused) {
+            const queued = {
+                ...message,
+                status: "queued",
+                failureReason: "Auto orchestration is paused."
+            };
+            return { message: queued, delivered: false, requiresUserApproval: false };
+        }
+        const activeMessage = findActiveMessageForRole(existingMessages, input.toRole);
+        if (activeMessage) {
+            const queued = {
+                ...message,
+                status: "queued",
+                queuedBehindMessageId: activeMessage.id,
+                failureReason: `${input.toRole} is still handling VCM message ${activeMessage.id}.`
+            };
+            return { message: queued, delivered: false, requiresUserApproval: false };
+        }
+        const delivered = await deliverMessageToSession(session.id, message, timestamp);
+        return { message: delivered, delivered: true, requiresUserApproval: false };
+    }
+    async function deliverNextQueuedMessage(input, targetRole) {
+        const state = await getOrchestrationState(input);
+        if (state.mode !== "auto" || state.paused) {
+            return undefined;
+        }
+        const messages = await readLatestMessages(deps.fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
+        if (findActiveMessageForRole(messages, targetRole)) {
+            return undefined;
+        }
+        const nextMessage = messages.find((message) => message.toRole === targetRole && message.status === "queued");
+        if (!nextMessage) {
+            return undefined;
+        }
+        const session = await deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, targetRole);
+        if (!session || session.status !== "running") {
+            return undefined;
+        }
+        const delivered = await deliverMessageToSession(session.id, nextMessage, now());
+        await appendMessageSnapshot(deps.fs, input, delivered);
+        return delivered;
+    }
+    async function deliverMessageToSession(sessionId, message, timestamp) {
+        const delivered = {
+            ...message,
+            status: "delivered",
+            deliveredAt: timestamp,
+            queuedBehindMessageId: undefined,
+            failureReason: undefined
+        };
+        await submitTerminalInput(deps.runtime, sessionId, renderMessageEnvelope(delivered));
+        return delivered;
+    }
+    return {
+        listMessages(input) {
+            return readLatestMessages(deps.fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
+        },
+        async sendMessage(input) {
+            return withTaskLock(taskLocks, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), () => sendMessageLocked(input));
         },
         async stageMessage(input) {
             const message = await getMessageOrThrow(deps.fs, input);
@@ -96,19 +169,10 @@ export function createMessageService(deps) {
             return rejected;
         },
         async getOrchestrationState(input) {
-            const statePath = getOrchestrationStatePath(getStateRepoRoot(input), input.stateRoot, input.taskSlug);
-            if (!(await deps.fs.pathExists(statePath))) {
-                return {
-                    taskSlug: input.taskSlug,
-                    mode: "manual",
-                    paused: false,
-                    updatedAt: now()
-                };
-            }
-            return deps.fs.readJson(statePath);
+            return getOrchestrationState(input);
         },
         async updateOrchestrationState(input) {
-            const current = await this.getOrchestrationState(input);
+            const current = await getOrchestrationState(input);
             const next = {
                 ...current,
                 mode: input.mode ?? current.mode,
@@ -158,6 +222,45 @@ function validateMessagePolicy(fromRole, toRole, type) {
         hint: "Use project-manager as the orchestration hub."
     });
 }
+async function withTaskLock(locks, key, run) {
+    const previous = locks.get(key) ?? Promise.resolve();
+    const next = previous.catch(() => undefined).then(run);
+    locks.set(key, next);
+    try {
+        return await next;
+    }
+    finally {
+        if (locks.get(key) === next) {
+            locks.delete(key);
+        }
+    }
+}
+function isRoleActor(actor) {
+    return ROLE_NAMES.includes(actor);
+}
+function findActiveMessageForRole(messages, role) {
+    return messages.find((message) => message.toRole === role && message.status === "delivered");
+}
+function acknowledgeActiveMessages(messages, role, timestamp) {
+    return messages
+        .filter((message) => message.toRole === role && message.status === "delivered")
+        .map((message) => ({
+        ...message,
+        status: "acknowledged",
+        acknowledgedAt: timestamp,
+        failureReason: undefined
+    }));
+}
+function applyMessageSnapshots(messages, snapshots) {
+    if (snapshots.length === 0) {
+        return messages;
+    }
+    const latest = new Map(messages.map((message) => [message.id, message]));
+    for (const snapshot of snapshots) {
+        latest.set(snapshot.id, snapshot);
+    }
+    return [...latest.values()].sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+}
 async function writeMessageBody(fs, repoRoot, handoffDir, message) {
     const bodyPath = path.posix.join(handoffDir, "messages", `${message.id}.md`);
     await fs.writeText(resolveRepoPath(repoRoot, bodyPath), renderMessageBodyFile(message));

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

@@ -31,7 +31,7 @@ export function createProjectService(deps) {
             const config = await this.loadConfig(repoRoot);
             await deps.fs.ensureDir(path.join(repoRoot, config.handoffRoot));
             await deps.fs.ensureDir(path.join(repoRoot, config.stateRoot, "tasks"));
-            await deps.fs.ensureDir(path.join(repoRoot, config.stateRoot, "worktrees"));
+            await deps.fs.ensureDir(path.join(repoRoot, ".claude", "worktrees"));
             await this.saveConfig(config, true);
             const warnings = [];
             let branch = "unknown";