@yeaft/webchat-agent 0.1.649 → 0.1.652

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.649",
+  "version": "0.1.652",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/unify/pipeline/dispatcher.js

@@ -1,104 +1,55 @@
 /**
- * pipeline/dispatcher.js — task-310 Phase 2 integration.
+ * pipeline/dispatcher.js — H2.f.1 single-thread dispatcher.
  *
- * Composes the three Phase-2 building blocks into a single linear pipeline:
+ * H2 retires the multi-thread routing model. The new memory architecture
+ * (pre-flow FTS + adjustMemory) does not need an LLM router to pick a
+ * thread per turn; one engine, one conversation. This module preserves
+ * the historic `submit()` / `drain()` API surface so web-bridge does not
+ * change in this PR — it just always routes to MAIN_THREAD_ID and never
+ * calls a classifier.
+ *
+ * The pipeline now collapses to:
  *
  *     unify_chat input
  *            │
  *            ▼
- *    ┌──────────────┐   (task-307b)
+ *    ┌──────────────┐
  *    │ InputQueue   │   persistent FIFO of pending user inputs
  *    └──────┬───────┘
- *           │ claim()                (transition pending → routing)
- *           ▼
- *    ┌──────────────┐   (task-309)
- *    │ IntentClass. │   explicit @prefix / override / LLM / fallback
- *    └──────┬───────┘
- *           │ { action, targetThreadId, source, reason }
- *           ▼
- *    ┌──────────────┐   (task-308)
- *    │ EngineReg.   │   ensure(threadId) → EngineInstance
- *    └──────┬───────┘
- *           │ inst.query({ prompt })
+ *           │ claim()
  *           ▼
  *    ┌──────────────┐
- *    │ Engine events│   text_delta / tool_call / tool_end / …
+ *    │ EngineReg.   │   ensure(MAIN_THREAD_ID) → EngineInstance
  *    └──────┬───────┘
- *           │ each event tagged { ...ev, threadId } by EngineInstance
+ *           │ inst.query({ prompt })
  *           ▼
- *      web-bridge forwards to `unify_output`
- *
- * ### Responsibilities
- *
- * This module OWNS the pipeline's control-flow decisions:
- *
- *   - `submit(input)` — enqueue + return the queue entry, non-streaming.
- *     The caller either invokes `drain()` to actually dispatch, or lets a
- *     future background worker pick it up. (We go with the simple "drain
- *     on submit" default because the web-bridge is the sole producer and
- *     cannot afford a stuck pending entry.)
+ *      web-bridge forwards engine events as `unify_output`.
  *
- *   - `dispatch(entry)` async-generator — runs one entry through router +
- *     engine. Yields a stream of bridge events:
- *
- *       { type: 'input_queue_updated', pending, routing, … }
- *       { type: 'routing_decision', entryId, action, targetThreadId, source, reason }
- *       { type: 'thread_list_updated', threads, currentThreadId }  (on fork)
- *       { type: 'engine_event', threadId, event }     // raw Engine event
- *       { type: 'error', error: Error, retryable }
- *
- *     The web-bridge translates `engine_event`s into claude_output (the
- *     existing code path) and forwards the pipeline-level events as
- *     `unify_output.event`.
- *
- *   - `drain()` — convenience: claim + dispatch repeatedly until the queue
- *     is empty. Web-bridge calls this after every submit().
- *
- * ### What this module does NOT own
- *
- *   - Persistence of messages (Engine / EngineInstance).
- *   - ThreadStore mutations beyond incrementing currentId on 'switch' /
- *     creating a fork thread on 'fork'.
- *   - WebSocket framing (web-bridge does that).
- *   - Abort semantics — each caller wraps `dispatch()` with its own
- *     AbortController / signal (we forward it to EngineInstance.query).
- *
- * ### Concurrent reflow (spec point 5)
- *
- * Node's single-thread event loop means two concurrent `dispatch()` calls
- * interleave at await points. Every yielded `engine_event` carries a
- * `threadId` (EngineInstance re-tags), so the web-bridge can render events
- * into the correct UI bubble. The dispatcher itself holds NO per-turn
- * state on `this` — all state lives in the async generator's closure, so
- * two pipelines can be in-flight at the same time without aliasing.
+ * `routing_decision` is still yielded so the wire protocol is unchanged
+ * (action='continue', source='single-thread'). Frontend treats it as a
+ * no-op marker.
  */
 
 import { MAIN_THREAD_ID } from '../threads/store.js';
