vibe-coding-master 0.3.22 → 0.3.24

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

@@ -12,8 +12,9 @@ const CODEX_REVIEW_DIR = ".ai/vcm/codex-reviews";
 const CODEX_CONFIG_PATH = ".ai/codex/config.toml";
 const CODEX_TRANSLATOR_DIR = ".ai/codex-translator";
 const CODEX_TRANSLATION_DIR = ".ai/vcm/translations";
-const CODEX_TRANSLATOR_SESSION_PATH = ".ai/vcm/translations/runtime/session.json";
+const CODEX_TRANSLATOR_SESSION_PATH = ".ai/vcm/translations/session.json";
 const CODEX_TRANSLATOR_CONFIG_PATH = ".ai/codex-translator/config.toml";
+const PROJECT_TRANSLATOR_SCOPE = "__project__";
 export function createSessionService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     async function launchRoleSession(repoRoot, taskSlug, role, input, launchMode) {
@@ -29,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)
@@ -71,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 = {
@@ -90,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,
@@ -104,14 +102,167 @@ export function createSessionService(deps) {
         await persistRoleSessionRecord(deps.fs, repoRoot, taskRepoRoot, config.stateRoot, record);
         return record;
     }
+    async function launchProjectTranslatorSession(repoRoot, input, launchMode) {
+        const live = toRoleSessionRecordView(getRegisteredProjectTranslatorSession(deps.registry, deps.runtime), deps.runtime);
+        if (live && live.status === "running") {
+            return live;
+        }
+        const persisted = await loadPersistedCodexTranslatorSession(deps.fs, repoRoot);
+        const model = normalizeCodexModel(input.model ?? persisted?.model);
+        const effort = normalizeCodexEffort(input.effort ?? persisted?.effort);
+        const claudeSessionId = launchMode === "resume"
+            ? persisted?.claudeSessionId
+            : randomUUID();
+        if (!claudeSessionId) {
+            throw new VcmError({
+                code: "CODEX_TRANSLATOR_SESSION_MISSING",
+                message: "Codex Translator does not have a session id to resume.",
+                statusCode: 409,
+                hint: "Start the translator once before using Resume."
+            });
+        }
+        const startCommand = await buildCodexStartCommand(deps.fs, repoRoot, repoRoot, CODEX_TRANSLATOR_ROLE, launchMode, model, effort, deps.sandboxMode, launchMode === "resume" && hasCapturedCodexSession(persisted) ? claudeSessionId : undefined);
+        const runtimeSession = await deps.runtime.createSession({
+            taskSlug: PROJECT_TRANSLATOR_SCOPE,
+            role: CODEX_TRANSLATOR_ROLE,
+            command: startCommand.command,
+            args: startCommand.args,
+            cwd: startCommand.cwd,
+            env: {
+                VCM_API_URL: deps.apiUrl,
+                VCM_TASK_REPO_ROOT: repoRoot,
+                VCM_TASK_SLUG: PROJECT_TRANSLATOR_SCOPE,
+                VCM_ROLE: CODEX_TRANSLATOR_ROLE,
+                VCM_SESSION_ID: claudeSessionId
+            },
+            cols: input.cols,
+            rows: input.rows
+        });
+        const timestamp = now();
+        const record = {
+            id: runtimeSession.id,
+            claudeSessionId,
+            taskSlug: PROJECT_TRANSLATOR_SCOPE,
+            role: CODEX_TRANSLATOR_ROLE,
+            status: runtimeSession.status,
+            activityStatus: "idle",
+            command: startCommand.display,
+            permissionMode: "default",
+            model,
+            effort,
+            cwd: startCommand.cwd,
+            terminalBackend: "node-pty",
+            pid: runtimeSession.pid,
+            startedAt: runtimeSession.startedAt,
+            updatedAt: timestamp,
+            lastOutputAt: runtimeSession.lastOutputAt,
+            exitCode: runtimeSession.exitCode
+        };
+        deps.registry.upsert(record);
+        await persistCodexTranslatorSession(deps.fs, repoRoot, record);
+        return record;
+    }
     return {
+        startProjectTranslatorSession(repoRoot, input = {}) {
+            return launchProjectTranslatorSession(repoRoot, input, "fresh");
+        },
+        resumeProjectTranslatorSession(repoRoot, input = {}) {
+            return launchProjectTranslatorSession(repoRoot, input, "resume");
+        },
+        async stopProjectTranslatorSession(repoRoot) {
+            const existing = await this.getProjectTranslatorSession(repoRoot);
+            if (!existing) {
+                throw new VcmError({
+                    code: "SESSION_MISSING",
+                    message: "Codex Translator session has not been started.",
+                    statusCode: 404
+                });
+            }
+            if (deps.runtime.getSession(existing.id)) {
+                await deps.runtime.stop(existing.id);
+            }
+            const updated = {
+                ...existing,
+                status: "exited",
+                activityStatus: "idle",
+                updatedAt: now()
+            };
+            deps.registry.upsert(updated);
+            await persistCodexTranslatorSession(deps.fs, repoRoot, updated);
+            return updated;
+        },
+        async restartProjectTranslatorSession(repoRoot, input = {}) {
+            const existing = await this.getProjectTranslatorSession(repoRoot);
+            if (!existing) {
+                return launchProjectTranslatorSession(repoRoot, input, "fresh");
+            }
+            if (deps.runtime.getSession(existing.id)) {
+                await deps.runtime.stop(existing.id);
+            }
+            deps.registry.remove(existing.id);
+            return launchProjectTranslatorSession(repoRoot, input, "fresh");
+        },
+        async getProjectTranslatorSession(repoRoot) {
+            const record = getRegisteredProjectTranslatorSession(deps.registry, deps.runtime)
+                ?? await loadPersistedCodexTranslatorSession(deps.fs, repoRoot);
+            return toRoleSessionRecordView(record, deps.runtime);
+        },
+        async ensureProjectTranslatorSession(repoRoot, input = {}) {
+            const existing = await this.getProjectTranslatorSession(repoRoot);
+            if (existing?.status === "running") {
+                return existing;
+            }
+            if (existing?.claudeSessionId) {
+                return this.resumeProjectTranslatorSession(repoRoot, {
+                    model: input.model ?? existing.model,
+                    effort: input.effort ?? existing.effort,
+                    cols: input.cols,
+                    rows: input.rows
+                });
+            }
+            return this.startProjectTranslatorSession(repoRoot, input);
+        },
+        async recordProjectTranslatorHookEvent(repoRoot, input) {
+            const current = await this.getProjectTranslatorSession(repoRoot);
+            if (!current) {
+                return undefined;
+            }
+            const timestamp = now();
+            const isStop = input.eventName === "Stop";
+            const updated = {
+                ...current,
+                claudeSessionId: input.sessionId ?? current.claudeSessionId,
+                transcriptPath: input.transcriptPath ?? current.transcriptPath,
+                cwd: input.cwd ?? current.cwd,
+                activityStatus: isStop ? "idle" : "running",
+                lastHookEventAt: timestamp,
+                lastTurnEndedAt: isStop ? timestamp : current.lastTurnEndedAt,
+                lastTurnStartedAt: isStop ? current.lastTurnStartedAt : timestamp,
+                updatedAt: timestamp
+            };
+            deps.registry.upsert(updated);
+            await persistCodexTranslatorSession(deps.fs, repoRoot, updated);
+            return updated;
+        },
         startRoleSession(repoRoot, taskSlug, role, input = {}) {
+            if (role === CODEX_TRANSLATOR_ROLE) {
+                void taskSlug;
+                return this.startProjectTranslatorSession(repoRoot, input);
+            }
             return launchRoleSession(repoRoot, taskSlug, role, input, "fresh");
         },
         resumeRoleSession(repoRoot, taskSlug, role, input = {}) {
+            if (role === CODEX_TRANSLATOR_ROLE) {
+                void taskSlug;
+                return this.resumeProjectTranslatorSession(repoRoot, input);
+            }
             return launchRoleSession(repoRoot, taskSlug, role, input, "resume");
         },
         async stopRoleSession(repoRoot, taskSlug, role) {
+            if (role === CODEX_TRANSLATOR_ROLE) {
+                void taskSlug;
+                return this.stopProjectTranslatorSession(repoRoot);
+            }
             const existing = await this.getRoleSession(repoRoot, taskSlug, role);
             if (!existing) {
                 throw new VcmError({
@@ -136,6 +287,10 @@ export function createSessionService(deps) {
             return updated;
         },
         async restartRoleSession(repoRoot, taskSlug, role, input = {}) {
+            if (role === CODEX_TRANSLATOR_ROLE) {
+                void taskSlug;
+                return this.restartProjectTranslatorSession(repoRoot, input);
+            }
             const existing = await this.getRoleSession(repoRoot, taskSlug, role);
             if (!existing) {
                 return launchRoleSession(repoRoot, taskSlug, role, input, "fresh");
@@ -147,6 +302,10 @@ export function createSessionService(deps) {
             return launchRoleSession(repoRoot, taskSlug, role, input, "fresh");
         },
         async getRoleSession(repoRoot, taskSlug, role) {
+            if (role === CODEX_TRANSLATOR_ROLE) {
+                void taskSlug;
+                return this.getProjectTranslatorSession(repoRoot);
+            }
             const config = await deps.projectService.loadConfig(repoRoot);
             const task = await deps.taskService.loadTask(repoRoot, taskSlug);
             const taskRepoRoot = getTaskRuntimeRepoRoot(task);
@@ -163,12 +322,9 @@ export function createSessionService(deps) {
             const task = await deps.taskService.loadTask(repoRoot, taskSlug);
             const taskRepoRoot = getTaskRuntimeRepoRoot(task);
             const persistedTaskSession = await loadPersistedTaskSessionRecord(deps.fs, taskRepoRoot, config.stateRoot, taskSlug);
-            for (const role of ROLE_NAMES) {
-                const record = role === CODEX_TRANSLATOR_ROLE
-                    ? getRegisteredRoleSession(deps.registry, deps.runtime, taskSlug, role)
-                        ?? await loadPersistedCodexTranslatorSession(deps.fs, repoRoot, taskSlug)
-                    : deps.registry.getByRole(taskSlug, role)
-                        ?? normalizePersistedRoleRecord(persistedTaskSession?.roles[role]?.record);
+            for (const role of ROLE_NAMES.filter((candidate) => candidate !== CODEX_TRANSLATOR_ROLE)) {
+                const record = deps.registry.getByRole(taskSlug, role)
+                    ?? normalizePersistedRoleRecord(persistedTaskSession?.roles[role]?.record);
                 const session = toRoleSessionRecordView(record, deps.runtime);
                 if (session) {
                     sessions.push(session);
@@ -177,6 +333,15 @@ export function createSessionService(deps) {
             return sessions;
         },
         async recordRoleHookEvent(repoRoot, input) {
+            if (input.role === CODEX_TRANSLATOR_ROLE) {
+                void input.taskSlug;
+                return this.recordProjectTranslatorHookEvent(repoRoot, {
+                    eventName: input.eventName,
+                    sessionId: input.sessionId,
+                    transcriptPath: input.transcriptPath,
+                    cwd: input.cwd
+                });
+            }
             const current = await this.getRoleSession(repoRoot, input.taskSlug, input.role);
             if (!current || (!input.allowSessionMismatch && !matchesRoleHookSession(current, input))) {
                 return undefined;
@@ -385,6 +550,11 @@ function getRegisteredRoleSession(registry, runtime, taskSlug, role) {
         ?? candidates.sort(compareSessionUpdatedAtDesc)[0];
     return scopeProjectRoleSession(scoped, taskSlug);
 }
+function getRegisteredProjectTranslatorSession(registry, runtime) {
+    const candidates = registry.list().filter((session) => session.role === CODEX_TRANSLATOR_ROLE);
+    const live = candidates.find((session) => runtime.getSession(session.id)?.status === "running");
+    return live ?? candidates.sort(compareSessionUpdatedAtDesc)[0];
+}
 function compareSessionUpdatedAtDesc(left, right) {
     return (right.updatedAt ?? "").localeCompare(left.updatedAt ?? "");
 }
@@ -399,11 +569,12 @@ function scopeProjectRoleSession(record, taskSlug) {
 }
 async function loadPersistedRoleRecordForRole(fs, baseRepoRoot, taskRepoRoot, stateRoot, taskSlug, role) {
     if (role === CODEX_TRANSLATOR_ROLE) {
-        return loadPersistedCodexTranslatorSession(fs, baseRepoRoot, taskSlug);
+        void taskSlug;
+        return loadPersistedCodexTranslatorSession(fs, baseRepoRoot);
     }
     return loadPersistedRoleRecord(fs, taskRepoRoot, stateRoot, taskSlug, role);
 }
-async function loadPersistedCodexTranslatorSession(fs, repoRoot, taskSlug) {
+async function loadPersistedCodexTranslatorSession(fs, repoRoot) {
     const sessionPath = resolveRepoPath(repoRoot, CODEX_TRANSLATOR_SESSION_PATH);
     if (!(await fs.pathExists(sessionPath))) {
         return undefined;
@@ -413,7 +584,10 @@ async function loadPersistedCodexTranslatorSession(fs, repoRoot, taskSlug) {
     if (!record) {
         return undefined;
     }
-    return scopeProjectRoleSession(record, taskSlug);
+    return {
+        ...record,
+        taskSlug: PROJECT_TRANSLATOR_SCOPE
+    };
 }
 async function loadPersistedRoleRecord(fs, repoRoot, stateRoot, taskSlug, role) {
     const current = await loadPersistedTaskSessionRecord(fs, repoRoot, stateRoot, taskSlug);
@@ -486,7 +660,7 @@ async function persistCodexTranslatorSession(fs, repoRoot, session) {
         updatedAt: session.updatedAt,
         record: {
             ...session,
-            taskSlug: session.taskSlug
+            taskSlug: PROJECT_TRANSLATOR_SCOPE
         }
     });
 }

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`,

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

@@ -9,13 +9,8 @@ export function createTaskService(deps) {
             const config = await deps.projectService.loadConfig(repoRoot);
             const taskStoreRoot = deps.projectService.getProjectDataRoot(repoRoot);
             const taskPath = getTaskPath(taskStoreRoot, input.taskSlug);
-            const shouldCreateWorktree = input.createWorktree !== false;
-            const taskBranch = shouldCreateWorktree
-                ? `feature/${input.taskSlug}`
-                : await deps.git.getCurrentBranch(repoRoot);
-            const worktreePath = shouldCreateWorktree
-                ? getTaskWorktreePath(repoRoot, input.taskSlug)
-                : undefined;
+            const taskBranch = `feature/${input.taskSlug}`;
+            const worktreePath = getTaskWorktreePath(repoRoot, input.taskSlug);
             if (await deps.fs.pathExists(taskPath)) {
                 throw new VcmError({
                     code: "TASK_EXISTS",
@@ -31,7 +26,7 @@ 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"))) {
+            if (!(await deps.git.isIgnored(repoRoot, ".claude/worktrees/.probe"))) {
                 throw new VcmError({
                     code: "VCM_WORKTREES_NOT_IGNORED",
                     message: ".claude/worktrees/ is not ignored by Git.",
@@ -39,53 +34,39 @@ export function createTaskService(deps) {
                     hint: "Apply VCM Harness first so .gitignore ignores Claude-compatible task worktrees."
                 });
             }
-            if (!shouldCreateWorktree) {
-                const activeInlineTask = await findActiveInlineTask(deps.fs, taskStoreRoot);
-                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 (await deps.git.branchExists(repoRoot, taskBranch)) {
+                throw new VcmError({
+                    code: "TASK_BRANCH_EXISTS",
+                    message: `Task branch already exists: ${taskBranch}`,
+                    statusCode: 409,
+                    hint: "Choose a different task name or clean up the existing branch."
+                });
+            }
+            if (await deps.fs.pathExists(worktreePath)) {
+                throw new VcmError({
+                    code: "TASK_WORKTREE_EXISTS",
+                    message: `Task worktree already exists: ${worktreePath}`,
+                    statusCode: 409,
+                    hint: "Choose a different task name or clean up the existing worktree."
+                });
             }
-            if (shouldCreateWorktree && worktreePath) {
-                if (await deps.git.branchExists(repoRoot, taskBranch)) {
-                    throw new VcmError({
-                        code: "TASK_BRANCH_EXISTS",
-                        message: `Task branch already exists: ${taskBranch}`,
-                        statusCode: 409,
-                        hint: "Choose a different task name or clean up the existing branch."
-                    });
-                }
-                if (await deps.fs.pathExists(worktreePath)) {
-                    throw new VcmError({
-                        code: "TASK_WORKTREE_EXISTS",
-                        message: `Task worktree already exists: ${worktreePath}`,
-                        statusCode: 409,
-                        hint: "Choose a different task name or clean up the existing worktree."
-                    });
-                }
-                const baseStatus = await deps.git.getStatusPorcelain(repoRoot);
-                if (baseStatus.trim()) {
-                    throw new VcmError({
-                        code: "BASE_REPO_DIRTY",
-                        message: "The connected repository has uncommitted changes.",
-                        statusCode: 409,
-                        hint: "Commit, stash, or discard base repository changes before creating a task worktree."
-                    });
-                }
-                await deps.fs.ensureDir(path.dirname(worktreePath));
-                await deps.git.createWorktree({
-                    repoRoot,
-                    branch: taskBranch,
-                    worktreePath,
-                    baseRef: "HEAD"
+            const baseStatus = await deps.git.getStatusPorcelain(repoRoot);
+            if (baseStatus.trim()) {
+                throw new VcmError({
+                    code: "BASE_REPO_DIRTY",
+                    message: "The connected repository has uncommitted changes.",
+                    statusCode: 409,
+                    hint: "Commit, stash, or discard base repository changes before creating a task worktree."
                 });
             }
             const timestamp = now();
-            const taskRepoRoot = worktreePath ?? repoRoot;
+            await deps.fs.ensureDir(path.dirname(worktreePath));
+            await deps.git.createWorktree({
+                repoRoot,
+                branch: taskBranch,
+                worktreePath,
+                baseRef: "HEAD"
+            });
             const task = {
                 version: 1,
                 taskSlug: input.taskSlug,
@@ -100,14 +81,14 @@ export function createTaskService(deps) {
                 specPath: input.specPath,
                 cleanupStatus: "active"
             };
-            await ensureTaskRuntimeStateDirs(deps.fs, taskRepoRoot, config.stateRoot);
+            await ensureTaskRuntimeStateDirs(deps.fs, worktreePath, config.stateRoot);
             await deps.artifactService.ensureHandoffStructure({
-                repoRoot: taskRepoRoot,
+                repoRoot: worktreePath,
                 taskSlug: input.taskSlug,
                 handoffDir: task.handoffDir
             });
             await deps.artifactService.createArtifactTemplates({
-                repoRoot: taskRepoRoot,
+                repoRoot: worktreePath,
                 taskSlug: input.taskSlug,
                 handoffDir: task.handoffDir,
                 branch: task.branch
@@ -123,7 +104,7 @@ export function createTaskService(deps) {
             const entries = await deps.fs.readDir(tasksDir);
             const tasks = [];
             for (const entry of entries.filter((candidate) => candidate.endsWith(".json"))) {
-                tasks.push(normalizeTaskRecord(await deps.fs.readJson(path.join(tasksDir, entry))));
+                tasks.push(await deps.fs.readJson(path.join(tasksDir, entry)));
             }
             return tasks.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
         },
@@ -137,7 +118,7 @@ export function createTaskService(deps) {
                     statusCode: 404
                 });
             }
-            return normalizeTaskRecord(await deps.fs.readJson(taskPath));
+            return deps.fs.readJson(taskPath);
         },
         async saveTask(repoRoot, task) {
             await deps.fs.writeJsonAtomic(getTaskPath(deps.projectService.getProjectDataRoot(repoRoot), task.taskSlug), task);
@@ -167,15 +148,9 @@ export function createTaskService(deps) {
             const statePaths = getTaskStatePaths(deps.projectService.getProjectDataRoot(repoRoot), taskRepoRoot, config.stateRoot, config.handoffRoot, taskSlug);
             const removedStatePaths = [];
             const cleanedAt = now();
-            if (task.worktreePath) {
-                assertTaskWorktreePath(repoRoot, task.worktreePath);
-                await deps.git.removeWorktree(repoRoot, task.worktreePath, { force: options.force ?? true });
-            }
-            let deletedBranch;
-            if (task.worktreePath && (options.deleteBranch ?? true)) {
-                await deps.git.deleteBranch(repoRoot, task.branch, { force: options.forceDeleteBranch ?? true });
-                deletedBranch = task.branch;
-            }
+            assertTaskWorktreePath(repoRoot, task.worktreePath);
+            await deps.git.removeWorktree(repoRoot, task.worktreePath, { force: options.force ?? true });
+            await deps.git.deleteBranch(repoRoot, task.branch, { force: options.forceDeleteBranch ?? true });
             for (const statePath of statePaths) {
                 await deps.fs.removePath(statePath, { recursive: true, force: true });
                 removedStatePaths.push(statePath);
@@ -184,14 +159,14 @@ export function createTaskService(deps) {
                 taskSlug,
                 removedWorktreePath: task.worktreePath,
                 removedStatePaths,
-                deletedBranch,
+                deletedBranch: task.branch,
                 cleanedAt
             };
         }
     };
 }
 export function getTaskRuntimeRepoRoot(task) {
-    return task.worktreePath ?? task.repoRoot;
+    return task.worktreePath;
 }
 function getTaskPath(taskStoreRoot, taskSlug) {
     return path.join(taskStoreRoot, "tasks", `${taskSlug}.json`);
@@ -206,49 +181,6 @@ async function ensureTaskRuntimeStateDirs(fs, taskRepoRoot, stateRoot) {
     await fs.ensureDir(path.join(taskRepoRoot, stateRoot, "translation"));
     await fs.ensureDir(path.join(taskRepoRoot, stateRoot, "codex-reviews"));
 }
-async function findActiveInlineTask(fs, taskStoreRoot) {
-    const tasksDir = path.join(taskStoreRoot, "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 = normalizeTaskRecord(await fs.readJson(path.join(tasksDir, entry)));
-        if (!task.worktreePath && task.cleanupStatus !== "cleaned") {
-            return task;
-        }
-    }
-    return undefined;
-}
-function normalizeTaskRecord(input) {
-    return {
-        version: 1,
-        taskSlug: input.taskSlug ?? "",
-        title: input.title,
-        createdAt: input.createdAt ?? "",
-        updatedAt: input.updatedAt ?? input.createdAt ?? "",
-        repoRoot: input.repoRoot ?? "",
-        worktreePath: input.worktreePath,
-        branch: input.branch ?? "",
-        handoffDir: input.handoffDir ?? ".ai/vcm/handoffs",
-        status: normalizeTaskStatus(input.status),
-        specPath: input.specPath,
-        cleanupStatus: input.cleanupStatus,
-        cleanedAt: input.cleanedAt
-    };
-}
-function normalizeTaskStatus(value) {
-    if (value === "created" || value === "running" || value === "stopped") {
-        return value;
-    }
-    if (value === undefined || value === null) {
-        return "created";
-    }
-    if (value === "planning") {
-        return "created";
-    }
-    return "stopped";
-}
 function getTaskStatePaths(taskStoreRoot, taskRepoRoot, stateRoot, handoffRoot, taskSlug) {
     return [
         getTaskPath(taskStoreRoot, taskSlug),