@causyne/agent 1.10.13 → 1.10.18

package/src/tools/registry.js

@@ -12,7 +12,6 @@ import { processList } from './processList.js';
 import { procTerm } from './procTerm.js';
 import { webFetch } from './webFetch.js';
 import { desktopOpen } from './desktopOpen.js';
-import { todoWrite } from './todoWrite.js';
 import { multiEdit } from './multiEdit.js';
 import { codebaseSearch } from './codebaseSearch.js';
 import { browserAct } from './browserAutomator.js';
@@ -22,6 +21,7 @@ import { palmierAutomator } from './palmierAutomator.js';
 import { viewImage } from './viewImage.js';
 import { webSearch } from './webSearch.js';
 import { updatePlan } from './updatePlan.js';
+import { requestDecision } from './requestDecision.js';
 import { clipboard } from './clipboard.js';
 import { screenshot } from './screenshot.js';
 import { axSnapshot } from './axSnapshot.js';
@@ -106,9 +106,9 @@ const TOOL_MODULES = [
   sysRun, sysRunBg, fsRead, fsWrite,
   fsEdit, fsFind, fsSearch, fsList, fsMove,
   fsDelete, gitExec, processList, procTerm,
-  webFetch, desktopOpen, todoWrite, multiEdit,
+  webFetch, desktopOpen, multiEdit,
   codebaseSearch, browserAct, viewImage, webSearch,
-  updatePlan, clipboard, screenshot, axSnapshot, desktopAct, archive,
+  updatePlan, requestDecision, clipboard, screenshot, axSnapshot, desktopAct, archive,
   checkSystemSpecs, executeProceduralMedia, manageLocalAiDependencies,
   generateMediaViaApi, memoryWrite, printerPrint, printerList, printerStatus, toolForgeTool, pluginManagerTool,
   astryxOracle, pdfRead, codeVerifySyntax, codeListSymbols, blenderAct, resolveAutomator, palmierAutomator,
@@ -145,6 +145,7 @@ for (const module of TOOL_MODULES) {
 // a tool whose canonical schema name is different. Resolved only at execution
 // time — never advertised, so they cost no context.
 const TOOL_ALIASES = {
+  TodoWrite: 'update_plan',
   manage_local_ai_dependencies: 'manage_local_dependencies',
   procTerm: 'proc_term',
   gitExec: 'gitOp',

package/src/tools/requestDecision.js

@@ -0,0 +1,87 @@
+import crypto from 'node:crypto';
+const KINDS = new Set(['architecture', 'product', 'data', 'security', 'workflow', 'other']);
+function text(value, name, limit) {
+    if (typeof value !== 'string')
+        throw new Error(`${name} must be a string`);
+    const cleaned = value.replace(/\s+/g, ' ').trim();
+    if (!cleaned)
+        throw new Error(`${name} must not be empty`);
+    if (cleaned.length > limit)
+        throw new Error(`${name} exceeds ${limit} characters`);
+    return cleaned;
+}
+function normalizeRequest(args) {
+    const kind = String(args.kind ?? 'other');
+    if (!KINDS.has(kind))
+        throw new Error('kind is invalid');
+    if (!Array.isArray(args.options) || args.options.length < 2 || args.options.length > 4) {
+        throw new Error('options must contain 2-4 choices');
+    }
+    const ids = new Set();
+    const options = args.options.map((raw, index) => {
+        const option = (raw && typeof raw === 'object' ? raw : {});
+        const id = text(option.id ?? `option-${index + 1}`, `options[${index}].id`, 48);
+        if (ids.has(id))
+            throw new Error(`Duplicate option id: ${id}`);
+        ids.add(id);
+        return {
+            id,
+            label: text(option.label, `options[${index}].label`, 80),
+            description: text(option.description, `options[${index}].description`, 240)
+        };
+    });
+    return {
+        id: crypto.randomUUID(),
+        kind,
+        header: text(args.header, 'header', 48),
+        question: text(args.question, 'question', 500),
+        reason: text(args.reason, 'reason', 500),
+        options,
+        allowCustom: true
+    };
+}
+export const requestDecision = {
+    schema: {
+        name: 'request_decision',
+        description: 'Pause for a durable user decision when several materially different implementation directions are valid. Provide 2-4 concrete options; a custom answer is always available. This is a design decision, not a tool permission request.',
+        parameters: {
+            type: 'object',
+            properties: {
+                kind: { type: 'string', enum: ['architecture', 'product', 'data', 'security', 'workflow', 'other'] },
+                header: { type: 'string', description: 'Short decision label, at most 48 characters.' },
+                question: { type: 'string', description: 'One specific decision the user must make.' },
+                reason: { type: 'string', description: 'Why this choice has durable consequences.' },
+                options: {
+                    type: 'array', minItems: 2, maxItems: 4,
+                    items: {
+                        type: 'object',
+                        properties: {
+                            id: { type: 'string' },
+                            label: { type: 'string' },
+                            description: { type: 'string' }
+                        },
+                        required: ['id', 'label', 'description'],
+                        additionalProperties: false
+                    }
+                }
+            },
+            required: ['kind', 'header', 'question', 'reason', 'options'],
+            additionalProperties: false
+        }
+    },
+    async execute(args, context = {}) {
+        try {
+            if (!context.parentLoop || typeof context.parentLoop.requestDecision !== 'function') {
+                return { success: false, error: 'Structured decisions require an active Causyne session' };
+            }
+            const request = normalizeRequest(args);
+            const answer = await context.parentLoop.requestDecision(request);
+            if (!answer)
+                return { success: false, error: 'The user dismissed the decision without choosing an option' };
+            return { success: true, output: JSON.stringify(answer), decision: answer };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+};

package/src/tools/requestDecision.ts

@@ -0,0 +1,107 @@
+import crypto from 'node:crypto';
+import type { DecisionKind, DecisionRequest } from '../decisionPolicy.js';
+
+interface ToolContext {
+  parentLoop?: {
+    requestDecision(request: DecisionRequest): Promise<unknown>;
+  };
+}
+
+interface RawOption {
+  id?: unknown;
+  label?: unknown;
+  description?: unknown;
+}
+
+interface RawInput {
+  kind?: unknown;
+  header?: unknown;
+  question?: unknown;
+  reason?: unknown;
+  options?: unknown;
+}
+
+const KINDS = new Set<DecisionKind>(['architecture', 'product', 'data', 'security', 'workflow', 'other']);
+
+function text(value: unknown, name: string, limit: number): string {
+  if (typeof value !== 'string') throw new Error(`${name} must be a string`);
+  const cleaned = value.replace(/\s+/g, ' ').trim();
+  if (!cleaned) throw new Error(`${name} must not be empty`);
+  if (cleaned.length > limit) throw new Error(`${name} exceeds ${limit} characters`);
+  return cleaned;
+}
+
+function normalizeRequest(args: RawInput): DecisionRequest {
+  const kind = String(args.kind ?? 'other') as DecisionKind;
+  if (!KINDS.has(kind)) throw new Error('kind is invalid');
+  if (!Array.isArray(args.options) || args.options.length < 2 || args.options.length > 4) {
+    throw new Error('options must contain 2-4 choices');
+  }
+  const ids = new Set<string>();
+  const options = args.options.map((raw, index) => {
+    const option = (raw && typeof raw === 'object' ? raw : {}) as RawOption;
+    const id = text(option.id ?? `option-${index + 1}`, `options[${index}].id`, 48);
+    if (ids.has(id)) throw new Error(`Duplicate option id: ${id}`);
+    ids.add(id);
+    return {
+      id,
+      label: text(option.label, `options[${index}].label`, 80),
+      description: text(option.description, `options[${index}].description`, 240)
+    };
+  });
+  return {
+    id: crypto.randomUUID(),
+    kind,
+    header: text(args.header, 'header', 48),
+    question: text(args.question, 'question', 500),
+    reason: text(args.reason, 'reason', 500),
+    options,
+    allowCustom: true
+  };
+}
+
+export const requestDecision = {
+  schema: {
+    name: 'request_decision',
+    description: 'Pause for a durable user decision when several materially different implementation directions are valid. Provide 2-4 concrete options; a custom answer is always available. This is a design decision, not a tool permission request.',
+    parameters: {
+      type: 'object',
+      properties: {
+        kind: { type: 'string', enum: ['architecture', 'product', 'data', 'security', 'workflow', 'other'] },
+        header: { type: 'string', description: 'Short decision label, at most 48 characters.' },
+        question: { type: 'string', description: 'One specific decision the user must make.' },
+        reason: { type: 'string', description: 'Why this choice has durable consequences.' },
+        options: {
+          type: 'array', minItems: 2, maxItems: 4,
+          items: {
+            type: 'object',
+            properties: {
+              id: { type: 'string' },
+              label: { type: 'string' },
+              description: { type: 'string' }
+            },
+            required: ['id', 'label', 'description'],
+            additionalProperties: false
+          }
+        }
+      },
+      required: ['kind', 'header', 'question', 'reason', 'options'],
+      additionalProperties: false
+    }
+  },
+
+  async execute(args: RawInput, context: ToolContext = {}) {
+    try {
+      if (!context.parentLoop || typeof context.parentLoop.requestDecision !== 'function') {
+        return { success: false, error: 'Structured decisions require an active Causyne session' };
+      }
+      const request = normalizeRequest(args);
+      const answer = await context.parentLoop.requestDecision(request);
+      if (!answer) return { success: false, error: 'The user dismissed the decision without choosing an option' };
+      return { success: true, output: JSON.stringify(answer), decision: answer };
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+  }
+};
+

package/src/tools/subagentOrchestrator.js

@@ -1,4 +1,10 @@
 import { TokenTracker } from '../tokenTracker.js';
+import { listAgentProfiles, loadAgentProfile } from '../agentProfiles.js';
+import {
+  completeSubagentJournal,
+  failSubagentJournal,
+  startSubagentJournal
+} from '../subagentJournal.js';
 
 // Subagent delegation.
 //
@@ -67,6 +73,8 @@ async function executeSubagent(record, parentLoop) {
   const child = new AgentLoop(transport, record.subagentId, record.prompt);
 
   // A delegated task is a bounded errand, not a second full session.
+  child.maxStepsCeiling = record.maxSteps;
+  child.taskTokenLimit = record.maxTokens;
   child.maxSteps = Math.min(child.maxSteps || 25, record.maxSteps);
   child.maxCircuitBreaker = child.maxSteps;
   child.messages = [];
@@ -78,8 +86,16 @@ async function executeSubagent(record, parentLoop) {
 
   record.loop = child;
   record.startedAtMs = Date.now();
+  record.journalStarted = startSubagentJournal(record);
 
-  await child.run();
+  try {
+    await child.run();
+  } catch (error) {
+    if (record.journalStarted) {
+      failSubagentJournal(record.subagentId, error instanceof Error ? error.message : String(error));
+    }
+    throw error;
+  }
 
   const finalAssistant = [...child.messages].reverse()
     .find(m => m.role === 'assistant' && typeof m.content === 'string' && m.content.trim());
@@ -88,7 +104,7 @@ async function executeSubagent(record, parentLoop) {
     try { return JSON.parse(m.content).success === false; } catch (e) { return false; }
   });
 
-  return {
+  const result = {
     subagentId: record.subagentId,
     name: record.name,
     stepsCompleted: child.stepsCompleted,
@@ -100,6 +116,8 @@ async function executeSubagent(record, parentLoop) {
     summary: finalAssistant ? finalAssistant.content : null,
     stoppedEarly: child.stepsCompleted >= child.maxSteps
   };
+  if (record.journalStarted) completeSubagentJournal(record.subagentId, child.messages, result);
+  return result;
 }
 
 export const subagentOrchestrator = {
@@ -111,15 +129,16 @@ export const subagentOrchestrator = {
       properties: {
         action: {
           type: 'string',
-          enum: ['spawn', 'list', 'kill', 'delegate_and_wait'],
-          description: 'spawn (start in the background and return immediately), list (show active subagents), kill (stop one), delegate_and_wait (run it and return the result).'
+          enum: ['spawn', 'list', 'list_profiles', 'kill', 'delegate_and_wait'],
+          description: 'spawn (start in the background), list (show active subagents), list_profiles (show static user-defined agent profiles), kill (stop one), or delegate_and_wait (run and return the result).'
         },
         name: { type: 'string', description: 'A short name for the subagent, e.g. Audit_Worker.' },
         prompt: { type: 'string', description: 'The complete instruction for the subagent. It has no memory of this conversation, so it must be self-contained.' },
+        profile: { type: 'string', description: 'Optional profile name from ~/.causyne/agents/<name>.json. Its tool and budget limits cannot be widened by the call.' },
         subagentId: { type: 'string', description: 'Target subagent for the kill action.' },
         toolScope: { type: 'array', items: { type: 'string' }, description: 'Catalogue tool names the subagent may use. Defaults to read-only inspection tools. It can never receive the delegation tool itself.' },
-        maxSteps: { type: 'integer', description: 'Step ceiling for the subagent. Defaults to 25.' },
-        maxTokens: { type: 'integer', description: 'Advisory token budget for this subagent. Defaults to 50000.' },
+        maxSteps: { type: 'integer', description: 'Hard step ceiling for the subagent. Defaults to 25.' },
+        maxTokens: { type: 'integer', description: 'Hard per-task token ceiling for the subagent. Defaults to 50000.' },
         depth: { type: 'integer', description: 'Hierarchy depth. 0 = master, 1 = worker. Subagents cannot spawn subagents.' }
       },
       required: ['action']
@@ -153,6 +172,23 @@ export const subagentOrchestrator = {
         };
       }
 
+      if (action === 'list_profiles') {
+        const { profiles, problems } = listAgentProfiles();
+        return {
+          success: true,
+          output: JSON.stringify({
+            profiles: profiles.map(profile => ({
+              name: profile.name,
+              description: profile.description,
+              toolScope: profile.toolScope,
+              maxSteps: profile.maxSteps,
+              maxTokens: profile.maxTokens
+            })),
+            problems
+          }, null, 2)
+        };
+      }
+
       if (action === 'kill') {
         const id = args.subagentId || args.name;
         if (!id) return { success: false, error: 'subagentId or name is required to stop a subagent.' };
@@ -173,7 +209,17 @@ export const subagentOrchestrator = {
         return { success: false, error: `Unknown action: ${action}` };
       }
 
-      const prompt = args.prompt;
+      let profile = null;
+      if (args.profile !== undefined) {
+        const loaded = loadAgentProfile(args.profile);
+        if (!loaded.ok) return { success: false, error: `Agent profile ${JSON.stringify(args.profile)}: ${loaded.error}` };
+        profile = loaded.profile;
+      }
+
+      const requestedPrompt = args.prompt;
+      const prompt = profile
+        ? `${profile.instructions}\n\nDelegated task:\n${String(requestedPrompt || '')}`
+        : requestedPrompt;
       if (!prompt) return { success: false, error: 'A prompt is required to delegate a task.' };
 
       const depth = args.depth !== undefined ? args.depth : 1;
@@ -195,11 +241,19 @@ export const subagentOrchestrator = {
         };
       }
 
-      const name = args.name || `Worker_${Math.random().toString(36).slice(2, 7)}`;
+      const name = args.name || profile?.name || `Worker_${Math.random().toString(36).slice(2, 7)}`;
       const subagentId = `sub_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
-      const requestedScope = Array.isArray(args.toolScope) && args.toolScope.length > 0
+      let requestedScope = Array.isArray(args.toolScope) && args.toolScope.length > 0
         ? args.toolScope
-        : DEFAULT_TOOL_SCOPE;
+        : profile?.toolScope || DEFAULT_TOOL_SCOPE;
+      if (profile) {
+        const ceiling = new Set(profile.toolScope);
+        requestedScope = requestedScope.filter(tool => ceiling.has(String(tool).replace(/\./g, '_')));
+        if (requestedScope.length === 0) {
+          return { success: false, error: `Agent profile ${profile.name} permits none of the requested tools.` };
+        }
+      }
+      requestedScope = [...new Set(requestedScope.map(tool => String(tool).replace(/\./g, '_')))];
 
       // Reject an unknown tool name instead of silently accepting it. The old
       // implementation accepted anything, which is easy to do when the scope is
@@ -211,14 +265,21 @@ export const subagentOrchestrator = {
         return { success: false, error: `Unknown tools in toolScope: ${unknown.join(', ')}.` };
       }
 
+      const requestedMaxSteps = Number.isInteger(args.maxSteps)
+        ? Math.max(1, Math.min(args.maxSteps, 100))
+        : profile?.maxSteps || 25;
+      const requestedMaxTokens = Number.isInteger(args.maxTokens)
+        ? Math.max(1_000, Math.min(args.maxTokens, 200_000))
+        : profile?.maxTokens || 50_000;
       const record = {
         subagentId,
         name,
         prompt,
         toolScope: requestedScope,
         depth,
-        maxSteps: args.maxSteps || 25,
-        maxTokens: args.maxTokens || 50000,
+        maxSteps: Math.min(requestedMaxSteps, profile?.maxSteps || 100),
+        maxTokens: Math.min(requestedMaxTokens, profile?.maxTokens || 200_000),
+        profile: profile?.name || null,
         status: 'running',
         startTime: new Date().toISOString(),
         summary: null,

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) };
+    }
+  }
+};