zilmate 1.3.5 → 1.6.0

package/.env.example

@@ -24,6 +24,8 @@ ZILMATE_VOICE_INPUT_DEVICE=
 ZILMATE_SCREENSHOT_MODEL=google/gemini-3.1-flash-lite
 ZILMATE_CAMERA_DEVICE=
 ZILMATE_FILE_ROOTS=
+ZILMATE_WORKSPACE=
+ZILMATE_WEBHOOK_PORT=8787
 ZILO_MANAGER_MODEL=minimax/minimax-m3
 ZILO_HELP_MODEL=alibaba/qwen3.7-plus
 ZILO_POST_MODEL=alibaba/qwen3.7-plus

package/dist/agents/automation-planner.agent.d.ts

@@ -3,6 +3,114 @@ export declare function createAutomationPlannerAgent(): ToolLoopAgent<never, {
     appKnowledge: import("ai").Tool<{
         key: "agent-docs" | "readme";
     }, string>;
+    getPersonalContext: import("ai").Tool<Record<string, never>, {
+        context: import("../memory/personal-context.js").PersonalContext;
+        summary: string;
+    }>;
+    updatePersonalContext: import("ai").Tool<{
+        ownerName?: string | undefined;
+        businessName?: string | undefined;
+        urgencyRule?: string | undefined;
+        workflow?: string | undefined;
+        contact?: {
+            name: string;
+            vip: boolean;
+            id?: string | undefined;
+            email?: string | undefined;
+            handle?: string | undefined;
+            role?: string | undefined;
+            notes?: string | undefined;
+        } | undefined;
+        project?: {
+            name: string;
+            status: "done" | "active" | "paused";
+            tags: string[];
+            id?: string | undefined;
+            description?: string | undefined;
+        } | undefined;
+    }, {
+        updated: boolean;
+        summary: string;
+    }>;
+    listTriggerPolicies: import("ai").Tool<Record<string, never>, import("../jobs/trigger-policies.js").TriggerRoutingPolicy[]>;
+    getTriggerPolicy: import("ai").Tool<Record<string, never>, import("../jobs/trigger-policies.js").TriggerRoutingPolicy>;
+    saveTriggerPolicy: import("ai").Tool<{
+        policy: {
+            name: string;
+            enabled: boolean;
+            vipSenders: string[];
+            urgentKeywords: string[];
+            lowPriorityKeywords: string[];
+            customInstructions: string;
+            id?: string | undefined;
+        };
+    }, {
+        updatedAt: string;
+        id: string;
+        name: string;
+        enabled: boolean;
+        vipSenders: string[];
+        urgentKeywords: string[];
+        lowPriorityKeywords: string[];
+        customInstructions: string;
+        routes: Partial<Record<import("../jobs/trigger-orchestrator.js").TriggerRoute, import("../jobs/trigger-policies.js").RoutePolicy>>;
+        createdAt: string;
+    }>;
+    proposeTriggerOrchestration: import("ai").Tool<{
+        triggerSlug: string;
+        toolkitSlug: string;
+        payload?: Record<string, unknown> | undefined;
+    }, {
+        proposal: string;
+        plan: {
+            chainId: string;
+            priority: import("../jobs/trigger-orchestrator.js").TriggerPriority;
+            route: import("../jobs/trigger-orchestrator.js").TriggerRoute;
+            category: string;
+            followUpCount: number;
+            followUps: import("../jobs/trigger-orchestrator.js").TriggerFollowUp[];
+        };
+    }>;
+    applyTriggerOrchestration: import("ai").Tool<{
+        triggerSlug: string;
+        toolkitSlug: string;
+        payload?: Record<string, unknown> | undefined;
+        triggerId?: string | undefined;
+        userId?: string | undefined;
+        dryRun?: boolean | undefined;
+    }, {
+        dryRun: boolean;
+        proposal: string;
+        plan: import("../jobs/trigger-orchestrator.js").TriggerOrchestrationPlan;
+        applied?: never;
+        blocked?: never;
+        message?: never;
+        jobs?: never;
+        report?: never;
+    } | {
+        applied: boolean;
+        blocked: boolean;
+        proposal: string;
+        message: string;
+        dryRun?: never;
+        plan?: never;
+        jobs?: never;
+        report?: never;
+    } | {
+        applied: boolean;
+        proposal: string;
+        jobs: {
+            id: string;
+            status: import("../server.js").JobStatus;
+            schedule: string | undefined;
+            role: unknown;
+        }[];
+        report: string;
+        dryRun?: never;
+        plan?: never;
+        blocked?: never;
+        message?: never;
+    }>;
     listTriggerTypes: import("ai").Tool<{
         toolkit?: string | undefined;
         limit?: number | undefined;

package/dist/agents/automation-planner.agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"automation-planner.agent.d.ts","sourceRoot":"","sources":["../../src/agents/automation-planner.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,aAAa,EAAE,MAAM,IAAI,CAAC;AAQhD,wBAAgB,4BAA4B;;;;;;;;;;;;;;;;;;;mBAoBw7zG,CAAC;wBAAsC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAAz2S,CAAC;uBAAqC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UADzshG"}
+{"version":3,"file":"automation-planner.agent.d.ts","sourceRoot":"","sources":["../../src/agents/automation-planner.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,aAAa,EAAE,MAAM,IAAI,CAAC;AAUhD,wBAAgB,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA2BksyG,CAAC;wBAAsC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAAz2S,CAAC;uBAAqC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UADn9/F"}

package/dist/agents/automation-planner.agent.js

@@ -4,22 +4,31 @@ import { appKnowledgeTool } from '../tools/app-knowledge.tool.js';
 import { jobTools } from '../tools/jobs.tool.js';
 import { timeTools } from '../tools/time.tool.js';
 import { triggerTools } from '../tools/triggers.tool.js';
+import { orchestrationTools } from '../tools/orchestration.tool.js';
+import { personalContextTools } from '../tools/personal-context.tool.js';
 import { limits } from '../safety/limits.js';
 export function createAutomationPlannerAgent() {
     return new ToolLoopAgent({
         model: models.manager,
         instructions: [
-            'You are ZilMate Automation Planner. Design practical automations, schedules, background jobs, trigger workflows, and follow-up flows.',
+            'You are ZilMate Automation Planner. Design practical automations, schedules, background jobs, trigger workflows, and follow-up chains.',
+            'Use getPersonalContext and updatePersonalContext so routing reflects the user\'s VIP contacts, projects, and urgency rules.',
+            'Use listTriggerPolicies, getTriggerPolicy, and saveTriggerPolicy to manage routing behavior.',
+            'Always use proposeTriggerOrchestration to preview what will happen before applyTriggerOrchestration creates jobs.',
+            'When applyTriggerOrchestration needs approval, tell the user exactly what primary and follow-up jobs will be created. The confirmation prompt handles yes/no.',
+            'After applying orchestration, report job ids, route, priority, and any skipped follow-ups waiting for approval.',
             'Use time tools for current date/time and schedule-relative wording.',
-            'Use job tools to inspect existing jobs and logs. Create or cancel jobs only when the user clearly asks and approval is available through the manager.',
-            'Use trigger tools to discover Composio trigger types, inspect schemas, and reason about trigger setup. Prefer dry-run thinking before real creation.',
-            'Explain local worker limits clearly: local jobs need `zilmate jobs worker`; laptop-closed automation needs QStash plus a public job webhook.',
+            'Use job tools to inspect existing jobs and logs. Create or cancel jobs only when the user clearly asks.',
+            'Use trigger tools to discover Composio trigger types and inspect schemas. Prefer dry-run before real creation.',
+            'Explain local worker limits: local jobs need `zilmate jobs worker`; laptop-closed automation needs QStash plus a public job webhook.',
             'Return concise plans with exact commands or setup steps when useful.',
         ].join(' '),
         tools: {
             ...timeTools,
             ...jobTools,
             ...triggerTools,
+            ...orchestrationTools,
+            ...personalContextTools,
             appKnowledge: appKnowledgeTool,
         },
         stopWhen: stepCountIs(limits.subagentSteps),

package/dist/agents/automation-planner.agent.js.map

@@ -1 +1 @@
-{"version":3,"file":"automation-planner.agent.js","sourceRoot":"","sources":["../../src/agents/automation-planner.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE7C,MAAM,UAAU,4BAA4B;IAC1C,OAAO,IAAI,aAAa,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC,OAAO;QACrB,YAAY,EAAE;YACZ,uIAAuI;YACvI,qEAAqE;YACrE,uJAAuJ;YACvJ,sJAAsJ;YACtJ,8IAA8I;YAC9I,sEAAsE;SACvE,CAAC,IAAI,CAAC,GAAG,CAAC;QACX,KAAK,EAAE;YACL,GAAG,SAAS;YACZ,GAAG,QAAQ;YACX,GAAG,YAAY;YACf,YAAY,EAAE,gBAAgB;SAC/B;QACD,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,aAAa,CAAC;KAC5C,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"automation-planner.agent.js","sourceRoot":"","sources":["../../src/agents/automation-planner.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE7C,MAAM,UAAU,4BAA4B;IAC1C,OAAO,IAAI,aAAa,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC,OAAO;QACrB,YAAY,EAAE;YACZ,wIAAwI;YACxI,6HAA6H;YAC7H,8FAA8F;YAC9F,mHAAmH;YACnH,+JAA+J;YAC/J,iHAAiH;YACjH,qEAAqE;YACrE,yGAAyG;YACzG,gHAAgH;YAChH,sIAAsI;YACtI,sEAAsE;SACvE,CAAC,IAAI,CAAC,GAAG,CAAC;QACX,KAAK,EAAE;YACL,GAAG,SAAS;YACZ,GAAG,QAAQ;YACX,GAAG,YAAY;YACf,GAAG,kBAAkB;YACrB,GAAG,oBAAoB;YACvB,YAAY,EAAE,gBAAgB;SAC/B;QACD,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,aAAa,CAAC;KAC5C,CAAC,CAAC;AACL,CAAC"}

package/dist/agents/coding.agent.d.ts

@@ -0,0 +1,352 @@
+import { ToolLoopAgent } from 'ai';
+export declare function createCodingAgent(runId?: string): ToolLoopAgent<never, {
+    readScratchpad: import("ai").Tool<Record<string, never>, string>;
+    appendScratchpad: import("ai").Tool<{
+        note: string;
+    }, string>;
+    listSkills: import("ai").Tool<Record<string, never>, {
+        skills: import("../skills/loader.js").SkillSummary[];
+        searchPaths: string[];
+        registry: string;
+    }>;
+    searchSkills: import("ai").Tool<{
+        query: string;
+        limit?: number | undefined;
+    }, {
+        query: string;
+        skills: import("../skills/loader.js").SkillSummary[];
+        scope: string;
+    }>;
+    searchSkillsRegistry: import("ai").Tool<{
+        query: string;
+        limit?: number | undefined;
+    }, {
+        query: string;
+        results: import("../skills/registry.js").RegistrySkill[];
+        installHint: string;
+        browse: string;
+    }>;
+    installRegistrySkill: import("ai").Tool<{
+        packageRef: string;
+        global?: boolean | undefined;
+    }, {
+        ok: boolean;
+        packageRef: string;
+        installPath: string;
+        output: string;
+        browse: string;
+    }>;
+    readSkill: import("ai").Tool<{
+        skillId: string;
+    }, import("../skills/loader.js").SkillContent>;
+    executeCommand: import("ai").Tool<{
+        command: string;
+        cwd?: string | undefined;
+        timeout?: number | undefined;
+        env?: Record<string, string> | undefined;
+    }, {
+        success: boolean;
+        exit: any;
+        stdout: any;
+        stderr: any;
+        command: string;
+    }>;
+    installDependencies: import("ai").Tool<{
+        command: string;
+        manager?: "npm" | "pnpm" | "yarn" | undefined;
+        cwd?: string | undefined;
+        timeout?: number | undefined;
+    }, {
+        success: boolean;
+        exit: any;
+        manager: string;
+        stdout: any;
+        stderr: any;
+    }>;
+    runPipeline: import("ai").Tool<{
+        commands: string[];
+        cwd?: string | undefined;
+        timeout?: number | undefined;
+    }, {
+        success: boolean;
+        exit: any;
+        stdout: any;
+        stderr: any;
+        pipeline: string;
+    }>;
+    pythonScript: import("ai").Tool<{
+        code: string;
+        cwd?: string | undefined;
+        timeout?: number | undefined;
+    }, {
+        success: boolean;
+        exit: any;
+        stdout: any;
+        stderr: any;
+    }>;
+    getSystemInfo: import("ai").Tool<Record<string, never>, {
+        platform: NodeJS.Platform;
+        arch: NodeJS.Architecture;
+        release: string;
+        cpuCores: number;
+        totalMemoryGB: string;
+        freeMemoryGB: string;
+        nodeVersion: string;
+        currentUser: string;
+        uptime: string;
+        homeDir: string;
+    } | {
+        platform: NodeJS.Platform;
+        arch: NodeJS.Architecture;
+        error: any;
+    }>;
+    listProcesses: import("ai").Tool<{
+        filter?: string | undefined;
+        limit?: number | undefined;
+    }, {
+        processes: string[];
+        count: number;
+        filtered: boolean;
+        error?: never;
+    } | {
+        error: any;
+        processes: never[];
+        count: number;
+        filtered?: never;
+    }>;
+    findInPath: import("ai").Tool<{
+        command: string;
+    }, {
+        found: boolean;
+        command: string;
+        path: string;
+        suggestion?: never;
+    } | {
+        found: boolean;
+        command: string;
+        suggestion: string;
+        path?: never;
+    }>;
+    searchFiles: import("ai").Tool<{
+        query: string;
+        root?: string | undefined;
+        includeContent?: boolean | undefined;
+        maxDepth?: number | undefined;
+        maxResults?: number | undefined;
+    }, {
+        match: string;
+        excerpt: string;
+        path: string;
+        absolutePath: string;
+        type: "file" | "directory";
+        size: number;
+        modifiedAt: string;
+    }[]>;
+    readFile: import("ai").Tool<{
+        path: string;
+        maxBytes?: number | undefined;
+    }, {
+        path: string;
+        size: number;
+        modifiedAt: string;
+        truncated: boolean;
+        content: string;
+    }>;
+    writeFile: import("ai").Tool<{
+        path: string;
+        content: string;
+        mode?: "append" | "overwrite" | undefined;
+    }, {
+        path: string;
+        bytes: number;
+        mode: "append" | "overwrite";
+    }>;
+    createFolder: import("ai").Tool<{
+        path: string;
+    }, {
+        path: string;
+        created: boolean;
+    }>;
+    moveCopyRename: import("ai").Tool<{
+        operation: "move" | "copy" | "rename";
+        from: string;
+        to: string;
+        overwrite?: boolean | undefined;
+    }, {
+        operation: "move" | "copy" | "rename";
+        from: string;
+        to: string;
+    }>;
+    summarizeDocument: import("ai").Tool<{
+        path: string;
+        maxBytes?: number | undefined;
+    }, {
+        characters: number;
+        words: number;
+        summary: string;
+        path: string;
+        truncated: boolean;
+    }>;
+    watchFolderChanges: import("ai").Tool<{
+        path?: string | undefined;
+        watchName?: string | undefined;
+        reset?: boolean | undefined;
+        maxDepth?: number | undefined;
+    }, {
+        watchName: string;
+        baselineSaved: boolean;
+        added: string[];
+        changed: string[];
+        removed: string[];
+    }>;
+    findDuplicateLargeFiles: import("ai").Tool<{
+        root?: string | undefined;
+        minSizeBytes?: number | undefined;
+        maxDepth?: number | undefined;
+        maxResults?: number | undefined;
+    }, {
+        large: {
+            path: string;
+            absolutePath: string;
+            type: "file" | "directory";
+            size: number;
+            modifiedAt: string;
+        }[];
+        duplicateSizeGroups: {
+            size: number;
+            files: string[];
+        }[];
+    }>;
+    deleteFile: import("ai").Tool<{
+        path: string;
+        confirm: boolean;
+    }, {
+        deleted: boolean;
+        path: string;
+        size: number;
+    }>;
+    deleteFolder: import("ai").Tool<{
+        path: string;
+        confirm: boolean;
+    }, {
+        deleted: boolean;
+        path: string;
+    }>;
+    listDirectory: import("ai").Tool<{
+        path: string;
+        filter?: string | undefined;
+        includeHidden?: boolean | undefined;
+        maxDepth?: number | undefined;
+        limit?: number | undefined;
+    }, {
+        directory: string;
+        entries: {
+            path: string;
+            absolutePath: string;
+            type: "file" | "directory";
+            size: number;
+            modifiedAt: string;
+        }[];
+        count: number;
+        filtered: boolean;
+    }>;
+    getFileInfo: import("ai").Tool<{
+        path: string;
+    }, {
+        path: string;
+        type: string;
+        size: number;
+        sizeKB: string;
+        sizeMB: string;
+        created: string;
+        modified: string;
+        accessed: string;
+        isFile: boolean;
+        isDirectory: boolean;
+        isSymlink: boolean;
+        mode: string;
+    }>;
+    gitStatus: import("ai").Tool<{
+        short: boolean;
+        cwd?: string | undefined;
+    }, {
+        cwd: string;
+        output: string;
+    }>;
+    gitDiff: import("ai").Tool<{
+        staged: boolean;
+        cwd?: string | undefined;
+        path?: string | undefined;
+        commit?: string | undefined;
+    }, {
+        cwd: string;
+        output: string;
+    }>;
+    gitLog: import("ai").Tool<{
+        limit: number;
+        cwd?: string | undefined;
+        path?: string | undefined;
+    }, {
+        cwd: string;
+        output: string;
+    }>;
+    gitBranch: import("ai").Tool<{
+        action: "list" | "create" | "checkout";
+        cwd?: string | undefined;
+        name?: string | undefined;
+    }, {
+        cwd: string;
+        branches: string;
+        action?: never;
+        name?: never;
+        output?: never;
+    } | {
+        cwd: string;
+        action: "create" | "checkout";
+        name: string;
+        output: string;
+        branches?: never;
+    }>;
+    gitStage: import("ai").Tool<{
+        paths: string[];
+        cwd?: string | undefined;
+    }, {
+        cwd: string;
+        staged: string[];
+        output: string;
+    }>;
+    gitCommit: import("ai").Tool<{
+        message: string;
+        cwd?: string | undefined;
+    }, {
+        cwd: string;
+        message: string;
+        output: string;
+    }>;
+    applyUnifiedPatch: import("ai").Tool<{
+        patch: string;
+        dryRun: boolean;
+        cwd?: string | undefined;
+    }, {
+        dryRun: boolean;
+        cwd: string;
+        check: string;
+        applied?: never;
+        output?: never;
+    } | {
+        cwd: string;
+        applied: boolean;
+        output: string;
+        dryRun?: never;
+        check?: never;
+    }>;
+    getCurrentTime: import("ai").Tool<{
+        timeZone?: string | undefined;
+    }, {
+        iso: string;
+        unixMs: number;
+        timeZone: string;
+        formatted: string;
+    }>;
+}, never>;
+//# sourceMappingURL=coding.agent.d.ts.map

package/dist/agents/coding.agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coding.agent.d.ts","sourceRoot":"","sources":["../../src/agents/coding.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,aAAa,EAAE,MAAM,IAAI,CAAC;AAUhD,wBAAgB,iBAAiB,CAAC,KAAK,SAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAwBlD"}

package/dist/agents/coding.agent.js

@@ -0,0 +1,34 @@
+import { stepCountIs, ToolLoopAgent } from 'ai';
+import { models } from '../config/models.js';
+import { createScratchpadTools } from '../tools/scratchpad.tool.js';
+import { fileSystemTools } from '../tools/filesystem.tool.js';
+import { gitTools } from '../tools/git.tool.js';
+import { shellTools } from '../tools/shell.tool.js';
+import { skillTools } from '../tools/skills.tool.js';
+import { timeTools } from '../tools/time.tool.js';
+import { limits } from '../safety/limits.js';
+export function createCodingAgent(runId = 'default') {
+    const scratchpadTools = createScratchpadTools(runId);
+    return new ToolLoopAgent({
+        model: models.coding,
+        instructions: [
+            'You are ZilMate Coding Agent — a focused software engineering partner for this machine.',
+            'Prefer small, reviewable changes: read files, use gitDiff, applyUnifiedPatch for surgical edits instead of rewriting entire files.',
+            'Workflow: gitStatus → read affected files → gitDiff → patch or targeted writeFile → run tests via executeCommand → gitStage → gitCommit (only when user asked to commit).',
+            'Use git tools for branch awareness, diffs, staging, and commits. Never force-push unless the user explicitly requests it.',
+            'Use searchSkills/readSkill when a repo skill documents conventions.',
+            'Report what you changed, which files, and test/build output. Keep scratchpad notes for multi-file refactors.',
+            'Do not claim tests passed unless executeCommand output shows success.',
+        ].join(' '),
+        tools: {
+            ...timeTools,
+            ...gitTools,
+            ...fileSystemTools,
+            ...shellTools,
+            ...skillTools,
+            ...scratchpadTools,
+        },
+        stopWhen: stepCountIs(limits.subagentSteps),
+    });
+}
+//# sourceMappingURL=coding.agent.js.map

package/dist/agents/coding.agent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coding.agent.js","sourceRoot":"","sources":["../../src/agents/coding.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE7C,MAAM,UAAU,iBAAiB,CAAC,KAAK,GAAG,SAAS;IACjD,MAAM,eAAe,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAErD,OAAO,IAAI,aAAa,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC,MAAM;QACpB,YAAY,EAAE;YACZ,yFAAyF;YACzF,oIAAoI;YACpI,2KAA2K;YAC3K,2HAA2H;YAC3H,qEAAqE;YACrE,8GAA8G;YAC9G,uEAAuE;SACxE,CAAC,IAAI,CAAC,GAAG,CAAC;QACX,KAAK,EAAE;YACL,GAAG,SAAS;YACZ,GAAG,QAAQ;YACX,GAAG,eAAe;YAClB,GAAG,UAAU;YACb,GAAG,UAAU;YACb,GAAG,eAAe;SACnB;QACD,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,aAAa,CAAC;KAC5C,CAAC,CAAC;AACL,CAAC"}