@yeaft/webchat-agent 0.1.854 → 0.1.856

package/{unify → yeaft}/web-bridge.js

@@ -1,5 +1,5 @@
 /**
- * web-bridge.js — Bridge between web UI and Yeaft Unify Engine.
+ * web-bridge.js — Bridge between web UI and Yeaft Yeaft Engine.
  *
  * PR #797: group VP runtime is threaded again. Each group VP can own multiple
  * classified threads, keyed by (groupId, vpId, threadId), with separate engine,
@@ -52,7 +52,7 @@ import { seedDefaultGroup } from './groups/seed-default.js';
 import {
   trimSnapshotForBudget,
 } from './history-compact.js';
-import { persistUnifyAttachments, attachmentsForPersistence, persistedAttachmentPreviewPayload } from './attachments.js';
+import { persistYeaftAttachments, attachmentsForPersistence, persistedAttachmentPreviewPayload } from './attachments.js';
 import { parseSeqFromId } from './conversation/persist.js';
 import { sliceLastNTurns } from './turn-utils.js';
 import { createVpStatusBroker } from './vp-status-broker.js';
@@ -70,7 +70,7 @@ export function __testSetThreadClassifier(fn) {
 
 /**
  * Tracks scoped-dream triggers that are currently inflight, keyed by
- * groupId. Used by `handleUnifyDreamTrigger` to reject any overlapping
+ * groupId. Used by `handleYeaftDreamTrigger` to reject any overlapping
  * scoped trigger rather than racing the sink-wrapping logic against
  * itself.
  *
@@ -103,8 +103,8 @@ let currentAbortCtrl = null;
 /**
  * Per-VP-turn AbortControllers. Maps `turnId` → `AbortController`.
  * Each VP-turn in a fan-out gets its own controller so it can be stopped
- * independently (per-VP Stop button). `handleUnifyAbortTurn` looks up by
- * turnId to abort a single VP. `handleUnifyAbortAll` iterates and aborts all.
+ * independently (per-VP Stop button). `handleYeaftAbortTurn` looks up by
+ * turnId to abort a single VP. `handleYeaftAbortAll` iterates and aborts all.
  * @type {Map<string, AbortController>}
  */
 const turnAbortCtrls = new Map();
@@ -118,7 +118,7 @@ const turnAbortMeta = new Map();
 
 /**
  * Per-VP status broker — the agent-side authority for VP timeline
- * status. Lazy-initialized on first use because `sendUnifyEvent` is
+ * status. Lazy-initialized on first use because `sendYeaftEvent` is
  * declared below; trying to call it at module top-level would crash
  * with a TDZ error during agent boot.
  *
@@ -134,8 +134,8 @@ function getVpStatusBroker() {
     vpStatusBroker = createVpStatusBroker({
       send: (event) => {
         // The broker emits both `vp_status_changed` and
-        // `vp_status_snapshot`. Both ride the standard sendUnifyEvent
-        // envelope so the frontend's existing unify_output dispatcher
+        // `vp_status_snapshot`. Both ride the standard sendYeaftEvent
+        // envelope so the frontend's existing yeaft_output dispatcher
         // sees them. We stamp groupId/vpId on the envelope for
         // events that target a specific VP so the server's per-client
         // routing (groupId scoping, etc.) works the same way as
@@ -146,7 +146,7 @@ function getVpStatusBroker() {
           if (event.vpId) env.vpId = event.vpId;
           if (event.turnId) env.turnId = event.turnId;
         }
-        sendUnifyEvent(event, env);
+        sendYeaftEvent(event, env);
       },
     });
   }
@@ -202,7 +202,7 @@ const vpAborts = new Map();
 const vpCurrentTodos = new Map();
 /**
  * Per-group cached coordinator + router. Created on first
- * `handleUnifyGroupChat` for a given groupId; reused across user messages
+ * `handleYeaftGroupChat` for a given groupId; reused across user messages
  * AND across `route_forward` deliveries inside running VP turns (the
  * router is wired into engine ctx; if we recreated coord per turn the
  * route_forward path would deliver into a freshly-created `captured[]`
@@ -213,9 +213,9 @@ const vpCurrentTodos = new Map();
  *     handler that mutates roster / meta / lifecycle state on disk
  *     (rename, update announcement, archive, delete, add/remove member,
  *     set default VP).
- *   - `handleUnifyGroupChat` — invalidates inline when its own
+ *   - `handleYeaftGroupChat` — invalidates inline when its own
  *     auto-add / default-VP-heal pass mutated the roster.
- *   - `resetUnifySession` and `__testResetVpState` clear the whole map.
+ *   - `resetYeaftSession` and `__testResetVpState` clear the whole map.
  *
  * @type {Map<string, { coord: ReturnType<typeof createCoordinator>,
  *                     router: ReturnType<typeof createRouter>,
@@ -383,7 +383,7 @@ function invalidateGroupContext(groupId) {
   // Engines are NOT torn down here on purpose. They hold subordinate
   // state (AMS adjustments) that should survive a meta change and a
   // closed groupHandle — they don't reach the on-disk group meta
-  // directly. They *are* dropped on `resetUnifySession`.
+  // directly. They *are* dropped on `resetYeaftSession`.
 }
 
 /**
@@ -449,8 +449,8 @@ const QUERY_TIMEOUT_MS = 120_000;
  */
 const ESCALATE_AFTER_ABORT_MS = 15_000;
 
-/** Virtual conversationId for the Unify session */
-let unifyConversationId = null;
+/** Virtual conversationId for the Yeaft session */
+let yeaftConversationId = null;
 
 /** task-334-followup-batch-b: stored unsubscribe fn from VP subscribe,
  *  called on session reset to prevent stale subscriber leaks. */
@@ -624,7 +624,7 @@ function loadVisibleGroupHistoryPage(store, groupId, limit, beforeSeq = null) {
       rows = store.loadRecentByGroup(groupId, Infinity);
     }
   } catch (err) {
-    console.error('[Unify] visible history page load failed:', err?.message || err);
+    console.error('[Yeaft] visible history page load failed:', err?.message || err);
     return { messages: [], oldestSeq: null, hasMore: false };
   }
 