-import { getFeatureStore } from '../tools/feature-tools.js';
 
 /**
- * Per-entry transient metadata (messageId, override) lives here — a
- * WeakMap keyed by the queue entry object so it is NEVER persisted to
- * disk by InputQueueStore.#writeEntry. Entries are GC'd together with
- * the entry once the queue drops the strong reference.
- * @type {WeakMap<object, {messageId?: string, override?: {threadId: string}}>}
+ * Per-entry transient metadata (messageId, queryOpts) lives in a WeakMap
+ * keyed by the queue entry object so it is NEVER persisted to disk by
+ * InputQueueStore. Entries are GC'd together with the entry once the
+ * queue drops the strong reference.
+ * @type {WeakMap<object, {messageId?: string, queryOpts?: object}>}
  */
 const transientMeta = new WeakMap();
 
 /**
- * @typedef {'continue'|'interrupt'|'fork'|'switch'} RouterAction
- *
  * @typedef {Object} SubmitOptions
- * @property {string} [messageId]   — optional stable id for override()
- * @property {{ threadId: string }} [override] — UI-side `@thread-name` hint
- *   or user correction: skip router, go straight to `switch`/`continue`
- *   targeting the given threadId.
+ * @property {string} [messageId]
+ * @property {object} [queryOpts]
+ * @property {object} [override] — accepted for back-compat, ignored.
  *
  * @typedef {Object} DispatcherDeps
  * @property {import('../input-queue/store.js').InputQueueStore} inputQueue
- * @property {import('../router/intent-classifier.js').IntentClassifier} router
  * @property {import('../threads/engine-registry.js').ThreadEngineRegistry} engineRegistry
- * @property {import('../threads/store.js').ThreadStore} threadStore
  * @property {object} [trace]
  */
 
