clay-server 4.0.0-beta.8 → 4.0.0

package/lib/public/modules/worker-pane-lock.js

@@ -0,0 +1,176 @@
+// Driver-operated Split Worker surface.
+//
+// A configured Split Worker executes work its Driver delegated, so its pane is
+// an execution surface rather than a chat the person types into. This module
+// takes the composer's footprint away and replaces it with one compact,
+// non-interactive status line.
+//
+// What stays, deliberately: the transcript, streaming status, tool and
+// permission progress, scrolling, and the stop control — the human keeps their
+// emergency brake. What goes: the text input, attachments, send, the composer
+// context row, and any Worker-local permission-mode affordance.
+//
+// The role is read from pair state only (`splitGroups` + the displayed
+// session), which is server-broadcast and therefore correct across reconnect,
+// project switch, session switch, dissolve, replacement and role change. There
+// is no second copy of the role and nothing in localStorage. A plain ad-hoc
+// side-by-side split has no pair roles, so it is never locked and keeps its
+// composer.
+//
+// Accessibility: locked controls are removed from the tab order with `disabled`
+// and `tabindex="-1"`, and the composer region is `aria-hidden` while the
+// status line carries the explanation, so a screen reader is told the pane is
+// Driver-controlled instead of finding focusable inputs that do nothing.
+
+import { store } from './store.js';
+
+var STATUS_ID = "worker-pane-status";
+var LOCK_CLASS = "worker-pane-locked";
+
+// Every interactive composer affordance. Queried lazily: a pane iframe and the
+// main window share this markup, and some ids are mobile-only.
+var LOCKED_CONTROL_IDS = [
+  "input",
+  "send-btn",
+  "attach-file-btn",
+  "attach-image-btn",
+  "input-more-btn",
+  "shell-command-btn",
+  "stt-btn",
+  "schedule-btn",
+  "ask-mate-btn",
+  "context-sources-add",
+  "composer-add-worker-btn",
+  "composer-handoff-btn",
+];
+
+function lockedControls() {
+  var found = [];
+  for (var i = 0; i < LOCKED_CONTROL_IDS.length; i++) {
+    var el = document.getElementById(LOCKED_CONTROL_IDS[i]);
+    if (el) found.push(el);
+  }
+  return found;
+}
+
+// The configured Worker of a live pair, for the session actually on screen.
+// Returns false for an ad-hoc split, for the Driver, and for any ordinary
+// session, so the composer is only ever taken away in the one real case.
+export function isDriverOperatedView(state) {
+  var snapshot = state || store.snap();
+  var sessionId = snapshot.paneMode && snapshot.paneSessionId
+    ? snapshot.paneSessionId
+    : snapshot.activeSessionId;
+  if (!sessionId) return false;
+  var groups = snapshot.splitGroups || [];
+  for (var i = 0; i < groups.length; i++) {
+    var pair = groups[i] && groups[i].pair;
+    if (!pair) continue;
+    if (pair.workerId === sessionId) return true;
+  }
+  return false;
+}
+
+function ensureStatusLine(inputArea) {
+  var existing = document.getElementById(STATUS_ID);
+  if (existing) return existing;
+  var line = document.createElement("div");
+  line.id = STATUS_ID;
+  line.className = "worker-pane-status";
+  // A status region, not a live region: it states a standing condition rather
+  // than announcing a change, so it should not interrupt.
+  line.setAttribute("role", "status");
+  var mark = document.createElement("span");
+  mark.className = "worker-pane-status-mark";
+  mark.setAttribute("aria-hidden", "true");
+  var label = document.createElement("span");
+  label.className = "worker-pane-status-label";
+  label.textContent = "Controlled by Driver";
+  line.appendChild(mark);
+  line.appendChild(label);
+  inputArea.appendChild(line);
+  return line;
+}
+
+function applyLock(locked) {
+  var inputArea = document.getElementById("input-area");
+  var inputWrapper = document.getElementById("input-wrapper");
+  if (!inputArea) return;
+
+  document.body.classList.toggle(LOCK_CLASS, locked);
+
+  if (inputWrapper) {
+    // Hidden from assistive tech as well as sight; the status line speaks for
+    // the region instead.
+    if (locked) inputWrapper.setAttribute("aria-hidden", "true");
+    else inputWrapper.removeAttribute("aria-hidden");
+  }
+
+  var controls = lockedControls();
+  for (var i = 0; i < controls.length; i++) {
+    var el = controls[i];
+    if (locked) {
+      if (el.dataset.workerLockPrev === undefined) {
+        el.dataset.workerLockPrev = el.disabled ? "1" : "0";
+      }
+      el.disabled = true;
+      el.setAttribute("tabindex", "-1");
+    } else if (el.dataset.workerLockPrev !== undefined) {
+      // Restore exactly what was there before the lock, so an independently
+      // disabled send button stays disabled when the pair dissolves.
+      el.disabled = el.dataset.workerLockPrev === "1";
+      el.removeAttribute("tabindex");
+      delete el.dataset.workerLockPrev;
+    }
+  }
+
+  var status = document.getElementById(STATUS_ID);
+  if (locked) {
+    status = ensureStatusLine(inputArea);
+    status.classList.add("visible");
+  } else if (status) {
+    status.classList.remove("visible");
+  }
+}
+
+// Skip permissions and any other Worker-local permission-mode affordance are
+// the Driver's to set, so they are removed from this pane only. The Driver pane
+// and ordinary sessions are untouched.
+function applyPermissionChrome(locked) {
+  var ids = ["skip-perms-pill", "config-chip-wrap"];
+  for (var i = 0; i < ids.length; i++) {
+    var el = document.getElementById(ids[i]);
+    if (!el) continue;
+    if (locked) {
+      if (el.dataset.workerLockHidden === undefined) {
+        el.dataset.workerLockHidden = el.classList.contains("hidden") ? "1" : "0";
+      }
+      el.classList.add("hidden");
+      el.setAttribute("aria-hidden", "true");
+    } else if (el.dataset.workerLockHidden !== undefined) {
+      if (el.dataset.workerLockHidden === "0") el.classList.remove("hidden");
+      el.removeAttribute("aria-hidden");
+      delete el.dataset.workerLockHidden;
+    }
+  }
+}
+
+export function syncWorkerPaneLock(state) {
+  var locked = isDriverOperatedView(state);
+  applyLock(locked);
+  applyPermissionChrome(locked);
+  return locked;
+}
+
+export function initWorkerPaneLock() {
+  syncWorkerPaneLock();
+  // Pair state is the source of truth, so every input that could change the
+  // role re-runs the same resolution: a dissolve, a replacement, a role swap,
+  // switching to another session, or a reconnect that reloads the groups.
+  store.subscribe(function (state, prev) {
+    if (state.splitGroups === prev.splitGroups
+      && state.activeSessionId === prev.activeSessionId
+      && state.paneSessionId === prev.paneSessionId) return;
+    syncWorkerPaneLock(state);
+  });
+}

