@yeaft/webchat-agent 0.1.510 → 0.1.512

package/unify/tools/js-repl.js

@@ -3,6 +3,11 @@
  *
  * Runs JavaScript code in a persistent VM context, allowing
  * state to be maintained across calls.
+ *
+ * task-333b: merged the former `JsReplReset` tool into this one as a
+ * `reset: true` parameter. A single tool with a reset flag eliminates a
+ * duplicate schema entry in the function-call catalogue. The old
+ * JsReplReset name is kept below as a deprecated alias for one release.
  */
 
 import { defineTool } from './types.js';
@@ -55,7 +60,9 @@ defined in one call are available in subsequent calls.
 
 Guidelines:
 - Use for calculations, data transformations, and quick experiments
-- State is preserved between calls (use JsReplReset to clear)
+- State is preserved between calls
+- Pass \`reset: true\` to wipe all state before evaluating (clean slate).
+  \`code\` becomes optional in this mode — pass reset alone to just clear.
 - console.log output is captured and returned
 - Returns the last expression's value plus any console output
 - No filesystem or network access from within the REPL`,
@@ -64,16 +71,27 @@ Guidelines:
     properties: {
       code: {
         type: 'string',
-        description: 'JavaScript code to evaluate',
+        description: 'JavaScript code to evaluate. Optional when reset=true and you only want to clear state.',
+      },
+      reset: {
+        type: 'boolean',
+        description: 'When true, reset the REPL context BEFORE evaluating `code`. If `code` is omitted, just resets.',
       },
     },
-    required: ['code'],
   },
   isConcurrencySafe: () => false,
   isReadOnly: () => true,
   async execute(input, ctx) {
-    const { code } = input;
-    if (!code) return JSON.stringify({ error: 'code is required' });
+    const { code, reset } = input || {};
+
+    if (reset) {
+      vmContext = null;
+      if (!code) {
+        return JSON.stringify({ success: true, message: 'REPL context reset' });
+      }
+    }
+
+    if (!code) return JSON.stringify({ error: 'code is required (or pass reset=true to clear state)' });
 
     const vmCtx = getContext();
 
@@ -87,6 +105,7 @@ Guidelines:
       const resultStr = result === undefined ? '' : String(result);
 
       const parts = [];
+      if (reset) parts.push('(REPL context reset)');
       if (output.length > 0) parts.push(output.join('\n'));
       if (resultStr) parts.push(`→ ${resultStr}`);
 
@@ -101,20 +120,28 @@ Guidelines:
   },
 });
 
+/**
+ * Deprecated alias — `JsReplReset`. task-333b merged reset behaviour into
+ * `JsRepl` via `reset: true`. Kept registered for one release so older
+ * prompts / saved tool calls still resolve. Emits a one-time deprecation
+ * warning on first invocation, then delegates to jsRepl.execute with reset.
+ */
+const _jsReplResetWarned = { v: false };
+function warnJsReplResetDeprecated() {
+  if (_jsReplResetWarned.v) return;
+  _jsReplResetWarned.v = true;
+  // eslint-disable-next-line no-console
+  console.warn('[deprecated] JsReplReset → JsRepl. Call JsRepl with { reset: true } to clear REPL state.');
+}
+
 export const jsReplReset = defineTool({
   name: 'JsReplReset',
-  description: `Reset the JavaScript REPL environment.
-
-Clears all variables and state from previous evaluations.
-Use when you want a clean slate.`,
-  parameters: {
-    type: 'object',
-    properties: {},
-  },
+  description: 'DEPRECATED — use JsRepl with `reset: true` instead. Resets the persistent REPL context. Removal target: v0.2.0.',
+  parameters: { type: 'object', properties: {} },
   isConcurrencySafe: () => false,
   isReadOnly: () => false,
   async execute(input, ctx) {
-    vmContext = null;
-    return JSON.stringify({ success: true, message: 'REPL context reset' });
+    warnJsReplResetDeprecated();
+    return jsRepl.execute({ reset: true }, ctx);
   },
 });

package/unify/tools/memory-query.js

@@ -10,7 +10,9 @@
  *   3. Returns a compact list suitable for LLM consumption
  *
  * Use this for fuzzy discovery over atomic entries. For loading a known
