zilmate 1.0.0 → 1.0.1

package/.env.example

@@ -4,6 +4,11 @@ ZILMATE_USER_ID=
 TAVILY_API_KEY=
 UPSTASH_REDIS_REST_URL=
 UPSTASH_REDIS_REST_TOKEN=
+ZILMATE_JOBS_ENABLED=false
+UPSTASH_QSTASH_TOKEN=
+ZILMATE_PUBLIC_JOB_WEBHOOK_URL=
+ZILMATE_JOB_WEBHOOK_SECRET=
+ZILMATE_TRIGGER_WORKFLOWS_ENABLED=false
 ZILO_MANAGER_MODEL=minimax/minimax-m3
 ZILO_HELP_MODEL=alibaba/qwen3.7-plus
 ZILO_POST_MODEL=alibaba/qwen3.7-plus

package/README.md

@@ -37,8 +37,8 @@ iwr https://raw.githubusercontent.com/zester4/zilo-manager/main/install.ps1 | ie
 The installer runs the full first-use flow:
 
 1. Installs ZilMate globally.
-2. Runs `zilmate setup` to collect `AI_GATEWAY_API_KEY`, optional `COMPOSIO_API_KEY`, optional `TAVILY_API_KEY`, and optional Redis keys.
-3. Lets users skip Composio, Tavily, and Redis keys.
+2. Runs `zilmate setup` to collect `AI_GATEWAY_API_KEY`.
+3. Lets users skip optional Composio, Tavily, Redis, background jobs, QStash, and trigger workflows.
 4. Runs `zilmate ping` to verify the key.
 5. Starts `zilmate talk`.
 
@@ -78,7 +78,16 @@ The easiest path is:
 zilmate setup
 ```
 
-It asks for `AI_GATEWAY_API_KEY`, optionally asks for `COMPOSIO_API_KEY`, `TAVILY_API_KEY`, and Upstash Redis keys, then writes a local `.env`. Composio, Tavily, and Redis can be skipped.
+It asks for `AI_GATEWAY_API_KEY`, then guides users through optional features:
+
+- Composio external app tools.
+- Tavily web research.
+- Upstash Redis memory/job storage.
+- Local background jobs and schedules.
+- Upstash QStash hosted schedules.
+- Composio trigger-to-job workflows.
+
+Every optional feature can be skipped. If users only want chat, they only need the AI Gateway key.
 
 You can also create `.env` manually:
 
@@ -89,6 +98,11 @@ ZILMATE_USER_ID=zilmate-generated-local-user-id
 TAVILY_API_KEY=your_tavily_key
 UPSTASH_REDIS_REST_URL=
 UPSTASH_REDIS_REST_TOKEN=
+ZILMATE_JOBS_ENABLED=false
+UPSTASH_QSTASH_TOKEN=
+ZILMATE_PUBLIC_JOB_WEBHOOK_URL=
+ZILMATE_JOB_WEBHOOK_SECRET=
+ZILMATE_TRIGGER_WORKFLOWS_ENABLED=false
 ZILO_MANAGER_MODEL=minimax/minimax-m3
 ZILO_HELP_MODEL=alibaba/qwen3.7-plus
 ZILO_POST_MODEL=alibaba/qwen3.7-plus
@@ -102,6 +116,16 @@ Composio is optional. If `COMPOSIO_API_KEY` is set, ZilMate creates a stable loc
 
 Redis is optional. If `UPSTASH_REDIS_REST_URL` and `UPSTASH_REDIS_REST_TOKEN` are set, chat turns, scratchpads, and Composio session ids use Redis. If they are missing, ZilMate falls back to local files under `.zilo-manager/`.
 
+Background jobs are optional. Setup explains the difference between local jobs and hosted schedules. Local jobs and local schedules run while `zilmate jobs worker` is running. They do not keep running after a laptop sleeps, shuts down, or loses internet. For hosted schedules that can fire while the local machine is closed, configure QStash plus a public job webhook URL.
+
+For unattended setup or installers, pass the options directly:
+
+```powershell
+zilmate setup --yes --ai-gateway-key <key> --jobs-enabled true
+zilmate setup --yes --ai-gateway-key <key> --composio-key <key> --trigger-workflows-enabled true
+zilmate setup --yes --ai-gateway-key <key> --qstash-token <token> --job-webhook-url https://example.com/api/zilmate/jobs
+```
+
 ## Development Commands
 
 Use these while working inside the project folder:
@@ -117,6 +141,9 @@ npm run zilmate -- apps status
 npm run zilmate -- triggers listen
 npm run zilmate -- triggers types github
 npm run zilmate -- triggers list
+npm run zilmate -- jobs create "Research today's priority updates and summarize them"
+npm run zilmate -- jobs list
+npm run zilmate -- jobs worker --once
 npm run zilmate -- remember "Prefers concise support replies"
 npm run zilmate -- recall support
 npm run zilmate -- memory list
@@ -163,6 +190,14 @@ zilmate triggers types github
 zilmate triggers create GITHUB_BRANCH_CREATED_TRIGGER --dry-run --owner zester4 --repo zilo-manager
 zilmate triggers create GITHUB_COMMIT_EVENT --owner zester4 --repo zilo-manager
 zilmate triggers list
+zilmate jobs create "Research today's priority updates and summarize them"
+zilmate jobs create "Prepare my weekday morning briefing" --schedule "daily"
+zilmate jobs list
+zilmate jobs status job_xxx
+zilmate jobs logs job_xxx
+zilmate jobs run job_xxx
+zilmate jobs worker
+zilmate jobs cancel job_xxx
 zilmate remember "Use a warm but concise support tone"
 zilmate recall support
 zilmate memory list
@@ -213,6 +248,7 @@ Available SDK methods:
 - `research({ query | message })`: local docs and web research.
 - `image({ prompt, provider, size, outputDir })`: image generation.
 - `remember({ text, tags })`, `recall({ query, limit })`, `listMemories()`, `forget(id)`, `clearMemories()`: durable memory helpers.
+- `createJob({ task, schedule, source, metadata })`, `listJobs({ status, limit })`, `getJob(id)`, `getJobLogs(id)`, `runJob(id)`, `runDueJobs()`, `handleJobWebhook({ jobId, secret }, expectedSecret)`, `cancelJob(id)`: background job and hosted webhook helpers.
 
 For UI integrations, pass `onProgress` to render agent/tool progress and `confirm` to approve or block external write-like Composio actions.
 
@@ -233,6 +269,13 @@ For UI integrations, pass `onProgress` to render agent/tool progress and `confir
 - `triggers info <trigger>`: show trigger config and payload schemas.
 - `triggers create <trigger> --flag value`: create a trigger instance; unknown flags become trigger config.
 - `triggers list`: list trigger instances.
