@causyne/agent 1.10.17 → 1.10.18

package/src/tools/updatePlan.js

@@ -1,88 +1,41 @@
-import fs from 'fs';
-import path from 'path';
-
+import { normalizePlanUpdate, summarizePlan } from '../implementationPlan.js';
 export const updatePlan = {
-  schema: {
-    name: 'update_plan',
-    description: 'Self-Correcting Trajectory Engine: Update specific tasks in your plan using delta operations without rewriting everything.',
-    parameters: {
-      type: 'object',
-      properties: {
-        action: {
-          type: 'string',
-          enum: ['read', 'ADD_TASK', 'REMOVE_TASK', 'MARK_COMPLETED', 'MARK_FAILED']
-        },
-        taskId: { type: 'string', description: 'ID of the task to modify' },
-        taskContent: { type: 'string', description: 'Content of the new task (if ADD_TASK)' },
-        failureReason: { type: 'string', description: 'REQUIRED if action is MARK_FAILED' }
-      },
-      required: ['action']
-    }
-  },
-  
-  execute: async (args) => {
-    try {
-      const todoPath = path.resolve(process.cwd(), '.causyne_todos.json');
-      const mdPath = path.resolve(process.cwd(), 'AGI_PLAN.md');
-      
-      let todos = [];
-      if (fs.existsSync(todoPath)) {
-        todos = JSON.parse(fs.readFileSync(todoPath, 'utf8'));
-      }
-      
-      if (args.action === 'read') {
-        if (!fs.existsSync(mdPath)) return "No plan exists.";
-        return fs.readFileSync(mdPath, 'utf8');
-      }
-      
-      if (args.action === 'MARK_FAILED' && !args.failureReason) {
-        return "Error: You MUST provide a failureReason when marking a task as failed.";
-      }
-
-      if (args.action === 'ADD_TASK') {
-        if (!args.taskId || !args.taskContent) return "Missing taskId or taskContent";
-        todos.push({ id: args.taskId, content: args.taskContent, status: 'pending' });
-      } 
-      else if (args.action === 'REMOVE_TASK') {
-        todos = todos.filter(t => t.id !== args.taskId);
-      }
-      else if (args.action === 'MARK_COMPLETED') {
-        const t = todos.find(t => t.id === args.taskId);
-        if (t) t.status = 'completed';
-      }
-      else if (args.action === 'MARK_FAILED') {
-        const t = todos.find(t => t.id === args.taskId);
-        if (t) {
-          t.status = 'pending'; // Reset it
-          // Phase 2 AGI Upgrade: Auto-Pivot
-          todos.push({ 
-            id: `investigate_${args.taskId}`, 
-            content: `Investigate failure of ${args.taskId}: ${args.failureReason}`, 
-            status: 'in_progress' 
-          });
+    schema: {
+        name: 'update_plan',
+        description: 'Create or replace the visible implementation checklist. Use it before complex implementation and update statuses as work advances. Keep exactly one step in_progress.',
+        parameters: {
+            type: 'object',
+            properties: {
+                explanation: { type: 'string', description: 'Short reason for this plan update.' },
+                plan: {
+                    type: 'array', minItems: 1, maxItems: 24,
+                    items: {
+                        type: 'object',
+                        properties: {
+                            id: { type: 'string' },
+                            step: { type: 'string', description: 'Atomic, verifiable implementation step.' },
+                            status: { type: 'string', enum: ['pending', 'in_progress', 'completed'] }
+                        },
+                        required: ['id', 'step', 'status'],
+                        additionalProperties: false
+                    }
+                }
+            },
+            required: ['plan'],
+            additionalProperties: false
+        }
+    },
+    async execute(args, context = {}) {
+        try {
+            if (!context.parentLoop || typeof context.parentLoop.updateImplementationPlan !== 'function') {
+                return { success: false, error: 'Implementation plans require an active Causyne session' };
+            }
+            const update = normalizePlanUpdate(args);
+            context.parentLoop.updateImplementationPlan(update);
+            return { success: true, output: summarizePlan(update.plan), plan: update.plan };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : String(error) };
         }
-      }
-
-      // Sync JSON
-      fs.writeFileSync(todoPath, JSON.stringify(todos, null, 2), 'utf8');
-      
-      // Sync MD
-      let mdContent = '# AGI Execution Plan\n\n';
-      for (const t of todos) {
-        let box = '[ ]';
-        if (t.status === 'in_progress') box = '[/]';
-        if (t.status === 'completed') box = '[x]';
-        mdContent += `- ${box} ${t.id}: ${t.content}\n`;
-      }
-      fs.writeFileSync(mdPath, mdContent, 'utf8');
-      
-      if (args.action === 'MARK_FAILED') {
-        return `Task failed. Auto-pivot engaged. Added investigation task.`;
-      }
-
-      return "Plan delta updated successfully.";
-    } catch (error) {
-      return `Error updating plan: ${error.message}`;
     }
-  }
 };

package/src/tools/updatePlan.ts

@@ -0,0 +1,48 @@
+import { normalizePlanUpdate, summarizePlan, type PlanUpdate } from '../implementationPlan.js';
+
+interface ToolContext {
+  parentLoop?: {
+    updateImplementationPlan(update: PlanUpdate): void;
+  };
+}
+
+export const updatePlan = {
+  schema: {
+    name: 'update_plan',
+    description: 'Create or replace the visible implementation checklist. Use it before complex implementation and update statuses as work advances. Keep exactly one step in_progress.',
+    parameters: {
+      type: 'object',
+      properties: {
+        explanation: { type: 'string', description: 'Short reason for this plan update.' },
+        plan: {
+          type: 'array', minItems: 1, maxItems: 24,
+          items: {
+            type: 'object',
+            properties: {
+              id: { type: 'string' },
+              step: { type: 'string', description: 'Atomic, verifiable implementation step.' },
+              status: { type: 'string', enum: ['pending', 'in_progress', 'completed'] }
+            },
+            required: ['id', 'step', 'status'],
+            additionalProperties: false
+          }
+        }
+      },
+      required: ['plan'],
+      additionalProperties: false
+    }
+  },
+
+  async execute(args: unknown, context: ToolContext = {}) {
+    try {
+      if (!context.parentLoop || typeof context.parentLoop.updateImplementationPlan !== 'function') {
+        return { success: false, error: 'Implementation plans require an active Causyne session' };
+      }
+      const update = normalizePlanUpdate(args);
+      context.parentLoop.updateImplementationPlan(update);
+      return { success: true, output: summarizePlan(update.plan), plan: update.plan };
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+  }
+};

package/src/tools/webFetch.js

@@ -144,7 +144,7 @@ export const webFetch = {
             if (!response.ok && !args.outputFile && contentType.includes('text/html') && [401, 403, 429, 503].includes(response.status)) {
                 const fallback = await browserFallback(finalUrl.href);
                 if (fallback.success)
-                    return { ...fallback, status: response.status, finalUrl: finalUrl.href, via: 'camoufox' };
+                    return { ...fallback, status: response.status, finalUrl: finalUrl.href, via: 'causyne-browser' };
                 return { success: false, error: `HTTP ${response.status}; browser fallback failed: ${fallback.error}`, requiresConsent: fallback.requiresConsent };
             }
             if (!response.ok)

package/src/tools/webFetch.ts

@@ -142,7 +142,7 @@ export const webFetch = {
 
       if (!response.ok && !args.outputFile && contentType.includes('text/html') && [401, 403, 429, 503].includes(response.status)) {
         const fallback = await browserFallback(finalUrl.href);
-        if (fallback.success) return { ...fallback, status: response.status, finalUrl: finalUrl.href, via: 'camoufox' };
+        if (fallback.success) return { ...fallback, status: response.status, finalUrl: finalUrl.href, via: 'causyne-browser' };
         return { success: false, error: `HTTP ${response.status}; browser fallback failed: ${fallback.error}`, requiresConsent: fallback.requiresConsent };
       }
       if (!response.ok) return { success: false, error: `HTTP ${response.status} ${response.statusText}`.trim(), status: response.status, finalUrl: finalUrl.href };

package/src/tools/webSearch.js

@@ -14,7 +14,7 @@ function renderResults(query, results) {
 export const webSearch = {
     schema: {
         name: 'web_search',
-        description: 'Search the public web through lightweight providers, with the optional Causyne Camoufox browser as a rendered-page fallback. No browser binary is downloaded automatically.',
+        description: 'Search the public web through lightweight providers, with the optional Causyne Browser as a rendered-page fallback. No browser binary is downloaded automatically.',
         parameters: {
             type: 'object',
             properties: {

package/src/tools/webSearch.ts

@@ -15,7 +15,7 @@ function renderResults(query: string, results: SearchResult[]): string {
 export const webSearch = {
   schema: {
     name: 'web_search',
-    description: 'Search the public web through lightweight providers, with the optional Causyne Camoufox browser as a rendered-page fallback. No browser binary is downloaded automatically.',
+    description: 'Search the public web through lightweight providers, with the optional Causyne Browser as a rendered-page fallback. No browser binary is downloaded automatically.',
     parameters: {
       type: 'object',
       properties: {

package/src/tui/ask.js

@@ -25,7 +25,7 @@
 
 import readline from 'readline';
 import { ChatPrompt, isInteractive } from './prompt.js';
-import { SelectLayer, InputLayer, ConfirmLayer } from './dialogs.js';
+import { SelectLayer, InputLayer, ConfirmLayer, DecisionLayer } from './dialogs.js';
 
 /**
  * Run one layer on a temporary prompt host.
@@ -162,3 +162,43 @@ export async function askConfirm(message) {
   const raw = await fallbackQuestion(`${message} [y/N]`);
   return /^y(es)?$/i.test(String(raw).trim());
 }
+
+/**
+ * Ask for a durable product or architecture choice.
+ *
+ * This remains separate from permissions: choosing an implementation direction
+ * never grants a tool the right to mutate files or execute a command.
+ */
+export async function askDecision(request = {}) {
+  const options = Array.isArray(request.options) ? request.options : [];
+
+  if (canAskInPanel()) {
+    const answer = await hostOneLayer((resolve) => new DecisionLayer({
+      request,
+      onAnswer: resolve
+    }));
+    if (answer !== undefined) return answer;
+  }
+
+  const custom = { id: '__custom__', label: 'Type your own answer', description: '' };
+  const selected = await askSelect({
+    title: request.header || 'Decision required',
+    items: [...options, custom]
+  });
+  if (!selected) return null;
+  if (selected.id === custom.id) {
+    const label = await askText({
+      title: request.question || 'Describe the direction you want',
+      lines: request.reason ? [request.reason] : [],
+      validate: (value) => String(value).trim() ? null : 'An answer is required.'
+    });
+    if (!label) return null;
+    return { requestId: request.id, optionId: null, label: String(label).trim(), custom: true };
+  }
+  return {
+    requestId: request.id,
+    optionId: selected.id,
+    label: selected.label,
+    custom: false
+  };
+}

package/src/tui/chatRenderer.js

@@ -211,6 +211,7 @@ export class ChatRenderer {
     this.spinnerIndex = 0;
     this.currentStatus = '';
     this.pendingApprovals = new Map();
+    this.latestPlan = [];
     this.status = new StatusLine();
     this.turnStartedAt = null;
 
@@ -548,9 +549,34 @@ export class ChatRenderer {
   onAgentPlan(msg) {
     if (!Array.isArray(msg.plan) || msg.plan.length === 0) return;
     const plan = msg.plan.slice();
+    this.latestPlan = plan;
+    if (this.onPlanChange) this.onPlanChange(plan);
     this.frame('plan', () => this.renderPlan(plan), { items: plan.length });
   }
 
+  onDecisionRequest(msg) {
+    if (this.dialogWillAsk) return;
+    const request = msg.request || {};
+    this.frame('approval', () => {
+      this.write();
+      this.write(`${paint('accent', GLYPHS.arrow)} ${bold(safeDisplay(request.header || 'decision required'))}`);
+      for (const row of wrapBlock(safeDisplay(request.question || ''), Math.max(20, this.width() - 4))) this.write(`  ${row}`);
+      this.write();
+    }, { kind: request.kind || 'other' });
+  }
+
+  onDecisionResult(msg) {
+    const request = msg.request || {};
+    const answer = msg.answer;
+    this.frame('approval', () => {
+      if (!answer) {
+        this.write(`  ${paint('muted', 'decision dismissed')}  ${safeDisplay(request.header || '')}`);
+        return;
+      }
+      this.write(`  ${paint('success', GLYPHS.check)} ${bold(safeDisplay(answer.label || ''))}${answer.custom ? dim('  custom choice') : ''}`);
+    }, { kind: request.kind || 'other', answered: Boolean(answer) });
+  }
+
   renderPlan(plan) {
     const width = this.width();
     this.write();
@@ -940,6 +966,8 @@ export class ChatRenderer {
       case 'step_error':       this.onStepError(msg); return true;
       case 'checkpoint':       this.onCheckpoint(msg); return true;
       case 'approval_request': this.onApprovalRequest(msg); return true;
+      case 'decision_request': this.onDecisionRequest(msg); return true;
+      case 'decision_result':  this.onDecisionResult(msg); return true;
       case 'error':            this.onError(msg); return true;
       case 'budget_warning':   this.onBudgetWarning(msg); return true;
       case 'notice':           this.onNotice(msg); return true;

package/src/tui/dialogs.js

@@ -489,6 +489,97 @@ export class ApprovalLayer extends Layer {
   }
 }
 
+/** A structured product or architecture choice, separate from permissions. */
+export class DecisionLayer extends Layer {
+  constructor(options = {}) {
+    super({ width: options.width || 82, height: options.height || 24, ...options });
+    this.request = options.request || {};
+    this.onAnswer = options.onAnswer || null;
+    this.options = Array.isArray(this.request.options) ? this.request.options.slice(0, 4) : [];
+    this.selected = 0;
+    this.customIndex = this.options.length;
+    this.customMode = false;
+    this.editor = new LineEditor();
+    this.answered = false;
+    this.title = safeDisplay(this.request.header || 'decision required');
+    this.footer = `↑↓ choose  ${GLYPHS.dot}  enter select  ${GLYPHS.dot}  esc cancel`;
+  }
+
+  preferredHeight() {
+    const questionRows = wrap(safeDisplay(this.request.question || ''), Math.max(20, this.width - 6)).length;
+    const reasonRows = wrap(safeDisplay(this.request.reason || ''), Math.max(20, this.width - 6)).length;
+    return Math.min(this.height, questionRows + reasonRows + (this.options.length * 2) + 7);
+  }
+
+  body(width, height) {
+    const rows = [];
+    rows.push(...wrap(bold(safeDisplay(this.request.question || 'Choose a direction')), width).slice(0, 4));
+    if (this.request.reason) rows.push(...wrap(dim(safeDisplay(this.request.reason)), width).slice(0, 3));
+    rows.push('');
+
+    for (const [index, option] of this.options.entries()) {
+      const selected = index === this.selected;
+      const marker = selected ? paint('accent', GLYPHS.arrow) : paint('muted', GLYPHS.dot);
+      rows.push(`${marker} ${selected ? bold(safeDisplay(option.label || '')) : safeDisplay(option.label || '')}`);
+      if (option.description) rows.push(`  ${dim(truncate(safeDisplay(option.description), Math.max(1, width - 2), GLYPHS.ellipsis))}`);
+    }
+
+    const customSelected = this.selected === this.customIndex;
+    rows.push(`${customSelected ? paint('accent', GLYPHS.arrow) : paint('muted', GLYPHS.dot)} ${customSelected ? bold('Type your own answer') : 'Type your own answer'}`);
+    if (this.customMode) {
+      const value = this.editor.getText();
+      rows.push(`${paint('accent', `${GLYPHS.arrow} `)}${value || dim('Describe the direction you want')}`);
+      this.cursor = { x: 2 + visibleWidth(value.slice(0, this.editor.col)), y: rows.length - 1 };
+      this.footer = `enter submit  ${GLYPHS.dot}  esc choices`;
+    } else {
+      this.cursor = null;
+      this.footer = `↑↓ choose  ${GLYPHS.dot}  enter select  ${GLYPHS.dot}  esc cancel`;
+    }
+    return rows.slice(0, height);
+  }
+
+  key(event) {
+    if (!event) return null;
+    if (this.customMode) {
+      if (event.name === 'escape') { this.customMode = false; return 'handled'; }
+      if (event.name === 'enter' || event.name === 'return') {
+        const label = this.editor.getText().replace(/\s+/g, ' ').trim();
+        if (!label) return 'handled';
+        this.answer({ requestId: this.request.id, optionId: null, label, custom: true });
+        return 'close';
+      }
+      if (event.name === 'backspace') { this.editor.backspace(); return 'handled'; }
+      if (event.name === 'delete') { this.editor.deleteForward(); return 'handled'; }
+      if (event.name === 'left') { this.editor.moveLeft(); return 'handled'; }
+      if (event.name === 'right') { this.editor.moveRight(); return 'handled'; }
+      if (event.name === 'home') { this.editor.moveHome(); return 'handled'; }
+      if (event.name === 'end') { this.editor.moveEnd(); return 'handled'; }
+      if (event.name === 'paste') { this.editor.insert(event.text); return 'handled'; }
+      if (event.name === 'char') { this.editor.insert(event.text); return 'handled'; }
+      return 'handled';
+    }
+
+    if (event.name === 'escape') { this.answer(null); return 'close'; }
+    const count = this.options.length + 1;
+    if (event.name === 'up') { this.selected = (this.selected - 1 + count) % count; return 'handled'; }
+    if (event.name === 'down') { this.selected = (this.selected + 1) % count; return 'handled'; }
+    if (event.name === 'enter' || event.name === 'return') {
+      if (this.selected === this.customIndex) { this.customMode = true; return 'handled'; }
+      const option = this.options[this.selected];
+      if (!option) return 'handled';
+      this.answer({ requestId: this.request.id, optionId: option.id, label: option.label, custom: false });
+      return 'close';
+    }
+    return 'handled';
+  }
+
+  answer(value = null) {
+    if (this.answered) return;
+    this.answered = true;
+    if (this.onAnswer) this.onAnswer(value);
+  }
+}
+
 /** A yes/no confirm, for destructive commands that are not tool approvals. */
 export class ConfirmLayer extends Layer {
   constructor(options = {}) {

package/src/tui/prompt.js

@@ -26,7 +26,7 @@ import { barBlock, GUTTER } from './block.js';
 import { visibleWidth, truncate, wrapBlock, shortenHome, safeDisplay } from './text.js';
 import { pickExample, fitHints } from './banner.js';
 import { panelRows } from './overlay.js';
-import { commandPalette, skillPicker, ApprovalLayer, ConfirmLayer, HomeLayer, TextLayer } from './dialogs.js';
+import { commandPalette, skillPicker, ApprovalLayer, DecisionLayer, ConfirmLayer, HomeLayer, TextLayer } from './dialogs.js';
 import { describeTool } from './toolDisplay.js';
 
 const CTRL_C_WINDOW_MS = 2000;
@@ -264,6 +264,7 @@ export class ChatPrompt {
       this.statusMessage = message;
       this.scheduleDraw();
     };
+    renderer.onPlanChange = () => this.scheduleDraw();
   }
 
   /**
@@ -321,6 +322,26 @@ export class ChatPrompt {
     return visibleWidth(full) > width ? truncate(full, width, GLYPHS.ellipsis) : full;
   }
 
+  /** Persistent checklist shown outside the chat transcript. */
+  planRows(width) {
+    const plan = this.renderer && Array.isArray(this.renderer.latestPlan) ? this.renderer.latestPlan : [];
+    if (plan.length === 0) return [];
+    const completed = plan.filter(item => item.status === 'completed').length;
+    const rows = [`${bold(paint('accent', 'implementation plan'))}  ${dim(`${completed}/${plan.length}`)}`];
+    const limit = Math.min(plan.length, 5);
+    for (const item of plan.slice(0, limit)) {
+      const mark = item.status === 'completed'
+        ? paint('success', GLYPHS.check)
+        : item.status === 'in_progress'
+          ? paint('accent', GLYPHS.arrow)
+          : paint('muted', GLYPHS.dot);
+      rows.push(`  ${mark} ${truncate(safeDisplay(item.text || item.step || ''), Math.max(8, width - 5), GLYPHS.ellipsis)}`);
+    }
+    if (plan.length > limit) rows.push(`  ${dim(`${GLYPHS.ellipsis} ${plan.length - limit} more`)}`);
+    rows.push('');
+    return rows;
+  }
+
   startTick() {
     if (this.tickTimer) return;
     this.tickTimer = setInterval(() => {
@@ -456,6 +477,13 @@ export class ChatPrompt {
     });
   }
 
+  /** Ask for a durable implementation choice, with a free-form option. */
+  decide(request = {}) {
+    return new Promise((resolve) => {
+      this.openLayer(new DecisionLayer({ request, onAnswer: resolve }));
+    });
+  }
+
   /** A plain yes/no, for the questions that are not tool approvals. */
   confirm(message, options = {}) {
     return new Promise((resolve) => {
@@ -1136,12 +1164,13 @@ export class ChatPrompt {
     const status = this.statusRow(width);
     const gap = status.length > 0 ? new Array(FOOTER_GAP).fill('') : [];
 
+    const planRows = this.planRows(width);
     const all = this.clampRows(
-      boxRows.concat(pickerRows, noticeRows, gap, status), width
+      planRows.concat(boxRows, pickerRows, noticeRows, gap, status), width
     );
 
     // Park the cursor where the user is typing, not at the end of the picker.
-    this.present(all, caretRow + padTop, layout.cursorCol + inset);
+    this.present(all, planRows.length + caretRow + padTop, layout.cursorCol + inset);
   }
 
   /**

package/src/tui/toolDisplay.js

@@ -82,7 +82,6 @@ const TOOL_DISPLAY = new Map([
   ['code_verify_syntax',  (a) => ({ verb: 'verify', detail: pathDetail(firstString(a, ['path', 'file_path'])) })],
 
   ['memory_write',  (a) => ({ verb: 'remember', detail: firstString(a, ['fact', 'key', 'project']) })],
-  ['TodoWrite',     (a) => ({ verb: 'plan',     detail: countDetail(a.todos, 'item') })],
   ['update_plan',   (a) => ({ verb: 'plan',     detail: countDetail(a.plan, 'step') })],
   ['tool_search',   (a) => ({ verb: 'discover', detail: firstString(a, ['query', 'description']) })],
   ['fs_read_skill', (a) => ({ verb: 'skill',    detail: firstString(a, ['id', 'skillId', 'domain']) })],

package/src/tools/todoWrite.js

@@ -1,75 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-
-export const todoWrite = {
-  schema: {
-    name: 'TodoWrite',
-    description: 'Dynamic Context Injector: Create and manage structured tasks. Forces atomic, granular steps instead of vague goals.',
-    parameters: {
-      type: 'object',
-      properties: {
-        todos: {
-          type: 'array',
-          description: 'The updated todo list (JSON state)',
-          items: {
-            type: 'object',
-            properties: {
-              id: { type: 'string' },
-              content: { type: 'string', minLength: 5, description: 'Must be an atomic, actionable step.' },
-              status: { 
-                type: 'string',
-                enum: ['pending', 'in_progress', 'completed']
-              }
-            },
-            required: ['id', 'content', 'status'],
-            additionalProperties: false
-          }
-        }
-      },
-      required: ['todos'],
-      additionalProperties: false
-    }
-  },
-  async execute(args) {
-    try {
-      const todoPath = path.join(process.cwd(), '.causyne_todos.json');
-      const mdPath = path.join(process.cwd(), 'AGI_PLAN.md');
-      
-      // Phase 2 AGI Upgrade: Atomic Validation
-      for (const task of args.todos) {
-        const words = task.content.split(' ').length;
-        if (words < 2) {
-          return { success: false, error: `Task [${task.id}] is too vague ("${task.content}"). Rewrite it into an atomic, actionable step (e.g., "Scaffold React Navbar").` };
-        }
-      }
-      
-      // Save JSON state
-      await fs.writeFile(todoPath, JSON.stringify(args.todos, null, 2), 'utf8');
-      
-      // Render to MD for user visibility
-      let mdContent = '# AGI Execution Plan\n\n';
-      for (const t of args.todos) {
-        let box = '[ ]';
-        if (t.status === 'in_progress') box = '[/]';
-        if (t.status === 'completed') box = '[x]';
-        mdContent += `- ${box} ${t.id}: ${t.content}\n`;
-      }
-      await fs.writeFile(mdPath, mdContent, 'utf8');
-      
-      // Phase 2 AGI Upgrade: Memory Hook (Signaling back to AgentLoop context window)
-      const inProgress = args.todos.filter(t => t.status === 'in_progress');
-      const completed = args.todos.filter(t => t.status === 'completed');
-      
-      if (inProgress.length > 1) {
-        return { success: true, output: `[Memory Hook] Saved. WARNING: You have ${inProgress.length} tasks in_progress. Only ONE task may be in progress at a time.` };
-      }
-      
-      return { 
-        success: true, 
-        output: `[Memory Hook] Tasks synchronized. ${completed.length} completed, ${inProgress.length} active. Focus locked on: ${inProgress[0]?.content || 'None'}` 
-      };
-    } catch (e) {
-      return { success: false, error: e.message };
-    }
-  }
-};