@yeaft/webchat-agent 0.1.587 → 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.587",
+  "version": "0.1.588",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

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

@@ -1635,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