@yeaft/webchat-agent 0.1.657 → 0.1.659

package/package.json

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

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/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,
-    };
-  }
-}

package/unify/vp/run-turn.js

@@ -1,251 +0,0 @@
-/**
- * run-turn.js — execute one turn for a RoleInstance.
- *
- * A "turn" = consume one envelope from RoleInstance.inputQueue, build a
- * fresh system prompt (§8), call `engine.query({prompt, messages, signal})`,
- * accumulate the streamed text, and append the resulting assistant
- * message both to `ri.messages` (for next-turn context) and — if the
- * caller provides a GroupHandle — to the group's jsonl log via its
- * `appendMessage` API (§334b public surface; hard constraint c: we never
- * hand-write bytes).
- *
- * This is the canonical runner passed to `RoleInstance.drain(runner)`.
- * Tests substitute a fake engine via createEngineBinder to exercise the
- * drain loop / state machine without a live adapter.
- *
- * Streaming contract — event types handled (all optional; Engine.query is
- * the source of truth):
- *   { type: 'text',        text: string }          — accumulate
- *   { type: 'text_chunk',  text: string }          — accumulate
- *   { type: 'tool_call',   ... }                   — pass to onEvent
- *   { type: 'tool_end',    ... }                   — pass to onEvent
- *   { type: 'aborted',     reason }                — exit loop, throw AbortError
- *   { type: 'error',       error }                 — throw
- *   { type: 'turn_end',    ... }                   — exit loop
- *
- * Unknown event types are forwarded to `onEvent(evt)` if provided.
- */
-
-import { buildSystemPrompt } from './system-prompt.js';
-
-/**
- * Build the taskCtx opt for buildSystemPrompt. Pulls active tasks for the
- * VP's current group from the task store, plus the current task (if any).
- * Returns null if no taskStore is wired (legacy / tests).
- */
-function collectTaskCtx({ taskStore, groupId, currentTaskId }) {
-  if (!taskStore || !groupId) return null;
-  let allTasks;
-  try {
-    allTasks = taskStore.list();
-  } catch {
-    return null;
-  }
-  if (!Array.isArray(allTasks)) return null;
-
-  const inGroup = allTasks.filter(
-    (t) => t && t.groupId === groupId && t.status !== 'completed' && t.status !== 'cancelled',
-  );
-  // Order by lastActivity / updatedAt desc so most-recent surface first.
-  inGroup.sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
-
-  const activeTasks = inGroup.map((t) => ({
-    id: t.id,
-    title: t.title,
-    status: t.status,
-    members: Array.isArray(t.members) ? t.members.slice() : [],
-    initiator: t.initiator || null,
-    lastActivityAt: t.updatedAt || t.createdAt || 0,
-  }));
-
-  let currentTask = null;
-  if (currentTaskId) {
-    const t = allTasks.find((x) => x && x.id === currentTaskId);
-    if (t) {
-      currentTask = {
-        id: t.id,
-        title: t.title,
-        members: Array.isArray(t.members) ? t.members.slice() : [],
-        initiator: t.initiator || null,
-      };
-    }
-  }
-
-  if (activeTasks.length === 0 && !currentTask) return null;
-  return { activeTasks, currentTask };
-}
-
-/**
- * Build a runner suitable for RoleInstance.drain().
- *
- * @param {{
- *   binder: import('./engine-binding.js').createEngineBinder extends (...args:any)=>infer R ? R : never,
- *   registry?: import('./registry.js').Registry,
- *   group?: import('../groups/group-store.js').GroupHandle,  // optional persistence
- *   rosterMembers?: string[],
- *   capabilitiesLine?: string,
- *   onEvent?: (evt:any, ri:any) => void,
- *   buildPromptOverride?: typeof buildSystemPrompt,
- * }} deps
- */
-export function createTurnRunner(deps = {}) {
-  const {
-    binder,
-    registry,
-    group,
-    rosterMembers,
-    capabilitiesLine,
-    onEvent,
-    buildPromptOverride,
-    taskStore,             // R6 §6 trigger #6: enables task_ctx affiliation hint
-  } = deps;
-
-  if (!binder || typeof binder.bind !== 'function') {
-    throw new Error('createTurnRunner: binder (from createEngineBinder) is required');
-  }
-
-  const buildPrompt = buildPromptOverride || buildSystemPrompt;
-
-  /**
-   * The actual runner. Called once per envelope by drain().
-   *
-   * @param {object} envelope   — { groupId, taskId, msg, trigger }
-   * @param {import('./role-instance.js').RoleInstance} ri
-   */
-  return async function runOneTurn(envelope, ri) {
-    if (!envelope || !envelope.msg) {
-      throw new Error('runOneTurn: envelope.msg missing');
-    }
-
-    const engine = binder.bind(ri);
-
-    // Fresh system prompt per turn — DYNAMIC section changes every turn.
-    const taskCtx = collectTaskCtx({
-      taskStore,
-      groupId: ri.groupId,
-      currentTaskId: envelope.taskId || null,
-    });
-    const systemPrompt = await buildPrompt(ri, {
-      registry,
-      rosterMembers,
-      capabilitiesLine,
-      runtimeCtx: {
-        taskId: envelope.taskId || null,
-        isDream: false,
-      },
-      taskCtx,
-    });
-
-    // Prompt text = inbound message body. Engine.query spec:
-    //   { prompt, messages, signal, ... }
-    // It prepends the system prompt via adapter-level wiring; we pass
-    // `systemPrompt` as an explicit first message if the engine supports
-    // it, else rely on the engine's own system injection. For §334c MVP
-    // we pass systemPrompt as metadata on messages[0] and let the engine
-    // decide — tests supply a fake engine that echoes back.
-    const prompt = String(envelope.msg.text || '').trim();
-    if (!prompt) {
-      // No-op envelope (empty msg): record a stub and return.
-      ri.messages.push({ role: 'user', text: '', ts: new Date().toISOString(), meta: envelope });
-      return;
-    }
-
-    ri.messages.push({
-      role: 'user',
-      text: prompt,
-      ts: envelope.msg.ts || new Date().toISOString(),
-      from: envelope.msg.from || 'user',
-      msgId: envelope.msg.id || null,
-      trigger: envelope.trigger || null,
-    });
-
-    const signal = ri.abortController ? ri.abortController.signal : undefined;
-
-    // Build prior-messages window for the engine — MVP: the last 20.
-    const priorMessages = ri.messages.slice(-20);
-
-    let accumulated = '';
-    let aborted = false;
-    let errored = null;
-
-    const iterator = engine.query({
-      prompt,
-      messages: priorMessages,
-      signal,
-      systemPrompt,
-      metadata: {
-        vpId: ri.vpId,
-        groupId: ri.groupId,
-        taskId: envelope.taskId || null,
-        turnId: `${ri.id}:${ri.turnCount}`,
-      },
-    });
-
-    try {
-      for await (const evt of iterator) {
-        if (!evt || typeof evt !== 'object') continue;
-        switch (evt.type) {
-          case 'text':
-          case 'text_chunk':
-          case 'message':
-            if (typeof evt.text === 'string') accumulated += evt.text;
-            if (onEvent) try { onEvent(evt, ri); } catch { /* ignore */ }
-            break;
-          case 'aborted':
-            aborted = true;
-            if (onEvent) try { onEvent(evt, ri); } catch { /* ignore */ }
-            break;
-          case 'error':
-            errored = evt.error instanceof Error ? evt.error : new Error(String(evt.error || 'engine error'));
-            if (onEvent) try { onEvent(evt, ri); } catch { /* ignore */ }
-            break;
-          case 'turn_end':
-            if (onEvent) try { onEvent(evt, ri); } catch { /* ignore */ }
-            break;
-          default:
-            if (onEvent) try { onEvent(evt, ri); } catch { /* ignore */ }
-        }
-        if (aborted || errored) break;
-      }
-    } catch (err) {
-      if (err && err.name === 'AbortError') {
-        aborted = true;
-      } else {
-        errored = err;
-      }
-    }
-
-    if (aborted) {
-      const e = new Error('aborted');
-      e.name = 'AbortError';
-      throw e;
-    }
-    if (errored) throw errored;
-
-    // Record assistant reply (even if empty — the turn still counted).
-    const assistantMsg = {
-      role: 'assistant',
-      text: accumulated,
-      ts: new Date().toISOString(),
-      from: ri.vpId,
-      taskId: envelope.taskId || null,
-    };
-    ri.messages.push(assistantMsg);
-
-    // Hard constraint (c): persistence goes through 334b's appendMessage.
-    if (group && typeof group.appendMessage === 'function' && accumulated.trim()) {
-      try {
-        group.appendMessage({
-          from: ri.vpId,
-          role: 'assistant',
-          text: accumulated,
-          taskId: envelope.taskId || null,
-          meta: { trigger: envelope.trigger || null, replyTo: envelope.msg.id || null },
-        });
-      } catch (err) {
-        // Non-fatal: the in-memory message is still recorded on ri.messages.
-        if (onEvent) try { onEvent({ type: 'persist_error', error: err }, ri); } catch { /* ignore */ }
-      }
-    }
-  };
-}

