@yeaft/webchat-agent 0.1.615 → 0.1.617

package/unify/router/intent-classifier.js

@@ -2,7 +2,7 @@
  * intent-classifier.js — task-309 (Phase 2 Router).
  *
  * Routes an incoming user message to one of four intents relative to the
- * current set of live threads + pending tasks:
+ * current set of live threads + pending features:
  *
  *   - 'continue'  — append to currentThreadId (default / most common)
  *   - 'interrupt' — steal focus on another LIVE thread (e.g. user replies
@@ -14,7 +14,7 @@
  *
  *   1. **Explicit signal parse** (no LLM):
  *      - Prefix `@thread-<id>` → switch/interrupt that thread (direct).
- *      - Prefix `@task-<nnn>` → switch to the thread attached to that task,
+ *      - Prefix `@feat-<nnn>` → switch to the thread attached to that task,
  *        if any; otherwise fall through to LLM.
  *   2. **User override lookup**: if UI previously called `.override(msgId,…)`
  *      for this message, return that decision verbatim.
@@ -53,7 +53,7 @@
  * @property {string} [goal]
  * @property {string} [status]
  *
- * @typedef {Object} PendingTask
+ * @typedef {Object} PendingFeature
  * @property {string} id
  * @property {string} [title]
  * @property {string} [threadId]  — attached thread, if any
@@ -63,7 +63,7 @@
  * @property {string} userMessage
  * @property {string} currentThreadId
  * @property {Array<ThreadSummary>} [allThreads]
- * @property {Array<PendingTask>} [pendingTasks]
+ * @property {Array<PendingFeature>} [pendingFeatures]
  * @property {string} [messageId] — if provided, any stored override for this
  *   id is consulted before the LLM path
  */
@@ -78,10 +78,10 @@ const VALID_ACTIONS = ['continue', 'interrupt', 'fork', 'switch'];
 const THREAD_PREFIX_RE = /^@(thread-[A-Za-z0-9_-]+)\b\s*/;
 
 /**
- * Match a leading `@task-NNN` marker. Captures the task id WITHOUT the `@`.
- * Example matches: "@task-309 ...", "@task-abc ..."
+ * Match a leading `@feat-NNN` marker. Captures the feature id WITHOUT the `@`.
+ * Example matches: "@feat-309 ...", "@feat-abc ..."
  */
-const TASK_PREFIX_RE = /^@(task-[A-Za-z0-9_-]+)\b\s*/;
+const FEATURE_PREFIX_RE = /^@(feat-[A-Za-z0-9_-]+)\b\s*/;
 
 export class IntentClassifier {
   /** @type {object} */            #adapter;
@@ -161,7 +161,7 @@ export class IntentClassifier {
       userMessage,
       currentThreadId,
       allThreads = [],
-      pendingTasks = [],
+      pendingFeatures = [],
       messageId,
     } = input || {};
 
@@ -181,14 +181,14 @@ export class IntentClassifier {
 
     // 2. Explicit signals (no LLM call).
     const explicit = this.#parseExplicit(userMessage, {
-      currentThreadId, allThreads, pendingTasks,
+      currentThreadId, allThreads, pendingFeatures,
     });
     if (explicit) return explicit;
 
     // 3. LLM classification (best-effort).
     try {
       const decision = await this.#classifyWithLLM({
-        userMessage, currentThreadId, allThreads, pendingTasks,
+        userMessage, currentThreadId, allThreads, pendingFeatures,
       });
       return this.#validateOrFallback(decision, {
         currentThreadId, allThreads, reason: 'llm',
@@ -205,10 +205,10 @@ export class IntentClassifier {
 
   /**
    * @param {string} msg
-   * @param {{ currentThreadId: string, allThreads: Array<ThreadSummary>, pendingTasks: Array<PendingTask> }} ctx
+   * @param {{ currentThreadId: string, allThreads: Array<ThreadSummary>, pendingFeatures: Array<PendingFeature> }} ctx
    * @returns {RouterDecision|null}
    */
-  #parseExplicit(msg, { currentThreadId, allThreads, pendingTasks }) {
+  #parseExplicit(msg, { currentThreadId, allThreads, pendingFeatures }) {
     const trimmed = msg.replace(/^\s+/, '');
 
     // @thread-xxx
@@ -233,21 +233,21 @@ export class IntentClassifier {
       };
     }
 
