@yeaft/webchat-agent 0.1.505 → 0.1.507

package/connection/message-router.js

@@ -25,7 +25,7 @@ import { sendToServer, flushMessageBuffer } from './buffer.js';
 import { handleRestartAgent, handleUpgradeAgent } from './upgrade.js';
 import { loadMcpServers, updateMcpConfig } from '../mcp.js';
 import { getLlmConfig, updateLlmConfig, getUnifySettings, updateUnifySettings } from '../unify/config-api.js';
-import { handleUnifyChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory, handleUnifyMergeThread, handleUnifyForkThread } from '../unify/web-bridge.js';
+import { handleUnifyChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory, handleUnifyMergeThread, handleUnifyForkThread, handleUnifyAbortThread, handleUnifyAbortAll } from '../unify/web-bridge.js';
 
 export async function handleMessage(msg) {
   switch (msg.type) {
@@ -373,6 +373,19 @@ export async function handleMessage(msg) {
       handleUnifyForkThread(msg);
       break;
 
+    case 'unify_abort_thread':
+      // task-325c: user-initiated abort of a single thread's in-flight
+      // query. Payload `{ threadId }`. Silent no-op when the thread has
+      // no in-flight controller.
+      handleUnifyAbortThread(msg);
+      break;
+
+    case 'unify_abort_all':
+      // task-325c: user-initiated abort of ALL in-flight queries across
+      // every thread. Always emits `unify_aborted` ack.
+      handleUnifyAbortAll();
+      break;
+
     // Expert roles definition (for ExpertPanel detail view)
     case 'get_expert_roles': {
       const { getExpertRolesDefinition } = await import('../expert-roles.js');

package/package.json

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

package/unify/effort.js

@@ -0,0 +1,119 @@
+/**
+ * effort.js — Scenario → effort decision tree for Unify
+ *
+ * task-327b: given a per-query context (scenario tag, tool-loop depth,
+ * user override), pick the thinking/reasoning effort level that should be
+ * passed to `adapter.stream({ effort })`.
+ *
+ * Config layering (highest wins):
+ *   1. userEffort (explicit per-query override — from `/max` prefix,
+ *      Settings slider, or API caller)
+ *   2. scenarioEffort (from the decision tree below)
+ *   3. model defaultEffort (from registry) — handled at adapter level
+ *   4. null (no effort = adapter/router drops the param)
+ *
+ * Red lines:
+ *   • Never error on unknown scenario — default to 'high'.
+ *   • Feature flag UNIFY_THINKING_V1 is enforced at the adapter/router
+ *     layer; this module just computes the intended value. If the flag
+ *     is off, adapters drop it anyway.
+ *   • Unsupported models silently drop effort at the router — this
+ *     module does NOT consult the capability matrix.
+ */
+
+import { normalizeEffort } from './models.js';
+
+/**
+ * Number of tool-loop turns past which a query is considered "complex"
+ * and gets an auto-bump from 'high' to 'max'. Tuned to catch genuine
+ * multi-hop work (code refactor across many files, sub-agent coordination)
+ * without punishing normal 2–3 tool chat turns.
+ */
+export const LONG_LOOP_TURN_THRESHOLD = 8;
+
+/**
+ * Scenario → default effort mapping. The engine tags each LLM call with
+ * a scenario string before invoking `pickEffort()`.
+ *
+ * Tiers (6 scenarios per architect spec):
+ *   chat          → high   (default interactive pair-programming turn)
+ *   consolidate   → max    (memory compaction — quality matters, runs once)
+ *   dream         → max    (memory maintenance — same rationale)
+ *   sub_agent     → max    (coordinator spawns + merges)
+ *   long_loop     → max    (auto-bumped when toolLoopTurns >= threshold)
+ *   recall        → low    (keyword/tag pre-filter — cheap classifier)
+ *   light         → low    (side-queries: summary title, extract pass1)
+ *
+ * Unknown scenarios fall through to 'high'.
+ */
+export const SCENARIO_EFFORT = Object.freeze({
+  chat: 'high',
+  consolidate: 'max',
+  dream: 'max',
+  sub_agent: 'max',
+  long_loop: 'max',
+  recall: 'low',
+  light: 'low',
+});
+
+/**
+ * Pick the effort level for a given query context.
+ *
+ * Decision order:
+ *   1. If userEffort is a valid Effort ('low'|'medium'|'high'|'max'),
+ *      return it unchanged. This is the explicit override path —
+ *      `/max` prefix, Settings slider, or API caller.
+ *   2. If toolLoopTurns >= LONG_LOOP_TURN_THRESHOLD, upgrade the
+ *      base scenario to 'long_loop' (→ 'max').
+ *   3. Look up SCENARIO_EFFORT[scenario]; unknown → 'high'.
+ *
+ * @param {object} ctx
+ * @param {string} [ctx.scenario='chat'] — Scenario tag; see SCENARIO_EFFORT.
+ * @param {number} [ctx.toolLoopTurns=0] — Number of tool-use turns
+ *   already consumed in the current `query()` call.
+ * @param {unknown} [ctx.userEffort=null] — User-supplied override.
+ *   Invalid values are ignored (fall through to scenario path).
+ * @returns {'low'|'medium'|'high'|'max'} Resolved effort. Never null —
+ *   the adapter/router is responsible for dropping it when the
+ *   feature flag is off or the model doesn't support thinking.
+ */
+export function pickEffort({ scenario = 'chat', toolLoopTurns = 0, userEffort = null } = {}) {
+  // 1. Explicit user override wins.
+  const normUser = normalizeEffort(userEffort);
+  if (normUser) return normUser;
+
+  // 2. Long-loop auto-bump (only when scenario was a "normal" one).
+  //    If the scenario is already 'recall' / 'light' (explicitly cheap),
+  //    we respect the operator's intent and don't bump — those are
+  //    classifier calls where depth doesn't imply complexity.
+  const cheap = scenario === 'recall' || scenario === 'light';
+  if (!cheap && typeof toolLoopTurns === 'number' && toolLoopTurns >= LONG_LOOP_TURN_THRESHOLD) {
+    return SCENARIO_EFFORT.long_loop;
+  }
+
+  // 3. Scenario table lookup.
+  return SCENARIO_EFFORT[scenario] || 'high';
+}
+
+/**
+ * Parse a user prompt for `/max`, `/high`, `/medium`, `/low` prefix
+ * commands. Returns `{ effort, cleanedPrompt }` where cleanedPrompt has
+ * the prefix (plus one trailing space) stripped.
+ *
+ * Red line: only ONE leading prefix is honoured — stacking (`/max /high
+ * hello`) just eats the first and leaves the rest untouched.
+ *
+ * PM decision (task-327): `/max` prefix is retained; skills trigger
+ * via `!` or `/skill:` instead to avoid collision.
+ *
+ * @param {string} prompt
+ * @returns {{ effort: 'low'|'medium'|'high'|'max'|null, cleanedPrompt: string }}
+ */
+export function parseEffortPrefix(prompt) {
+  if (typeof prompt !== 'string') return { effort: null, cleanedPrompt: prompt };
+  const m = prompt.match(/^\/(max|high|medium|low)(\s+|$)/);
+  if (!m) return { effort: null, cleanedPrompt: prompt };
+  const effort = m[1];
+  const cleanedPrompt = prompt.slice(m[0].length);
+  return { effort, cleanedPrompt };
+}

package/unify/engine.js

@@ -25,6 +25,7 @@ import { shouldConsolidate, consolidate } from './memory/consolidate.js';
 import { buildMemoryInjection } from './memory/layout.js';
 import { runStopHooks } from './stop-hooks.js';
 import { getThreadStore, MAIN_THREAD_ID } from './threads/store.js';
+import { pickEffort, parseEffortPrefix } from './effort.js';
 
 /**
  * task-324 — Turn cap removed.
@@ -424,9 +425,16 @@ export class Engine {
    * @param {string} params.prompt - The user prompt (required, non-empty).
    * @param {Array} [params.messages] - Prior conversation messages.
    * @param {AbortSignal} [params.signal] - Abort signal.
+   * @param {'low'|'medium'|'high'|'max'|null} [params.userEffort] -
+   *   task-327b: explicit per-query effort override (from Settings or
+   *   API caller). `/max`/`/high`/`/medium`/`/low` prefixes in prompt
+   *   also set this. Null/invalid → scenario decision tree decides.
+   * @param {string} [params.scenario='chat'] - task-327b: scenario tag
+   *   forwarded to the effort decision tree. See effort.js
+   *   SCENARIO_EFFORT. Unknown values fall through to 'high'.
    * @yields {EngineEvent}
    */
-  async *query({ prompt, messages = [], signal }) {
+  async *query({ prompt, messages = [], signal, userEffort = null, scenario = 'chat' }) {
     if (!prompt || typeof prompt !== 'string' || !prompt.trim()) {
       yield {
         type: 'error',
@@ -436,6 +444,12 @@ export class Engine {
       return;
     }
 
+    // task-327b: `/max` / `/high` / `/medium` / `/low` prefix override.
+    // Explicit caller-supplied userEffort wins over the prefix.
+    const parsed = parseEffortPrefix(prompt);
+    const effectivePrompt = parsed.cleanedPrompt;
+    const effectiveUserEffort = userEffort || parsed.effort || null;
+
     // ─── task-325a: engine-owned AbortController ─────────────
     // We create our own controller for this query run so `engine.abort()`
     // can trigger cancellation without requiring the caller to hand in a
@@ -468,7 +482,7 @@ export class Engine {
     const runSignal = abortCtrl.signal;
 
     try {
-      yield* this.#runQuery({ prompt, messages, signal: runSignal });
+      yield* this.#runQuery({ prompt: effectivePrompt, messages, signal: runSignal, userEffort: effectiveUserEffort, scenario });
     } finally {
       if (signal) {
         try { signal.removeEventListener('abort', onExternalAbort); } catch { /* ignore */ }
@@ -486,7 +500,7 @@ export class Engine {
    * in a try/finally without indenting the whole loop.
    * @private
    */
-  async *#runQuery({ prompt, messages, signal }) {
+  async *#runQuery({ prompt, messages, signal, userEffort = null, scenario = 'chat' }) {
 
     // ─── Pre-query: Memory Injection (task-287) + Compact Summary ──
     // New layout: always inject Memory Index + user-preferences + project
@@ -522,6 +536,7 @@ export class Engine {
     const toolDefs = this.#getToolDefs();
     let turnNumber = 0;
     let continueTurns = 0; // auto-continue counter
+    let toolLoopTurns = 0; // task-327b: tool-use turns for long-loop auto-bump
     let fullResponseText = '';
     let currentModel = this.#config.model;
 
@@ -557,6 +572,10 @@ export class Engine {
       yield { type: 'turn_start', turnNumber };
 
       try {
+        // task-327b: resolve effort per-turn so the long-loop auto-bump
+        // kicks in once toolLoopTurns crosses the threshold.
+        const resolvedEffort = pickEffort({ scenario, toolLoopTurns, userEffort });
+
         // Stream from adapter
         for await (const event of this.#adapter.stream({
           model: currentModel,
@@ -564,6 +583,7 @@ export class Engine {
           messages: [...conversationMessages],
           tools: toolDefs.length > 0 ? toolDefs : undefined,
           maxTokens: this.#config.maxOutputTokens || 16384,
+          effort: resolvedEffort,
           signal,
         })) {
           switch (event.type) {
@@ -834,6 +854,11 @@ export class Engine {
 
       yield { type: 'turn_end', turnNumber, stopReason: 'tool_use' };
 
+      // task-327b: count this as a tool-loop turn. Next iteration's
+      // pickEffort() will see the bumped counter and upgrade to 'max'
+      // once LONG_LOOP_TURN_THRESHOLD is reached.
+      toolLoopTurns++;
+
       // Loop back to call adapter again with tool results
     }
   }

package/unify/session.js

@@ -269,5 +269,13 @@ export async function loadSession(options = {}) {
     threadStore: getThreadStore(),
     status,
     shutdown,
+    // task-325c: user-initiated abort API. Delegates to web-bridge which
+    // owns the per-thread AbortController registry (`abortByThread`).
+    // Lazy-imported to avoid a hard cycle with web-bridge.js (which already
+    // imports this module to call loadSession).
+    async abort(opts = {}) {
+      const { abortUnifySession } = await import('./web-bridge.js');
+      return abortUnifySession(opts);
+    },
   };
 }

package/unify/web-bridge.js

@@ -848,6 +848,90 @@ export async function handleUnifyChat(msg) {
   }
 }
 
+/**
+ * task-325c: user-initiated abort of an in-flight Unify query on ONE thread.
+ *
+ * Cancels the AbortController registered for `msg.threadId` (if any). Silent
+ * no-op when the thread has no in-flight round — users clicking Stop on an
+ * already-idle thread should not trigger an error bubble. Emits an
+ * `unify_aborted` event for UI acknowledgement and a fresh
+ * `thread_list_updated` so inflight pills clear immediately.
+ *
+ * Red line (PM): the `thread_list_updated` event name is preserved; no
+ * new per-thread abort signal leaks into `Engine.abort()`'s signature.
+ *
+ * @param {{ threadId?: string }} msg
+ * @returns {{ aborted: string[], all: boolean }}
+ */
+export function handleUnifyAbortThread(msg = {}) {
+  const aborted = [];
+  const threadId = msg && msg.threadId;
+  if (threadId) {
+    const ctrl = abortByThread.get(threadId);
+    if (ctrl) {
+      try { ctrl.abort(); } catch { /* best-effort */ }
+      abortByThread.delete(threadId);
+      aborted.push(threadId);
+    }
+  }
+  sendUnifyEvent({ type: 'unify_aborted', aborted, all: false });
+  sendThreadListUpdate();
+  return { aborted, all: false };
+}
+
+/**
+ * task-325c: user-initiated abort of ALL in-flight Unify queries.
+ *
+ * Iterates every registered controller, aborts it, then clears the map.
+ * Always emits `unify_aborted` with `all:true` (even when nothing was
+ * running) so the UI can confirm the click landed.
+ *
+ * @returns {{ aborted: string[], all: boolean }}
+ */
+export function handleUnifyAbortAll() {
+  const aborted = [];
+  for (const [threadId, ctrl] of abortByThread.entries()) {
+    try { ctrl.abort(); } catch { /* best-effort */ }
+    aborted.push(threadId);
+  }
+  abortByThread.clear();
+  sendUnifyEvent({ type: 'unify_aborted', aborted, all: true });
+  sendThreadListUpdate();
+  return { aborted, all: true };
+}
+
+/**
+ * Unified dispatcher bound onto `session.abort({ threadId?, all? })`.
+ * Routes to {@link handleUnifyAbortThread} or {@link handleUnifyAbortAll}
+ * per input. Kept exported so message-router and tests can call it too.
+ *
+ * @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 });
+  // No payload — conservative default: abort nothing, just emit ack so
+  // callers see the no-op round-trip. Matches PM "don't accidentally
+  // nuke everything on a bare click".
+  sendUnifyEvent({ type: 'unify_aborted', aborted: [], all: false });
+  return { aborted: [], all: false };
+}
+
+/**
+ * Test-only: seed / inspect the abort registry without spinning up a
+ * full session. Never use from production code — the prod registry is
+ * managed by handleUnifyChat's per-query controller lifecycle.
+ * @private
+ */
+export function __testSeedAbortController(threadId, ctrl) {
+  abortByThread.set(threadId, ctrl);
+}
+
+/** Test-only: returns the set of thread ids currently registered. */
+export function __testGetRegisteredThreadIds() {
+  return [...abortByThread.keys()];
+}
+
 /**
  * Handle mode switch from the web UI.
  * DEPRECATED (task-297): Unify no longer has chat/work mode distinction.