@yeaft/webchat-agent 0.1.478 → 0.1.480

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.478",
+  "version": "0.1.480",
   "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;
@@ -140,14 +141,16 @@ export class Engine {
 
   /**
    * Get the list of registered tool definitions (for passing to the adapter).
-   * Prefers ToolRegistry (mode-aware) when available, falls back to legacy #tools Map.
+   * Prefers ToolRegistry when available, falls back to legacy #tools Map.
+   *
+   * task-297: mode-based filtering was removed — all registered tools are
+   * always exposed to the LLM.
    *
-   * @param {string} [mode]
    * @returns {import('./llm/adapter.js').UnifiedToolDef[]}
    */
-  #getToolDefs(mode) {
+  #getToolDefs() {
     if (this.#toolRegistry) {
-      return this.#toolRegistry.getToolDefs(mode || 'chat');
+      return this.#toolRegistry.getToolDefs();
     }
     // Legacy path: no mode filtering
     const defs = [];
@@ -180,7 +183,7 @@ export class Engine {
 
     // Get tool names from the appropriate source
     const toolNames = this.#toolRegistry
-      ? this.#toolRegistry.getToolNames(mode || 'chat')
+      ? this.#toolRegistry.getToolNames()
       : Array.from(this.#tools.keys());
 
     return buildSystemPrompt({
@@ -269,11 +272,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 +296,7 @@ export class Engine {
       content: assistantContent,
       mode,
       model: this.#config.model,
+      threadId,
     };
     if (toolCalls && toolCalls.length > 0) {
       assistantMsg.toolCalls = toolCalls;
@@ -326,7 +341,7 @@ export class Engine {
    * @param {{ prompt: string, mode?: string, messages?: Array, signal?: AbortSignal }} params
    * @yields {EngineEvent}
    */
-  async *query({ prompt, mode = 'chat', messages = [], signal }) {
+  async *query({ prompt, mode, messages = [], signal }) {
     if (!prompt || typeof prompt !== 'string' || !prompt.trim()) {
       yield {
         type: 'error',
@@ -367,7 +382,7 @@ export class Engine {
       { role: 'user', content: prompt },
     ];
 
-    const toolDefs = this.#getToolDefs(mode);
+    const toolDefs = this.#getToolDefs();
     let turnNumber = 0;
     let continueTurns = 0; // auto-continue counter
     let fullResponseText = '';
@@ -601,21 +616,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 +702,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/prompts.js

@@ -95,8 +95,7 @@ function extractLangSection(content, language) {
 /** Loaded templates — read once at module load time. */
 const RAW_TEMPLATES = {
   base: readTemplate('base.md'),
-  modeChat: readTemplate('mode-chat.md'),
-  modeWorker: readTemplate('mode-worker.md'),
+  modeUnified: readTemplate('mode-unified.md'),
   modeDream: readTemplate('mode-dream.md'),
   toolGuidance: readTemplate('tool-guidance.md'),
 };
@@ -118,9 +117,7 @@ function getTemplate(key, language) {
 const PROMPTS = {
   en: {
     identity: 'You are Yeaft, a helpful AI assistant.',
-    mode: (mode) => `Current mode: ${mode}`,
     date: (d) => `Date: ${d}`,
-    work: 'You are in work mode. Break tasks into steps, execute them using tools, and report progress.',
     dream: 'You are in dream mode. Reflect on past conversations and consolidate memories.',
     tools: (names) => `Available tools: ${names}`,
     memoryHeader: '## User Memory',
@@ -130,9 +127,7 @@ const PROMPTS = {
   },
   zh: {
     identity: '你是 Yeaft，一个有用的 AI 助手。',
-    mode: (mode) => `当前模式：${mode}`,
     date: (d) => `日期：${d}`,
-    work: '你处于工作模式。将任务分解为步骤，使用工具执行，并报告进度。',
     dream: '你处于梦境模式。回顾过去的对话，整理和巩固记忆。',
     tools: (names) => `可用工具：${names}`,
     memoryHeader: '## 用户记忆',
@@ -146,12 +141,17 @@ const PROMPTS = {
 export const SUPPORTED_LANGUAGES = Object.keys(PROMPTS);
 
 /**
- * Build the system prompt for a given language and mode.
+ * Build the system prompt for a given language.
+ *
+ * task-297: chat/work mode distinction was removed. The prompt now always uses
+ * the unified mode template. The `mode` param is retained for backward compat
+ * — only `mode === 'dream'` triggers the dream-mode template (used by background
+ * memory maintenance); all other values fall through to unified mode.
  *
  * Prompt structure:
  *   1. Core identity (from template or fallback)
- *   2. Mode + date metadata
- *   3. Mode-specific behavioral instructions (from template or fallback)
+ *   2. Date metadata
+ *   3. Mode-specific behavioral instructions (unified, or dream)
  *   4. Tool list + tool guidance (from template)
  *   5. Skills section
  *   6. Memory section
@@ -170,7 +170,7 @@ export const SUPPORTED_LANGUAGES = Object.keys(PROMPTS);
  */
 export function buildSystemPrompt({
   language = 'en',
-  mode = 'chat',
+  mode,
   toolNames = [],
   memory,
   memoryInjection,
@@ -192,23 +192,20 @@ export function buildSystemPrompt({
     parts.push(lang.identity);
   }
 
-  // ─── 2. Mode + Date Metadata ───────────────────────────
-  parts.push(lang.mode(mode));
+  // ─── 2. Date Metadata ──────────────────────────────────
   parts.push(lang.date(new Date().toISOString().split('T')[0]));
 
   // ─── 3. Mode-Specific Instructions ─────────────────────
-  if (mode === 'work') {
-    const workerTemplate = getTemplate('modeWorker', effectiveLang);
-    parts.push(workerTemplate || lang.work);
-  } else if (mode === 'dream') {
+  // task-297: single unified mode for all normal operation.
+  // `dream` is retained for background memory maintenance.
+  if (mode === 'dream') {
     const dreamTemplate = getTemplate('modeDream', effectiveLang);
     parts.push(dreamTemplate || lang.dream);
-  } else if (mode === 'chat') {
-    const chatTemplate = getTemplate('modeChat', effectiveLang);
-    if (chatTemplate) {
-      parts.push(chatTemplate);
+  } else {
+    const unifiedTemplate = getTemplate('modeUnified', effectiveLang);
+    if (unifiedTemplate) {
+      parts.push(unifiedTemplate);
     }
-    // No fallback needed — chat mode previously had no instructions
   }
 
   // ─── 4. Tools + Tool Guidance ──────────────────────────

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/registry.js

@@ -1,20 +1,14 @@
 /**
  * registry.js — Tool registration center for Yeaft Unify
  *
- * Manages tool registration, mode-based filtering, and execution dispatch.
+ * Manages tool registration and execution dispatch.
  * The engine uses this to get tool definitions for the LLM and to execute tool calls.
+ *
+ * NOTE (task-297): Mode-based filtering (chat/work) has been removed. Unify now runs as
+ * a single unified mode where all registered tools are available. Tool definitions may
+ * still carry a `modes` field, but the registry ignores it.
  */
 
-/**
- * Mode normalization map.
- * 'coordinator' and 'worker' inherit 'work' tools.
- * 'dream' has no tools by design (returns empty).
- */
-const MODE_ALIASES = {
-  coordinator: 'work',
-  worker: 'work',
-};
-
 export class ToolRegistry {
   /** @type {Map<string, import('./types.js').ToolDef>} */
   #tools = new Map();
@@ -69,35 +63,20 @@ export class ToolRegistry {
   }
 
   /**
-   * Resolve a mode to its effective tool mode.
-   * @param {string} mode
-   * @returns {string}
-   */
-  static resolveMode(mode) {
-    return MODE_ALIASES[mode] || mode;
-  }
-
-  /**
-   * Get all tools available in a given mode.
-   * @param {string} mode
+   * Get all registered tools (unfiltered).
    * @returns {import('./types.js').ToolDef[]}
    */
-  getToolsForMode(mode) {
-    const effectiveMode = ToolRegistry.resolveMode(mode);
-    const result = [];
-    for (const [, tool] of this.#tools) {
-      if (tool.modes.includes(effectiveMode)) result.push(tool);
-    }
-    return result;
+  getAllTools() {
+    return Array.from(this.#tools.values());
   }
 
   /**
    * Get tool definitions for the LLM adapter.
-   * @param {string} mode
+   * Returns all registered tools — mode filtering was removed in task-297.
    * @returns {{ name: string, description: string, parameters: object }[]}
    */
-  getToolDefs(mode) {
-    return this.getToolsForMode(mode).map(t => ({
+  getToolDefs() {
+    return this.getAllTools().map(t => ({
       name: t.name,
       description: t.description,
       parameters: t.parameters,
@@ -105,12 +84,11 @@ export class ToolRegistry {
   }
 
   /**
-   * Get tool names available in a given mode.
-   * @param {string} mode
+   * Get all registered tool names.
    * @returns {string[]}
    */
-  getToolNames(mode) {
-    return this.getToolsForMode(mode).map(t => t.name);
+  getToolNames() {
+    return Array.from(this.#tools.keys());
   }
 
   /**

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

@@ -29,9 +29,6 @@ const QUERY_TIMEOUT_MS = 120_000;
 /** Virtual conversationId for the Unify session */
 let unifyConversationId = null;
 
-/** Current query mode: 'chat' or 'work' */
-let currentMode = 'chat';
-
 /** Accumulated conversation messages for context continuity across queries.
  *  Each entry is { role: 'user'|'assistant', content: string|Array }.
  *  Cleared on session reset or consolidation. */
@@ -79,14 +76,16 @@ function sendUnifyEvent(event) {
  * Handle a unify_chat message from the web UI.
  *
  * @param {{ prompt: string, mode?: string, userId?: string, username?: string }} msg
+ *   NOTE: `mode` is deprecated (task-297) — Unify now runs in a single unified mode.
+ *   If present, a warning is logged and the field is ignored.
  */
 export async function handleUnifyChat(msg) {
   const { prompt, mode } = msg;
   if (!prompt?.trim()) return;
 
-  // Update mode if provided
-  if (mode === 'chat' || mode === 'work') {
-    currentMode = mode;
+  // Deprecation warning — task-297 removed chat/work mode distinction
+  if (mode !== undefined && mode !== null) {
+    console.warn('[Unify] unify_chat.mode is deprecated and ignored — Unify now runs in a single unified mode.');
   }
 
   try {
@@ -150,7 +149,6 @@ export async function handleUnifyChat(msg) {
     // ─── Stream Engine events → claude_output format ──
     for await (const event of session.engine.query({
       prompt,
-      mode: currentMode,
       messages: conversationMessages,
       signal: currentAbort.signal,
     })) {
@@ -192,12 +190,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 +212,7 @@ export async function handleUnifyChat(msg) {
               content: event.output || '',
               is_error: event.isError || false,
             }],
+            threadId: event.threadId,
           });
           break;
 
@@ -406,12 +408,12 @@ export async function handleUnifyChat(msg) {
 
 /**
  * Handle mode switch from the web UI.
- * @param {{ mode: 'chat' | 'work' }} msg
+ * DEPRECATED (task-297): Unify no longer has chat/work mode distinction.
+ * Retained as a no-op with warning for backward compatibility.
+ * @param {{ mode?: string }} _msg
  */
-export function handleUnifyModeSwitch(msg) {
-  if (msg.mode === 'chat' || msg.mode === 'work') {
-    currentMode = msg.mode;
-  }
+export function handleUnifyModeSwitch(_msg) {
+  console.warn('[Unify] unify_mode_switch is deprecated and ignored — Unify now runs in a single unified mode.');
 }
 
 /**
@@ -518,7 +520,6 @@ export async function resetUnifySession() {
     session = null;
   }
   unifyConversationId = null;
-  currentMode = 'chat';
   conversationMessages = [];
 
   // Re-initialize session immediately so frontend gets updated config