- * classification file in full, use `memory_search` instead.
+ * classification file in full, use `memory_load` instead (renamed from
+ * the old `memory_search` in task-333b; the old name still works as a
+ * deprecated alias for one release).
  */
 
 import { defineTool } from './types.js';

package/unify/tools/memory-search.js

@@ -1,7 +1,12 @@
 /**
- * memory-search.js — Load memory classification files by path.
+ * memory-search.js → memory_load (task-333b rename).
  *
- * New-layout tool (task-287 memory refactor).
+ * This tool loads memory classification files by path (it is NOT a search).
+ * task-333b renamed it from `memory_search` → `memory_load` so the name
+ * actually reflects behaviour; `memory_query` remains the fuzzy search tool.
+ *
+ * Backwards compatibility: a thin alias tool named `memory_search` is also
+ * exported (see bottom of file) so older transcripts/prompts still resolve.
  *
  * The system prompt injects `index.md` every turn, which lists all available
  * classification files under `~/.yeaft/memory/` (single files + by-project /
@@ -9,9 +14,6 @@
  * it calls this tool with `paths: [...]` to load one or more of those files
  * in full.
  *
- * This is NOT a fuzzy search. It is a precise file loader. Use `memory_query`
- * for fuzzy search over atomic entries.
- *
  * Only paths under `memory/` are accepted. `..` segments are rejected.
  */
 
@@ -21,9 +23,7 @@ import { readMemoryFile, listClassificationFiles } from '../memory/layout.js';
 const MAX_FILES_PER_CALL = 5;
 const MAX_BYTES_PER_FILE = 32000;
 
