@triflux/remote 10.45.0 → 10.47.0

package/hub/server.mjs

@@ -72,9 +72,7 @@ import {
 } from "@triflux/core/hub/state.mjs";
 import { createStoreAdapter } from "./store-adapter.mjs";
 import { createCtoAutoCollector } from "./team/cto-auto-collect.mjs";
-import { createGitPreflight } from "./team/git-preflight.mjs";
 import { nativeProxy } from "./team/nativeProxy.mjs";
-import { createSwarmLocks } from "./team/swarm-locks.mjs";
 import {
   createSynapseRegistry,
   projectPeer,
@@ -119,14 +117,6 @@ const AIMD_WINDOW_MS = 30 * 60 * 1000;
 const AIMD_INITIAL_BATCH_SIZE = 3;
 const AIMD_MIN_BATCH_SIZE = 1;
 const AIMD_MAX_BATCH_SIZE = 10;
-const SYNAPSE_VALID_OPS = new Set([
-  "checkout",
-  "rebase",
-  "cherry-pick",
-  "reset",
-  "stash-pop",
-  "worktree-remove",
-]);
 const HUB_IDLE_TIMEOUT_DEFAULT_MS = 30 * 60 * 1000;
 const HUB_IDLE_SWEEP_DEFAULT_MS = 60 * 1000;
 const STATIC_CONTENT_TYPES = Object.freeze({
@@ -1124,21 +1114,13 @@ export async function startHub({
   }
   const delegatorService = new DelegatorService({ worker: delegatorWorker });
 
-  // Synapse Layer 4: session registry + git preflight + swarm locks
+  // Synapse Layer 4: session registry
   const synapseEmitter = new EventEmitter();
   synapseEmitter.setMaxListeners(50);
   const synapseRegistry = createSynapseRegistry({
     persistPath: join(CACHE_DIR, "tfx-hub", "synapse-sessions.json"),
     emitter: synapseEmitter,
   });
-  const swarmLocks = createSwarmLocks({
-    repoRoot: PROJECT_ROOT,
-    persistPath: join(CACHE_DIR, "tfx-hub", "swarm-locks.json"),
-  });
-  const gitPreflight = createGitPreflight({
-    registry: synapseRegistry,
-    locks: swarmLocks,
-  });
   const ctoAutoCollector = createCtoAutoCollector({
     registry: synapseRegistry,
     runCollect,
@@ -1437,7 +1419,7 @@ export async function startHub({
         });
       }
 
-      // ── Synapse Layer 5: session registry + locks + preflight routes ──
+      // ── Synapse Layer 5: session registry routes ──
       // Admin/raw snapshot (loopback-only). Returns raw cwd/pid for local
       // admin/HUD use; the redacted peer surface is GET /synapse/peers.
       if (path === "/synapse/sessions" && req.method === "GET") {
@@ -1642,37 +1624,6 @@ export async function startHub({
         }
       }
 
-      if (path === "/synapse/locks" && req.method === "GET") {
-        return writeJson(res, 200, {
-          ok: true,
-          locks: swarmLocks.snapshot(),
-          ts: Date.now(),
-        });
-      }
-
-      if (path === "/synapse/preflight" && req.method === "POST") {
-        try {
-          const body = await parseBody(req);
-          const { op, args = {}, sessionContext = {} } = body;
-          if (!op || typeof op !== "string") {
-            return writeJson(res, 400, { ok: false, error: "op 필수" });
-          }
-          if (!SYNAPSE_VALID_OPS.has(op)) {
-            return writeJson(res, 400, {
-              ok: false,
-              error: `invalid op: ${op}`,
-            });
-          }
-          const result = gitPreflight.check(op, args, sessionContext);
-          return writeJson(res, 200, { ok: true, ...result });
-        } catch (err) {
-          return writeJson(res, 400, {
-            ok: false,
-            error: String(err?.message || err),
-          });
-        }
-      }
-
       if (path.startsWith("/bridge")) {
         const isBridgeStatusGet =
           path === "/bridge/status" && req.method === "GET";

package/hub/team/recovery-store.mjs

@@ -1,6 +1,6 @@
 // hub/team/recovery-store.mjs — Best-effort preservation of worker changes
 // before a dirty worktree is removed. Uses file-based `.patch` + JSON manifest
-// instead of git stash (git-preflight flags stash-pop/worktree-remove as risky).
+// instead of git stash, which is risky to pop under concurrent worktree use.
 
 import { execFile } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";

package/hub/team/retry-state-machine.mjs

@@ -23,7 +23,10 @@ import {
 } from "node:fs";
 import { dirname, join } from "node:path";
 
-import { normalizeCodexProfileName } from "../../scripts/lib/codex-profile-config.mjs";
+import {
+  canonicalCodexProfileModel,
+  normalizeCodexProfileName,
+} from "../../scripts/lib/codex-profile-config.mjs";
 
 export const STATES = Object.freeze({
   PLANNING: "PLANNING",
@@ -318,6 +321,11 @@ function normalizeEscalationChainEntry(entry, index, source) {
     const profile = entry.profile.trim();
     normalized.profile =
       entry.cli === "codex" ? normalizeEscalationProfile(profile) : profile;
+    // A remapped legacy profile must not keep reporting its old model.
+    if (normalized.profile !== profile) {
+      normalized.model =
+        canonicalCodexProfileModel(normalized.profile) ?? normalized.model;
+    }
   }
   return normalized;
 }

package/hub/team/synapse-registry.mjs

@@ -48,9 +48,9 @@ function hasDirtyFiles(session) {
 // A session is "live" while active OR idle. Idle is an interactive session that
 // missed its heartbeat interval but is still under the TTL — alive but inactive,
 // not presumed dead. getActive() and querySessions() share this single predicate
-// so the liveness contract can't drift: getActive() feeds git-preflight's
-// dirty-file conflict guard, so dropping idle there would hide a still-live
-// interactive session's claimed paths from that safety check.
+// so the liveness contract can't drift: getActive() feeds peer discovery,
+// CTO status/hygiene and log retention, so dropping idle there would hide a
+// still-live interactive session from every one of those consumers.
 function isLiveStatus(status) {
   return status === "active" || status === "idle";
 }
@@ -337,7 +337,7 @@ export function createSynapseRegistry(opts = {}) {
     // session resuming: Claude Code re-fires SessionStart with the same
     // session_id on resume/clear/compact, so fall through and re-register
     // (revive) it. Otherwise the resumed-but-live session stays stale forever
-    // and vanishes from peer-discovery AND git-preflight's dirty-file guard.
+    // and vanishes from peer-discovery.
     const existing = sessions.get(sessionId);
     if (existing && isLiveStatus(existing.status)) {
       console.warn(
@@ -381,10 +381,13 @@ export function createSynapseRegistry(opts = {}) {
   }
 
   // stale/expired 세션이 cutoff 넘게 누적되면 Map에서 제거.
-  // live(active/idle)는 lastHeartbeat가 오래돼도 보존 — git-preflight dirty-file 가드가 의존.
-  // Dirty stale rows keep the historical 24h window because same-id resume
-  // revives their dirty-file guard; clean stale rows expire quickly to avoid
-  // daily dummy rows after overnight operator gaps.
+  // live(active/idle) rows survive a long-stale lastHeartbeat because peer
+  // discovery and CTO status/hygiene still read them.
+  // Dirty stale rows keep the historical 24h window. Its original consumer,
+  // the git-preflight dirty-file guard, is gone and nothing populates
+  // dirtyFiles today, so this split is a candidate for collapsing into one
+  // window. Clean stale rows expire quickly to avoid daily dummy rows after
+  // overnight operator gaps.
   function pruneExpired(opts2 = {}) {
     if (destroyed) return { removed: [], count: 0 };
 
@@ -510,9 +513,9 @@ export function createSynapseRegistry(opts = {}) {
   }
 
   function getActive() {
-    // Live = active or idle. git-preflight uses this to detect other live
-    // sessions whose dirty files would conflict; an idle interactive session is
-    // still live (process alive, dirty files on disk) and must stay visible.
+    // Live = active or idle. Peer discovery, CTO status/hygiene and log
+    // retention read this list; an idle interactive session is still live
+    // (process alive) and must stay visible to them.
     return [...sessions.values()]
       .filter((session) => isLiveStatus(session.status))
       .map((session) => cloneSession(session));

package/hub/team/uds-orchestrator.mjs

@@ -1,9 +1,9 @@
 import { spawn } from "node:child_process";
 import crypto from "node:crypto";
-import { mkdtemp, rm, stat } from "node:fs/promises";
+import { mkdtemp, realpath, rm, stat } from "node:fs/promises";
 import net from "node:net";
 import { tmpdir } from "node:os";
-import { join as pathJoin } from "node:path";
+import { join as pathJoin, resolve as pathResolve } from "node:path";
 
 import { execute as defaultExecuteCodex } from "@triflux/core/hub/codex-adapter.mjs";
 import {
@@ -23,6 +23,378 @@ const DEFAULT_TIMEOUT_MS = 90_000;
 const DEFAULT_CODEX_APP_SERVER_UDS_TIMEOUT_MS = 120_000;
 const DEFAULT_CODEX_APP_SERVER_UDS_BOOTSTRAP_MS = 12_000;
 
+function codexClient(socketPath, timeoutMs, clientFactory) {
+  return clientFactory({ socketPath, connectTimeoutMs: timeoutMs });
+}
+
+async function initializeCodexClient(client, timeoutMs) {
+  await client.connect();
+  await client.request(
+    "initialize",
+    { clientInfo: { name: "triflux-tfx-live", version: "1.0.0" } },
+    timeoutMs,
+  );
+  client.notify("initialized", {});
+}
+
+async function runCodexAppServerTurn({
+  client,
+  threadId,
+  prompt,
+  timeoutMs,
+  maxTurnMs,
+  expectedTurnId,
+}) {
+  const messages = new Map();
+  const pending = [];
+  let turnId = null;
+  let startedTurnId = null;
+  let retries = 0;
+  let settled = false;
+  let timer = null;
+  let resolveCompletion;
+  const completion = new Promise((resolve) => {
+    resolveCompletion = resolve;
+  });
+  const lifecycle = createActivityLifecycle({
+    enabled: isActivityLifecycleEnabled(),
+    interventionMs: timeoutMs,
+    hardCeilingMs: maxTurnMs,
+  });
+  const finish = (result) => {
+    if (settled) return;
+    settled = true;
+    resolveCompletion(result);
+  };
+  const matching = (params) =>
+    (!params?.threadId || params.threadId === threadId) &&
+    (!params?.turnId || params.turnId === turnId) &&
+    (!params?.turn?.id || params.turn.id === turnId);
+  const receive = (kind, params) => {
+    if (!turnId) {
+      pending.push([kind, params]);
+      return;
+    }
+    if (!matching(params)) return;
+    if (kind === "started" && params?.turn?.id === turnId) {
+      startedTurnId = turnId;
+    } else if (kind === "delta" && typeof params?.delta === "string") {
+      const itemId = params?.itemId || "__unidentified_agent_message__";
+      if (!messages.has(itemId))
+        messages.set(itemId, { text: "", phase: null });
+      messages.get(itemId).text += params.delta;
+      lifecycle.observe();
+    } else if (
+      kind === "itemCompleted" &&
+      params?.item?.type === "agentMessage"
+    ) {
+      const itemId = params.item.id;
+      if (itemId) {
+        if (!messages.has(itemId))
+          messages.set(itemId, { text: "", phase: null });
+        const message = messages.get(itemId);
+        if (typeof params.item.text === "string")
+          message.text = params.item.text;
+        message.phase = params.item.phase || null;
+      }
+    } else if (kind === "completed" && params?.turn?.id === turnId) {
+      finish({
+        status: params?.turn?.status || "unknown",
+        matchedCompletion: true,
+      });
+    } else if (kind === "error") {
+      if (params?.willRetry === true) {
+        retries++;
+        lifecycle.observe();
+        return;
+      }
+      finish({
+        status: "failed",
+        message:
+          params?.error?.message || params?.message || "codex app-server error",
+        matchedCompletion: false,
+      });
+    }
+  };
+  const offDelta = client.onNotification("item/agentMessage/delta", (p) =>
+    receive("delta", p),
+  );
+  const offItemCompleted = client.onNotification("item/completed", (p) =>
+    receive("itemCompleted", p),
+  );
+  const offStarted = client.onNotification("turn/started", (p) =>
+    receive("started", p),
+  );
+  const offDone = client.onNotification("turn/completed", (p) =>
+    receive("completed", p),
+  );
+  const offError = client.onNotification("error", (p) => receive("error", p));
+  const offActivity = client.onNotification("*", (params) => {
+    if (matching(params)) lifecycle.observe();
+  });
+  const armTimer = () => {
+    timer = setTimeout(async () => {
+      if (settled) return;
+      if (!isActivityLifecycleEnabled()) {
+        finish({ status: "timeout", matchedCompletion: false });
+        return;
+      }
+      const reason = await lifecycle.check();
+      if (settled) return;
+      if (reason)
+        finish({ status: "timeout", reason, matchedCompletion: false });
+      else armTimer();
+    }, timeoutMs);
+  };
+  armTimer();
+  try {
+    const input = [{ type: "text", text: prompt }];
+    const started = expectedTurnId
+      ? await client.request(
+          "turn/steer",
+          { threadId, input, expectedTurnId },
+          timeoutMs,
+        )
+      : await client.request("turn/start", { threadId, input }, timeoutMs);
+    turnId = started?.turn?.id || started?.turnId;
+    if (!turnId)
+      throw new Error("codex app-server turn/start returned no turn id");
+    for (const [kind, params] of pending) receive(kind, params);
+    const result = await completion;
+    const entries = [...messages.values()].map((item) => ({
+      ...item,
+      text: item.text.trim(),
+    }));
+    const finals = entries.filter((item) => item.phase === "final_answer");
+    const answer = finals.length ? finals : entries.slice(-1);
+    const commentary = entries.filter(
+      (item) => item.phase === "commentary" && item.text,
+    );
+    return {
+      ...result,
+      turnId,
+      response: answer
+        .map((item) => item.text)
+        .filter(Boolean)
+        .join("\n\n"),
+      commentary: commentary.map((item) => item.text),
+      retries,
+      steered:
+        result.matchedCompletion &&
+        (expectedTurnId === turnId || startedTurnId !== turnId),
+      timedOut: result.status === "timeout",
+    };
+  } finally {
+    clearTimeout(timer);
+    offDelta();
+    offItemCompleted();
+    offStarted();
+    offDone();
+    offError();
+    offActivity();
+  }
+}
+
+async function readCodexThread(client, threadId, timeoutMs) {
+  const result = await client.request("thread/read", { threadId }, timeoutMs);
+  if (!result?.thread)
+    throw new Error(`codex thread/read returned no thread: ${threadId}`);
+  return result.thread;
+}
+
+async function normalizedCwd(cwd) {
+  if (!cwd) return null;
+  try {
+    return await realpath(cwd);
+  } catch (error) {
+    if (error?.code === "ENOENT") return pathResolve(cwd);
+    throw error;
+  }
+}
+
+async function loadedCodexThreads(client, cwd, timeoutMs) {
+  const wantedCwd = await normalizedCwd(cwd);
+  const threads = [];
+  let cursor;
+  do {
+    const result = await client.request(
+      "thread/loaded/list",
+      cursor ? { cursor } : {},
+      timeoutMs,
+    );
+    for (const threadId of result?.data || []) {
+      const thread = await readCodexThread(client, threadId, timeoutMs);
+      if (wantedCwd && (await normalizedCwd(thread.cwd)) !== wantedCwd)
+        continue;
+      threads.push({
+        threadId,
+        cwd: thread.cwd,
+        name: thread.name,
+        status: thread.status,
+        source: thread.source,
+      });
+    }
+    cursor = result?.nextCursor;
+  } while (cursor);
+  return threads;
+}
+
+export async function listCodexAppServerThreads({
+  socketPath,
+  cwd,
+  clientFactory = (opts) => new JsonRpcWsUdsClient(opts),
+} = {}) {
+  const client = codexClient(
+    socketPath,
+    DEFAULT_CODEX_APP_SERVER_UDS_BOOTSTRAP_MS,
+    clientFactory,
+  );
+  try {
+    await initializeCodexClient(
+      client,
+      DEFAULT_CODEX_APP_SERVER_UDS_BOOTSTRAP_MS,
+    );
+    return await loadedCodexThreads(
+      client,
+      cwd,
+      DEFAULT_CODEX_APP_SERVER_UDS_BOOTSTRAP_MS,
+    );
+  } finally {
+    client.close();
+  }
+}
+
+export async function askCodexAppServerThread({
+  socketPath,
+  threadId,
+  cwd,
+  prompt,
+  timeoutMs = DEFAULT_CODEX_APP_SERVER_UDS_TIMEOUT_MS,
+  maxTurnMs = Math.min(resolveHardCeilingMs(), 15 * 60_000),
+  ifBusy = "wait",
+  busyTimeoutMs = timeoutMs,
+  pollIntervalMs = 200,
+  clientFactory = (opts) => new JsonRpcWsUdsClient(opts),
+} = {}) {
+  if (typeof prompt !== "string" || !prompt.trim())
+    throw new Error("codex UDS ask requires a non-empty prompt");
+  if (!threadId) throw new Error("codex UDS ask requires --thread <id|auto>");
+  if (!["wait", "fail", "steer"].includes(ifBusy))
+    throw new Error(`invalid --if-busy: ${ifBusy}`);
+  const client = codexClient(
+    socketPath,
+    DEFAULT_CODEX_APP_SERVER_UDS_BOOTSTRAP_MS,
+    clientFactory,
+  );
+  try {
+    await initializeCodexClient(
+      client,
+      DEFAULT_CODEX_APP_SERVER_UDS_BOOTSTRAP_MS,
+    );
+    let selectedId = threadId;
+    if (threadId === "auto") {
+      const candidates = await loadedCodexThreads(
+        client,
+        cwd,
+        DEFAULT_CODEX_APP_SERVER_UDS_BOOTSTRAP_MS,
+      );
+      if (!candidates.length)
+        throw new Error(
+          "no loaded Codex threads; open the TUI and send its first message before using --thread auto",
+        );
+      if (candidates.length !== 1)
+        throw new Error(
+          `multiple loaded Codex threads; pass --thread ID: ${JSON.stringify(candidates)}`,
+        );
+      selectedId = candidates[0].threadId;
+    }
+    const busyStarted = Date.now();
+    let thread = await readCodexThread(
+      client,
+      selectedId,
+      DEFAULT_CODEX_APP_SERVER_UDS_BOOTSTRAP_MS,
+    );
+    const initiallyBusy = thread.status?.type === "active";
+    if (thread.status?.type === "active" && ifBusy === "fail")
+      throw new Error(`target busy (--if-busy fail): ${selectedId}`);
+    const busyDeadline = busyStarted + busyTimeoutMs;
+    const busyError = () =>
+      new Error(
+        `target busy after ${Math.ceil(busyTimeoutMs / 1000)}s (--if-busy wait)`,
+      );
+    while (thread.status?.type === "active" && ifBusy === "wait") {
+      const waitMs = Math.min(
+        pollIntervalMs,
+        Math.max(0, busyDeadline - Date.now()),
+      );
+      if (waitMs > 0)
+        await new Promise((resolve) => setTimeout(resolve, waitMs));
+      const remainingMs = busyDeadline - Date.now();
+      try {
+        thread = await readCodexThread(
+          client,
+          selectedId,
+          Math.min(
+            DEFAULT_CODEX_APP_SERVER_UDS_BOOTSTRAP_MS,
+            Math.max(1, remainingMs),
+          ),
+        );
+      } catch (error) {
+        if (Date.now() >= busyDeadline) throw busyError();
+        throw error;
+      }
+      if (Date.now() >= busyDeadline && thread.status?.type === "active")
+        throw busyError();
+    }
+    const busyWaitedMs =
+      ifBusy === "wait" && initiallyBusy ? Date.now() - busyStarted : 0;
+    const resumed = await client.request(
+      "thread/resume",
+      { threadId: selectedId, excludeTurns: true },
+      DEFAULT_CODEX_APP_SERVER_UDS_BOOTSTRAP_MS,
+    );
+    let activeTurns = null;
+    if (resumed?.thread?.status?.type === "active")
+      activeTurns = resumed.thread.turns?.length
+        ? resumed.thread.turns
+        : thread.turns;
+    else if (!resumed?.thread && thread.status?.type === "active")
+      activeTurns = thread.turns;
+    const expectedTurnId =
+      ifBusy === "steer"
+        ? activeTurns?.findLast((turn) => turn.status === "inProgress")?.id
+        : undefined;
+    const turn = await runCodexAppServerTurn({
+      client,
+      threadId: selectedId,
+      prompt,
+      timeoutMs,
+      maxTurnMs,
+      expectedTurnId,
+    });
+    if (turn.message) throw new Error(turn.message);
+    return {
+      cli: "codex",
+      transport: "uds",
+      threadId: selectedId,
+      turnId: turn.turnId,
+      response: turn.response,
+      done: turn.status === "completed",
+      matchedCompletion: turn.matchedCompletion,
+      timedOut: turn.timedOut,
+      status: turn.status,
+      commentary: turn.commentary,
+      meta: { retries: turn.retries },
+      ifBusy,
+      busyWaitedMs,
+      steered: turn.steered,
+      socketPath,
+    };
+  } finally {
+    client.close();
+  }
+}
+
 function requireEndpoint(endpoint, name) {
   if (!endpoint || typeof endpoint.ask !== "function") {
     throw new Error(`${name} endpoint with ask(prompt) is required`);
@@ -532,17 +904,8 @@ export function createCodexAppServerUdsEndpoint({
           );
         }
 
-        client = clientFactory({
-          socketPath: resolvedSock,
-          connectTimeoutMs: bootstrapTimeoutMs,
-        });
-        await client.connect();
-        await client.request(
-          "initialize",
-          { clientInfo: { name: "triflux-tfx-live", version: "1.0.0" } },
-          bootstrapTimeoutMs,
-        );
-        client.notify("initialized", {});
+        client = codexClient(resolvedSock, bootstrapTimeoutMs, clientFactory);
+        await initializeCodexClient(client, bootstrapTimeoutMs);
 
         const threadParams = {
           sandbox: "read-only",
@@ -563,85 +926,23 @@ export function createCodexAppServerUdsEndpoint({
           );
         }
 
-        const parts = [];
-        let offDelta = () => {};
-        let offError = () => {};
-        let offDone = () => {};
-        let offActivity = () => {};
-        const cleanup = () => {
-          offDelta();
-          offError();
-          offDone();
-          offActivity();
-        };
-        const completion = new Promise((resolve) => {
-          offDelta = client.onNotification(
-            "item/agentMessage/delta",
-            (params) => {
-              if (typeof params?.delta === "string") parts.push(params.delta);
-            },
-          );
-          offError = client.onNotification("error", (params) => {
-            cleanup();
-            resolve({
-              status: "failed",
-              message: params?.message || "codex app-server error",
-            });
-          });
-          offDone = client.onNotification("turn/completed", (params) => {
-            cleanup();
-            resolve({ status: params?.turn?.status || "unknown" });
-          });
-        });
-
-        await client.request(
-          "turn/start",
-          { threadId, input: [{ type: "text", text: prompt }] },
+        const settled = await runCodexAppServerTurn({
+          client,
+          threadId,
+          prompt,
           timeoutMs,
-        );
-        const activityEnabled = isActivityLifecycleEnabled();
-        const lifecycle = createActivityLifecycle({
-          enabled: activityEnabled,
-          interventionMs: timeoutMs,
-          hardCeilingMs: maxTurnMs,
-        });
-        offActivity = client.onNotification("*", () => lifecycle.observe());
-        let timeoutHandle = null;
-        const timeoutPromise = new Promise((resolve) => {
-          const arm = () => {
-            timeoutHandle = setTimeout(async () => {
-              if (!activityEnabled) {
-                cleanup();
-                resolve({ status: "timeout" });
-                return;
-              }
-              const reason = await lifecycle.check();
-              if (reason) {
-                cleanup();
-                resolve({ status: "timeout", reason });
-                return;
-              }
-              arm();
-            }, timeoutMs);
-          };
-          arm();
+          maxTurnMs,
         });
-        let settled;
-        try {
-          settled = await Promise.race([completion, timeoutPromise]);
-        } finally {
-          // Clear the timer whichever side won, so a completed turn does not
-          // keep the event loop alive until timeoutMs.
-          if (timeoutHandle) clearTimeout(timeoutHandle);
-        }
 
         return {
           endpoint: "codex-app-server-uds",
-          text: parts.join("").trim(),
+          text: settled.response,
           done: settled.status === "completed",
           meta: {
             threadId,
             status: settled.status,
+            retries: settled.retries,
+            commentary: settled.commentary,
             socketPath: resolvedSock,
             spawned: Boolean(child),
             ...(settled.message ? { error: settled.message } : {}),

package/hub/team/worktree-lifecycle.mjs

@@ -273,6 +273,8 @@ export async function ensureWorktree({
  * @param {string} opts.baseBranch
  * @param {string} [opts.rootDir=process.cwd()]
  * @returns {Promise<{ integrationBranch: string, baseCommit: string }>}
+ * @throws {Error} when the integration branch is checked out by another
+ * worktree; this is an intentional NO-GO and leaves that worktree untouched.
  */
 export async function prepareIntegrationBranch({
   runId,
@@ -299,42 +301,17 @@ export async function prepareIntegrationBranch({
  * Rebase a shard branch onto the integration branch.
  * Uses rebase + fast-forward only (no merge commits).
  *
- * Synapse v1: when a `preflight` checker + `sessionContext` are provided,
- * the rebase is pre-flighted against active sessions' dirty files/leases.
- * Blocked rebases return `{ ok: false, preflight: decision }` without touching
- * any branch. If preflight is omitted, behavior is unchanged.
- *
  * @param {object} opts
  * @param {string} opts.shardBranch — the shard's branch name
  * @param {string} opts.integrationBranch — target integration branch
  * @param {string} [opts.rootDir=process.cwd()]
- * @param {{ checkRebase: Function } | null} [opts.preflight=null] — git-preflight instance
- * @param {{ sessionId: string, workerId?: string } | null} [opts.sessionContext=null]
- * @returns {Promise<{ ok: boolean, headCommit?: string, strategy?: string, commits?: number, notes?: string, fallbackReason?: string, error?: string, preflight?: object }>}
+ * @returns {Promise<{ ok: boolean, headCommit?: string, strategy?: string, commits?: number, notes?: string, fallbackReason?: string, error?: string }>}
  */
 export async function rebaseShardOntoIntegration({
   shardBranch,
   integrationBranch,
   rootDir = process.cwd(),
-  preflight = null,
-  sessionContext = null,
 }) {
-  // Synapse v1 pre-flight: bail out before mutating branches when another
-  // session claims overlapping files.
-  if (preflight && sessionContext) {
-    const decision = preflight.checkRebase(
-      { branch: integrationBranch },
-      sessionContext,
-    );
-    if (!decision.allowed) {
-      return {
-        ok: false,
-        error: `git-preflight blocked rebase: ${decision.reason || "overlap"}`,
-        preflight: decision,
-      };
-    }
-  }
-
   // #127 BUG-E accident history: this function used to checkout the
   // integration branch in rootDir, leak rootDir HEAD, and redirect later user
   // edits/commits into swarm/.../merge. Integration now happens exclusively in
@@ -458,6 +435,11 @@ export async function rebaseShardOntoIntegration({
       }
     } else {
       await rm(integrationWorktree, { recursive: true, force: true });
+      try {
+        await git(["worktree", "prune"], rootDir);
+      } catch {
+        /* best-effort metadata cleanup after a partial worktree add */
+      }
     }
   }
 }
@@ -524,40 +506,18 @@ export async function cleanupWorktree({
  * Remove a worktree and its branch.
  * Follows WT race-guard: sleep between operations.
  *
- * Synapse v1: when `preflight` + `sessionContext` are provided, the removal
- * is pre-flighted against active sessions — blocked if another session is
- * still registered to this worktree path.
- *
  * @param {object} opts
  * @param {string} opts.worktreePath
  * @param {string} [opts.branchName] — optional branch to delete
  * @param {string} [opts.rootDir=process.cwd()]
  * @param {boolean} [opts.force=false]
- * @param {{ checkWorktreeRemove: Function } | null} [opts.preflight=null]
- * @param {{ sessionId: string, workerId?: string } | null} [opts.sessionContext=null]
  */
 export async function pruneWorktree({
   worktreePath,
   branchName,
   rootDir = process.cwd(),
   force = false,
-  preflight = null,
-  sessionContext = null,
 }) {
-  if (preflight && sessionContext) {
-    const decision = preflight.checkWorktreeRemove(
-      { worktreePath },
-      sessionContext,
-    );
-    if (!decision.allowed) {
-      return {
-        ok: false,
-        error: `git-preflight blocked worktree-remove: ${decision.reason || "active_worktree"}`,
-        preflight: decision,
-      };
-    }
-  }
-
   const cleanupResult = await cleanupWorktree({
     worktreePath,
     branchName,

package/hub/tray-lifecycle.mjs

@@ -120,7 +120,7 @@ export function spawnTrayForHub({
   cwd = process.cwd(),
   spawnFn = spawn,
 } = {}) {
-  if (env?.TFX_HUB_AUTO_TRAY === "0") return { status: "disabled" };
+  if (env?.TFX_HUB_AUTO_TRAY !== "1") return { status: "disabled" };
   if (isWorktreeOrEphemeralHubContext({ cwd, env })) {
     return { status: "disabled", reason: "ephemeral-or-worktree-context" };
   }

package/hub/workers/codex-mcp.mjs

@@ -120,7 +120,7 @@ function readTomlScalar(raw, key) {
 }
 
 /**
- * Resolve a Codex effort profile name (e.g. "gpt56_terra_high") to its concrete
+ * Resolve a Codex effort profile name (e.g. "gpt6_sol_high") to its concrete
  * `model` + reasoning effort. SSOT = the per-profile file written by
  * `tfx setup` at `~/.codex/<profile>.config.toml`. Falls back to deriving the
  * effort from the `<...>_<effort>` naming convention when the file is absent.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triflux/remote",
-  "version": "10.45.0",
+  "version": "10.47.0",
   "description": "triflux remote — team mode, psmux, MCP workers, SQLite store.",
   "type": "module",
   "main": "hub/index.mjs",

package/scripts/lib/agent-route-policy.mjs

@@ -7,7 +7,7 @@ import {
 
 const policy = {
   executor: {
-    profile: "gpt56_terra_high",
+    profile: "gpt6_sol_high",
     timeoutSec: 1080,
     runMode: "fg",
     opusOversight: false,
@@ -15,7 +15,7 @@ const policy = {
     subcommand: "exec",
   },
   codex: {
-    profile: "gpt56_terra_high",
+    profile: "gpt6_sol_high",
     timeoutSec: 1080,
     runMode: "fg",
     opusOversight: false,
@@ -23,7 +23,7 @@ const policy = {
     subcommand: "exec",
   },
   "build-fixer": {
-    profile: "gpt56_luna_low",
+    profile: "gpt6_luna_high",
     timeoutSec: 540,
     runMode: "fg",
     opusOversight: false,
@@ -31,7 +31,7 @@ const policy = {
     subcommand: "exec",
   },
   cleanup: {
-    profile: "gpt56_terra_med",
+    profile: "gpt6_sol_med",
     timeoutSec: 540,
     runMode: "fg",
     opusOversight: false,
@@ -39,7 +39,7 @@ const policy = {
     subcommand: "exec",
   },
   deslop: {
-    profile: "gpt56_terra_med",
+    profile: "gpt6_sol_med",
     timeoutSec: 540,
     runMode: "fg",
     opusOversight: false,
@@ -95,7 +95,7 @@ const policy = {
     subcommand: "exec",
   },
   "code-reviewer": {
-    profile: "gpt56_terra_high",
+    profile: "gpt6_sol_high",
     timeoutSec: 1800,
     runMode: "bg",
     opusOversight: false,
@@ -103,7 +103,7 @@ const policy = {
     subcommand: "review",
   },
   "quality-reviewer": {
-    profile: "gpt56_terra_high",
+    profile: "gpt6_sol_high",
     timeoutSec: 1800,
     runMode: "bg",
     opusOversight: false,
@@ -119,7 +119,7 @@ const policy = {
     subcommand: "review",
   },
   scientist: {
-    profile: "gpt56_terra_high",
+    profile: "gpt6_sol_high",
     timeoutSec: 1440,
     runMode: "bg",
     opusOversight: false,
@@ -127,7 +127,7 @@ const policy = {
     subcommand: "exec",
   },
   "document-specialist": {
-    profile: "gpt56_terra_high",
+    profile: "gpt6_sol_high",
     timeoutSec: 1440,
     runMode: "bg",
     opusOversight: false,
@@ -143,7 +143,7 @@ const policy = {
     subcommand: "exec",
   },
   verifier: {
-    profile: "gpt56_terra_high",
+    profile: "gpt6_sol_high",
     timeoutSec: 1200,
     runMode: "fg",
     opusOversight: false,
@@ -151,7 +151,7 @@ const policy = {
     subcommand: "review",
   },
   "test-engineer": {
-    profile: "gpt56_terra_high",
+    profile: "gpt6_sol_high",
     timeoutSec: 1200,
     runMode: "bg",
     opusOversight: false,
@@ -159,7 +159,7 @@ const policy = {
     subcommand: "exec",
   },
   "qa-tester": {
-    profile: "gpt56_terra_high",
+    profile: "gpt6_sol_high",
     timeoutSec: 1200,
     runMode: "bg",
     opusOversight: false,
@@ -167,7 +167,7 @@ const policy = {
     subcommand: "review",
   },
   spark: {
-    profile: "gpt56_luna_low",
+    profile: "gpt6_luna_low",
     timeoutSec: 180,
     runMode: "fg",
     opusOversight: false,
@@ -185,7 +185,7 @@ const policy = {
     subcommand: "exec",
   },
   writer: {
-    profile: "gpt56_luna_low",
+    profile: "gpt6_luna_high",
     timeoutSec: 900,
     runMode: "bg",
     opusOversight: false,
@@ -210,9 +210,10 @@ export const DEFAULT_CODEX_AGENT = "executor";
 
 export const CANONICAL_CODEX_PROFILE_OVERRIDES = Object.freeze(
   new Set([
-    "gpt56_luna_low",
-    "gpt56_terra_med",
-    "gpt56_terra_high",
+    "gpt6_luna_low",
+    "gpt6_luna_high",
+    "gpt6_sol_med",
+    "gpt6_sol_high",
     "gpt6_astra_xhigh",
     "gpt6_astra_max",
     "gpt6_astra_ultra",

package/scripts/lib/codex-profile-config.mjs

@@ -19,18 +19,24 @@ const EFFORT_BY_SUFFIX = {
 };
 
 const CANONICAL_PROFILE_VALUES = Object.freeze({
-  gpt56_luna_low: { model: "gpt-5.6-luna", effort: "low" },
-  gpt56_terra_med: { model: "gpt-5.6-terra", effort: "medium" },
-  gpt56_terra_high: { model: "gpt-5.6-terra", effort: "high" },
+  gpt6_luna_low: { model: "gpt-6-luna", effort: "low" },
+  gpt6_luna_high: { model: "gpt-6-luna", effort: "high" },
+  gpt6_sol_med: { model: "gpt-6-sol", effort: "medium" },
+  gpt6_sol_high: { model: "gpt-6-sol", effort: "high" },
   gpt6_astra_xhigh: { model: "gpt-6-astra", effort: "xhigh" },
   gpt6_astra_max: { model: "gpt-6-astra", effort: "max" },
   gpt6_astra_ultra: { model: "gpt-6-astra", effort: "ultra" },
 });
 
+// GPT-5.6 lane names map to the GPT-6 lane with the same effort. GPT-6 has no
+// Terra tier, so Terra lanes move to Sol.
 const LEGACY_CANONICAL_PROFILE_ALIASES = Object.freeze({
   gpt56_sol_xhigh: "gpt6_astra_xhigh",
   gpt56_sol_max: "gpt6_astra_max",
   gpt56_sol_ultra: "gpt6_astra_ultra",
+  gpt56_terra_high: "gpt6_sol_high",
+  gpt56_terra_med: "gpt6_sol_med",
+  gpt56_luna_low: "gpt6_luna_low",
 });
 
 export function normalizeCodexProfileName(profileName) {
@@ -38,6 +44,14 @@ export function normalizeCodexProfileName(profileName) {
   return LEGACY_CANONICAL_PROFILE_ALIASES[normalized] || normalized;
 }
 
+/** Model ID of a canonical profile (after legacy normalization), or null. */
+export function canonicalCodexProfileModel(profileName) {
+  return (
+    CANONICAL_PROFILE_VALUES[normalizeCodexProfileName(profileName)]?.model ??
+    null
+  );
+}
+
 function readProfileScalar(raw, key) {
   const match = String(raw).match(
     new RegExp(
@@ -51,7 +65,7 @@ function readProfileScalar(raw, key) {
 }
 
 /**
- * Resolve a Codex effort profile name (e.g. "gpt56_terra_high") to the `-c key=value`
+ * Resolve a Codex effort profile name (e.g. "gpt6_sol_high") to the `-c key=value`
  * config overrides that `codex exec` accepts, so the headless CLI lanes can
  * select a profile WITHOUT `codex exec --profile <name>`. codex 0.134+ rejects
  * `--profile X` whenever config.toml still contains an inline `[profiles.X]`
@@ -69,7 +83,7 @@ function readProfileScalar(raw, key) {
  *
  * @param {string} profileName
  * @param {{ codexHome?: string }} [opts]
- * @returns {string[]} e.g. ['model="gpt-5.6-terra"', 'model_reasoning_effort="high"']
+ * @returns {string[]} e.g. ['model="gpt-6-sol"', 'model_reasoning_effort="high"']
  */
 export function resolveCodexProfileConfigValues(profileName, opts = {}) {
   if (typeof profileName !== "string" || !profileName) {

package/hub/team/git-preflight.mjs

@@ -1,286 +0,0 @@
-// hub/team/git-preflight.mjs — Pre-flight safety check for dangerous git ops.
-// Blocks checkout/rebase/cherry-pick/reset/stash-pop/worktree-remove when they
-// would conflict with other active Synapse sessions' dirty files or claimed
-// leases. Fail-open by default: if registry/locks are unavailable, allow the op
-// with a warning (worktree isolation is the baseline safety net).
-
-/**
- * Factory for git pre-flight check.
- *
- * @param {object} opts
- * @param {{ getActive: () => Array<object> }} opts.registry — synapse-registry duck type
- * @param {{ snapshot: () => Array<object> }} opts.locks — swarm-locks duck type
- * @param {boolean} [opts.failOpen=true] — allow op when registry/locks throw or are missing
- * @param {(level: string, msg: string, data?: object) => void} [opts.logger] — optional logger
- * @returns {{
- *   check: Function,
- *   checkRebase: Function,
- *   checkCheckout: Function,
- *   checkCherryPick: Function,
- *   checkReset: Function,
- *   checkStashPop: Function,
- *   checkWorktreeRemove: Function,
- * }}
- */
-export function createGitPreflight(opts = {}) {
-  const { registry, locks, failOpen = true, logger = null } = opts;
-
-  function log(level, msg, data) {
-    if (logger) {
-      try {
-        logger(level, msg, data);
-      } catch {
-        /* logger failure is non-fatal */
-      }
-      return;
-    }
-    if (level === "warn") {
-      console.warn(`[git-preflight] ${msg}`, data ?? "");
-    } else if (level === "error") {
-      console.error(`[git-preflight] ${msg}`, data ?? "");
-    }
-  }
-
-  // ── helpers ──────────────────────────────────────────────
-
-  function safeGetActive() {
-    try {
-      const value = registry?.getActive?.();
-      if (!Array.isArray(value)) return null;
-      return value;
-    } catch (err) {
-      log("warn", "registry.getActive threw", { error: err?.message });
-      return null;
-    }
-  }
-
-  function safeSnapshot() {
-    try {
-      const value = locks?.snapshot?.();
-      if (!Array.isArray(value)) return null;
-      return value;
-    } catch (err) {
-      log("warn", "locks.snapshot threw", { error: err?.message });
-      return null;
-    }
-  }
-
-  function failOpenDecision(reason) {
-    log("warn", "hub unavailable, failing open", { reason });
-    return { allowed: true, reason: "hub_unavailable_fail_open" };
-  }
-
-  function normalizeFiles(list) {
-    if (!Array.isArray(list)) return new Set();
-    return new Set(
-      list
-        .filter((f) => typeof f === "string" && f.length > 0)
-        .map((f) => f.replace(/\\/g, "/")),
-    );
-  }
-
-  function otherActiveSessions(active, sessionId) {
-    return active.filter((s) => s?.sessionId && s.sessionId !== sessionId);
-  }
-
-  function otherLeases(snapshot, workerId) {
-    return snapshot.filter(
-      (entry) => entry?.workerId && entry.workerId !== workerId,
-    );
-  }
-
-  function buildConflict(file, session, holder) {
-    return {
-      file,
-      activeSession: session?.sessionId ?? holder ?? "unknown",
-      activeTask: session?.taskSummary ?? "",
-      ...(holder ? { leaseHolder: holder } : {}),
-    };
-  }
-
-  function recommend(conflicts) {
-    if (!conflicts.length) return "";
-    const first = conflicts[0];
-    const owner = first.leaseHolder || first.activeSession;
-    const task = first.activeTask ? ` Active task: '${first.activeTask}'` : "";
-    return `Wait for '${owner}' to finish, or coordinate via HITL.${task}`;
-  }
-
-  function blockedDecision(op, conflicts, extraReason) {
-    return {
-      allowed: false,
-      reason: extraReason || "overlap_with_active_session",
-      conflicts,
-      recommendation: recommend(conflicts),
-      op,
-    };
-  }
-
-  function allowedDecision() {
-    return { allowed: true };
-  }
-
-  // ── shared scanners ─────────────────────────────────────
-
-  function findDirtyFileConflicts(sessionId, workerId) {
-    const active = safeGetActive();
-    const snapshot = safeSnapshot();
-
-    if (active == null || snapshot == null) {
-      return failOpen ? { fallOpen: true } : { fallOpen: false, conflicts: [] };
-    }
-
-    const conflicts = [];
-    const seen = new Set();
-
-    for (const session of otherActiveSessions(active, sessionId)) {
-      const dirty = normalizeFiles(session.dirtyFiles);
-      for (const file of dirty) {
-        if (seen.has(file)) continue;
-        seen.add(file);
-        conflicts.push(buildConflict(file, session));
-      }
-    }
-
-    for (const lease of otherLeases(snapshot, workerId)) {
-      if (lease.leaseType && lease.leaseType !== "exclusive") continue;
-      const file = typeof lease.file === "string" ? lease.file : null;
-      if (!file || seen.has(file)) continue;
-      seen.add(file);
-      const sessionMeta = lease.sessionMeta || null;
-      conflicts.push(
-        buildConflict(
-          file,
-          sessionMeta
-            ? {
-                sessionId: sessionMeta.sessionId || lease.workerId,
-                taskSummary: sessionMeta.taskSummary || "",
-              }
-            : null,
-          lease.workerId,
-        ),
-      );
-    }
-
-    return { conflicts };
-  }
-
-  function findTargetFileConflicts(targetFiles, sessionId, workerId) {
-    const active = safeGetActive();
-    const snapshot = safeSnapshot();
-
-    if (active == null || snapshot == null) {
-      return failOpen ? { fallOpen: true } : { fallOpen: false, conflicts: [] };
-    }
-
-    const targets = normalizeFiles(targetFiles);
-    if (targets.size === 0) return { conflicts: [] };
-
-    const conflicts = [];
-    const seen = new Set();
-
-    for (const session of otherActiveSessions(active, sessionId)) {
-      const dirty = normalizeFiles(session.dirtyFiles);
-      for (const file of dirty) {
-        if (!targets.has(file) || seen.has(file)) continue;
-        seen.add(file);
-        conflicts.push(buildConflict(file, session));
-      }
-    }
-
-    for (const lease of otherLeases(snapshot, workerId)) {
-      if (lease.leaseType && lease.leaseType !== "exclusive") continue;
-      const file = typeof lease.file === "string" ? lease.file : null;
-      if (!file || !targets.has(file) || seen.has(file)) continue;
-      seen.add(file);
-      const sessionMeta = lease.sessionMeta || null;
-      conflicts.push(
-        buildConflict(
-          file,
-          sessionMeta
-            ? {
-                sessionId: sessionMeta.sessionId || lease.workerId,
-                taskSummary: sessionMeta.taskSummary || "",
-              }
-            : null,
-          lease.workerId,
-        ),
-      );
-    }
-
-    return { conflicts };
-  }
-
-  // ── public API ──────────────────────────────────────────
-
-  /**
-   * Core pre-flight check.
-   *
-   * @param {"checkout"|"rebase"|"cherry-pick"|"reset"|"stash-pop"|"worktree-remove"} op
-   * @param {{ targetFiles?: string[], branch?: string, ref?: string, worktreePath?: string }} args
-   * @param {{ sessionId: string, workerId?: string }} sessionContext
-   * @returns {{ allowed: boolean, reason?: string, conflicts?: object[], recommendation?: string, op?: string }}
-   */
-  function check(op, args = {}, sessionContext = {}) {
-    const sessionId = sessionContext.sessionId || "";
-    const workerId = sessionContext.workerId || sessionId;
-
-    switch (op) {
-      case "checkout":
-      case "rebase":
-      case "reset":
-      case "stash-pop": {
-        const res = findDirtyFileConflicts(sessionId, workerId);
-        if (res.fallOpen) return failOpenDecision(op);
-        if (res.conflicts.length > 0) return blockedDecision(op, res.conflicts);
-        return allowedDecision();
-      }
-      case "cherry-pick": {
-        const targets = Array.isArray(args.targetFiles) ? args.targetFiles : [];
-        const res = findTargetFileConflicts(targets, sessionId, workerId);
-        if (res.fallOpen) return failOpenDecision(op);
-        if (res.conflicts.length > 0) return blockedDecision(op, res.conflicts);
-        return allowedDecision();
-      }
-      case "worktree-remove": {
-        const active = safeGetActive();
-        if (active == null) return failOpenDecision(op);
-        const target =
-          typeof args.worktreePath === "string"
-            ? args.worktreePath.replace(/\\/g, "/")
-            : "";
-        if (!target) return allowedDecision();
-        const conflicts = [];
-        for (const session of otherActiveSessions(active, sessionId)) {
-          const sessionPath =
-            typeof session.worktreePath === "string"
-              ? session.worktreePath.replace(/\\/g, "/")
-              : "";
-          if (sessionPath && sessionPath === target) {
-            conflicts.push({
-              file: target,
-              activeSession: session.sessionId,
-              activeTask: session.taskSummary || "",
-            });
-          }
-        }
-        if (conflicts.length > 0) {
-          return blockedDecision(op, conflicts, "active_worktree");
-        }
-        return allowedDecision();
-      }
-      default:
-        return allowedDecision();
-    }
-  }
-
-  return Object.freeze({
-    check,
-    checkRebase: (args, ctx) => check("rebase", args, ctx),
-    checkCheckout: (args, ctx) => check("checkout", args, ctx),
-    checkCherryPick: (args, ctx) => check("cherry-pick", args, ctx),
-    checkReset: (args, ctx) => check("reset", args, ctx),
-    checkStashPop: (args, ctx) => check("stash-pop", args, ctx),
-    checkWorktreeRemove: (args, ctx) => check("worktree-remove", args, ctx),
-  });
-}