@@ -660,7 +660,7 @@ function hydrateGroupHistory(groupId) {
   try {
     recent = session.conversationStore.loadRecentByGroup(groupId);
   } catch (err) {
-    console.warn('[Unify] hydrateGroupHistory failed (groupId=%s):', groupId, err?.message || err);
+    console.warn('[Yeaft] hydrateGroupHistory failed (groupId=%s):', groupId, err?.message || err);
     return [];
   }
   const out = [];
@@ -852,7 +852,7 @@ function getOrCreateVpEngine(groupId, vpId, threadId = 'main') {
     mcpManager: session.mcpManager,
     yeaftDir: session.yeaftDir,
     // Share the session-shared ToolUsageStats so per-VP tool calls land
-    // in the same on-disk snapshot the `unify_fetch_tool_stats` handler
+    // in the same on-disk snapshot the `yeaft_fetch_tool_stats` handler
     // reads. Without this, engine's record-on-tool-exec guard
     // (`if (this.#toolStats && ...)`) is false and group VP tool calls
     // are silently dropped.
@@ -873,7 +873,7 @@ function getOrCreateVpEngine(groupId, vpId, threadId = 'main') {
  *
  * The coordinator MUST be reused across user turns AND across in-flight
  * tool calls (route_forward) — its `deliver` callback is the only way
- * envelopes reach `vpInboxes`. If we recreated it per `handleUnifyGroupChat`
+ * envelopes reach `vpInboxes`. If we recreated it per `handleYeaftGroupChat`
  * call (the pre-707 design), `route_forward` running mid-turn would
  * deliver into a doomed `captured[]` while the new dispatch ran against
  * a fresh coordinator. The persistent coordinator + module-level inboxes
@@ -984,7 +984,7 @@ async function routeEnvelopeToVpThread(groupId, vpId, envelope) {
     });
     thread.updatedAt = Date.now();
     try {
-      sendUnifyEvent({
+      sendYeaftEvent({
         type: 'vp_thread_user_appended',
         groupId,
         vpId,
@@ -1006,7 +1006,7 @@ async function routeEnvelopeToVpThread(groupId, vpId, envelope) {
   inbox.push({ envelope, turnId, thread });
 
   try {
-    sendUnifyEvent({
+    sendYeaftEvent({
       type: 'vp_typing_start',
       groupId,
       vpId,
@@ -1028,7 +1028,7 @@ async function routeEnvelopeToVpThread(groupId, vpId, envelope) {
       messageCount: thread.messageIds.length,
     });
   } catch (err) {
-    console.warn('[Unify] vp-status typing transition failed:', err?.message || err);
+    console.warn('[Yeaft] vp-status typing transition failed:', err?.message || err);
   }
 
   ensureDriverRunning(groupId, vpId, thread.threadId);
@@ -1085,13 +1085,13 @@ function ensureDriverRunning(groupId, vpId, threadId = 'main') {
           baseSnapshot,
         });
       } catch (err) {
-        console.warn('[Unify] driveVp: runVpTurn failed', vpId, err?.message || err);
+        console.warn('[Yeaft] driveVp: runVpTurn failed', vpId, err?.message || err);
       } finally {
         turnAbortCtrls.delete(turnId);
         turnAbortMeta.delete(turnId);
         if (vpAborts.get(key) === vpAbort) vpAborts.delete(key);
         try {
-          sendUnifyEvent({
+          sendYeaftEvent({
             type: 'vp_typing_end',
             groupId,
             vpId,
@@ -1103,7 +1103,7 @@ function ensureDriverRunning(groupId, vpId, threadId = 'main') {
       }
       try {
         if (text && envelope?.msg) {
-          sendUnifyEvent({
+          sendYeaftEvent({
             type: 'group_message',
             groupId,
             vpId,
@@ -1168,10 +1168,10 @@ function ensureDriverRunning(groupId, vpId, threadId = 'main') {
               messageCount: thread.messageIds.length,
             });
           } catch (err) {
-            console.warn('[Unify] vp-status typing transition (rescue) failed:', err?.message || err);
+            console.warn('[Yeaft] vp-status typing transition (rescue) failed:', err?.message || err);
           }
           try {
-            sendUnifyEvent({
+            sendYeaftEvent({
               type: 'vp_typing_start',
               groupId,
               vpId,
@@ -1239,7 +1239,7 @@ export async function __testResetVpState() {
 
 
 /**
- * Send a unify_output message carrying claude_output-format data.
+ * Send a yeaft_output message carrying claude_output-format data.
  * Envelope fields: conversationId, groupId, vpId, turnId, threadId let the
  * frontend route incremental deltas to the correct per-VP/thread block.
  */
@@ -1254,11 +1254,11 @@ function resolveGroupDefaultVpId(groupId) {
   }
 }
 
-function sendUnifyOutput(data, { groupId, vpId, turnId, threadId } = {}) {
+function sendYeaftOutput(data, { groupId, vpId, turnId, threadId } = {}) {
   const resolvedVpId = vpId || resolveGroupDefaultVpId(groupId);
   sendToServer({
-    type: 'unify_output',
-    conversationId: unifyConversationId,
+    type: 'yeaft_output',
+    conversationId: yeaftConversationId,
     ...(groupId ? { groupId } : {}),
     ...(resolvedVpId ? { vpId: resolvedVpId } : {}),
     ...(turnId ? { turnId } : {}),
@@ -1267,11 +1267,11 @@ function sendUnifyOutput(data, { groupId, vpId, turnId, threadId } = {}) {
   });
 }
 
-/** Send a unify_output event (non-claude_output metadata). */
-function sendUnifyEvent(event, { groupId, vpId, turnId, threadId } = {}) {
+/** Send a yeaft_output event (non-claude_output metadata). */
+function sendYeaftEvent(event, { groupId, vpId, turnId, threadId } = {}) {
   sendToServer({
-    type: 'unify_output',
-    conversationId: unifyConversationId,
+    type: 'yeaft_output',
+    conversationId: yeaftConversationId,
     ...(groupId ? { groupId } : {}),
     ...(vpId ? { vpId } : {}),
     ...(turnId ? { turnId } : {}),
@@ -1290,14 +1290,14 @@ function configuredVpPaths() {
   };
 }
 
-export function handleUnifyVpSubscribe(_msg) {
+export function handleYeaftVpSubscribe(_msg) {
   if (_vpUnsubscribe) {
     try { _vpUnsubscribe(); } catch { /* ignore */ }
     _vpUnsubscribe = null;
   }
   const { libDir } = configuredVpPaths();
   _vpUnsubscribe = handleVpSubscribe(
-    sendUnifyEvent,
+    sendYeaftEvent,
     undefined,
     libDir ? { dir: libDir } : {},
   );
@@ -1307,10 +1307,10 @@ export function handleUnifyVpSubscribe(_msg) {
  * VP CRUD from the web client. See historic doc for full message shapes.
  */
 function sendVpCrudResult(payload) {
-  sendUnifyEvent({ type: 'vp_crud_result', ...payload });
+  sendYeaftEvent({ type: 'vp_crud_result', ...payload });
 }
 
-export function handleUnifyVpCreate(msg) {
+export function handleYeaftVpCreate(msg) {
   const requestId = msg && msg.requestId;
   const payload = msg && msg.payload;
   try {
@@ -1335,7 +1335,7 @@ export function handleUnifyVpCreate(msg) {
   }
 }
 
-export function handleUnifyVpUpdate(msg) {
+export function handleYeaftVpUpdate(msg) {
   const requestId = msg && msg.requestId;
   const payload = msg && msg.payload;
   try {
@@ -1356,7 +1356,7 @@ export function handleUnifyVpUpdate(msg) {
   }
 }
 
-export function handleUnifyVpDelete(msg) {
+export function handleYeaftVpDelete(msg) {
   const requestId = msg && msg.requestId;
   const vpId = msg && msg.vpId;
   try {
@@ -1376,7 +1376,7 @@ export function handleUnifyVpDelete(msg) {
         if (row.vpId === vpId) broker.forget({ groupId: row.groupId, vpId });
       }
     } catch (err) {
-      console.warn('[Unify] vp-status forget on delete failed:', err?.message || err);
+      console.warn('[Yeaft] vp-status forget on delete failed:', err?.message || err);
     }
     sendVpCrudResult({ op: 'delete', requestId, ok: true, vpId });
   } catch (err) {
@@ -1393,7 +1393,7 @@ export function handleUnifyVpDelete(msg) {
   }
 }
 
-export function handleUnifyVpRead(msg) {
+export function handleYeaftVpRead(msg) {
   const requestId = msg && msg.requestId;
   const vpId = msg && msg.vpId;
   const { libDir } = configuredVpPaths();
@@ -1414,7 +1414,7 @@ export function handleUnifyVpRead(msg) {
  * Group CRUD wired to WS events.
  */
 function sendGroupCrudResult(payload) {
-  sendUnifyEvent({ type: 'group_crud_result', ...payload });
+  sendYeaftEvent({ type: 'group_crud_result', ...payload });
 }
 
 function sendGroupSnapshotBroadcast() {
@@ -1422,15 +1422,15 @@ function sendGroupSnapshotBroadcast() {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
     if (!yeaftDir) return;
     const groups = snapshotGroups(yeaftDir);
-    sendUnifyEvent({ type: 'group_list_updated', groups });
+    sendYeaftEvent({ type: 'group_list_updated', groups });
   } catch (err) {
-    console.warn('[Unify] sendGroupSnapshotBroadcast failed:', err?.message || err);
+    console.warn('[Yeaft] sendGroupSnapshotBroadcast failed:', err?.message || err);
   }
 }
 
 function sendGroupRosterChanged(group) {
   if (!group) return;
-  sendUnifyEvent({
+  sendYeaftEvent({
     type: 'group_roster_changed',
     groupId: group.id,
     name: group.name,
@@ -1451,7 +1451,7 @@ function groupErrorPayload(err) {
   };
 }
 
-export function handleUnifyListGroups(msg) {
+export function handleYeaftListGroups(msg) {
   const requestId = msg && msg.requestId;
   try {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
@@ -1462,7 +1462,7 @@ export function handleUnifyListGroups(msg) {
   }
 }
 
-export function handleUnifyCreateGroup(msg) {
+export function handleYeaftCreateGroup(msg) {
   const requestId = msg && msg.requestId;
   const payload = (msg && msg.payload) || {};
   try {
@@ -1475,7 +1475,7 @@ export function handleUnifyCreateGroup(msg) {
   }
 }
 
-export function handleUnifyRenameGroup(msg) {
+export function handleYeaftRenameGroup(msg) {
   const requestId = msg && msg.requestId;
   const groupId = msg && msg.groupId;
   const name = msg && msg.name;
@@ -1491,7 +1491,7 @@ export function handleUnifyRenameGroup(msg) {
 }
 
 /**
- * `unify_update_group` — generalised group meta patch. Currently accepts
+ * `yeaft_update_group` — generalised group meta patch. Currently accepts
  * `name` and `announcement` keys. Empty patch is rejected; an empty/
  * whitespace-only `name` is also rejected up front rather than letting
  * `renameGroup` raise a less-specific error deeper in the call stack.
@@ -1504,7 +1504,7 @@ export function handleUnifyRenameGroup(msg) {
  * so this is theoretical; readers extending the patch shape should know
  * the contract permits half-commits.
  */
-export function handleUnifyUpdateGroup(msg) {
+export function handleYeaftUpdateGroup(msg) {
   const requestId = msg && msg.requestId;
   const groupId = msg && msg.groupId;
   const patch = (msg && msg.patch && typeof msg.patch === 'object') ? msg.patch : null;
@@ -1538,7 +1538,7 @@ export function handleUnifyUpdateGroup(msg) {
  * Payload: { groupId, requestId, config: { model?: string|null } }
  *  - `model: ''` or `null` clears the selected group model (falls back to user default).
  */
-export function handleUnifyUpdateGroupConfig(msg) {
+export function handleYeaftUpdateGroupConfig(msg) {
   const requestId = msg && msg.requestId;
   const groupId = msg && msg.groupId;
   const partial = (msg && msg.config && typeof msg.config === 'object') ? msg.config : null;
@@ -1560,7 +1560,7 @@ export function handleUnifyUpdateGroupConfig(msg) {
   }
 }
 
-export function handleUnifyArchiveGroup(msg) {
+export function handleYeaftArchiveGroup(msg) {
   const requestId = msg && msg.requestId;
   const groupId = msg && msg.groupId;
   try {
@@ -1574,7 +1574,7 @@ export function handleUnifyArchiveGroup(msg) {
   }
 }
 
-export function handleUnifyDeleteGroup(msg) {
+export function handleYeaftDeleteGroup(msg) {
   const requestId = msg && msg.requestId;
   const groupId = msg && msg.groupId;
   try {
@@ -1614,7 +1614,7 @@ export function handleUnifyDeleteGroup(msg) {
   }
 }
 
-export function handleUnifyAddMember(msg) {
+export function handleYeaftAddMember(msg) {
   const requestId = msg && msg.requestId;
   const groupId = msg && msg.groupId;
   const vpId = msg && msg.vpId;
@@ -1629,7 +1629,7 @@ export function handleUnifyAddMember(msg) {
   }
 }
 
-export function handleUnifyRemoveMember(msg) {
+export function handleYeaftRemoveMember(msg) {
   const requestId = msg && msg.requestId;
   const groupId = msg && msg.groupId;
   const vpId = msg && msg.vpId;
@@ -1650,7 +1650,7 @@ export function handleUnifyRemoveMember(msg) {
   }
 }
 
-export function handleUnifySetDefaultVp(msg) {
+export function handleYeaftSetDefaultVp(msg) {
   const requestId = msg && msg.requestId;
   const groupId = msg && msg.groupId;
   const vpId = msg && msg.vpId;
@@ -1673,20 +1673,20 @@ export function handleUnifySetDefaultVp(msg) {
  *
  * @param {import('./session.js').Session} s
  */
-export function installUnifyRuntimeBridge(s) {
+export function installYeaftRuntimeBridge(s) {
   if (!s) return;
 
   // Forward dream pipeline progress events to the web debug panel.
   //
   // Group-id stamping is NO LONGER done here. It used to be: this sink
   // read a module-level `activeScopedDreamGroupId` that
-  // `handleUnifyDreamTrigger({groupId})` parked before awaiting the
+  // `handleYeaftDreamTrigger({groupId})` parked before awaiting the
   // scope-filtered pass. That created a race when two scoped triggers
   // overlapped (auto-tick during a manual click; or two manual clicks
   // for different groups): the second handler's `finally` could clear
   // the module slot while the first run was still emitting events,
   // dropping the stamp from the tail of the first pass. The new design:
-  // `handleUnifyDreamTrigger` wraps THIS sink for the lifetime of the
+  // `handleYeaftDreamTrigger` wraps THIS sink for the lifetime of the
   // trigger to inject `groupId` per-call (see that function below). The
   // base sink is intentionally a pure passthrough.
   //
@@ -1696,25 +1696,25 @@ export function installUnifyRuntimeBridge(s) {
     try {
       if (evt.type === 'turn_open' || evt.type === 'turn_close' || evt.type === 'loop') {
         const tag = evt && evt.groupId ? { groupId: evt.groupId } : {};
-        sendUnifyEvent(evt, tag);
+        sendYeaftEvent(evt, tag);
       } else {
         const out = { type: 'dream_progress', ...evt };
         const tag = evt && evt.groupId ? { groupId: evt.groupId } : {};
-        sendUnifyEvent(out, tag);
+        sendYeaftEvent(out, tag);
       }
     } catch { /* never let event delivery throw */ }
   };
 
   // Wire the post-compact WS sink. Compactor is constructed in
-  // session.js with a no-op sink; bridge owns `sendUnifyEvent` /
-  // `unifyConversationId`, so the sink is wired here once a session is
-  // present. Per-group `unify_history_compacted` events fire after a
+  // session.js with a no-op sink; bridge owns `sendYeaftEvent` /
+  // `yeaftConversationId`, so the sink is wired here once a session is
+  // present. Per-group `yeaft_history_compacted` events fire after a
   // successful summarize+swap.
   if (s.compactor && typeof s.compactor.setOnCompacted === 'function') {
     s.compactor.setOnCompacted((groupId, result) => {
       try {
-        sendUnifyEvent({
-          type: 'unify_history_compacted',
+        sendYeaftEvent({
+          type: 'yeaft_history_compacted',
           reason: result?.reason ?? null,
           beforeTurns: result?.beforeTurns,
           afterTurns: result?.afterTurns,
@@ -1727,9 +1727,9 @@ export function installUnifyRuntimeBridge(s) {
     });
   }
 
-  ctx.unifyRuntimeSettings = {
+  ctx.yeaftRuntimeSettings = {
     // No multi-thread settings to surface anymore. Stub for back-compat
-    // with message-router's update_unify_settings branch — assignments are
+    // with message-router's update_yeaft_settings branch — assignments are
     // accepted but ignored.
     get maxConcurrentThreads() { return null; },
     set maxConcurrentThreads(_v) { /* deprecated, ignored */ },
@@ -1764,7 +1764,7 @@ function maybeTransitionVpStatus(hctx, state) {
       messageCount: hctx.thread?.messageIds?.length || 0,
     });
   } catch (err) {
-    console.warn(`[Unify] vp-status ${state} transition failed:`, err?.message || err);
+    console.warn(`[Yeaft] vp-status ${state} transition failed:`, err?.message || err);
   }
 }
 
@@ -1792,7 +1792,7 @@ function handleEngineEvent(event, hctx) {
   switch (event.type) {
     case 'text_delta':
       hctx.assistantTextParts.push(event.text);
-      sendUnifyOutput({
+      sendYeaftOutput({
         type: 'assistant',
         message: { content: [{ type: 'text', text: event.text }] },
       }, envelope);
@@ -1803,7 +1803,7 @@ function handleEngineEvent(event, hctx) {
       break;
 
     case 'thinking_delta':
-      sendUnifyEvent({ type: 'thinking_delta', text: event.text }, envelope);
+      sendYeaftEvent({ type: 'thinking_delta', text: event.text }, envelope);
       break;
 
     case 'thinking_block_end':
@@ -1812,7 +1812,7 @@ function handleEngineEvent(event, hctx) {
       // turns / VPs includes it. Without this echo Anthropic 400s the
       // next request with "content[].thinking in the thinking mode must
       // be passed back to the API". The signature stays server-side
-      // only — wire serializers (stripMetaForWire / sendUnifyOutput)
+      // only — wire serializers (stripMetaForWire / sendYeaftOutput)
       // never reference thinkingBlocks, so it cannot leak to the UI.
       if (hctx.thinkingBlocksAccum && event.signature) {
         if (event.redacted) {
@@ -1842,11 +1842,11 @@ function handleEngineEvent(event, hctx) {
         });
       }
       // Finish any in-progress text streaming so UI shows typing dots
-      sendUnifyOutput({
+      sendYeaftOutput({
         type: 'assistant',
         message: { content: [] },
       }, envelope);
-      sendUnifyOutput({
+      sendYeaftOutput({
         type: 'assistant',
         message: {
           content: [{
@@ -1861,7 +1861,7 @@ function handleEngineEvent(event, hctx) {
       break;
 
     case 'tool_start':
-      sendUnifyEvent({
+      sendYeaftEvent({
         type: 'tool_start',
         id: event.id,
         name: event.name,
@@ -1877,7 +1877,7 @@ function handleEngineEvent(event, hctx) {
           isError: !!event.isError,
         });
       }
-      sendUnifyOutput({
+      sendYeaftOutput({
         type: 'user',
         tool_use_result: [{
           type: 'tool_result',
@@ -1920,9 +1920,9 @@ function handleEngineEvent(event, hctx) {
             messageCount: hctx.thread?.messageIds?.length || 0,
           });
         } catch (err) {
-          console.warn('[Unify] vp-status settleIdle (route_forward) failed:', err?.message || err);
+          console.warn('[Yeaft] vp-status settleIdle (route_forward) failed:', err?.message || err);
         }
-        sendUnifyEvent({
+        sendYeaftEvent({
           type: 'vp_turn_end',
           groupId: hctx.groupId,
           vpId: hctx.vpId,
@@ -1936,7 +1936,7 @@ function handleEngineEvent(event, hctx) {
       break;
 
     case 'usage':
-      sendUnifyEvent({
+      sendYeaftEvent({
         type: 'context_usage',
         inputTokens: event.inputTokens,
         outputTokens: event.outputTokens,
@@ -1944,7 +1944,7 @@ function handleEngineEvent(event, hctx) {
       break;
 
     case 'recall':
-      sendUnifyEvent({
+      sendYeaftEvent({
         type: 'recall',
         entryCount: event.entryCount,
         cached: event.cached,
@@ -1955,7 +1955,7 @@ function handleEngineEvent(event, hctx) {
       // Engine compressed the context — clear THIS group's accumulated
       // history. Other groups' histories stay intact.
       if (hctx.groupId) setGroupHistory(hctx.groupId, []);
-      sendUnifyEvent({
+      sendYeaftEvent({
         type: 'consolidate',
         archivedCount: event.archivedCount,
         extractedCount: event.extractedCount,
@@ -1963,7 +1963,7 @@ function handleEngineEvent(event, hctx) {
       break;
 
     case 'fallback':
-      sendUnifyEvent({
+      sendYeaftEvent({
         type: 'fallback',
         from: event.from,
         to: event.to,
@@ -1972,7 +1972,7 @@ function handleEngineEvent(event, hctx) {
       break;
 
     case 'reflection':
-      sendUnifyEvent({
+      sendYeaftEvent({
         type: 'reflection',
         // feat-6af5f9f1 PR B: stamp turnId/loopNumber so the debug panel
         // can attach reflection cards to the matching loop.
@@ -1989,7 +1989,7 @@ function handleEngineEvent(event, hctx) {
       break;
 
     case 'turn_open':
-      sendUnifyEvent({
+      sendYeaftEvent({
         type: 'turn_open',
         turnId: event.turnId,
         userPrompt: event.userPrompt,
@@ -2000,7 +2000,7 @@ function handleEngineEvent(event, hctx) {
       break;
 
     case 'turn_close':
-      sendUnifyEvent({
+      sendYeaftEvent({
         type: 'turn_close',
         turnId: event.turnId,
         totalMs: event.totalMs,
@@ -2010,7 +2010,7 @@ function handleEngineEvent(event, hctx) {
       break;
 
     case 'memory_used':
-      sendUnifyEvent({
+      sendYeaftEvent({
         type: 'memory_used',
         turnId: event.turnId,
         loaded: event.loaded || [],
@@ -2018,7 +2018,7 @@ function handleEngineEvent(event, hctx) {
       break;
 
     case 'memory_adjust':
-      sendUnifyEvent({
+      sendYeaftEvent({
         type: 'memory_adjust',
         turnId: event.turnId,
         groupKey: event.groupKey,
@@ -2033,7 +2033,7 @@ function handleEngineEvent(event, hctx) {
       if (hctx && Array.isArray(hctx.appendedUserPrompts) && event.preview) {
         hctx.appendedUserPrompts.push(String(event.preview));
       }
-      sendUnifyEvent({
+      sendYeaftEvent({
         type: 'vp_thread_user_append_consumed',
         turnId: event.turnId,
         threadId: event.threadId,
@@ -2044,7 +2044,7 @@ function handleEngineEvent(event, hctx) {
       break;
 
     case 'tool_exec':
-      sendUnifyEvent({
+      sendYeaftEvent({
         type: 'tool_exec',
         turnId: event.turnId,
         loopNumber: event.loopNumber,
@@ -2058,7 +2058,7 @@ function handleEngineEvent(event, hctx) {
     case 'loop':
       // feat-6af5f9f1 PR B: replaces the old `debug_turn` event. Same
       // payload shape plus turnId + loopNumber + usage.totalTokens.
-      sendUnifyEvent({
+      sendYeaftEvent({
         type: 'loop',
         turnId: event.turnId,
         loopNumber: event.loopNumber,
@@ -2081,7 +2081,7 @@ function handleEngineEvent(event, hctx) {
       if (isPermissionErrorMsg(errMsg)) {
         if (!_permissionDiagnosticSent) {
           _permissionDiagnosticSent = true;
-          sendUnifyOutput({
+          sendYeaftOutput({
             type: 'assistant',
             message: {
               content: [{
@@ -2092,7 +2092,7 @@ function handleEngineEvent(event, hctx) {
           }, envelope);
         }
       } else {
-        sendUnifyOutput({
+        sendYeaftOutput({
           type: 'assistant',
           message: {
             content: [{ type: 'text', text: `⚠️ Error: ${errMsg}` }],
@@ -2109,13 +2109,13 @@ function handleEngineEvent(event, hctx) {
 }
 
 /**
- * Handle a unify_group_chat message from the web UI — the SOLE Unify
+ * Handle a yeaft_group_chat message from the web UI — the SOLE Yeaft
  * conversation entry point.
  *
- * Contract (post-consolidation, was previously split between handleUnifyChat
- * and handleUnifyGroupChat):
- *   - Frontend ALWAYS sends `unify_group_chat`. There is no `unify_chat`.
- *   - `groupId` defaults to `'grp_default'` if missing — Unify is a single
+ * Contract (post-consolidation, was previously split between handleYeaftChat
+ * and handleYeaftGroupChat):
+ *   - Frontend ALWAYS sends `yeaft_group_chat`. There is no `yeaft_chat`.
+ *   - `groupId` defaults to `'grp_default'` if missing — Yeaft is a single
  *     conversation backed by the default group; the user is never "outside"
  *     a group.
  *   - If the group dir doesn't exist and the resolved id is `'grp_default'`,
@@ -2125,12 +2125,12 @@ function handleEngineEvent(event, hctx) {
  *   - No legacy "no-group" fallback paths — they were the source of the
  *     router_unavailable bug fixed in v0.1.671.
  */
-export async function handleUnifyGroupChat(msg) {
+export async function handleYeaftGroupChat(msg) {
   if (!msg || typeof msg !== 'object') return;
   const { text } = msg;
   // PR #721: image-only send is allowed — text may be empty when the
   // user attached files only. The frontend synthesizes a placeholder
-  // string in `sendUnifyGroupChat`, so by the time we get here `text`
+  // string in `sendYeaftGroupChat`, so by the time we get here `text`
   // should always be non-empty; but defend anyway in case an API
   // caller sends a bare attachment payload.
   const hasFiles = Array.isArray(msg.files) && msg.files.length > 0;
@@ -2157,11 +2157,11 @@ export async function handleUnifyGroupChat(msg) {
   // session lying around.
   const yeaftDir = ctx.CONFIG?.yeaftDir;
   if (!yeaftDir) {
-    sendUnifyOutput({
+    sendYeaftOutput({
       type: 'assistant',
-      message: { content: [{ type: 'text', text: '⚠️ Unify session error: no yeaft directory configured.' }] },
+      message: { content: [{ type: 'text', text: '⚠️ Yeaft session error: no yeaft directory configured.' }] },
     }, { groupId });
-    sendUnifyOutput({ type: 'result', result_text: '' }, { groupId });
+    sendYeaftOutput({ type: 'result', result_text: '' }, { groupId });
     return;
   }
 
@@ -2185,24 +2185,24 @@ export async function handleUnifyGroupChat(msg) {
         groupHandle = seeded.group;
       } catch (seedErr) {
         seedFailed = true;
-        console.warn('[Unify] unify_group_chat: seedDefaultGroup failed', seedErr?.message || seedErr);
+        console.warn('[Yeaft] yeaft_group_chat: seedDefaultGroup failed', seedErr?.message || seedErr);
       }
     } else {
-      console.warn('[Unify] unify_group_chat: groupId %s not found', groupId);
+      console.warn('[Yeaft] yeaft_group_chat: groupId %s not found', groupId);
     }
   } catch (err) {
-    console.warn('[Unify] unify_group_chat: group open failed', err?.message || err);
+    console.warn('[Yeaft] yeaft_group_chat: group open failed', err?.message || err);
   }
 
   if (!groupHandle) {
     const errText = seedFailed
       ? `⚠️ Failed to seed default group ${groupId} — check group .yeaft permissions.`
       : `⚠️ Group ${groupId} not found.`;
-    sendUnifyOutput({
+    sendYeaftOutput({
       type: 'assistant',
       message: { content: [{ type: 'text', text: errText }] },
     }, { groupId });
-    sendUnifyOutput({ type: 'result', result_text: '' }, { groupId });
+    sendYeaftOutput({ type: 'result', result_text: '' }, { groupId });
     return;
   }
 
@@ -2239,7 +2239,7 @@ export async function handleUnifyGroupChat(msg) {
       } catch { /* best-effort */ }
     }
   } catch (err) {
-    console.warn('[Unify] unify_group_chat: auto-roster heal failed', err?.message || err);
+    console.warn('[Yeaft] yeaft_group_chat: auto-roster heal failed', err?.message || err);
   }
 
   // task-707: per-group persistent coordinator/router. Created once per
@@ -2260,7 +2260,7 @@ export async function handleUnifyGroupChat(msg) {
   // ── Attachments (images + files) ───────────────────────────────
   // Server has already resolved fileId → { name, mimeType, data:base64,
   // isImage } via the same path crew uses (client-conversation.js relay
-  // for `unify_*`). We persist files to disk under the agent's CWD so
+  // for `yeaft_*`). We persist files to disk under the agent's CWD so
   // file-tools (file-read / bash) can pick them up with relative paths,
   // and we build per-image content blocks for the LLM call. The
   // resolved metadata WITHOUT base64 rides on coord.ingest meta so it
@@ -2270,9 +2270,9 @@ export async function handleUnifyGroupChat(msg) {
   let attachmentBundle = { promptAttachments: [], promptSuffix: '', promptParts: [], failed: [] };
   if (inboundFiles.length > 0) {
     try {
-      attachmentBundle = persistUnifyAttachments(inboundFiles, { subdir: groupId });
+      attachmentBundle = persistYeaftAttachments(inboundFiles, { subdir: groupId });
     } catch (err) {
-      console.warn('[Unify] unify_group_chat: attachment persist failed', err?.message || err);
+      console.warn('[Yeaft] yeaft_group_chat: attachment persist failed', err?.message || err);
     }
   }
   // Surface partial / total upload failures to the user. We don't abort
@@ -2282,7 +2282,7 @@ export async function handleUnifyGroupChat(msg) {
     const detail = attachmentBundle.failed
       .map((f) => `  - ${f.name}: ${f.error}`)
       .join('\n');
-    sendUnifyOutput({
+    sendYeaftOutput({
       type: 'assistant',
       message: { content: [{ type: 'text', text: `⚠️ ${attachmentBundle.failed.length} file(s) could not be attached:\n${detail}` }] },
     }, { groupId });
@@ -2311,12 +2311,12 @@ export async function handleUnifyGroupChat(msg) {
       _promptSuffix: attachmentBundle.promptSuffix,
     });
   } catch (err) {
-    console.warn('[Unify] unify_group_chat: coord.ingest failed', err?.message || err);
-    sendUnifyOutput({
+    console.warn('[Yeaft] yeaft_group_chat: coord.ingest failed', err?.message || err);
+    sendYeaftOutput({
       type: 'assistant',
       message: { content: [{ type: 'text', text: `⚠️ Group dispatch error: ${err?.message || err}` }] },
     }, { groupId });
-    sendUnifyOutput({ type: 'result', result_text: '' }, { groupId });
+    sendYeaftOutput({ type: 'result', result_text: '' }, { groupId });
     return;
   }
 
@@ -2333,11 +2333,11 @@ export async function handleUnifyGroupChat(msg) {
     // with a healthy roster. Surface the failure explicitly rather than
     // silently retrying as a single-VP turn (the legacy fallback masked
     // group-roster bugs).
-    sendUnifyOutput({
+    sendYeaftOutput({
       type: 'assistant',
       message: { content: [{ type: 'text', text: '⚠️ No VP available to respond — check the group roster.' }] },
     }, { groupId });
-    sendUnifyOutput({ type: 'result', result_text: '' }, { groupId });
+    sendYeaftOutput({ type: 'result', result_text: '' }, { groupId });
     return;
   }
 
@@ -2502,18 +2502,18 @@ async function ensureSessionLoaded() {
     serverMode: true,
   });
 
-  installUnifyRuntimeBridge(session);
+  installYeaftRuntimeBridge(session);
 
   try {
     if (session.engine && typeof session.engine.setSubAgentEventSink === 'function') {
       session.engine.setSubAgentEventSink((agentId, evt) => {
         try {
-          sendUnifyEvent({ type: 'sub_agent_event', agentId, payload: evt });
+          sendYeaftEvent({ type: 'sub_agent_event', agentId, payload: evt });
         } catch { /* ignore */ }
       });
     }
   } catch (err) {
-    console.warn('[Unify] setSubAgentEventSink wiring failed:', err?.message || err);
+    console.warn('[Yeaft] setSubAgentEventSink wiring failed:', err?.message || err);
   }
 
   // Bug 8: clean up legacy `.archived-*` group dirs at boot.
@@ -2521,21 +2521,21 @@ async function ensureSessionLoaded() {
     if (yeaftDir) {
       const removed = purgeArchivedGroups(yeaftDir);
       if (removed && removed.length > 0) {
-        console.log(`[Unify] purged ${removed.length} legacy .archived group dir(s)`);
+        console.log(`[Yeaft] purged ${removed.length} legacy .archived group dir(s)`);
       }
     }
   } catch (err) {
-    console.warn('[Unify] purgeArchivedGroups failed:', err?.message || err);
+    console.warn('[Yeaft] purgeArchivedGroups failed:', err?.message || err);
   }
 
-  unifyConversationId = `unify-${Date.now()}`;
+  yeaftConversationId = `yeaft-${Date.now()}`;
 
   // Per-group history is hydrated lazily on first `getOrCreateGroupHistory`
   // — there's no global "all conversations" tape any more.
 
-  sendUnifyEvent({
+  sendYeaftEvent({
     type: 'session_ready',
-    conversationId: unifyConversationId,
+    conversationId: yeaftConversationId,
     model: session.config.model,
     availableModels: session.config.availableModels || [],
     skills: session.status.skills,
@@ -2551,7 +2551,7 @@ async function ensureSessionLoaded() {
   try {
     getVpStatusBroker().broadcastSnapshot();
   } catch (err) {
-    console.warn('[Unify] vp-status snapshot broadcast failed:', err?.message || err);
+    console.warn('[Yeaft] vp-status snapshot broadcast failed:', err?.message || err);
   }
 }
 
@@ -2589,10 +2589,10 @@ async function runVpTurnWithEscalation(args) {
     deadlineMs,
     onEscalate: () => {
       console.error(
-        `[Unify] runVpTurn watchdog escalation: VP ${vpId} did not return ${deadlineMs}ms after enqueue — emitting synthetic stop and unblocking driver`,
+        `[Yeaft] runVpTurn watchdog escalation: VP ${vpId} did not return ${deadlineMs}ms after enqueue — emitting synthetic stop and unblocking driver`,
       );
       try {
-        sendUnifyOutput(
+        sendYeaftOutput(
           { type: 'result', result_text: '', stopped: true },
           { groupId, vpId, turnId, threadId },
         );
@@ -2608,7 +2608,7 @@ async function runVpTurnWithEscalation(args) {
       try {
         getVpStatusBroker().settleIdle({ groupId, vpId, threadId: threadId || 'main', title: thread?.title || '' });
       } catch (err) {
-        console.warn('[Unify] vp-status settleIdle (escalation) failed:', err?.message || err);
+        console.warn('[Yeaft] vp-status settleIdle (escalation) failed:', err?.message || err);
       }
     },
   });
@@ -2692,7 +2692,7 @@ async function runVpTurn({ prompt, promptParts = null, groupId, vpId, threadId =
       if (queryTimer) clearTimeout(queryTimer);
       queryTimer = setTimeout(() => {
         if (!vpAbort.signal.aborted) {
-          console.error(`[Unify] query timeout after ${QUERY_TIMEOUT_MS / 1000}s of silence — aborting VP ${vpId}`);
+          console.error(`[Yeaft] query timeout after ${QUERY_TIMEOUT_MS / 1000}s of silence — aborting VP ${vpId}`);
           try { vpAbort.abort(); } catch { /* best-effort */ }
         }
       }, QUERY_TIMEOUT_MS);
@@ -2700,12 +2700,12 @@ async function runVpTurn({ prompt, promptParts = null, groupId, vpId, threadId =
     resetQueryTimer();
 
     // Emit turn_start so frontend can create the message block.
-    sendUnifyEvent({ type: 'vp_turn_start', vpId, threadId, turnId, groupId, title: thread?.title || '' }, envelope);
+    sendYeaftEvent({ type: 'vp_turn_start', vpId, threadId, turnId, groupId, title: thread?.title || '' }, envelope);
     // vp-status: LLM call about to start, no text/tool yet → 'thinking'.
     try {
       getVpStatusBroker().transition({ groupId, vpId, threadId, title: thread?.title || '', state: 'thinking', turnId, messageCount: thread?.messageIds?.length || 0 });
     } catch (err) {
-      console.warn('[Unify] vp-status thinking transition failed:', err?.message || err);
+      console.warn('[Yeaft] vp-status thinking transition failed:', err?.message || err);
     }
 
     try {
@@ -2717,7 +2717,7 @@ async function runVpTurn({ prompt, promptParts = null, groupId, vpId, threadId =
       let vpEngine = null;
 
       // task-707: per-VP engine + persistent group coord. The coord is
-      // created in handleUnifyGroupChat via getOrCreateGroupContext and
+      // created in handleYeaftGroupChat via getOrCreateGroupContext and
       // cached on `groupContexts`; we pull it here so route_forward
       // (router built from this same coord) lands envelopes back on the
       // right inbox set.
@@ -2760,7 +2760,7 @@ async function runVpTurn({ prompt, promptParts = null, groupId, vpId, threadId =
         messages: trimmedMessages,
         signal: vpAbort.signal,
         // Multi-VP fan-out (history-dedup): the user row was persisted
-        // ONCE by handleUnifyGroupChat → persistUserMessageOnce before
+        // ONCE by handleYeaftGroupChat → persistUserMessageOnce before
         // fan-out. Tell the engine's stop-hook to skip the user-row
         // append for THIS VP's turn (it still writes assistant + tool
         // rows for this VP). Without this the magnet of N engines would
@@ -2781,11 +2781,11 @@ async function runVpTurn({ prompt, promptParts = null, groupId, vpId, threadId =
       // Turn completed — atomically append this VP's output to shared history.
       appendTurnToGroupHistory(groupId, threadId, [prompt, ...appendedUserPrompts], assistantTextParts, toolCallsAccum, toolResultsAccum, thinkingBlocksAccum);
 
-      sendUnifyOutput({
+      sendYeaftOutput({
         type: 'assistant',
         message: { content: [] },
       }, envelope);
-      sendUnifyOutput({
+      sendYeaftOutput({
         type: 'result',
         result_text: '',
       }, envelope);
@@ -2795,7 +2795,7 @@ async function runVpTurn({ prompt, promptParts = null, groupId, vpId, threadId =
   } catch (err) {
     const isAbort = err && (err.name === 'AbortError' || err.name === 'LLMAbortError');
     if (isAbort) {
-      sendUnifyOutput({
+      sendYeaftOutput({
         type: 'result',
         result_text: '',
         stopped: true,
@@ -2803,7 +2803,7 @@ async function runVpTurn({ prompt, promptParts = null, groupId, vpId, threadId =
       return;
     }
 
-    console.error('[Unify] query error:', err);
+    console.error('[Yeaft] query error:', err);
 
     // vp-status: surface a transient `error` state so the row's status
     // label flips red for the brief window before the outer finally
@@ -2813,13 +2813,13 @@ async function runVpTurn({ prompt, promptParts = null, groupId, vpId, threadId =
     try {
       getVpStatusBroker().transition({ groupId, vpId, threadId, title: thread?.title || '', state: 'error', turnId, messageCount: thread?.messageIds?.length || 0 });
     } catch (brokerErr) {
-      console.warn('[Unify] vp-status error transition failed:', brokerErr?.message || brokerErr);
+      console.warn('[Yeaft] vp-status error transition failed:', brokerErr?.message || brokerErr);
     }
 
     if (isPermissionErrorMsg(err.message)) {
       if (!_permissionDiagnosticSent) {
         _permissionDiagnosticSent = true;
-        sendUnifyOutput({
+        sendYeaftOutput({
           type: 'assistant',
           message: {
             content: [{
@@ -2830,7 +2830,7 @@ async function runVpTurn({ prompt, promptParts = null, groupId, vpId, threadId =
         }, envelope);
       }
     } else {
-      sendUnifyOutput({
+      sendYeaftOutput({
         type: 'assistant',
         message: {
           content: [{
@@ -2840,7 +2840,7 @@ async function runVpTurn({ prompt, promptParts = null, groupId, vpId, threadId =
         },
       }, envelope);
     }
-    sendUnifyOutput({
+    sendYeaftOutput({
       type: 'result',
       result_text: '',
     }, envelope);
@@ -2852,7 +2852,7 @@ async function runVpTurn({ prompt, promptParts = null, groupId, vpId, threadId =
     try {
       getVpStatusBroker().settleIdle({ groupId, vpId, threadId: threadId || 'main', title: thread?.title || '' });
     } catch (err) {
-      console.warn('[Unify] vp-status settleIdle failed:', err?.message || err);
+      console.warn('[Yeaft] vp-status settleIdle failed:', err?.message || err);
     }
     // fix-vp-multi-thread (bug 2): the bridge tracks per-thread status
     // on `thread.status` separately from the broker. Multiple sites
@@ -2934,14 +2934,14 @@ function appendTurnToGroupHistory(groupId, threadId, prompts, assistantTextParts
 /**
  * Persist an inbound message row to disk EXACTLY ONCE per
  * coordinator-ingest call, keyed by the coordinator-assigned `msgId`.
- * Both `handleUnifyGroupChat` (real user input, persists as
+ * Both `handleYeaftGroupChat` (real user input, persists as
  * role='user') and `enqueueForVp`'s driver loop (route_forward
  * synthetic injections, persists as role='assistant' attributed via
  * `speakerVpId`) call this — the Set guard makes either path the
  * writer, whichever runs first, while the other becomes a no-op.
  *
  * Without this dedup, a 2-VP group prompt produces TWO `m{NNNN}.md`
- * user rows (one per engine) — `handleUnifyLoadHistory` then replays
+ * user rows (one per engine) — `handleYeaftLoadHistory` then replays
  * the user's prompt twice and sandwiches one VP's reply between two
  * copies of the user message. Visually this reads as "messages out of
  * order" because the second copy of the user prompt sits BETWEEN the
@@ -2992,7 +2992,7 @@ function persistInboundMessageOnceByMsgId({ msgId, text, groupId, threadId = 'ma
     }
   }
   try {
-    // role defaults to 'user' for back-compat: handleUnifyGroupChat's
+    // role defaults to 'user' for back-compat: handleYeaftGroupChat's
     // real-user call site passes no role and gets a user row. The driver
     // loop passes role='assistant' + speakerVpId for route_forward
     // injections so the on-disk record correctly attributes the text to
@@ -3018,7 +3018,7 @@ function persistInboundMessageOnceByMsgId({ msgId, text, groupId, threadId = 'ma
     return true;
   } catch (err) {
     console.warn(
-      '[Unify] persistInboundMessageOnceByMsgId failed (non-fatal):',
+      '[Yeaft] persistInboundMessageOnceByMsgId failed (non-fatal):',
       err?.message || err,
     );
     return false;
@@ -3026,24 +3026,24 @@ function persistInboundMessageOnceByMsgId({ msgId, text, groupId, threadId = 'ma
 }
 
 /**
- * Cleared on session reset (resetUnifySession) so a fresh session
+ * Cleared on session reset (resetYeaftSession) so a fresh session
  * starts with no stale msg-ids.
  */
 const _persistedUserMsgIds = new Set();
 
 // Per-group post-turn compaction lives on `session.compactor`
-// (`agent/unify/compact/compactor.js`), constructed in `session.js`.
+// (`agent/yeaft/compact/compactor.js`), constructed in `session.js`.
 // Bridge passes a per-call `historyHandle = { get, set }` and wires the
-// `unify_history_compacted` WS sink via `compactor.setOnCompacted` from
-// `installUnifyRuntimeBridge`. The bridge keeps history ownership; the
+// `yeaft_history_compacted` WS sink via `compactor.setOnCompacted` from
+// `installYeaftRuntimeBridge`. The bridge keeps history ownership; the
 // Compactor owns single-flight, anti-starvation, race-guard, and the
 // LLM summarize call.
 
 /**
  * Abort every in-flight VP turn and clear all queued envelopes across
- * every group/thread runtime. Shared by `handleUnifyAbortThread` when no
- * target thread is supplied and by `handleUnifyAbortAll`. Pushes `vp:<key>`
- * strings into the supplied `aborted` array for the unify_aborted event.
+ * every group/thread runtime. Shared by `handleYeaftAbortThread` when no
+ * target thread is supplied and by `handleYeaftAbortAll`. Pushes `vp:<key>`
+ * strings into the supplied `aborted` array for the yeaft_aborted event.
  *
  * @param {string[]} aborted — output array, mutated in place
  */
@@ -3066,7 +3066,7 @@ function abortAllVpRuntime(aborted) {
  * @param {{ threadId?: string }} _msg
  * @returns {{ aborted: string[], all: boolean }}
  */
-export function handleUnifyAbortThread(_msg = {}) {
+export function handleYeaftAbortThread(_msg = {}) {
   const aborted = [];
   const targetThreadId = _msg && typeof _msg.threadId === 'string' ? _msg.threadId : '';
 
@@ -3093,7 +3093,7 @@ export function handleUnifyAbortThread(_msg = {}) {
       const thread = vpMap.get(targetThreadId);
       if (thread) thread.status = 'aborted';
     }
-    sendUnifyEvent({ type: 'unify_aborted', aborted, all: false, threadId: targetThreadId });
+    sendYeaftEvent({ type: 'yeaft_aborted', aborted, all: false, threadId: targetThreadId });
     return { aborted, all: false };
   }
 
@@ -3107,15 +3107,15 @@ export function handleUnifyAbortThread(_msg = {}) {
   turnAbortCtrls.clear();
   turnAbortMeta.clear();
   abortAllVpRuntime(aborted);
-  sendUnifyEvent({ type: 'unify_aborted', aborted, all: false });
+  sendYeaftEvent({ type: 'yeaft_aborted', aborted, all: false });
   return { aborted, all: false };
 }
 
 /**
- * Abort all in-flight Unify runtime work.
+ * Abort all in-flight Yeaft runtime work.
  * @returns {{ aborted: string[], all: boolean }}
  */
-export function handleUnifyAbortAll() {
+export function handleYeaftAbortAll() {
   const aborted = [];
   if (currentAbortCtrl && !currentAbortCtrl.signal.aborted) {
     try { currentAbortCtrl.abort(); aborted.push('main'); } catch { /* best-effort */ }
@@ -3128,19 +3128,19 @@ export function handleUnifyAbortAll() {
   turnAbortCtrls.clear();
   turnAbortMeta.clear();
   abortAllVpRuntime(aborted);
-  sendUnifyEvent({ type: 'unify_aborted', aborted, all: true });
+  sendYeaftEvent({ type: 'yeaft_aborted', aborted, all: true });
   return { aborted, all: true };
 }
 
 /**
  * Per-VP abort: stops a single VP turn by turnId without affecting siblings.
- * Frontend sends `{ type: 'unify_abort_turn', turnId }`.
+ * Frontend sends `{ type: 'yeaft_abort_turn', turnId }`.
  * @param {{ turnId?: string }} msg
  */
-export function handleUnifyAbortTurn(msg = {}) {
+export function handleYeaftAbortTurn(msg = {}) {
   const { turnId } = msg;
   if (!turnId) {
-    sendUnifyEvent({ type: 'unify_turn_aborted', turnId: null, success: false });
+    sendYeaftEvent({ type: 'yeaft_turn_aborted', turnId: null, success: false });
     return;
   }
   const ctrl = turnAbortCtrls.get(turnId);
@@ -3148,11 +3148,11 @@ export function handleUnifyAbortTurn(msg = {}) {
     try { ctrl.abort(); } catch { /* best-effort */ }
     turnAbortCtrls.delete(turnId);
     turnAbortMeta.delete(turnId);
-    sendUnifyEvent({ type: 'unify_turn_aborted', turnId, success: true });
+    sendYeaftEvent({ type: 'yeaft_turn_aborted', turnId, success: true });
   } else {
     turnAbortCtrls.delete(turnId);
     turnAbortMeta.delete(turnId);
-    sendUnifyEvent({ type: 'unify_turn_aborted', turnId, success: false });
+    sendYeaftEvent({ type: 'yeaft_turn_aborted', turnId, success: false });
   }
 }
 
@@ -3160,11 +3160,11 @@ export function handleUnifyAbortTurn(msg = {}) {
  * Unified abort entry: routes by payload shape.
  * @param {{ threadId?: string, all?: boolean }} [opts]
  */
-export function abortUnifySession(opts = {}) {
-  if (opts && opts.all) return handleUnifyAbortAll();
-  if (opts && opts.threadId) return handleUnifyAbortThread({ threadId: opts.threadId });
+export function abortYeaftSession(opts = {}) {
+  if (opts && opts.all) return handleYeaftAbortAll();
+  if (opts && opts.threadId) return handleYeaftAbortThread({ threadId: opts.threadId });
   // No payload — conservative no-op ack.
-  sendUnifyEvent({ type: 'unify_aborted', aborted: [], all: false });
+  sendYeaftEvent({ type: 'yeaft_aborted', aborted: [], all: false });
   return { aborted: [], all: false };
 }
 
@@ -3206,7 +3206,7 @@ export function __testGetRegisteredThreadIds() {
 /**
  * Test-only: expose the bridge-level escalation helper. Lets tests verify
  * the "tool ignored signal → wrapper escalates" contract without booting a
- * full session. See `test/agent/unify/web-bridge-escalation.test.js`.
+ * full session. See `test/agent/yeaft/web-bridge-escalation.test.js`.
  */
 export const __testRaceWithEscalation = raceWithEscalation;
 
@@ -3215,11 +3215,11 @@ export const __testRaceWithEscalation = raceWithEscalation;
  *
  * Two call shapes, both routed through this single handler:
  *
- *   { type: 'unify_dream_trigger', vpId }     — per-VP trigger (legacy
+ *   { type: 'yeaft_dream_trigger', vpId }     — per-VP trigger (legacy
  *     VP-detail page button). Fires an unscoped dream pass; the result
  *     event is tagged with `vpId` so the per-VP store row updates.
  *
- *   { type: 'unify_dream_trigger', groupId }  — per-GROUP trigger (new
+ *   { type: 'yeaft_dream_trigger', groupId }  — per-GROUP trigger (new
  *     in v0.1.754 — added so users can manually kick dream for a group
  *     after seeing the Resident layer stuck on the bootstrap seed).
  *     Fires a scope-filtered pass via `triggerDreamForScopes(['group/X'])`
@@ -3270,7 +3270,7 @@ export function normalizeDreamResult(result) {
   };
 }
 
-export async function handleUnifyDreamTrigger(msg = {}) {
+export async function handleYeaftDreamTrigger(msg = {}) {
   // Resolve tag up-front so EVERY outbound envelope (including the
   // scheduler-uninitialised early-return below) carries `groupId` /
   // `vpId`. Without this the frontend's `applyDreamResult` couldn't
@@ -3284,7 +3284,7 @@ export async function handleUnifyDreamTrigger(msg = {}) {
   if (!session?.dreamScheduler) {
     const error = 'Dream scheduler not initialized — session not loaded.';
     sendToServer({
-      type: 'unify_dream_result',
+      type: 'yeaft_dream_result',
       ...tag,
       ...normalizeDreamResult({ error }),
     });
@@ -3310,7 +3310,7 @@ export async function handleUnifyDreamTrigger(msg = {}) {
       trigger: msg.manual === false ? 'auto' : 'manual',
     };
     sendToServer({
-      type: 'unify_dream_result',
+      type: 'yeaft_dream_result',
       ...tag,
       ...skippedResult,
       ...normalizeDreamResult(skippedResult),
@@ -3341,7 +3341,7 @@ export async function handleUnifyDreamTrigger(msg = {}) {
 
   try {
     sendToServer({
-      type: 'unify_dream_status',
+      type: 'yeaft_dream_status',
       ...tag,
       status: 'running',
     });
@@ -3361,15 +3361,15 @@ export async function handleUnifyDreamTrigger(msg = {}) {
     // mode of the alternative ordering is silent — review feedback from
     // PR #743.
     //
-    // This `unify_dream_result` envelope is the SOLE terminal signal for
-    // a dream pass. The chat-store projects it into BOTH `unifyDreamLatest`
-    // (final tally row) AND `unifyDreamEvents` (ring-buffer terminal
+    // This `yeaft_dream_result` envelope is the SOLE terminal signal for
+    // a dream pass. The chat-store projects it into BOTH `yeaftDreamLatest`
+    // (final tally row) AND `yeaftDreamEvents` (ring-buffer terminal
     // marker), so we no longer mirror a synthetic `phase:'result'`
     // dream_progress event — that mirror used to race the
-    // `unifyDreamLatest` writer and flip the success row back to
+    // `yeaftDreamLatest` writer and flip the success row back to
     // 'running' (Critical reviewer finding pre-merge).
     sendToServer({
-      type: 'unify_dream_result',
+      type: 'yeaft_dream_result',
       ...tag,
       ...result,
       ...normalized,
@@ -3377,7 +3377,7 @@ export async function handleUnifyDreamTrigger(msg = {}) {
   } catch (err) {
     const error = err?.message || String(err);
     sendToServer({
-      type: 'unify_dream_result',
+      type: 'yeaft_dream_result',
       ...tag,
       ...normalizeDreamResult({ error }),
     });
@@ -3392,9 +3392,9 @@ export async function handleUnifyDreamTrigger(msg = {}) {
 }
 
 /**
- * 2026-05-13: serve the Unify debug drawer's "Tool Stats" panel.
+ * 2026-05-13: serve the Yeaft debug drawer's "Tool Stats" panel.
  *
- * Replies with `{type: 'unify_tool_stats', snapshot, registered,
+ * Replies with `{type: 'yeaft_tool_stats', snapshot, registered,
  * unused}`. `snapshot` is the `ToolUsageStats.snapshot()` keyed by
  * tool name (callCount, errorCount, p50Ms, p95Ms, avgMs, lastCalledAt,
  * lastError, errorRate). `registered` is the static list of built-in
@@ -3405,7 +3405,7 @@ export async function handleUnifyDreamTrigger(msg = {}) {
  * missing, we still reply with an empty snapshot so the UI can render
  * a placeholder rather than spin forever.
  */
-export async function handleUnifyFetchToolStats(_msg = {}) {
+export async function handleYeaftFetchToolStats(_msg = {}) {
   let snapshot = {};
   let registered = [];
   let unused = [];
@@ -3427,7 +3427,7 @@ export async function handleUnifyFetchToolStats(_msg = {}) {
     }
   } catch (err) {
     sendToServer({
-      type: 'unify_tool_stats',
+      type: 'yeaft_tool_stats',
       snapshot: {},
       registered: [],
       unused: [],
@@ -3436,7 +3436,7 @@ export async function handleUnifyFetchToolStats(_msg = {}) {
     return;
   }
   sendToServer({
-    type: 'unify_tool_stats',
+    type: 'yeaft_tool_stats',
     snapshot,
     registered,
     unused,
@@ -3444,8 +3444,8 @@ export async function handleUnifyFetchToolStats(_msg = {}) {
 }
 
 /**
- * Hydrate the UnifyDebugPanel from the persistent SQLite trace. The
- * panel state (`unifyDebugLoops` / `unifyDebugTurnsById`) is otherwise
+ * Hydrate the YeaftDebugPanel from the persistent SQLite trace. The
+ * panel state (`yeaftDebugLoops` / `yeaftDebugTurnsById`) is otherwise
  * built ONLY from in-flight `loop` / `turn_open` events on the wire,
  * so a panel opened after a turn has finished sees nothing for that
  * turn. This handler ships back a frontend-shaped snapshot the store
@@ -3457,12 +3457,12 @@ export async function handleUnifyFetchToolStats(_msg = {}) {
  *   - `threadId`  — narrow by thread
  *
  * Sends:
- *   { type: 'unify_debug_history', loops: [...], turns: [...] }
+ *   { type: 'yeaft_debug_history', loops: [...], turns: [...] }
  *
  * Best-effort: if the session / trace isn't ready, sends an empty
  * snapshot so the panel renders a placeholder instead of spinning.
  */
-export async function handleUnifyFetchDebugHistory(msg = {}) {
+export async function handleYeaftFetchDebugHistory(msg = {}) {
   const limit = Number.isFinite(msg?.limit) ? Number(msg.limit) : 100;
   const dreamLimit = Number.isFinite(msg?.dreamLimit) ? Number(msg.dreamLimit) : 5;
   const groupId = typeof msg?.groupId === 'string' && msg.groupId ? msg.groupId : null;
@@ -3479,7 +3479,7 @@ export async function handleUnifyFetchDebugHistory(msg = {}) {
     }
   } catch (err) {
     sendToServer({
-      type: 'unify_debug_history',
+      type: 'yeaft_debug_history',
       loops: [],
       turns: [],
       dreamEvents: [],
@@ -3488,7 +3488,7 @@ export async function handleUnifyFetchDebugHistory(msg = {}) {
     return;
   }
   sendToServer({
-    type: 'unify_debug_history',
+    type: 'yeaft_debug_history',
     loops,
     turns,
     dreamEvents,
@@ -3497,26 +3497,26 @@ export async function handleUnifyFetchDebugHistory(msg = {}) {
   });
 }
 
-/** Deprecated mode switch — Unify is single-mode. */
-export function handleUnifyModeSwitch(_msg) {
-  console.warn('[Unify] unify_mode_switch is deprecated and ignored — Unify now runs in a single unified mode.');
+/** Deprecated mode switch — Yeaft is single-mode. */
+export function handleYeaftModeSwitch(_msg) {
+  console.warn('[Yeaft] yeaft_mode_switch is deprecated and ignored — Yeaft now runs in a single unified mode.');
 }
 
 
 /** Handle model switch from the web UI. */
-export function handleUnifyModelSwitch(msg) {
+export function handleYeaftModelSwitch(msg) {
   if (!session || !msg.model) return;
 
   const available = session.config.availableModels || [];
   const found = available.some(m => m.id === msg.model);
   if (!found) {
-    console.warn(`[Unify] model switch rejected — "${msg.model}" not in availableModels`);
+    console.warn(`[Yeaft] model switch rejected — "${msg.model}" not in availableModels`);
     return;
   }
 
   session.config.model = msg.model;
 
-  sendUnifyEvent({
+  sendYeaftEvent({
     type: 'model_switched',
     model: msg.model,
   });
@@ -3532,7 +3532,7 @@ export function handleUnifyModelSwitch(msg) {
  * groupId at all — are excluded so a stale `grp_default` (or any other
  * group) never bleeds into the active group's pane.
  */
-export async function handleUnifyLoadHistory(msg) {
+export async function handleYeaftLoadHistory(msg) {
   const groupId = (msg && typeof msg.groupId === 'string' && msg.groupId) || null;
   // `lim` is now expressed in TURNS, not raw messages. `loadRecent` and
   // `loadRecentByGroup` use turn-based slicing so the cut never lands
@@ -3549,9 +3549,9 @@ export async function handleUnifyLoadHistory(msg) {
       skipSkills: false,
       serverMode: true,
     });
-    installUnifyRuntimeBridge(session);
+    installYeaftRuntimeBridge(session);
 
-    unifyConversationId = `unify-${Date.now()}`;
+    yeaftConversationId = `yeaft-${Date.now()}`;
 
     // Per-group history hydrates lazily via getOrCreateGroupHistory.
     // When the load-history call carries a groupId, force-refresh THAT
@@ -3567,9 +3567,9 @@ export async function handleUnifyLoadHistory(msg) {
   }
 
   // Always replay session_ready so refresh / reconnect rebuilds UI state.
-  sendUnifyEvent({
+  sendYeaftEvent({
     type: 'session_ready',
-    conversationId: unifyConversationId,
+    conversationId: yeaftConversationId,
     model: session.config.model,
     availableModels: session.config.availableModels || [],
     skills: session.status.skills,
@@ -3584,13 +3584,13 @@ export async function handleUnifyLoadHistory(msg) {
   try {
     getVpStatusBroker().broadcastSnapshot();
   } catch (err) {
-    console.warn('[Unify] vp-status snapshot broadcast (replay) failed:', err?.message || err);
+    console.warn('[Yeaft] vp-status snapshot broadcast (replay) failed:', err?.message || err);
   }
 
   // `msg.limit` is the replay-scrollback request from the frontend (UI
   // history pane, not engine context). Keep the bootstrap window small so
   // opening a group can paint the latest messages quickly; older rows are
-  // paged via `unify_load_more_history` when the user scrolls upward.
+  // paged via `yeaft_load_more_history` when the user scrolls upward.
   const limit = (typeof msg.limit === 'number') ? msg.limit : 10;
   const visiblePage = groupId
     ? loadVisibleGroupHistoryPage(session.conversationStore, groupId, limit)
@@ -3607,7 +3607,7 @@ export async function handleUnifyLoadHistory(msg) {
 
   for (const entry of replayEntries) {
     if (entry.role === 'user') {
-      sendUnifyOutput({
+      sendYeaftOutput({
         type: 'user',
         message: {
           content: entry.content,
@@ -3627,12 +3627,12 @@ export async function handleUnifyLoadHistory(msg) {
         turnId: entry.turnId || entry.threadId || 'main',
       };
       if (entry.speakerVpId) envelopeOpts.vpId = entry.speakerVpId;
-      sendUnifyOutput({
+      sendYeaftOutput({
         type: 'assistant',
         message: { id: entry.id || null, content: [{ type: 'text', text: entry.content }] },
         ts: entry.ts || null,
       }, envelopeOpts);
-      sendUnifyOutput({ type: 'result', result_text: '' }, envelopeOpts);
+      sendYeaftOutput({ type: 'result', result_text: '' }, envelopeOpts);
     }
   }
 
@@ -3657,7 +3657,7 @@ export async function handleUnifyLoadHistory(msg) {
     hasCompactSummaryFlag = session.conversationStore.hasAnyCompactSummaryForGroup(groupId);
   }
 
-  sendUnifyEvent({
+  sendYeaftEvent({
     type: 'history_loaded',
     count: replayEntries.length,
     hasCompactSummary: hasCompactSummaryFlag,
@@ -3672,21 +3672,21 @@ export async function handleUnifyLoadHistory(msg) {
 /**
  * Handle a "load older messages" pagination request. Reads `turns` more
  * turns of history strictly older than `beforeSeq` for `groupId`, and
- * emits them in a single `unify_history_chunk` envelope (NOT a
- * `unify_output` — that pipeline appends, but the frontend needs to
+ * emits them in a single `yeaft_history_chunk` envelope (NOT a
+ * `yeaft_output` — that pipeline appends, but the frontend needs to
  * PREPEND these older messages above what it already has).
  *
  * Tool replay is NOT included in this PR — same projection as
- * `handleUnifyLoadHistory` (user / assistant text only). On any internal
+ * `handleYeaftLoadHistory` (user / assistant text only). On any internal
  * failure we still emit an empty chunk so the spinner clears.
  *
  * @param {object} msg — { groupId, beforeSeq, turns }
  */
-export async function handleUnifyLoadMoreHistory(msg) {
+export async function handleYeaftLoadMoreHistory(msg) {
   const groupId = (msg && typeof msg.groupId === 'string' && msg.groupId) || null;
   const emit = (payload) => sendToServer({
-    type: 'unify_history_chunk',
-    conversationId: unifyConversationId,
+    type: 'yeaft_history_chunk',
+    conversationId: yeaftConversationId,
     groupId,
     ...payload,
   });
@@ -3703,11 +3703,11 @@ export async function handleUnifyLoadMoreHistory(msg) {
   try {
     result = loadVisibleGroupHistoryPage(session.conversationStore, groupId, turns, beforeSeq);
   } catch (err) {
-    console.error('[Unify] loadOlderByGroup failed:', err.message);
+    console.error('[Yeaft] loadOlderByGroup failed:', err.message);
     result = { messages: [], oldestSeq: null, hasMore: false };
   }
 
-  // Wire shape mirrors handleUnifyLoadHistory's projection: only visible
+  // Wire shape mirrors handleYeaftLoadHistory's projection: only visible
   // user / assistant text rows. Internal reflection/system-only rows stay
   // server-side, and stable ids + speaker attribution ride with each row
   // so older-history prepend renders exactly like refresh replay.
@@ -3732,10 +3732,10 @@ export async function handleUnifyLoadMoreHistory(msg) {
 }
 
 /**
- * Reset Unify session. Aborts the in-flight controller, tears down the
+ * Reset Yeaft session. Aborts the in-flight controller, tears down the
  * session, then re-initialises so the frontend gets fresh config.
  */
-export async function resetUnifySession() {
+export async function resetYeaftSession() {
   if (currentAbortCtrl && !currentAbortCtrl.signal.aborted) {
     try { currentAbortCtrl.abort(); } catch { /* ignore */ }
   }
@@ -3748,7 +3748,7 @@ export async function resetUnifySession() {
     await session.shutdown();
     session = null;
   }
-  unifyConversationId = null;
+  yeaftConversationId = null;
   // Per-group histories live on groupContexts entries — clearing the
   // map (a few lines below) drops every group's history with it. No
   // separate global tape to clear.
@@ -3783,7 +3783,7 @@ export async function resetUnifySession() {
   try {
     getVpStatusBroker().reset();
   } catch (err) {
-    console.warn('[Unify] vp-status broker reset failed:', err?.message || err);
+    console.warn('[Yeaft] vp-status broker reset failed:', err?.message || err);
   }
 
   try {
@@ -3794,16 +3794,16 @@ export async function resetUnifySession() {
       skipSkills: false,
       serverMode: true,
     });
-    installUnifyRuntimeBridge(session);
+    installYeaftRuntimeBridge(session);
 
-    unifyConversationId = `unify-${Date.now()}`;
+    yeaftConversationId = `yeaft-${Date.now()}`;
 
     // Per-group history hydrates lazily via getOrCreateGroupHistory on
     // first read. Nothing to seed here.
 
-    sendUnifyEvent({
+    sendYeaftEvent({
       type: 'session_ready',
-      conversationId: unifyConversationId,
+      conversationId: yeaftConversationId,
       model: session.config.model,
       availableModels: session.config.availableModels || [],
       skills: session.status.skills,
@@ -3817,9 +3817,9 @@ export async function resetUnifySession() {
     try {
       getVpStatusBroker().broadcastSnapshot();
     } catch (err) {
-      console.warn('[Unify] vp-status snapshot broadcast (reset) failed:', err?.message || err);
+      console.warn('[Yeaft] vp-status snapshot broadcast (reset) failed:', err?.message || err);
     }
   } catch (err) {
-    console.error('[Unify] Failed to re-initialize session after reset:', err.message);
+    console.error('[Yeaft] Failed to re-initialize session after reset:', err.message);
   }
 }