@sylix/coworker 1.4.2 → 1.5.2

package/dist/tools/Schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Schemas.d.ts","sourceRoot":"","sources":["../../src/tools/Schemas.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA0iB/B,CAAC"}
+{"version":3,"file":"Schemas.d.ts","sourceRoot":"","sources":["../../src/tools/Schemas.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA+O/B,CAAC"}

package/dist/tools/Schemas.js

@@ -3,188 +3,90 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CoWorkerToolSchemas = void 0;
 /**
  * CoWorker Tool Schemas — OpenAI Function Calling format.
- * Complete parity with Claude Code's tool suite + diagnostics.
- * These are sent to the LLM so it knows what tools it can call.
+ * v1.5.2 — Concise Names & Sylix Branding.
  */
 exports.CoWorkerToolSchemas = [
-    // ═══════════════════════════════════════════════════════════════════
-    // FILESYSTEM — Read, Write, Edit, Multi-Edit, LS, ListDir, Glob, Grep
-    // ═══════════════════════════════════════════════════════════════════
     {
         type: 'function',
         function: {
-            name: 'executeRead',
-            description: 'Reads the complete text content of a file from the filesystem. Returns content with line numbers for precise referencing.',
+            name: 'Read',
+            description: 'Reads the complete text content of a file. Returns content with line numbers.',
             parameters: {
                 type: 'object',
                 properties: {
-                    filePath: { type: 'string', description: 'Absolute or relative path to the file to read.' }
+                    file_path: { type: 'string', description: 'Absolute or relative path to the file.' }
                 },
-                required: ['filePath']
+                required: ['file_path']
             }
         }
     },
     {
         type: 'function',
         function: {
-            name: 'executeWrite',
-            description: 'Creates or securely overwrites a file at the specified path. Parent directories are created automatically.',
+            name: 'Write',
+            description: 'Creates or overwrites a file with specific content.',
             parameters: {
                 type: 'object',
                 properties: {
-                    filePath: { type: 'string', description: 'Absolute or relative path to the file.' },
-                    content: { type: 'string', description: 'The complete content to write into the file.' }
+                    file_path: { type: 'string', description: 'Path to the file.' },
+                    content: { type: 'string', description: 'The content to write.' }
                 },
-                required: ['filePath', 'content']
+                required: ['file_path', 'content']
             }
         }
     },
     {
         type: 'function',
         function: {
-            name: 'executeEdit',
-            description: 'Performs a targeted string replacement within an existing file without rewriting the entire file. The oldString must match exactly (including whitespace and indentation).',
+            name: 'Edit',
+            description: 'Replaces a specific string in a file with new text.',
             parameters: {
                 type: 'object',
                 properties: {
-                    filePath: { type: 'string', description: 'Absolute or relative path to the file.' },
-                    oldString: { type: 'string', description: 'The exact text to find and replace. Must match character-for-character.' },
-                    newString: { type: 'string', description: 'The replacement text.' },
-                    replaceAll: { type: 'boolean', description: 'If true, replace ALL occurrences. Default: false (first only).' }
+                    file_path: { type: 'string', description: 'Path to the file.' },
+                    old_string: { type: 'string', description: 'Text to find.' },
+                    new_string: { type: 'string', description: 'Text to insert.' },
+                    replace_all: { type: 'boolean', description: 'Whether to replace all occurrences.' }
                 },
-                required: ['filePath', 'oldString', 'newString']
+                required: ['file_path', 'old_string', 'new_string']
             }
         }
     },
     {
         type: 'function',
         function: {
-            name: 'executeMultiEdit',
-            description: 'Performs multiple targeted string replacements on a single file in one atomic operation.',
+            name: 'MultiEdit',
+            description: 'Performs multiple string replacements in a single file.',
             parameters: {
                 type: 'object',
                 properties: {
-                    filePath: { type: 'string', description: 'Absolute or relative path to the file to edit.' },
+                    file_path: { type: 'string', description: 'Path to the file.' },
                     edits: {
                         type: 'array',
                         items: {
                             type: 'object',
                             properties: {
-                                oldString: { type: 'string', description: 'The exact text to replace.' },
-                                newString: { type: 'string', description: 'The replacement text.' },
-                                replaceAll: { type: 'boolean', description: 'Replace all occurrences (default: false).' }
+                                old_string: { type: 'string' },
+                                new_string: { type: 'string' },
+                                replace_all: { type: 'boolean' }
                             },
-                            required: ['oldString', 'newString']
+                            required: ['old_string', 'new_string']
                         }
                     }
                 },
-                required: ['filePath', 'edits']
+                required: ['file_path', 'edits']
             }
         }
     },
     {
         type: 'function',
         function: {
-            name: 'executeLS',
-            description: 'Lists files and directories in the specified path, optionally recursively.',
+            name: 'Bash',
+            description: 'Executes a shell command and returns output.',
             parameters: {
                 type: 'object',
                 properties: {
-                    path: { type: 'string', description: 'Path to list. Defaults to current working directory.' },
-                    recursive: { type: 'boolean', description: 'If true, list directories recursively. Default: false.' }
-                },
-                required: []
-            }
-        }
-    },
-    {
-        type: 'function',
-        function: {
-            name: 'executeListDir',
-            description: 'Lists all files and subdirectories in a directory with their sizes.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    dirPath: { type: 'string', description: 'Path to the directory. Defaults to current working directory.' }
-                },
-                required: []
-            }
-        }
-    },
-    {
-        type: 'function',
-        function: {
-            name: 'executeGlob',
-            description: 'Fast recursive file search matching a wildcard pattern. Automatically ignores node_modules, .git, dist, build, and out directories.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    pattern: { type: 'string', description: 'Wildcard pattern like *.ts, *.py, or src/**/*.js' },
-                    dir: { type: 'string', description: 'Root directory to search within. Defaults to cwd.' }
-                },
-                required: ['pattern']
-            }
-        }
-    },
-    {
-        type: 'function',
-        function: {
-            name: 'executeGrep',
-            description: 'Searches for a regex pattern inside a list of file paths. Returns matching lines with file:line format.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    regexQuery: { type: 'string', description: 'The regular expression string to match.' },
-                    filesToSearch: { type: 'array', items: { type: 'string' }, description: 'Array of file paths to scan.' }
-                },
-                required: ['regexQuery', 'filesToSearch']
-            }
-        }
-    },
-    // ═══════════════════════════════════════════════════════════════════
-    // DIAGNOSTICS — Inline error detection (Claude Code PostToolUse parity)
-    // ═══════════════════════════════════════════════════════════════════
-    {
-        type: 'function',
-        function: {
-            name: 'diagnostics',
-            description: 'Runs the appropriate linter or type-checker on a specific file and returns any errors. Supports: TypeScript (tsc), JavaScript (node --check), Python (py_compile), JSON (parse), CSS (stylelint). NOTE: Diagnostics also run AUTOMATICALLY after every Write/Edit/MultiEdit — but you can use this tool to manually re-check a file at any time.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    filePath: { type: 'string', description: 'Path to the file to validate.' }
-                },
-                required: ['filePath']
-            }
-        }
-    },
-    // ═══════════════════════════════════════════════════════════════════
-    // SHELL & PROCESS — Bash, BashOutput, KillShell
-    {
-        type: 'function',
-        function: {
-            name: 'codeReview',
-            description: 'Runs a full code review on the current git branch, analyzing all changed files for bugs, security vulnerabilities, logic errors, and style violations. Reads REVIEW.md and COWORKER.md for project-specific review rules. Returns structured findings with severity levels: 🔴 Normal (bugs), 🟡 Nit (minor), 🟣 Pre-existing.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    baseBranch: { type: 'string', description: 'The base branch to diff against (default: main or master).' }
-                },
-                required: []
-            }
-        }
-    },
-    // ═══════════════════════════════════════════════════════════════════
-    {
-        type: 'function',
-        function: {
-            name: 'executeBash',
-            description: 'Executes a terminal/shell command synchronously and returns stdout + stderr. Use for git, npm, running scripts, compiling, etc. 60 second timeout.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    command: { type: 'string', description: 'The shell command to execute.' },
-                    cwd: { type: 'string', description: 'Optional working directory for the command.' }
+                    command: { type: 'string', description: 'The command to run.' }
                 },
                 required: ['command']
             }