-export default defineTool({
-  name: 'memory_search',
-  description: `Load one or more memory classification files in full.
+const DESCRIPTION = `Load one or more memory classification files in full.
 
 Paths are relative to ~/.yeaft/memory/. Allowed targets:
   - user-preferences.md           — merged user preferences
@@ -36,66 +36,105 @@ of available files. Use this tool when the index suggests a file is relevant
 to the user's current request. For fuzzy search over atomic memory entries
 (facts, lessons, preferences), use the memory_query tool instead.
 
-Up to ${MAX_FILES_PER_CALL} files per call. Each file is capped at ${MAX_BYTES_PER_FILE} bytes.`,
-  parameters: {
-    type: 'object',
-    properties: {
-      paths: {
-        type: 'array',
-        items: { type: 'string' },
-        description: 'Relative paths under memory/. Example: ["by-project/claude-web-chat.md", "user-preferences.md"]',
-      },
+Up to ${MAX_FILES_PER_CALL} files per call. Each file is capped at ${MAX_BYTES_PER_FILE} bytes.`;
+
+const PARAMETERS = {
+  type: 'object',
+  properties: {
+    paths: {
+      type: 'array',
+      items: { type: 'string' },
+      description: 'Relative paths under memory/. Example: ["by-project/claude-web-chat.md", "user-preferences.md"]',
     },
-    required: ['paths'],
   },
-  isConcurrencySafe: () => true,
-  isReadOnly: () => true,
-  async execute(input, ctx) {
-    const yeaftDir = ctx?.yeaftDir;
-    if (!yeaftDir) {
-      return JSON.stringify({ error: 'Memory system not initialized (no yeaftDir in context)' });
-    }
+  required: ['paths'],
+};
 
-    const paths = Array.isArray(input?.paths) ? input.paths : [];
-    if (paths.length === 0) {
-      return JSON.stringify({
-        error: 'paths is required and must be a non-empty string array',
-        availablePaths: listClassificationFiles(yeaftDir).map(f => f.path),
-      });
+async function executeLoad(input, ctx) {
+  const yeaftDir = ctx?.yeaftDir;
+  if (!yeaftDir) {
+    return JSON.stringify({ error: 'Memory system not initialized (no yeaftDir in context)' });
+  }
+
+  const paths = Array.isArray(input?.paths) ? input.paths : [];
+  if (paths.length === 0) {
+    return JSON.stringify({
+      error: 'paths is required and must be a non-empty string array',
+      availablePaths: listClassificationFiles(yeaftDir).map(f => f.path),
+    });
+  }
+
+  const results = [];
+  const errors = [];
+
+  for (const rel of paths.slice(0, MAX_FILES_PER_CALL)) {
+    if (typeof rel !== 'string' || !rel.trim()) {
+      errors.push({ path: rel, error: 'not a non-empty string' });
+      continue;
+    }
+    if (rel.includes('..') || rel.startsWith('/')) {
+      errors.push({ path: rel, error: 'path must be relative and must not contain ..' });
+      continue;
+    }
+    if (!rel.endsWith('.md')) {
+      errors.push({ path: rel, error: 'only .md files are supported' });
+      continue;
     }
 
-    const results = [];
-    const errors = [];
-
-    for (const rel of paths.slice(0, MAX_FILES_PER_CALL)) {
-      if (typeof rel !== 'string' || !rel.trim()) {
-        errors.push({ path: rel, error: 'not a non-empty string' });
-        continue;
-      }
-      if (rel.includes('..') || rel.startsWith('/')) {
-        errors.push({ path: rel, error: 'path must be relative and must not contain ..' });
-        continue;
-      }
-      if (!rel.endsWith('.md')) {
-        errors.push({ path: rel, error: 'only .md files are supported' });
-        continue;
-      }
-
-      const text = readMemoryFile(yeaftDir, rel);
-      if (!text) {
-        errors.push({ path: rel, error: 'file not found or empty' });
-        continue;
-      }
-
-      const truncated = text.length > MAX_BYTES_PER_FILE;
-      results.push({
-        path: rel,
-        content: truncated ? text.slice(0, MAX_BYTES_PER_FILE) : text,
-        truncated,
-        size: text.length,
-      });
+    const text = readMemoryFile(yeaftDir, rel);
+    if (!text) {
+      errors.push({ path: rel, error: 'file not found or empty' });
+      continue;
     }
 
-    return JSON.stringify({ results, errors }, null, 2);
-  },
+    const truncated = text.length > MAX_BYTES_PER_FILE;
+    results.push({
+      path: rel,
+      content: truncated ? text.slice(0, MAX_BYTES_PER_FILE) : text,
+      truncated,
+      size: text.length,
+    });
+  }
+
+  return JSON.stringify({ results, errors }, null, 2);
+}
+
+/**
+ * Canonical tool — `memory_load`. This is the default export so existing
+ * import sites (`import memorySearch from './memory-search.js'`) keep
+ * working; the renamed identity is expressed via the tool's `name`.
+ */
+const memoryLoad = defineTool({
+  name: 'memory_load',
+  description: DESCRIPTION,
+  parameters: PARAMETERS,
+  isConcurrencySafe: () => true,
+  isReadOnly: () => true,
+  execute: executeLoad,
+});
+
+/**
+ * Deprecated alias — `memory_search`. Kept so older prompts / saved tool
+ * calls still resolve. Delegates to the same executor. Do not use for new
+ * call sites. Emits a one-time console.warn on first invocation.
+ */
+const _memSearchWarned = { v: false };
+async function executeLoadWithWarn(input, ctx) {
+  if (!_memSearchWarned.v) {
+    _memSearchWarned.v = true;
+    // eslint-disable-next-line no-console
+    console.warn('[deprecated] memory_search → memory_load. Use memory_load for path-based file loading; use memory_query for fuzzy keyword search.');
+  }
+  return executeLoad(input, ctx);
+}
+
+export const memorySearchAlias = defineTool({
+  name: 'memory_search',
+  description: 'DEPRECATED — use memory_load. Same params. Removal target: v0.2.0.',
+  parameters: PARAMETERS,
+  isConcurrencySafe: () => true,
+  isReadOnly: () => true,
+  execute: executeLoadWithWarn,
 });
+
+export default memoryLoad;

package/unify/tools/task-tools.js

@@ -48,7 +48,9 @@ export const taskCreate = defineTool({
 
 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.`,
+Use this to break down complex work into trackable items.
+
+Pass \`parent_id\` to create a subtask under an existing task.`,
   parameters: {
     type: 'object',
     properties: {
@@ -69,6 +71,10 @@ Use this to break down complex work into trackable items.`,
         type: 'string',
         description: 'Parent task ID for subtasks',
       },
+      // Note (task-333b): `parent_task_id` is accepted by execute() as a
+      // soft-compat alias for `parent_id` (absorbed from the former
+      // SpawnTask tool) but intentionally NOT advertised in the schema to
+      // avoid giving the LLM two live params for one field.
     },
     required: ['title'],
   },
@@ -78,9 +84,17 @@ Use this to break down complex work into trackable items.`,
     const err = requireStore();
     if (err) return err;
 
-    const { title, description, priority = 'medium', parent_id } = input;
+    const { title, description, priority = 'medium', parent_id, parent_task_id } = input;
     if (!title) return JSON.stringify({ error: 'title is required' });
 
+    // task-333b: accept either `parent_id` (original TaskCreate field) or
+    // `parent_task_id` (the former SpawnTask field). When both are present,
+    // parent_id wins.
+    const parentId = parent_id || parent_task_id || null;
+    if (parentId && !taskStore.get(parentId)) {
+      return JSON.stringify({ error: `Parent task not found: ${parentId}` });
+    }
+
     const id = `task-${randomUUID().slice(0, 8)}`;
     const task = {
       id,
@@ -88,7 +102,8 @@ Use this to break down complex work into trackable items.`,
       description: description || '',
       priority,
       status: 'pending',
-      parentId: parent_id || null,
+      parentId,
+      parentTaskId: parentId, // design §5 canonical field
       createdAt: Date.now(),
       updatedAt: Date.now(),
     };
@@ -97,8 +112,10 @@ Use this to break down complex work into trackable items.`,
 
     return JSON.stringify({
       success: true,
-      task: { id, title, priority, status: 'pending' },
-      message: `Task created: ${title} (${id})`,
+      task: { id, title, priority, status: 'pending', parentTaskId: parentId },
+      message: parentId
+        ? `Subtask created: ${title} (${id}) under ${parentId}`
+        : `Task created: ${title} (${id})`,
     });
   },
 });

package/unify/tools/thread-tools.js

@@ -193,20 +193,24 @@ the same thread.`,
   },
 });
 
-// ─── SpawnTask (merged — subtask via parent_task_id) ────
+// ─── SpawnTask (deprecated alias — task-333b) ──────────────
+//
+// task-333b folded SpawnTask into TaskCreate (see task-tools.js). Kept
+// registered for one release as a deprecated alias per PM constraint:
+// LLM calls still resolve, but a one-time console.warn nudges migration.
+// Prefer TaskCreate with `parent_task_id` for all new call sites.
+
+const _spawnTaskWarned = { v: false };
+function warnSpawnTaskDeprecated() {
+  if (_spawnTaskWarned.v) return;
+  _spawnTaskWarned.v = true;
+  // eslint-disable-next-line no-console
+  console.warn('[deprecated] SpawnTask → TaskCreate. Pass parent_task_id to TaskCreate for subtasks.');
+}
 
-/**
- * SpawnTask replaces both the old SpawnTask and the separate SpawnSubtask:
- * pass `parent_task_id` when you want a subtask, omit it for top-level.
- * Per prev-1 rework note: eliminating two tools with the same effect.
- */
 export const spawnTask = defineTool({
   name: 'SpawnTask',
-  description: `Spawn a new task. Pass parent_task_id to create a subtask.
-
-When parent_task_id is omitted → top-level task.
-When parent_task_id is provided → subtask under that parent (parent must exist).
-This replaces the deprecated SpawnSubtask tool.`,
+  description: `DEPRECATED — use TaskCreate with parent_id instead. Retained as a thin alias for backwards compatibility; delegates to the same task store. When parent_task_id is omitted this behaves like TaskCreate; when provided it creates a subtask under that parent (parent must exist). Removal target: v0.2.0.`,
   parameters: {
     type: 'object',
     properties: {
@@ -226,6 +230,7 @@ This replaces the deprecated SpawnSubtask tool.`,
   isConcurrencySafe: () => false,
   isReadOnly: () => false,
   async execute(input) {
+    warnSpawnTaskDeprecated();
     const store = getTaskStore();
     if (!store) {
       return JSON.stringify({ error: 'Task store not initialized. Session may still be loading.' });