package/lib/public/modules/worker-proposal-state.js

@@ -0,0 +1,16 @@
+export function workerProposalSelection(msg) {
+  var hasSelection = typeof msg.selectedVendor === "string" ||
+    typeof msg.selectedModel === "string" || typeof msg.selectedEffort === "string";
+  return {
+    selected: hasSelection,
+    vendor: hasSelection ? (msg.selectedVendor || "") : (msg.recommendedVendor || ""),
+    model: hasSelection ? (msg.selectedModel || "") : (msg.recommendedModel || ""),
+    effort: hasSelection ? (msg.selectedEffort || "") : (msg.recommendedEffort || "medium"),
+  };
+}
+
+export function syncWorkerProposalSelection(msg, sync) {
+  var selection = workerProposalSelection(msg);
+  if (selection.selected && typeof sync === "function") sync(selection);
+  return selection;
+}

package/lib/public/modules/worker-proposal.js

@@ -2,6 +2,7 @@ import { getWs } from './ws-ref.js';
 import { addToMessages, scrollToBottom, VENDOR_AVATARS, VENDOR_NAMES } from './app-rendering.js';
 import { effortLevelsFor, effortDisplayName } from './app-panels.js';
 import { iconHtml, refreshIcons } from './icons.js';
+import { workerProposalSelection, syncWorkerProposalSelection } from './worker-proposal-state.js';
 
 function optionValue(entry) {
   if (typeof entry === "string") return entry;
@@ -27,7 +28,7 @@ function planSteps(plan) {
   }).filter(Boolean).slice(0, 8);
 }
 