@@ -193,118 +95,56 @@ exports.CoWorkerToolSchemas = [
     {
         type: 'function',
         function: {
-            name: 'bashOutput',
-            description: 'Reads output from a still-running background bash process by its process ID.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    pid: { type: 'number', description: 'The process ID of the background process.' }
-                },
-                required: ['pid']
-            }
-        }
-    },
-    {
-        type: 'function',
-        function: {
-            name: 'killShell',
-            description: 'Forcefully kills a running background process by its PID.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    pid: { type: 'number', description: 'The process ID to kill.' }
-                },
-                required: ['pid']
-            }
-        }
-    },
-    // ═══════════════════════════════════════════════════════════════════
-    // GIT — GitStatus, GitDiff, GitCommit
-    // ═══════════════════════════════════════════════════════════════════
-    {
-        type: 'function',
-        function: {
-            name: 'gitStatus',
-            description: 'Returns the current git status showing branch, staged, unstaged, and untracked files.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    cwd: { type: 'string', description: 'Working directory of the git repo. Defaults to cwd.' }
-                },
-                required: []
-            }
-        }
-    },
-    {
-        type: 'function',
-        function: {
-            name: 'gitDiff',
-            description: 'Returns the git diff for the working directory or a specific file.',
+            name: 'Glob',
+            description: 'Finds files matching a pattern.',
             parameters: {
                 type: 'object',
                 properties: {
-                    filePath: { type: 'string', description: 'Optional specific file to diff. If omitted, diffs entire working tree.' },
-                    staged: { type: 'boolean', description: 'If true, shows staged changes (--cached). Default: false.' },
-                    cwd: { type: 'string', description: 'Working directory. Defaults to cwd.' }
+                    pattern: { type: 'string', description: 'Glob pattern (e.g. src/**/*.ts).' },
+                    directory: { type: 'string', description: 'Directory to search in.' }
                 },
-                required: []
+                required: ['pattern']
             }
         }
     },
     {
         type: 'function',
         function: {
-            name: 'gitCommit',
-            description: 'Stages specified files (or all changes) and creates a git commit with the given message.',
+            name: 'Grep',
+            description: 'Searches for a pattern in a list of files.',
             parameters: {
                 type: 'object',
                 properties: {
-                    message: { type: 'string', description: 'The commit message.' },
-                    files: { type: 'array', items: { type: 'string' }, description: 'Files to stage. If empty, stages all changes (git add -A).' },
-                    cwd: { type: 'string', description: 'Working directory. Defaults to cwd.' }
+                    pattern: { type: 'string', description: 'Regex pattern.' },
+                    files: { type: 'array', items: { type: 'string' }, description: 'Files to search.' }
                 },
-                required: ['message']
+                required: ['pattern', 'files']
             }
         }
     },