package/unify/vp/system-prompt.js

@@ -1,311 +0,0 @@
-/**
- * system-prompt.js — assemble a VP's system prompt per architecture §8.
- *
- * Three sections:
- *   § STATIC
- *     - identity (yeaft base — short)
- *     - vp_persona (role.md persona body)
- *     - capabilities (tools) — 334d owns the real list; this slice leaves
- *       a stub that names the MVP tool surface ("route_forward" ...).
- *
- *   § SEMI-DYNAMIC
- *     - group_roster (name + on-line status via Registry.activeCount)
- *     - (skills / mcp / user_profile — owned by other slices; 334c emits
- *       placeholder only if the caller provides them)
- *
- *   § DYNAMIC
- *     - runtime_ctx  { vpId, groupId, taskId?, isDream=false }
- *     - core_memory  (recall top-K; vp single-dim per R3 §Δ2.3)
- *     - task_ctx     (R6 §8: lists active tasks in current group + affiliation
- *                    hint guiding the LLM to call task_create / continue an
- *                    existing task / reply at group level — this is the
- *                    mechanism that lets tasks "auto-emerge" from chat per
- *                    R6 §6 trigger #6.)
- *
- * Caching: the STATIC persona section is cached per RoleInstance via
- * `ri._promptBuiltForMtime === vp.mtimeMs`. DYNAMIC is always rebuilt.
- *
- * Hard constraint (334c): this module does not touch 334f/334g memory
- * internals. It calls `memoryStore.query({vp})` (duck-typed) and falls
- * back to an empty top-K if the store is null.
- */
-
-import { recallCoreMemory } from './core-memory-recall.js';
-
-const CORE_MEMORY_TOP_K = 7;          // §8
-const ROSTER_STATUS_ONLINE = 'online';
-const ROSTER_STATUS_BUSY = 'busy';
-
-/**
- * Build one complete system prompt string.
- *
- * @param {import('./role-instance.js').RoleInstance} ri
- * @param {{
- *   registry?: import('./registry.js').Registry,
- *   rosterMembers?: string[],           // explicit override (334b GroupHandle.roster)
- *   runtimeCtx?: { taskId?: string|null, isDream?: boolean, recentChatSummary?: string },
- *   capabilitiesLine?: string,          // 334d injects tool inventory
- *   userProfile?: string,               // 334l injects top-5 user-memory
- *   recentGroupChat?: string,           // 334h injects N recent msgs
- *   taskCtx?: {
- *     activeTasks?: Array<{
- *       id: string, title?: string, status?: string,
- *       members?: string[], initiator?: string,
- *       lastActivityAt?: number,
- *     }>,                                // tasks in this group the VP can join/continue
- *     currentTask?: {                    // the task the VP is currently inside
- *       id: string, title?: string, members?: string[], initiator?: string,
- *     },
- *     relatedTasks?: Array<{ id: string, title?: string, groupId?: string }>,
- *   },
- * }} opts
- * @returns {string}
- */
-export async function buildSystemPrompt(ri, opts = {}) {
-  if (!ri || !ri.vp) throw new Error('buildSystemPrompt: role instance required');
-  const vp = ri.vp;
-
-  // ─── § STATIC (cached per mtime) ────────────────────────────
-  let staticBlock = ri.systemPrompt;
-  if (!staticBlock || ri._promptBuiltForMtime !== vp.mtimeMs) {
-    staticBlock = buildStatic(vp, opts.capabilitiesLine);
-    ri.systemPrompt = staticBlock;
-    ri._promptBuiltForMtime = vp.mtimeMs;
-  }
-
-  // ─── § SEMI-DYNAMIC ─────────────────────────────────────────
-  const roster = buildRoster(ri, opts.registry, opts.rosterMembers);
-  const userProfile = opts.userProfile ? `\n## user_profile\n${opts.userProfile.trim()}\n` : '';
-
-  // ─── § DYNAMIC ──────────────────────────────────────────────
-  const ctx = opts.runtimeCtx || {};
-  const runtime = buildRuntimeCtx(ri, ctx);
-  const recent = opts.recentGroupChat
-    ? `\n## recent_group_chat\n${opts.recentGroupChat.trim()}\n`
-    : '';
-  const coreMem = await buildCoreMemoryBlock(ri, ctx);
-  const taskCtx = buildTaskCtxBlock(ri, opts.taskCtx, ctx);
-
-  return [
-    '# § STATIC',
-    staticBlock,
-    '',
-    '# § SEMI-DYNAMIC',
-    roster,
-    userProfile.trim() ? userProfile : '',
-    '',
-    '# § DYNAMIC',
-    runtime,
-    recent.trim() ? recent : '',
-    coreMem,
-    taskCtx,
-  ]
-    .filter(Boolean)
-    .join('\n')
-    .replace(/\n{3,}/g, '\n\n')
-    .trim();
-}
-
-// ──────────────────────────────────────────────────────────────
-// STATIC
-// ──────────────────────────────────────────────────────────────
-
-function buildStatic(vp, capabilitiesLine) {
-  const identity =
-    'You are a Virtual Person (VP) in a yeaft multi-agent group.\n' +
-    'Respect §6 triggers: text @-mentions do NOT route. Use the `route_forward` tool for explicit dispatch.';
-
-  const persona = vp.persona && vp.persona.trim()
-    ? vp.persona.trim()
-    : `(no persona body for ${vp.id})`;
-
-  const caps = (capabilitiesLine && capabilitiesLine.trim())
-    || [
-      'Tools: route_forward, memory_search, memory_trace, task_summary_post (if initiator).',
-      'Sub-agent fan-out: when a single user task is large enough to benefit from parallel execution,',
-      'you MAY spawn sub-agents using the `Agent` tool. Each sub-agent inherits your persona +',
-      'voice, gets its own ToolRegistry (without Agent / RouteForward / AskUser to prevent recursion),',
-      'and runs the same Engine flow. Use `Agent` to spawn (returns agentId), `WaitAgent` to collect',
-      'each turn output, `SendMessage` for follow-ups, `CloseAgent` when done. You can fire multiple',
-      '`Agent` tool_calls in one assistant turn to launch them in parallel. Pass a self-contained,',
-      'markdown mission ("## Goal / ## Context / ## Deliverable / ## Constraints") — the sub-agent',
-      'cannot see your conversation history. Only spawn when work is genuinely parallelisable; for',
-      'small or strictly-sequential tasks, do it yourself.',
-    ].join('\n');
-
-  // personaHash travels in the static block so downstream (334h live-diff)
-  // can detect changes without re-hashing.
-  return [
-    '## identity',
-    identity,
-    '',
-    `## vp_persona (id=${vp.id}, hash=${vp.personaHash || '-'})`,
-    `Name: ${vp.name}`,
-    vp.role ? `Role: ${vp.role}` : '',
-    vp.traits && vp.traits.length ? `Traits: ${vp.traits.join(', ')}` : '',
-    '',
-    persona,
-    '',
-    '## capabilities',
-    caps,
-  ].filter(Boolean).join('\n');
-}
-
-// ──────────────────────────────────────────────────────────────
-// SEMI-DYNAMIC — Roster
-// ──────────────────────────────────────────────────────────────
-
-function buildRoster(ri, registry, rosterMembers) {
-  const members = Array.isArray(rosterMembers) && rosterMembers.length > 0
-    ? rosterMembers
-    : registry
-      ? Array.from(new Set(registry.listRoleInstances()
-          .filter((r) => r.groupId === ri.groupId)
-          .map((r) => r.vpId)))
-      : [ri.vpId];
-
-  const lines = [`## 群成员 (${members.length})`];
-  for (const vpId of members) {
-    if (vpId === ri.vpId) {
-      lines.push(`- 你自己：${vpId}`);
-      continue;
-    }
-    const status = memberStatus(vpId, registry);
-    const name = registry?.getVp?.(vpId)?.name || vpId;
-    lines.push(`- ${name} (${vpId}) · ${status}`);
-  }
-  return lines.join('\n');
-}
-
-function memberStatus(vpId, registry) {
-  if (!registry) return ROSTER_STATUS_ONLINE;
-  // §8.2: busy if any RoleInstance for this VP has state==='running' in any group.
-  // MVP: also 'running' while 'queued'? — spec says "running RoleInstance 数 > 0".
-  const ris = registry.listRoleInstances?.() || [];
-  const busy = ris.some((r) => r.vpId === vpId && r.state === 'running');
-  return busy ? ROSTER_STATUS_BUSY : ROSTER_STATUS_ONLINE;
-}
-
-// ──────────────────────────────────────────────────────────────
-// DYNAMIC
-// ──────────────────────────────────────────────────────────────
-
-function buildRuntimeCtx(ri, ctx) {
-  return [
-    '## runtime_ctx',
-    `vpId: ${ri.vpId}`,
-    `groupId: ${ri.groupId}`,
-    ctx.taskId ? `taskId: ${ctx.taskId}` : null,
-    `isDream: ${Boolean(ctx.isDream)}`,
-  ].filter(Boolean).join('\n');
-}
-
-async function buildCoreMemoryBlock(ri, ctx) {
-  if (!ri.memoryStore) return '';
-  const entries = await recallCoreMemory(ri.memoryStore, {
-    vp: ri.vpId,
-    limit: CORE_MEMORY_TOP_K,
-  });
-  if (!entries || entries.length === 0) return '';
-  void ctx; // task_ctx injection is 334n's scope; reserved param.
-  const lines = ['## core_memory'];
-  for (const e of entries) {
-    const shard = e.shard || 'general';
-    const body = (e.body || '').trim();
-    if (!body) continue;
-    lines.push(`- [mem:${shard}] ${body}`);
-  }
-  if (lines.length === 1) return '';
-  return lines.join('\n');
-}
-
-// ──────────────────────────────────────────────────────────────
-// DYNAMIC — task_ctx (R6 §6 trigger #6 + §8)
-//
-// The affiliation hint is the load-bearing piece that lets tasks
-// auto-emerge from chat. Without it, VPs never call task_create —
-// the spec lists the tool but a model with no nudge will just keep
-// chatting at group level. We list active tasks in the group + give
-// crisp guidance on when to (a) continue an existing task, (b) start
-// a new one, or (c) reply at group level.
-// ──────────────────────────────────────────────────────────────
-
-function buildTaskCtxBlock(ri, taskCtx, runtimeCtx) {
-  if (!taskCtx) return '';
-
-  const currentTask = taskCtx.currentTask;
-  const activeTasks = Array.isArray(taskCtx.activeTasks) ? taskCtx.activeTasks : [];
-  const relatedTasks = Array.isArray(taskCtx.relatedTasks) ? taskCtx.relatedTasks : [];
-
-  const otherTasks = activeTasks
-    .filter((t) => t && t.id && (!currentTask || t.id !== currentTask.id))
-    .slice(0, 8); // cap to avoid prompt bloat — coordinator orders by recency
-
-  // Nothing useful to say — drop the block entirely. Without active tasks,
-  // a current task, or related tasks, the affiliation_hint has no anchor.
-  if (otherTasks.length === 0 && !currentTask && relatedTasks.length === 0) {
-    return '';
-  }
-
-  const lines = ['## task_ctx'];
-
-  // (a) currently inside a task → focus on this one
-  if (currentTask && currentTask.id) {
-    lines.push(`### current_task`);
-    lines.push(`- id: ${currentTask.id}`);
-    if (currentTask.title) lines.push(`- title: ${currentTask.title}`);
-    if (currentTask.initiator) lines.push(`- initiator: ${currentTask.initiator}`);
-    if (Array.isArray(currentTask.members) && currentTask.members.length) {
-      lines.push(`- members: ${currentTask.members.join(', ')}`);
-    }
-  }
-
-  // (b) other open tasks in the same group — candidates for affiliation
-  if (otherTasks.length > 0) {
-    lines.push(`### active_tasks_in_group (${otherTasks.length})`);
-    for (const t of otherTasks) {
-      const parts = [`- ${t.id}`];
-      if (t.title) parts.push(`"${t.title}"`);
-      if (t.status) parts.push(`(${t.status})`);
-      if (Array.isArray(t.members) && t.members.length) {
-        parts.push(`members=[${t.members.join(',')}]`);
-      }
-      lines.push(parts.join(' '));
-    }
-  }
-
-  // (c) related tasks (recall top-N from §14)
-  if (relatedTasks.length > 0) {
-    lines.push(`### related_tasks (${relatedTasks.length})`);
-    for (const t of relatedTasks.slice(0, 3)) {
-      const parts = [`- ${t.id}`];
-      if (t.title) parts.push(`"${t.title}"`);
-      if (t.groupId && t.groupId !== ri.groupId) parts.push(`(grp:${t.groupId})`);
-      lines.push(parts.join(' '));
-    }
-  }
-
-  // (d) affiliation hint — the actual decision rubric
-  // Suppress full hint when already inside a task (focus on continuing).
-  const inTask = Boolean(runtimeCtx?.taskId || currentTask?.id);
-  if (!inTask) {
-    lines.push('');
-    lines.push('### affiliation_hint');
-    lines.push('Decide BEFORE replying:');
-    lines.push('- If this user message clearly continues one of the active_tasks_in_group above,');
-    lines.push('  use the `task_message` route (other VPs in that task will see your reply, others will not).');
-    lines.push('- If this is a NEW multi-turn collaboration worth tracking (decisions, deliverables,');
-    lines.push('  multiple VPs needed), call `TaskCreate` with title + members[] + groupId; you become');
-    lines.push('  the task initiator and may post `task_summary_post` to broadcast progress.');
-    lines.push('- If this is just a quick question / chitchat / single-shot answer, reply at group level — no task.');
-    lines.push('Do NOT create a task for trivial back-and-forth. Do NOT continue a task whose topic clearly diverged.');
-  } else {
-    lines.push('');
-    lines.push('### affiliation_hint');
-    lines.push('You are inside a task. Stay focused on its scope. Use `task_summary_post` (initiator only)');
-    lines.push('to broadcast progress to the group. Use `route_forward` to hand off; do not silently leave.');
-  }
-
-  if (lines.length === 1) return '';
-  return lines.join('\n');
-}