@yeaft/webchat-agent 0.1.615 → 0.1.617

package/unify/tools/index.js

@@ -48,25 +48,25 @@ import listAgents from './list-agents.js';
 // --- P1 Routing tools (task-334d) ---
 import routeForward from './route-forward.js';
 
-// --- P1 Task tools ---
+// --- P1 Feature tools ---
 import {
-  taskCreate,
-  taskUpdate,
-  taskList,
-  taskGet,
-  taskProgress,
-  taskMemory,
-  followupTask,
+  featureCreate,
+  featureUpdate,
+  featureList,
+  featureGet,
+  featureProgress,
+  featureMemory,
+  followupFeature,
   updatePlan,
-} from './task-tools.js';
+  featureSummaryPost,
+} from './feature-tools.js';
 
 // --- P1 Thread tools (task-299 Phase 1) ---
 import {
   spawnThread,
   switchThread,
   listThreads,
-  attachThreadToTask,
-  spawnTask,
+  attachThreadToFeature,
   readThreadSummary,
   readThreadRecent,
 } from './thread-tools.js';
@@ -126,22 +126,22 @@ export const allTools = [
   // P1 Routing (task-334d)
   routeForward,
 
-  // P1 Task
-  taskCreate,
-  taskUpdate,
-  taskList,
-  taskGet,
-  taskProgress,
-  taskMemory,
-  followupTask,
+  // P1 Feature
+  featureCreate,
+  featureUpdate,
+  featureList,
+  featureGet,
+  featureProgress,
+  featureMemory,
+  followupFeature,
   updatePlan,
+  featureSummaryPost,
 
   // P1 Thread (task-299 Phase 1)
   spawnThread,
   switchThread,
   listThreads,
-  attachThreadToTask,
-  spawnTask,
+  attachThreadToFeature,
   readThreadSummary,
   readThreadRecent,
 

package/unify/tools/thread-tools.js

@@ -2,14 +2,13 @@
  * thread-tools.js — Thread-spawning tools for Unify Engine (Phase 1).
  *
  * Phase 1 scope (task-299 rework):
- *   - SpawnThread         — create a new thread
- *   - SwitchThread        — set the engine's currentThreadId marker
- *   - ListThreads         — list threads + current marker + cached stats
- *   - AttachThreadToTask  — bind a thread to an existing task
- *   - SpawnTask           — create a task or subtask (parent_task_id optional)
- *   - ReadThreadSummary   — cross-reference: summary of a thread (id/name/
- *                           status/messageCount/lastMessageAt/task)
- *   - ReadThreadRecent    — cross-reference: last N messages of a thread
+ *   - SpawnThread             — create a new thread
+ *   - SwitchThread            — set the engine's currentThreadId marker
+ *   - ListThreads             — list threads + current marker + cached stats
+ *   - AttachThreadToFeature   — bind a thread to an existing feature
+ *   - ReadThreadSummary       — cross-reference: summary of a thread (id/name/
+ *                               status/messageCount/lastMessageAt/feature)
+ *   - ReadThreadRecent        — cross-reference: last N messages of a thread
  *
  * Phase 1 uses the in-memory ThreadStore (agent/unify/threads/store.js)
  * and the existing ConversationStore for messages. When task-298 merges,
@@ -18,9 +17,8 @@
  */
 
 import { defineTool } from './types.js';
-import { randomUUID } from 'crypto';
 import { getThreadStore, MAIN_THREAD_ID } from '../threads/store.js';
-import { getTaskStore } from './task-tools.js';
+import { getFeatureStore } from './feature-tools.js';
 
 // ─── SpawnThread ─────────────────────────────────────────
 
@@ -134,7 +132,7 @@ fields — does not scan messages.`,
       archived: t.archived,
       unread: t.unread || 0,
       preview: t.preview || '',
-      attachedTaskId: store.attachedTask(t.id),
+      attachedFeatureId: store.attachedFeature(t.id),
     }));
     return JSON.stringify(
       {
@@ -148,44 +146,44 @@ fields — does not scan messages.`,
   },
 });
 
