@yeaft/webchat-agent 0.1.494 → 0.1.495

package/connection/message-router.js

@@ -24,7 +24,7 @@ import {
 import { sendToServer, flushMessageBuffer } from './buffer.js';
 import { handleRestartAgent, handleUpgradeAgent } from './upgrade.js';
 import { loadMcpServers, updateMcpConfig } from '../mcp.js';
-import { getLlmConfig, updateLlmConfig } from '../unify/config-api.js';
+import { getLlmConfig, updateLlmConfig, getUnifySettings, updateUnifySettings } from '../unify/config-api.js';
 import { handleUnifyChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory, handleUnifyMergeThread, handleUnifyForkThread } from '../unify/web-bridge.js';
 
 export async function handleMessage(msg) {
@@ -320,6 +320,30 @@ export async function handleMessage(msg) {
       break;
     }
 
+    // task-318: Unify runtime settings (thread concurrency + auto-archive).
+    // Read/write the nested `unify` section of config.json — LLM fields
+    // untouched. On update we broadcast a `unify_settings_updated` event
+    // so the UI reflects the new values and in-process consumers
+    // (ThreadEngineRegistry, ThreadStore) can reload their caps.
+    case 'get_unify_settings': {
+      const settings = getUnifySettings(ctx.CONFIG?.yeaftDir);
+      sendToServer({ type: 'unify_settings', ...settings });
+      break;
+    }
+
+    case 'update_unify_settings': {
+      const result = updateUnifySettings(msg.settings || msg.config || {}, ctx.CONFIG?.yeaftDir);
+      // Let live consumers pick up the new caps without a session restart.
+      // The registry/store are created per-session; we update the exported
+      // accessors so subsequent dispatches see the new values.
+      if (!result.error && ctx.unifyRuntimeSettings) {
+        ctx.unifyRuntimeSettings.maxConcurrentThreads = result.maxConcurrentThreads;
+        ctx.unifyRuntimeSettings.autoArchiveIdleDays = result.autoArchiveIdleDays;
+      }
+      sendToServer({ type: 'unify_settings_updated', ...result });
+      break;
+    }
+
     // Unify — independent chat via Engine
     case 'unify_chat':
       await handleUnifyChat(msg);

package/context.js

@@ -30,4 +30,9 @@ export default {
   sendToServer: null,
   // 由 index.js 注册的配置保存函数
   saveConfig: null,
+  // task-318: live Unify runtime caps. Mutated in-place by
+  // `update_unify_settings` so in-process consumers (web-bridge) can
+  // pick up the new values without a session restart. `null` until the
+  // Unify session has finished loading.
+  unifyRuntimeSettings: null,
 };

package/package.json

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

package/unify/config-api.js

@@ -12,6 +12,7 @@ import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { DEFAULT_YEAFT_DIR } from './init.js';
 import { normalizeProviderModels, serializeModelForPersistence } from './models.js';
+import { normaliseUnifySection } from './config.js';
 
 /**
  * Read the LLM-relevant portion of config.json.
@@ -126,3 +127,91 @@ export function updateLlmConfig(update, dir) {
     language: existing.language || 'en',
   };
 }
+
+// ─── Unify runtime settings (task-318) ────────────────────────────
+
+/**
+ * Read the Unify-section of config.json. Returns defaults when the file
+ * or section is absent. Callers (UI, registry, ThreadStore) rely on a
+ * stable shape — `normaliseUnifySection` guarantees that.
+ *
+ * @param {string} [dir] — Yeaft data directory
+ * @returns {{ maxConcurrentThreads: number, autoArchiveIdleDays: number } | { error: string }}
+ */
+export function getUnifySettings(dir) {
+  const root = dir || process.env.YEAFT_DIR || DEFAULT_YEAFT_DIR;
+  const configPath = join(root, 'config.json');
+  if (!existsSync(configPath)) return normaliseUnifySection(null);
+  try {
+    const raw = readFileSync(configPath, 'utf8');
+    const json = JSON.parse(raw);
+    return normaliseUnifySection(json.unify);
+  } catch (e) {
+    return { error: `Failed to read config.json: ${e.message}` };
+  }
+}
+
+/**
+ * Update the Unify-section of config.json. Merges into existing config
+ * (LLM provider / model fields are untouched) and validates each field:
+ * `maxConcurrentThreads` must be 1..50, `autoArchiveIdleDays` must be
+ * 1..3650. Invalid values are rejected outright so the UI sees an error
+ * rather than silently reverting — a silent revert would make "I set it
+ * to 100 and nothing happened" impossible to debug.
+ *
+ * @param {{ maxConcurrentThreads?: number, autoArchiveIdleDays?: number }} update
+ * @param {string} [dir]
+ * @returns {{ maxConcurrentThreads: number, autoArchiveIdleDays: number } | { error: string }}
+ */
+export function updateUnifySettings(update, dir) {
+  const root = dir || process.env.YEAFT_DIR || DEFAULT_YEAFT_DIR;
+  const configPath = join(root, 'config.json');
+
+  if (!update || typeof update !== 'object') {
+    return { error: 'update payload required' };
+  }
+
+  // Validate before touching the file. We enforce the same clamp bounds
+  // that `normaliseUnifySection` uses for reads so round-trip is stable.
+  if (update.maxConcurrentThreads !== undefined) {
+    const n = Number(update.maxConcurrentThreads);
+    if (!Number.isFinite(n) || n < 1 || n > 50) {
+      return { error: 'maxConcurrentThreads must be between 1 and 50' };
+    }
+  }
+  if (update.autoArchiveIdleDays !== undefined) {
+    const n = Number(update.autoArchiveIdleDays);
+    if (!Number.isFinite(n) || n < 1 || n > 3650) {
+      return { error: 'autoArchiveIdleDays must be between 1 and 3650' };
+    }
+  }
+
+  // Read existing config (preserve LLM and other top-level fields).
+  let existing = {};
+  if (existsSync(configPath)) {
+    try {
+      existing = JSON.parse(readFileSync(configPath, 'utf8'));
+    } catch {
+      existing = {};
+    }
+  }
+
+  const prev = normaliseUnifySection(existing.unify);
+  const merged = {
+    maxConcurrentThreads: update.maxConcurrentThreads !== undefined
+      ? Math.floor(Number(update.maxConcurrentThreads))
+      : prev.maxConcurrentThreads,
+    autoArchiveIdleDays: update.autoArchiveIdleDays !== undefined
+      ? Math.floor(Number(update.autoArchiveIdleDays))
+      : prev.autoArchiveIdleDays,
+  };
+  existing.unify = merged;
+
+  try {
+    writeFileSync(configPath, JSON.stringify(existing, null, 2) + '\n', 'utf8');
+  } catch (e) {
+    return { error: `Failed to write config.json: ${e.message}` };
+  }
+
+  return merged;
+}

package/unify/config.js

@@ -33,6 +33,15 @@ const DEFAULTS = {
   maxOutputTokens: 16384,
   messageTokenBudget: 8192,
   maxContinueTurns: 3,
+  // task-318: Unify-specific runtime caps. `maxConcurrentThreads` gates
+  // how many ThreadEngineRegistry instances may be live at once; dispatch
+  // refuses new threads beyond this. The count INCLUDES the always-on
+  // `main` thread, so the default 6 gives users 5 user-initiated threads
+  // on top of main. `autoArchiveIdleDays` is consumed by ThreadStore's
+  // idle-archive pass (task-317 will wire the pass itself; here we just
+  // plumb the knob through so the UI can set it).
+  unifyMaxConcurrentThreads: 6,
+  unifyAutoArchiveIdleDays: 30,
 };
 
 // ─── config.json reader ─────────────────────────────────────────
@@ -134,6 +143,52 @@ function isTruthy(val) {
   return val === '1' || val === 'true' || val === 'yes';
 }
 
+/**
+ * Clamp and normalise the `unify` config section. Missing / non-numeric
+ * inputs fall back to the DEFAULTS; numeric-but-out-of-range inputs are
+ * *clamped* to the valid range rather than silently reverting to the
+ * default. This keeps the read path aligned with `updateUnifySettings`,
+ * which rejects out-of-range writes up front — a hand-edited
+ * `config.json` with `maxConcurrentThreads: 100` now loads as 50 (the
+ * nearest valid value) instead of collapsing back to 5.
+ *
+ * Exported for tests and for `config-api.js` to share the same clamp
+ * bounds via `clampUnifyField`.
+ *
+ * @param {any} raw — jsonConfig.unify (may be undefined / malformed)
+ * @returns {{ maxConcurrentThreads: number, autoArchiveIdleDays: number }}
+ */
+export function normaliseUnifySection(raw) {
+  const out = {
+    maxConcurrentThreads: DEFAULTS.unifyMaxConcurrentThreads,
+    autoArchiveIdleDays: DEFAULTS.unifyAutoArchiveIdleDays,
+  };
+  if (!raw || typeof raw !== 'object') return out;
+  const mc = clampUnifyField(raw.maxConcurrentThreads, 'maxConcurrentThreads');
+  if (mc !== null) out.maxConcurrentThreads = mc;
+  const ad = clampUnifyField(raw.autoArchiveIdleDays, 'autoArchiveIdleDays');
+  if (ad !== null) out.autoArchiveIdleDays = ad;
+  return out;
+}
+
+/**
+ * Clamp a single unify field to its valid range. Returns `null` if the
+ * input is not a finite number (so callers can treat it as "not set" and
+ * keep the previous value). Centralises the bounds used on both read
+ * (`normaliseUnifySection`) and write (`updateUnifySettings` validation).
+ *
+ * @param {unknown} v
+ * @param {'maxConcurrentThreads'|'autoArchiveIdleDays'} field
+ * @returns {number | null}
+ */
+export function clampUnifyField(v, field) {
+  if (v === null || v === undefined) return null;
+  const n = Number(v);
+  if (!Number.isFinite(n)) return null;
+  const [lo, hi] = field === 'maxConcurrentThreads' ? [1, 50] : [1, 3650];
+  return Math.min(hi, Math.max(lo, Math.floor(n)));
+}
+
 /**
  * Build config from legacy config.md + .env + env vars.
  * @deprecated — used only when config.json doesn't exist.
@@ -160,6 +215,8 @@ function loadLegacyConfig(dir, overrides) {
     maxOutputTokens: overrides.maxOutputTokens ?? fileConfig.maxOutputTokens ?? DEFAULTS.maxOutputTokens,
     messageTokenBudget: overrides.messageTokenBudget ?? (env.YEAFT_MESSAGE_TOKEN_BUDGET ? parseInt(env.YEAFT_MESSAGE_TOKEN_BUDGET, 10) : null) ?? fileConfig.messageTokenBudget ?? DEFAULTS.messageTokenBudget,
     maxContinueTurns: overrides.maxContinueTurns ?? fileConfig.maxContinueTurns ?? DEFAULTS.maxContinueTurns,
+    // task-318: legacy path never had the `unify` section — defaults.
+    unify: normaliseUnifySection(null),
     providers: null,
     primaryModel: null,
     fastModel: null,
@@ -252,6 +309,10 @@ export function loadConfig(overrides = {}) {
     messageTokenBudget: overrides.messageTokenBudget ?? jsonConfig.messageTokenBudget ?? DEFAULTS.messageTokenBudget,
     maxContinueTurns: overrides.maxContinueTurns ?? jsonConfig.maxContinueTurns ?? DEFAULTS.maxContinueTurns,
 
+    // task-318: Unify runtime caps. `unify` is a nested section so we
+    // don't pollute the flat config namespace used by chat/crew code.
+    unify: normaliseUnifySection(jsonConfig.unify),
+
     // Legacy fields (null when using config.json)
     apiKey: overrides.apiKey || null,
     openaiApiKey: null,

package/unify/session.js

@@ -131,7 +131,13 @@ export async function loadSession(options = {}) {
   // ─── 5b. Initialize thread store (task-299 Phase 1) ────
   //         task-307a: now file-backed under ~/.yeaft/threads/. Passing the
   //         yeaftDir switches on disk persistence; read-only mode is honoured.
-  initThreadStore(yeaftDir, { readOnly: config._readOnly || false, force: true });
+  //         task-318: forward the Unify autoArchiveIdleDays knob so the
+  //         archive pass (owned by task-317) can read it off the store.
+  initThreadStore(yeaftDir, {
+    readOnly: config._readOnly || false,
+    force: true,
+    idleArchiveDays: config.unify?.autoArchiveIdleDays ?? 0,
+  });
 
   // ─── 6. Load skills ────────────────────────────────────
   let skillManager;
@@ -187,6 +193,8 @@ export async function loadSession(options = {}) {
     skillManager,
     mcpManager,
     yeaftDir,
+    // task-318: concurrent-thread cap (UI-adjustable via Settings).
+    maxConcurrent: config.unify?.maxConcurrentThreads ?? null,
   });
   // Seed the main-thread instance so listActive() is non-empty from T=0.
   engineRegistry.ensure(MAIN_THREAD_ID);
@@ -254,6 +262,11 @@ export async function loadSession(options = {}) {
     toolRegistry,
     trace,
     yeaftDir,
+    // task-318 rev-1 fix: expose the live ThreadStore handle so callers
+    // (web-bridge, message-router via ctx) can invoke setIdleArchiveDays()
+    // on the exact instance that's wired into the dispatcher. Without this
+    // export the setter was effectively dead code.
+    threadStore: getThreadStore(),
     status,
     shutdown,
   };

package/unify/threads/engine-registry.js

@@ -29,6 +29,17 @@
 import { MAIN_THREAD_ID } from './store.js';
 import { createEngineInstance } from './engine-instance.js';
 
+/**
+ * Coerce a maxConcurrent input to either a positive integer or null
+ * (meaning "no cap"). Keeps the cap logic branch-free elsewhere.
+ */
+function normaliseMaxConcurrent(n) {
+  if (n === null || n === undefined) return null;
+  const v = Number(n);
+  if (!Number.isFinite(v) || v <= 0) return null;
+  return Math.floor(v);
+}
+
 export class ThreadEngineRegistry {
   /** @type {Map<string, import('./engine-instance.js').EngineInstance>} */
   #instances;
@@ -39,18 +50,33 @@ export class ThreadEngineRegistry {
   /** @type {string} */
   #currentThreadId;
 
+  /**
+   * task-318: soft cap on concurrent live engine instances. When set,
+   * `ensure()` refuses to spawn a new instance beyond this many live
+   * entries. Already-live instances continue to serve query()s — the
+   * cap only gates net-new thread creation. Can be mutated at runtime
+   * by `setMaxConcurrent()` so the Settings UI takes effect without a
+   * session restart.
+   *
+   * Null / 0 / negative → unlimited (treat as "no cap").
+   * @type {number | null}
+   */
+  #maxConcurrent;
+
   /**
    * @param {{
    *   factory: (threadId: string, opts?: object) => import('./engine-instance.js').EngineInstance,
+   *   maxConcurrent?: number | null,
    * }} params
    */
-  constructor({ factory } = {}) {
+  constructor({ factory, maxConcurrent } = {}) {
     if (typeof factory !== 'function') {
       throw new Error('ThreadEngineRegistry: factory function is required');
     }
     this.#instances = new Map();
     this.#factory = factory;
     this.#currentThreadId = MAIN_THREAD_ID;
+    this.#maxConcurrent = normaliseMaxConcurrent(maxConcurrent);
   }
 
   /** @returns {string} */
@@ -83,6 +109,22 @@ export class ThreadEngineRegistry {
     }
     const existing = this.#instances.get(threadId);
     if (existing && !existing.terminated) return existing;
+    // task-318: enforce concurrency cap before spawning a net-new
+    // instance. Replacing a terminated slot for the same threadId does
+    // NOT count against the cap — it's the same thread resuming.
+    if (!existing && this.#maxConcurrent !== null) {
+      const live = this.#countLive();
+      if (live >= this.#maxConcurrent) {
+        const err = new Error(
+          `ThreadEngineRegistry: concurrent thread limit reached (${live}/${this.#maxConcurrent}). ` +
+          `Archive or terminate an existing thread before starting a new one.`
+        );
+        err.code = 'ERR_MAX_CONCURRENT_THREADS';
+        err.limit = this.#maxConcurrent;
+        err.live = live;
+        throw err;
+      }
+    }
     const instance = this.#factory(threadId, opts);
     if (!instance || typeof instance.query !== 'function') {
       throw new Error(`ThreadEngineRegistry.ensure: factory did not return an EngineInstance for ${threadId}`);
@@ -91,6 +133,31 @@ export class ThreadEngineRegistry {
     return instance;
   }
 
+  /**
+   * Count currently non-terminated instances — the denominator for the
+   * concurrency cap. O(n) scan, n is small (≤ 50 in practice).
+   * @returns {number}
+   */
+  #countLive() {
+    let n = 0;
+    for (const inst of this.#instances.values()) {
+      if (!inst.terminated) n += 1;
+    }
+    return n;
+  }
+
+  /**
+   * task-318: read or update the concurrency cap. `setMaxConcurrent(null)`
+   * disables the cap entirely. Existing live instances are NOT terminated
+   * if the cap is lowered below their count — the cap only gates new
+   * `ensure()` calls going forward.
+   * @returns {number | null}
+   */
+  get maxConcurrent() { return this.#maxConcurrent; }
+  setMaxConcurrent(n) {
+    this.#maxConcurrent = normaliseMaxConcurrent(n);
+  }
+
   /**
    * Set the current thread marker. Does not lazy-create — caller must
    * ensure() if they want an instance for an unseen thread.
@@ -188,5 +255,6 @@ export function createThreadEngineRegistry(deps) {
       ...opts,
       threadId,
     }),
+    maxConcurrent: deps?.maxConcurrent ?? null,
   });
 }

package/unify/threads/store.js

@@ -52,6 +52,18 @@ export const MAIN_THREAD_ID = 'main';
 /** Valid thread status values. Mirrors design doc §5. */
 export const THREAD_STATUSES = ['active', 'idle', 'archived'];
 
+/**
+ * task-318: Coerce an idle-archive days input to a non-negative integer
+ * (0 disables the feature). Anything invalid falls through to 0 so a
+ * malformed config can never silently enable auto-archive.
+ */
+function normaliseIdleDays(n) {
+  if (n === null || n === undefined) return 0;
+  const v = Number(n);
+  if (!Number.isFinite(v) || v <= 0) return 0;
+  return Math.floor(v);
+}
+
 /** Debounce window for grouped disk writes. Kept short so tests don't hang. */
 const FLUSH_DEBOUNCE_MS = 8;
 
@@ -275,10 +287,12 @@ export class ThreadStore {
   #dirtyAttachments;
   /** @type {any} NodeJS.Timeout */
   #flushTimer;
+  /** @type {number} task-318: days of inactivity before auto-archive (0 = disabled) */
+  #idleArchiveDays;
 
   /**
    * @param {string} [yeaftDir] — Base ~/.yeaft directory. Omit for in-memory mode.
-   * @param {{ readOnly?: boolean }} [opts]
+   * @param {{ readOnly?: boolean, idleArchiveDays?: number }} [opts]
    */
   constructor(yeaftDir, opts = {}) {
     this.#threads = new Map();
@@ -290,6 +304,11 @@ export class ThreadStore {
     this.#flushTimer = null;
 
     this.#readOnly = !!opts.readOnly;
+    // task-318: idle-archive threshold (days). Consumed by the archive
+    // pass in task-317; here we just accept + expose the knob so the
+    // config plumbing is testable end-to-end today. A value ≤ 0 means
+    // "no auto-archive" (feature disabled).
+    this.#idleArchiveDays = normaliseIdleDays(opts.idleArchiveDays);
     if (yeaftDir) {
       this.#dir = join(yeaftDir, 'threads');
       this.#indexPath = join(this.#dir, 'index.md');
@@ -487,6 +506,18 @@ export class ThreadStore {
   get currentId() { return this.#currentId; }
   get size() { return this.#threads.size; }
 
+  /**
+   * task-318: idle-archive threshold (days). 0 disables auto-archive.
+   * The actual archive pass is owned by task-317 — this accessor is the
+   * contract between config and that future consumer, plus a write path
+   * so the Settings UI takes effect without restarting the session.
+   * @returns {number}
+   */
+  get idleArchiveDays() { return this.#idleArchiveDays; }
+  setIdleArchiveDays(days) {
+    this.#idleArchiveDays = normaliseIdleDays(days);
+  }
+
   get(id) { return this.#threads.get(id) || null; }
   list() { return [...this.#threads.values()]; }
   has(id) { return this.#threads.has(id); }

package/unify/web-bridge.js

@@ -73,6 +73,38 @@ function sendUnifyEvent(event) {
   });
 }
 
+/**
+ * task-318 rev-1 fix: install live-setter bridge between the session's
+ * runtime handles (engineRegistry + threadStore) and `ctx.unifyRuntimeSettings`,
+ * which message-router's `update_unify_settings` branch reads. Previously
+ * that object was null and the setters were dead code. Now every
+ * `update_unify_settings` mutation pushes the new caps into the live
+ * session within the same tick — no reload required.
+ *
+ * Exported so tests can drive the same wiring with a mock session.
+ *
+ * @param {import('./session.js').Session} s
+ */
+export function installUnifyRuntimeBridge(s) {
+  if (!s) return;
+  const initialMax = s.engineRegistry?.maxConcurrent ?? null;
+  const initialIdle = s.threadStore?.idleArchiveDays ?? 0;
+  ctx.unifyRuntimeSettings = {
+    get maxConcurrentThreads() { return s.engineRegistry?.maxConcurrent ?? initialMax; },
+    set maxConcurrentThreads(v) {
+      if (typeof s.engineRegistry?.setMaxConcurrent === 'function') {
+        s.engineRegistry.setMaxConcurrent(v);
+      }
+    },
+    get autoArchiveIdleDays() { return s.threadStore?.idleArchiveDays ?? initialIdle; },
+    set autoArchiveIdleDays(v) {
+      if (typeof s.threadStore?.setIdleArchiveDays === 'function') {
+        s.threadStore.setIdleArchiveDays(v);
+      }
+    },
+  };
+}
+
 /**
  * task-301 Part 2: push the full thread list snapshot to the web client.
  * Called after any ThreadStore-mutating tool completes and at turn_end so
@@ -391,6 +423,14 @@ export async function handleUnifyChat(msg) {
         skipSkills: false,
       });
 
+      // task-318 rev-1 fix: expose live setters on ctx so message-router's
+      // update_unify_settings branch can push the new caps into the
+      // registry + thread store without a session reload. Previously this
+      // object was null and setMaxConcurrent/setIdleArchiveDays were dead
+      // code — the config file was updated on disk but the running
+      // session continued with the old caps until next restart.
+      installUnifyRuntimeBridge(session);
+
       // Create a stable conversationId for the Unify session
       unifyConversationId = `unify-${Date.now()}`;
 
@@ -737,6 +777,8 @@ export async function handleUnifyLoadHistory(msg) {
       skipMCP: false,
       skipSkills: false,
     });
+    // task-318 rev-1 fix: wire live setters; see handleUnifyChat.
+    installUnifyRuntimeBridge(session);
 
     unifyConversationId = `unify-${Date.now()}`;
 
@@ -811,6 +853,8 @@ export async function resetUnifySession() {
       skipMCP: false,
       skipSkills: false,
     });
+    // task-318 rev-1 fix: wire live setters; see handleUnifyChat.
+    installUnifyRuntimeBridge(session);
 
     unifyConversationId = `unify-${Date.now()}`;