-    // ═══════════════════════════════════════════════════════════════════
-    // MEMORY — MemoryRead, MemoryWrite (COWORKER.md persistence)
-    // ═══════════════════════════════════════════════════════════════════
-    {
-        type: 'function',
-        function: {
-            name: 'memoryRead',
-            description: 'Reads the COWORKER.md memory file from the project root. Contains persistent notes, conventions, and learnings that survive across sessions.',
-            parameters: { type: 'object', properties: {} }
-        }
-    },
     {
         type: 'function',
         function: {
-            name: 'memoryWrite',
-            description: 'Appends or overwrites content in the COWORKER.md memory file. Use to save project conventions, decisions, and learnings.',
+            name: 'LS',
+            description: 'Lists files in a directory.',
             parameters: {
                 type: 'object',
                 properties: {
-                    content: { type: 'string', description: 'The content to write to COWORKER.md.' },
-                    mode: { type: 'string', enum: ['append', 'overwrite'], description: 'Whether to append to or overwrite the file. Default: append.' }
-                },
-                required: ['content']
+                    path: { type: 'string', description: 'Directory path.' },
+                    recursive: { type: 'boolean', description: 'Recursive listing.' }
+                }
             }
         }
     },
-    // ═══════════════════════════════════════════════════════════════════
-    // WEB — Search, Fetch, OpenBrowser
-    // ═══════════════════════════════════════════════════════════════════
     {
         type: 'function',
         function: {
-            name: 'executeWebSearch',
-            description: 'Searches the internet for information using DuckDuckGo. Returns top 5 results.',
+            name: 'WebSearch',
+            description: 'Searches the web for information.',
             parameters: {
                 type: 'object',
                 properties: {
-                    query: { type: 'string', description: 'The search query.' }
+                    query: { type: 'string', description: 'Search query.' }
                 },
                 required: ['query']
             }
@@ -313,12 +153,12 @@ exports.CoWorkerToolSchemas = [
     {
         type: 'function',
         function: {
-            name: 'executeWebFetch',
-            description: 'Downloads and parses the text content of a specific web URL. HTML is stripped automatically.',
+            name: 'WebFetch',
+            description: 'Fetches content from a URL.',
             parameters: {
                 type: 'object',
                 properties: {
-                    url: { type: 'string', description: 'The complete URI to fetch.' }
+                    url: { type: 'string', description: 'URL to fetch.' }
                 },
                 required: ['url']
             }
@@ -327,33 +167,22 @@ exports.CoWorkerToolSchemas = [
     {
         type: 'function',
         function: {
-            name: 'executeOpenBrowser',
-            description: 'Opens a URL in the user\'s default system browser.',
+            name: 'Task',
+            description: 'Launches a sub-agent for a complex task.',
             parameters: {
                 type: 'object',
                 properties: {
-                    url: { type: 'string', description: 'The fully qualified URL to open.' }
+                    description: { type: 'string', description: 'The task for the sub-agent.' }
                 },
-                required: ['url']
+                required: ['description']
             }
         }
     },
-    // ═══════════════════════════════════════════════════════════════════
-    // TASK MANAGEMENT — TodoRead, TodoWrite, TaskCreate, TaskUpdate
-    // ═══════════════════════════════════════════════════════════════════
-    {
-        type: 'function',
-        function: {
-            name: 'todoRead',
-            description: 'Reads the current todo list for the session.',
-            parameters: { type: 'object', properties: {} }
-        }
-    },
     {
         type: 'function',
         function: {
-            name: 'todoWrite',
-            description: 'Writes a structured todo list for tracking progress. Mark items completed immediately when done.',
+            name: 'TodoWrite',
+            description: 'Writes a session todo list.',
             parameters: {
                 type: 'object',
                 properties: {
@@ -362,12 +191,10 @@ exports.CoWorkerToolSchemas = [
                         items: {
                             type: 'object',
                             properties: {
-                                id: { type: 'string' },
-                                content: { type: 'string', description: 'Goal or checklist item.' },
-                                status: { type: 'string', enum: ['pending', 'in_progress', 'completed'] },
-                                priority: { type: 'string', enum: ['high', 'medium', 'low'] }
+                                content: { type: 'string' },
+                                status: { type: 'string', enum: ['pending', 'completed'] }
                             },
-                            required: ['content', 'status', 'priority']
+                            required: ['content', 'status']
                         }
                     }
                 },
@@ -378,175 +205,44 @@ exports.CoWorkerToolSchemas = [
     {
         type: 'function',
         function: {
-            name: 'taskCreate',
-            description: 'Creates a tracked objective with dependency tracking in the persistent task graph.',
+            name: 'BashOutput',
+            description: 'Reads output from a background process.',
             parameters: {
                 type: 'object',
                 properties: {
-                    description: { type: 'string', description: 'Goal or checklist item details.' },
-                    dependencies: { type: 'array', items: { type: 'string' }, description: 'Array of existing task IDs that must complete first.' }
+                    pid: { type: 'number', description: 'Process ID.' }
                 },
-                required: ['description']
-            }
-        }
-    },
-    {
-        type: 'function',
-        function: {
-            name: 'taskUpdate',
-            description: 'Updates a tracked task status in the persistent task graph.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    taskId: { type: 'string' },
-                    state: { type: 'string', enum: ['pending', 'in_progress', 'blocked', 'completed'] },
-                    notes: { type: 'string', description: 'Any context or blockers.' }
-                },
-                required: ['taskId', 'state']
-            }
-        }
-    },
-    // ═══════════════════════════════════════════════════════════════════
-    // INTERACTION — AskUser
-    // ═══════════════════════════════════════════════════════════════════
-    {
-        type: 'function',
-        function: {
-            name: 'executeAskUserQuestion',
-            description: 'Pauses the agentic loop and prompts the user for input or clarification.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    question: { type: 'string', description: 'The exact question to ask the user.' }
-                },
-                required: ['question']
-            }
-        }
-    },
-    // ═══════════════════════════════════════════════════════════════════
-    // JUPYTER NOTEBOOKS — NotebookRead, NotebookEdit
-    // ═══════════════════════════════════════════════════════════════════
-    {
-        type: 'function',
-        function: {
-            name: 'executeNotebookRead',
-            description: 'Reads a Jupyter notebook (.ipynb) and returns all cells with source code and outputs.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    notebookPath: { type: 'string', description: 'Absolute path to the Jupyter notebook file.' }
-                },
-                required: ['notebookPath']
-            }
-        }
-    },
-    {
-        type: 'function',
-        function: {
-            name: 'executeNotebookEdit',
-            description: 'Replaces, inserts, or deletes cells in a Jupyter notebook (.ipynb).',
-            parameters: {
-                type: 'object',
-                properties: {
-                    notebookPath: { type: 'string', description: 'Absolute path to the Jupyter notebook file.' },
-                    cellId: { type: 'string', description: 'ID of the cell to edit. If omitted, appends a new cell.' },
-                    newSource: { type: 'string', description: 'New cell content.' },
-                    cellType: { type: 'string', enum: ['code', 'markdown'], description: 'Cell type (default: code).' }
-                },
-                required: ['notebookPath', 'newSource']
-            }
-        }
-    },
-    // ═══════════════════════════════════════════════════════════════════
-    // AGENTS — Spawn Subagent, Return Result
-    // ═══════════════════════════════════════════════════════════════════
-    {
-        type: 'function',
-        function: {
-            name: 'agent',
-            description: 'Launches a sub-agent to handle a complex subtask autonomously.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    description: { type: 'string', description: 'Goal or task description for the sub-agent.' },
-                    subagentType: { type: 'string', description: 'Specialization: general-purpose, code-reviewer, plan-agent, bash-worker.' }
-                },
-                required: ['description']
-            }
-        }
-    },
-    {
-        type: 'function',
-        function: {
-            name: 'returnSubagentResult',
-            description: 'Returns the result from a sub-agent back to the parent agent.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    result: { type: 'string', description: 'The sub-agent\'s final output to return to the parent.' }
-                },
-                required: ['result']
+                required: ['pid']
             }
         }
     },