-    // @task-NNN
-    const mt = trimmed.match(TASK_PREFIX_RE);
+    // @feat-NNN
+    const mt = trimmed.match(FEATURE_PREFIX_RE);
     if (mt) {
-      const taskId = mt[1];
-      const task = pendingTasks.find(t => t && t.id === taskId);
-      if (task && task.threadId) {
-        const action = task.threadId === currentThreadId ? 'continue' : 'switch';
+      const featureId = mt[1];
+      const feature = pendingFeatures.find(t => t && t.id === featureId);
+      if (feature && feature.threadId) {
+        const action = feature.threadId === currentThreadId ? 'continue' : 'switch';
         return {
           action,
-          targetThreadId: task.threadId,
-          reason: `explicit @${taskId} → ${task.threadId}`,
+          targetThreadId: feature.threadId,
+          reason: `explicit @${featureId} → ${feature.threadId}`,
           source: 'explicit',
         };
       }
-      // Task unknown or not attached — fall through to LLM.
+      // Feature unknown or not attached — fall through to LLM.
       return null;
     }
 
@@ -259,7 +259,7 @@ export class IntentClassifier {
   // ──────────────────────────────────────────────────────────────
 
   /** Build the prompt/messages for the router LLM call. */
-  #buildMessages({ userMessage, currentThreadId, allThreads, pendingTasks }) {
+  #buildMessages({ userMessage, currentThreadId, allThreads, pendingFeatures }) {
     const system = [
       'You are a thread-routing classifier for a multi-thread AI chat.',
       'Given the user message and current thread context, pick exactly one action:',
@@ -286,7 +286,7 @@ export class IntentClassifier {
         goal: t.goal || '',
         status: t.status || 'active',
       })),
-      pendingTasks: (pendingTasks || []).map(t => ({
+      pendingFeatures: (pendingFeatures || []).map(t => ({
         id: t.id,
         title: t.title || '',
         threadId: t.threadId || null,
@@ -305,9 +305,9 @@ export class IntentClassifier {
   }
 
   /** @returns {Promise<RouterDecision>} */
-  async #classifyWithLLM({ userMessage, currentThreadId, allThreads, pendingTasks }) {
+  async #classifyWithLLM({ userMessage, currentThreadId, allThreads, pendingFeatures }) {
     const { system, messages } = this.#buildMessages({
-      userMessage, currentThreadId, allThreads, pendingTasks,
+      userMessage, currentThreadId, allThreads, pendingFeatures,
     });
     // Q2: router uses primaryModel (no fast-model split yet).
     const model = this.#config.primaryModel || this.#config.model;

package/unify/session.js

@@ -23,7 +23,7 @@ import { openMemoryShardStore } from './memory/shard-store.js';
 import { SkillManager, createSkillManager } from './skills.js';
 import { MCPManager } from './mcp.js';
 import { createFullRegistry } from './tools/index.js';
-import { initTaskStore } from './tools/task-tools.js';
+import { initFeatureStore } from './tools/feature-tools.js';
 import { initThreadStore } from './threads/store.js';
 import { Engine } from './engine.js';
 import { createThreadEngineRegistry } from './threads/engine-registry.js';
@@ -167,8 +167,8 @@ export async function loadSession(options = {}) {
     console.warn(`[Yeaft] Failed to open R6 memory shard store: ${err?.message || err}`);
   }
 
-  // ─── 5a. Initialize task store ─────────────────────────
-  initTaskStore(yeaftDir, { readOnly: config._readOnly || false });
+  // ─── 5a. Initialize feature store ──────────────────────
+  initFeatureStore(yeaftDir, { readOnly: config._readOnly || false });
 
   // ─── 5b. Initialize thread store (task-299 Phase 1) ────
   //         task-307a: now file-backed under ~/.yeaft/threads/. Passing the

package/unify/threads/store.js

@@ -210,10 +210,10 @@ function generateIndex(threads, currentId, attachments) {
     lines.push('');
     lines.push('## Attachments');
     lines.push('');
-    lines.push('| Thread | Task |');
-    lines.push('|--------|------|');
-    for (const [threadId, taskId] of attachments.entries()) {
-      lines.push(`| ${threadId} | ${taskId} |`);
+    lines.push('| Thread | Feature |');
+    lines.push('|--------|---------|');
+    for (const [threadId, featureId] of attachments.entries()) {
+      lines.push(`| ${threadId} | ${featureId} |`);
     }
   }
   return lines.join('\n') + '\n';
@@ -226,7 +226,7 @@ function generateIndex(threads, currentId, attachments) {
  */
 function serializeAttachments(attachments) {
   return JSON.stringify(
-    [...attachments.entries()].map(([threadId, taskId]) => ({ threadId, taskId })),
+    [...attachments.entries()].map(([threadId, featureId]) => ({ threadId, featureId })),
     null,
     2,
   ) + '\n';
@@ -237,7 +237,7 @@ function parseAttachments(raw) {
     const arr = JSON.parse(raw);
     if (!Array.isArray(arr)) return [];
     return arr.filter(
-      (e) => e && typeof e.threadId === 'string' && typeof e.taskId === 'string',
+      (e) => e && typeof e.threadId === 'string' && typeof e.featureId === 'string',
     );
   } catch {
     return [];
@@ -268,7 +268,7 @@ export class ThreadStore {
   #threads;
   /** @type {string} */
   #currentId;
-  /** @type {Map<string, string>} threadId → taskId */
+  /** @type {Map<string, string>} threadId → featureId */
   #attachments;
 
   /** @type {string|null} */
@@ -395,9 +395,9 @@ export class ThreadStore {
     try {
       if (this.#attachmentsPath && existsSync(this.#attachmentsPath)) {
         const raw = readFileSync(this.#attachmentsPath, 'utf8');
-        for (const { threadId, taskId } of parseAttachments(raw)) {
+        for (const { threadId, featureId } of parseAttachments(raw)) {
           if (this.#threads.has(threadId)) {
-            this.#attachments.set(threadId, taskId);
+            this.#attachments.set(threadId, featureId);
           }
         }
       }
@@ -708,13 +708,13 @@ export class ThreadStore {
       this.#currentId = targetId;
     }
 
-    // Drop any task attachment on source (it now belongs to target).
+    // Drop any feature attachment on source (it now belongs to target).
     if (this.#attachments.has(sourceId)) {
-      const taskId = this.#attachments.get(sourceId);
+      const featureId = this.#attachments.get(sourceId);
       this.#attachments.delete(sourceId);
       // Preserve attachment on target if it had none; otherwise keep target's.
       if (!this.#attachments.has(targetId)) {
-        this.#attachments.set(targetId, taskId);
+        this.#attachments.set(targetId, featureId);
       }
       this.#markAttachmentsDirty();
     }
@@ -814,23 +814,23 @@ export class ThreadStore {
     }
   }
 
-  attachTask(threadId, taskId) {
+  attachFeature(threadId, featureId) {
     if (!this.#threads.has(threadId)) {
       throw new Error(`thread not found: ${threadId}`);
     }
-    if (!taskId || typeof taskId !== 'string') {
-      throw new Error('taskId is required');
+    if (!featureId || typeof featureId !== 'string') {
+      throw new Error('featureId is required');
     }
-    this.#attachments.set(threadId, taskId);
+    this.#attachments.set(threadId, featureId);
     this.#markAttachmentsDirty();
   }
 
-  attachedTask(threadId) {
+  attachedFeature(threadId) {
     return this.#attachments.get(threadId) || null;
   }
 
   listAttachments() {
-    return [...this.#attachments.entries()].map(([threadId, taskId]) => ({ threadId, taskId }));
+    return [...this.#attachments.entries()].map(([threadId, featureId]) => ({ threadId, featureId }));
   }
 }