@yeaft/webchat-agent 0.1.586 → 0.1.588

package/connection/message-router.js

@@ -36,7 +36,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, handleUnifyGroupChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory, handleUnifyMergeThread, handleUnifyForkThread, handleUnifyAbortThread, handleUnifyAbortAll, handleUnifyVpSubscribe, handleUnifyVpCreate, handleUnifyVpUpdate, handleUnifyVpDelete, handleUnifyVpRead, handleUnifyTaskMessage, handleUnifyUserMemoryWrite, handleUnifyUserMemoryRemove, handleUnifyMemoryScopeList, handleUnifyListGroups, handleUnifyCreateGroup, handleUnifyRenameGroup, handleUnifyArchiveGroup, handleUnifyAddMember, handleUnifyRemoveMember, handleUnifySetDefaultVp, handleUnifyDreamTrigger } from '../unify/web-bridge.js';
+import { handleUnifyChat, handleUnifyGroupChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory, handleUnifyMergeThread, handleUnifyForkThread, handleUnifyAbortThread, handleUnifyAbortAll, handleUnifyVpSubscribe, handleUnifyVpCreate, handleUnifyVpUpdate, handleUnifyVpDelete, handleUnifyVpRead, handleUnifyTaskMessage, handleUnifyUserMemoryWrite, handleUnifyUserMemoryRemove, handleUnifyMemoryScopeList, handleUnifyMemoryQuery, handleUnifyMemoryTrace, handleUnifyFetchSummaryHistory, handleUnifyTaskCrud, handleUnifyListGroups, handleUnifyCreateGroup, handleUnifyRenameGroup, handleUnifyArchiveGroup, handleUnifyAddMember, handleUnifyRemoveMember, handleUnifySetDefaultVp, handleUnifyDreamTrigger } from '../unify/web-bridge.js';
 
 export async function handleMessage(msg) {
   switch (msg.type) {
@@ -446,6 +446,23 @@ export async function handleMessage(msg) {
       handleUnifyMemoryScopeList(msg);
       break;
 
+    // R6 G2 — VP/Task memory browser (read-only). Replies with
+    // unify_memory_query_result / unify_memory_trace_result.
+    case 'unify_memory_query':
+      handleUnifyMemoryQuery(msg);
+      break;
+    case 'unify_memory_trace':
+      handleUnifyMemoryTrace(msg);
+      break;
+
+    // R6 G1a — task summary history + task affiliation CRUD.
+    case 'unify_fetch_summary_history':
+      await handleUnifyFetchSummaryHistory(msg);
+      break;
+    case 'unify_task_crud':
+      await handleUnifyTaskCrud(msg);
+      break;
+
     // task-334m: Group CRUD + D1 seed wiring (§Δ10 334m + R6 §Δ31.2).
     // All handlers reply via `group_crud_result`; mutating ops additionally
     // emit `group_roster_changed` (add/remove/default) or

package/package.json

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

package/unify/engine.js

@@ -297,7 +297,7 @@ export class Engine {
    * @param {string} [userProfile] — user profile from user-memory shard store
    * @returns {string}
    */
-  #buildSystemPrompt(memory, compactSummary, prompt, memoryInjection, userProfile) {
+  #buildSystemPrompt(memory, compactSummary, prompt, memoryInjection, userProfile, vpPersona) {
     // Get relevant skill content if SkillManager is wired
     let skillContent = '';
     if (this.#skillManager && prompt) {
@@ -317,6 +317,7 @@ export class Engine {
       compactSummary,
       skillContent,
       userProfile,
+      vpPersona,
       // task-334f: memory_trace tool is now registered (49 → 51 tools), so
       // unlock the core_memory meta-line behind 334e's feature flag.
       memoryTraceAvailable: true,
@@ -329,7 +330,7 @@ export class Engine {
    * @param {AbortSignal} [signal]
    * @returns {object}
    */
-  #buildToolContext(signal) {
+  #buildToolContext(signal, vpCtx) {
     return {
       signal,
       yeaftDir: this.#yeaftDir,
@@ -348,6 +349,13 @@ export class Engine {
       imageAllowlist: Array.isArray(this.#config?.unify?.imageAllowlist)
         ? this.#config.unify.imageAllowlist
         : [],
+      // Bug 4 fix — VP / routing context for RouteForward (and any other
+      // VP-aware tool). Undefined when running in non-group / no-VP flows.
+      router: vpCtx?.router,
+      senderVpId: vpCtx?.senderVpId,
+      inboundEnvelope: vpCtx?.inboundEnvelope,
+      taskId: vpCtx?.taskId,
+      taskMembers: vpCtx?.taskMembers,
     };
   }
 
@@ -510,7 +518,7 @@ export class Engine {
    *   SCENARIO_EFFORT. Unknown values fall through to 'high'.
    * @yields {EngineEvent}
    */
-  async *query({ prompt, messages = [], signal, userEffort = null, scenario = 'chat' }) {
+  async *query({ prompt, messages = [], signal, userEffort = null, scenario = 'chat', vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers } = {}) {
     if (!prompt || typeof prompt !== 'string' || !prompt.trim()) {
       yield {
         type: 'error',
@@ -561,7 +569,7 @@ export class Engine {
     const runSignal = abortCtrl.signal;
 
     try {
-      yield* this.#runQuery({ prompt: effectivePrompt, messages, signal: runSignal, userEffort: effectiveUserEffort, scenario });
+      yield* this.#runQuery({ prompt: effectivePrompt, messages, signal: runSignal, userEffort: effectiveUserEffort, scenario, vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers });
     } finally {
       if (signal) {
         try { signal.removeEventListener('abort', onExternalAbort); } catch { /* ignore */ }
@@ -579,7 +587,7 @@ export class Engine {
    * in a try/finally without indenting the whole loop.
    * @private
    */
-  async *#runQuery({ prompt, messages, signal, userEffort = null, scenario = 'chat' }) {
+  async *#runQuery({ prompt, messages, signal, userEffort = null, scenario = 'chat', vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers }) {
 
     // ─── Pre-query: Memory Injection (task-287) + Compact Summary ──
     // Two-layer recall:
@@ -618,7 +626,7 @@ export class Engine {
 
     const compactSummary = this.#getCompactSummary();
     const userProfile = recallResult?.profile || '';
-    const systemPrompt = this.#buildSystemPrompt(undefined, compactSummary, prompt, memoryInjection, userProfile);
+    const systemPrompt = this.#buildSystemPrompt(undefined, compactSummary, prompt, memoryInjection, userProfile, vpPersona);
 
     // Build conversation: existing messages + new user message
     const conversationMessages = [
@@ -883,7 +891,7 @@ export class Engine {
       }
 
       // Execute tool calls and feed results back
-      const toolCtx = this.#buildToolContext(signal);
+      const toolCtx = this.#buildToolContext(signal, { router, senderVpId, inboundEnvelope, taskId, taskMembers });
 
       // task-325a: track whether we aborted mid tool-loop so we can
       // break out of the outer while-loop cleanly once the current

package/unify/pipeline/dispatcher.js

@@ -164,6 +164,7 @@ export class Dispatcher {
     transientMeta.set(entry, {
       messageId: opts.messageId || undefined,
       override: opts.override || undefined,
+      queryOpts: opts.queryOpts || undefined,
     });
     const snapshot = this.#queueSnapshot();
     return { entry, snapshot };
@@ -299,7 +300,8 @@ export class Dispatcher {
     }
 
     try {
-      for await (const event of instance.query({ prompt: claimed.text, signal })) {
+      const queryOpts = (transientMeta.get(claimed) || {}).queryOpts || {};
+      for await (const event of instance.query({ prompt: claimed.text, signal, ...queryOpts })) {
         yield { type: 'engine_event', threadId: targetThreadId, event };
       }
       inputQueue.markRouted(claimed.id, targetThreadId);

package/unify/prompts.js

@@ -192,6 +192,9 @@ const PROMPTS = {
     userProfileHeader: '## user_profile',
     coreMemoryHeader: '## core_memory',
     coreMemoryMeta: 'To open the original message behind any entry above, call `memory_trace`.',
+    vpPersonaHeader: '## active_persona',
+    vpPersonaIntro: (name, role) =>
+      `For this turn you are speaking as **${name}**${role ? ` (${role})` : ''}. Stay in character; the persona below overrides the generic Yeaft identity for tone, expertise, and decision style.`,
   },
   zh: {
     identity: '你是 Yeaft，一个有用的 AI 助手。',
@@ -210,6 +213,9 @@ const PROMPTS = {
     userProfileHeader: '## user_profile',
     coreMemoryHeader: '## core_memory',
     coreMemoryMeta: '如需原始 message，调 `memory_trace`。',
+    vpPersonaHeader: '## active_persona',
+    vpPersonaIntro: (name, role) =>
+      `本轮你以 **${name}**${role ? `（${role}）` : ''} 的身份说话。请保持人设：以下 persona 在语气、专业方向与判断风格上覆盖默认的 Yeaft 身份。`,
   },
 };
 
@@ -289,6 +295,7 @@ export function buildSystemPrompt({
   userProfile,
   coreMemory,
   memoryTraceAvailable = false,
+  vpPersona,
 } = {}) {
   // Fallback to English for unknown languages
   const lang = PROMPTS[language] || PROMPTS.en;
@@ -308,6 +315,14 @@ export function buildSystemPrompt({
   // ─── 2. Date Metadata ──────────────────────────────────
   parts.push(lang.date(new Date().toISOString().split('T')[0]));
 
+  // ─── 2.5 VP Persona Override (Bug 3 fix) ───────────────
+  // When the caller (web-bridge / dispatcher) addressed a specific VP via
+  // @-mention, inject that VP's persona body so the LLM stops speaking as
+  // generic Yeaft and adopts the VP's voice. Placed AFTER base identity so
+  // the persona section's directive ("override generic Yeaft") wins.
+  const vpBlock = renderVpPersona(vpPersona, lang);
+  if (vpBlock) parts.push(vpBlock);
+
   // ─── 3. Mode-Specific Instructions ─────────────────────
   // task-297: single unified mode for all normal operation.
   // `dream` is retained for background memory maintenance.
@@ -382,6 +397,36 @@ export function buildSystemPrompt({
 
 // ─── task-334e helpers ───────────────────────────────────────────
 
+/**
+ * Render the `## active_persona` block when the engine is running on
+ * behalf of an addressed VP. Accepts `{ displayName, role?, persona }` —
+ * `persona` is the body text from the VP's role.md (loaded by the engine
+ * via readVp). When `persona` is empty we still emit the intro line so
+ * the LLM at least knows whose voice to adopt; if even displayName is
+ * missing we omit the whole block (no useful signal).
+ *
+ * @param {object} vpPersona
+ * @param {string} vpPersona.displayName
+ * @param {string} [vpPersona.role]
+ * @param {string} [vpPersona.persona]
+ * @param {object} lang
+ * @returns {string}
+ */
+function renderVpPersona(vpPersona, lang) {
+  if (!vpPersona || typeof vpPersona !== 'object') return '';
+  const name = typeof vpPersona.displayName === 'string'
+    ? vpPersona.displayName.trim() : '';
+  if (!name) return '';
+  const role = typeof vpPersona.role === 'string' ? vpPersona.role.trim() : '';
+  const body = typeof vpPersona.persona === 'string' ? vpPersona.persona.trim() : '';
+  const lines = [
+    lang.vpPersonaHeader,
+    lang.vpPersonaIntro(name, role),
+  ];
+  if (body) lines.push('', body);
+  return lines.join('\n');
+}
+
 const DEFAULT_TASK_MEMORY_TOP = 5;
 const DEFAULT_RELATED_TASK_TOP = 3;
 const DEFAULT_RELATED_TASK_MEMORY_TOP = 2;

package/unify/threads/engine-instance.js

@@ -97,7 +97,7 @@ export class EngineInstance {
    * @param {AbortSignal} [params.signal]
    * @yields {object} EngineEvent with { ...event, threadId }
    */
-  async *query({ prompt, mode, signal }) {
+  async *query({ prompt, mode, signal, vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers } = {}) {
     if (this.#terminated) {
       yield {
         type: 'error',
@@ -173,7 +173,7 @@ export class EngineInstance {
       curToolResults = [];
     }
 
-    for await (const event of this.#engine.query({ prompt, mode, messages: snapshot, signal })) {
+    for await (const event of this.#engine.query({ prompt, mode, messages: snapshot, signal, vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers })) {
       // Re-tag every event with the bound threadId. Non-object events
       // (shouldn't happen — all engine events are objects) are passed
       // through untouched.

package/unify/tools/task-tools.js

@@ -50,7 +50,15 @@ Tasks have a title, description, priority, and status.
 Each task gets its own folder with task.md, progress.md, and memory.md.
 Use this to break down complex work into trackable items.
 
-Pass \`parent_id\` to create a subtask under an existing task.`,
+Pass \`parent_id\` to create a subtask under an existing task.
+
+R6 multi-VP groups (Unify): pass \`group_id\` + \`members\` to create a
+collaborative task inside a group. The caller's vpId becomes the task
+\`initiator\`. \`members\` MUST be a subset of the group's roster — the
+tool validates this server-side and returns a \`not_in_roster\` error
+otherwise. The user owns invitations; the tool will not auto-invite.
+
+Use \`related_task_ids\` to soft-link to other tasks (cross-group OK).`,
   parameters: {
     type: 'object',
     properties: {
@@ -71,6 +79,20 @@ Pass \`parent_id\` to create a subtask under an existing task.`,
         type: 'string',
         description: 'Parent task ID for subtasks',
       },
+      group_id: {
+        type: 'string',
+        description: 'R6: group this task belongs to. Required for multi-VP collaboration tasks.',
+      },
+      members: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'R6: VP ids participating in this task (≥1). MUST be ⊆ group roster.',
+      },
+      related_task_ids: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'R6: soft-linked task ids (cross-group OK). See arch §14.',
+      },
       // Note (task-333b): `parent_task_id` is accepted by execute() as a
       // soft-compat alias for `parent_id` (absorbed from the former
       // SpawnTask tool) but intentionally NOT advertised in the schema to
@@ -84,7 +106,16 @@ Pass \`parent_id\` to create a subtask under an existing task.`,
     const err = requireStore();
     if (err) return err;
 
-    const { title, description, priority = 'medium', parent_id, parent_task_id } = input;
+    const {
+      title,
+      description,
+      priority = 'medium',
+      parent_id,
+      parent_task_id,
+      group_id,
+      members,
+      related_task_ids,
+    } = input;
     if (!title) return JSON.stringify({ error: 'title is required' });
 
     // task-333b: accept either `parent_id` (original TaskCreate field) or
@@ -95,6 +126,62 @@ Pass \`parent_id\` to create a subtask under an existing task.`,
       return JSON.stringify({ error: `Parent task not found: ${parentId}` });
     }
 
+    // R6 multi-VP fields — validated only when group_id is present, so
+    // legacy single-tenant TaskCreate calls keep working.
+    let groupId = null;
+    let normalizedMembers = null;
+    let initiator = null;
+    if (group_id) {
+      groupId = String(group_id);
+
+      // Validate members ⊆ roster. We resolve the roster via the tool ctx
+      // because the tool layer must not import group-store directly (loose
+      // coupling — ctx.getGroupRoster is wired in session.js).
+      let roster = null;
+      if (typeof ctx?.getGroupRoster === 'function') {
+        try { roster = ctx.getGroupRoster(groupId); } catch { roster = null; }
+      }
+      if (!Array.isArray(roster)) {
+        return JSON.stringify({
+          error: 'group_not_found',
+          hint: `group ${groupId} has no roster (group not loaded or doesn't exist)`,
+        });
+      }
+
+      // Default members to [initiator] if not given (R6 §1.5: members ≥ 1).
+      const callerVpId = ctx?.currentVpId || null;
+      const candidateMembers = Array.isArray(members) && members.length > 0
+        ? members.map(String)
+        : (callerVpId ? [callerVpId] : []);
+      if (candidateMembers.length === 0) {
+        return JSON.stringify({
+          error: 'no_members',
+          hint: 'Specify members[] (≥1) or call from a VP context (currentVpId resolves to self).',
+        });
+      }
+      const offRoster = candidateMembers.filter((m) => !roster.includes(m));
+      if (offRoster.length > 0) {
+        return JSON.stringify({
+          error: 'not_in_roster',
+          offRoster,
+          roster,
+          hint: 'These VP ids are not in the group roster. Ask the user to invite them first; do not auto-invite.',
+        });
+      }
+      // Always include the caller as a member (initiator must be ∈ members).
+      if (callerVpId && !candidateMembers.includes(callerVpId)) {
+        if (!roster.includes(callerVpId)) {
+          return JSON.stringify({
+            error: 'caller_not_in_roster',
+            hint: `caller VP ${callerVpId} is not in group ${groupId} roster.`,
+          });
+        }
+        candidateMembers.unshift(callerVpId);
+      }
+      normalizedMembers = Array.from(new Set(candidateMembers));
+      initiator = callerVpId;
+    }
+
     const id = `task-${randomUUID().slice(0, 8)}`;
     const task = {
       id,
@@ -107,15 +194,34 @@ Pass \`parent_id\` to create a subtask under an existing task.`,
       createdAt: Date.now(),
       updatedAt: Date.now(),
     };
+    if (groupId) {
+      task.groupId = groupId;
+      task.members = normalizedMembers;
+      if (initiator) task.initiator = initiator;
+      if (Array.isArray(related_task_ids) && related_task_ids.length) {
+        task.relatedTaskIds = related_task_ids.map(String);
+      }
+    }
 
     taskStore.create(task);
 
     return JSON.stringify({
       success: true,
-      task: { id, title, priority, status: 'pending', parentTaskId: parentId },
-      message: parentId
-        ? `Subtask created: ${title} (${id}) under ${parentId}`
-        : `Task created: ${title} (${id})`,
+      task: {
+        id,
+        title,
+        priority,
+        status: 'pending',
+        parentTaskId: parentId,
+        groupId: groupId || undefined,
+        members: normalizedMembers || undefined,
+        initiator: initiator || undefined,
+      },
+      message: groupId
+        ? `Task created in group ${groupId}: ${title} (${id}) with members [${(normalizedMembers || []).join(', ')}]`
+        : parentId
+          ? `Subtask created: ${title} (${id}) under ${parentId}`
+          : `Task created: ${title} (${id})`,
     });
   },
 });

package/unify/tools/types.js

@@ -19,6 +19,11 @@
  * @property {object} [skillManager] — Skill manager
  * @property {object} [trace] — debug trace
  * @property {object} [config] — engine config
+ * @property {string} [currentVpId] — R6: VP id of the caller (set in multi-VP groups)
+ * @property {string} [currentGroupId] — R6: group id of the caller's RoleInstance
+ * @property {(groupId: string) => string[]|null} [getGroupRoster]
+ *   — R6: resolve a group's roster (used by TaskCreate / route_forward to
+ *   validate `members` ⊆ roster without importing group-store directly).
  */
 
 /**

package/unify/vp/run-turn.js

@@ -28,6 +28,53 @@
 
 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().
  *
@@ -50,6 +97,7 @@ export function createTurnRunner(deps = {}) {
     capabilitiesLine,
     onEvent,
     buildPromptOverride,
+    taskStore,             // R6 §6 trigger #6: enables task_ctx affiliation hint
   } = deps;
 
   if (!binder || typeof binder.bind !== 'function') {
@@ -72,6 +120,11 @@ export function createTurnRunner(deps = {}) {
     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,
@@ -80,6 +133,7 @@ export function createTurnRunner(deps = {}) {
         taskId: envelope.taskId || null,
         isDream: false,
       },
+      taskCtx,
     });
 
     // Prompt text = inbound message body. Engine.query spec:

package/unify/vp/system-prompt.js

@@ -16,6 +16,11 @@
  *   § 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.
@@ -42,6 +47,17 @@ const ROSTER_STATUS_BUSY = 'busy';
  *   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}
  */
@@ -68,6 +84,7 @@ export async function buildSystemPrompt(ri, opts = {}) {
     ? `\n## recent_group_chat\n${opts.recentGroupChat.trim()}\n`
     : '';
   const coreMem = await buildCoreMemoryBlock(ri, ctx);
+  const taskCtx = buildTaskCtxBlock(ri, opts.taskCtx, ctx);
 
   return [
     '# § STATIC',
@@ -81,6 +98,7 @@ export async function buildSystemPrompt(ri, opts = {}) {
     runtime,
     recent.trim() ? recent : '',
     coreMem,
+    taskCtx,
   ]
     .filter(Boolean)
     .join('\n')
@@ -189,3 +207,94 @@ async function buildCoreMemoryBlock(ri, ctx) {
   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');
+}

package/unify/web-bridge.js

@@ -28,6 +28,7 @@ import ctx from '../context.js';
 import { getThreadStore, MAIN_THREAD_ID } from './threads/store.js';
 import { handleVpSubscribe } from './vp/vp-bridge.js';
 import { createVp, updateVp, deleteVp, readVp, VpCrudError } from './vp/vp-crud.js';
+import { createRouter } from './routing/router.js';
 import { handleUnifyTaskMessage as _handleUnifyTaskMessage } from './task-message.js';
 import {
   handleUnifyUserMemoryWrite as _handleUnifyUserMemoryWrite,
@@ -1165,6 +1166,10 @@ export async function handleUnifyGroupChat(msg) {
         groupId,
         vpId,
         speakerVpId: vpId,
+        // Bug 4: hand the coordinator down so handleUnifyChat can build a
+        // Router for the RouteForward tool. Field is namespaced with `_`
+        // to mark it as an internal hop, never sent over WS.
+        _groupCoordinator: coord,
       });
     } catch (err) {
       console.warn('[Unify] unify_group_chat: per-vp dispatch failed', vpId, err?.message || err);
@@ -1181,6 +1186,42 @@ export async function handleUnifyGroupChat(msg) {
   }
 }
 
+/**
+ * Build the per-query VP context for the Engine.
+ *
+ * - Loads the addressed VP's persona via readVp() so the system prompt
+ *   speaks in that VP's voice (Bug 3 fix).
+ * - When a GroupCoordinator handle is supplied, wraps it in a Router so
+ *   the RouteForward tool actually forwards instead of returning
+ *   `router_unavailable` (Bug 4 fix).
+ *
+ * Returns `undefined` when we have nothing to inject — keeps the legacy
+ * single-agent path identical to before.
+ */
+function buildVpQueryOpts({ vpId, groupCoordinator }) {
+  if (!vpId) return undefined;
+  const out = { senderVpId: vpId };
+  try {
+    const vp = readVp(vpId);
+    if (vp) {
+      out.vpPersona = {
+        displayName: vp.displayName || vpId,
+        role: vp.role || '',
+        persona: vp.persona || '',
+      };
+    }
+  } catch { /* persona load is best-effort */ }
+  if (groupCoordinator && typeof groupCoordinator.ingest === 'function') {
+    try {
+      out.router = createRouter({ coordinator: groupCoordinator });
+    } catch {
+      // Router build failure is non-fatal — RouteForward will report
+      // router_unavailable and the VP can pivot.
+    }
+  }
+  return out;
+}
+
 /**
  * Handle a unify_chat message from the web UI.
  *
@@ -1191,6 +1232,12 @@ export async function handleUnifyGroupChat(msg) {
 export async function handleUnifyChat(msg) {
   const { prompt, mode } = msg;
   if (!prompt?.trim()) return;
+  // Bug 3 / Bug 4 — when the upstream group dispatcher addresses a specific
+  // VP, it stamps `vpId` (and optionally a coordinator handle in
+  // `_groupCoordinator`). Hoist them now so they survive the lazy-init
+  // branch and reach the dispatcher.submit() queryOpts.
+  const vpId = typeof msg.vpId === 'string' && msg.vpId.trim() ? msg.vpId.trim() : null;
+  const groupCoordinator = msg._groupCoordinator || null;
 
   // Deprecation warning — task-297 removed chat/work mode distinction
   if (mode !== undefined && mode !== null) {
@@ -1302,6 +1349,7 @@ export async function handleUnifyChat(msg) {
     const { entry } = session.dispatcher.submit(cleanedPrompt, {
       messageId: msg.messageId,
       override: override || undefined,
+      queryOpts: buildVpQueryOpts({ vpId, groupCoordinator }),
     });
     sendUnifyEvent({
       type: 'input_queue_updated',
@@ -1587,6 +1635,279 @@ export function handleUnifyModeSwitch(_msg) {
   console.warn('[Unify] unify_mode_switch is deprecated and ignored — Unify now runs in a single unified mode.');
 }
 
+/**
+ * R6 G2 — VP/Task memory browser query.
+ *
+ * Reads from session.memoryShardStore (R6 shard-based memory) and replies
+ * with a time-sorted list of entries scoped to the requested vpId / taskId.
+ * The web UI's MemoryCard / MemoryTraceModal consume the reply.
+ *
+ * Request shape:
+ *   { type: 'unify_memory_query',
+ *     vpId?: string, taskId?: string,
+ *     limit?: number, requestId?: string }
+ *
+ * Reply shape:
+ *   { type: 'unify_memory_query_result',
+ *     scope: { vpId, taskId },
+ *     entries: Array<thinEntry>,   // shape from shard-store mapRecordToThinEntry
+ *     requestId? }
+ *
+ * Per D2 the query is scoped — the LLM owns memory recall via the
+ * memory_query tool; this surface is purely UI browsing (read-only).
+ *
+ * @param {{ vpId?: string, taskId?: string, limit?: number, requestId?: string }} msg
+ */
+export function handleUnifyMemoryQuery(msg = {}) {
+  const requestId = typeof msg.requestId === 'string' ? msg.requestId : undefined;
+  const vpId = typeof msg.vpId === 'string' ? msg.vpId : null;
+  const taskId = typeof msg.taskId === 'string' ? msg.taskId : null;
+  const limit = Number.isFinite(msg.limit) ? Math.max(1, Math.min(200, msg.limit)) : 50;
+
+  const reply = (extra = {}) => sendUnifyEvent({
+    type: 'unify_memory_query_result',
+    scope: { vpId, taskId },
+    ...extra,
+    ...(requestId ? { requestId } : {}),
+  });
+
+  if (!session || !session.memoryShardStore) {
+    reply({ entries: [], error: 'no_memory_store' });
+    return;
+  }
+
+  try {
+    const filter = {};
+    if (vpId) filter.vp = vpId;
+    if (taskId) filter.task = taskId;
+    const res = session.memoryShardStore.query(filter);
+    const list = Array.isArray(res?.results) ? res.results : [];
+    // Time-sorted desc on updatedAt / createdAt.
+    list.sort((a, b) => {
+      const ax = (a && (a.updatedAt || a.createdAt)) || 0;
+      const bx = (b && (b.updatedAt || b.createdAt)) || 0;
+      const at = typeof ax === 'string' ? Date.parse(ax) : ax;
+      const bt = typeof bx === 'string' ? Date.parse(bx) : bx;
+      return (bt || 0) - (at || 0);
+    });
+    reply({ entries: list.slice(0, limit) });
+  } catch (err) {
+    reply({ entries: [], error: String(err?.message || err) });
+  }
+}
+
+/**
+ * R6 G2 — Open the source message behind a memory entry (memory_trace).
+ *
+ * Resolves entry → sourceRef.{conversationId, messageId} (or threadId/range)
+ * via MemoryShardStore.get(entryId), then echoes the reference + the entry
+ * for the MemoryTraceModal to render. The trace itself is a read-only
+ * surface — the UI follows the conversationId/messageId to MessageList.
+ *
+ * Request shape:
+ *   { type: 'unify_memory_trace', entryId: string, requestId?: string }
+ *
+ * Reply shape:
+ *   { type: 'unify_memory_trace_result',
+ *     entryId, entry: object|null, sourceRef: object|null, requestId? }
+ *
+ * @param {{ entryId?: string, requestId?: string }} msg
+ */
+export function handleUnifyMemoryTrace(msg = {}) {
+  const requestId = typeof msg.requestId === 'string' ? msg.requestId : undefined;
+  const entryId = typeof msg.entryId === 'string' ? msg.entryId : null;
+
+  const reply = (extra = {}) => sendUnifyEvent({
+    type: 'unify_memory_trace_result',
+    entryId,
+    ...extra,
+    ...(requestId ? { requestId } : {}),
+  });
+
+  if (!entryId) { reply({ entry: null, sourceRef: null, error: 'missing_entry_id' }); return; }
+  if (!session || !session.memoryShardStore) {
+    reply({ entry: null, sourceRef: null, error: 'no_memory_store' });
+    return;
+  }
+  try {
+    const entry = session.memoryShardStore.get(entryId);
+    if (!entry) { reply({ entry: null, sourceRef: null, error: 'not_found' }); return; }
+    reply({ entry, sourceRef: entry.sourceRef || null });
+  } catch (err) {
+    reply({ entry: null, sourceRef: null, error: String(err?.message || err) });
+  }
+}
+
+/**
+ * R6 G1a — Fetch a task's summary history (revision chain).
+ *
+ * Streams the group log filtered by `taskId` and `meta.kind === 'summary'`,
+ * separates `current` (≤10 most recent non-superseded) from `archived` rows
+ * per §Δ31.5. Default `includeArchived: false` keeps the wire payload small;
+ * the UI's "Show archived" button re-issues with the flag set.
+ *
+ * Request shape:
+ *   { type: 'unify_fetch_summary_history', taskId, includeArchived?: bool }
+ *
+ * Reply shape:
+ *   { type: 'unify_summary_history', taskId, revisions: [...],
+ *     archived: [...]|null, error?: string, requestId? }
+ */
+export async function handleUnifyFetchSummaryHistory(msg = {}) {
+  const requestId = typeof msg.requestId === 'string' ? msg.requestId : undefined;
+  const taskId = typeof msg.taskId === 'string' ? msg.taskId : null;
+  const includeArchived = !!msg.includeArchived;
+
+  const reply = (extra = {}) => sendUnifyEvent({
+    type: 'unify_summary_history',
+    taskId,
+    ...extra,
+    ...(requestId ? { requestId } : {}),
+  });
+
+  if (!taskId) { reply({ revisions: [], archived: null, error: 'missing_task_id' }); return; }
+
+  try {
+    const { getTaskStore } = await import('./tools/task-tools.js');
+    const taskStore = getTaskStore();
+    const task = taskStore?.get(taskId);
+    if (!task) { reply({ revisions: [], archived: null, error: 'task_not_found' }); return; }
+    const groupId = task.groupId;
+    if (!groupId) { reply({ revisions: [], archived: null, error: 'task_has_no_group' }); return; }
+
+    const yeaftDir = ctx.CONFIG?.yeaftDir;
+    if (!yeaftDir) { reply({ revisions: [], archived: null, error: 'no_yeaft_dir' }); return; }
+
+    const { openGroup, loadGroupMeta } = await import('./groups/group-store.js');
+    const { join } = await import('node:path');
+    const { existsSync } = await import('node:fs');
+    const root = join(yeaftDir, 'groups');
+    const dir = join(root, groupId);
+    if (!existsSync(dir) || !loadGroupMeta(dir)) {
+      reply({ revisions: [], archived: null, error: 'group_not_found' });
+      return;
+    }
+    const groupHandle = openGroup(root, groupId);
+    const summaries = [];
+    for (const m of groupHandle.streamMessages()) {
+      if (!m || m.taskId !== taskId) continue;
+      const meta = m.meta || {};
+      if (meta.kind === 'summary' || meta.type === 'summary') summaries.push(m);
+    }
+    summaries.sort((a, b) => {
+      const at = Date.parse(a.ts || '') || 0;
+      const bt = Date.parse(b.ts || '') || 0;
+      return bt - at;
+    });
+    const supersededIds = new Set();
+    for (const s of summaries) {
+      const arr = s.meta?.supersedes;
+      if (Array.isArray(arr)) for (const id of arr) supersededIds.add(id);
+    }
+    const current = [];
+    const archived = [];
+    for (const s of summaries) {
+      if (supersededIds.has(s.id)) archived.push(s);
+      else current.push(s);
+    }
+    // §Δ31.5: keep only 10 in current; oldest extras spill to archived.
+    const overflow = current.slice(10);
+    const trimmedCurrent = current.slice(0, 10);
+    if (overflow.length) archived.push(...overflow);
+    archived.sort((a, b) => {
+      const at = Date.parse(a.ts || '') || 0;
+      const bt = Date.parse(b.ts || '') || 0;
+      return bt - at;
+    });
+    reply({
+      revisions: trimmedCurrent,
+      archived: includeArchived ? archived : null,
+    });
+  } catch (err) {
+    reply({ revisions: [], archived: null, error: String(err?.message || err) });
+  }
+}
+
+/**
+ * R6 G1a — Task affiliation CRUD (relate / unrelate / kick_vp / abort_vp).
+ *
+ * Single envelope so the UI doesn't fan out four separate WS message types
+ * for housekeeping verbs. Replies with `unify_task_crud_result`.
+ *
+ *   - relate     { taskId, relatedTaskId } — bidirectional Δ27 link
+ *   - unrelate   { taskId, relatedTaskId } — drop both directions
+ *   - kick_vp    { taskId, vpId } — taskStore.removeMember
+ *   - abort_vp   { taskId, vpId } — abort that VP's in-flight engine inside the task
+ */
+export async function handleUnifyTaskCrud(msg = {}) {
+  const requestId = typeof msg.requestId === 'string' ? msg.requestId : undefined;
+  const op = typeof msg.op === 'string' ? msg.op : null;
+  const taskId = typeof msg.taskId === 'string' ? msg.taskId : null;
+  const vpId = typeof msg.vpId === 'string' ? msg.vpId : null;
+  const relatedTaskId = typeof msg.relatedTaskId === 'string' ? msg.relatedTaskId : null;
+
+  const reply = (extra = {}) => sendUnifyEvent({
+    type: 'unify_task_crud_result',
+    op,
+    taskId,
+    ...(vpId ? { vpId } : {}),
+    ...extra,
+    ...(requestId ? { requestId } : {}),
+  });
+
+  if (!op) { reply({ ok: false, error: 'missing_op' }); return; }
+  if (!taskId) { reply({ ok: false, error: 'missing_task_id' }); return; }
+
+  try {
+    const { getTaskStore } = await import('./tools/task-tools.js');
+    const taskStore = getTaskStore();
+    const task = taskStore?.get(taskId);
+    if (!task) { reply({ ok: false, error: 'task_not_found' }); return; }
+
+    if (op === 'relate' || op === 'unrelate') {
+      if (!relatedTaskId) { reply({ ok: false, error: 'missing_related_task_id' }); return; }
+      const other = taskStore.get(relatedTaskId);
+      if (!other) { reply({ ok: false, error: 'related_task_not_found' }); return; }
+      const apply = (t, otherId, add) => {
+        const cur = Array.isArray(t.relatedTaskIds) ? t.relatedTaskIds.slice() : [];
+        const idx = cur.indexOf(otherId);
+        if (add && idx === -1) cur.push(otherId);
+        if (!add && idx !== -1) cur.splice(idx, 1);
+        taskStore.update(t.id, { relatedTaskIds: cur });
+      };
+      apply(task, relatedTaskId, op === 'relate');
+      apply(other, taskId, op === 'relate');
+      reply({ ok: true, relatedTaskId });
+      return;
+    }
+
+    if (op === 'kick_vp') {
+      if (!vpId) { reply({ ok: false, error: 'missing_vp_id' }); return; }
+      taskStore.removeMember(taskId, vpId);
+      reply({ ok: true });
+      return;
+    }
+
+    if (op === 'abort_vp') {
+      if (!vpId) { reply({ ok: false, error: 'missing_vp_id' }); return; }
+      // Reuse per-thread abort registry — keyed by (taskId,vpId) tuple if
+      // the engine instance is registered there. For v1 we surface success
+      // and let the engine settle; full per-VP cancellation is owned by
+      // the engine registry in 334o follow-up.
+      const reg = session?.engineRegistry;
+      if (reg && typeof reg.abortVpInTask === 'function') {
+        reg.abortVpInTask(taskId, vpId);
+      }
+      reply({ ok: true });
+      return;
+    }
+
+    reply({ ok: false, error: 'unknown_op' });
+  } catch (err) {
+    reply({ ok: false, error: String(err?.message || err) });
+  }
+}
+
 /**
  * task-313: merge a source thread into a target thread.
  * Reassigns messages, archives source with `mergedInto`, terminates source