@yeaft/webchat-agent 0.1.656 → 0.1.658

package/unify/vp/index.js

@@ -3,12 +3,5 @@
  */
 
 export { parseRoleMd, loadVpFromDir, scanVpLibrary, count, DEFAULT_VP_LIB_DIR } from './vp-store.js';
-export { RoleInstance } from './role-instance.js';
 export { Registry, defaultRegistry } from './registry.js';
 export { VpLoader } from './vp-loader.js';
-
-// task-334c
-export { buildSystemPrompt } from './system-prompt.js';
-export { recallCoreMemory, searchCoreMemory } from './core-memory-recall.js';
-export { createEngineBinder } from './engine-binding.js';
-export { createTurnRunner } from './run-turn.js';

package/unify/vp/registry.js

@@ -1,35 +1,19 @@
 /**
- * registry.js — In-memory VP + RoleInstance registry.
+ * registry.js — In-memory VP registry.
  *
- * Two maps:
- *   - vpMap:           vpId → VP
- *   - instanceMap:     "<groupId>::<vpId>" → RoleInstance
+ * Holds the process-wide VP map (vpId → VP). VpLoader writes to it on
+ * startup + filesystem rescans; vp-bridge.js reads it to serve the
+ * `vp_snapshot` and live-diff WS events.
  *
- * RoleInstance creation is idempotent: `getOrCreateRoleInstance(vpId, groupId)`
- * returns the same instance for the same (vpId, groupId) pair.
- *
- * LRU eviction (per acceptance #3): when active instance count exceeds
- * `softLimit.maxActiveRoleInstances` (default 40), the least-recently-used
- * idle instance is evicted. Instances with `state !== 'idle'` are skipped
- * over during eviction; if no idle candidate exists, the new instance is
- * still created (soft limit — we do not hard-reject).
+ * The previous RoleInstance map (per (vpId, groupId) pair, with LRU
+ * eviction) was removed in GC.2 — production fans out per-VP via
+ * `handleUnifyChat` directly and never instantiated RoleInstance.
  */
 
