vibe-coding-master 0.3.23 → 0.3.25

package/dist/backend/adapters/filesystem.js

@@ -54,7 +54,21 @@ export function createNodeFileSystemAdapter() {
             });
         },
         async readJson(targetPath) {
-            return JSON.parse(await runFileOperation(() => fs.readFile(targetPath, "utf8")));
+            let attempt = 0;
+            for (;;) {
+                const content = await runFileOperation(() => fs.readFile(targetPath, "utf8"));
+                try {
+                    return JSON.parse(content);
+                }
+                catch (error) {
+                    const delayMs = JSON_READ_RETRY_DELAYS_MS[attempt];
+                    if (!(error instanceof SyntaxError) || delayMs === undefined) {
+                        throw error;
+                    }
+                    attempt += 1;
+                    await delay(delayMs);
+                }
+            }
         },
         async writeJson(targetPath, value) {
             await this.writeText(targetPath, `${JSON.stringify(value, null, 2)}\n`);
@@ -84,6 +98,7 @@ export function createNodeFileSystemAdapter() {
 }
 const DEFAULT_FILE_OPERATION_CONCURRENCY = 8;
 const OPEN_FILE_RETRY_DELAYS_MS = [25, 50, 100, 200, 400, 800];
+const JSON_READ_RETRY_DELAYS_MS = [25, 50, 100, 200];
 function createFileOperationRunner(maxConcurrent = DEFAULT_FILE_OPERATION_CONCURRENCY) {
     let active = 0;
     const waiters = [];

package/dist/backend/adapters/git-adapter.js

@@ -81,6 +81,18 @@ export function createGitAdapter(runner) {
             }
             return result.stdout;
         },
+        async getStagedStatus(repoRoot) {
+            const result = await runGit(runner, repoRoot, ["diff", "--cached", "--name-status"]);
+            if (result.exitCode !== 0) {
+                throw new VcmError({
+                    code: "GIT_ERROR",
+                    message: "Unable to read staged Git changes.",
+                    statusCode: 400,
+                    hint: result.stderr
+                });
+            }
+            return result.stdout;
+        },
         async isIgnored(repoRoot, repoRelativePath) {
             const result = await runGit(runner, repoRoot, ["check-ignore", "-q", "--", repoRelativePath]);
             if (result.exitCode === 0) {
@@ -111,6 +123,47 @@ export function createGitAdapter(runner) {
                 hint: result.stderr
             });
         },
+        async addPaths(repoRoot, paths) {
+            if (paths.length === 0) {
+                return;
+            }
+            const result = await runGit(runner, repoRoot, ["add", "--", ...paths]);
+            if (result.exitCode !== 0) {
+                throw new VcmError({
+                    code: "GIT_ADD_FAILED",
+                    message: "Unable to stage harness changes.",
+                    statusCode: 409,
+                    hint: result.stderr || result.stdout
+                });
+            }
+        },
+        async commit(repoRoot, message) {
+            const result = await runGit(runner, repoRoot, ["commit", "-m", message]);
+            if (result.exitCode !== 0) {
+                throw new VcmError({
+                    code: "GIT_COMMIT_FAILED",
+                    message: "Unable to commit harness changes.",
+                    statusCode: 409,
+                    hint: result.stderr || result.stdout
+                });
+            }
+            return this.getHeadCommit(repoRoot);
+        },
+        async rebase(repoRoot, upstream) {
+            const result = await runGit(runner, repoRoot, ["rebase", upstream]);
+            if (result.exitCode !== 0) {
+                throw new VcmError({
+                    code: "GIT_REBASE_FAILED",
+                    message: "Unable to rebase task branch onto the harness commit.",
+                    statusCode: 409,
+                    hint: result.stderr || result.stdout
+                });
+            }
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr
+            };
+        },
         async createWorktree(input) {
             const result = await runGit(runner, input.repoRoot, [
                 "worktree",

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

@@ -1,4 +1,4 @@
-import { isDispatchableRole, isRoleName } from "../../shared/constants.js";
+import { isDispatchableRole } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
 export function registerArtifactRoutes(app, deps) {
@@ -52,33 +52,6 @@ export function registerArtifactRoutes(app, deps) {
         });
         return { ok: true };
     });
-    app.get("/api/tasks/:taskSlug/logs/:role", async (request) => {
-        const project = await requireCurrentProject(deps.projectService);
-        if (!isRoleName(request.params.role)) {
-            throw new VcmError({
-                code: "UNKNOWN_ROLE",
-                message: `Unknown role: ${request.params.role}`,
-                statusCode: 400
-            });
-        }
-        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
-            })
-        };
-    });
 }
 function parseDispatchableRole(role) {
     if (!isDispatchableRole(role)) {

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

@@ -2,7 +2,9 @@ import { VcmError } from "../errors.js";
 export function registerCodexTranslationRoutes(app, deps) {
     app.get("/api/translation/codex/state", async () => {
         const project = await requireCurrentProject(deps.projectService);
-        return deps.codexTranslationService.getState(project.repoRoot);
+        return deps.codexTranslationService.getState(project.repoRoot, {
+            visibility: "public"
+        });
     });
     app.get("/api/translation/codex/session", async () => {
         const project = await requireCurrentProject(deps.projectService);

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

@@ -16,6 +16,16 @@ export function registerHarnessRoutes(app, deps) {
         const project = await requireCurrentProject(deps.projectService);
         return deps.harnessService.applyHarness(project.repoRoot);
     });
+    app.post("/api/projects/harness/tasks/:taskSlug/commit-and-rebase", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        return deps.harnessService.commitAndRebaseTask(project.repoRoot, {
+            taskSlug: task.taskSlug,
+            branch: task.branch,
+            worktreePath: task.worktreePath,
+            changedFiles: request.body?.changedFiles ?? []
+        });
+    });
     app.get("/api/projects/harness/bootstrap", async () => {
         const project = await requireCurrentProject(deps.projectService);
         try {

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

@@ -1,4 +1,4 @@
-import { DISPATCHABLE_ROLES, ROLE_NAMES } from "../../shared/constants.js";
+import { DISPATCHABLE_ROLES } from "../../shared/constants.js";
 import { isOpenFileLimitError, VcmError } from "../errors.js";
 import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
 export function registerTaskRoutes(app, deps) {
@@ -66,6 +66,7 @@ function degradedTaskStatus(repoRoot, taskSlug, error) {
             createdAt: timestamp,
             updatedAt: timestamp,
             repoRoot,
+            worktreePath: `${repoRoot}/.claude/worktrees/${taskSlug}`,
             branch: "unknown",
             handoffDir,
             status: "stopped"
@@ -79,18 +80,13 @@ function degradedTaskStatus(repoRoot, taskSlug, error) {
 }
 function degradedArtifactSummary(handoffDir) {
     const roleCommandsDir = `${handoffDir}/role-commands`;
-    const logsDir = `${handoffDir}/logs`;
     const messagesDir = `${handoffDir}/messages`;
     return {
         paths: {
             handoffDir,
             roleCommandsDir,
-            logsDir,
             messagesDir,
             roleCommandPaths: Object.fromEntries(DISPATCHABLE_ROLES.map((role) => [role, `${roleCommandsDir}/${role}.md`])),
-            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/gateway/gateway-service.js

@@ -352,17 +352,6 @@ export function createGatewayService(deps) {
     }
     async function pullCurrent() {
         const project = await ensureProject();
-        const settings = await syncDesktopContext(await deps.settings.loadSettings());
-        if (settings.currentTaskSlug) {
-            const task = await deps.taskService.loadTask(project.repoRoot, settings.currentTaskSlug);
-            if (!task.worktreePath && task.cleanupStatus !== "cleaned") {
-                throw new VcmError({
-                    code: "GATEWAY_PULL_BLOCKED_BY_INLINE_TASK",
-                    message: `Inline task "${task.taskSlug}" uses the base repository.`,
-                    statusCode: 409
-                });
-            }
-        }
         const pulled = await deps.projectService.pullCurrentProject();
         return [
             "Connected repository updated.",
@@ -377,7 +366,7 @@ export function createGatewayService(deps) {
         if (tasks.length === 0) {
             return "No tasks. Use /create-task <task-slug> [title] to create one.";
         }
-        return tasks.map((task, index) => `${index + 1}. ${task.taskSlug} [${task.status}] ${task.worktreePath ? "worktree" : "inline"}`).join("\n");
+        return tasks.map((task, index) => `${index + 1}. ${task.taskSlug} [${task.status}] ${task.branch}`).join("\n");
     }
     async function useTask(selector) {
         const project = await ensureProject();
@@ -405,8 +394,7 @@ export function createGatewayService(deps) {
         const project = await ensureProject();
         const task = await deps.taskService.createTask(project.repoRoot, {
             taskSlug,
-            title,
-            createWorktree: true
+            title
         });
         const config = await deps.projectService.loadConfig(project.repoRoot);
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
@@ -460,7 +448,7 @@ export function createGatewayService(deps) {
         return [
             `Task created and initialized: ${task.taskSlug}`,
             `branch: ${task.branch}`,
-            `worktree: ${task.worktreePath ?? task.repoRoot}`,
+            `worktree: ${task.worktreePath}`,
             `orchestration: ${template.autoOrchestration ? "auto" : "manual"}`,
             `translation: ${preferences.translationEnabled ? "on" : "off"}`,
             `sessions: ${startedRoles.join(", ")}`
@@ -523,7 +511,6 @@ export function createGatewayService(deps) {
         deps.roundService.stopTask(taskSlug);
         const result = await deps.taskService.cleanupTask(project.repoRoot, taskSlug, {
             force: true,
-            deleteBranch: Boolean(task.worktreePath),
             forceDeleteBranch: true
         });
         clearFailedTranslation(project.repoRoot, taskSlug);

package/dist/backend/server.js

@@ -82,7 +82,8 @@ export async function createServer(deps, options = {}) {
     });
     registerHarnessRoutes(app, {
         projectService: deps.projectService,
-        harnessService: deps.harnessService
+        harnessService: deps.harnessService,
+        taskService: deps.taskService
     });
     registerTaskRoutes(app, {
         projectService: deps.projectService,
@@ -170,6 +171,7 @@ export function createDefaultServerDeps(options = {}) {
     const projectService = createProjectService({ fs, git, appSettings });
     const harnessService = createHarnessService({
         fs,
+        git,
         runtime,
         projectService,
         apiUrl: options.apiUrl,

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

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { DISPATCHABLE_ROLES, ROLE_NAMES } from "../../shared/constants.js";
+import { DISPATCHABLE_ROLES } from "../../shared/constants.js";
 import { checkMarkdownArtifact } from "../../shared/validation/artifact-check.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
@@ -25,25 +25,16 @@ export function createArtifactService(fs) {
     return {
         getHandoffPaths(_repoRoot, handoffDir) {
             const roleCommandsDir = path.posix.join(handoffDir, "role-commands");
-            const logsDir = path.posix.join(handoffDir, "logs");
             const messagesDir = path.posix.join(handoffDir, "messages");
             return {
                 handoffDir,
                 roleCommandsDir,
-                logsDir,
                 messagesDir,
                 roleCommandPaths: {
                     architect: path.posix.join(roleCommandsDir, "architect.md"),
                     coder: path.posix.join(roleCommandsDir, "coder.md"),
                     reviewer: path.posix.join(roleCommandsDir, "reviewer.md")
                 },
-                roleLogPaths: {
-                    "project-manager": path.posix.join(logsDir, "project-manager.log"),
-                    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")
-                },
                 messageRoutePaths: getDefaultMessageRoutePaths(messagesDir),
                 architecturePlanPath: path.posix.join(handoffDir, "architecture-plan.md"),
                 knownIssuesPath: path.posix.join(handoffDir, "known-issues.md"),
@@ -59,7 +50,6 @@ export function createArtifactService(fs) {
             const paths = this.getHandoffPaths(input.repoRoot, input.handoffDir);
             await fs.ensureDir(resolveRepoPath(input.repoRoot, paths.handoffDir));
             await fs.ensureDir(resolveRepoPath(input.repoRoot, paths.roleCommandsDir));
-            await fs.ensureDir(resolveRepoPath(input.repoRoot, paths.logsDir));
             await fs.ensureDir(resolveRepoPath(input.repoRoot, paths.messagesDir));
             return paths;
         },
@@ -168,25 +158,6 @@ export function createArtifactService(fs) {
         async saveRoleCommand(input) {
             const paths = this.getHandoffPaths(input.repoRoot, input.handoffDir);
             await fs.writeText(resolveRepoPath(input.repoRoot, paths.roleCommandPaths[input.role]), input.content);
-        },
-        async appendRoleLog(input) {
-            if (!ROLE_NAMES.includes(input.role)) {
-                throw new VcmError({
-                    code: "UNKNOWN_ROLE",
-                    message: `Unknown role: ${input.role}`,
-                    statusCode: 400
-                });
-            }
-            const paths = this.getHandoffPaths(input.repoRoot, input.handoffDir);
-            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-translation-service.js

@@ -812,7 +812,7 @@ export function createCodexTranslationService(deps) {
             await cleanupStartupFileIndex(repoRoot);
             await cleanupStartupBootstrapIndex(repoRoot);
         },
-        async getState(repoRoot) {
+        async getState(repoRoot, options = {}) {
             await ensureLayout(repoRoot);
             await cleanupCompletedRuntime(repoRoot);
             const [queue, fileIndex, bootstrapIndex, memoryInitialized] = await Promise.all([
@@ -822,7 +822,7 @@ export function createCodexTranslationService(deps) {
                 isMemoryInitialized(repoRoot, deps.fs)
             ]);
             const runtimeFileJobs = await loadRuntimeFileJobs(repoRoot, queue);
-            return {
+            const state = {
                 queue,
                 fileIndex: visibleFileTranslationIndex({
                     ...fileIndex,
@@ -831,6 +831,7 @@ export function createCodexTranslationService(deps) {
                 bootstrapIndex,
                 memoryInitialized
             };
+            return options.visibility === "public" ? toPublicTranslationState(state) : state;
         },
         async browseSourceFiles(repoRoot, input = {}) {
             const currentPath = normalizeBrowserPath(input.path ?? "");
@@ -1742,6 +1743,26 @@ function isPrunableCompletedQueueItem(item) {
         item.type === "bootstrap" ||
         item.type === "memory-update");
 }
+function toPublicTranslationState(state) {
+    const items = state.queue.items
+        .filter((item) => item.type !== "conversation")
+        .map(toPublicQueueItem);
+    const activeItemId = state.queue.activeItemId && items.some((item) => item.id === state.queue.activeItemId)
+        ? state.queue.activeItemId
+        : undefined;
+    return {
+        ...state,
+        queue: {
+            ...state.queue,
+            activeItemId,
+            items
+        }
+    };
+}
+function toPublicQueueItem(item) {
+    const { translatedText: _translatedText, ...publicItem } = item;
+    return publicItem;
+}
 function isTranslationRuntimeDirectory(relativePath) {
     const normalized = normalizeRepoRelative(relativePath);
     return normalized.startsWith(`${TRANSLATIONS_RUNTIME_DIR}/`);

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

@@ -246,6 +246,73 @@ export function createHarnessService(deps) {
                     : "VCM Harness updated. Review these files and commit the harness changes before starting long-running work."
             };
         },
+        async commitAndRebaseTask(repoRoot, input) {
+            if (!deps.git) {
+                throw new VcmError({
+                    code: "HARNESS_GIT_UNAVAILABLE",
+                    message: "Git-backed harness sync is not available in this VCM runtime.",
+                    statusCode: 501
+                });
+            }
+            const changedFiles = dedupeHarnessChanges(input.changedFiles);
+            const changedPaths = changedFiles.map((change) => change.path);
+            const taskBranch = await deps.git.getCurrentBranch(input.worktreePath);
+            if (taskBranch !== input.branch) {
+                throw new VcmError({
+                    code: "HARNESS_TASK_BRANCH_MISMATCH",
+                    message: "The selected task worktree is not on its recorded task branch.",
+                    statusCode: 409,
+                    hint: `Expected ${input.branch}, found ${taskBranch}.`
+                });
+            }
+            const taskStatus = await deps.git.getStatusPorcelain(input.worktreePath);
+            if (taskStatus.trim()) {
+                throw new VcmError({
+                    code: "HARNESS_TASK_DIRTY",
+                    message: "The selected task worktree has uncommitted changes.",
+                    statusCode: 409,
+                    hint: "Commit or clean the task worktree before rebasing it onto the harness commit."
+                });
+            }
+            const preExistingStaged = await deps.git.getStagedStatus(repoRoot);
+            if (preExistingStaged.trim()) {
+                throw new VcmError({
+                    code: "HARNESS_BASE_STAGED_CHANGES",
+                    message: "The connected repository already has staged changes.",
+                    statusCode: 409,
+                    hint: "Commit, unstage, or clean existing staged changes before using Commit & rebase task."
+                });
+            }
+            const baseBranch = await deps.git.getCurrentBranch(repoRoot);
+            const baseCommitBefore = await deps.git.getHeadCommit(repoRoot);
+            let harnessCommit;
+            let committed = false;
+            if (changedPaths.length > 0) {
+                await deps.git.addPaths(repoRoot, changedPaths);
+                const stagedHarnessChanges = await deps.git.getStagedStatus(repoRoot);
+                if (stagedHarnessChanges.trim()) {
+                    harnessCommit = await deps.git.commit(repoRoot, "chore: update VCM harness");
+                    committed = true;
+                }
+            }
+            const baseCommitAfter = await deps.git.getHeadCommit(repoRoot);
+            await deps.git.rebase(input.worktreePath, baseCommitAfter);
+            return {
+                taskSlug: input.taskSlug,
+                branch: input.branch,
+                worktreePath: input.worktreePath,
+                baseBranch,
+                baseCommitBefore,
+                baseCommitAfter,
+                harnessCommit,
+                committed,
+                rebased: true,
+                changedFiles,
+                message: committed
+                    ? `Committed VCM harness update ${shortCommit(baseCommitAfter)} on ${baseBranch} and rebased ${input.branch}.`
+                    : `No new harness commit was needed; rebased ${input.branch} onto ${shortCommit(baseCommitAfter)}.`
+            };
+        },
         async getBootstrapStatus(repoRoot) {
             return getHarnessBootstrapStatus(deps, repoRoot, now);
         },
@@ -320,6 +387,45 @@ export function createHarnessService(deps) {
         }
     };
 }
+function dedupeHarnessChanges(changedFiles) {
+    const seen = new Set();
+    const changes = [];
+    for (const change of changedFiles) {
+        const normalizedPath = normalizeHarnessGitPath(change.path);
+        if (seen.has(normalizedPath)) {
+            continue;
+        }
+        seen.add(normalizedPath);
+        changes.push({
+            ...change,
+            path: normalizedPath
+        });
+    }
+    return changes;
+}
+function normalizeHarnessGitPath(value) {
+    if (!value || value.includes("\0") || path.posix.isAbsolute(value)) {
+        throw new VcmError({
+            code: "HARNESS_CHANGED_PATH_INVALID",
+            message: "Harness changed file path is invalid.",
+            statusCode: 400,
+            hint: value
+        });
+    }
+    const normalized = path.posix.normalize(value).replace(/^\.\//, "");
+    if (normalized === "." || normalized.startsWith("../")) {
+        throw new VcmError({
+            code: "HARNESS_CHANGED_PATH_INVALID",
+            message: "Harness changed file path must stay inside the repository.",
+            statusCode: 400,
+            hint: value
+        });
+    }
+    return normalized;
+}
+function shortCommit(commit) {
+    return commit.slice(0, 7);
+}
 async function analyzeHarnessFiles(fs, repoRoot) {
     const analyses = [];
     for (const definition of HARNESS_FILES) {

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

@@ -30,7 +30,6 @@ export function createSessionService(deps) {
         const isCodexRole = isCodexRoleName(role);
         const isTranslator = role === CODEX_TRANSLATOR_ROLE;
         const sessionRepoRoot = isTranslator ? repoRoot : taskRepoRoot;
-        const sessionLogPath = isTranslator ? undefined : paths.roleLogPaths[role];
         const permissionMode = normalizeClaudePermissionMode(input.permissionMode ?? persisted?.permissionMode);
         const model = isCodexRole
             ? normalizeCodexModel(input.model ?? persisted?.model)
@@ -72,8 +71,7 @@ export function createSessionService(deps) {
                 VCM_SESSION_ID: claudeSessionId
             },
             cols: input.cols,
-            rows: input.rows,
-            ...(sessionLogPath ? { logPath: resolveRepoPath(sessionRepoRoot, sessionLogPath) } : {})
+            rows: input.rows
         });
         const timestamp = now();
         const record = {
@@ -91,7 +89,6 @@ export function createSessionService(deps) {
             cwd: startCommand.cwd,
             terminalBackend: "node-pty",
             pid: runtimeSession.pid,
-            ...(sessionLogPath ? { logPath: sessionLogPath } : {}),
             roleCommandPath: isDispatchableRole(role)
                 ? paths.roleCommandPaths[role]
                 : undefined,

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

@@ -1,4 +1,4 @@
-import { DISPATCHABLE_ROLES, ROLE_NAMES } from "../../shared/constants.js";
+import { DISPATCHABLE_ROLES } from "../../shared/constants.js";
 import { isOpenFileLimitError } from "../errors.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
 export function createStatusService(deps) {
@@ -45,18 +45,13 @@ export function createStatusService(deps) {
 }
 function degradedArtifactSummary(handoffDir) {
     const roleCommandsDir = `${handoffDir}/role-commands`;
-    const logsDir = `${handoffDir}/logs`;
     const messagesDir = `${handoffDir}/messages`;
     return {
         paths: {
             handoffDir,
             roleCommandsDir,
-            logsDir,
             messagesDir,
             roleCommandPaths: Object.fromEntries(DISPATCHABLE_ROLES.map((role) => [role, `${roleCommandsDir}/${role}.md`])),
-            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`,