-function buildVendorSelect(msg) {
+function buildVendorSelect(msg, preferred) {
   var select = document.createElement("select");
   select.className = "worker-proposal-select worker-proposal-vendor";
   var installed = (msg.options && msg.options.installedVendors) || [];
@@ -37,7 +38,7 @@ function buildVendorSelect(msg) {
     option.textContent = VENDOR_NAMES[installed[i]] || installed[i];
     select.appendChild(option);
   }
-  if (installed.indexOf(msg.recommendedVendor) !== -1) select.value = msg.recommendedVendor;
+  if (installed.indexOf(preferred) !== -1) select.value = preferred;
   return select;
 }
 
@@ -98,29 +99,38 @@ function statusLabel(status) {
   if (status === "interrupted") return "Interrupted";
   if (status === "declined") return "Continuing here";
   if (status === "error") return "Needs attention";
-  return "Suggested by Fable";
+  return "Awaiting your choice";
+}
+
+function decisionLabel(status, autoAccepted) {
+  if (autoAccepted) return "Driver recommendation auto-accepted under Full auto";
+  if (status === "pending") return "Runtime choice remains with you";
+  if (status === "declined") return "Runtime proposal declined by user";
+  return "Runtime configuration accepted by user";
 }
 
 function applyState(card, msg) {
   var status = msg.status || "pending";
   card.dataset.status = status;
-  if (msg.autoApproved) card.dataset.autoApproved = "true";
-  var autoApproved = card.dataset.autoApproved === "true";
+  if (msg.autoAccepted || msg.autoApproved) card.dataset.autoAccepted = "true";
+  if (msg.autoAccepted === false || msg.autoApproved === false) card.dataset.autoAccepted = "false";
+  var autoAccepted = card.dataset.autoAccepted === "true";
+  syncWorkerProposalSelection(msg, card._syncWorkerProposalSelection);
   var badge = card.querySelector(".worker-proposal-status");
-  if (badge) badge.textContent = statusLabel(status) + (autoApproved ? " · auto-approved" : "");
+  if (badge) badge.textContent = statusLabel(status) + (autoAccepted ? " · auto-accepted" : "");
+  var decision = card.querySelector(".worker-proposal-decision");
+  if (decision) {
+    decision.textContent = decisionLabel(status, autoAccepted);
+    decision.classList.toggle("automatic", autoAccepted);
+  }
   var error = card.querySelector(".worker-proposal-error");
   if (error) {
     error.textContent = msg.error || "";
     error.classList.toggle("hidden", !msg.error);
   }
-  var preview = card.querySelector(".worker-proposal-result");
-  if (preview && msg.resultPreview) {
-    preview.textContent = msg.resultPreview;
-    preview.classList.remove("hidden");
-  }
   setControlsDisabled(card, status !== "pending");
   var actions = card.querySelector(".worker-proposal-actions");
-  if (actions) actions.classList.toggle("hidden", autoApproved);
+  if (actions) actions.classList.toggle("hidden", autoAccepted);
 }
 
 function sendDecision(card, accepted) {
@@ -150,10 +160,12 @@ export function renderWorkerProposal(msg) {
   card.className = "worker-proposal-card";
   card.dataset.proposalId = msg.proposalId;
   card.dataset.status = msg.status || "pending";
+  var runtimeSelection = workerProposalSelection(msg);
 
   var header = document.createElement("div");
   header.className = "worker-proposal-header";
-  header.innerHTML = '<div class="worker-proposal-mark">' + iconHtml("git-branch") + '</div><div class="worker-proposal-heading"><span class="worker-proposal-kicker">DRIVER / WORKER</span><strong>Let a Worker handle the execution</strong></div><span class="worker-proposal-status"></span>';
+  var replacing = msg.action === "replace";
+  header.innerHTML = '<div class="worker-proposal-mark">' + iconHtml("git-branch") + '</div><div class="worker-proposal-heading"><span class="worker-proposal-kicker">DRIVER / SPLIT WORKER</span><strong>' + (replacing ? "Configure a replacement Split Worker" : "Configure a Split Worker") + '</strong></div><span class="worker-proposal-status"></span>';
   card.appendChild(header);
 
   var summary = document.createElement("p");
@@ -173,12 +185,24 @@ export function renderWorkerProposal(msg) {
     card.appendChild(plan);
   }
 
+  if (msg.recommendationRationale) {
+    var rationale = document.createElement("div");
+    rationale.className = "worker-proposal-rationale";
+    var rationaleLabel = document.createElement("span");
+    rationaleLabel.textContent = "Driver's recommendation rationale";
+    var rationaleText = document.createElement("p");
+    rationaleText.textContent = msg.recommendationRationale;
+    rationale.appendChild(rationaleLabel);
+    rationale.appendChild(rationaleText);
+    card.appendChild(rationale);
+  }
+
   var config = document.createElement("div");
   config.className = "worker-proposal-config";
   var vendorField = document.createElement("label");
   vendorField.className = "worker-proposal-field worker-proposal-vendor-field";
   vendorField.innerHTML = '<span>Worker</span><span class="worker-proposal-vendor-control"><img alt=""></span>';
-  var vendorSelect = buildVendorSelect(msg);
+  var vendorSelect = buildVendorSelect(msg, runtimeSelection.vendor);
   vendorField.querySelector(".worker-proposal-vendor-control").appendChild(vendorSelect);
   config.appendChild(vendorField);
   var modelField = document.createElement("label");
@@ -194,6 +218,10 @@ export function renderWorkerProposal(msg) {
   config.appendChild(effortField);
   card.appendChild(config);
 
+  var decision = document.createElement("div");
+  decision.className = "worker-proposal-decision";
+  card.appendChild(decision);
+
   function syncVendor(preferredModel, preferredEffort) {
     var vendor = vendorSelect.value;
     var avatar = vendorField.querySelector("img");
@@ -201,31 +229,32 @@ export function renderWorkerProposal(msg) {
     fillModels(modelSelect, vendor, msg, preferredModel);
     fillEffort(card, vendor, modelSelect.value, msg, preferredEffort);
   }
+  card._syncWorkerProposalSelection = function (selection) {
+    if (selection.vendor && vendorSelect.value !== selection.vendor) vendorSelect.value = selection.vendor;
+    syncVendor(selection.model, selection.effort);
+  };
   vendorSelect.addEventListener("change", function () { syncVendor("", "medium"); });
   modelSelect.addEventListener("change", function () {
     var active = card.querySelector(".worker-proposal-effort-btn.active");
     fillEffort(card, vendorSelect.value, modelSelect.value, msg, active ? active.dataset.effort : "medium");
   });
-  syncVendor(msg.recommendedModel || "", msg.recommendedEffort || "medium");
+  syncVendor(runtimeSelection.model, runtimeSelection.effort);
 
   var error = document.createElement("div");
   error.className = "worker-proposal-error hidden";
   card.appendChild(error);
-  var result = document.createElement("div");
-  result.className = "worker-proposal-result hidden";
-  card.appendChild(result);
 
   var actions = document.createElement("div");
   actions.className = "worker-proposal-actions";
   var decline = document.createElement("button");
   decline.type = "button";
   decline.className = "worker-proposal-action secondary";
-  decline.textContent = "Continue here";
+  decline.textContent = replacing ? "Keep current Worker" : "Continue here";
   decline.addEventListener("click", function () { sendDecision(card, false); });
   var accept = document.createElement("button");
   accept.type = "button";
   accept.className = "worker-proposal-action primary";
-  accept.innerHTML = iconHtml("panel-right-open") + "<span>Run with Split Worker</span>";
+  accept.innerHTML = iconHtml("panel-right-open") + "<span>" + (replacing ? "Replace Split Worker" : "Run with Split Worker") + "</span>";
   accept.addEventListener("click", function () { sendDecision(card, true); });
   actions.appendChild(decline);
   actions.appendChild(accept);

package/lib/public/style.css

@@ -14,6 +14,7 @@
 @import url("css/input.css?v=20260828-composer-depth1");
 @import url("css/filebrowser.css?v=20260829-terminal-canvas1");
 @import url("css/git-panel.css");
+@import url("css/git-placard.css");
 @import url("css/diff.css");
 @import url("css/highlight.css");
 @import url("css/server-settings.css");
@@ -22,6 +23,7 @@
 @import url("css/mobile-nav.css?v=20260407");
 @import url("css/loop.css");
 @import url("css/scheduler.css");
+@import url("css/project-logs.css");
 @import url("css/scheduler-modal.css");
 @import url("css/home-hub.css");
 @import url("css/home-sidebar.css");
@@ -39,7 +41,7 @@
 @import url("css/session-search.css");
 @import url("css/tooltip.css");
 @import url("css/mates.css?v=20260407");
-@import url("css/command-palette.css?v=20260901-clay-chat2");
+@import url("css/command-palette.css?v=20260908-log-links2");
 @import url("css/mention.css");
 @import url("css/debate.css");
 @import url("css/home-debate-planning.css");

package/lib/sdk-bridge.js

@@ -12,6 +12,7 @@ var { createMessageQueue } = require("./sdk-message-queue");
 var { attachMessageProcessor } = require("./sdk-message-processor");
 var homeDebateToolPolicy = require("./home-debate-tool-policy");
 var yoke = require("./yoke");
+var sessionTitlePolicy = require("./session-title-policy");
 
 // Extract serializable tool descriptors from MCP server instances.
 // Used for IPC to worker processes (McpSdkServerConfigWithInstance is not serializable).
@@ -128,6 +129,9 @@ function createSDKBridge(opts) {
   var clayTls = opts.clayTls || false;
   var clayAuthToken = opts.clayAuthToken || null;
   var getSessionToolDefs = opts.getSessionToolDefs || function () { return []; };
+  // Split Worker permission routing. A getter because the pair module is
+  // constructed before this bridge exists.
+  var getWorkerPermissionRouter = opts.getWorkerPermissionRouter || function () { return null; };
   var onProcessingChanged = opts.onProcessingChanged || function () {};
   var _cachedFreshAuthState = null;
   var _cachedFreshAuthAt = 0;
@@ -601,27 +605,77 @@ function createSDKBridge(opts) {
       return { behavior: "allow", updatedInput: input };
     }
 
-    // Auto-approve split-pair partner tools. The pair itself is
-    // user-constructed (the user created the split and its roles and
-    // watches both panes live), the target is structurally confined to the
-    // split partner, and a prompt on every delegation hop defeats the
-    // driver/worker workflow. spawn_sessions is NOT here: it creates new
-    // sessions and keeps its prompt.
-    var pairPartnerTools = { send_to_partner: true, read_partner: true, propose_worker: true };
-    if (toolName.indexOf("mcp__clay-sessions__") === 0) {
-      var sessionsToolName = toolName.substring(toolName.lastIndexOf("__") + 2);
-      if (pairPartnerTools[sessionsToolName]) {
+    // Auto-approve the non-mutating configuration proposal and the visible
+    // Driver/Split Worker pair tools, including the Driver's answer to a Worker
+    // permission request. Creation and replacement still require a separate
+    // human decision in the proposal card; skip-permissions is never treated as
+    // that product choice. Every handler is confined to the caller's exact
+    // session/pair and re-checks eligibility, ownership and live identity.
+    //
+    // spawn_sessions is deliberately absent: it creates arbitrary sessions.
+    //
+    // Only the two name forms the bridge can genuinely emit are accepted:
+    //
+    //   mcp__clay-sessions__<tool>  every MCP-mounted vendor. The server
+    //                              segment is matched exactly, so a tool of
+    //                              the same name on another MCP server is
+    //                              never auto-approved.
+    //   <tool>                      a Codex dynamic tool. Codex canonicalizes
+    //                              send_to_partner and read_partner to the MCP
+    //                              form itself, so only the remaining names
+    //                              can legitimately arrive bare.
+    var PAIR_MCP_PREFIX = "mcp__clay-sessions__";
+    var pairMcpTools = {
+      propose_worker: true,
+      send_to_partner: true,
+      read_partner: true,
+      partner_status: true,
+      replace_partner: true,
+      interrupt_partner: true,
+      close_partner: true,
+      record_partner_evaluation: true,
+      respond_to_worker_permission: true,
+    };
+    var pairDynamicTools = {
+      propose_worker: true,
+      partner_status: true,
+      replace_partner: true,
+      interrupt_partner: true,
+      close_partner: true,
+      record_partner_evaluation: true,
+      respond_to_worker_permission: true,
+    };
+    if (toolName.indexOf("mcp__") === 0) {
+      if (toolName.indexOf(PAIR_MCP_PREFIX) === 0
+          && pairMcpTools[toolName.slice(PAIR_MCP_PREFIX.length)]) {
         return { behavior: "allow", updatedInput: input };
       }
+    } else if (pairDynamicTools[toolName]) {
+      return { behavior: "allow", updatedInput: input };
+    }
+
+    // Sticky-note operations are immediately visible and reversible on the
+    // shared board. The exact session-bound handlers still enforce ownership,
+    // lifecycle rules, and input validation, so a provider prompt adds no
+    // authority. Keep this confined to the exact Clay Notes namespace.
+    var NOTES_MCP_PREFIX = "mcp__clay-notes__";
+    var notesTools = {
+      list_notes: true,
+      write_note: true,
+      close_note: true,
+      reopen_note: true,
+      remove_note: true,
+    };
+    if (toolName.indexOf(NOTES_MCP_PREFIX) === 0
+        && notesTools[toolName.slice(NOTES_MCP_PREFIX.length)]) {
+      return { behavior: "allow", updatedInput: input };
     }
 
-    // Sticky-note reads and writes are immediately visible on the shared
-    // board. Deletion stays outside the whitelist and therefore prompts;
-    // its session ownership is enforced again inside the server handler.
-    var notesToolName = toolName.substring(toolName.lastIndexOf("__") + 2);
-    var isClayNotesTool = toolName.indexOf("mcp__clay-notes__") === 0
-      || toolName.indexOf("clay-notes__") !== -1;
-    if (isClayNotesTool && (notesToolName === "list_notes" || notesToolName === "write_note")) {
+    // Project Logs are exact-session, project-bound tools whose authority is
+    // enforced again by the server binding. Canonical changes are append-only
+    // revisions, and the surface exposes no destructive delete operation, so
+    // a second provider permission prompt adds no additional safety.
+    if (toolName.indexOf("mcp__clay-logs__") === 0) {
       return { behavior: "allow", updatedInput: input };
     }
 
@@ -720,6 +774,19 @@ function createSDKBridge(opts) {
     // Full-auto mode: auto-approve everything except AskUserQuestion
     // (which still needs to go through the user interaction flow).
     var clayPermissionMode = session.permissionMode || sm.currentPermissionMode;
+    // A configured Split Worker is Driver-operated, so it runs under its
+    // Driver's permission mode, re-resolved from the live pair on every single
+    // decision. Nothing is copied at creation and the Worker's own persisted
+    // setting is never written, so toggling skip permissions on the Driver
+    // applies to the Worker's next call in either direction, mid-turn included.
+    var _wpMode = getWorkerPermissionRouter();
+    if (_wpMode && typeof _wpMode.inheritedPermissionMode === "function") {
+      var inherited = _wpMode.inheritedPermissionMode(session);
+      if (inherited) clayPermissionMode = inherited;
+    }
+    // AskUserQuestion is genuine user input, not an authorization, so it is
+    // excluded here exactly as it always was: a Driver in skip mode still
+    // cannot silently answer a question addressed to the person.
     if (clayPermissionMode === "bypassPermissions" && toolName !== "AskUserQuestion") {
       return Promise.resolve({ behavior: "allow", updatedInput: input });
     }
@@ -747,6 +814,22 @@ function createSDKBridge(opts) {
       return Promise.resolve({ behavior: "allow", updatedInput: input });
     }
 
+    // A visible Split Worker's remaining prompts belong to its paired Driver,
+    // not to the Worker pane. This sits below every auto-decision above, so
+    // skip permissions, the whitelist, allowedTools and the loop/debate
+    // policies all still resolve first and never wait on a Driver.
+    var _wp = getWorkerPermissionRouter();
+    if (_wp) {
+      var routed = _wp.routeIfWorker(session, {
+        toolName: toolName,
+        input: input,
+        toolUseId: opts.toolUseID,
+        decisionReason: opts.decisionReason || "",
+        signal: opts.signal,
+      });
+      if (routed) return routed;
+    }
+
     // Regular tool permission request: send to client and wait
     return new Promise(function(resolve) {
       var requestId = crypto.randomUUID();
@@ -1540,25 +1623,33 @@ function createSDKBridge(opts) {
     if (selectedUserInputMode === "fallback") {
       sessionToolDefs = sessionToolDefs.concat(yoke.userInput.fallbackToolDefs(sessionUserInputHandler));
     }
+    function findSessionToolDef(toolName) {
+      // Codex restores a thread's original dynamic-tool catalog on resume, but
+      // pair state can change after this query starts. Resolve live session
+      // handlers first so the dispatcher cannot lag behind that catalog. Keep
+      // the query snapshot as a fallback for query-bound tools such as the
+      // structured-input fallback, whose handler exists only for this turn.
+      var liveToolDefs = getSessionToolDefs(session) || [];
+      for (var liveIndex = 0; liveIndex < liveToolDefs.length; liveIndex++) {
+        if (liveToolDefs[liveIndex].name === toolName) return liveToolDefs[liveIndex];
+      }
+      for (var snapshotIndex = 0; snapshotIndex < sessionToolDefs.length; snapshotIndex++) {
+        if (sessionToolDefs[snapshotIndex].name === toolName) return sessionToolDefs[snapshotIndex];
+      }
+      return null;
+    }
 
-    // Derive an explicit session title for fresh queries so the SDK records
-    // it at session creation and skips its own auto-generation. This also
-    // lets us short-circuit autoGenerateTitle below for the common case.
+    // Give fresh queries an immediate provisional label. The visible user
+    // message in history wins over `text`, which may contain an internal
+    // provider wrapper rather than what the person typed.
     // Only applied to NEW sessions (no cliSessionId yet) — when resuming,
     // the SDK ignores Options.title in favor of the persisted title.
     var initialTitle = null;
+    var initialTitleProvisional = false;
     if (!session.cliSessionId && !session.titleManuallySet && !session.titleAutoGenerated) {
-      if (session.title) {
-        // Loop / scheduled / mate-seeded sessions arrive with a title already set.
-        initialTitle = session.title;
-      } else if (typeof text === "string") {
-        // Derive a quick first-line snippet from the user's first message.
-        // Skip if too short to be meaningful — fall back to autoGenerateTitle.
-        var firstLine = text.replace(/\s+/g, " ").trim();
-        if (firstLine.length >= 10) {
-          initialTitle = firstLine.length > 60 ? firstLine.substring(0, 60) : firstLine;
-        }
-      }
+      var initialTitleChoice = sessionTitlePolicy.selectInitialTitle(session, text);
+      initialTitle = initialTitleChoice.title;
+      initialTitleProvisional = initialTitleChoice.provisional;
     }
 
     var queryOpts = {
@@ -1587,10 +1678,9 @@ function createSDKBridge(opts) {
       toolServerDescriptors: extractMcpDescriptors(mergedMcpServers) || undefined,
       dynamicTools: sessionToolDefs,
       callDynamicTool: function (toolName, args) {
-        for (var dti = 0; dti < sessionToolDefs.length; dti++) {
-          if (sessionToolDefs[dti].name === toolName && typeof sessionToolDefs[dti].handler === "function") {
-            return sessionToolDefs[dti].handler(args || {});
-          }
+        var toolDef = findSessionToolDef(toolName);
+        if (toolDef && typeof toolDef.handler === "function") {
+          return toolDef.handler(args || {});
         }
         return Promise.reject(new Error("Session tool not found: " + toolName));
       },
@@ -1598,12 +1688,8 @@ function createSDKBridge(opts) {
       abortController: linuxUser ? undefined : session.abortController,
       canUseTool: function(toolName, input, toolOpts) {
         var permissionName = toolName;
-        for (var pti = 0; pti < sessionToolDefs.length; pti++) {
-          if (sessionToolDefs[pti].name === toolName && sessionToolDefs[pti].permissionName) {
-            permissionName = sessionToolDefs[pti].permissionName;
-            break;
-          }
-        }
+        var permissionToolDef = findSessionToolDef(toolName);
+        if (permissionToolDef && permissionToolDef.permissionName) permissionName = permissionToolDef.permissionName;
         return handleCanUseTool(session, permissionName, input, toolOpts);
       },
       onUserInputRequest: function(request, respond) {
@@ -1653,16 +1739,16 @@ function createSDKBridge(opts) {
     try {
       handle = await sessionAdapter.createQuery(queryOpts);
       console.log("[sdk-bridge] createQuery returned handle, vendor=" + sessionAdapter.vendor);
-      // SDK accepted the explicit title — adopt it locally so the session
-      // list reflects it immediately and autoGenerateTitle skips this
-      // session (titleAutoGenerated gates re-trigger).
+      // SDK accepted the explicit title. Provisional labels remain eligible
+      // for semantic generation after the first Home exchange (or the normal
+      // project threshold); seeded titles remain fixed.
       if (initialTitle && !session.title) {
         session.title = initialTitle;
-        session.titleAutoGenerated = true;
+        session.titleAutoGenerated = !initialTitleProvisional;
         sm.saveSessionFile(session);
         sm.broadcastSessionList();
       } else if (initialTitle && session.title === initialTitle) {
-        session.titleAutoGenerated = true;
+        session.titleAutoGenerated = !initialTitleProvisional;
         sm.saveSessionFile(session);
       }
     } catch (e) {
@@ -2035,6 +2121,7 @@ function createSDKBridge(opts) {
       // No active query — just store the model for next startQuery
       session.model = model;
       sm.saveSessionFile(session);
+      sm.broadcastSessionList();
       sm.defaultModelByVendor = sm.defaultModelByVendor || {};
       // Confirm against the session vendor so a non-default vendor does not
       // receive model metadata labeled as the project's default adapter.
@@ -2048,6 +2135,7 @@ function createSDKBridge(opts) {
       await session.queryInstance.setModel(model);
       session.model = model;
       sm.saveSessionFile(session);
+      sm.broadcastSessionList();
       sm.defaultModelByVendor = sm.defaultModelByVendor || {};
       var sessionVendor = session.vendor || (adapter && adapter.vendor) || "claude";
       sm.defaultModelByVendor[sessionVendor] = model;
@@ -2070,6 +2158,7 @@ function createSDKBridge(opts) {
     sm.currentEffortByVendor[effortVendor] = clamped;
     session.effort = clamped;
     sm.saveSessionFile(session);
+    sm.broadcastSessionList();
     sm.currentEffort = clamped;
     if (!session.queryInstance) {
       return clamped;