@yeaft/webchat-agent 0.1.478 → 0.1.479

package/package.json

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

package/unify/engine.js

@@ -24,6 +24,7 @@ import { recall } from './memory/recall.js';
 import { shouldConsolidate, consolidate } from './memory/consolidate.js';
 import { buildMemoryInjection } from './memory/layout.js';
 import { runStopHooks } from './stop-hooks.js';
+import { getThreadStore, MAIN_THREAD_ID } from './threads/store.js';
 
 /** Maximum number of turns before the engine stops to prevent infinite loops. */
 const MAX_TURNS = 25;
@@ -269,11 +270,22 @@ export class Engine {
     if (!this.#conversationStore) return;
     if (this.#config._readOnly) return;
 
+    // task-299 Phase 1: tag persisted messages with the current thread.
+    // getThreadStore() lazily seeds a default 'main' thread if not yet init'd.
+    let threadId = MAIN_THREAD_ID;
+    try {
+      threadId = getThreadStore().currentId || MAIN_THREAD_ID;
+    } catch {
+      // Defensive: any store failure falls back to 'main' so persistence
+      // never breaks because of thread bookkeeping.
+    }
+
     // Persist user message
     this.#conversationStore.append({
       role: 'user',
       content: userContent,
       mode,
+      threadId,
     });
 
     // Persist assistant message
@@ -282,6 +294,7 @@ export class Engine {
       content: assistantContent,
       mode,
       model: this.#config.model,
+      threadId,
     };
     if (toolCalls && toolCalls.length > 0) {
       assistantMsg.toolCalls = toolCalls;
@@ -601,21 +614,21 @@ export class Engine {
         if (!hasTool) {
           output = `Error: unknown tool "${tc.name}"`;
           isError = true;
-          yield { type: 'tool_end', id: tc.id, name: tc.name, output, isError: true };
+          yield { type: 'tool_end', id: tc.id, name: tc.name, output, isError: true, threadId: this.currentThreadId };
         } else {
           try {
-            yield { type: 'tool_start', id: tc.id, name: tc.name, input: tc.input };
+            yield { type: 'tool_start', id: tc.id, name: tc.name, input: tc.input, threadId: this.currentThreadId };
             if (this.#toolRegistry) {
               output = await this.#toolRegistry.execute(tc.name, tc.input, toolCtx);
             } else {
               const tool = this.#tools.get(tc.name);
               output = await tool.execute(tc.input, { signal });
             }
-            yield { type: 'tool_end', id: tc.id, name: tc.name, output, isError: false };
+            yield { type: 'tool_end', id: tc.id, name: tc.name, output, isError: false, threadId: this.currentThreadId };
           } catch (err) {
             output = `Error: ${err.message}`;
             isError = true;
-            yield { type: 'tool_end', id: tc.id, name: tc.name, output, isError: true };
+            yield { type: 'tool_end', id: tc.id, name: tc.name, output, isError: true, threadId: this.currentThreadId };
           }
         }
 
@@ -687,6 +700,19 @@ export class Engine {
   /** @returns {import('./mcp.js').MCPManager|null} */
   get mcpManager() { return this.#mcpManager; }
 
+  /**
+   * task-299 Phase 1: the engine's current thread marker.
+   * Defaults to 'main' if the thread store is unreachable for any reason.
+   * @returns {string}
+   */
+  get currentThreadId() {
+    try {
+      return getThreadStore().currentId || MAIN_THREAD_ID;
+    } catch {
+      return MAIN_THREAD_ID;
+    }
+  }
+
   /** @returns {string|null} */
   get yeaftDir() { return this.#yeaftDir; }
 

package/unify/session.js

@@ -23,6 +23,7 @@ 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 { initThreadStore } from './threads/store.js';
 import { Engine } from './engine.js';
 import { join } from 'path';
 
@@ -121,6 +122,11 @@ export async function loadSession(options = {}) {
   // ─── 5a. Initialize task store ─────────────────────────
   initTaskStore(yeaftDir, { readOnly: config._readOnly || false });
 
+  // ─── 5b. Initialize thread store (task-299 Phase 1) ────
+  //         In-memory only for Phase 1; replaced by a file-backed store
+  //         when task-298's data layer merges.
+  initThreadStore();
+
   // ─── 6. Load skills ────────────────────────────────────
   let skillManager;
   if (skipSkills) {

package/unify/threads/store.js

@@ -0,0 +1,181 @@
+/**
+ * store.js — In-memory ThreadStore for Yeaft Unify (Phase 1 mock).
+ *
+ * Phase 1 intentionally keeps the implementation in-memory only: it lets the
+ * thread/task spawn tools ship and be tested before task-298's real
+ * filesystem layer is merged. When task-298 merges, this module will be
+ * replaced (or promoted to a shim) by a file-backed store with the same API.
+ *
+ * Responsibilities (Phase 1):
+ *   - Maintain a map of threadId → thread metadata.
+ *   - Track a "currentThreadId" marker for the engine.
+ *   - Maintain attachments from threadId → taskId.
+ *
+ * A single "main" thread is created on construction so that pre-spawn
+ * messages have a valid threadId to carry.
+ */
+
+import { randomUUID } from 'crypto';
+
+/** Default / root thread id — every fresh ThreadStore has one. */
+export const MAIN_THREAD_ID = 'main';
+
+/**
+ * @typedef {Object} Thread
+ * @property {string} id
+ * @property {string} name
+ * @property {string} [goal]
+ * @property {string|null} parentThreadId
+ * @property {number} createdAt
+ * @property {number} updatedAt
+ */
+
+export class ThreadStore {
+  /** @type {Map<string, Thread>} */
+  #threads;
+
+  /** @type {string} */
+  #currentId;
+
+  /** @type {Map<string, string>} threadId → taskId */
+  #attachments;
+
+  constructor() {
+    this.#threads = new Map();
+    this.#attachments = new Map();
+
+    const now = Date.now();
+    const main = {
+      id: MAIN_THREAD_ID,
+      name: 'main',
+      goal: '',
+      parentThreadId: null,
+      createdAt: now,
+      updatedAt: now,
+    };
+    this.#threads.set(main.id, main);
+    this.#currentId = main.id;
+  }
+
+  /** Get current thread id (defaults to 'main'). */
+  get currentId() {
+    return this.#currentId;
+  }
+
+  /** Total thread count (including 'main'). */
+  get size() {
+    return this.#threads.size;
+  }
+
+  /**
+   * Create a new thread.
+   * @param {{ name: string, goal?: string, parentThreadId?: string }} spec
+   * @returns {Thread}
+   */
+  create({ name, goal = '', parentThreadId = null } = {}) {
+    if (!name || typeof name !== 'string' || !name.trim()) {
+      throw new Error('thread name is required');
+    }
+    if (parentThreadId && !this.#threads.has(parentThreadId)) {
+      throw new Error(`parent thread not found: ${parentThreadId}`);
+    }
+    const id = `thr-${randomUUID().slice(0, 8)}`;
+    const now = Date.now();
+    const thread = {
+      id,
+      name: name.trim(),
+      goal: goal || '',
+      parentThreadId: parentThreadId || null,
+      createdAt: now,
+      updatedAt: now,
+    };
+    this.#threads.set(id, thread);
+    return thread;
+  }
+
+  /** @param {string} id */
+  get(id) {
+    return this.#threads.get(id) || null;
+  }
+
+  /** @returns {Thread[]} */
+  list() {
+    return [...this.#threads.values()];
+  }
+
+  /** @param {string} id */
+  has(id) {
+    return this.#threads.has(id);
+  }
+
+  /**
+   * Set the current thread marker. Throws if unknown.
+   * @param {string} id
+   */
+  switch(id) {
+    if (!this.#threads.has(id)) {
+      throw new Error(`thread not found: ${id}`);
+    }
+    this.#currentId = id;
+    const t = this.#threads.get(id);
+    t.updatedAt = Date.now();
+  }
+
+  /**
+   * Attach a task to a thread. Overwrites any existing attachment.
+   * @param {string} threadId
+   * @param {string} taskId
+   */
+  attachTask(threadId, taskId) {
+    if (!this.#threads.has(threadId)) {
+      throw new Error(`thread not found: ${threadId}`);
+    }
+    if (!taskId || typeof taskId !== 'string') {
+      throw new Error('taskId is required');
+    }
+    this.#attachments.set(threadId, taskId);
+  }
+
+  /**
+   * Get the taskId attached to a thread, if any.
+   * @param {string} threadId
+   * @returns {string|null}
+   */
+  attachedTask(threadId) {
+    return this.#attachments.get(threadId) || null;
+  }
+
+  /** @returns {Array<{ threadId: string, taskId: string }>} */
+  listAttachments() {
+    return [...this.#attachments.entries()].map(([threadId, taskId]) => ({ threadId, taskId }));
+  }
+}
+
+/** @type {ThreadStore|null} */
+let threadStore = null;
+
+/**
+ * Initialize the thread store. Safe to call multiple times — subsequent calls
+ * replace the store only if `force` is true (primarily for tests).
+ * @param {{ force?: boolean }} [opts]
+ * @returns {ThreadStore}
+ */
+export function initThreadStore(opts = {}) {
+  if (!threadStore || opts.force) {
+    threadStore = new ThreadStore();
+  }
+  return threadStore;
+}
+
+/** @returns {ThreadStore} */
+export function getThreadStore() {
+  if (!threadStore) {
+    threadStore = new ThreadStore();
+  }
+  return threadStore;
+}
+
+/** Test-only reset helper. */
+export function _resetThreadStoreForTests() {
+  threadStore = null;
+}

package/unify/tools/index.js

@@ -55,6 +55,15 @@ import {
   updatePlan,
 } from './task-tools.js';
 
+// --- P1 Thread tools (task-299 Phase 1) ---
+import {
+  spawnThread,
+  switchThread,
+  listThreads,
+  attachThreadToTask,
+} from './thread-tools.js';
+import { spawnTask, spawnSubtask } from './spawn-task-tools.js';
+
 // --- P2 Auxiliary tools ---
 import { jsRepl, jsReplReset } from './js-repl.js';
 import notebookEdit from './notebook-edit.js';
@@ -113,6 +122,14 @@ export const allTools = [
   followupTask,
   updatePlan,
 
+  // P1 Thread (task-299 Phase 1)
+  spawnThread,
+  switchThread,
+  listThreads,
+  attachThreadToTask,
+  spawnTask,
+  spawnSubtask,
+
   // P2 Auxiliary
   jsRepl,
   jsReplReset,

package/unify/tools/spawn-task-tools.js

@@ -0,0 +1,125 @@
+/**
+ * spawn-task-tools.js — Thin semantic-sugar wrappers over TaskCreate.
+ *
+ * Phase 1 of task-299: expose `SpawnTask` and `SpawnSubtask` as first-class
+ * tool names so the LLM can "spawn" work items in the same vocabulary it
+ * uses to spawn threads. Both delegate to the existing TaskStore (shared
+ * with TaskCreate), so there is a single source of truth for task data.
+ */
+
+import { defineTool } from './types.js';
+import { randomUUID } from 'crypto';
+import { getTaskStore } from './task-tools.js';
+
+function requireStore() {
+  const store = getTaskStore();
+  if (!store) return { error: 'Task store not initialized. Session may still be loading.' };
+  return { store };
+}
+
+function newTaskId() {
+  return `task-${randomUUID().slice(0, 8)}`;
+}
+
+// ─── SpawnTask ──────────────────────────────────────────
+
+export const spawnTask = defineTool({
+  name: 'SpawnTask',
+  description: `Spawn a new top-level task.
+
+Equivalent to TaskCreate without a parent. Provided as a first-class
+name so tasks and threads can be "spawned" with a uniform vocabulary.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      title: { type: 'string' },
+      description: { type: 'string' },
+      priority: {
+        type: 'string',
+        enum: ['low', 'medium', 'high', 'critical'],
+      },
+    },
+    required: ['title'],
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => false,
+  isReadOnly: () => false,
+  async execute(input) {
+    const got = requireStore();
+    if (got.error) return JSON.stringify({ error: got.error });
+    const { title, description = '', priority = 'medium' } = input || {};
+    if (!title) return JSON.stringify({ error: 'title is required' });
+
+    const id = newTaskId();
+    const now = Date.now();
+    got.store.create({
+      id,
+      title,
+      description,
+      priority,
+      status: 'pending',
+      parentId: null,
+      createdAt: now,
+      updatedAt: now,
+    });
+    return JSON.stringify({
+      success: true,
+      task: { id, title, priority, status: 'pending' },
+      message: `Task spawned: ${title} (${id})`,
+    });
+  },
+});
+
+// ─── SpawnSubtask ───────────────────────────────────────
+
+export const spawnSubtask = defineTool({
+  name: 'SpawnSubtask',
+  description: `Spawn a subtask under an existing parent task.
+
+Requires parent_task_id. The parent must exist. Use for breaking a
+larger task into executable pieces.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      parent_task_id: { type: 'string' },
+      title: { type: 'string' },
+      description: { type: 'string' },
+      priority: {
+        type: 'string',
+        enum: ['low', 'medium', 'high', 'critical'],
+      },
+    },
+    required: ['parent_task_id', 'title'],
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => false,
+  isReadOnly: () => false,
+  async execute(input) {
+    const got = requireStore();
+    if (got.error) return JSON.stringify({ error: got.error });
+    const { parent_task_id, title, description = '', priority = 'medium' } = input || {};
+    if (!parent_task_id) return JSON.stringify({ error: 'parent_task_id is required' });
+    if (!title) return JSON.stringify({ error: 'title is required' });
+
+    const parent = got.store.get(parent_task_id);
+    if (!parent) return JSON.stringify({ error: `Parent task not found: ${parent_task_id}` });
+
+    const id = newTaskId();
+    const now = Date.now();
+    got.store.create({
+      id,
+      title,
+      description: description || `Subtask of: ${parent.title}`,
+      priority,
+      status: 'pending',
+      parentId: parent_task_id,
+      createdAt: now,
+      updatedAt: now,
+    });
+    return JSON.stringify({
+      success: true,
+      task: { id, title, priority, status: 'pending', parentId: parent_task_id },
+      message: `Subtask spawned: ${title} (${id}) under ${parent_task_id}`,
+    });
+  },
+});

package/unify/tools/thread-tools.js

@@ -0,0 +1,183 @@
+/**
+ * thread-tools.js — Thread-spawning tools for Unify Engine (Phase 1).
+ *
+ * Phase 1 scope (task-299):
+ *   - SpawnThread        — create a new thread
+ *   - SwitchThread       — set the engine's currentThreadId marker
+ *   - ListThreads        — list threads + current marker
+ *   - AttachThreadToTask — bind a thread to an existing task
+ *
+ * Phase 1 uses the in-memory ThreadStore (agent/unify/threads/store.js)
+ * so these tools can ship and be tested before task-298's file-backed
+ * data layer merges. The tool surface is designed to remain stable when
+ * the store is replaced.
+ */
+
+import { defineTool } from './types.js';
+import { getThreadStore } from '../threads/store.js';
+import { getTaskStore } from './task-tools.js';
+
+// ─── SpawnThread ─────────────────────────────────────────
+
+export const spawnThread = defineTool({
+  name: 'SpawnThread',
+  description: `Create a new thread (conversation track) for parallel work.
+
+A thread is a named conversation track that groups related messages and
+tool calls under a single goal. Use when the work needs a fresh focus
+track separate from the current conversation.
+
+Returns the new threadId (format: "thr-xxxxxxxx"). Does NOT switch the
+engine to the new thread — call SwitchThread to activate it.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      name: { type: 'string', description: 'Short human-readable name' },
+      goal: { type: 'string', description: 'Optional one-sentence goal' },
+      parent_thread_id: {
+        type: 'string',
+        description: 'Optional parent threadId for hierarchy',
+      },
+    },
+    required: ['name'],
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => false,
+  isReadOnly: () => false,
+  async execute(input) {
+    const { name, goal, parent_thread_id } = input || {};
+    if (!name) return JSON.stringify({ error: 'name is required' });
+    try {
+      const store = getThreadStore();
+      const t = store.create({ name, goal, parentThreadId: parent_thread_id || null });
+      return JSON.stringify({
+        success: true,
+        thread: {
+          id: t.id,
+          name: t.name,
+          goal: t.goal,
+          parentThreadId: t.parentThreadId,
+        },
+        message: `Thread created: ${t.name} (${t.id})`,
+      });
+    } catch (err) {
+      return JSON.stringify({ error: err.message || String(err) });
+    }
+  },
+});
+
+// ─── SwitchThread ────────────────────────────────────────
+
+export const switchThread = defineTool({
+  name: 'SwitchThread',
+  description: `Switch the engine's active thread marker.
+
+All messages and tool calls persisted after this call will carry the new
+threadId (Phase 1: marker only — the Engine reads it when persisting and
+the web-bridge forwards it to the UI). Use 'main' to return to the root
+thread.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      thread_id: { type: 'string', description: 'Thread id to switch to' },
+    },
+    required: ['thread_id'],
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => false,
+  isReadOnly: () => false,
+  async execute(input) {
+    const { thread_id } = input || {};
+    if (!thread_id) return JSON.stringify({ error: 'thread_id is required' });
+    try {
+      const store = getThreadStore();
+      store.switch(thread_id);
+      return JSON.stringify({
+        success: true,
+        currentThreadId: store.currentId,
+        message: `Switched to thread ${thread_id}`,
+      });
+    } catch (err) {
+      return JSON.stringify({ error: err.message || String(err) });
+    }
+  },
+});
+
+// ─── ListThreads ─────────────────────────────────────────
+
+export const listThreads = defineTool({
+  name: 'ListThreads',
+  description: `List all threads and the engine's current thread marker.`,
+  parameters: { type: 'object', properties: {} },
+  modes: ['work'],
+  isConcurrencySafe: () => true,
+  isReadOnly: () => true,
+  async execute() {
+    const store = getThreadStore();
+    const threads = store.list().map(t => ({
+      id: t.id,
+      name: t.name,
+      goal: t.goal,
+      parentThreadId: t.parentThreadId,
+      attachedTaskId: store.attachedTask(t.id),
+    }));
+    return JSON.stringify(
+      {
+        currentThreadId: store.currentId,
+        threads,
+        totalCount: threads.length,
+      },
+      null,
+      2,
+    );
+  },
+});
+
+// ─── AttachThreadToTask ──────────────────────────────────
+
+export const attachThreadToTask = defineTool({
+  name: 'AttachThreadToTask',
+  description: `Link an existing thread to an existing task.
+
+Use to record which thread is responsible for which task. The thread and
+the task must both already exist. Overwrites any previous attachment for
+the same thread.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      thread_id: { type: 'string' },
+      task_id: { type: 'string' },
+    },
+    required: ['thread_id', 'task_id'],
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => false,
+  isReadOnly: () => false,
+  async execute(input) {
+    const { thread_id, task_id } = input || {};
+    if (!thread_id) return JSON.stringify({ error: 'thread_id is required' });
+    if (!task_id) return JSON.stringify({ error: 'task_id is required' });
+
+    const taskStore = getTaskStore();
+    // If the task store is initialized, validate the task exists; if not
+    // initialized (e.g. Phase 1 unit tests running before session bootstrap),
+    // skip the task existence check — we still enforce thread existence.
+    if (taskStore) {
+      const task = taskStore.get(task_id);
+      if (!task) return JSON.stringify({ error: `Task not found: ${task_id}` });
+    }
+
+    try {
+      const store = getThreadStore();
+      store.attachTask(thread_id, task_id);
+      return JSON.stringify({
+        success: true,
+        threadId: thread_id,
+        taskId: task_id,
+        message: `Thread ${thread_id} attached to task ${task_id}`,
+      });
+    } catch (err) {
+      return JSON.stringify({ error: err.message || String(err) });
+    }
+  },
+});

package/unify/web-bridge.js

@@ -192,12 +192,15 @@ export async function handleUnifyChat(msg) {
                 input: event.input,
               }],
             },
+            threadId: event.threadId,
           });
           break;
 
         // ── Tool execution started ──
         case 'tool_start':
-          // Tool is running — the UI already shows it from tool_use block above
+          // Tool is running — the UI already shows it from tool_use block above.
+          // Forward threadId so the UI can group tool activity by thread (Phase 1).
+          sendUnifyEvent({ type: 'tool_start', id: event.id, name: event.name, threadId: event.threadId });
           break;
 
         // ── Tool execution completed ──
@@ -211,6 +214,7 @@ export async function handleUnifyChat(msg) {
               content: event.output || '',
               is_error: event.isError || false,
             }],
+            threadId: event.threadId,
           });
           break;