@yeaft/webchat-agent 0.1.648 → 0.1.651

package/package.json

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

package/unify/dream-v2/prompts/index.js

@@ -17,8 +17,34 @@ const FILES = {
   triagePass2: 'triage-pass2.md',
   update: 'update.md',
   create: 'create.md',
+  // H2.e — per-scope segment extraction prompts (one per scope family)
+  extractUser: 'extract-user.md',
+  extractVp: 'extract-vp.md',
+  extractGroup: 'extract-group.md',
+  extractFeature: 'extract-feature.md',
+  extractTopic: 'extract-topic.md',
+  // H2.e — per-scope summary compression
+  summarizeScope: 'summarize-scope.md',
 };
 
+/**
+ * Map a scope string (e.g. "user", "vp/alice", "topic/auth/jwt") to the
+ * extraction template name. Unknown scopes fall back to `extractTopic`
+ * (the most generic template) so we never throw at extraction time.
+ *
+ * @param {string} scope
+ * @returns {keyof typeof FILES}
+ */
+export function extractTemplateForScope(scope) {
+  if (!scope || typeof scope !== 'string') return 'extractTopic';
+  if (scope === 'user') return 'extractUser';
+  if (scope.startsWith('vp/')) return 'extractVp';
+  if (scope.startsWith('group/')) return 'extractGroup';
+  if (scope.startsWith('feature/')) return 'extractFeature';
+  if (scope.startsWith('topic/')) return 'extractTopic';
+  return 'extractTopic';
+}
+
 /** @type {Record<string, string>} */
 const cache = {};
 

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,

package/unify/router/intent-classifier.js