+- `jobs create "<task>"`: queue a background job, optionally with `--schedule "daily"` or `--schedule "every 15 minutes"`.
+- `jobs list`: list queued/running/completed jobs.
+- `jobs status <id>`: inspect one job.
+- `jobs logs <id>`: inspect job progress, output, and errors.
+- `jobs run <id>`: run a queued job immediately.
+- `jobs worker`: run the local job processor and local scheduler.
+- `jobs cancel <id>`: cancel one job.
 - `help`: fast troubleshooting and app guidance.
 - `chat`: one-shot natural dialogue about ZiloShift workflows.
 - `post`: WhatsApp/status/social copy generation.
@@ -251,8 +294,12 @@ ZilMate uses a manager agent that delegates to focused subagents and external to
 - Post: launch messages, WhatsApp statuses, captions, and outreach copy.
 - Research: local Zilo docs first, then external docs/web research when needed.
 - Image: image generation through Gateway image models.
+- Automation Planner: background jobs, schedules, trigger workflows, QStash/webhook planning, monitoring, and follow-up automations.
+- Personal Assistant: daily planning, reminders, briefings, prioritization, follow-ups, summaries, and memory-aware organization.
+- Developer Helper: CLI/SDK usage, Next.js integration, publishing, QStash, Cloudflare tunnels, webhooks, Composio setup, and debugging.
 - Composio: external app discovery, auth links, schemas, and execution, attached only to the manager.
 - Memory: durable ZilMate facts and preferences saved locally or in Redis, available through CLI commands and manager tools.
+- Jobs: background task creation, schedule setup, status checks, logs, and cancellation available through CLI, SDK, and manager tools.
 
 Local ZiloShift docs live under `src/doc/`. ZilMate reads them on demand through dedicated tools instead of dumping all docs into every prompt. The manager prefers these local docs for ZiloShift support, worker, venue, payment, verification, SMS, and dispute questions.
 