@@ -107,19 +58,13 @@ export class Dispatcher {
   #deps;
 
   constructor(deps) {
-    const { inputQueue, router, engineRegistry, threadStore } = deps || {};
+    const { inputQueue, engineRegistry } = deps || {};
     if (!inputQueue || typeof inputQueue.enqueue !== 'function') {
       throw new Error('Dispatcher: inputQueue is required');
     }
-    if (!router || typeof router.classify !== 'function') {
-      throw new Error('Dispatcher: router is required');
-    }
     if (!engineRegistry || typeof engineRegistry.ensure !== 'function') {
       throw new Error('Dispatcher: engineRegistry is required');
     }
-    if (!threadStore || typeof threadStore.list !== 'function') {
-      throw new Error('Dispatcher: threadStore is required');
-    }
     this.#deps = deps;
   }
 
@@ -143,8 +88,7 @@ export class Dispatcher {
 
   /**
    * Enqueue a user input. Does NOT dispatch — caller invokes `drain()` or
-   * `dispatch(entry)` next. Separated so callers can atomically observe
-   * the `input_queue_updated` snapshot before the first router call fires.
+   * `dispatch(entry)` next.
    *
    * @param {string} text
    * @param {SubmitOptions} [opts]
@@ -156,14 +100,8 @@ export class Dispatcher {
     }
     const { inputQueue } = this.#deps;
     const entry = inputQueue.enqueue(text);
-    // Transient metadata lives in a WeakMap keyed by the entry — it is
-    // intentionally off the entry object itself so InputQueueStore's
-    // JSON.stringify write path does NOT leak `_messageId`/`_override`
-    // to disk. The WeakMap entry is dropped when the queue releases the
-    // entry reference (after markRouted removes it from memory).
     transientMeta.set(entry, {
       messageId: opts.messageId || undefined,
-      override: opts.override || undefined,
       queryOpts: opts.queryOpts || undefined,
     });
     const snapshot = this.#queueSnapshot();
@@ -172,7 +110,6 @@ export class Dispatcher {
 
   /**
    * Drain the queue: claim → dispatch in a loop until empty.
-   * Yields the union of every `dispatch()`'s events, interleaved naturally.
    *
    * @param {{ signal?: AbortSignal }} [opts]
    * @yields {object} bridge events
@@ -188,22 +125,18 @@ export class Dispatcher {
   }
 
   /**
-   * Dispatch one queue entry through router + engine. Transitions the
-   * entry: pending → routing (on claim) → dispatched (on success) or back
-   * to pending (on router exception, which is already guarded inside the
-   * classifier — so in practice this branch is very rare).
+   * Dispatch one queue entry to the single thread engine. Always routes
+   * to MAIN_THREAD_ID — no LLM classification, no fork/switch/interrupt.
    *
    * @param {object} entry — from inputQueue.peek() or inputQueue.enqueue()
    * @param {{ signal?: AbortSignal }} [opts]
    * @yields {object} bridge events
    */
   async *dispatch(entry, opts = {}) {
-    const { inputQueue, router, engineRegistry, threadStore } = this.#deps;
+    const { inputQueue, engineRegistry } = this.#deps;
     const { signal } = opts;
 
     // ── Step 1: claim (pending → routing) ──
-    // Note: we assume the caller already found `entry` as the head. A
-    // concurrent dispatcher would have claimed it first; we check for that.
     let claimed = entry;
     if (entry.status === 'pending') {
       claimed = inputQueue.claim();
@@ -215,80 +148,19 @@ export class Dispatcher {
     }
     yield this.#queueSnapshot();
 
-    // ── Step 2: gather router context ──
-    const currentThreadId = threadStore.currentId || MAIN_THREAD_ID;
-    const allThreads = threadStore.list().map(t => ({
-      id: t.id, name: t.name, goal: t.goal, status: t.status,
-    }));
-    const pendingFeatures = this.#listPendingFeatures();
-
-    // ── Step 3: classify (explicit override > classifier) ──
-    /** @type {import('../router/intent-classifier.js').RouterDecision} */
-    let decision;
-    const meta = transientMeta.get(entry) || {};
-    const ov = meta.override;
-    if (ov && typeof ov.threadId === 'string' && ov.threadId) {
-      const known = allThreads.some(t => t.id === ov.threadId) || ov.threadId === currentThreadId;
-      if (known) {
-        const action = ov.threadId === currentThreadId ? 'continue' : 'switch';
-        decision = {
-          action,
-          targetThreadId: ov.threadId,
-          reason: 'ui_override',
-          source: 'override',
-        };
-      }
-    }
-    if (!decision) {
-      try {
-        decision = await router.classify({
-          userMessage: claimed.text,
-          currentThreadId,
-          allThreads,
-          pendingFeatures,
-          messageId: meta.messageId || undefined,
-        });
-      } catch (err) {
-        // Classifier is wrapped in its own try/catch already; reaching here
-        // means a truly unexpected failure. Degrade to continue.
-        decision = {
-          action: 'continue',
-          targetThreadId: currentThreadId,
-          reason: `dispatcher_classify_exception: ${err.message}`,
-          source: 'fallback',
-        };
-      }
-    }
-
+    // ── Step 2: synthesize a "continue to main" routing decision so the
+    //            wire protocol stays compatible with old clients. ──
+    const targetThreadId = MAIN_THREAD_ID;
     yield {
       type: 'routing_decision',
       entryId: claimed.id,
-      action: decision.action,
-      targetThreadId: decision.targetThreadId,
-      source: decision.source || 'llm',
-      reason: decision.reason || '',
+      action: 'continue',
+      targetThreadId,
+      source: 'single-thread',
+      reason: 'single-thread-dispatcher',
     };
 
-    // ── Step 4: resolve target thread (fork may create a new one) ──
-    let targetThreadId = decision.targetThreadId;
-    if (decision.action === 'fork') {
-      const parentId = decision.targetThreadId || currentThreadId;
-      const forked = this.#spawnForkedThread(parentId, claimed.text);
-      if (forked) {
-        targetThreadId = forked.id;
-        yield this.#threadListSnapshot();
-      }
-    } else if (decision.action === 'switch') {
-      // Move the ThreadStore cursor so subsequent tool-originated events
-      // see the right thread for persistence hooks. Guard: not every
-      // ThreadStore implementation exposes has() (e.g. historic mocks).
-      const hasFn = typeof threadStore.has === 'function' ? (id) => threadStore.has(id) : () => true;
-      if (hasFn(targetThreadId)) {
-        try { threadStore.switch(targetThreadId); } catch { /* ignore */ }
-      }
-    }
-
-    // ── Step 5: dispatch to EngineInstance ──
+    // ── Step 3: dispatch to the single EngineInstance ──
     let instance;
     try {
       instance = engineRegistry.ensure(targetThreadId);
@@ -312,61 +184,10 @@ export class Dispatcher {
       yield { type: 'error', error: err, retryable: true };
     }
   }
-
-  // ──────────────────────────────────────────────────────────────
-
-  #threadListSnapshot() {
-    const { threadStore } = this.#deps;
-    const threads = threadStore.list().map(t => ({
-      id: t.id,
-      name: t.name,
-      goal: t.goal || '',
-      parentThreadId: t.parentThreadId || null,
-      status: t.status,
-      archived: !!t.archived,
-      messageCount: t.messageCount || 0,
-      lastMessageAt: t.lastMessageAt || null,
-    }));
-    return {
-      type: 'thread_list_updated',
-      threads,
-      currentThreadId: threadStore.currentId,
-    };
-  }
-
-  #spawnForkedThread(parentId, promptText) {
-    const { threadStore } = this.#deps;
-    if (!threadStore.create) return null;
-    // Short label from first non-empty line, capped at 40 chars.
-    const firstLine = (promptText || '').split(/\r?\n/).find(l => l.trim()) || 'fork';
-    const name = firstLine.trim().slice(0, 40);
-    try {
-      return threadStore.create({ name, parentThreadId: parentId });
-    } catch {
-      return null;
-    }
-  }
-
-  #listPendingFeatures() {
-    // Best-effort: the FeatureStore is a singleton initialised in loadSession().
-    // If the store isn't available (e.g. unit tests without a session) we
-    // just return []. Never let a FeatureStore exception break routing.
-    try {
-      const store = getFeatureStore();
-      if (!store || typeof store.list !== 'function') return [];
-      const pending = store.list({ status: 'pending' }) || [];
-      return pending.map(t => ({
-        id: t.id,
-        title: t.title || '',
-        threadId: t.threadId || null,
-      }));
-    } catch { /* ignore */ }
-    return [];
-  }
 }
 
 /**
- * Build a Dispatcher from session-level deps.
+ * Build a single-thread Dispatcher from session-level deps.
  * @param {DispatcherDeps} deps
  * @returns {Dispatcher}
  */