@@ -1,444 +0,0 @@
-/**
- * intent-classifier.js — task-309 (Phase 2 Router).
- *
- * Routes an incoming user message to one of four intents relative to the
- * current set of live threads + pending features:
- *
- *   - 'continue'  — append to currentThreadId (default / most common)
- *   - 'interrupt' — steal focus on another LIVE thread (e.g. user replies
- *                   while another thread is mid-stream)
- *   - 'fork'      — spawn a NEW thread from the current one
- *   - 'switch'    — re-focus on a different existing thread
- *
- * ### Routing pipeline
- *
- *   1. **Explicit signal parse** (no LLM):
- *      - Prefix `@thread-<id>` → switch/interrupt that thread (direct).
- *      - Prefix `@feat-<nnn>` → switch to the thread attached to that task,
- *        if any; otherwise fall through to LLM.
- *   2. **User override lookup**: if UI previously called `.override(msgId,…)`
- *      for this message, return that decision verbatim.
- *   3. **LLM classification**: one call to `primaryModel` (Q2 — router also
- *      uses primary; fast-model route disabled for this phase) with a small
- *      JSON-only prompt. Parse `{action, targetThreadId, reason}`.
- *   4. **Fallback**: on ANY exception, unknown action, or unknown
- *      targetThreadId → degrade to `continue` on the current thread and
- *      record a `router.failure` trace event.
- *
- * ### Out of scope (task-310)
- *
- *   - user_input_queue storage of pending messages.
- *   - Actual dispatch to an EngineInstance (the router just decides WHERE;
- *     task-310 owns the WHO/WHEN).
- *   - Concurrent stream flush-back semantics.
- *
- * This module only exposes `classify()` + `override()`; the caller owns the
- * registry routing after the decision is returned.
- */
-
-/**
- * @typedef {'continue'|'interrupt'|'fork'|'switch'} RouterAction
- *
- * @typedef {Object} RouterDecision
- * @property {RouterAction} action
- * @property {string} targetThreadId — resolved thread (always defined; for
- *   'fork' this is the PARENT thread, the actual new-thread id is chosen
- *   by the caller when it creates the thread)
- * @property {string} reason — short human-readable explanation
- * @property {'explicit'|'override'|'llm'|'fallback'} [source]
- *
- * @typedef {Object} ThreadSummary — minimum info the classifier needs
- * @property {string} id
- * @property {string} [name]
- * @property {string} [goal]
- * @property {string} [status]
- *
- * @typedef {Object} PendingFeature
- * @property {string} id
- * @property {string} [title]
- * @property {string} [threadId]  — attached thread, if any
- * @property {string} [status]
- *
- * @typedef {Object} ClassifyInput
- * @property {string} userMessage
- * @property {string} currentThreadId
- * @property {Array<ThreadSummary>} [allThreads]
- * @property {Array<PendingFeature>} [pendingFeatures]
- * @property {string} [messageId] — if provided, any stored override for this
- *   id is consulted before the LLM path
- */
-
-const VALID_ACTIONS = ['continue', 'interrupt', 'fork', 'switch'];
-
-/**
- * Match a leading `@thread-xxx` marker. Captures the thread id WITHOUT the
- * `@` prefix. Case-sensitive (thread ids are canonical).
- * Example matches: "@thread-main ...", "@thread-abcd1234 ..."
- */
-const THREAD_PREFIX_RE = /^@(thread-[A-Za-z0-9_-]+)\b\s*/;
-
-/**
- * Match a leading `@feat-NNN` marker. Captures the feature id WITHOUT the `@`.
- * Example matches: "@feat-309 ...", "@feat-abc ..."
- */
-const FEATURE_PREFIX_RE = /^@(feat-[A-Za-z0-9_-]+)\b\s*/;
-
-export class IntentClassifier {
-  /** @type {object} */            #adapter;
-  /** @type {object} */            #trace;
-  /** @type {object} */            #config;
-  /** @type {Map<string, RouterDecision>} */ #overrides;
-
-  /**
-   * @param {{
-   *   adapter: object,
-   *   trace?: object,
-   *   config: object,
-   * }} deps
-   */
-  constructor({ adapter, trace, config } = {}) {
-    if (!adapter || typeof adapter.stream !== 'function') {
-      throw new Error('IntentClassifier: adapter with .stream() is required');
-    }
-    if (!config || typeof config !== 'object') {
-      throw new Error('IntentClassifier: config is required');
-    }
-    this.#adapter = adapter;
-    this.#trace = trace || null;
-    this.#config = config;
-    this.#overrides = new Map();
-  }
-
-  /**
-   * Store a user correction for a specific messageId. Next `.classify()`
-   * call with the matching `messageId` will return this decision verbatim
-   * (and consume it, so a second call re-enters normal routing).
-   *
-   * Used by the UI "不对，我是问 X" affordance.
-   *
-   * @param {string} messageId
-   * @param {{ action: RouterAction, targetThreadId: string, reason?: string }} decision
-   * @returns {void}
-   */
-  override(messageId, decision) {
-    if (!messageId || typeof messageId !== 'string') {
-      throw new Error('IntentClassifier.override: messageId required');
-    }
-    if (!decision || !VALID_ACTIONS.includes(decision.action)) {
-      throw new Error(`IntentClassifier.override: invalid action ${decision && decision.action}`);
-    }
-    if (!decision.targetThreadId || typeof decision.targetThreadId !== 'string') {
-      throw new Error('IntentClassifier.override: targetThreadId required');
-    }
-    this.#overrides.set(messageId, {
-      action: decision.action,
-      targetThreadId: decision.targetThreadId,
-      reason: decision.reason || 'user_override',
-      source: 'override',
-    });
-  }
-
-  /** Whether an override is currently stored for a given messageId. */
-  hasOverride(messageId) {
-    return this.#overrides.has(messageId);
-  }
-
-  /** Test-only / admin — drop all stored overrides. */
-  clearOverrides() {
-    this.#overrides.clear();
-  }
-
-  /**
-   * Classify the user message into a router decision.
-   *
-   * Resolution order: override → explicit @prefix → LLM → fallback.
-   *
-   * @param {ClassifyInput} input
-   * @returns {Promise<RouterDecision>}
-   */
-  async classify(input) {
-    const {
-      userMessage,
-      currentThreadId,
-      allThreads = [],
-      pendingFeatures = [],
-      messageId,
-    } = input || {};
-
-    if (!userMessage || typeof userMessage !== 'string') {
-      throw new Error('classify: userMessage is required');
-    }
-    if (!currentThreadId || typeof currentThreadId !== 'string') {
-      throw new Error('classify: currentThreadId is required');
-    }
-
-    // 1. User override takes precedence over everything else.
-    if (messageId && this.#overrides.has(messageId)) {
-      const decision = this.#overrides.get(messageId);
-      this.#overrides.delete(messageId);
-      return { ...decision, source: 'override' };
-    }
-
-    // 2. Explicit signals (no LLM call).
-    const explicit = this.#parseExplicit(userMessage, {
-      currentThreadId, allThreads, pendingFeatures,
-    });
-    if (explicit) return explicit;
-
-    // 3. LLM classification (best-effort).
-    try {
-      const decision = await this.#classifyWithLLM({
-        userMessage, currentThreadId, allThreads, pendingFeatures,
-      });
-      return this.#validateOrFallback(decision, {
-        currentThreadId, allThreads, reason: 'llm',
-      });
-    } catch (err) {
-      this.#traceFailure(err, { userMessage, currentThreadId });
-      return this.#fallback(currentThreadId, `classifier_exception: ${err.message}`);
-    }
-  }
-
-  // ──────────────────────────────────────────────────────────────
-  // Explicit-signal parser
-  // ──────────────────────────────────────────────────────────────
-
-  /**
-   * @param {string} msg
-   * @param {{ currentThreadId: string, allThreads: Array<ThreadSummary>, pendingFeatures: Array<PendingFeature> }} ctx
-   * @returns {RouterDecision|null}
-   */
-  #parseExplicit(msg, { currentThreadId, allThreads, pendingFeatures }) {
-    const trimmed = msg.replace(/^\s+/, '');
-
-    // @thread-xxx
-    const tm = trimmed.match(THREAD_PREFIX_RE);
-    if (tm) {
-      const targetId = tm[1];
-      const known = allThreads.some(t => t && t.id === targetId);
-      if (!known) {
-        // Unknown thread — silently degrade. Record trace so ops can see it.
-        this.#traceFailure(
-          new Error(`unknown thread in @prefix: ${targetId}`),
-          { userMessage: msg, currentThreadId },
-        );
-        return this.#fallback(currentThreadId, `unknown_thread:${targetId}`);
-      }
-      const action = targetId === currentThreadId ? 'continue' : 'switch';
-      return {
-        action,
-        targetThreadId: targetId,
-        reason: `explicit @${targetId}`,
-        source: 'explicit',
-      };
-    }
-
-    // @feat-NNN
-    const mt = trimmed.match(FEATURE_PREFIX_RE);
-    if (mt) {
-      const featureId = mt[1];
-      const feature = pendingFeatures.find(t => t && t.id === featureId);
-      if (feature && feature.threadId) {
-        const action = feature.threadId === currentThreadId ? 'continue' : 'switch';
-        return {
-          action,
-          targetThreadId: feature.threadId,
-          reason: `explicit @${featureId} → ${feature.threadId}`,
-          source: 'explicit',
-        };
-      }
-      // Feature unknown or not attached — fall through to LLM.
-      return null;
-    }
-
-    return null;
-  }
-
-  // ──────────────────────────────────────────────────────────────
-  // LLM classification path
-  // ──────────────────────────────────────────────────────────────
-
-  /** Build the prompt/messages for the router LLM call. */
-  #buildMessages({ userMessage, currentThreadId, allThreads, pendingFeatures }) {
-    const system = [
-      'You are a thread-routing classifier for a multi-thread AI chat.',
-      'Given the user message and current thread context, pick exactly one action:',
-      "  - 'continue'  — the message belongs to the current thread",
-      "  - 'interrupt' — it answers / redirects a DIFFERENT live thread",
-      "  - 'fork'      — it starts a new tangent that should be its own thread",
-      "  - 'switch'    — it explicitly re-focuses on another existing thread",
-      '',
-      'Respond with ONE LINE of JSON, nothing else:',
-      '{"action":"<action>","targetThreadId":"<id>","reason":"<short>"}',
-      '',
-      'Rules:',
-      '- For fork, set targetThreadId to the CURRENT thread (it is the parent).',
-      '- For continue, set targetThreadId to the CURRENT thread.',
-      '- For switch/interrupt, targetThreadId MUST be one of the known thread ids.',
-      '- If uncertain, pick continue.',
-    ].join('\n');
-
-    const ctx = {
-      currentThreadId,
-      threads: (allThreads || []).map(t => ({
-        id: t.id,
-        name: t.name || '',
-        goal: t.goal || '',
-        status: t.status || 'active',
-      })),
-      pendingFeatures: (pendingFeatures || []).map(t => ({
-        id: t.id,
-        title: t.title || '',
-        threadId: t.threadId || null,
-      })),
-    };
-
-    const user = [
-      'Context:',
-      JSON.stringify(ctx),
-      '',
-      'User message:',
-      userMessage,
-    ].join('\n');
-
-    return { system, messages: [{ role: 'user', content: user }] };
-  }
-
-  /** @returns {Promise<RouterDecision>} */
-  async #classifyWithLLM({ userMessage, currentThreadId, allThreads, pendingFeatures }) {
-    const { system, messages } = this.#buildMessages({
-      userMessage, currentThreadId, allThreads, pendingFeatures,
-    });
-    // Q2: router uses primaryModel (no fast-model split yet).
-    const model = this.#config.primaryModel || this.#config.model;
-    if (!model) {
-      throw new Error('router: no primaryModel configured');
-    }
-
-    let text = '';
-    for await (const event of this.#adapter.stream({
-      model,
-      system,
-      messages,
-      maxTokens: 256,
-    })) {
-      if (event && event.type === 'text_delta' && typeof event.text === 'string') {
-        text += event.text;
-      } else if (event && event.type === 'error') {
-        throw event.error || new Error('router stream error');
-      }
-    }
-    return parseLLMDecision(text);
-  }
-
-  // ──────────────────────────────────────────────────────────────
-  // Validation & fallback
-  // ──────────────────────────────────────────────────────────────
-
-  #validateOrFallback(decision, { currentThreadId, allThreads, reason }) {
-    if (!decision || !VALID_ACTIONS.includes(decision.action)) {
-      this.#traceFailure(
-        new Error(`invalid action from classifier: ${decision && decision.action}`),
-        { currentThreadId },
-      );
-      return this.#fallback(currentThreadId, 'invalid_action');
-    }
-    const known = new Set((allThreads || []).map(t => t && t.id).filter(Boolean));
-    known.add(currentThreadId);
-
-    // For fork/continue the target MUST be the current thread parent (we
-    // allow any known thread since callers may want to fork from a
-    // non-current parent, but continue MUST land on current).
-    if (decision.action === 'continue' && decision.targetThreadId !== currentThreadId) {
-      decision.targetThreadId = currentThreadId;
-    }
-    if (!decision.targetThreadId || !known.has(decision.targetThreadId)) {
-      this.#traceFailure(
-        new Error(`unknown targetThreadId: ${decision.targetThreadId}`),
-        { currentThreadId },
-      );
-      return this.#fallback(currentThreadId, 'unknown_target');
-    }
-    return {
-      action: decision.action,
-      targetThreadId: decision.targetThreadId,
-      reason: decision.reason || reason,
-      source: 'llm',
-    };
-  }
-
-  /** @returns {RouterDecision} */
-  #fallback(currentThreadId, reason) {
-    return {
-      action: 'continue',
-      targetThreadId: currentThreadId,
-      reason,
-      source: 'fallback',
-    };
-  }
-
-  #traceFailure(err, ctx) {
-    if (!this.#trace || typeof this.#trace.logEvent !== 'function') return;
-    try {
-      this.#trace.logEvent({
-        traceId: 'router',
-        eventType: 'router.failure',
-        eventData: {
-          error: err && err.message ? err.message : String(err),
-          currentThreadId: ctx && ctx.currentThreadId,
-          userMessage: ctx && typeof ctx.userMessage === 'string'
-            ? ctx.userMessage.slice(0, 200)
-            : undefined,
-        },
-      });
-    } catch {
-      // Trace must never propagate errors into the router path.
-    }
-  }
-}
-
-/**
- * Parse the LLM's single-line JSON response. Tolerates a leading/trailing
- * code fence ```json ... ``` because some proxies wrap.
- *
- * @param {string} raw
- * @returns {RouterDecision}
- */
-export function parseLLMDecision(raw) {
-  if (!raw || typeof raw !== 'string') {
-    throw new Error('empty classifier response');
-  }
-  let text = raw.trim();
-  // Strip ```json fences if present.
-  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
-  if (fenced) text = fenced[1].trim();
-  // Take the first { ... } block.
-  const start = text.indexOf('{');
-  const end = text.lastIndexOf('}');
-  if (start < 0 || end <= start) {
-    throw new Error('no JSON object in classifier response');
-  }
-  const slice = text.slice(start, end + 1);
-  let obj;
-  try {
-    obj = JSON.parse(slice);
-  } catch (e) {
-    throw new Error(`classifier response not valid JSON: ${e.message}`);
-  }
-  return {
-    action: obj.action,
-    targetThreadId: obj.targetThreadId,
-    reason: obj.reason || '',
-  };
-}
-
-/**
- * Build an IntentClassifier from session-level deps. This is the entry
- * point used by session.js to populate `session.router`.
- *
- * @param {{ adapter: object, trace?: object, config: object }} deps
- * @returns {IntentClassifier}
- */
-export function createIntentClassifier(deps) {
-  return new IntentClassifier(deps);
-}