-// ─── AttachThreadToTask ──────────────────────────────────
+// ─── AttachThreadToFeature ──────────────────────────────────
 
-export const attachThreadToTask = defineTool({
-  name: 'AttachThreadToTask',
-  description: `Link an existing thread to an existing task.
+export const attachThreadToFeature = defineTool({
+  name: 'AttachThreadToFeature',
+  description: `Link an existing thread to an existing feature.
 
-Use to record which thread is responsible for which task. The thread and
-the task must both already exist. Overwrites any previous attachment for
+Use to record which thread is responsible for which feature. The thread and
+the feature must both already exist. Overwrites any previous attachment for
 the same thread.`,
   parameters: {
     type: 'object',
     properties: {
       thread_id: { type: 'string' },
-      task_id: { type: 'string' },
+      feature_id: { type: 'string' },
     },
-    required: ['thread_id', 'task_id'],
+    required: ['thread_id', 'feature_id'],
   },
   isConcurrencySafe: () => false,
   isReadOnly: () => false,
   async execute(input) {
-    const { thread_id, task_id } = input || {};
+    const { thread_id, feature_id } = input || {};
     if (!thread_id) return JSON.stringify({ error: 'thread_id is required' });
-    if (!task_id) return JSON.stringify({ error: 'task_id is required' });
+    if (!feature_id) return JSON.stringify({ error: 'feature_id is required' });
 
-    const taskStore = getTaskStore();
-    if (taskStore) {
-      const task = taskStore.get(task_id);
-      if (!task) return JSON.stringify({ error: `Task not found: ${task_id}` });
+    const featureStore = getFeatureStore();
+    if (featureStore) {
+      const feature = featureStore.get(feature_id);
+      if (!feature) return JSON.stringify({ error: `Feature not found: ${feature_id}` });
     }
 
     try {
       const store = getThreadStore();
-      store.attachTask(thread_id, task_id);
+      store.attachFeature(thread_id, feature_id);
       return JSON.stringify({
         success: true,
         threadId: thread_id,
-        taskId: task_id,
-        message: `Thread ${thread_id} attached to task ${task_id}`,
+        featureId: feature_id,
+        message: `Thread ${thread_id} attached to feature ${feature_id}`,
       });
     } catch (err) {
       return JSON.stringify({ error: err.message || String(err) });
@@ -193,91 +191,14 @@ the same thread.`,
   },
 });
 