-    // ═══════════════════════════════════════════════════════════════════
-    // SCHEDULING — Cron Create, List, Delete
-    // ═══════════════════════════════════════════════════════════════════
     {
         type: 'function',
         function: {
-            name: 'cronCreate',
-            description: 'Schedules a recurring background check or task.',
+            name: 'KillBash',
+            description: 'Forcefully kills a background process.',
             parameters: {
                 type: 'object',
                 properties: {
-                    description: { type: 'string', description: 'What to check or do.' },
-                    intervalMinutes: { type: 'number', description: 'Frequency in minutes.' }
+                    pid: { type: 'number', description: 'Process ID.' }
                 },
-                required: ['description', 'intervalMinutes']
+                required: ['pid']
             }
         }
     },
     {
         type: 'function',
         function: {
-            name: 'cronList',
-            description: 'Lists all currently active scheduled background tasks.',
-            parameters: { type: 'object', properties: {} }
-        }
-    },
-    {
-        type: 'function',
-        function: {
-            name: 'cronDelete',
-            description: 'Cancels a specific recurring background task by its ID.',
+            name: 'executeBrowser',
+            description: 'Executes a sandboxed JavaScript script to control a Chromium browser. Available globals: browser, saveScreenshot, writeFile.',
             parameters: {
                 type: 'object',
                 properties: {
-                    cronId: { type: 'string' }
+                    script: { type: 'string', description: 'JS code to execute.' }
                 },
-                required: ['cronId']
+                required: ['script']
             }
         }
-    },
-    // ═══════════════════════════════════════════════════════════════════
-    // PLAN MODE — Enter/Exit safe brainstorming
-    // ═══════════════════════════════════════════════════════════════════
-    {
-        type: 'function',
-        function: {
-            name: 'enterPlanMode',
-            description: 'Temporarily revokes mutation tool access (bash, write, edit) so you can safely brainstorm.',
-            parameters: { type: 'object', properties: {} }
-        }
-    },
-    {
-        type: 'function',
-        function: {
-            name: 'exitPlanMode',
-            description: 'Restores mutation tool access after brainstorming is complete.',
-            parameters: { type: 'object', properties: {} }
-        }
     }
 ];
 //# sourceMappingURL=Schemas.js.map