vibe64 0.1.21 → 0.1.22

package/packages/vibe64-terminals/src/server/codexTerminal.js

@@ -43,6 +43,8 @@ import {
   codexTerminalNamespace,
   directoryExists,
   dockerCommand,
+  fixCodexTerminalNamespace,
+  globalCodexTerminalNamespace,
   stableHash,
   terminalTargetRoot,
   terminalWorktreePath
@@ -68,6 +70,11 @@ import {
 import {
   targetToolchainTerminalArgs
 } from "./targetToolchainTerminal.js";
+import {
+  defaultFixCodexJobStore,
+  fixCodexReportInstructions,
+  prepareFixCodexReportHelper
+} from "./fixCodexJobs.js";
 
 const CODEX_THREAD_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu;
 const CODEX_THREAD_ID_TOKEN_PATTERN = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/giu;
@@ -99,6 +106,7 @@ const CODEX_BOOTSTRAP_TASK_ID = "codex_bootstrap";
 const START_CODEX_TERMINAL_CONTROL_ACTION = "start_codex_terminal";
 const MAX_OPEN_CODEX_TERMINALS = 3;
 const STUDIO_DAEMON_ID = crypto.randomUUID();
+const GLOBAL_CODEX_TERMINAL_SCOPE = "global";
 const CODEX_TURN_STATE = Object.freeze({
   IDLE: "idle",
   TRANSMITTING: "transmitting"
@@ -112,6 +120,13 @@ function errorMessage(value, fallback = "Codex could not be prepared.") {
   return normalizeText(value?.error || value?.message || value) || fallback;
 }
 
+function retryableTerminalFailure(result = {}) {
+  return {
+    ...result,
+    retryable: false
+  };
+}
+
 function delay(ms) {
   return new Promise((resolve) => {
     setTimeout(resolve, ms);
@@ -149,9 +164,37 @@ async function terminalTargetRootForSession(projectService, sessionId) {
   try {
     const runtime = await projectService.createRuntime();
     const session = await runtime.getSession(sessionId);
-    return terminalTargetRoot(session, projectService);
+    return terminalTargetRoot(session, projectService) ||
+      await globalCodexTargetRoot(projectService, runtime);
+  } catch {
+    return globalCodexTargetRoot(projectService);
+  }
+}
+
+async function globalCodexTargetRoot(projectService = {}, runtime = null) {
+  const serviceRoot = terminalTargetRoot({}, projectService);
+  if (serviceRoot) {
+    return serviceRoot;
+  }
+
+  const runtimeRoot = terminalTargetRoot({
+    targetRoot: runtime?.targetRoot
+  });
+  if (runtimeRoot) {
+    return runtimeRoot;
+  }
+
+  if (typeof projectService.readProjectType !== "function") {
+    return "";
+  }
+
+  try {
+    const projectType = await projectService.readProjectType();
+    return terminalTargetRoot({
+      targetRoot: projectType?.projectType?.targetRoot || projectType?.targetRoot
+    });
   } catch {
-    return terminalTargetRoot({}, projectService);
+    return "";
   }
 }
 
@@ -235,6 +278,34 @@ function codexTerminalSnapshot(sessionId = "", terminalSessionId = "") {
   });
 }
 
+function globalCodexTerminalSnapshot(terminalSessionId = "") {
+  return readTerminalSession(terminalSessionId, {
+    namespace: globalCodexTerminalNamespace()
+  });
+}
+
+function codexTerminalStatus(terminal = null) {
+  if (!terminal) {
+    return null;
+  }
+  return {
+    activityLabel: terminal.metadata?.codexTurnLabel || "",
+    activityStartedAt: terminal.metadata?.codexTurnStartedAt || "",
+    activityFinishedAt: terminal.metadata?.codexTurnFinishedAt || "",
+    activityReason: terminal.metadata?.codexTurnReason || "",
+    commandPreview: terminal.commandPreview || "",
+    id: terminal.id || "",
+    inputVersion: terminal.inputVersion || 0,
+    lastInputAt: terminal.lastInputAt || "",
+    lastInputBytes: terminal.lastInputBytes || 0,
+    lastOutputAt: terminal.lastOutputAt || "",
+    lastOutputBytes: terminal.lastOutputBytes || 0,
+    outputVersion: terminal.outputVersion || 0,
+    status: terminal.status || "",
+    transmitting: terminal.metadata?.codexTurnState === CODEX_TURN_STATE.TRANSMITTING
+  };
+}
+
 function activeCodexTerminal(session = {}) {
   const sessionId = normalizeText(session.sessionId);
   if (!sessionId) {
@@ -248,17 +319,17 @@ function activeCodexTerminal(session = {}) {
     .filter((terminal) => !workdir || terminal.metadata?.workdir === workdir)
     .sort((left, right) => String(right.createdAt || "").localeCompare(String(left.createdAt || "")));
   const terminal = terminals[0] || null;
-  if (!terminal) {
-    return null;
-  }
-  return {
-    activityLabel: terminal.metadata?.codexTurnLabel || "",
-    activityReason: terminal.metadata?.codexTurnReason || "",
-    commandPreview: terminal.commandPreview || "",
-    id: terminal.id || "",
-    status: terminal.status || "",
-    transmitting: terminal.metadata?.codexTurnState === CODEX_TURN_STATE.TRANSMITTING
-  };
+  return codexTerminalStatus(terminal);
+}
+
+function activeGlobalCodexTerminal(targetRoot = "") {
+  const terminals = listTerminalSessions({
+    namespace: globalCodexTerminalNamespace()
+  })
+    .filter((terminal) => terminal.status !== "exited")
+    .filter((terminal) => !targetRoot || terminal.metadata?.targetRoot === targetRoot)
+    .sort((left, right) => String(right.createdAt || "").localeCompare(String(left.createdAt || "")));
+  return codexTerminalStatus(terminals[0] || null);
 }
 
 function writeCodexTerminalInput(sessionId = "", terminalSessionId = "", data = "") {
@@ -286,7 +357,7 @@ function codexTurnLabel(reason = "") {
     case "codex-prompt-injection-started":
       return "Sending prompt to Codex...";
     default:
-      return "Terminal is transmitting...";
+      return "Codex is thinking...";
   }
 }
 
@@ -429,8 +500,13 @@ function codexTerminalArgs({
   });
 }
 
-function codexContainerName({ sessionId, terminalId }) {
-  return `${STUDIO_CODEX_CONTAINER_PREFIX}-${stableHash(sessionId)}-${stableHash(terminalId)}`;
+function codexContainerName({
+  scope = "",
+  sessionId = "",
+  terminalId = ""
+} = {}) {
+  const containerScope = normalizeText(scope || sessionId || GLOBAL_CODEX_TERMINAL_SCOPE);
+  return `${STUDIO_CODEX_CONTAINER_PREFIX}-${stableHash(containerScope)}-${stableHash(terminalId)}`;
 }
 
 function maskedCodexTerminalDockerArgs(args = []) {
@@ -438,6 +514,7 @@ function maskedCodexTerminalDockerArgs(args = []) {
 }
 
 function createCodexTerminalController({
+  fixJobStore = defaultFixCodexJobStore,
   projectService,
   publishPromptInjected = async () => null,
   publishSessionChanged = async () => null
@@ -449,25 +526,25 @@ function createCodexTerminalController({
     const session = await runtime.getSession(sessionId);
     const targetRoot = terminalTargetRoot(session, projectService);
     if (!targetRoot) {
-      return {
+      return retryableTerminalFailure({
         ok: false,
         error: "Vibe64 Codex target root is not available."
-      };
+      });
     }
     const workdir = terminalWorktreePath(session);
     if (!workdir || !containerWorkspacePath(targetRoot, workdir)) {
-      return {
+      return retryableTerminalFailure({
         ok: false,
         error: workdir
           ? "Vibe64 Codex workdir is outside the target root."
           : "Create the session worktree before starting Codex."
-      };
+      });
     }
     if (!await directoryExists(workdir)) {
-      return {
+      return retryableTerminalFailure({
         ok: false,
         error: `Session worktree directory does not exist: ${workdir}`
-      };
+      });
     }
     const imageResult = await resolveTerminalToolchainImage({
       runtime,
@@ -556,6 +633,102 @@ function createCodexTerminalController({
     return withCodexState(terminalResponse, session);
   }
 
+  async function startGlobalCodexTerminalSession() {
+    const runtime = await projectService.createRuntime();
+    const targetRoot = await globalCodexTargetRoot(projectService, runtime);
+    if (!targetRoot) {
+      return retryableTerminalFailure({
+        ok: false,
+        error: "Global Codex target root is not available."
+      });
+    }
+    if (!await directoryExists(targetRoot)) {
+      return retryableTerminalFailure({
+        ok: false,
+        error: `Main repo directory does not exist: ${targetRoot}`
+      });
+    }
+
+    const session = {
+      targetRoot
+    };
+    const imageResult = await resolveTerminalToolchainImage({
+      runtime,
+      session,
+      target: "codex",
+      targetRoot
+    });
+    if (imageResult.ok === false) {
+      return imageResult;
+    }
+
+    await prepareCodexAttachmentRoot();
+    await ensureTargetRuntimeNetwork(targetRoot);
+    await ensureAdapterRuntimeContainers({
+      runtime,
+      session,
+      target: "codex",
+      targetRoot
+    });
+    const terminalEnv = await projectTerminalEnvironment({
+      projectService,
+      runtime,
+      session,
+      target: "codex",
+      targetRoot
+    });
+    const terminalEnvHash = terminalEnvironmentFingerprint(terminalEnv);
+    const namespace = globalCodexTerminalNamespace();
+    const terminalResponse = startTerminalSession({
+      args: ({ id }) => codexTerminalArgs({
+        codexThreadId: "",
+        containerName: codexContainerName({
+          scope: GLOBAL_CODEX_TERMINAL_SCOPE,
+          terminalId: id
+        }),
+        env: terminalEnv,
+        image: imageResult.image,
+        sessionId: "",
+        targetRoot,
+        terminalId: id,
+        worktree: targetRoot
+      }),
+      command: "docker",
+      commandPreview: ({ args }) => dockerCommand(maskedCodexTerminalDockerArgs(args)),
+      cwd: targetRoot,
+      maxRunning: MAX_OPEN_CODEX_TERMINALS,
+      metadata: {
+        envHash: terminalEnvHash,
+        image: imageResult.image,
+        imageLabel: imageResult.label,
+        scope: GLOBAL_CODEX_TERMINAL_SCOPE,
+        targetRoot,
+        workdir: targetRoot
+      },
+      namespace,
+      onClose: async ({ id }) => {
+        await removeDockerContainer(codexContainerName({
+          scope: GLOBAL_CODEX_TERMINAL_SCOPE,
+          terminalId: id
+        }));
+        await cleanupCodexAttachments(targetRoot, GLOBAL_CODEX_TERMINAL_SCOPE);
+      },
+      reuseRunning: (terminalSession) => {
+        return terminalSession.metadata?.scope === GLOBAL_CODEX_TERMINAL_SCOPE &&
+          terminalSession.metadata?.targetRoot === targetRoot &&
+          terminalSession.metadata?.envHash === terminalEnvHash &&
+          terminalSession.metadata?.image === imageResult.image &&
+          terminalSession.metadata?.workdir === targetRoot;
+      }
+    });
+    const codexTerminal = activeGlobalCodexTerminal(targetRoot);
+    return {
+      ...terminalResponse,
+      codexTerminal,
+      globalCodexTerminal: codexTerminal
+    };
+  }
+
   async function waitForCodexReady(sessionId, terminalSessionId) {
     const startedAt = Date.now();
     let lastOutput = "";
@@ -656,6 +829,16 @@ function createCodexTerminalController({
     );
   }
 
+  async function writePromptIntoGlobalCodexTerminal(terminalSessionId, prompt) {
+    return writeTerminalSession(
+      terminalSessionId,
+      `${PROMPT_INJECTION_PREFIX}${prompt}${PROMPT_INJECTION_SUFFIX}`,
+      {
+        namespace: globalCodexTerminalNamespace()
+      }
+    );
+  }
+
   async function markCodexTerminalTransmitting(sessionId, terminalSessionId, signature, reason) {
     const result = updateCodexTerminalMetadata(
       sessionId,
@@ -683,10 +866,290 @@ function createCodexTerminalController({
     return result;
   }
 
+  async function waitForGlobalCodexReady(terminalSessionId) {
+    const startedAt = Date.now();
+    let lastOutput = "";
+    let lastChangedAt = Date.now();
+    while (Date.now() - startedAt <= CODEX_BOOT_TIMEOUT_MS) {
+      const snapshot = globalCodexTerminalSnapshot(terminalSessionId);
+      if (snapshot.ok === false || snapshot.status === "exited") {
+        return {
+          ok: false,
+          error: snapshot.error || "Global Codex terminal is not running."
+        };
+      }
+      const output = String(snapshot.output || "");
+      if (codexTrustPromptLooksActive(output)) {
+        return {
+          ok: false,
+          error: "Answer the Codex trust prompt before sending this project tool prompt."
+        };
+      }
+      if (output !== lastOutput) {
+        lastOutput = output;
+        lastChangedAt = Date.now();
+      }
+      if (
+        output &&
+        Date.now() - startedAt >= CODEX_BOOT_MIN_AGE_MS &&
+        Date.now() - lastChangedAt >= CODEX_BOOT_QUIET_MS
+      ) {
+        return {
+          ok: true,
+          output
+        };
+      }
+      await delay(250);
+    }
+    return {
+      ok: true,
+      output: lastOutput
+    };
+  }
+
+  async function injectPromptIntoGlobalCodex(handoff = {}) {
+    const terminalInput = codexPromptHandoffTerminalInput(handoff);
+    if (!terminalInput) {
+      return {
+        ok: false,
+        error: "Codex prompt handoff is empty."
+      };
+    }
+
+    const terminalResponse = await startGlobalCodexTerminalSession();
+    if (terminalResponse.ok === false) {
+      return terminalResponse;
+    }
+    const terminalSessionId = terminalResponse.id || terminalResponse.terminalSessionId || "";
+    if (!terminalSessionId) {
+      return {
+        ok: false,
+        error: "Global Codex terminal did not start."
+      };
+    }
+
+    const ready = await waitForGlobalCodexReady(terminalSessionId);
+    if (ready.ok === false) {
+      return ready;
+    }
+
+    const snapshot = globalCodexTerminalSnapshot(terminalSessionId);
+    const outputStart = String(snapshot.output || "").length;
+    const injected = await writePromptIntoGlobalCodexTerminal(
+      terminalSessionId,
+      terminalInput
+    );
+    if (injected.ok === false) {
+      return injected;
+    }
+
+    const targetRoot = await globalCodexTargetRoot(projectService);
+    const codexTerminal = activeGlobalCodexTerminal(targetRoot);
+    return {
+      ...injected,
+      codexPromptInjected: true,
+      codexPromptHandoffOutputStart: outputStart,
+      codexTerminal,
+      globalCodexTerminal: codexTerminal,
+      terminalSessionId
+    };
+  }
+
+  async function waitForCodexReadyInNamespace(namespace = "", terminalSessionId = "") {
+    const startedAt = Date.now();
+    let lastOutput = "";
+    let lastChangedAt = Date.now();
+    while (Date.now() - startedAt <= CODEX_BOOT_TIMEOUT_MS) {
+      const snapshot = readTerminalSession(terminalSessionId, {
+        namespace
+      });
+      if (snapshot.ok === false || snapshot.status === "exited") {
+        return {
+          ok: false,
+          error: snapshot.error || "Fix Codex terminal is not running."
+        };
+      }
+      const output = String(snapshot.output || "");
+      if (codexTrustPromptLooksActive(output)) {
+        return {
+          ok: false,
+          error: "Answer the Codex trust prompt before sending this fix prompt."
+        };
+      }
+      if (output !== lastOutput) {
+        lastOutput = output;
+        lastChangedAt = Date.now();
+      }
+      if (
+        output &&
+        Date.now() - startedAt >= CODEX_BOOT_MIN_AGE_MS &&
+        Date.now() - lastChangedAt >= CODEX_BOOT_QUIET_MS
+      ) {
+        return {
+          ok: true,
+          output
+        };
+      }
+      await delay(250);
+    }
+    return {
+      ok: true,
+      output: lastOutput
+    };
+  }
+
+  async function startFixCodexJob(input = {}) {
+    const runtime = await projectService.createRuntime();
+    const targetRoot = terminalTargetRoot({
+      targetRoot: input.targetRoot || projectService.targetRoot || runtime?.targetRoot
+    });
+    if (!targetRoot) {
+      return retryableTerminalFailure({
+        ok: false,
+        error: "Fix Codex target root is not available."
+      });
+    }
+    if (!await directoryExists(targetRoot)) {
+      return retryableTerminalFailure({
+        ok: false,
+        error: `Main repo directory does not exist: ${targetRoot}`
+      });
+    }
+    const workdir = path.resolve(normalizeText(input.workdir) || targetRoot);
+    if (!containerWorkspacePath(targetRoot, workdir)) {
+      return retryableTerminalFailure({
+        ok: false,
+        error: "Fix Codex workdir is outside the target root."
+      });
+    }
+    if (!await directoryExists(workdir)) {
+      return retryableTerminalFailure({
+        ok: false,
+        error: `Fix Codex workdir does not exist: ${workdir}`
+      });
+    }
+    const jobSeed = fixJobStore.createJob({
+      prompt: input.prompt,
+      scope: input.scope || "project",
+      subject: input.subject,
+      targetRoot
+    });
+    const fullPrompt = [
+      input.prompt,
+      "",
+      fixCodexReportInstructions(jobSeed)
+    ].join("\n").trim();
+    const jobId = jobSeed.job.id;
+    const namespace = fixCodexTerminalNamespace(jobId);
+    const session = {
+      metadata: {
+        worktree_path: workdir
+      },
+      targetRoot
+    };
+    const imageResult = await resolveTerminalToolchainImage({
+      runtime,
+      session,
+      target: "fix-codex",
+      targetRoot
+    });
+    if (imageResult.ok === false) {
+      return imageResult;
+    }
+
+    await prepareCodexAttachmentRoot();
+    const reportHelper = await prepareFixCodexReportHelper({
+      fixJobStore,
+      jobId,
+      targetRoot,
+      token: jobSeed.token
+    });
+    await ensureTargetRuntimeNetwork(targetRoot);
+    await ensureAdapterRuntimeContainers({
+      runtime,
+      session,
+      target: "fix-codex",
+      targetRoot
+    });
+    const terminalEnv = await projectTerminalEnvironment({
+      projectService,
+      runtime,
+      session,
+      target: "fix-codex",
+      targetRoot
+    });
+    const terminalEnvHash = terminalEnvironmentFingerprint(terminalEnv);
+    const terminalResponse = startTerminalSession({
+      args: ({ id }) => codexTerminalArgs({
+        codexThreadId: "",
+        containerName: codexContainerName({
+          scope: `fix:${jobId}`,
+          terminalId: id
+        }),
+        env: {
+          ...terminalEnv,
+          ...reportHelper.env
+        },
+        helperMount: reportHelper.mount,
+        image: imageResult.image,
+        sessionId: "",
+        targetRoot,
+        terminalId: id,
+        worktree: workdir
+      }),
+      command: "docker",
+      commandPreview: ({ args }) => dockerCommand(maskedCodexTerminalDockerArgs(args)),
+      cwd: targetRoot,
+      maxRunning: 1,
+      metadata: {
+        envHash: terminalEnvHash,
+        fixJobId: jobId,
+        image: imageResult.image,
+        imageLabel: imageResult.label,
+        scope: "fix-codex",
+        targetRoot,
+        workdir
+      },
+      namespace,
+      onClose: async ({ id }) => {
+        await removeDockerContainer(codexContainerName({
+          scope: `fix:${jobId}`,
+          terminalId: id
+        }));
+        await cleanupCodexAttachments(targetRoot, `fix:${jobId}`);
+      },
+      reuseRunning: false
+    });
+    if (terminalResponse.ok === false) {
+      return terminalResponse;
+    }
+
+    const job = fixJobStore.attachTerminal(jobId, terminalResponse.id);
+    void (async () => {
+      const ready = await waitForCodexReadyInNamespace(namespace, terminalResponse.id);
+      if (ready.ok === false) {
+        return;
+      }
+      await writeTerminalSession(
+        terminalResponse.id,
+        `${PROMPT_INJECTION_PREFIX}${wrapPromptWithStudioContext(fullPrompt)}${PROMPT_INJECTION_SUFFIX}`,
+        {
+          namespace
+        }
+      );
+    })();
+
+    return {
+      ...terminalResponse,
+      fixJob: job
+    };
+  }
+
   async function writeCodexBootstrapTaskEvent(runtime, sessionId, {
     error = "",
     kind = "",
     message = "",
+    retryable = true,
     status = "running",
     terminalSessionId = ""
   } = {}) {
@@ -702,7 +1165,7 @@ function createCodexTerminalController({
         kind: "codex_bootstrap",
         label: "Codex bootstrap",
         message: normalizeText(message),
-        retry: status === "failed"
+        retry: status === "failed" && retryable !== false
           ? {
               control: {
                 action: START_CODEX_TERMINAL_CONTROL_ACTION
@@ -749,6 +1212,7 @@ function createCodexTerminalController({
       error: errorMessage(result),
       kind: "failed",
       message: "Codex bootstrap failed.",
+      retryable: result?.retryable !== false,
       status: "failed",
       terminalSessionId
     });
@@ -1016,6 +1480,18 @@ function createCodexTerminalController({
   }
 
   return Object.freeze({
+    closeGlobalTerminal(terminalSessionId) {
+      return closeTerminalSession(terminalSessionId, {
+        namespace: globalCodexTerminalNamespace()
+      });
+    },
+
+    closeFixTerminal(jobId, terminalSessionId) {
+      return closeTerminalSession(terminalSessionId, {
+        namespace: fixCodexTerminalNamespace(jobId)
+      });
+    },
+
     async closeAllForSession(sessionId) {
       await closeTerminalSessionsForNamespace(codexTerminalNamespace(sessionId));
       const targetRoot = await terminalTargetRootForSession(projectService, sessionId);
@@ -1030,6 +1506,29 @@ function createCodexTerminalController({
       });
     },
 
+    readGlobalTerminal(terminalSessionId) {
+      return vibe64Result(async () => {
+        const targetRoot = await globalCodexTargetRoot(projectService);
+        const snapshot = readTerminalSession(terminalSessionId, {
+          namespace: globalCodexTerminalNamespace()
+        });
+        const codexTerminal = activeGlobalCodexTerminal(targetRoot);
+        return {
+          ...snapshot,
+          codexTerminal,
+          globalCodexTerminal: codexTerminal
+        };
+      });
+    },
+
+    readFixTerminal(jobId, terminalSessionId) {
+      return vibe64Result(async () => {
+        return readTerminalSession(terminalSessionId, {
+          namespace: fixCodexTerminalNamespace(jobId)
+        });
+      });
+    },
+
     readTerminal(sessionId, terminalSessionId) {
       return vibe64Result(async () => {
         const runtime = await projectService.createRuntime();
@@ -1046,6 +1545,27 @@ function createCodexTerminalController({
       });
     },
 
+    async injectGlobalCodexPrompt(handoff = {}) {
+      return vibe64Result(async () => {
+        return injectPromptIntoGlobalCodex(handoff);
+      });
+    },
+
+    async startFixJob(input = {}) {
+      return vibe64Result(async () => {
+        return startFixCodexJob(input);
+      });
+    },
+
+    async reportFixJob(jobId, input = {}) {
+      return vibe64Result(async () => {
+        return {
+          fixJob: fixJobStore.reportJob(jobId, input),
+          ok: true
+        };
+      });
+    },
+
     async ensureThread(sessionId) {
       return vibe64Result(async () => {
         return ensureCodexThreadReady(sessionId);
@@ -1070,6 +1590,47 @@ function createCodexTerminalController({
       });
     },
 
+    async startGlobalTerminal() {
+      return vibe64Result(async () => {
+        return startGlobalCodexTerminalSession();
+      });
+    },
+
+    async globalTerminalState() {
+      return vibe64Result(async () => {
+        const targetRoot = await globalCodexTargetRoot(projectService);
+        const codexTerminal = activeGlobalCodexTerminal(targetRoot);
+        return {
+          codexTerminal,
+          globalCodexTerminal: codexTerminal,
+          ok: true
+        };
+      });
+    },
+
+    subscribeGlobalTerminal(terminalSessionId, subscriber) {
+      return vibe64Result(async () => {
+        const targetRoot = await globalCodexTargetRoot(projectService);
+        const subscribed = subscribeTerminalSession(terminalSessionId, subscriber, {
+          namespace: globalCodexTerminalNamespace()
+        });
+        const codexTerminal = activeGlobalCodexTerminal(targetRoot);
+        return {
+          ...subscribed,
+          codexTerminal,
+          globalCodexTerminal: codexTerminal
+        };
+      });
+    },
+
+    subscribeFixTerminal(jobId, terminalSessionId, subscriber) {
+      return vibe64Result(async () => {
+        return subscribeTerminalSession(terminalSessionId, subscriber, {
+          namespace: fixCodexTerminalNamespace(jobId)
+        });
+      });
+    },
+
     subscribeTerminal(sessionId, terminalSessionId, subscriber) {
       return vibe64Result(async () => {
         const runtime = await projectService.createRuntime();
@@ -1105,10 +1666,34 @@ function createCodexTerminalController({
       });
     },
 
+    writeGlobalTerminal(terminalSessionId, data) {
+      return writeTerminalSession(terminalSessionId, data, {
+        namespace: globalCodexTerminalNamespace()
+      });
+    },
+
+    writeFixTerminal(jobId, terminalSessionId, data) {
+      return writeTerminalSession(terminalSessionId, data, {
+        namespace: fixCodexTerminalNamespace(jobId)
+      });
+    },
+
     resizeTerminal(sessionId, terminalSessionId, size) {
       return resizeTerminalSession(terminalSessionId, size, {
         namespace: codexTerminalNamespace(sessionId)
       });
+    },
+
+    resizeGlobalTerminal(terminalSessionId, size) {
+      return resizeTerminalSession(terminalSessionId, size, {
+        namespace: globalCodexTerminalNamespace()
+      });
+    },
+
+    resizeFixTerminal(jobId, terminalSessionId, size) {
+      return resizeTerminalSession(terminalSessionId, size, {
+        namespace: fixCodexTerminalNamespace(jobId)
+      });
     }
   });
 }