@@ -287,7 +334,7 @@ zilmate triggers listen --trigger ti_abc123
 zilmate triggers listen --trigger-slug GMAIL_NEW_EMAIL_EVENT --once
 ```
 
-This is terminal-local. For persistent public callbacks, use webhook/tunnel support later.
+This is terminal-local. When `ZILMATE_TRIGGER_WORKFLOWS_ENABLED=true`, trigger events handled by `zilmate triggers listen` also create background jobs. ZilMate includes generic workflow prompts for Gmail, GitHub, Slack, and calendar-style events, and falls back to a general external-app summary task for other toolkits.
 
 The manager agent also has trigger tools. In `zilmate talk`, you can ask:
 
@@ -299,6 +346,37 @@ create that trigger
 
 ZilMate should discover current trigger slugs first, inspect the trigger schema, prefer a dry-run payload, and ask for confirmation before creating a real trigger.
 
+## Background Jobs And Schedules
+
+Use jobs when ZilMate should keep working after a chat turn ends:
+
+```powershell
+zilmate jobs create "Research AI assistant scheduling patterns and save a summary"
+zilmate jobs create "Prepare my morning briefing" --schedule daily
+zilmate jobs worker
+```
+
+Local job storage uses `.zilo-manager/jobs.json` and `.zilo-manager/job-logs.json` unless Redis is configured. With Redis, jobs and logs use the same Upstash REST connection as memory.
+
+Schedules supported locally include `hourly`, `daily`, `every 15 minutes`, `every 2 hours`, `every 1 day`, and ISO date/time strings. QStash schedules can use `cron:<expression>` when `UPSTASH_QSTASH_TOKEN` and `ZILMATE_PUBLIC_JOB_WEBHOOK_URL` are configured.
+
+Hosted apps can expose a webhook route and call:
+
+```ts
+import { createZilMate } from 'zilmate/server';
+
+export async function POST(req: Request) {
+  const body = await req.json();
+  const zilmate = createZilMate();
+  const result = await zilmate.handleJobWebhook(
+    { jobId: body.jobId, secret: req.headers.get('ZilMate-Webhook-Secret') ?? undefined },
+    process.env.ZILMATE_JOB_WEBHOOK_SECRET,
+  );
+
+  return Response.json(result);
+}
+```
+
 ## Model Notes
 
 - Manager/orchestration default: `minimax/minimax-m3`.

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

@@ -0,0 +1,103 @@
+import { ToolLoopAgent } from 'ai';
+export declare function createAutomationPlannerAgent(): ToolLoopAgent<never, {
+    appKnowledge: import("ai").Tool<{
+        key: "agent-docs" | "readme";
+    }, string>;
+    listTriggerTypes: import("ai").Tool<{
+        toolkit?: string | undefined;
+        limit?: number | undefined;
+    }, {
+        items: {
+            slug: string;
+            name: string;
+            description: string;
+            toolkit: {
+                slug: string;
+                name: string;
+                logo: string;
+            };
+            payload: Record<string, unknown>;
+            config: Record<string, unknown>;
+            version?: string | undefined;
+            instructions?: string | undefined;
+        }[];
+        totalPages: number;
+        nextCursor?: string | null | undefined;
+    }>;
+    showTriggerType: import("ai").Tool<{
+        triggerSlug: string;
+    }, {
+        slug: string;
+        name: string;
+        description: string;
+        toolkit: {
+            slug: string;
+            name: string;
+            logo: string;
+        };
+        payload: Record<string, unknown>;
+        config: Record<string, unknown>;
+        version?: string | undefined;
+        instructions?: string | undefined;
+    }>;
+    listTriggers: import("ai").Tool<{
+        limit?: number | undefined;
+        showDisabled?: boolean | undefined;
+    }, {
+        items: {
+            connectedAccountId: string;
+            id: string;
+            updatedAt: string;
+            disabledAt: string | null;
+            state: Record<string, unknown>;
+            triggerConfig: Record<string, unknown>;
+            triggerName: string;
+            uuid?: string | undefined;
+            triggerData?: string | undefined;
+        }[];
+        nextCursor: string | null;
+        totalPages: number;
+    }>;
+    createTrigger: import("ai").Tool<{
+        triggerSlug: string;
+        triggerConfig?: Record<string, unknown> | undefined;
+        connectedAccountId?: string | undefined;
+        dryRun?: boolean | undefined;
+    }, {
+        triggerId: string;
+    } | {
+        triggerConfig?: Record<string, unknown>;
+        connectedAccountId?: string;
+        userId: string;
+        triggerSlug: string;
+        dryRun: boolean;
+    }>;
+    createJob: import("ai").Tool<{
+        task: string;
+        schedule?: string | undefined;
+        runAt?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }, import("../server.js").ZilMateJob>;
+    listJobs: import("ai").Tool<{
+        status?: "running" | "failed" | "queued" | "succeeded" | "cancelled" | undefined;
+        limit?: number | undefined;
+    }, import("../server.js").ZilMateJob[]>;
+    showJob: import("ai").Tool<{
+        id: string;
+    }, import("../server.js").ZilMateJob | null>;
+    listJobLogs: import("ai").Tool<{
+        id: string;
+    }, import("../server.js").JobLog[]>;
+    cancelJob: import("ai").Tool<{
+        id: string;
+    }, import("../server.js").ZilMateJob | null>;
+    getCurrentTime: import("ai").Tool<{
+        timeZone?: string | undefined;
+    }, {
+        iso: string;
+        unixMs: number;
+        timeZone: string;
+        formatted: string;
+    }>;
+}, never>;
+//# sourceMappingURL=automation-planner.agent.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,28 @@
+import { stepCountIs, ToolLoopAgent } from 'ai';
+import { models } from '../config/models.js';
+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 { 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.',
+            '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.',
+            'Return concise plans with exact commands or setup steps when useful.',
+        ].join(' '),
+        tools: {
+            ...timeTools,
+            ...jobTools,
+            ...triggerTools,
+            appKnowledge: appKnowledgeTool,
+        },
+        stopWhen: stepCountIs(limits.subagentSteps),
+    });
+}
+//# sourceMappingURL=automation-planner.agent.js.map

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

@@ -0,0 +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"}

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

@@ -3,6 +3,14 @@ export declare function createChatAgent(): ToolLoopAgent<never, {
     appKnowledge: import("ai").Tool<{
         key: "agent-docs" | "readme";
     }, string>;
+    getCurrentTime: import("ai").Tool<{
+        timeZone?: string | undefined;
+    }, {
+        iso: string;
+        unixMs: number;
+        timeZone: string;
+        formatted: string;
+    }>;
     listZiloDocs: import("ai").Tool<Record<string, never>, {
         key: string;
         title: string;

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

@@ -1 +1 @@
-{"version":3,"file":"chat.agent.d.ts","sourceRoot":"","sources":["../../src/agents/chat.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,aAAa,EAAE,MAAM,IAAI,CAAC;AAKhD,wBAAgB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;UAU9B"}
+{"version":3,"file":"chat.agent.d.ts","sourceRoot":"","sources":["../../src/agents/chat.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,aAAa,EAAE,MAAM,IAAI,CAAC;AAOhD,wBAAgB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAW9B"}

package/dist/agents/chat.agent.js

@@ -2,15 +2,18 @@ import { stepCountIs, ToolLoopAgent } from 'ai';
 import { models } from '../config/models.js';
 import { appKnowledgeTool } from '../tools/app-knowledge.tool.js';
 import { ziloDocsTools } from '../tools/zilo-docs.tool.js';
+import { timeTools } from '../tools/time.tool.js';
+import { limits } from '../safety/limits.js';
 export function createChatAgent() {
     return new ToolLoopAgent({
         model: models.chat,
-        instructions: 'You are the ZiloShift conversational app guide. Explain workflows for workers, venues, admin operations, payments, disputes, shifts, onboarding, and launch tasks in a calm practical tone. Use local ZiloShift docs on demand for accurate product behavior instead of guessing. Keep answers practical and do not dump long docs into the response.',
+        instructions: 'You are the ZiloShift conversational app guide. Explain workflows for workers, venues, admin operations, payments, disputes, shifts, onboarding, and launch tasks in a calm practical tone. Use local ZiloShift docs on demand for accurate product behavior instead of guessing. Use getCurrentTime when the user asks for current date/time or relative schedule wording. Keep answers practical and do not dump long docs into the response.',
         tools: {
             ...ziloDocsTools,
+            ...timeTools,
             appKnowledge: appKnowledgeTool,
         },
-        stopWhen: stepCountIs(6),
+        stopWhen: stepCountIs(limits.subagentSteps),
     });
 }
 //# sourceMappingURL=chat.agent.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"chat.agent.js","sourceRoot":"","sources":["../../src/agents/chat.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,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE3D,MAAM,UAAU,eAAe;IAC7B,OAAO,IAAI,aAAa,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC,IAAI;QAClB,YAAY,EAAE,uVAAuV;QACrW,KAAK,EAAE;YACL,GAAG,aAAa;YAChB,YAAY,EAAE,gBAAgB;SAC/B;QACD,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC;KACzB,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"chat.agent.js","sourceRoot":"","sources":["../../src/agents/chat.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,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE7C,MAAM,UAAU,eAAe;IAC7B,OAAO,IAAI,aAAa,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC,IAAI;QAClB,YAAY,EAAE,ibAAib;QAC/b,KAAK,EAAE;YACL,GAAG,aAAa;YAChB,GAAG,SAAS;YACZ,YAAY,EAAE,gBAAgB;SAC/B;QACD,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,aAAa,CAAC;KAC5C,CAAC,CAAC;AACL,CAAC"}

package/dist/agents/developer-helper.agent.d.ts

@@ -0,0 +1,94 @@
+import { ToolLoopAgent } from 'ai';
+export declare function createDeveloperHelperAgent(runId?: string): ToolLoopAgent<never, {
+    readScratchpad: import("ai").Tool<Record<string, never>, string>;
+    appendScratchpad: import("ai").Tool<{
+        note: string;
+    }, string>;
+    docsSearch: import("ai").Tool<{
+        query: string;
+    }, import("../tools/web-search.tool.js").WebSearchResult[]>;
+    docsFetch: import("ai").Tool<{
+        url: string;
+    }, string>;
+    webSearch: import("ai").Tool<{
+        query: string;
+        maxResults?: number | undefined;
+        searchDepth?: "basic" | "advanced" | undefined;
+        includeAnswer?: boolean | undefined;
+        includeRawContent?: "text" | "markdown" | undefined;
+        includeDomains?: string[] | undefined;
+        excludeDomains?: string[] | undefined;
+        topic?: "general" | "news" | "finance" | undefined;
+        timeRange?: "day" | "week" | "month" | "year" | undefined;
+    }, {
+        answer: string | undefined;
+        results: {
+            title: string;
+            url: string;
+            content: string;
+            rawContent: string | undefined;
+            score: number | undefined;
+            publishedDate: string | undefined;
+        }[];
+    }>;
+    webExtract: import("ai").Tool<{
+        urls: string[];
+        query?: string | undefined;
+        extractDepth?: "basic" | "advanced" | undefined;
+        format?: "text" | "markdown" | undefined;
+        chunksPerSource?: number | undefined;
+    }, {
+        results: {
+            url: string;
+            title: string;
+            rawContent: string;
+        }[];
+        failedResults: {
+            url: string;
+            error: string;
+        }[];
+    }>;
+    webMap: import("ai").Tool<{
+        url: string;
+        instructions?: string | undefined;
+        maxDepth?: number | undefined;
+        limit?: number | undefined;
+        allowExternal?: boolean | undefined;
+    }, {
+        baseUrl: string;
+        results: string[];
+    }>;
+    deepResearch: import("ai").Tool<{
+        input: string;
+        model?: "mini" | "pro" | undefined;
+        timeoutSeconds?: number | undefined;
+        pollIntervalSeconds?: number | undefined;
+    }, {
+        requestId: string;
+        status: string;
+        content: string;
+        sources: {
+            title: string;
+            url: string;
+        }[];
+        message?: never;
+    } | {
+        requestId: string;
+        status: string;
+        message: string;
+        content?: never;
+        sources?: never;
+    }>;
+    appKnowledge: import("ai").Tool<{
+        key: "agent-docs" | "readme";
+    }, string>;
+    getCurrentTime: import("ai").Tool<{
+        timeZone?: string | undefined;
+    }, {
+        iso: string;
+        unixMs: number;
+        timeZone: string;
+        formatted: string;
+    }>;
+}, never>;
+//# sourceMappingURL=developer-helper.agent.d.ts.map

package/dist/agents/developer-helper.agent.d.ts.map

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

package/dist/agents/developer-helper.agent.js

@@ -0,0 +1,34 @@
+import { stepCountIs, ToolLoopAgent } from 'ai';
+import { models } from '../config/models.js';
+import { appKnowledgeTool } from '../tools/app-knowledge.tool.js';
+import { docsFetchTool } from '../tools/docs-fetch.tool.js';
+import { docsSearchTool } from '../tools/docs-search.tool.js';
+import { createScratchpadTools } from '../tools/scratchpad.tool.js';
+import { timeTools } from '../tools/time.tool.js';
+import { deepResearchTool, webExtractTool, webMapTool, webSearchTool } from '../tools/web-search.tool.js';
+import { limits } from '../safety/limits.js';
+export function createDeveloperHelperAgent(runId = 'default') {
+    const scratchpadTools = createScratchpadTools(runId);
+    return new ToolLoopAgent({
+        model: models.research,
+        instructions: [
+            'You are ZilMate Developer Helper. Help developers integrate ZilMate through the CLI, SDK, Next.js server routes, background jobs, QStash webhooks, Cloudflare tunnels, Composio, package publishing, and troubleshooting.',
+            'Prefer local app/package knowledge first. For external technical facts, prefer official docs and primary sources.',
+            'Use time tools for current versions, release timing, date-sensitive debugging, or schedule-relative wording.',
+            'Return exact commands, minimal code snippets, and clear verification steps. Do not invent credentials or claim external setup succeeded without tool evidence.',
+        ].join(' '),
+        tools: {
+            ...timeTools,
+            docsSearch: docsSearchTool,
+            docsFetch: docsFetchTool,
+            webSearch: webSearchTool,
+            webExtract: webExtractTool,
+            webMap: webMapTool,
+            deepResearch: deepResearchTool,
+            appKnowledge: appKnowledgeTool,
+            ...scratchpadTools,
+        },
+        stopWhen: stepCountIs(limits.subagentSteps),
+    });
+}
+//# sourceMappingURL=developer-helper.agent.js.map

package/dist/agents/developer-helper.agent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"developer-helper.agent.js","sourceRoot":"","sources":["../../src/agents/developer-helper.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,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC1G,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE7C,MAAM,UAAU,0BAA0B,CAAC,KAAK,GAAG,SAAS;IAC1D,MAAM,eAAe,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IACrD,OAAO,IAAI,aAAa,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC,QAAQ;QACtB,YAAY,EAAE;YACZ,2NAA2N;YAC3N,mHAAmH;YACnH,8GAA8G;YAC9G,gKAAgK;SACjK,CAAC,IAAI,CAAC,GAAG,CAAC;QACX,KAAK,EAAE;YACL,GAAG,SAAS;YACZ,UAAU,EAAE,cAAc;YAC1B,SAAS,EAAE,aAAa;YACxB,SAAS,EAAE,aAAa;YACxB,UAAU,EAAE,cAAc;YAC1B,MAAM,EAAE,UAAU;YAClB,YAAY,EAAE,gBAAgB;YAC9B,YAAY,EAAE,gBAAgB;YAC9B,GAAG,eAAe;SACnB;QACD,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,aAAa,CAAC;KAC5C,CAAC,CAAC;AACL,CAAC"}

package/dist/agents/docs-research.agent.d.ts

@@ -100,6 +100,14 @@ export declare function createDocsResearchAgent(runId?: string): ToolLoopAgent<n
     appKnowledge: import("ai").Tool<{
         key: "agent-docs" | "readme";
     }, string>;
+    getCurrentTime: import("ai").Tool<{
+        timeZone?: string | undefined;
+    }, {
+        iso: string;
+        unixMs: number;
+        timeZone: string;
+        formatted: string;
+    }>;
     listZiloDocs: import("ai").Tool<Record<string, never>, {
         key: string;
         title: string;

package/dist/agents/docs-research.agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"docs-research.agent.d.ts","sourceRoot":"","sources":["../../src/agents/docs-research.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,aAAa,EAAE,MAAM,IAAI,CAAC;AAShD,wBAAgB,uBAAuB,CAAC,KAAK,SAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAmBxD"}
+{"version":3,"file":"docs-research.agent.d.ts","sourceRoot":"","sources":["../../src/agents/docs-research.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,aAAa,EAAE,MAAM,IAAI,CAAC;AAWhD,wBAAgB,uBAAuB,CAAC,KAAK,SAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAoBxD"}

package/dist/agents/docs-research.agent.js

@@ -6,13 +6,16 @@ import { appKnowledgeTool } from '../tools/app-knowledge.tool.js';
 import { createScratchpadTools } from '../tools/scratchpad.tool.js';
 import { ziloDocsTools } from '../tools/zilo-docs.tool.js';
 import { deepResearchTool, webCrawlTool, webExtractTool, webMapTool, webSearchTool } from '../tools/web-search.tool.js';
+import { timeTools } from '../tools/time.tool.js';
+import { limits } from '../safety/limits.js';
 export function createDocsResearchAgent(runId = 'default') {
     const scratchpadTools = createScratchpadTools(runId);
     return new ToolLoopAgent({
         model: models.research,
-        instructions: 'You are a focused docs research subagent. For ZiloShift product behavior, search/read local Zilo docs first. For external facts, prefer official or primary docs: search lightly, extract known URLs deeply, map before crawling, crawl only small docs sections, and use deepResearch only for broad synthesis where the user clearly benefits from a heavier task. Return compact answers with source URLs. Use the scratchpad for compact intermediate notes only when research spans multiple sources.',
+        instructions: 'You are a focused docs research subagent. For ZiloShift product behavior, search/read local Zilo docs first. For external facts, prefer official or primary docs: search lightly, extract known URLs deeply, map before crawling, crawl only small docs sections, and use deepResearch only for broad synthesis where the user clearly benefits from a heavier task. Use getCurrentTime for current date/time or relative-date research framing. Return compact answers with source URLs. Use the scratchpad for compact intermediate notes only when research spans multiple sources.',
         tools: {
             ...ziloDocsTools,
+            ...timeTools,
             docsSearch: docsSearchTool,
             docsFetch: docsFetchTool,
             webSearch: webSearchTool,
@@ -23,7 +26,7 @@ export function createDocsResearchAgent(runId = 'default') {
             appKnowledge: appKnowledgeTool,
             ...scratchpadTools,
         },
-        stopWhen: stepCountIs(8),
+        stopWhen: stepCountIs(limits.subagentSteps),
     });
 }
 //# sourceMappingURL=docs-research.agent.js.map

package/dist/agents/docs-research.agent.js.map

@@ -1 +1 @@
-{"version":3,"file":"docs-research.agent.js","sourceRoot":"","sources":["../../src/agents/docs-research.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,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAExH,MAAM,UAAU,uBAAuB,CAAC,KAAK,GAAG,SAAS;IACvD,MAAM,eAAe,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IACrD,OAAO,IAAI,aAAa,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC,QAAQ;QACtB,YAAY,EAAE,4eAA4e;QAC1f,KAAK,EAAE;YACL,GAAG,aAAa;YAChB,UAAU,EAAE,cAAc;YAC1B,SAAS,EAAE,aAAa;YACxB,SAAS,EAAE,aAAa;YACxB,UAAU,EAAE,cAAc;YAC1B,MAAM,EAAE,UAAU;YAClB,QAAQ,EAAE,YAAY;YACtB,YAAY,EAAE,gBAAgB;YAC9B,YAAY,EAAE,gBAAgB;YAC9B,GAAG,eAAe;SACnB;QACD,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC;KACzB,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"docs-research.agent.js","sourceRoot":"","sources":["../../src/agents/docs-research.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,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACxH,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE7C,MAAM,UAAU,uBAAuB,CAAC,KAAK,GAAG,SAAS;IACvD,MAAM,eAAe,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IACrD,OAAO,IAAI,aAAa,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC,QAAQ;QACtB,YAAY,EAAE,wjBAAwjB;QACtkB,KAAK,EAAE;YACL,GAAG,aAAa;YAChB,GAAG,SAAS;YACZ,UAAU,EAAE,cAAc;YAC1B,SAAS,EAAE,aAAa;YACxB,SAAS,EAAE,aAAa;YACxB,UAAU,EAAE,cAAc;YAC1B,MAAM,EAAE,UAAU;YAClB,QAAQ,EAAE,YAAY;YACtB,YAAY,EAAE,gBAAgB;YAC9B,YAAY,EAAE,gBAAgB;YAC9B,GAAG,eAAe;SACnB;QACD,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,aAAa,CAAC;KAC5C,CAAC,CAAC;AACL,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"image.agent.d.ts","sourceRoot":"","sources":["../../src/agents/image.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,aAAa,EAAE,MAAM,IAAI,CAAC;AAIhD,wBAAgB,gBAAgB;;;;;;UAO/B"}
+{"version":3,"file":"image.agent.d.ts","sourceRoot":"","sources":["../../src/agents/image.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,aAAa,EAAE,MAAM,IAAI,CAAC;AAKhD,wBAAgB,gBAAgB;;;;;;UAO/B"}

package/dist/agents/image.agent.js

@@ -1,12 +1,13 @@
 import { stepCountIs, ToolLoopAgent } from 'ai';
 import { models } from '../config/models.js';
 import { imageGenerateTool } from '../tools/image-generate.tool.js';
+import { limits } from '../safety/limits.js';
 export function createImageAgent() {
     return new ToolLoopAgent({
         model: models.manager,
         instructions: 'You are the ZiloShift image agent. Improve the user image prompt when useful, then call generateImage. Use Gemini 3 Pro Image via Gateway. Do not claim GPT-2 can generate images.',
         tools: { generateImage: imageGenerateTool },
-        stopWhen: stepCountIs(4),
+        stopWhen: stepCountIs(limits.subagentSteps),
     });
 }
 //# sourceMappingURL=image.agent.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"image.agent.js","sourceRoot":"","sources":["../../src/agents/image.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,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AAEpE,MAAM,UAAU,gBAAgB;IAC9B,OAAO,IAAI,aAAa,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC,OAAO;QACrB,YAAY,EAAE,oLAAoL;QAClM,KAAK,EAAE,EAAE,aAAa,EAAE,iBAAiB,EAAE;QAC3C,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC;KACzB,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"image.agent.js","sourceRoot":"","sources":["../../src/agents/image.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,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE7C,MAAM,UAAU,gBAAgB;IAC9B,OAAO,IAAI,aAAa,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC,OAAO;QACrB,YAAY,EAAE,oLAAoL;QAClM,KAAK,EAAE,EAAE,aAAa,EAAE,iBAAiB,EAAE;QAC3C,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,aAAa,CAAC;KAC5C,CAAC,CAAC;AACL,CAAC"}

package/dist/agents/manager.d.ts

@@ -77,6 +77,33 @@ export declare function createManagerAgent(runId?: string, options?: {
         triggerSlug: string;
         dryRun: boolean;
     }>;
+    createJob: import("ai").Tool<{
+        task: string;
+        schedule?: string | undefined;
+        runAt?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }, import("../server.js").ZilMateJob>;
+    listJobs: import("ai").Tool<{
+        status?: "running" | "failed" | "queued" | "succeeded" | "cancelled" | undefined;
+        limit?: number | undefined;
+    }, import("../server.js").ZilMateJob[]>;
+    showJob: import("ai").Tool<{
+        id: string;
+    }, import("../server.js").ZilMateJob | null>;
+    listJobLogs: import("ai").Tool<{
+        id: string;
+    }, import("../server.js").JobLog[]>;
+    cancelJob: import("ai").Tool<{
+        id: string;
+    }, import("../server.js").ZilMateJob | null>;
+    getCurrentTime: import("ai").Tool<{
+        timeZone?: string | undefined;
+    }, {
+        iso: string;
+        unixMs: number;
+        timeZone: string;
+        formatted: string;
+    }>;
     rememberMemory: import("ai").Tool<{
         text: string;
         tags?: string[] | undefined;
@@ -130,6 +157,15 @@ export declare function createManagerAgent(runId?: string, options?: {
     research: import("ai").Tool<{
         prompt: string;
     }, string>;
+    automationPlanner: import("ai").Tool<{
+        prompt: string;
+    }, string>;
+    personalAssistant: import("ai").Tool<{
+        prompt: string;
+    }, string>;
+    developerHelper: import("ai").Tool<{
+        prompt: string;
+    }, string>;
 }, never>>;
 export declare function runManager(prompt: string, options?: {
     progress?: (event: ProgressEvent) => void;

package/dist/agents/manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../src/agents/manager.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,aAAa,EAAE,MAAM,IAAI,CAAC;AAUtD,OAAO,EAAgB,KAAK,aAAa,EAAwB,MAAM,wBAAwB,CAAC;AAChG,OAAO,EAAE,KAAK,mBAAmB,EAA2B,MAAM,uBAAuB,CAAC;AA4D1F,wBAAsB,kBAAkB,CAAC,KAAK,GAAE,MAAqB,EAAE,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO;;;;;;;;;;;;;;;;;;;;mBAsFo4lG,CAAC;wBAAsC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAAz2S,CAAC;uBAAqC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAjCptzF;AAOD,wBAAsB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,mBAAmB,CAAA;CAAO,mBAsB9K"}
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../src/agents/manager.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,aAAa,EAAE,MAAM,IAAI,CAAC;AAatD,OAAO,EAAgB,KAAK,aAAa,EAAwB,MAAM,wBAAwB,CAAC;AAChG,OAAO,EAAE,KAAK,mBAAmB,EAA2B,MAAM,uBAAuB,CAAC;AAuE1F,wBAAsB,kBAAkB,CAAC,KAAK,GAAE,MAAqB,EAAE,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO;;;;;;;;;;;;;;;;;;;;mBA8Gg4/F,CAAC;wBAAsC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAAz2S,CAAC;uBAAqC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAjChttF;AAOD,wBAAsB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,mBAAmB,CAAA;CAAO,mBAsB9K"}