-// ─── SpawnTask (deprecated alias — task-333b) ──────────────
-//
-// task-333b folded SpawnTask into TaskCreate (see task-tools.js). Kept
-// registered for one release as a deprecated alias per PM constraint:
-// LLM calls still resolve, but a one-time console.warn nudges migration.
-// Prefer TaskCreate with `parent_task_id` for all new call sites.
-
-const _spawnTaskWarned = { v: false };
-function warnSpawnTaskDeprecated() {
-  if (_spawnTaskWarned.v) return;
-  _spawnTaskWarned.v = true;
-  // eslint-disable-next-line no-console
-  console.warn('[deprecated] SpawnTask → TaskCreate. Pass parent_task_id to TaskCreate for subtasks.');
-}
-
-export const spawnTask = defineTool({
-  name: 'SpawnTask',
-  description: `DEPRECATED — use TaskCreate with parent_id instead. Retained as a thin alias for backwards compatibility; delegates to the same task store. When parent_task_id is omitted this behaves like TaskCreate; when provided it creates a subtask under that parent (parent must exist). Removal target: v0.2.0.`,
-  parameters: {
-    type: 'object',
-    properties: {
-      title: { type: 'string' },
-      description: { type: 'string' },
-      priority: {
-        type: 'string',
-        enum: ['low', 'medium', 'high', 'critical'],
-      },
-      parent_task_id: {
-        type: 'string',
-        description: 'Optional parent task id; when present, a subtask is created',
-      },
-    },
-    required: ['title'],
-  },
-  isConcurrencySafe: () => false,
-  isReadOnly: () => false,
-  async execute(input) {
-    warnSpawnTaskDeprecated();
-    const store = getTaskStore();
-    if (!store) {
-      return JSON.stringify({ error: 'Task store not initialized. Session may still be loading.' });
-    }
-    const { title, description = '', priority = 'medium', parent_task_id } = input || {};
-    if (!title) return JSON.stringify({ error: 'title is required' });
-
-    if (parent_task_id) {
-      const parent = store.get(parent_task_id);
-      if (!parent) return JSON.stringify({ error: `Parent task not found: ${parent_task_id}` });
-    }
-
-    const id = `task-${randomUUID().slice(0, 8)}`;
-    const now = Date.now();
-    store.create({
-      id,
-      title,
-      description,
-      priority,
-      status: 'pending',
-      parentId: parent_task_id || null,
-      parentTaskId: parent_task_id || null, // design §5 canonical field; kept in sync with parentId
-      createdAt: now,
-      updatedAt: now,
-    });
-    return JSON.stringify({
-      success: true,
-      task: {
-        id,
-        title,
-        priority,
-        status: 'pending',
-        parentTaskId: parent_task_id || null,
-      },
-      message: parent_task_id
-        ? `Subtask spawned: ${title} (${id}) under ${parent_task_id}`
-        : `Task spawned: ${title} (${id})`,
-    });
-  },
-});
+// ─── SpawnTask removed (task-333b) — use FeatureCreate with parent_feature_id
 
 // ─── ReadThreadSummary (cross-reference, design §6 Q5) ──
 
 export const readThreadSummary = defineTool({
   name: 'ReadThreadSummary',
   description: `Return a one-shot summary of a thread: id, name, goal, status,
-messageCount, lastMessageAt, parentThreadId, attachedTaskId.
+messageCount, lastMessageAt, parentThreadId, attachedFeatureId.
 
 Use this to cross-reference work on another thread without switching.`,
   parameters: {
@@ -305,7 +226,7 @@ Use this to cross-reference work on another thread without switching.`,
         messageCount: t.messageCount,
         lastMessageAt: t.lastMessageAt,
         parentThreadId: t.parentThreadId,
-        attachedTaskId: store.attachedTask(t.id),
+        attachedFeatureId: store.attachedFeature(t.id),
         createdAt: t.createdAt,
         updatedAt: t.updatedAt,
       },

package/unify/web-bridge.js

@@ -30,7 +30,7 @@ import { handleVpSubscribe } from './vp/vp-bridge.js';
 import { createVp, updateVp, deleteVp, readVp, VpCrudError } from './vp/vp-crud.js';
 import { scanVpLibrary } from './vp/vp-store.js';
 import { createRouter } from './routing/router.js';
-import { handleUnifyTaskMessage as _handleUnifyTaskMessage } from './task-message.js';
+import { handleUnifyFeatureMessage as _handleUnifyFeatureMessage } from './feature-message.js';
 import {
   handleUnifyUserMemoryWrite as _handleUnifyUserMemoryWrite,
   handleUnifyUserMemoryRemove as _handleUnifyUserMemoryRemove,
@@ -278,8 +278,8 @@ export function handleUnifyVpDelete(msg) {
  *
  * @param {any} msg
  */
-export function handleUnifyTaskMessage(msg) {
-  _handleUnifyTaskMessage(msg, sendUnifyEvent);
+export function handleUnifyFeatureMessage(msg) {
+  _handleUnifyFeatureMessage(msg, sendUnifyEvent);
 }
 
 /**
@@ -639,11 +639,11 @@ function sendThreadListUpdate() {
       preview: t.preview || '',
       createdAt: t.createdAt,
       updatedAt: t.updatedAt,
-      // task-315: attached taskId (if any) so the UI can aggregate all
-      // messages belonging to a task across multiple threads. null when
-      // the thread has no attached task.
-      taskId: (typeof store.attachedTask === 'function')
-        ? (store.attachedTask(t.id) || null)
+      // task-315: attached featureId (if any) so the UI can aggregate all
+      // messages belonging to a feature across multiple threads. null when
+      // the thread has no attached feature.
+      featureId: (typeof store.attachedFeature === 'function')
+        ? (store.attachedFeature(t.id) || null)
         : null,
       // `running` — the thread whose id equals the store's currentId is
       // considered the active/running track. The UI uses this for the
@@ -662,7 +662,7 @@ const THREAD_MUTATING_TOOLS = new Set([
   'SpawnThread',
   'SwitchThread',
   'ArchiveThread',
-  'AttachThreadToTask',
+  'AttachThreadToFeature',
 ]);
 
 /**
@@ -751,8 +751,8 @@ function sendThreadListSnapshot() {
       preview: t.preview || '',
       createdAt: t.createdAt,
       updatedAt: t.updatedAt,
-      taskId: (typeof store.attachedTask === 'function')
-        ? (store.attachedTask(t.id) || null)
+      featureId: (typeof store.attachedFeature === 'function')
+        ? (store.attachedFeature(t.id) || null)
         : null,
       running: t.id === store.currentId,
       state: inflight.has(t.id) ? 'running' : 'idle',
@@ -1809,37 +1809,37 @@ export function handleUnifyModeSwitch(_msg) {
 }
 
 /**
- * R6 G2 — VP/Task memory browser query.
+ * R6 G2 — VP/Feature 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.
+ * with a time-sorted list of entries scoped to the requested vpId / featureId.
  * The web UI's MemoryCard / MemoryTraceModal consume the reply.
  *
  * Request shape:
  *   { type: 'unify_memory_query',
- *     vpId?: string, taskId?: string,
+ *     vpId?: string, featureId?: string,
  *     limit?: number, requestId?: string }
  *
  * Reply shape:
  *   { type: 'unify_memory_query_result',
- *     scope: { vpId, taskId },
+ *     scope: { vpId, featureId },
  *     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
+ * @param {{ vpId?: string, featureId?: 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 featureId = typeof msg.featureId === 'string' ? msg.featureId : 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 },
+    scope: { vpId, featureId },
     ...extra,
     ...(requestId ? { requestId } : {}),
   });
@@ -1852,7 +1852,7 @@ export function handleUnifyMemoryQuery(msg = {}) {
   try {
     const filter = {};
     if (vpId) filter.vp = vpId;
-    if (taskId) filter.task = taskId;
+    if (featureId) filter.feature = featureId;
     const res = session.memoryShardStore.query(filter);
     const list = Array.isArray(res?.results) ? res.results : [];
     // Time-sorted desc on updatedAt / createdAt.
@@ -1912,41 +1912,41 @@ export function handleUnifyMemoryTrace(msg = {}) {
 }
 
 /**
- * R6 G1a — Fetch a task's summary history (revision chain).
+ * R6 G1a — Fetch a feature's summary history (revision chain).
  *
- * Streams the group log filtered by `taskId` and `meta.kind === 'summary'`,
+ * Streams the group log filtered by `featureId` 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 }
+ *   { type: 'unify_fetch_summary_history', featureId, includeArchived?: bool }
  *
  * Reply shape:
- *   { type: 'unify_summary_history', taskId, revisions: [...],
+ *   { type: 'unify_summary_history', featureId, 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 featureId = typeof msg.featureId === 'string' ? msg.featureId : null;
   const includeArchived = !!msg.includeArchived;
 
   const reply = (extra = {}) => sendUnifyEvent({
     type: 'unify_summary_history',
-    taskId,
+    featureId,
     ...extra,
     ...(requestId ? { requestId } : {}),
   });
 
-  if (!taskId) { reply({ revisions: [], archived: null, error: 'missing_task_id' }); return; }
+  if (!featureId) { reply({ revisions: [], archived: null, error: 'missing_feature_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 { getFeatureStore } = await import('./tools/feature-tools.js');
+    const featureStore = getFeatureStore();
+    const feature = featureStore?.get(featureId);
+    if (!feature) { reply({ revisions: [], archived: null, error: 'feature_not_found' }); return; }
+    const groupId = feature.groupId;
+    if (!groupId) { reply({ revisions: [], archived: null, error: 'feature_has_no_group' }); return; }
 
     const yeaftDir = ctx.CONFIG?.yeaftDir;
     if (!yeaftDir) { reply({ revisions: [], archived: null, error: 'no_yeaft_dir' }); return; }
@@ -1963,7 +1963,7 @@ export async function handleUnifyFetchSummaryHistory(msg = {}) {
     const groupHandle = openGroup(root, groupId);
     const summaries = [];
     for (const m of groupHandle.streamMessages()) {
-      if (!m || m.taskId !== taskId) continue;
+      if (!m || m.featureId !== featureId) continue;
       const meta = m.meta || {};
       if (meta.kind === 'summary' || meta.type === 'summary') summaries.push(m);
     }
@@ -2002,74 +2002,74 @@ export async function handleUnifyFetchSummaryHistory(msg = {}) {
 }
 
 /**
- * R6 G1a — Task affiliation CRUD (relate / unrelate / kick_vp / abort_vp).
+ * R6 G1a — Feature 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`.
+ * for housekeeping verbs. Replies with `unify_feature_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
+ *   - relate     { featureId, relatedFeatureId } — bidirectional Δ27 link
+ *   - unrelate   { featureId, relatedFeatureId } — drop both directions
+ *   - kick_vp    { featureId, vpId } — featureStore.removeMember
+ *   - abort_vp   { featureId, vpId } — abort that VP's in-flight engine inside the feature
  */
-export async function handleUnifyTaskCrud(msg = {}) {
+export async function handleUnifyFeatureCrud(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 featureId = typeof msg.featureId === 'string' ? msg.featureId : null;
   const vpId = typeof msg.vpId === 'string' ? msg.vpId : null;
-  const relatedTaskId = typeof msg.relatedTaskId === 'string' ? msg.relatedTaskId : null;
+  const relatedFeatureId = typeof msg.relatedFeatureId === 'string' ? msg.relatedFeatureId : null;
 
   const reply = (extra = {}) => sendUnifyEvent({
-    type: 'unify_task_crud_result',
+    type: 'unify_feature_crud_result',
     op,
-    taskId,
+    featureId,
     ...(vpId ? { vpId } : {}),
     ...extra,
     ...(requestId ? { requestId } : {}),
   });
 
   if (!op) { reply({ ok: false, error: 'missing_op' }); return; }
-  if (!taskId) { reply({ ok: false, error: 'missing_task_id' }); return; }
+  if (!featureId) { reply({ ok: false, error: 'missing_feature_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; }
+    const { getFeatureStore } = await import('./tools/feature-tools.js');
+    const featureStore = getFeatureStore();
+    const feature = featureStore?.get(featureId);
+    if (!feature) { reply({ ok: false, error: 'feature_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; }
+      if (!relatedFeatureId) { reply({ ok: false, error: 'missing_related_feature_id' }); return; }
+      const other = featureStore.get(relatedFeatureId);
+      if (!other) { reply({ ok: false, error: 'related_feature_not_found' }); return; }
       const apply = (t, otherId, add) => {
-        const cur = Array.isArray(t.relatedTaskIds) ? t.relatedTaskIds.slice() : [];
+        const cur = Array.isArray(t.relatedFeatureIds) ? t.relatedFeatureIds.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 });
+        featureStore.update(t.id, { relatedFeatureIds: cur });
       };
-      apply(task, relatedTaskId, op === 'relate');
-      apply(other, taskId, op === 'relate');
-      reply({ ok: true, relatedTaskId });
+      apply(feature, relatedFeatureId, op === 'relate');
+      apply(other, featureId, op === 'relate');
+      reply({ ok: true, relatedFeatureId });
       return;
     }
 
     if (op === 'kick_vp') {
       if (!vpId) { reply({ ok: false, error: 'missing_vp_id' }); return; }
-      taskStore.removeMember(taskId, vpId);
+      featureStore.removeMember(featureId, 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
+      // Reuse per-thread abort registry — keyed by (featureId,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);
+      if (reg && typeof reg.abortVpInFeature === 'function') {
+        reg.abortVpInFeature(featureId, vpId);
       }
       reply({ ok: true });
       return;