vibe-coding-master 0.3.21 → 0.3.23

package/README.md

@@ -237,7 +237,7 @@ the base repo has uncommitted changes, when the current branch has no upstream,
 or when the active task is an inline task using the base repo directly. It does
 not stash, merge, or mutate task worktrees.
 
-When VCM is connected to an active task, the bottom of the sidebar shows a task status dock. It stays outside the collapsible groups and shows the active VCM Session title, task status, start time, total elapsed time, total Round count, and role active runtime. If a Round is currently running, the dock also shows the Current Round start time, total elapsed time, role active runtime, and Turn count.
+When VCM is connected to an active task, the bottom of the sidebar shows a task status dock. It stays outside the collapsible groups and shows the active VCM Session title, task status, start time, total elapsed time, total Round count, and role active runtime. The dock also shows the Current Round while it is running, or the Last Round after a flow pause, including start time, total elapsed time, role active runtime, Turn count, and Round status.
 
 ## Mobile Gateway
 
@@ -586,7 +586,7 @@ The normal path is timer-driven: `Stop` starts a backend timer, and `UserPromptS
 
 When `Flow pause alert` is enabled, the frontend polls the task Round state and deduplicates each stopped Round so the same stopped state does not alert on every poll. Flow duration is measured from the first `UserPromptSubmit` to `stoppedAt`, falling back to the last `Stop` when needed. If the flow lasted less than 2 minutes, it plays the local chime 3 times at 1.4 second intervals. If the flow lasted 2 minutes or longer, it shows a modal alert and repeats the local chime until the user clicks `Confirm`. A stopped Round can mean normal completion, user decision needed, dispatch failure, or another workflow interruption; the point is to get the user to look with the right amount of urgency.
 
-The Current Round dock separates wall-clock Round duration from role active runtime. `Total` is `now - Round.startedAt`; `Role runtime` is only the accumulated time between each Turn's `UserPromptSubmit` and `Stop`; `Turn count` is the number of accepted prompts inside the current Round.
+The Round dock separates wall-clock Round duration from role active runtime. For a running Round, `Total` is `now - Round.startedAt`; for a stopped Round, it is `stoppedAt - Round.startedAt`. `Role runtime` is only the accumulated time between each Turn's `UserPromptSubmit` and `Stop`; `Turn count` is the number of accepted prompts inside the Round.
 
 ## Resume Behavior
 

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

@@ -64,11 +64,18 @@ export function registerArtifactRoutes(app, deps) {
         const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
         const paths = deps.artifactService.getHandoffPaths(taskRepoRoot, task.handoffDir);
+        const artifactPath = paths.roleLogPaths[request.params.role];
+        if (!artifactPath) {
+            return {
+                role: request.params.role,
+                content: ""
+            };
+        }
         return {
             role: request.params.role,
             content: await deps.artifactService.readArtifact({
                 repoRoot: taskRepoRoot,
-                artifactPath: paths.roleLogPaths[request.params.role]
+                artifactPath
             })
         };
     });

package/dist/backend/api/codex-translation-routes.js

@@ -4,6 +4,30 @@ export function registerCodexTranslationRoutes(app, deps) {
         const project = await requireCurrentProject(deps.projectService);
         return deps.codexTranslationService.getState(project.repoRoot);
     });
+    app.get("/api/translation/codex/session", async () => {
+        const project = await requireCurrentProject(deps.projectService);
+        return (await deps.sessionService.getProjectTranslatorSession(project.repoRoot)) ?? null;
+    });
+    app.post("/api/translation/codex/session/ensure", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.sessionService.ensureProjectTranslatorSession(project.repoRoot, request.body);
+    });
+    app.post("/api/translation/codex/session/start", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.sessionService.startProjectTranslatorSession(project.repoRoot, request.body);
+    });
+    app.post("/api/translation/codex/session/resume", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.sessionService.resumeProjectTranslatorSession(project.repoRoot, request.body);
+    });
+    app.post("/api/translation/codex/session/restart", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.sessionService.restartProjectTranslatorSession(project.repoRoot, request.body);
+    });
+    app.post("/api/translation/codex/session/stop", async () => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.sessionService.stopProjectTranslatorSession(project.repoRoot);
+    });
     app.get("/api/translation/codex/source-files", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         return deps.codexTranslationService.browseSourceFiles(project.repoRoot, {

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

@@ -4,7 +4,9 @@ export function registerProjectRoutes(app, deps) {
         return deps.projectService.getRecentRepositoryPaths();
     });
     app.post("/api/projects/connect", async (request) => {
-        return deps.projectService.connectProject(request.body);
+        const project = await deps.projectService.connectProject(request.body);
+        await deps.codexTranslationService?.cleanupStartupRuntime(project.repoRoot);
+        return project;
     });
     app.get("/api/projects/current", async () => {
         return deps.projectService.getCurrentProject();

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

@@ -88,7 +88,9 @@ function degradedArtifactSummary(handoffDir) {
             logsDir,
             messagesDir,
             roleCommandPaths: Object.fromEntries(DISPATCHABLE_ROLES.map((role) => [role, `${roleCommandsDir}/${role}.md`])),
-            roleLogPaths: Object.fromEntries(ROLE_NAMES.map((role) => [role, `${logsDir}/${role}.log`])),
+            roleLogPaths: Object.fromEntries(ROLE_NAMES
+                .filter((role) => role !== "codex-translator")
+                .map((role) => [role, `${logsDir}/${role}.log`])),
             messageRoutePaths: {},
             architecturePlanPath: `${handoffDir}/architecture-plan.md`,
             knownIssuesPath: `${handoffDir}/known-issues.md`,

package/dist/backend/server.js

@@ -72,10 +72,14 @@ export async function createServer(deps, options = {}) {
         codexReviewService: deps.codexReviewService
     });
     registerCodexTranslationRoutes(app, {
+        projectService: deps.projectService,
+        codexTranslationService: deps.codexTranslationService,
+        sessionService: deps.sessionService
+    });
+    registerProjectRoutes(app, {
         projectService: deps.projectService,
         codexTranslationService: deps.codexTranslationService
     });
-    registerProjectRoutes(app, { projectService: deps.projectService });
     registerHarnessRoutes(app, {
         projectService: deps.projectService,
         harnessService: deps.harnessService
@@ -118,6 +122,7 @@ export async function createServer(deps, options = {}) {
     registerGatewayRoutes(app, { gatewayService: deps.gatewayService });
     registerTerminalWs(app, { runtime: deps.runtime });
     app.addHook("onReady", async () => {
+        await cleanupRecentTranslationRuntime(deps);
         await deps.gatewayService.start();
     });
     app.addHook("onClose", async () => {
@@ -134,6 +139,10 @@ export async function createServer(deps, options = {}) {
     }
     return app;
 }
+async function cleanupRecentTranslationRuntime(deps) {
+    const repoRoots = await deps.projectService.getRecentRepositoryPaths();
+    await Promise.all(repoRoots.map((repoRoot) => deps.codexTranslationService.cleanupStartupRuntime(repoRoot)));
+}
 export async function startServer(options = {}) {
     const host = options.host ?? "127.0.0.1";
     const port = options.port ?? 4173;

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

@@ -42,8 +42,7 @@ export function createArtifactService(fs) {
                     architect: path.posix.join(logsDir, "architect.log"),
                     coder: path.posix.join(logsDir, "coder.log"),
                     reviewer: path.posix.join(logsDir, "reviewer.log"),
-                    "codex-reviewer": path.posix.join(logsDir, "codex-reviewer.log"),
-                    "codex-translator": path.posix.join(logsDir, "codex-translator.log")
+                    "codex-reviewer": path.posix.join(logsDir, "codex-reviewer.log")
                 },
                 messageRoutePaths: getDefaultMessageRoutePaths(messagesDir),
                 architecturePlanPath: path.posix.join(handoffDir, "architecture-plan.md"),
@@ -179,7 +178,15 @@ export function createArtifactService(fs) {
                 });
             }
             const paths = this.getHandoffPaths(input.repoRoot, input.handoffDir);
-            await fs.appendText(resolveRepoPath(input.repoRoot, paths.roleLogPaths[input.role]), input.content);
+            const roleLogPath = paths.roleLogPaths[input.role];
+            if (!roleLogPath) {
+                throw new VcmError({
+                    code: "ROLE_LOG_UNAVAILABLE",
+                    message: `${input.role} does not write a handoff log.`,
+                    statusCode: 409
+                });
+            }
+            await fs.appendText(resolveRepoPath(input.repoRoot, roleLogPath), input.content);
         }
     };
 }

package/dist/backend/services/codex-hook-service.js

@@ -18,6 +18,13 @@ export function createCodexHookService(deps) {
                 statusCode: 409
             });
         }
+        if (input.role === "codex-translator") {
+            return {
+                project,
+                config: undefined,
+                taskRepoRoot: undefined
+            };
+        }
         const config = await deps.projectService.loadConfig(project.repoRoot);
         const task = await deps.taskService.loadTask(project.repoRoot, input.taskSlug);
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
@@ -37,16 +44,30 @@ export function createCodexHookService(deps) {
             });
         }
         const context = await getHookContext(input);
-        const session = await deps.sessionService.recordRoleHookEvent(context.project.repoRoot, {
-            taskSlug: input.taskSlug,
-            role: input.role,
-            eventName,
-            sessionId: stringOrUndefined(input.event.session_id),
-            transcriptPath: stringOrUndefined(input.event.transcript_path),
-            cwd: stringOrUndefined(input.event.cwd),
-            allowSessionMismatch: true
-        });
+        const session = input.role === "codex-translator"
+            ? await deps.sessionService.recordProjectTranslatorHookEvent(context.project.repoRoot, {
+                eventName,
+                sessionId: stringOrUndefined(input.event.session_id),
+                transcriptPath: stringOrUndefined(input.event.transcript_path),
+                cwd: stringOrUndefined(input.event.cwd)
+            })
+            : await deps.sessionService.recordRoleHookEvent(context.project.repoRoot, {
+                taskSlug: input.taskSlug,
+                role: input.role,
+                eventName,
+                sessionId: stringOrUndefined(input.event.session_id),
+                transcriptPath: stringOrUndefined(input.event.transcript_path),
+                cwd: stringOrUndefined(input.event.cwd),
+                allowSessionMismatch: true
+            });
         if (input.role === "codex-reviewer") {
+            if (!context.config || !context.taskRepoRoot) {
+                throw new VcmError({
+                    code: "CODEX_HOOK_TASK_CONTEXT_MISSING",
+                    message: "Codex Reviewer hook is missing task context.",
+                    statusCode: 500
+                });
+            }
             await deps.roundService.recordRoleTurnEvent({
                 repoRoot: context.project.repoRoot,
                 stateRepoRoot: context.taskRepoRoot,