@bitkyc08/opencodex 2.29.0 → 2.31.0-preview.20260822

package/src/codex/features.ts

@@ -155,6 +155,29 @@ export function multiAgentV2EnabledFromConfigText(content: string | null): boole
     return false;
   }
 
+  // Bun 1.4 enforces TOML's "value must begin on the assignment line" rule that
+  // 1.3.14 did not, so `hint =` followed by `[` on the next line now fails the
+  // real parse and reaches the line-based fallback below — which reads that `[`
+  // as a table header and truncates the table before `enabled`. Codex's own
+  // parser accepts the document, so answering "disabled" would report a parser
+  // disagreement as a feature state (#1295, #1691).
+  //
+  // Joining a dangling `=` to the line that follows is the smallest repair that
+  // keeps the scanner untouched: widening `tomlTableBody` to be string-aware is
+  // what previously broke `getAgentsEnabled`, `getAgentsMaxDepth`, and
+  // `getMaxConcurrentThreads` (see its comment). If the joined document parses,
+  // that answer is authoritative; if it does not, nothing is lost.
+  const joined = joinDanglingTomlAssignments(content);
+  if (joined !== content) {
+    const reparsed = parsedTomlTable(joined, "features");
+    if (reparsed !== null) {
+      const table = plainTomlRecord(reparsed.multi_agent_v2);
+      if (table !== null) return table.enabled === true;
+      if (typeof reparsed.multi_agent_v2 === "boolean") return reparsed.multi_agent_v2;
+      return false;
+    }
+  }
+
   const table = tomlTableBody(content, "features.multi_agent_v2");
   if (table !== null) {
     const enabled = tomlBoolInBody(table, "enabled");
@@ -184,6 +207,41 @@ function plainTomlRecord(value: unknown): Record<string, unknown> | null {
     : null;
 }
 
+/**
+ * Join `key =` to the following line when the value was written on the next
+ * line, so a parser enforcing TOML's same-line rule can read the document.
+ *
+ * Bun 1.3.14 accepted this shape; Bun 1.4 rejects it, correctly — TOML requires
+ * the value to begin on the assignment line. Codex's parser still accepts it, so
+ * this exists to keep the two readers agreeing rather than to endorse the shape.
+ *
+ * Deliberately narrow: it only acts on a line whose LAST non-comment character
+ * is `=`, which cannot occur in a valid assignment. Lines inside multi-line
+ * strings are left alone — a `"""` body line ending in `=` would be rewritten,
+ * but the result is only used when it PARSES, and the unmodified document is
+ * always tried first, so a wrong join cannot displace a correct read.
+ */
+function joinDanglingTomlAssignments(content: string): string {
+  const lines = content.split("\n");
+  const out: string[] = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]!;
+    // A dangling assignment: trailing `=` with nothing after it on this line.
+    if (/^[^#]*[^=!<>]=\s*$/.test(line) && i + 1 < lines.length) {
+      let j = i + 1;
+      // Skip blank and comment-only lines between the `=` and its value.
+      while (j < lines.length && /^\s*(?:#.*)?$/.test(lines[j]!)) j++;
+      if (j < lines.length) {
+        out.push(`${line.replace(/\s*$/, "")} ${lines[j]!.replace(/^\s*/, "")}`);
+        i = j;
+        continue;
+      }
+    }
+    out.push(line);
+  }
+  return out.join("\n");
+}
+
 /**
  * A top-level table from a full TOML parse, or null when the document does not
  * parse. A parsed document with no such table yields `{}` rather than null: that

package/src/codex/inject-coordination.ts

@@ -5,10 +5,11 @@
  * sequence it is, rather than doubling in length around the lock.
  */
 import { createHash } from "node:crypto";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, lstatSync, readFileSync } from "node:fs";
 
 import { atomicWriteFile } from "../config";
 import type { CodexWriteLockResult } from "./codex-write-lock";
+import { inspectCodexCoordinatorPath } from "./coordinator-doctor";
 import { JOURNAL_PATH } from "./journal";
 import { CODEX_CONFIG_PATH, CODEX_PROFILE_PATH } from "./paths";
 import {
@@ -43,21 +44,51 @@ export type CodexWriteCoordinationEligibility =
   | { kind: "legacy-uncoordinated"; reason: string }
   | { kind: "refused"; reason: string };
 
+/**
+ * A live SQLite creator exposes a zero-byte pathname before BEGIN IMMEDIATE.
+ * Requiring a settled filesystem age makes that scheduling window remain on
+ * the coordinated path while old crash remnants can use the legacy boundary.
+ */
+export const STABLE_ZERO_BYTE_COORDINATOR_AGE_MS = 1_000;
+
 export function codexWriteCoordinationEligibility(deps: {
   coordinatorPath: () => string;
   residue: () => { kind: string };
   integrationRecord: () => { kind: string };
+  nowMs?: () => number;
 }): CodexWriteCoordinationEligibility {
   let coordinatorExists: boolean;
+  let coordinatorIsStableZeroByte = false;
   try {
-    coordinatorExists = existsSync(deps.coordinatorPath());
+    const path = deps.coordinatorPath();
+    coordinatorExists = existsSync(path);
+    if (coordinatorExists) {
+      const entry = lstatSync(path);
+      if (entry.isFile() && !entry.isSymbolicLink() && entry.size === 0) {
+        const diagnostic = inspectCodexCoordinatorPath(path);
+        if (diagnostic.kind === "zero-byte") {
+          const lastIdentityChange = Math.max(diagnostic.identity.mtimeMs, diagnostic.identity.ctimeMs);
+          coordinatorIsStableZeroByte = (deps.nowMs?.() ?? Date.now()) - lastIdentityChange
+            >= STABLE_ZERO_BYTE_COORDINATOR_AGE_MS;
+        }
+      }
+    }
   } catch (error) {
     return { kind: "refused", reason: `the coordinator path could not be resolved: ${String(error)}` };
   }
 
-  // An existing coordinator is authoritative, and the lock owns validating it —
-  // including the unversioned and rowless cases it must refuse rather than adopt.
-  if (coordinatorExists) return { kind: "coordinated" };
+  // Every existing coordinator remains authoritative unless it is proven to be
+  // an old, immutable SQLite-empty remnant. The age gate is part of that proof:
+  // a live creator exposes the same zero-byte pathname briefly before taking N,
+  // and sending that fresh file down the legacy path would bypass its lock.
+  // Non-empty, fresh, unsafe, changed, unversioned, and rowless files therefore
+  // stay coordinated and are validated/refused by the transaction owner.
+  //
+  // We do NOT initialize or adopt it here. Clean homes still enter the
+  // coordinated path, whose SQLite transaction safely initializes it. Routed
+  // or indeterminate legacy homes keep the same uncoordinated compatibility
+  // boundary they would have had if the remnant pathname were absent.
+  if (coordinatorExists && !coordinatorIsStableZeroByte) return { kind: "coordinated" };
 
   const record = deps.integrationRecord();
   if (record.kind === "invalid") {
@@ -83,7 +114,9 @@ export function codexWriteCoordinationEligibility(deps: {
    */
   return {
     kind: "legacy-uncoordinated",
-    reason: residue.kind === "residue"
+    reason: coordinatorIsStableZeroByte
+      ? "the coordinator is a zero-byte non-authoritative remnant and this routed home has not been adopted yet"
+      : residue.kind === "residue"
       ? "this home was routed before write coordination existed and has not been adopted yet"
       : "the existing native Codex state could not be classified, so it cannot seed a coordinator row",
   };

package/src/codex/transition-state.ts

@@ -37,7 +37,7 @@ import {
   samePathIdentity,
 } from "./user-identity";
 
-const COORDINATOR_SCHEMA_VERSION = 1;
+export const CODEX_COORDINATOR_SCHEMA_VERSION = 1;
 const DURABLE_HISTORY_STATUSES = new Set(["converged", "pending", "running", "blocked", "unknown"]);
 const DURABLE_HISTORY_REASONS = new Set([
   "db-busy",
@@ -241,7 +241,7 @@ function rowToState(row: TransitionRow | null): CodexTransitionState {
   };
 }
 
-function readState(database: Database): CodexTransitionState {
+export function readCodexCoordinatorState(database: Database): CodexTransitionState {
   const row = database.query<TransitionRow, []>(SELECT_TRANSITION_ROW).get();
   return rowToState(row);
 }
@@ -282,7 +282,7 @@ function assertInitialStateCanBeCreated(): void {
 
 function initialize(database: Database, databaseWasAbsent: boolean): void {
   const version = database.query<{ user_version: number }, []>("PRAGMA user_version").get()?.user_version;
-  if (version !== 0 && version !== COORDINATOR_SCHEMA_VERSION) {
+  if (version !== 0 && version !== CODEX_COORDINATOR_SCHEMA_VERSION) {
     throw new CodexCoordinatorTransactionError("The coordinator database schema version is unsupported.");
   }
   if (!databaseWasAbsent && version === 0) {
@@ -301,8 +301,8 @@ function initialize(database: Database, databaseWasAbsent: boolean): void {
     assertInitialStateCanBeCreated();
     database.query(INITIALIZE_TRANSITION_ROW).run(new Date().toISOString());
   }
-  if (version === 0) database.exec(`PRAGMA user_version = ${COORDINATOR_SCHEMA_VERSION}`);
-  readState(database);
+  if (version === 0) database.exec(`PRAGMA user_version = ${CODEX_COORDINATOR_SCHEMA_VERSION}`);
+  readCodexCoordinatorState(database);
 }
 
 function createCapability(
@@ -336,7 +336,7 @@ function createCapability(
         expected.nativeGeneration,
         expected.currentTxId,
       );
-      const state = readState(database);
+      const state = readCodexCoordinatorState(database);
       const update: TransitionStateUpdate = result.changes === 1
         ? { kind: "updated", state }
         : { kind: "conflict", current: state };
@@ -451,7 +451,7 @@ export function openCodexCoordinatorTransaction(finalDatabasePath: string): Code
     capability,
     expectation() {
       requireOpen();
-      const state = readState(db);
+      const state = readCodexCoordinatorState(db);
       return {
         nativeBefore: state.nativeGeneration,
         nativeAfter: state.nativeGeneration + 1,
@@ -460,7 +460,7 @@ export function openCodexCoordinatorTransaction(finalDatabasePath: string): Code
     },
     version() {
       requireOpen();
-      const state = readState(db);
+      const state = readCodexCoordinatorState(db);
       return { nativeGeneration: state.nativeGeneration, currentTxId: state.currentTxId };
     },
     assertPublished(expectation) {
@@ -468,7 +468,7 @@ export function openCodexCoordinatorTransaction(finalDatabasePath: string): Code
       if (lastResult?.kind !== "updated") {
         throw new CodexCoordinatorTransactionError("The coordinator transition was not published.");
       }
-      const state = readState(db);
+      const state = readCodexCoordinatorState(db);
       if (state.nativeGeneration !== expectation.nativeAfter || state.currentTxId !== expectation.txId) {
         throw new CodexCoordinatorTransactionError("The coordinator published a different transition.");
       }
@@ -540,7 +540,7 @@ function readCommittedState(): TransitionStateRead {
   try {
     database = new Database(path, { readonly: true });
     database.exec("PRAGMA busy_timeout = 0");
-    return { kind: "ready", state: readState(database) };
+    return { kind: "ready", state: readCodexCoordinatorState(database) };
   } catch (error) {
     return mapUnavailable(error);
   } finally {
@@ -577,7 +577,7 @@ export const updateCodexHistoryTransition: UpdateCodexHistoryTransition = (expec
     database = new Database(currentCoordinatorDatabasePath(), { readwrite: true, create: false });
     database.exec("PRAGMA busy_timeout = 0; BEGIN IMMEDIATE");
     transactionOpen = true;
-    const current = readState(database);
+    const current = readCodexCoordinatorState(database);
     if (current.nativeGeneration > 0 && current.historySchedule === null) {
       throw new CodexCoordinatorTransactionError("A positive transition cannot lose its direction.");
     }
@@ -594,7 +594,7 @@ export const updateCodexHistoryTransition: UpdateCodexHistoryTransition = (expec
       expected.currentTxId,
       expected.currentTxId,
     );
-    const state = readState(database);
+    const state = readCodexCoordinatorState(database);
     database.exec("COMMIT");
     transactionOpen = false;
     return result.changes === 1