nine-hundred 0.0.1

package/dist/agent/skills/skill-creator/scripts/run_loop.py

@@ -0,0 +1,328 @@
+#!/usr/bin/env python3
+"""Run the eval + improve loop until all pass or max iterations reached.
+
+Combines run_eval.py and improve_description.py in a loop, tracking history
+and returning the best description found. Supports train/test split to prevent
+overfitting.
+"""
+
+import argparse
+import json
+import random
+import sys
+import tempfile
+import time
+import webbrowser
+from pathlib import Path
+
+from scripts.generate_report import generate_html
+from scripts.improve_description import improve_description
+from scripts.run_eval import find_project_root, run_eval
+from scripts.utils import parse_skill_md
+
+
+def split_eval_set(eval_set: list[dict], holdout: float, seed: int = 42) -> tuple[list[dict], list[dict]]:
+    """Split eval set into train and test sets, stratified by should_trigger."""
+    random.seed(seed)
+
+    # Separate by should_trigger
+    trigger = [e for e in eval_set if e["should_trigger"]]
+    no_trigger = [e for e in eval_set if not e["should_trigger"]]
+
+    # Shuffle each group
+    random.shuffle(trigger)
+    random.shuffle(no_trigger)
+
+    # Calculate split points
+    n_trigger_test = max(1, int(len(trigger) * holdout))
+    n_no_trigger_test = max(1, int(len(no_trigger) * holdout))
+
+    # Split
+    test_set = trigger[:n_trigger_test] + no_trigger[:n_no_trigger_test]
+    train_set = trigger[n_trigger_test:] + no_trigger[n_no_trigger_test:]
+
+    return train_set, test_set
+
+
+def run_loop(
+    eval_set: list[dict],
+    skill_path: Path,
+    description_override: str | None,
+    num_workers: int,
+    timeout: int,
+    max_iterations: int,
+    runs_per_query: int,
+    trigger_threshold: float,
+    holdout: float,
+    model: str,
+    verbose: bool,
+    live_report_path: Path | None = None,
+    log_dir: Path | None = None,
+) -> dict:
+    """Run the eval + improvement loop."""
+    project_root = find_project_root()
+    name, original_description, content = parse_skill_md(skill_path)
+    current_description = description_override or original_description
+
+    # Split into train/test if holdout > 0
+    if holdout > 0:
+        train_set, test_set = split_eval_set(eval_set, holdout)
+        if verbose:
+            print(f"Split: {len(train_set)} train, {len(test_set)} test (holdout={holdout})", file=sys.stderr)
+    else:
+        train_set = eval_set
+        test_set = []
+
+    history = []
+    exit_reason = "unknown"
+
+    for iteration in range(1, max_iterations + 1):
+        if verbose:
+            print(f"\n{'='*60}", file=sys.stderr)
+            print(f"Iteration {iteration}/{max_iterations}", file=sys.stderr)
+            print(f"Description: {current_description}", file=sys.stderr)
+            print(f"{'='*60}", file=sys.stderr)
+
+        # Evaluate train + test together in one batch for parallelism
+        all_queries = train_set + test_set
+        t0 = time.time()
+        all_results = run_eval(
+            eval_set=all_queries,
+            skill_name=name,
+            description=current_description,
+            num_workers=num_workers,
+            timeout=timeout,
+            project_root=project_root,
+            runs_per_query=runs_per_query,
+            trigger_threshold=trigger_threshold,
+            model=model,
+        )
+        eval_elapsed = time.time() - t0
+
+        # Split results back into train/test by matching queries
+        train_queries_set = {q["query"] for q in train_set}
+        train_result_list = [r for r in all_results["results"] if r["query"] in train_queries_set]
+        test_result_list = [r for r in all_results["results"] if r["query"] not in train_queries_set]
+
+        train_passed = sum(1 for r in train_result_list if r["pass"])
+        train_total = len(train_result_list)
+        train_summary = {"passed": train_passed, "failed": train_total - train_passed, "total": train_total}
+        train_results = {"results": train_result_list, "summary": train_summary}
+
+        if test_set:
+            test_passed = sum(1 for r in test_result_list if r["pass"])
+            test_total = len(test_result_list)
+            test_summary = {"passed": test_passed, "failed": test_total - test_passed, "total": test_total}
+            test_results = {"results": test_result_list, "summary": test_summary}
+        else:
+            test_results = None
+            test_summary = None
+
+        history.append({
+            "iteration": iteration,
+            "description": current_description,
+            "train_passed": train_summary["passed"],
+            "train_failed": train_summary["failed"],
+            "train_total": train_summary["total"],
+            "train_results": train_results["results"],
+            "test_passed": test_summary["passed"] if test_summary else None,
+            "test_failed": test_summary["failed"] if test_summary else None,
+            "test_total": test_summary["total"] if test_summary else None,
+            "test_results": test_results["results"] if test_results else None,
+            # For backward compat with report generator
+            "passed": train_summary["passed"],
+            "failed": train_summary["failed"],
+            "total": train_summary["total"],
+            "results": train_results["results"],
+        })
+
+        # Write live report if path provided
+        if live_report_path:
+            partial_output = {
+                "original_description": original_description,
+                "best_description": current_description,
+                "best_score": "in progress",
+                "iterations_run": len(history),
+                "holdout": holdout,
+                "train_size": len(train_set),
+                "test_size": len(test_set),
+                "history": history,
+            }
+            live_report_path.write_text(generate_html(partial_output, auto_refresh=True, skill_name=name))
+
+        if verbose:
+            def print_eval_stats(label, results, elapsed):
+                pos = [r for r in results if r["should_trigger"]]
+                neg = [r for r in results if not r["should_trigger"]]
+                tp = sum(r["triggers"] for r in pos)
+                pos_runs = sum(r["runs"] for r in pos)
+                fn = pos_runs - tp
+                fp = sum(r["triggers"] for r in neg)
+                neg_runs = sum(r["runs"] for r in neg)
+                tn = neg_runs - fp
+                total = tp + tn + fp + fn
+                precision = tp / (tp + fp) if (tp + fp) > 0 else 1.0
+                recall = tp / (tp + fn) if (tp + fn) > 0 else 1.0
+                accuracy = (tp + tn) / total if total > 0 else 0.0
+                print(f"{label}: {tp+tn}/{total} correct, precision={precision:.0%} recall={recall:.0%} accuracy={accuracy:.0%} ({elapsed:.1f}s)", file=sys.stderr)
+                for r in results:
+                    status = "PASS" if r["pass"] else "FAIL"
+                    rate_str = f"{r['triggers']}/{r['runs']}"
+                    print(f"  [{status}] rate={rate_str} expected={r['should_trigger']}: {r['query'][:60]}", file=sys.stderr)
+
+            print_eval_stats("Train", train_results["results"], eval_elapsed)
+            if test_summary:
+                print_eval_stats("Test ", test_results["results"], 0)
+
+        if train_summary["failed"] == 0:
+            exit_reason = f"all_passed (iteration {iteration})"
+            if verbose:
+                print(f"\nAll train queries passed on iteration {iteration}!", file=sys.stderr)
+            break
+
+        if iteration == max_iterations:
+            exit_reason = f"max_iterations ({max_iterations})"
+            if verbose:
+                print(f"\nMax iterations reached ({max_iterations}).", file=sys.stderr)
+            break
+
+        # Improve the description based on train results
+        if verbose:
+            print(f"\nImproving description...", file=sys.stderr)
+
+        t0 = time.time()
+        # Strip test scores from history so improvement model can't see them
+        blinded_history = [
+            {k: v for k, v in h.items() if not k.startswith("test_")}
+            for h in history
+        ]
+        new_description = improve_description(
+            skill_name=name,
+            skill_content=content,
+            current_description=current_description,
+            eval_results=train_results,
+            history=blinded_history,
+            model=model,
+            log_dir=log_dir,
+            iteration=iteration,
+        )
+        improve_elapsed = time.time() - t0
+
+        if verbose:
+            print(f"Proposed ({improve_elapsed:.1f}s): {new_description}", file=sys.stderr)
+
+        current_description = new_description
+
+    # Find the best iteration by TEST score (or train if no test set)
+    if test_set:
+        best = max(history, key=lambda h: h["test_passed"] or 0)
+        best_score = f"{best['test_passed']}/{best['test_total']}"
+    else:
+        best = max(history, key=lambda h: h["train_passed"])
+        best_score = f"{best['train_passed']}/{best['train_total']}"
+
+    if verbose:
+        print(f"\nExit reason: {exit_reason}", file=sys.stderr)
+        print(f"Best score: {best_score} (iteration {best['iteration']})", file=sys.stderr)
+
+    return {
+        "exit_reason": exit_reason,
+        "original_description": original_description,
+        "best_description": best["description"],
+        "best_score": best_score,
+        "best_train_score": f"{best['train_passed']}/{best['train_total']}",
+        "best_test_score": f"{best['test_passed']}/{best['test_total']}" if test_set else None,
+        "final_description": current_description,
+        "iterations_run": len(history),
+        "holdout": holdout,
+        "train_size": len(train_set),
+        "test_size": len(test_set),
+        "history": history,
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Run eval + improve loop")
+    parser.add_argument("--eval-set", required=True, help="Path to eval set JSON file")
+    parser.add_argument("--skill-path", required=True, help="Path to skill directory")
+    parser.add_argument("--description", default=None, help="Override starting description")
+    parser.add_argument("--num-workers", type=int, default=10, help="Number of parallel workers")
+    parser.add_argument("--timeout", type=int, default=30, help="Timeout per query in seconds")
+    parser.add_argument("--max-iterations", type=int, default=5, help="Max improvement iterations")
+    parser.add_argument("--runs-per-query", type=int, default=3, help="Number of runs per query")
+    parser.add_argument("--trigger-threshold", type=float, default=0.5, help="Trigger rate threshold")
+    parser.add_argument("--holdout", type=float, default=0.4, help="Fraction of eval set to hold out for testing (0 to disable)")
+    parser.add_argument("--model", required=True, help="Model for improvement")
+    parser.add_argument("--verbose", action="store_true", help="Print progress to stderr")
+    parser.add_argument("--report", default="auto", help="Generate HTML report at this path (default: 'auto' for temp file, 'none' to disable)")
+    parser.add_argument("--results-dir", default=None, help="Save all outputs (results.json, report.html, log.txt) to a timestamped subdirectory here")
+    args = parser.parse_args()
+
+    eval_set = json.loads(Path(args.eval_set).read_text())
+    skill_path = Path(args.skill_path)
+
+    if not (skill_path / "SKILL.md").exists():
+        print(f"Error: No SKILL.md found at {skill_path}", file=sys.stderr)
+        sys.exit(1)
+
+    name, _, _ = parse_skill_md(skill_path)
+
+    # Set up live report path
+    if args.report != "none":
+        if args.report == "auto":
+            timestamp = time.strftime("%Y%m%d_%H%M%S")
+            live_report_path = Path(tempfile.gettempdir()) / f"skill_description_report_{skill_path.name}_{timestamp}.html"
+        else:
+            live_report_path = Path(args.report)
+        # Open the report immediately so the user can watch
+        live_report_path.write_text("<html><body><h1>Starting optimization loop...</h1><meta http-equiv='refresh' content='5'></body></html>")
+        webbrowser.open(str(live_report_path))
+    else:
+        live_report_path = None
+
+    # Determine output directory (create before run_loop so logs can be written)
+    if args.results_dir:
+        timestamp = time.strftime("%Y-%m-%d_%H%M%S")
+        results_dir = Path(args.results_dir) / timestamp
+        results_dir.mkdir(parents=True, exist_ok=True)
+    else:
+        results_dir = None
+
+    log_dir = results_dir / "logs" if results_dir else None
+
+    output = run_loop(
+        eval_set=eval_set,
+        skill_path=skill_path,
+        description_override=args.description,
+        num_workers=args.num_workers,
+        timeout=args.timeout,
+        max_iterations=args.max_iterations,
+        runs_per_query=args.runs_per_query,
+        trigger_threshold=args.trigger_threshold,
+        holdout=args.holdout,
+        model=args.model,
+        verbose=args.verbose,
+        live_report_path=live_report_path,
+        log_dir=log_dir,
+    )
+
+    # Save JSON output
+    json_output = json.dumps(output, indent=2)
+    print(json_output)
+    if results_dir:
+        (results_dir / "results.json").write_text(json_output)
+
+    # Write final HTML report (without auto-refresh)
+    if live_report_path:
+        live_report_path.write_text(generate_html(output, auto_refresh=False, skill_name=name))
+        print(f"\nReport: {live_report_path}", file=sys.stderr)
+
+    if results_dir and live_report_path:
+        (results_dir / "report.html").write_text(generate_html(output, auto_refresh=False, skill_name=name))
+
+    if results_dir:
+        print(f"Results saved to: {results_dir}", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()

package/dist/agent/skills/skill-creator/scripts/utils.py

@@ -0,0 +1,47 @@
+"""Shared utilities for skill-creator scripts."""
+
+from pathlib import Path
+
+
+
+def parse_skill_md(skill_path: Path) -> tuple[str, str, str]:
+    """Parse a SKILL.md file, returning (name, description, full_content)."""
+    content = (skill_path / "SKILL.md").read_text()
+    lines = content.split("\n")
+
+    if lines[0].strip() != "---":
+        raise ValueError("SKILL.md missing frontmatter (no opening ---)")
+
+    end_idx = None
+    for i, line in enumerate(lines[1:], start=1):
+        if line.strip() == "---":
+            end_idx = i
+            break
+
+    if end_idx is None:
+        raise ValueError("SKILL.md missing frontmatter (no closing ---)")
+
+    name = ""
+    description = ""
+    frontmatter_lines = lines[1:end_idx]
+    i = 0
+    while i < len(frontmatter_lines):
+        line = frontmatter_lines[i]
+        if line.startswith("name:"):
+            name = line[len("name:"):].strip().strip('"').strip("'")
+        elif line.startswith("description:"):
+            value = line[len("description:"):].strip()
+            # Handle YAML multiline indicators (>, |, >-, |-)
+            if value in (">", "|", ">-", "|-"):
+                continuation_lines: list[str] = []
+                i += 1
+                while i < len(frontmatter_lines) and (frontmatter_lines[i].startswith("  ") or frontmatter_lines[i].startswith("\t")):
+                    continuation_lines.append(frontmatter_lines[i].strip())
+                    i += 1
+                description = " ".join(continuation_lines)
+                continue
+            else:
+                description = value.strip('"').strip("'")
+        i += 1
+
+    return name, description, content

package/dist/agent/skills.js

@@ -0,0 +1,129 @@
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+export function getDefaultSkillCreationRoot() {
+    return path.join(os.homedir(), '.900', 'skills');
+}
+function stripQuotes(value) {
+    const trimmedValue = value.trim();
+    if ((trimmedValue.startsWith('"') && trimmedValue.endsWith('"')) ||
+        (trimmedValue.startsWith("'") && trimmedValue.endsWith("'"))) {
+        return trimmedValue.slice(1, -1);
+    }
+    return trimmedValue;
+}
+function parseSkillFrontmatter(markdown, skillFilePath) {
+    const lines = markdown.split(/\r?\n/);
+    if (lines[0] !== '---') {
+        throw new Error(`Skill file is missing frontmatter: ${skillFilePath}`);
+    }
+    const endIndex = lines.findIndex((line, index) => index > 0 && line === '---');
+    if (endIndex === -1) {
+        throw new Error(`Skill file has unterminated frontmatter: ${skillFilePath}`);
+    }
+    const values = new Map();
+    for (const line of lines.slice(1, endIndex)) {
+        const separatorIndex = line.indexOf(':');
+        if (separatorIndex === -1)
+            continue;
+        const key = line.slice(0, separatorIndex).trim();
+        const value = stripQuotes(line.slice(separatorIndex + 1));
+        values.set(key, value);
+    }
+    const name = values.get('name')?.trim();
+    const description = values.get('description')?.trim();
+    if (!name) {
+        throw new Error(`Skill file is missing name: ${skillFilePath}`);
+    }
+    if (!description) {
+        throw new Error(`Skill file is missing description: ${skillFilePath}`);
+    }
+    return { name, description };
+}
+function assertInsideRoot(root, targetPath) {
+    const realRoot = realpathSync(root);
+    const realTarget = realpathSync(targetPath);
+    const relativePath = path.relative(realRoot, realTarget);
+    if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+        throw new Error(`Skill file must be inside skills root: ${targetPath}`);
+    }
+}
+export function loadSkillsFromRoot(skillsRoot) {
+    if (!existsSync(skillsRoot)) {
+        return { skillsRoot, skills: [] };
+    }
+    const rootStats = statSync(skillsRoot);
+    if (!rootStats.isDirectory()) {
+        throw new Error(`Skills root must be a directory: ${skillsRoot}`);
+    }
+    const skills = [];
+    const seenNames = new Set();
+    for (const entry of readdirSync(skillsRoot, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const skillFilePath = path.join(skillsRoot, entry.name, 'SKILL.md');
+        if (!existsSync(skillFilePath))
+            continue;
+        assertInsideRoot(skillsRoot, skillFilePath);
+        const markdown = readFileSync(skillFilePath, 'utf8');
+        const summary = parseSkillFrontmatter(markdown, skillFilePath);
+        if (seenNames.has(summary.name)) {
+            throw new Error(`Duplicate skill name: ${summary.name}`);
+        }
+        seenNames.add(summary.name);
+        skills.push({ ...summary, skillFilePath, root: skillsRoot });
+    }
+    skills.sort((a, b) => a.name.localeCompare(b.name));
+    return { skillsRoot, skills };
+}
+export function getUserSkillRoots() {
+    const home = os.homedir();
+    return [
+        path.join(home, '.agents', 'skills'),
+        path.join(home, '.900', '.agents', 'skills'),
+        path.join(home, '.900', 'skills'),
+    ];
+}
+export function mergeSkillRegistries(registries) {
+    const skillMap = new Map();
+    let lastRoot = getDefaultSkillCreationRoot();
+    for (const registry of registries) {
+        if (registry.skills.length > 0) {
+            lastRoot = registry.skillsRoot;
+        }
+        for (const skill of registry.skills) {
+            skillMap.set(skill.name, skill);
+        }
+    }
+    const skills = Array.from(skillMap.values()).toSorted((a, b) => a.name.localeCompare(b.name));
+    return { skillsRoot: lastRoot, skills };
+}
+const defaultRegistry = mergeSkillRegistries(getUserSkillRoots().map(loadSkillsFromRoot));
+export function getSkillSummaries(registry = defaultRegistry) {
+    return registry.skills.map(({ name, description }) => ({ name, description }));
+}
+export function formatSkillsForSystemPrompt(registry = defaultRegistry) {
+    const summaries = getSkillSummaries(registry);
+    if (summaries.length === 0) {
+        return '';
+    }
+    const skillLines = summaries.map((skill) => `- ${skill.name}: ${skill.description}`).join('\n');
+    return `Available skills:\nThe following skills are available. Each entry contains only the skill name and description. When a user request matches a skill, call load_skill_tool with exactly one skillName before applying that skill.\n\n${skillLines}`;
+}
+export function formatSkillCreationInstructions() {
+    const skillFilePath = path.join(getDefaultSkillCreationRoot(), '<kebab-case-skill-name>', 'SKILL.md');
+    return `Argos skill creation rules:\nWhen the user asks to create a new Argos skill, create actual files under ${getDefaultSkillCreationRoot()}. Use write_file_tool to write the completed skill to ${skillFilePath}. Do not merely draft the skill in chat unless the user explicitly asks for a draft only. The SKILL.md file must include YAML frontmatter with name and description. Put optional bundled resources under the same skill directory. After writing the files, tell the user that Argos scans skills at startup, so they should restart Argos before the new skill appears in Available skills.`;
+}
+export function loadSkillByName(skillName, registry = defaultRegistry) {
+    const trimmedSkillName = skillName.trim();
+    if (!trimmedSkillName) {
+        throw new Error('Skill name is required.');
+    }
+    const skill = registry.skills.find((item) => item.name === trimmedSkillName);
+    if (!skill) {
+        const availableSkills = registry.skills.map((item) => item.name).join(', ') || 'none';
+        throw new Error(`Unknown skill: ${trimmedSkillName}. Available skills: ${availableSkills}.`);
+    }
+    assertInsideRoot(skill.root, skill.skillFilePath);
+    return readFileSync(skill.skillFilePath, 'utf8');
+}

package/dist/agent/tools/agent_tool/agent_tool.test.js

@@ -0,0 +1,64 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { agentTool, registerSubagentRunner, resetAgentToolForTesting, } from './index.js';
+import { getToolsForRunMode, subagentTools, tools } from '../../tools.js';
+beforeEach(() => {
+    resetAgentToolForTesting();
+});
+describe('agentTool', () => {
+    it('rejects empty prompts', async () => {
+        const runner = vi.fn(async () => 'done');
+        registerSubagentRunner(runner);
+        await expect(agentTool('')).rejects.toThrow('Prompt is required.');
+        await expect(agentTool('   ')).rejects.toThrow('Prompt is required.');
+        expect(runner).not.toHaveBeenCalled();
+    });
+    it('rejects when the subagent runner is not registered', async () => {
+        await expect(agentTool('do work')).rejects.toThrow('Subagent runner is not registered.');
+    });
+    it('trims the prompt before invoking the runner', async () => {
+        const runner = vi.fn(async () => 'subagent result');
+        registerSubagentRunner(runner);
+        await expect(agentTool('  summarize package.json  ', 'parent-1')).resolves.toBe('subagent result');
+        expect(runner).toHaveBeenCalledWith({
+            prompt: 'summarize package.json',
+            parentThreadId: 'parent-1',
+        });
+    });
+    it('returns the runner result', async () => {
+        const runner = vi.fn(async () => 'final answer');
+        registerSubagentRunner(runner);
+        await expect(agentTool('do work')).resolves.toBe('final answer');
+    });
+    it('allows only one active subagent at a time', async () => {
+        let resolveFirst;
+        const firstRun = new Promise((resolve) => {
+            resolveFirst = resolve;
+        });
+        const runner = vi.fn(() => firstRun);
+        registerSubagentRunner(runner);
+        const first = agentTool('first');
+        await expect(agentTool('second')).rejects.toThrow('A subagent is already running.');
+        resolveFirst('first done');
+        await expect(first).resolves.toBe('first done');
+        expect(runner).toHaveBeenCalledTimes(1);
+    });
+    it('releases the active subagent lock when the runner fails', async () => {
+        const runner = vi
+            .fn()
+            .mockRejectedValueOnce(new Error('boom'))
+            .mockResolvedValueOnce('recovered');
+        registerSubagentRunner(runner);
+        await expect(agentTool('fail first')).rejects.toThrow('boom');
+        await expect(agentTool('try again')).resolves.toBe('recovered');
+        expect(runner).toHaveBeenCalledTimes(2);
+    });
+});
+describe('agent_tool registration', () => {
+    it('registers agent_tool as an exec tool for main agents only', () => {
+        const mainAgentTool = tools.find((t) => t.name === 'agent_tool');
+        expect(mainAgentTool?.permission_level).toBe('exec');
+        expect(subagentTools.some((t) => t.name === 'agent_tool')).toBe(false);
+        expect(getToolsForRunMode('main').some((t) => t.name === 'agent_tool')).toBe(true);
+        expect(getToolsForRunMode('subagent').some((t) => t.name === 'agent_tool')).toBe(false);
+    });
+});

package/dist/agent/tools/agent_tool/index.js

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+export const agentToolSchema = z.object({
+    prompt: z.string().describe('Plain text prompt for the subagent. Do not include chat history.'),
+});
+let subagentRunner = null;
+let activeSubagent = null;
+export function registerSubagentRunner(runner) {
+    subagentRunner = runner;
+}
+export async function agentTool(prompt, parentThreadId) {
+    const trimmedPrompt = prompt.trim();
+    if (!trimmedPrompt) {
+        throw new Error('Prompt is required.');
+    }
+    if (!subagentRunner) {
+        throw new Error('Subagent runner is not registered.');
+    }
+    if (activeSubagent) {
+        throw new Error('A subagent is already running. Wait for it to finish before starting another one.');
+    }
+    const task = subagentRunner({ prompt: trimmedPrompt, parentThreadId });
+    activeSubagent = task;
+    try {
+        return await task;
+    }
+    finally {
+        activeSubagent = null;
+    }
+}
+export function resetAgentToolForTesting() {
+    subagentRunner = null;
+    activeSubagent = null;
+}

package/dist/agent/tools/exec_tool/exec_tool.test.js

@@ -0,0 +1,48 @@
+import { mkdir, mkdtemp, rm, symlink, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { execTool } from './index.js';
+let originalCwd;
+let tempRoot;
+let currentDir;
+let outsideDir;
+beforeEach(async () => {
+    originalCwd = process.cwd();
+    tempRoot = await mkdtemp(path.join(tmpdir(), 'argos-exec-'));
+    currentDir = path.join(tempRoot, 'current');
+    outsideDir = path.join(tempRoot, 'outside');
+    await mkdir(currentDir);
+    await mkdir(outsideDir);
+    process.chdir(currentDir);
+});
+afterEach(async () => {
+    process.chdir(originalCwd);
+    await rm(tempRoot, { recursive: true, force: true });
+});
+describe('execTool', () => {
+    it('executes a safe command in the current working directory', async () => {
+        await mkdir('src');
+        await writeFile(path.join('src', 'hello.ts'), 'export {};');
+        await expect(execTool('ls src')).resolves.toContain('hello.ts');
+    });
+    it('executes a safe command in a nested working directory', async () => {
+        await mkdir('src');
+        await writeFile(path.join('src', 'hello.ts'), 'export {};');
+        await expect(execTool('ls', 'src')).resolves.toContain('hello.ts');
+    });
+    it('rejects path traversal outside the current working directory', async () => {
+        await expect(execTool('ls', '..')).rejects.toThrow('Can only execute commands inside the current working directory.');
+    });
+    it('rejects absolute working directories outside the current working directory', async () => {
+        await expect(execTool('ls', outsideDir)).rejects.toThrow('Can only execute commands inside the current working directory.');
+    });
+    it('rejects symlink working directories that point outside the current working directory', async () => {
+        await symlink(outsideDir, 'outside-link');
+        await expect(execTool('ls', 'outside-link')).rejects.toThrow('Can only execute commands inside the current working directory.');
+    });
+    it('rejects empty commands', async () => {
+        await expect(execTool('')).rejects.toThrow('Command is required.');
+        await expect(execTool('   ')).rejects.toThrow('Command is required.');
+    });
+});