vibe-coding-master 0.3.21 → 0.3.23

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

@@ -12,13 +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 LEGACY_CODEX_TRANSLATOR_SESSION_PATH = ".ai/vcm/translations/session.json";
-const CODEX_TRANSLATOR_LOG_PATHS = [
-    ".ai/vcm/translations/runtime/codex-translator.log",
-    ".ai/vcm/translations/codex-translator.log"
-];
+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) {
@@ -42,9 +38,6 @@ export function createSessionService(deps) {
         const effort = isCodexRole
             ? normalizeCodexEffort(input.effort ?? persisted?.effort)
             : normalizeClaudeEffort(input.effort ?? persisted?.effort);
-        if (isTranslator) {
-            await cleanupCodexTranslatorLogs(deps.fs, repoRoot);
-        }
         const claudeSessionId = launchMode === "resume"
             ? persisted?.claudeSessionId
             : randomUUID();
@@ -112,14 +105,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({
@@ -144,6 +290,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");
@@ -155,6 +305,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);
@@ -171,12 +325,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);
@@ -185,6 +336,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;
@@ -393,6 +553,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 ?? "");
 }
@@ -407,38 +572,25 @@ 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) {
-    let sessionPath = resolveRepoPath(repoRoot, CODEX_TRANSLATOR_SESSION_PATH);
+async function loadPersistedCodexTranslatorSession(fs, repoRoot) {
+    const sessionPath = resolveRepoPath(repoRoot, CODEX_TRANSLATOR_SESSION_PATH);
     if (!(await fs.pathExists(sessionPath))) {
-        const legacySessionPath = resolveRepoPath(repoRoot, LEGACY_CODEX_TRANSLATOR_SESSION_PATH);
-        if (!(await fs.pathExists(legacySessionPath))) {
-            return undefined;
-        }
-        sessionPath = legacySessionPath;
+        return undefined;
     }
     const payload = await fs.readJson(sessionPath);
     const record = normalizePersistedRoleRecord(isProjectRoleSessionFile(payload) ? payload.record : payload);
     if (!record) {
         return undefined;
     }
-    if (sessionPath.endsWith(LEGACY_CODEX_TRANSLATOR_SESSION_PATH)) {
-        await persistCodexTranslatorSession(fs, repoRoot, {
-            ...record,
-            taskSlug
-        });
-        await fs.removePath?.(sessionPath, { force: true });
-    }
-    return scopeProjectRoleSession(record, taskSlug);
-}
-async function cleanupCodexTranslatorLogs(fs, repoRoot) {
-    if (!fs.removePath) {
-        return;
-    }
-    await Promise.all(CODEX_TRANSLATOR_LOG_PATHS.map((relativePath) => fs.removePath?.(resolveRepoPath(repoRoot, relativePath), { force: true })));
+    return {
+        ...record,
+        taskSlug: PROJECT_TRANSLATOR_SCOPE
+    };
 }
 async function loadPersistedRoleRecord(fs, repoRoot, stateRoot, taskSlug, role) {
     const current = await loadPersistedTaskSessionRecord(fs, repoRoot, stateRoot, taskSlug);
@@ -511,7 +663,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

@@ -54,7 +54,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/services/translation-service.js

@@ -157,6 +157,8 @@ export function createTranslationService(deps) {
     }
     function startTranscriptTail(roleSession) {
         const state = getState(roleSession.id);
+        state.taskSlug = roleSession.taskSlug;
+        state.role = roleSession.role;
         if (state.unsubscribeTranscript) {
             return;
         }
@@ -183,7 +185,7 @@ export function createTranslationService(deps) {
         const config = await loadConfig();
         let displayed = false;
         if (event.kind === "text") {
-            const shouldTranslate = config.outputMode === "all" || event.stopReason === "end_turn";
+            const shouldTranslate = shouldTranslateTextTranscriptEvent(state, event, config);
             displayed = shouldTranslate
                 ? processClaudeOutputText(sessionId, event.text, config, event.id, {
                     flushImmediately: event.stopReason === "end_turn"
@@ -206,6 +208,18 @@ export function createTranslationService(deps) {
             state.seenTranscriptIds.add(event.id);
         }
     }
+    function shouldTranslateTextTranscriptEvent(state, event, config) {
+        if (config.outputMode === "all") {
+            return true;
+        }
+        if (event.stopReason !== "end_turn") {
+            return false;
+        }
+        if (config.outputMode === "pm-final-only") {
+            return state.role === "project-manager";
+        }
+        return true;
+    }
     function processClaudeOutputText(sessionId, rawText, config, entryId, options = {}) {
         return startClaudeOutputTranslation(sessionId, rawText, config, {
             entryId,
@@ -890,8 +904,6 @@ export function createTranslationService(deps) {
             });
         }
         return deps.codexTranslationService.createConversationJob(input.repoRoot, {
-            taskSlug: input.taskSlug,
-            role: input.role,
             direction: input.direction,
             sourceText: input.text,
             sourceLanguage: input.sourceLanguage,
@@ -921,7 +933,6 @@ export function createTranslationService(deps) {
             }
             try {
                 return await deps.codexTranslationService.validateConversationResult(repoRoot, {
-                    taskSlug: job.taskSlug,
                     resultPath: job.resultPath,
                     sourceHash: job.sourceHash,
                     targetLanguage: job.targetLanguage

package/dist/backend/templates/handoff.js

@@ -15,9 +15,9 @@ Task-specific context and coder guidance go here, not in source-code comments.
 Source-code comments should only describe durable behavior, contracts, invariants,
 error boundaries, or non-obvious logic that should remain useful after this task.
 
-| File | Action | Task Context | Durable Code Comment Needed | Coder Work | Allowed Freedom | VCM:CODE | Proof Point | Replan Trigger |
-| --- | --- | --- | --- | --- | --- | --- | --- | --- |
-| TBD | TBD | TBD | TBD | TBD | TBD | TBD | TBD | TBD |
+| ID | File | Action | Task Context | Durable Code Comment Needed | Coder Work | Allowed Freedom | VCM:CODE | Proof Point | Replan Trigger |
+| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
+| SCF-001 | TBD | TBD | TBD | TBD | TBD | TBD | TBD | TBD | TBD |
 
 ## Implementation Plan
 

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

@@ -27,7 +27,8 @@ export function renderArchitectHarnessRules() {
 
 - Define the expected implementation scope: affected modules, changed or created files, each file's responsibility, why it is in scope, and user-visible behavior changes.
 - Define every non-private callable surface intended for use outside its file: visibility, signature shape, responsibility, expected callers, behavior contract, side effects, and error boundaries.
-- Include a \`Scaffold Manifest\` for task-specific file context: file action, why the file is in scope, coder work, allowed implementation freedom, expected \`VCM:CODE\` placeholders, durable code comment needs, proof points, and Replan triggers.
+- Include a \`Scaffold Manifest\` for task-specific file context: stable row ID, file action, why the file is in scope, coder work, allowed implementation freedom, expected \`VCM:CODE\` placeholders, durable code comment needs, proof points, and Replan triggers.
+- Give each Scaffold Manifest row a stable ID such as \`SCF-001\`; use that ID in any related \`VCM:CODE\` marker so coder can report completion by ID.
 - Put task context, phase notes, handoff instructions, temporary rationale, and coder guidance in the \`Scaffold Manifest\`, not in source-code comments.
 - Cover architecture docs impact, known risks, and Replan triggers.
 - For docs impact, state whether changes belong in \`docs/ARCHITECTURE.md\`, affected \`<module>/ARCHITECTURE.md\`, \`.ai/generated/public-surface.json\`, or no durable architecture doc.
@@ -41,7 +42,7 @@ export function renderArchitectHarnessRules() {
 - Define every new or changed non-private callable surface directly in code with its signature shape and contract comment.
 - When changing an existing non-private callable surface, update its signature and contract comment in code before coder work starts; leave \`VCM:CODE\` only where implementation must change.
 - Non-private callable surface includes any function, method, type, trait, enum, constant, re-export, or similar symbol that another file can call or depend on.
-- Mark incomplete implementation bodies with \`VCM:CODE\`; coder must implement them and remove the markers before handoff.
+- Mark incomplete implementation bodies with \`VCM:CODE <Scaffold Manifest ID>\`; coder must implement them and remove the markers before handoff.
 - Architect scaffolding may include modules, files, signatures, type shapes, durable comments, and placeholder bodies, but not real business implementation beyond minimal scaffold code.
 - Coder may add private implementation helpers, but must not add or change cross-file callable surface without architect replan.
 

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

@@ -10,7 +10,7 @@ export function renderCoderHarnessRules() {
 ### Coder Implementation Discipline
 
 - Implement the architect-defined scaffold exactly; do not change file responsibilities, callable-surface signatures, or architect-defined contract intent unless the architecture plan explicitly allows it.
-- Implement every \`VCM:CODE\` placeholder and remove all \`VCM:CODE\` markers before handoff.
+- Implement every \`VCM:CODE\` placeholder, track completion by Scaffold Manifest ID when present, and remove all \`VCM:CODE\` markers before handoff.
 - Do not fake completion: no hardcoded success, disabled logic, swallowed errors, test-only shortcuts, or silent fallback that hides failure.
 - Keep the diff inside approved scope: no unrelated rewrites, drive-by refactors, renamed symbols, moved files, or formatting churn.
 - Preserve existing behavior unless the architecture plan explicitly changes it; keep existing call sites and shared code paths working.
@@ -40,6 +40,11 @@ export function renderCoderHarnessRules() {
 - Do not weaken, delete, or skip tests to make validation pass.
 - Record confirmed out-of-scope issues found during implementation in \`.ai/vcm/handoffs/known-issues.md\`.
 
+### Handoff
+
+- In the route message back to project-manager, include a \`Scaffold Completion\` section when the architecture plan contains a Scaffold Manifest.
+- The \`Scaffold Completion\` section must report completed Scaffold Manifest IDs or \`VCM:CODE\` IDs, remaining markers if any, private helpers added, manifest deviations, and whether Replan is needed.
+
 ### Generated Context
 
 - Regenerate \`.ai/generated/module-index.json\` with \`.ai/tools/generate-module-index\` after module, manifest, source-file, or test-file changes.

package/dist/shared/types/app-settings.js

@@ -12,8 +12,9 @@ export const TRANSLATION_TARGET_LANGUAGE_OPTIONS = [
     { value: "es", label: "Spanish" }
 ];
 export const TRANSLATION_OUTPUT_MODE_OPTIONS = [
-    { value: "final-only", label: "Final summary" },
-    { value: "all", label: "All output" }
+    { value: "pm-final-only", label: "PM final reply" },
+    { value: "final-only", label: "Each role final reply" },
+    { value: "all", label: "All replies" }
 ];
 export function createDefaultLaunchTemplate() {
     const roles = {};