vibe64 0.1.26 → 0.1.28

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

@@ -6900,19 +6900,21 @@ function createCodexTerminalController({
     const normalizedThreadId = normalizeText(threadId);
     const notificationTurnId = codexAppServerNotificationTurnId(notification);
     const goalStatus = normalizeText(notification.params?.goal?.status);
+    const goalCleared = notification.method === "thread/goal/cleared";
     const runtime = await createRuntimeForSession();
     let run = await readCodexAppServerAgentRunForSession(
       runtime.store,
       normalizedSessionId
     );
     const currentThreadId = normalizeText(run?.providerThreadId);
+    if (currentThreadId && currentThreadId !== normalizedThreadId) {
+      return { ok: true, processed: false, reason: "goal_thread_changed" };
+    }
     if (
-      run &&
-      CODEX_APP_SERVER_GOAL_STATUSES.has(goalStatus) &&
-      (!currentThreadId || currentThreadId === normalizedThreadId) &&
+      (goalCleared || CODEX_APP_SERVER_GOAL_STATUSES.has(goalStatus)) &&
       (
-        normalizeText(run.providerGoalStatus) !== goalStatus ||
-        normalizeText(run.providerGoalThreadId) !== normalizedThreadId
+        normalizeText(run?.providerGoalStatus) !== goalStatus ||
+        normalizeText(run?.providerGoalThreadId) !== normalizedThreadId
       )
     ) {
       const updatedAt = new Date().toISOString();
@@ -6924,6 +6926,12 @@ function createCodexTerminalController({
           providerThreadId: normalizedThreadId
         },
         patch: {
+          ...(!run ? {
+            provider: CODEX_AGENT_PROVIDER,
+            providerInterface: "codex_app_server",
+            providerThreadId: normalizedThreadId,
+            state: VIBE64_AGENT_RUN_STATE.COMPLETED
+          } : {}),
           providerGoalStatus: goalStatus,
           providerGoalThreadId: normalizedThreadId,
           providerGoalUpdatedAt: updatedAt
@@ -6950,7 +6958,7 @@ function createCodexTerminalController({
       };
     }
     if (
-      CODEX_APP_SERVER_GOAL_STATUSES.has(goalStatus) &&
+      (goalCleared || CODEX_APP_SERVER_GOAL_STATUSES.has(goalStatus)) &&
       goalStatus !== "active" &&
       turn.state === "finalizing" &&
       turn.threadId === normalizedThreadId &&
@@ -7044,8 +7052,16 @@ function createCodexTerminalController({
           );
         });
       }
+      if (method === "thread/goal/cleared") {
+        runCodexAppServerNotificationTask(notificationContext, async () => {
+          await reconcileCodexAppServerGoalUpdated(normalizedSessionId, provider, normalizedThreadId, notification);
+          await publishSessionChanged(normalizedSessionId, { reason: "codex-goal" });
+        });
+        return;
+      }
       if (method === "thread/goal/updated") {
-        runCodexAppServerNotificationTask(notificationContext, () => {
+        runCodexAppServerNotificationTask(notificationContext, async () => {
+          await publishSessionChanged(normalizedSessionId, { reason: "codex-goal" });
           return reconcileCodexAppServerGoalUpdated(
             normalizedSessionId,
             provider,
@@ -8990,10 +9006,10 @@ function createCodexTerminalController({
     );
     error.code = "vibe64_codex_economy_ownership_blocked";
     error.statusCode = 409;
-    error.retryable = true;
+    error.retryable = details.retryable !== false;
     error.details = {
       ...details,
-      retryable: true
+      retryable: error.retryable
     };
     return error;
   }
@@ -9066,33 +9082,31 @@ function createCodexTerminalController({
       await pendingMutation.catch(() => null);
     }
     const existing = codexAppServerEconomyThreads.get(key);
-    if (existing) {
-      if (
-        existing.ownershipId !== record.ownershipId ||
-        existing.revision < record.revision
-      ) {
-        throw codexAppServerEconomyOwnershipError(
-          "Persisted Codex economy ownership changed while the controller was running.",
-          {
-            sessionId: record.sessionId,
-            threadId: record.threadId
-          }
-        );
-      }
-      if (
-        session.status !== VIBE64_SESSION_STATUS.ARCHIVED &&
-        !sessionIsClosing(session)
-      ) {
+    if (existing && (
+      existing.ownershipId !== record.ownershipId ||
+      existing.revision < record.revision
+    )) {
+      throw codexAppServerEconomyOwnershipError(
+        "Persisted Codex economy ownership changed while the controller was running.",
+        { sessionId: record.sessionId, threadId: record.threadId }
+      );
+    }
+    const cleanupRequired = record.lifecycle === CODEX_ECONOMY_THREAD_LIFECYCLES.CLEANUP_REQUIRED;
+    if (existing && !cleanupRequired) {
+      if (session.status !== VIBE64_SESSION_STATUS.ARCHIVED && !sessionIsClosing(session)) {
         return { record: existing, retiredThreadId: "" };
       }
       await retireCodexAppServerEconomyThread(existing);
       return { record: null, retiredThreadId: existing.threadId };
     }
     if (!await directoryExists(record.identity.runtime.runtimeDir)) {
-      await ledger.remove(record);
+      if (existing) {
+        await retireCodexAppServerEconomyThread(existing);
+      } else {
+        await ledger.remove(record);
+      }
       return { record: null, retiredThreadId: record.threadId };
     }
-    const executionRoot = terminalSessionSourceRoot(session);
     const toolHome = await codexToolHomeResult();
     if (toolHome.ok === false) {
       throw codexAppServerEconomyOwnershipError(toolHome.error, {
@@ -9102,57 +9116,55 @@ function createCodexTerminalController({
     }
     const providerOptions = await codexAppServerEconomyRuntimeOptionsForSession(session, {
       runtime,
-      executionRoot,
+      executionRoot: terminalSessionSourceRoot(session),
       toolHomeSource: toolHome.toolHomeSource,
       workdir: record.workdir
     });
     const providerKey = codexAppServerProviderKey(record.sessionId, providerOptions);
-    if (codexAppServerProviderKeyFingerprint(providerKey) !== record.identity.providerKeyFingerprint) {
+    const contextChanged = !existing &&
+      codexAppServerProviderKeyFingerprint(providerKey) !== record.identity.providerKeyFingerprint;
+    if (cleanupRequired || contextChanged) {
       const staleProvider = codexAppServerProviderFactory({
         ...providerOptions,
         runtimeDir: record.identity.runtime.runtimeDir
       });
       try {
-        if (typeof staleProvider.currentRuntimeInfo !== "function") {
-          throw codexAppServerEconomyOwnershipError(
-            "The Codex provider cannot verify the account for stale economy ownership.",
-            {
-              sessionId: record.sessionId,
-              threadId: record.threadId
-            }
-          );
-        }
         const currentRuntime = await staleProvider.currentRuntimeInfo();
-        if (
-          record.identity.runtime.accountIdentitySignature !==
-          normalizeText(currentRuntime.accountIdentitySignature)
-        ) {
+        const accountChanged = record.identity.runtime.accountIdentitySignature !==
+          normalizeText(currentRuntime.accountIdentitySignature);
+        if (accountChanged && !cleanupRequired) {
           throw codexAppServerEconomyOwnershipError(
-            "The current Codex account does not match persisted economy ownership.",
-            {
-              sessionId: record.sessionId,
-              threadId: record.threadId
-            }
+            "Reconnect the original Codex account to resume or delete this helper thread.",
+            { retryable: false, sessionId: record.sessionId, threadId: record.threadId }
           );
         }
-        const stopped = typeof staleProvider.stopRuntime === "function"
-          ? await staleProvider.stopRuntime()
-          : null;
-        if (!codexAppServerRuntimeStopWasVerified(stopped)) {
-          throw codexAppServerEconomyOwnershipError(
-            "The earlier Codex economy runtime could not be retired after its provider context changed.",
-            {
-              sessionId: record.sessionId,
-              threadId: record.threadId
-            }
-          );
+        if (accountChanged || contextChanged) {
+          // Only the local runtime owner can retire another account's ephemeral
+          // work. Never issue a thread deletion authenticated as the new account.
+          const stopped = await staleProvider.stopRuntime(accountChanged ? {
+            expectedAccountIdentitySignature: record.identity.runtime.accountIdentitySignature
+          } : {});
+          const retired = accountChanged
+            ? stopped?.ownershipSuperseded === true || stopped?.processExitVerified === true
+            : codexAppServerRuntimeStopWasVerified(stopped);
+          if (!retired) {
+            throw codexAppServerEconomyOwnershipError(
+              "The earlier Codex runtime could not be verified as retired; its cleanup record has been preserved.",
+              { sessionId: record.sessionId, threadId: record.threadId }
+            );
+          }
+          await ledger.remove(record);
+          codexAppServerEconomyThreads.delete(key);
+          return { record: null, retiredThreadId: record.threadId };
         }
-        await ledger.remove(record);
-        return { record: null, retiredThreadId: record.threadId };
       } finally {
         staleProvider.close?.();
       }
     }
+    if (existing) {
+      await retireCodexAppServerEconomyThread(existing);
+      return { record: null, retiredThreadId: existing.threadId };
+    }
     let provider = codexAppServerProviders.get(providerKey);
     if (!provider) {
       assertCodexAppServerControllerOpen();
@@ -9182,6 +9194,7 @@ function createCodexTerminalController({
       throw codexAppServerEconomyOwnershipError(
         "The current Codex runtime/auth identity does not match persisted economy ownership.",
         {
+          retryable: record.identity.runtime.accountIdentitySignature === normalizeText(expectedRuntime.accountIdentitySignature),
           sessionId: record.sessionId,
           threadId: record.threadId
         }
@@ -9281,6 +9294,7 @@ function createCodexTerminalController({
         return !normalizedSessionId || record.sessionId === normalizedSessionId;
       });
       const retiredThreadIds = [];
+      const retiredBySession = new Map();
       for (const record of records) {
         try {
           const currentSession = normalizeText(session?.sessionId || session?.id) === record.sessionId
@@ -9293,11 +9307,47 @@ function createCodexTerminalController({
           });
           if (normalizeText(restored?.retiredThreadId)) {
             retiredThreadIds.push(normalizeText(restored.retiredThreadId));
+            const retired = retiredBySession.get(record.sessionId) || [];
+            retired.push(normalizeText(restored.retiredThreadId));
+            retiredBySession.set(record.sessionId, retired);
           }
         } catch (error) {
           failed.push(codexAppServerEconomyFailure(record, error));
         }
       }
+      const sessionIds = new Set(records.map((record) => record.sessionId));
+      if (normalizedSessionId) {
+        sessionIds.add(normalizedSessionId);
+      }
+      for (const id of sessionIds) {
+        const failures = failed.filter((failure) => !failure.sessionId || failure.sessionId === id);
+        const retired = retiredBySession.get(id) || [];
+        if (!failures.length && !retired.length) {
+          continue;
+        }
+        const status = failures.length ? "failed" : "ready";
+        const message = failures.length
+          ? `${failures.length} helper cleanup record(s) still need attention: ${failures[0].error}`
+          : `Cleaned up ${retired.length} stale helper ownership record(s).`;
+        await effectiveRuntime.store.writeBackgroundTaskEvent(id, "codex-economy-cleanup", {
+          event: {
+            kind: "cleanup-reconciled",
+            message,
+            status,
+            failed: failures,
+            retiredThreadIds: retired
+          },
+          patch: {
+            label: "Low-cost assistant cleanup",
+            message,
+            error: failures[0]?.error || "",
+            code: failures[0]?.code || "",
+            details: { failed: failures },
+            status,
+            retryable: failures.some((failure) => failure.retryable !== false)
+          }
+        });
+      }
       return {
         failed,
         ok: failed.length === 0,
@@ -9324,6 +9374,7 @@ function createCodexTerminalController({
       "Vibe64 could not reconcile persisted low-cost assistant thread ownership.",
       {
         failed: result.failed,
+        retryable: result.failed?.some((failure) => failure.retryable !== false) !== false,
         projectRuntimeRoot: normalizeText(result.projectRuntimeRoot)
       }
     );
@@ -9750,7 +9801,8 @@ function createCodexTerminalController({
         ? {}
         : await currentConversationActorMetadata(input.vibe64User || null),
       economyRestore,
-      provider
+      provider,
+      providerOptions: activeProvider?.providerOptions || providerOptions
     };
   }
 
@@ -12590,7 +12642,8 @@ function createCodexTerminalController({
     currentSession = await runtime.getSession(sessionId);
     turn = codexAppServerTurnState(currentSession);
     const turnId = normalizeText(turn.turnId);
-    if (!turn.active) {
+    const goalAwaitingTurn = !turn.active && turn.goalStatus === "active" && turn.goalThreadId === threadId;
+    if (!turn.active && !goalAwaitingTurn) {
       vibe64SessionDebugLog("server.codexTerminal.appServerMessage.newTurn", {
         messageId,
         reason: "provider_idle",
@@ -12604,7 +12657,7 @@ function createCodexTerminalController({
         turnId
       });
     }
-    if (!turnId || turn.state === "finalizing") {
+    if (goalAwaitingTurn || !turnId || turn.state === "finalizing") {
       return withCodexState({
         code: CODEX_AGENT_TURN_STEER_FAILED_CODE,
         delivered: false,
@@ -13099,6 +13152,69 @@ function createCodexTerminalController({
       });
     },
 
+    async readGoal(sessionId, options = {}) {
+      const context = await codexAppServerSessionContext(sessionId, options);
+      if (context.ok === false) {
+        return { status: "unavailable", goal: null };
+      }
+      const threadId = codexAppServerTurnState(context.session).threadId ||
+        codexThreadIdForWorkdir(context.session, context.workdir);
+      if (!threadId) {
+        return { status: "available", goal: null };
+      }
+      const sessionKey = codexTerminalNamespace(sessionId);
+      for (const [key, provider] of codexAppServerProviders) {
+        if (codexAppServerProviderSessionKeys.get(key) === sessionKey &&
+            !provider.isEconomyProvider() && provider.isAvailable()) {
+          const result = await provider.readGoal(threadId);
+          return { status: "available", goal: result.goal || null };
+        }
+      }
+      return { status: "unavailable", goal: null };
+    },
+
+    async updateGoal(sessionId, input = {}, options = {}) {
+      if (!["pause", "resume"].includes(input.action)) {
+        return { ok: false, error: "Choose pause or resume." };
+      }
+      const admission = beginTerminalNamespaceOperation(codexTerminalNamespace(sessionId));
+      if (admission.ok === false) return admission;
+      try {
+        const context = await codexAppServerConversationContext(sessionId, {}, options);
+        if (context.ok === false) return context;
+        const threadId = codexAppServerTurnState(context.session).threadId ||
+          codexThreadIdForWorkdir(context.session, context.workdir);
+        if (!threadId || threadId !== input.threadId) {
+          return { ok: false, error: "The Codex conversation changed. Refresh the goal before trying again." };
+        }
+        const { goal } = await context.provider.readGoal(threadId);
+        if (!goal || goal.status === "complete" || goal.createdAt !== input.createdAt || goal.objective !== input.objective) {
+          return { ok: false, error: "The Codex goal changed. Refresh it before trying again." };
+        }
+        if (input.action === "pause" && !["active", "paused"].includes(goal.status)) {
+          return { ok: false, error: "This goal is already stopped. Refresh its details." };
+        }
+        if (input.action === "resume" && !["paused", "blocked", "usageLimited"].includes(goal.status)) {
+          return { ok: false, error: "This goal cannot be resumed from its current status. Refresh its details." };
+        }
+        subscribeCodexAppServerEvents(sessionId, context.provider, threadId, context.providerOptions);
+        const result = await context.provider.setGoalStatus(threadId, input.action === "pause" ? "paused" : "active");
+        await reconcileCodexAppServerGoalUpdated(sessionId, context.provider, threadId, {
+          params: { goal: result.goal }
+        });
+        if (input.action === "pause") {
+          const stopped = await interruptCodexAppServerTurnWithinAdmission(sessionId, { threadId });
+          if (stopped.ok === false) {
+            return { ...stopped, goal: result.goal };
+          }
+        }
+        await publishSessionChanged(sessionId, { reason: "codex-goal" });
+        return { ok: true, status: "available", goal: result.goal || null };
+      } finally {
+        admission.release();
+      }
+    },
+
     async readPlanUsage(sessionId) {
       const sessionKey = codexTerminalNamespace(sessionId);
       for (const [key, provider] of codexAppServerProviders) {

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

@@ -313,6 +313,18 @@ function registerRoutes(
     );
   });
 
+  routes.serviceRoute("GET", "/sessions/:sessionId/agent-goal", {
+    summary: "Read the selected Codex conversation goal."
+  }, (request) => terminalService().readAgentGoal(
+    request.params.sessionId, withVibe64User(request, {})
+  ));
+
+  routes.serviceRoute("POST", "/sessions/:sessionId/agent-goal", {
+    summary: "Pause or resume the selected Codex conversation goal."
+  }, (request) => terminalService().updateAgentGoal(
+    request.params.sessionId, withVibe64User(request, routes.requestBody(request))
+  ));
+
   routes.serviceRoute("GET", "/sessions/:sessionId/agent-plan-usage", {
     summary: "Read the selected assistant account's remaining plan allowance."
   }, (request) => terminalService().readAgentPlanUsage(

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

@@ -241,6 +241,11 @@ function timestampIso(ms = 0) {
 }
 
 function agentRunIsActive(run = {}) {
+  // Codex acknowledges Resume before its scheduler starts the next turn.
+  if (run?.providerGoalStatus === "active" && run.providerGoalThreadId &&
+      run.providerGoalThreadId === run.providerThreadId) {
+    return true;
+  }
   if (run?.active === true) {
     return true;
   }
@@ -1711,22 +1716,45 @@ function createService({
           session,
           vibe64User: input.vibe64User || null
         };
-        const providerDescription = await sessionAgent.describeProvider(agentContext);
-        const commitTitle = await generateSessionSaveCommitMessage({
-          agentContext,
-          changes: saveMessageInput.changes,
-          deleteThread: (threadInput, options) => sessionAgent.deleteDetachedChatThread(
-            normalizedSessionId,
-            threadInput,
-            options
-          ),
-          runAgentTurn: (turnInput, options) => sessionAgent.streamDetachedChatTurn(
-            normalizedSessionId,
-            turnInput,
-            options
-          ),
-          expectedAccountIdentitySignature: providerDescription.accountIdentitySignature
-        });
+        let commitTitle;
+        try {
+          const providerDescription = await sessionAgent.describeProvider(agentContext);
+          commitTitle = await generateSessionSaveCommitMessage({
+            agentContext,
+            changes: saveMessageInput.changes,
+            deleteThread: (threadInput, options) => sessionAgent.deleteDetachedChatThread(
+              normalizedSessionId,
+              threadInput,
+              options
+            ),
+            runAgentTurn: (turnInput, options) => sessionAgent.streamDetachedChatTurn(
+              normalizedSessionId,
+              turnInput,
+              options
+            ),
+            expectedAccountIdentitySignature: providerDescription.accountIdentitySignature
+          });
+        } catch (error) {
+          // Naming is optional. Leave failed thread ownership intact and let the
+          // repository owner enforce the normal checkpoint and publish checks.
+          commitTitle = {
+            executionProfile: null,
+            subject: `Save work ${saveMessageInput.checkpoint.checkpointTree.slice(0, 12)}`
+          };
+          logOperationalEvent(logger, "warn", {
+            code: error.code || "vibe64_session_save_message_failed",
+            component: "vibe64.session_save",
+            event: "vibe64.session_save.message_fallback",
+            operationId: input.operationId,
+            sessionId: normalizedSessionId
+          }, "Assistant naming was unavailable; Save is using a checkpoint-based version name.");
+          await input.onProgress?.({
+            code: error.code || "vibe64_session_save_message_failed",
+            kind: "message",
+            message: "Assistant naming is unavailable. Saving with a checkpoint-based version name.",
+            stage: "message-fallback"
+          });
+        }
         await input.onProgress?.({
           executionProfile: commitTitle.executionProfile,
           kind: "message",
@@ -2381,6 +2409,19 @@ function createService({
       }
     },
 
+    async readAgentGoal(sessionId, options = {}) {
+      return sessionAgent.readGoal(sessionId, await assistantSessionOptions(sessionId, options));
+    },
+
+    async updateAgentGoal(sessionId, input = {}) {
+      if (input.action === "resume") {
+        return runMainAgentWrite(sessionId, input, (context) => (
+          sessionAgent.updateGoal(sessionId, input, context)
+        ), { operation: "resume-agent-goal" });
+      }
+      return sessionAgent.updateGoal(sessionId, input, await assistantSessionOptions(sessionId, input));
+    },
+
     async readAgentPlanUsage(sessionId, options = {}) {
       return sessionAgent.readPlanUsage(sessionId, await assistantSessionOptions(sessionId, options));
     },

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

@@ -636,7 +636,14 @@ function createSessionPromptHintsService({
       executionProfile: PROMPT_HINT_EXECUTION_PROFILE_REQUEST,
       threadId: job.threadId,
       turnId: job.turnId
-    }, agentOptions(job.context, job.vibe64User))).catch((error) => {
+    }, agentOptions(job.context, job.vibe64User))).then((result) => {
+      if (result?.ok !== true) {
+        const error = new Error(result?.error || "Prompt hint interruption was not confirmed.");
+        error.code = result?.code || "vibe64_prompt_hints_interrupt_unconfirmed";
+        throw error;
+      }
+      return result;
+    }).catch((error) => {
       reportDiagnostic("vibe64_prompt_hints_interrupt_failed", error, {
         sessionId: job.sessionId
       });
@@ -691,6 +698,7 @@ function createSessionPromptHintsService({
     } finally {
       if (job.threadId) {
         try {
+          await job.interruptPromise;
           const cleanup = await deleteAgentThread(job.sessionId, {
             executionProfile: PROMPT_HINT_EXECUTION_PROFILE_REQUEST,
             threadId: job.threadId

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

@@ -155,7 +155,7 @@ async function cleanupSessionSaveCommitMessageThread({
       [
         "The temporary naming conversation could not be removed.",
         detail,
-        "Retry Save to finish cleanup before publishing work."
+        "Cleanup will be retried on the next helper operation; Save can use a checkpoint-based name."
       ].filter(Boolean).join(" "),
       text(cleanup?.code) || "vibe64_session_save_message_cleanup_failed"
     );