package/unify/session.js

@@ -29,7 +29,10 @@ import { Engine } from './engine.js';
 import { createThreadEngineRegistry } from './threads/engine-registry.js';
 import { MAIN_THREAD_ID } from './threads/store.js';
 import { getThreadStore } from './threads/store.js';
-import { createIntentClassifier } from './router/intent-classifier.js';
+// H2.f.1: intent-classifier (LLM router) is retired. Memory recall now
+// runs through pre-flow (memory/preflow.js) + post-turn adjustMemory
+// (memory/adjust.js); the dispatcher routes every input to the single
+// MAIN_THREAD_ID engine instance.
 import { initInputQueueStore } from './input-queue/store.js';
 import { createDispatcher } from './pipeline/dispatcher.js';
 import { ensureDefaultGroupIfEmpty } from './groups/group-crud.js';
@@ -360,24 +363,22 @@ export async function loadSession(options = {}) {
   // Seed the main-thread instance so listActive() is non-empty from T=0.
   engineRegistry.ensure(MAIN_THREAD_ID);
 
-  // task-309 Phase 2 router: intent classifier that routes incoming user
-  // messages to the right EngineInstance. Shares the same adapter/trace/
-  // config as the engines so it can use primaryModel for classification.
-  const router = createIntentClassifier({ adapter, trace, config });
+  // H2.f.1: the LLM intent-classifier is retired. The dispatcher now
+  // unconditionally routes every input to the MAIN_THREAD_ID engine
+  // instance. Memory recall happens via memory/preflow.js (pre-turn)
+  // and memory/adjust.js (post-turn).
 
   // task-310 Phase 2 integration: wire InputQueue + Dispatcher so the
   // web-bridge can submit `unify_chat` inputs through the unified pipeline
-  // (queue → router → engineRegistry → EngineInstance). In read-only mode
-  // the queue is memory-only (no disk writes).
+  // (queue → engineRegistry → EngineInstance). In read-only mode the
+  // queue is memory-only (no disk writes).
   const inputQueue = initInputQueueStore({
     yeaftDir: config._readOnly ? null : yeaftDir,
     force: true,
   });
   const dispatcher = createDispatcher({
     inputQueue,
-    router,
     engineRegistry,
-    threadStore: getThreadStore(),
     trace,
   });
 
@@ -416,7 +417,10 @@ export async function loadSession(options = {}) {
   return {
     engine,
     engineRegistry,
-    router,
+    // H2.f.1: `router` removed (intent classifier retired). Kept the
+    // property as `null` for any caller doing back-compat existence
+    // checks; the dispatcher now always routes to MAIN_THREAD_ID.
+    router: null,
     inputQueue,
     dispatcher,
     adapter,