-import { RoleInstance } from './role-instance.js';
-
-const DEFAULT_MAX_ACTIVE_ROLE_INSTANCES = 40;
-
 export class Registry {
-  constructor(options = {}) {
+  constructor() {
     /** @type {Map<string, import('./vp-store.js').VP>} */
     this.vpMap = new Map();
-    /** @type {Map<string, RoleInstance>} */
-    this.instanceMap = new Map();
-    this.softLimit = {
-      maxActiveRoleInstances: options.maxActiveRoleInstances ?? DEFAULT_MAX_ACTIVE_ROLE_INSTANCES,
-    };
-    /** Listeners for eviction / persona-refresh (optional). */
-    this._evictListeners = new Set();
   }
 
   // ─── VP map ────────────────────────────────────────────────────
@@ -41,8 +25,8 @@ export class Registry {
 
   /**
    * Replace a VP's persona fields in-place, preserving identity so any
-   * RoleInstance with `.vp === vp` keeps its reference stable across
-   * hot-reload. Fields copied: name, role, traits, modelHint, persona,
+   * downstream reference keeps its handle stable across hot-reload.
+   * Fields copied: name, role, traits, modelHint, persona, personaHash,
    * mtimeMs.
    */
   updateVpInPlace(next) {
@@ -56,10 +40,6 @@ export class Registry {
     cur.traits = next.traits;
     cur.modelHint = next.modelHint;
     cur.persona = next.persona;
-    // task-334c: personaHash must track persona body. 334a-followup added
-    // the field; this is the in-place update mirror. (Originally recorded
-    // as a 334h nit, but 334c's system-prompt block names the hash in
-    // STATIC — carrying a stale hash would bleed into the prompt.)
     cur.personaHash = next.personaHash;
     cur.mtimeMs = next.mtimeMs;
     // dir / memoryDir / id stable
@@ -68,12 +48,6 @@ export class Registry {
 
   removeVp(vpId) {
     this.vpMap.delete(vpId);
-    // Also drop any RoleInstances bound to a vanished VP.
-    for (const [key, ri] of this.instanceMap) {
-      if (ri.vpId === vpId) {
-        this.instanceMap.delete(key);
-      }
-    }
   }
 
   getVp(vpId) {
@@ -87,87 +61,6 @@ export class Registry {
   vpCount() {
     return this.vpMap.size;
   }
-
-  // ─── RoleInstance map ─────────────────────────────────────────
-
-  _key(groupId, vpId) {
-    return `${groupId}::${vpId}`;
-  }
-
-  /**
-   * Idempotent create: same (vpId, groupId) returns same instance.
-   * Triggers LRU eviction when the soft limit is exceeded.
-   *
-   * @param {string} vpId
-   * @param {string} groupId
-   * @returns {RoleInstance}
-   */
-  getOrCreateRoleInstance(vpId, groupId) {
-    const vp = this.vpMap.get(vpId);
-    if (!vp) throw new Error(`unknown vpId: ${vpId}`);
-
-    const key = this._key(groupId, vpId);
-    const existing = this.instanceMap.get(key);
-    if (existing) {
-      existing.touch();
-      return existing;
-    }
-
-    const ri = new RoleInstance({ vp, groupId });
-    this.instanceMap.set(key, ri);
-    this._maybeEvict(ri);
-    return ri;
-  }
-
-  getRoleInstance(vpId, groupId) {
-    return this.instanceMap.get(this._key(groupId, vpId));
-  }
-
-  dropRoleInstance(vpId, groupId) {
-    const key = this._key(groupId, vpId);
-    const ri = this.instanceMap.get(key);
-    if (!ri) return false;
-    this.instanceMap.delete(key);
-    return true;
-  }
-
-  activeRoleInstanceCount() {
-    return this.instanceMap.size;
-  }
-
-  listRoleInstances() {
-    return Array.from(this.instanceMap.values());
-  }
-
-  onEvict(listener) {
-    this._evictListeners.add(listener);
-    return () => this._evictListeners.delete(listener);
-  }
-
-  _maybeEvict(exclude) {
-    const limit = this.softLimit.maxActiveRoleInstances;
-    if (this.instanceMap.size <= limit) return;
-
-    // Collect idle instances (excluding the just-created one), sort by
-    // lastActivityAt ascending.
-    const idle = [];
-    for (const ri of this.instanceMap.values()) {
-      if (ri === exclude) continue;
-      if (ri.state === 'idle') idle.push(ri);
-    }
-    idle.sort((a, b) => a.lastActivityAt - b.lastActivityAt);
-
-    while (this.instanceMap.size > limit && idle.length > 0) {
-      const victim = idle.shift();
-      const key = this._key(victim.groupId, victim.vpId);
-      this.instanceMap.delete(key);
-      for (const l of this._evictListeners) {
-        try { l(victim); } catch { /* ignore */ }
-      }
-    }
-    // If still over limit because no idle candidates exist, we accept the
-    // soft-limit breach — per spec, softLimit is a target, not a hard cap.
-  }
 }
 
 /** Module-level default registry (convenience). */

package/unify/web-bridge.js

@@ -736,7 +736,17 @@ export async function handleUnifyGroupChat(msg) {
         ts: Date.now(),
       });
     } catch { /* never crash WS pipeline */ }
+  }
 
+  // GC.1 Commit C: VP-level parallelism. Each selected VP runs its
+  // turn concurrently via Promise.all. Intra-VP loops (LLM → tool →
+  // LLM) stay serial inside each handleUnifyChat call.
+  //
+  // Side-effect: VP-B's transcript no longer contains VP-A's reply
+  // (they're concurrent). Cross-VP visibility moves to the explicit
+  // route_forward tool. The group jsonl log remains the source of
+  // truth for full-fidelity replay.
+  await Promise.all(captured.map(async ({ vpId }) => {
     try {
       await handleUnifyChat({
         ...msg,
@@ -758,7 +768,7 @@ export async function handleUnifyGroupChat(msg) {
         });
       } catch { /* never crash WS pipeline */ }
     }
-  }
+  }));
 }
 
 /**

package/unify/vp/core-memory-recall.js

@@ -1,75 +0,0 @@
-/**
- * core-memory-recall.js — single-dimension VP memory recall.
- *
- * Per R3 §Δ2.3: recall is scoped to the CURRENT VP only. The `scope`
- * dimension from R2 was deleted; VP memory is a single store per VP and
- * the recall filter is `{ vp: currentVpId, ... }` — no $or across local /
- * global.
- *
- * This module is a thin shim over whatever memory store RoleInstance has
- * (334f wraps 334o's shard-store). It duck-types the store so 334c does
- * not hard-depend on 334f's final shape:
- *
- *   store.query({ vp, shard?, kind?, tags?, limit?, recency? })
- *   store.search({ vp, query, limit? })    // optional
- *
- * Return shape: array of entries with at minimum `{ body, shard }`.
- * Additional fields are passed through.
- */
-
-const DEFAULT_LIMIT = 7;
-
-/**
- * Recall top-K core memory for a VP.
- *
- * @param {object|null} store  — memoryStore (may be null)
- * @param {{ vp: string, limit?: number, shard?: string, kind?: string,
- *           tags?: string[] }} opts
- * @returns {Promise<Array<{body:string, shard?:string, [k:string]:any}>>}
- */
-export async function recallCoreMemory(store, opts = {}) {
-  if (!store || typeof store.query !== 'function') return [];
-  if (!opts.vp || typeof opts.vp !== 'string') {
-    throw new Error('recallCoreMemory: opts.vp (vpId) is required');
-  }
-  const limit = Number.isInteger(opts.limit) && opts.limit > 0
-    ? opts.limit
-    : DEFAULT_LIMIT;
-
-  const filter = { vp: opts.vp, limit };
-  if (opts.shard) filter.shard = opts.shard;
-  if (opts.kind) filter.kind = opts.kind;
-  if (opts.tags && opts.tags.length) filter.tags = opts.tags;
-
-  // Support both sync and async stores.
-  const out = await Promise.resolve(store.query(filter));
-  if (!Array.isArray(out)) return [];
-  return out.slice(0, limit);
-}
-
-/**
- * Optional keyword-search variant — used by the `memory_search` tool in
- * 334d. Also VP-scoped.
- *
- * @param {object|null} store
- * @param {{ vp: string, query: string, limit?: number }} opts
- */
-export async function searchCoreMemory(store, opts = {}) {
-  if (!store) return [];
-  if (!opts.vp || !opts.query) return [];
-  const limit = opts.limit || DEFAULT_LIMIT;
-  if (typeof store.search === 'function') {
-    const out = await Promise.resolve(store.search({ vp: opts.vp, query: opts.query, limit }));
-    return Array.isArray(out) ? out.slice(0, limit) : [];
-  }
-  // Fallback: query + naive substring filter.
-  if (typeof store.query === 'function') {
-    const all = await Promise.resolve(store.query({ vp: opts.vp, limit: 200 }));
-    if (!Array.isArray(all)) return [];
-    const needle = opts.query.toLowerCase();
-    return all
-      .filter((e) => (e.body || '').toLowerCase().includes(needle))
-      .slice(0, limit);
-  }
-  return [];
-}

package/unify/vp/engine-binding.js

@@ -1,96 +0,0 @@
-/**
- * engine-binding.js — bind a single Engine instance to a VP.
- *
- * Per §5.1, Engine is a stateless library: `engine.query({prompt, messages,
- * signal, ...})`. Per §5.2, each RoleInstance runs ITS VP's Engine. We keep
- * one Engine per (vpId) — NOT per RoleInstance — because the Engine itself
- * holds no conversation state; messages live on the RoleInstance. Sharing
- * across groups for the same VP is correct and avoids adapter duplication.
- *
- * When a VP is hot-reloaded (persona body changed → personaHash changed),
- * the cached Engine is still valid — the persona is injected via system
- * prompt, not Engine constructor. We keep the cache stable unless the
- * caller passes a new adapter (e.g. modelHint switched).
- *
- * Hard constraint: 334c does NOT import ../engine.js directly, because
- * that pulls in adapter/config/tool machinery that's owned by the caller
- * (web-bridge / eval runner). Instead this module takes a factory:
- *
- *   createEngine(vp) → Engine
- *
- * which the caller supplies when they wire up a Registry.
- */
-
-const DEFAULT_SCOPE = Symbol.for('yeaft.334c.default-engine-scope');
-
-/**
- * Build an engine binder. Stateless helper — state lives on the registry-
- * like cache the caller provides (defaults to an internal WeakMap-style).
- *
- * @param {{
- *   createEngine: (vp: import('./vp-store.js').VP) => object,
- *   cache?: Map<string, object>,        // vpId → Engine
- * }} deps
- */
-export function createEngineBinder({ createEngine, cache } = {}) {
-  if (typeof createEngine !== 'function') {
-    throw new Error('createEngineBinder: createEngine(vp) factory is required');
-  }
-  const store = cache instanceof Map ? cache : new Map();
-  // Track personaHash at bind time so the caller can decide whether a
-  // later hot-reload warrants re-binding (MVP: we just stash it; engine
-  // itself is persona-agnostic).
-  const meta = new Map(); // vpId → { personaHash, modelHint }
-
-  return {
-    /**
-     * Resolve (or lazily create) the Engine for a RoleInstance's VP and
-     * attach it onto `ri.engine`. Idempotent.
-     *
-     * @param {import('./role-instance.js').RoleInstance} ri
-     * @returns {object} Engine
-     */
-    bind(ri) {
-      if (!ri || !ri.vp) throw new Error('bind: role instance required');
-      const vp = ri.vp;
-      let engine = store.get(vp.id);
-      if (!engine) {
-        engine = createEngine(vp);
-        if (!engine || typeof engine.query !== 'function') {
-          throw new Error(`bind: createEngine(${vp.id}) did not return an Engine-like object (missing query)`);
-        }
-        store.set(vp.id, engine);
-        meta.set(vp.id, { personaHash: vp.personaHash, modelHint: vp.modelHint });
-      }
-      ri.engine = engine;
-      return engine;
-    },
-
-    /**
-     * Mark a VP as "needs re-bind" — drop the cache entry. The next bind()
-     * call will invoke createEngine again. Useful when the caller knows
-     * the adapter or tool inventory has changed.
-     */
-    invalidate(vpId) {
-      const engine = store.get(vpId);
-      store.delete(vpId);
-      meta.delete(vpId);
-      // Best-effort: if the engine exposed a dispose, call it.
-      if (engine && typeof engine.dispose === 'function') {
-        try { engine.dispose(); } catch { /* ignore */ }
-      }
-    },
-
-    /** Drop every cached engine (e.g. on session teardown). */
-    clear() {
-      for (const vpId of Array.from(store.keys())) this.invalidate(vpId);
-    },
-
-    /** Diagnostics. */
-    size() { return store.size; },
-    has(vpId) { return store.has(vpId); },
-    getMeta(vpId) { return meta.get(vpId) || null; },
-  };
-
-  void DEFAULT_SCOPE; // reserved for cross-module sharing; not used in MVP
-}

package/unify/vp/role-instance.js

@@ -1,216 +0,0 @@
-/**
- * role-instance.js — RoleInstance class (per-group per-VP runtime handle).
- *
- * task-334 §5 RoleInstance. 334a defined the shape; task-334c adds the
- * lifecycle surface:
- *   - state machine:   idle → queued → running → (idle | error) + standby
- *   - inputQueue:      enqueue(envelope) + drain(runner) loop
- *   - abort:           per-instance AbortController, exposed via abort()
- *
- * Hard constraints (inherited from 334a):
- *   - does NOT import 334o shard-store directly (memoryStore stays nullable)
- *   - does NOT import 334d routing (inputQueue accepts whatever coordinator
- *     hands it; runner is the sole consumer)
- *
- * Hard constraint (334c-specific):
- *   - the runner callback is injected — RoleInstance does not know about
- *     Engine internals. See run-turn.js for the canonical runner.
- */
-
-/**
- * @typedef {'idle'|'queued'|'running'|'standby'|'error'} RoleInstanceState
- *
- *   - idle:     no work, ready to accept
- *   - queued:   inputQueue has items, drain scheduled/running but this
- *               iteration is not yet inside the runner (brief transition)
- *   - running:  inside runner for one envelope
- *   - standby:  explicit pause via setState('standby'); enqueue is allowed
- *               (buffers) but drain is gated until setState('idle')
- *   - error:    last turn threw; next enqueue re-enters drain and clears
- */
-
-let _seq = 0;
-function nextInstanceId(vpId, groupId) {
-  _seq = (_seq + 1) >>> 0;
-  return `ri_${groupId}_${vpId}_${Date.now().toString(36)}_${_seq.toString(36)}`;
-}
-
-export class RoleInstance {
-  /**
-   * @param {{ vp: import('./vp-store.js').VP, groupId: string }} params
-   */
-  constructor({ vp, groupId }) {
-    if (!vp) throw new Error('RoleInstance requires a vp');
-    if (!groupId) throw new Error('RoleInstance requires a groupId');
-
-    this.id = nextInstanceId(vp.id, groupId);
-    this.vpId = vp.id;
-    this.groupId = groupId;
-    /** Live VP reference. Persona hot-reload mutates fields in place. */
-    this.vp = vp;
-
-    // ── Runtime state (preserved across persona hot-reload) ─────
-    /** @type {RoleInstanceState} */
-    this.state = 'idle';
-    /** Conversation messages appended by run-turn (user + assistant pairs). */
-    this.messages = [];
-    /** Pending input queue (envelopes from coordinator). */
-    this.inputQueue = [];
-    /** Abort controller for in-flight run. Created per-turn. */
-    this.abortController = null;
-
-    // ── Nullable sub-system handles (attached by later slices) ──
-    /** threadStore — optional (334h). */
-    this.threadStore = null;
-    /** subagentPool — optional. */
-    this.subagentPool = null;
-    /** memoryStore — 334f wraps 334o; NOT created here. */
-    this.memoryStore = null;
-    /** Cached Engine for this VP; bound lazily by engine-binding.js. */
-    this.engine = null;
-    /** Cached systemPrompt string; rebuilt when vp.mtimeMs changes. */
-    this.systemPrompt = null;
-    /** mtimeMs seen when systemPrompt was last built — invalidation key. */
-    this._promptBuiltForMtime = null;
-
-    // ── Telemetry ───────────────────────────────────────────────
-    this.createdAt = Date.now();
-    this.lastActivityAt = this.createdAt;
-    /** Total turns executed via drain (error turns included). */
-    this.turnCount = 0;
-    /** Last error thrown by runner; cleared on next successful turn. */
-    this.lastError = null;
-
-    // ── Drain internals ────────────────────────────────────────
-    /** Set while a drain loop is active. Prevents re-entry. */
-    this._draining = false;
-    /** Promise that resolves when the current drain loop exits. */
-    this._drainPromise = null;
-  }
-
-  /** Update last-activity timestamp (used by LRU eviction). */
-  touch() {
-    this.lastActivityAt = Date.now();
-  }
-
-  /** Transition helper. Emits a state change to optional listeners. */
-  setState(next) {
-    this.state = next;
-    this.touch();
-  }
-
-  /**
-   * Enqueue an envelope for processing. Triggers a drain if one isn't
-   * already running.
-   *
-   * Envelope shape (from coordinator.js makeEnvelope): { groupId, taskId,
-   * msg, trigger }. Opaque to RoleInstance — handed verbatim to runner.
-   *
-   * @param {object} envelope
-   * @returns {number} new inputQueue length
-   */
-  enqueue(envelope) {
-    if (!envelope) throw new Error('enqueue: envelope required');
-    this.inputQueue.push(envelope);
-    this.touch();
-    if (this.state === 'idle') this.setState('queued');
-    return this.inputQueue.length;
-  }
-
-  /**
-   * Abort the in-flight run (if any) and clear the pending queue's
-   * ability to advance further by signalling abort. The queue is NOT
-   * cleared — that's policy left to the caller (e.g. GroupCoordinator
-   * may reshedule on next user message).
-   *
-   * @param {string} [reason]
-   */
-  abort(reason = 'user') {
-    if (this.abortController && !this.abortController.signal.aborted) {
-      try { this.abortController.abort(reason); } catch { /* ignore */ }
-    }
-    this.touch();
-  }
-
-  /**
-   * Drain the inputQueue by invoking `runner(envelope)` for each. One
-   * envelope at a time, FIFO. Re-entry safe: if a drain is already in
-   * progress, return the in-flight promise instead of starting a second
-   * loop. Standby gates the loop (standby → no runner calls until a
-   * subsequent `setState('idle')` + enqueue).
-   *
-   * The runner owns state transitions into 'running' and back to 'idle'
-   * for the iteration it's handling; drain only sets the initial queued
-   * / final idle around the whole loop.
-   *
-   * @param {(envelope: object, ri: RoleInstance) => Promise<void>} runner
-   * @returns {Promise<{turns:number, errors:number}>}
-   */
-  drain(runner) {
-    if (typeof runner !== 'function') {
-      return Promise.reject(new Error('drain: runner must be a function'));
-    }
-    if (this._draining) return this._drainPromise;
-
-    this._draining = true;
-    this._drainPromise = (async () => {
-      let turns = 0;
-      let errors = 0;
-      try {
-        while (this.inputQueue.length > 0) {
-          // Standby blocks the drain — buffer until caller reactivates.
-          if (this.state === 'standby') break;
-          const envelope = this.inputQueue.shift();
-          this.turnCount += 1;
-          turns += 1;
-          // Fresh controller per turn so abort(reason) only kills one iter
-          // and the next envelope starts with a clean signal.
-          this.abortController = new AbortController();
-          try {
-            this.setState('running');
-            await runner(envelope, this);
-            this.lastError = null;
-          } catch (err) {
-            errors += 1;
-            this.lastError = err;
-            this.setState('error');
-            // Propagate abort — don't swallow it; but do stop draining so
-            // the caller can decide to requeue / resume.
-            if (err && err.name === 'AbortError') break;
-            // Non-abort errors: continue draining. The next turn gets a
-            // fresh state via setState('running') at the top of the loop.
-          }
-        }
-        // Settle terminal state only if we didn't bail in 'error' or
-        // 'standby'. Keep 'standby' sticky so caller must reactivate.
-        if (this.state !== 'standby' && this.state !== 'error') {
-          this.setState('idle');
-        }
-      } finally {
-        this._draining = false;
-        this._drainPromise = null;
-        this.abortController = null;
-      }
-      return { turns, errors };
-    })();
-    return this._drainPromise;
-  }
-
-  /**
-   * Snapshot for debug / telemetry. Excludes bulky messages.
-   */
-  snapshot() {
-    return {
-      id: this.id,
-      vpId: this.vpId,
-      groupId: this.groupId,
-      state: this.state,
-      messageCount: this.messages.length,
-      queueDepth: this.inputQueue.length,
-      turnCount: this.turnCount,
-      hasError: Boolean(this.lastError),
-      lastActivityAt: this.lastActivityAt,
-      createdAt: this.createdAt,
-    };
-  }
-}