@yeaft/webchat-agent 0.1.446 → 0.1.447

package/connection/message-router.js

@@ -25,7 +25,7 @@ import { sendToServer, flushMessageBuffer } from './buffer.js';
 import { handleRestartAgent, handleUpgradeAgent } from './upgrade.js';
 import { loadMcpServers, updateMcpConfig } from '../mcp.js';
 import { getLlmConfig, updateLlmConfig } from '../unify/config-api.js';
-import { handleUnifyChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession } from '../unify/web-bridge.js';
+import { handleUnifyChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory } from '../unify/web-bridge.js';
 
 export async function handleMessage(msg) {
   switch (msg.type) {
@@ -325,6 +325,10 @@ export async function handleMessage(msg) {
       await handleUnifyChat(msg);
       break;
 
+    case 'unify_load_history':
+      await handleUnifyLoadHistory(msg);
+      break;
+
     case 'unify_mode_switch':
       handleUnifyModeSwitch(msg);
       break;

package/package.json

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

package/unify/session.js

@@ -22,6 +22,7 @@ import { MemoryStore } from './memory/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 { Engine } from './engine.js';
 import { join } from 'path';
 
@@ -117,6 +118,9 @@ export async function loadSession(options = {}) {
   const conversationStore = new ConversationStore(yeaftDir);
   const memoryStore = new MemoryStore(yeaftDir);
 
+  // ─── 5a. Initialize task store ─────────────────────────
+  initTaskStore(yeaftDir, { readOnly: config._readOnly || false });
+
   // ─── 6. Load skills ────────────────────────────────────
   let skillManager;
   if (skipSkills) {

package/unify/tasks/store.js

@@ -0,0 +1,397 @@
+/**
+ * store.js — File-system backed TaskStore for Yeaft Unify.
+ *
+ * Persists tasks to ~/.yeaft/tasks/ with one folder per task.
+ * Layout:
+ *   ~/.yeaft/tasks/
+ *     index.md              — Task index (auto-generated overview)
+ *     plan.md               — Global plan text
+ *     task-abc12345/         — One folder per task
+ *       task.md             — Task metadata (YAML frontmatter + description)
+ *       progress.md         — Progress log (append-only)
+ *       memory.md           — Task-specific context/notes
+ */
+
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+
+// ─── YAML Frontmatter helpers ────────────────────────────────
+
+/**
+ * Serialize a task object to YAML frontmatter + body for task.md.
+ * @param {object} task
+ * @returns {string}
+ */
+function serializeTask(task) {
+  const fm = [
+    '---',
+    `id: ${task.id}`,
+    `title: ${task.title}`,
+    `status: ${task.status}`,
+    `priority: ${task.priority || 'medium'}`,
+  ];
+
+  if (task.parentId) fm.push(`parentId: ${task.parentId}`);
+  if (task.createdAt) fm.push(`createdAt: ${task.createdAt}`);
+  if (task.updatedAt) fm.push(`updatedAt: ${task.updatedAt}`);
+
+  fm.push('---');
+  fm.push('');
+
+  // Body: description + result
+  const parts = [];
+  if (task.description) parts.push(task.description);
+  if (task.result) {
+    parts.push('');
+    parts.push('## Result');
+    parts.push(task.result);
+  }
+  fm.push(parts.join('\n'));
+
+  return fm.join('\n');
+}
+
+/**
+ * Parse a task.md file (YAML frontmatter + body) into a task object.
+ * @param {string} raw — File contents
+ * @returns {object|null}
+ */
+function parseTask(raw) {
+  if (!raw || !raw.startsWith('---')) return null;
+
+  const endIdx = raw.indexOf('---', 3);
+  if (endIdx === -1) return null;
+
+  const frontmatter = raw.slice(3, endIdx).trim();
+  const body = raw.slice(endIdx + 3).trim();
+
+  const task = {};
+
+  for (const line of frontmatter.split('\n')) {
+    const colonIdx = line.indexOf(':');
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const val = line.slice(colonIdx + 1).trim();
+    if (!key) continue;
+
+    if (key === 'createdAt' || key === 'updatedAt') {
+      task[key] = parseInt(val, 10) || 0;
+    } else {
+      task[key] = val;
+    }
+  }
+
+  if (!task.id) return null;
+
+  // Parse body: description and result
+  const resultIdx = body.indexOf('## Result');
+  if (resultIdx !== -1) {
+    task.description = body.slice(0, resultIdx).trim();
+    task.result = body.slice(resultIdx + '## Result'.length).trim();
+  } else {
+    task.description = body;
+  }
+
+  // Normalize parentId
+  if (!task.parentId || task.parentId === 'null') {
+    task.parentId = null;
+  }
+
+  return task;
+}
+
+// ─── Index generation ────────────────────────────────────────
+
+/**
+ * Generate index.md content from all tasks.
+ * @param {Map<string, object>} tasks
+ * @returns {string}
+ */
+function generateIndex(tasks) {
+  const now = new Date().toISOString();
+  const lines = [
+    '---',
+    `totalTasks: ${tasks.size}`,
+    `lastUpdated: ${now}`,
+    '---',
+    '# Task Index',
+    '',
+    '| ID | Title | Status | Priority | Updated |',
+    '|----|-------|--------|----------|---------|',
+  ];
+
+  // Sort: in_progress first, then pending, then others
+  const ORDER = { in_progress: 0, pending: 1, blocked: 2, completed: 3, cancelled: 4 };
+  const sorted = [...tasks.values()].sort(
+    (a, b) => (ORDER[a.status] ?? 5) - (ORDER[b.status] ?? 5)
+  );
+
+  for (const t of sorted) {
+    const date = t.updatedAt ? new Date(t.updatedAt).toISOString().slice(0, 10) : '-';
+    lines.push(`| ${t.id} | ${t.title} | ${t.status} | ${t.priority || 'medium'} | ${date} |`);
+  }
+
+  return lines.join('\n') + '\n';
+}
+
+// ─── Progress log helpers ────────────────────────────────────
+
+/**
+ * Format a progress entry for appending to progress.md.
+ * @param {string} note
+ * @param {object} [meta]
+ * @returns {string}
+ */
+function formatProgressEntry(note, meta = {}) {
+  const now = new Date();
+  const ts = `${now.toISOString().slice(0, 10)} ${now.toISOString().slice(11, 16)}`;
+  const lines = [`## ${ts}`];
+  lines.push(`- ${note}`);
+  if (meta.status) lines.push(`- Status: ${meta.status}`);
+  if (meta.result) lines.push(`- Result: ${meta.result}`);
+  lines.push('');
+  return lines.join('\n');
+}
+
+// ─── TaskStore ───────────────────────────────────────────────
+
+export class TaskStore {
+  /** @type {string} */
+  #dir;
+  /** @type {string} */
+  #indexPath;
+  /** @type {string} */
+  #planPath;
+  /** @type {Map<string, object>} */
+  #tasks;
+  /** @type {boolean} */
+  #readOnly;
+
+  /**
+   * @param {string} yeaftDir — Base ~/.yeaft directory
+   * @param {{ readOnly?: boolean }} [opts]
+   */
+  constructor(yeaftDir, opts = {}) {
+    this.#dir = join(yeaftDir, 'tasks');
+    this.#indexPath = join(this.#dir, 'index.md');
+    this.#planPath = join(this.#dir, 'plan.md');
+    this.#tasks = new Map();
+    this.#readOnly = opts.readOnly || false;
+
+    // Ensure base directory exists
+    if (!this.#readOnly) {
+      if (!existsSync(this.#dir)) {
+        try {
+          mkdirSync(this.#dir, { recursive: true });
+        } catch {
+          this.#readOnly = true;
+        }
+      }
+    }
+
+    // Load existing tasks from disk
+    this.#loadAll();
+  }
+
+  /** Number of tasks in the store. */
+  get size() {
+    return this.#tasks.size;
+  }
+
+  /**
+   * Create a new task. Creates its folder with task.md, progress.md, memory.md.
+   * @param {object} task — Must have .id, .title, .status
+   * @returns {object} The created task
+   */
+  create(task) {
+    this.#tasks.set(task.id, task);
+
+    if (!this.#readOnly) {
+      const taskDir = join(this.#dir, task.id);
+      try {
+        mkdirSync(taskDir, { recursive: true });
+        writeFileSync(join(taskDir, 'task.md'), serializeTask(task), 'utf8');
+        writeFileSync(join(taskDir, 'progress.md'), '# Progress Log\n\n', 'utf8');
+        writeFileSync(join(taskDir, 'memory.md'), '# Task Memory\n', 'utf8');
+        this.#appendProgressInternal(task.id, `Created task: ${task.title}`, { status: 'pending' });
+        this.#updateIndex();
+      } catch {
+        // Best-effort write
+      }
+    }
+
+    return task;
+  }
+
+  /**
+   * Update an existing task.
+   * @param {string} id
+   * @param {object} updates
+   * @returns {object|null} Updated task, or null if not found
+   */
+  update(id, updates) {
+    const task = this.#tasks.get(id);
+    if (!task) return null;
+
+    const oldStatus = task.status;
+    Object.assign(task, updates, { updatedAt: Date.now() });
+
+    if (!this.#readOnly) {
+      try {
+        const taskDir = join(this.#dir, id);
+        writeFileSync(join(taskDir, 'task.md'), serializeTask(task), 'utf8');
+
+        // Log progress on status change
+        if (updates.status && updates.status !== oldStatus) {
+          this.#appendProgressInternal(id, `Status changed: ${oldStatus} → ${updates.status}`, updates);
+        }
+        this.#updateIndex();
+      } catch {
+        // Best-effort
+      }
+    }
+
+    return task;
+  }
+
+  /**
+   * Get a task by ID.
+   * @param {string} id
+   * @returns {object|null}
+   */
+  get(id) {
+    return this.#tasks.get(id) || null;
+  }
+
+  /**
+   * List tasks with optional filters.
+   * @param {{ status?: string, priority?: string }} [filter]
+   * @returns {object[]}
+   */
+  list(filter) {
+    let results = [...this.#tasks.values()];
+    if (filter?.status) results = results.filter(t => t.status === filter.status);
+    if (filter?.priority) results = results.filter(t => t.priority === filter.priority);
+    return results;
+  }
+
+  /**
+   * Get progress log for a task.
+   * @param {string} id
+   * @returns {string}
+   */
+  getProgress(id) {
+    const path = join(this.#dir, id, 'progress.md');
+    try {
+      if (existsSync(path)) return readFileSync(path, 'utf8');
+    } catch { /* */ }
+    return '';
+  }
+
+  /**
+   * Append a progress note to a task's progress log.
+   * @param {string} id
+   * @param {string} note
+   * @param {object} [meta]
+   */
+  appendProgress(id, note, meta = {}) {
+    if (!this.#tasks.has(id)) return;
+    this.#appendProgressInternal(id, note, meta);
+  }
+
+  /**
+   * Get memory content for a task.
+   * @param {string} id
+   * @returns {string}
+   */
+  getMemory(id) {
+    const path = join(this.#dir, id, 'memory.md');
+    try {
+      if (existsSync(path)) return readFileSync(path, 'utf8');
+    } catch { /* */ }
+    return '';
+  }
+
+  /**
+   * Update memory content for a task.
+   * @param {string} id
+   * @param {string} content
+   */
+  updateMemory(id, content) {
+    if (this.#readOnly || !this.#tasks.has(id)) return;
+    try {
+      writeFileSync(join(this.#dir, id, 'memory.md'), content, 'utf8');
+    } catch { /* */ }
+  }
+
+  /**
+   * Get current plan text.
+   * @returns {string}
+   */
+  getPlan() {
+    try {
+      if (existsSync(this.#planPath)) return readFileSync(this.#planPath, 'utf8');
+    } catch { /* */ }
+    return '';
+  }
+
+  /**
+   * Set plan text.
+   * @param {string} text
+   */
+  setPlan(text) {
+    if (this.#readOnly) return;
+    try {
+      writeFileSync(this.#planPath, text, 'utf8');
+    } catch { /* */ }
+  }
+
+  // ─── Internal methods ──────────────────────────────────────
+
+  /** Load all task folders from disk. */
+  #loadAll() {
+    if (!existsSync(this.#dir)) return;
+    let entries;
+    try {
+      entries = readdirSync(this.#dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      if (!entry.isDirectory() || !entry.name.startsWith('task-')) continue;
+      const taskMdPath = join(this.#dir, entry.name, 'task.md');
+      try {
+        if (!existsSync(taskMdPath)) continue;
+        const raw = readFileSync(taskMdPath, 'utf8');
+        const task = parseTask(raw);
+        if (task && task.id) {
+          this.#tasks.set(task.id, task);
+        }
+      } catch {
+        // Skip corrupt task folders
+      }
+    }
+  }
+
+  /** Append to a task's progress.md. */
+  #appendProgressInternal(id, note, meta) {
+    if (this.#readOnly) return;
+    const path = join(this.#dir, id, 'progress.md');
+    try {
+      const existing = existsSync(path) ? readFileSync(path, 'utf8') : '# Progress Log\n\n';
+      writeFileSync(path, existing + formatProgressEntry(note, meta), 'utf8');
+    } catch { /* */ }
+  }
+
+  /** Regenerate index.md from all tasks. */
+  #updateIndex() {
+    if (this.#readOnly) return;
+    try {
+      writeFileSync(this.#indexPath, generateIndex(this.#tasks), 'utf8');
+    } catch { /* */ }
+  }
+}
+
+// Exported for testing
+export { serializeTask as _serializeTask, parseTask as _parseTask };

package/unify/tools/index.js

@@ -48,6 +48,8 @@ import {
   taskUpdate,
   taskList,
   taskGet,
+  taskProgress,
+  taskMemory,
   followupTask,
   updatePlan,
 } from './task-tools.js';
@@ -104,6 +106,8 @@ export const allTools = [
   taskUpdate,
   taskList,
   taskGet,
+  taskProgress,
+  taskMemory,
   followupTask,
   updatePlan,
 

package/unify/tools/task-tools.js

@@ -1,26 +1,43 @@
 /**
- * Task management tools — in-memory task tracking for work mode.
+ * Task management tools — persistent task tracking for work mode.
  *
- * Tasks are organized in a simple flat list with status tracking.
- * Persisted only in memory for the session duration.
+ * Tasks are persisted to ~/.yeaft/tasks/ via TaskStore (one folder per task).
+ * Call initTaskStore(yeaftDir) during session init before tools are used.
  */
 
 import { defineTool } from './types.js';
 import { randomUUID } from 'crypto';
+import { TaskStore } from '../tasks/store.js';
 
-/** In-memory task store. */
-const tasks = new Map();
+/** @type {TaskStore|null} */
+let taskStore = null;
 
-/** Plan text (free-form markdown). */
-let currentPlan = '';
+/**
+ * Initialize the task store with the yeaft directory.
+ * Must be called during session startup before any task tools are used.
+ * @param {string} yeaftDir — Base ~/.yeaft directory
+ * @param {{ readOnly?: boolean }} [opts]
+ */
+export function initTaskStore(yeaftDir, opts) {
+  taskStore = new TaskStore(yeaftDir, opts);
+}
 
-/** Get task store for other tools. */
+/** Get the task store instance (for other tools/tests). */
 export function getTaskStore() {
-  return tasks;
+  return taskStore;
 }
 
+/** Get current plan text. */
 export function getPlan() {
-  return currentPlan;
+  return taskStore ? taskStore.getPlan() : '';
+}
+
+/** Internal helper — ensure store is initialized. */
+function requireStore() {
+  if (!taskStore) {
+    return '{"error":"Task store not initialized. Session may still be loading."}';
+  }
+  return null;
 }
 
 // ─── TaskCreate ─────────────────────────────────────────
@@ -30,6 +47,7 @@ export const taskCreate = defineTool({
   description: `Create a new task for tracking work progress.
 
 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.`,
   parameters: {
     type: 'object',
@@ -58,6 +76,9 @@ Use this to break down complex work into trackable items.`,
   isConcurrencySafe: () => false,
   isReadOnly: () => false,
   async execute(input, ctx) {
+    const err = requireStore();
+    if (err) return err;
+
     const { title, description, priority = 'medium', parent_id } = input;
     if (!title) return JSON.stringify({ error: 'title is required' });
 
@@ -73,7 +94,7 @@ Use this to break down complex work into trackable items.`,
       updatedAt: Date.now(),
     };
 
-    tasks.set(id, task);
+    taskStore.create(task);
 
     return JSON.stringify({
       success: true,
@@ -126,18 +147,21 @@ Status values: pending, in_progress, completed, blocked, cancelled`,
   isConcurrencySafe: () => false,
   isReadOnly: () => false,
   async execute(input, ctx) {
+    const err = requireStore();
+    if (err) return err;
+
     const { task_id, status, priority, title, description, result } = input;
     if (!task_id) return JSON.stringify({ error: 'task_id is required' });
 
-    const task = tasks.get(task_id);
-    if (!task) return JSON.stringify({ error: `Task not found: ${task_id}` });
+    const updates = {};
+    if (status) updates.status = status;
+    if (priority) updates.priority = priority;
+    if (title) updates.title = title;
+    if (description !== undefined) updates.description = description;
+    if (result) updates.result = result;
 
-    if (status) task.status = status;
-    if (priority) task.priority = priority;
-    if (title) task.title = title;
-    if (description !== undefined) task.description = description;
-    if (result) task.result = result;
-    task.updatedAt = Date.now();
+    const task = taskStore.update(task_id, updates);
+    if (!task) return JSON.stringify({ error: `Task not found: ${task_id}` });
 
     return JSON.stringify({
       success: true,
@@ -172,34 +196,37 @@ Shows task IDs, titles, status, and priority. Filter by status if needed.`,
   isConcurrencySafe: () => true,
   isReadOnly: () => true,
   async execute(input, ctx) {
+    const err = requireStore();
+    if (err) return err;
+
     const { status, include_completed = true } = input;
 
-    const taskList = [];
-    for (const [, task] of tasks) {
-      if (status && task.status !== status) continue;
-      if (!include_completed && task.status === 'completed') continue;
-      taskList.push({
-        id: task.id,
-        title: task.title,
-        status: task.status,
-        priority: task.priority,
-        parentId: task.parentId,
-        hasResult: !!task.result,
-      });
+    let results = taskStore.list(status ? { status } : undefined);
+    if (!include_completed) {
+      results = results.filter(t => t.status !== 'completed');
     }
 
+    const taskItems = results.map(t => ({
+      id: t.id,
+      title: t.title,
+      status: t.status,
+      priority: t.priority,
+      parentId: t.parentId,
+      hasResult: !!t.result,
+    }));
+
     // Sort: in_progress first, then pending, then others
     const ORDER = { in_progress: 0, pending: 1, blocked: 2, completed: 3, cancelled: 4 };
-    taskList.sort((a, b) => (ORDER[a.status] ?? 5) - (ORDER[b.status] ?? 5));
+    taskItems.sort((a, b) => (ORDER[a.status] ?? 5) - (ORDER[b.status] ?? 5));
 
     return JSON.stringify({
-      tasks: taskList,
-      totalCount: taskList.length,
+      tasks: taskItems,
+      totalCount: taskItems.length,
       summary: {
-        pending: taskList.filter(t => t.status === 'pending').length,
-        in_progress: taskList.filter(t => t.status === 'in_progress').length,
-        completed: taskList.filter(t => t.status === 'completed').length,
-        blocked: taskList.filter(t => t.status === 'blocked').length,
+        pending: taskItems.filter(t => t.status === 'pending').length,
+        in_progress: taskItems.filter(t => t.status === 'in_progress').length,
+        completed: taskItems.filter(t => t.status === 'completed').length,
+        blocked: taskItems.filter(t => t.status === 'blocked').length,
       },
     }, null, 2);
   },
@@ -209,7 +236,7 @@ Shows task IDs, titles, status, and priority. Filter by status if needed.`,
 
 export const taskGet = defineTool({
   name: 'TaskGet',
-  description: `Get detailed information about a specific task.`,
+  description: `Get detailed information about a specific task, including its progress log and memory.`,
   parameters: {
     type: 'object',
     properties: {
@@ -224,27 +251,141 @@ export const taskGet = defineTool({
   isConcurrencySafe: () => true,
   isReadOnly: () => true,
   async execute(input, ctx) {
+    const err = requireStore();
+    if (err) return err;
+
     const { task_id } = input;
     if (!task_id) return JSON.stringify({ error: 'task_id is required' });
 
-    const task = tasks.get(task_id);
+    const task = taskStore.get(task_id);
     if (!task) return JSON.stringify({ error: `Task not found: ${task_id}` });
 
     // Find subtasks
-    const subtasks = [];
-    for (const [, t] of tasks) {
-      if (t.parentId === task_id) {
-        subtasks.push({ id: t.id, title: t.title, status: t.status });
-      }
-    }
+    const allTasks = taskStore.list();
+    const subtasks = allTasks
+      .filter(t => t.parentId === task_id)
+      .map(t => ({ id: t.id, title: t.title, status: t.status }));
 
     return JSON.stringify({
       ...task,
       subtasks,
+      hasProgress: !!taskStore.getProgress(task_id),
+      hasMemory: !!taskStore.getMemory(task_id),
     }, null, 2);
   },
 });
 
+// ─── TaskProgress ───────────────────────────────────────
+
+export const taskProgress = defineTool({
+  name: 'TaskProgress',
+  description: `View or append to a task's progress log.
+
+The progress log is an append-only timeline of what happened during task execution.
+Use "view" to see the full log, or "append" to add a new entry.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      task_id: {
+        type: 'string',
+        description: 'Task ID',
+      },
+      action: {
+        type: 'string',
+        enum: ['view', 'append'],
+        description: '"view" shows progress log, "append" adds an entry',
+      },
+      note: {
+        type: 'string',
+        description: 'Progress note to append (required for "append")',
+      },
+    },
+    required: ['task_id', 'action'],
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => false,
+  isReadOnly: (input) => input?.action === 'view',
+  async execute(input, ctx) {
+    const err = requireStore();
+    if (err) return err;
+
+    const { task_id, action, note } = input;
+    if (!task_id) return JSON.stringify({ error: 'task_id is required' });
+
+    const task = taskStore.get(task_id);
+    if (!task) return JSON.stringify({ error: `Task not found: ${task_id}` });
+
+    switch (action) {
+      case 'view':
+        return taskStore.getProgress(task_id) || '(No progress entries yet)';
+
+      case 'append':
+        if (!note) return JSON.stringify({ error: 'note is required for "append"' });
+        taskStore.appendProgress(task_id, note, { status: task.status });
+        return JSON.stringify({ success: true, message: `Progress noted for "${task.title}"` });
+
+      default:
+        return JSON.stringify({ error: `Unknown action: ${action}` });
+    }
+  },
+});
+
+// ─── TaskMemory ─────────────────────────────────────────
+
+export const taskMemory = defineTool({
+  name: 'TaskMemory',
+  description: `View or update a task's memory (context notes, key decisions, references).
+
+Task memory stores persistent context relevant to the task — key decisions,
+references to files, architectural notes, etc. Unlike progress (append-only),
+memory can be rewritten to keep it current.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      task_id: {
+        type: 'string',
+        description: 'Task ID',
+      },
+      action: {
+        type: 'string',
+        enum: ['view', 'update'],
+        description: '"view" shows memory, "update" replaces it',
+      },
+      content: {
+        type: 'string',
+        description: 'New memory content (required for "update")',
+      },
+    },
+    required: ['task_id', 'action'],
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => false,
+  isReadOnly: (input) => input?.action === 'view',
+  async execute(input, ctx) {
+    const err = requireStore();
+    if (err) return err;
+
+    const { task_id, action, content } = input;
+    if (!task_id) return JSON.stringify({ error: 'task_id is required' });
+
+    const task = taskStore.get(task_id);
+    if (!task) return JSON.stringify({ error: `Task not found: ${task_id}` });
+
+    switch (action) {
+      case 'view':
+        return taskStore.getMemory(task_id) || '(No memory entries yet)';
+
+      case 'update':
+        if (!content) return JSON.stringify({ error: 'content is required for "update"' });
+        taskStore.updateMemory(task_id, content);
+        return JSON.stringify({ success: true, message: `Memory updated for "${task.title}"` });
+
+      default:
+        return JSON.stringify({ error: `Unknown action: ${action}` });
+    }
+  },
+});
+
 // ─── FollowupTask ───────────────────────────────────────
 
 export const followupTask = defineTool({
@@ -279,11 +420,14 @@ The new task is linked as a child of the original.`,
   isConcurrencySafe: () => false,
   isReadOnly: () => false,
   async execute(input, ctx) {
+    const err = requireStore();
+    if (err) return err;
+
     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 = tasks.get(parent_task_id);
+    const parent = taskStore.get(parent_task_id);
     if (!parent) return JSON.stringify({ error: `Parent task not found: ${parent_task_id}` });
 
     const id = `task-${randomUUID().slice(0, 8)}`;
@@ -298,7 +442,7 @@ The new task is linked as a child of the original.`,
       updatedAt: Date.now(),
     };
 
-    tasks.set(id, task);
+    taskStore.create(task);
 
     return JSON.stringify({
       success: true,
@@ -335,21 +479,27 @@ approach, steps, and status of the current work.`,
   isConcurrencySafe: () => false,
   isReadOnly: (input) => input?.action === 'view',
   async execute(input, ctx) {
+    const err = requireStore();
+    if (err) return err;
+
     const { action, content } = input;
 
     switch (action) {
       case 'view':
-        return currentPlan || '(No plan set yet)';
+        return taskStore.getPlan() || '(No plan set yet)';
 
       case 'update':
         if (!content) return JSON.stringify({ error: 'content is required for "update"' });
-        currentPlan = content;
+        taskStore.setPlan(content);
         return JSON.stringify({ success: true, message: 'Plan updated', length: content.length });
 
-      case 'append':
+      case 'append': {
         if (!content) return JSON.stringify({ error: 'content is required for "append"' });
-        currentPlan = currentPlan ? `${currentPlan}\n\n${content}` : content;
-        return JSON.stringify({ success: true, message: 'Plan updated (appended)', length: currentPlan.length });
+        const existing = taskStore.getPlan();
+        const newPlan = existing ? `${existing}\n\n${content}` : content;
+        taskStore.setPlan(newPlan);
+        return JSON.stringify({ success: true, message: 'Plan updated (appended)', length: newPlan.length });
+      }
 
       default:
         return JSON.stringify({ error: `Unknown action: ${action}` });

package/unify/web-bridge.js

@@ -103,6 +103,12 @@ export async function handleUnifyChat(msg) {
       // Create a stable conversationId for the Unify session
       unifyConversationId = `unify-${Date.now()}`;
 
+      // Restore conversationMessages from persisted history for LLM context
+      const recent = session.conversationStore.loadRecent(50);
+      conversationMessages = recent
+        .filter(m => m.role === 'user' || m.role === 'assistant')
+        .map(m => ({ role: m.role, content: m.content }));
+
       // Notify UI: session is ready with model info + conversationId
       sendUnifyEvent({
         type: 'session_ready',
@@ -433,6 +439,69 @@ export function handleUnifyModelSwitch(msg) {
   });
 }
 
+/**
+ * Handle history load request from the web UI.
+ * Loads recent messages from ConversationStore and sends them through
+ * the standard claude_output rendering pipeline (sendUnifyOutput).
+ *
+ * @param {{ limit?: number }} msg
+ */
+export async function handleUnifyLoadHistory(msg) {
+  // Lazy-init session if needed (same logic as handleUnifyChat)
+  if (!session) {
+    const yeaftDir = ctx.CONFIG?.yeaftDir;
+    session = await loadSession({
+      ...(yeaftDir && { dir: yeaftDir }),
+      skipMCP: false,
+      skipSkills: false,
+    });
+
+    unifyConversationId = `unify-${Date.now()}`;
+
+    // Restore conversationMessages from persisted history for LLM context
+    const recent = session.conversationStore.loadRecent(50);
+    conversationMessages = recent
+      .filter(m => m.role === 'user' || m.role === 'assistant')
+      .map(m => ({ role: m.role, content: m.content }));
+
+    sendUnifyEvent({
+      type: 'session_ready',
+      conversationId: unifyConversationId,
+      model: session.config.model,
+      availableModels: session.config.availableModels || [],
+      skills: session.status.skills,
+      mcpServers: session.status.mcpServers,
+      tools: session.status.tools,
+    });
+  }
+
+  const limit = msg.limit || 50;
+  const messages = session.conversationStore.loadRecent(limit);
+  const compactSummary = session.conversationStore.readCompactSummary();
+
+  // Send each message through standard claude_output rendering pipeline
+  for (const m of messages) {
+    if (m.role === 'user') {
+      sendUnifyOutput({ type: 'user', message: { content: m.content } });
+    } else if (m.role === 'assistant') {
+      sendUnifyOutput({
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: m.content }] },
+      });
+      sendUnifyOutput({ type: 'result', result_text: '' });
+    }
+  }
+
+  // Signal history loading complete
+  sendUnifyEvent({
+    type: 'history_loaded',
+    count: messages.length,
+    hasCompactSummary: !!compactSummary,
+    totalHot: session.conversationStore.countHot(),
+    totalCold: session.conversationStore.countCold(),
+  });
+}
+
 /**
  * Reset Unify session (for clear messages).
  */