zilmate 1.6.2 → 1.7.2

package/SDK.md

@@ -0,0 +1,320 @@
+# ZilMate SDK
+
+Use ZilMate as a programmable agent layer in Next.js, server routes, background workers, and automation scripts. The SDK wraps the same manager, subagents, memory, jobs, and voice stack as the CLI.
+
+## Install
+
+```bash
+npm install zilmate
+```
+
+Set environment variables (see `.env.example`):
+
+```env
+AI_GATEWAY_API_KEY=...
+ZILMATE_USER_ID=zilmate-your-id
+```
+
+Optional: `COMPOSIO_API_KEY`, `TAVILY_API_KEY`, Upstash Redis/QStash, `DEEPGRAM_API_KEY`.
+
+## Quick start (Node / Next.js server)
+
+```ts
+import { createZilMate } from 'zilmate/server';
+
+const zilmate = createZilMate({
+  sessionId: 'dashboard-user-123',
+  onProgress: (event) => console.log(event.type, event.label),
+});
+
+const { text } = await zilmate.manager({ message: 'Summarize my open jobs and suggest next steps.' });
+console.log(text);
+```
+
+## Next.js App Router — streaming chat route
+
+Create `app/api/zilmate/route.ts`:
+
+```ts
+import { createZilMate } from 'zilmate/server';
+
+export const runtime = 'nodejs';
+export const maxDuration = 120;
+
+export async function POST(request: Request) {
+  const { message, sessionId = 'web-default' } = await request.json();
+
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      const send = (payload: unknown) => {
+        controller.enqueue(encoder.encode(`${JSON.stringify(payload)}\n`));
+      };
+
+      const zilmate = createZilMate({
+        sessionId,
+        onProgress: (event) => send({ type: 'progress', event }),
+      });
+
+      try {
+        const { text } = await zilmate.manager({ message });
+        send({ type: 'done', text });
+      } catch (error) {
+        send({
+          type: 'error',
+          message: error instanceof Error ? error.message : String(error),
+        });
+      } finally {
+        controller.close();
+      }
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'application/x-ndjson',
+      'Cache-Control': 'no-cache',
+    },
+  });
+}
+```
+
+Client hook (React):
+
+```tsx
+'use client';
+
+import { useState } from 'react';
+
+export function ZilMateChat() {
+  const [input, setInput] = useState('');
+  const [reply, setReply] = useState('');
+  const [progress, setProgress] = useState<string[]>([]);
+
+  async function send() {
+    setProgress([]);
+    const res = await fetch('/api/zilmate', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ message: input, sessionId: 'web-1' }),
+    });
+
+    const reader = res.body!.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() ?? '';
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        const chunk = JSON.parse(line);
+        if (chunk.type === 'progress') setProgress((p) => [...p, chunk.event.label]);
+        if (chunk.type === 'done') setReply(chunk.text);
+      }
+    }
+  }
+
+  return (
+    <div>
+      <textarea value={input} onChange={(e) => setInput(e.target.value)} />
+      <button onClick={send}>Ask ZilMate</button>
+      <ul>{progress.map((p) => <li key={p}>{p}</li>)}</ul>
+      <pre>{reply}</pre>
+    </div>
+  );
+}
+```
+
+## Subagents
+
+The manager orchestrates specialized subagents. Call them directly when you do not need full orchestration.
+
+| Method | Agent | Best for |
+|--------|-------|----------|
+| `manager()` | Main orchestrator | General tasks, routing, tools, memory |
+| `coding()` | Coding agent + appBuilder + qaIntegration | Repo edits, builds, tests, patches |
+| `imageAgent()` | Image director | Prompt refinement + generation/editing |
+| `goalManager()` | Goal planner | Break goals into steps and schedules |
+| `research()` | Docs/web research | Sourced answers |
+| `help()` | Quick help | Usage and troubleshooting |
+| `post()` | Copywriter | Short social/status posts |
+
+### Coding agent with sub-coders
+
+```ts
+const zilmate = createZilMate({ sessionId: 'repo-session' });
+
+const { text } = await zilmate.coding({
+  prompt: [
+    'In this Next.js repo:',
+    '1) Add a /api/health route',
+    '2) Run typecheck',
+    '3) Return files changed and test output',
+  ].join('\n'),
+});
+```
+
+Internally, the coding agent can delegate to:
+
+- **appBuilder** — full app/game/UI implementation
+- **qaIntegration** — tests, build fixes, release checks
+
+It also uses **code intelligence tools**: `grepCodebase`, `reviewWorkingTree`, `explainSymbol`, `scaffoldFiles`, `runProjectChecks`.
+
+### Image director
+
+```ts
+const { text } = await zilmate.imageAgent({
+  prompt: 'Product hero image: dark SaaS dashboard on laptop, cyan accent, no text gibberish, 16:9',
+});
+```
+
+The image agent runs `enhanceImagePrompt` then `generateImage` for precise visuals.
+
+## Agentic features (10x differentiators)
+
+### 1. Situational awareness
+
+Before major work, the manager can call `getSituationBrief` (cwd, git, workspace, models, jobs, memory, projects). Use directly:
+
+```ts
+const brief = await zilmate.situation({ sessionId: 'default' });
+console.log(brief.git, brief.recentJobs, brief.models);
+```
+
+### 2. Session continuity (handoffs)
+
+Resume work across sessions:
+
+```ts
+const handoff = await zilmate.handoff({ sessionId: 'default' });
+if (handoff) {
+  await zilmate.manager({
+    message: `Continue from handoff:\n${handoff.summary}\nNext: ${handoff.nextActions.join(', ')}`,
+  });
+}
+```
+
+The manager can also call `generateSessionHandoff` / `saveSessionHandoff` before ending a long task.
+
+## Model selection
+
+CLI users run `/model pick`. In code, persist selections to the workspace:
+
+```ts
+import { applyStoredModelSelections, saveModelSelection } from 'zilmate/server';
+
+await applyStoredModelSelections();
+await saveModelSelection('manager', 'anthropic/claude-sonnet-4');
+await saveModelSelection('coding', 'openai/gpt-5.4-mini');
+```
+
+Models are stored in `~/Downloads/ZilMate/config/models.json` (or `ZILMATE_WORKSPACE`).
+
+## Memory
+
+```ts
+await zilmate.remember({ text: 'User prefers pnpm and App Router', tags: ['prefs'] });
+const hits = await zilmate.recall({ query: 'package manager', limit: 5 });
+```
+
+## Background jobs
+
+```ts
+const job = await zilmate.createJob({
+  task: 'Weekly summary of GitHub PRs',
+  schedule: '0 9 * * 1',
+});
+
+await zilmate.runDueJobs();
+const logs = await zilmate.getJobLogs(job.id);
+```
+
+Expose webhooks for QStash:
+
+```ts
+// app/api/jobs/webhook/route.ts
+import { createZilMate } from 'zilmate/server';
+
+export async function POST(req: Request) {
+  const body = await req.json();
+  const zilmate = createZilMate();
+  const job = await zilmate.handleJobWebhook(body, process.env.ZILMATE_JOB_WEBHOOK_SECRET);
+  return Response.json({ ok: true, jobId: job.id });
+}
+```
+
+Use `zilmate jobs listen --tunnel` (Cloudflare quick tunnel) during local development.
+
+## Voice (Deepgram)
+
+```ts
+const session = await zilmate.startVoiceSession({
+  onProgress: (e) => console.log(e.label),
+});
+
+// session exposes Deepgram agent wiring — see src/voice/deepgram.ts
+console.log(session.config.listenModel);
+await session.close?.();
+```
+
+## Confirmation in server contexts
+
+Destructive tools require explicit approval. Provide a handler:
+
+```ts
+import type { ConfirmationHandler } from 'zilmate/server';
+
+const confirm: ConfirmationHandler = async (request) => {
+  // In a web app, push to UI and await user click
+  console.log('Approve?', request.message);
+  return true;
+};
+
+const zilmate = createZilMate({ confirm });
+```
+
+## Exports reference
+
+```ts
+import {
+  createZilMate,
+  chat,
+  help,
+  post,
+  research,
+  image,
+  applyStoredModelSelections,
+  buildSituationBrief,
+  loadSessionHandoff,
+  clearSessionApprovals,
+} from 'zilmate/server';
+```
+
+## CLI parity
+
+| CLI | SDK |
+|-----|-----|
+| `zilmate talk` | `createZilMate().manager()` |
+| `zilmate coding "..."` | `createZilMate().coding()` |
+| `zilmate heal` | manager + heal tools (via manager) |
+| `zilmate jobs worker` | `runDueJobs()` + worker process |
+| `/model pick` | `saveModelSelection()` |
+
+## Production checklist
+
+1. Run `zilmate setup` once per environment (merge-safe).
+2. Set `ZILMATE_WORKSPACE` for durable notebook/knowledge/skills.
+3. Enable Redis for multi-instance memory and jobs.
+4. Use QStash + Cloudflare tunnel for hosted schedules.
+5. Never expose `AI_GATEWAY_API_KEY` to the browser — keep SDK calls on the server.
+
+## Learn more
+
+- Repository: https://github.com/zester4/zilo-manager
+- Agent skill: `plugins/zilmate/skills/zilmate/SKILL.md`
+- AI SDK patterns: https://sdk.vercel.ai/docs

package/agent-docs.md

@@ -1,3 +1,15 @@
+ZilMate coding-agent note
+
+ZilMate uses the AI SDK v6 subagent pattern for coding work:
+
+- Manager delegates software work to the main Coding Agent.
+- Coding Agent stays responsible for orchestration and the final report.
+- Coding Agent can call `appBuilder` for full app/game/software implementation.
+- Coding Agent can call `qaIntegration` for builds, tests, debugging, and release-readiness checks.
+- Both internal coding delegates use skills, file tools, shell tools, and notebook tools.
+- Use scratchpad for temporary run coordination and notebook for durable project memory.
+- Delegate tools pass `abortSignal` into subagents and emit subagent progress events so the CLI can show what is happening.
+
 Building Subagents in the Vercel AI SDK v6
 11 min read
 ·

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

@@ -116,12 +116,12 @@ export declare function createAutomationPlannerAgent(): ToolLoopAgent<never, {
         limit?: number | undefined;
     }, {
         items: {
-            slug: string;
             name: string;
             description: string;
+            slug: string;
             toolkit: {
-                slug: string;
                 name: string;
+                slug: string;
                 logo: string;
             };
             payload: Record<string, unknown>;
@@ -135,12 +135,12 @@ export declare function createAutomationPlannerAgent(): ToolLoopAgent<never, {
     showTriggerType: import("ai").Tool<{
         triggerSlug: string;
     }, {
-        slug: string;
         name: string;
         description: string;
+        slug: string;
         toolkit: {
-            slug: string;
             name: string;
+            slug: string;
             logo: string;
         };
         payload: Record<string, unknown>;

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;AAUhD,wBAAgB,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA2BksyG,CAAC;wBAAsC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAAz2S,CAAC;uBAAqC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UADn9/F"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA2B8+uG,CAAC;wBAAsC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAAz2S,CAAC;uBAAqC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAD/v8F"}

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

@@ -4,6 +4,35 @@ export declare function createCodingAgent(runId?: string): ToolLoopAgent<never,
     appendScratchpad: import("ai").Tool<{
         note: string;
     }, string>;
+    readNotebook: import("ai").Tool<{
+        limitChars?: number | undefined;
+    }, {
+        paths: {
+            markdown: string;
+            json: string;
+        };
+        content: string;
+    }>;
+    appendNotebook: import("ai").Tool<{
+        title: string;
+        body: string;
+        tags?: string[] | undefined;
+    }, import("../memory/notebook.js").NotebookEntry>;
+    searchNotebook: import("ai").Tool<{
+        query: string;
+        limit?: number | undefined;
+    }, import("../memory/notebook.js").NotebookEntry[]>;
+    listNotebookEntries: import("ai").Tool<{
+        limit?: number | undefined;
+    }, import("../memory/notebook.js").NotebookEntry[]>;
+    quickNotebookNote: import("ai").Tool<{
+        section: string;
+        content: string;
+    }, {
+        path: string;
+        section: string;
+        appendedAt: string;
+    }>;
     listSkills: import("ai").Tool<Record<string, never>, {
         skills: import("../skills/loader.js").SkillSummary[];
         searchPaths: string[];
@@ -266,6 +295,71 @@ export declare function createCodingAgent(runId?: string): ToolLoopAgent<never,
         isSymlink: boolean;
         mode: string;
     }>;
+    grepCodebase: import("ai").Tool<{
+        pattern: string;
+        cwd?: string | undefined;
+        glob?: string | undefined;
+        limit?: number | undefined;
+    }, {
+        root: string;
+        pattern: string;
+        output: string;
+        error?: never;
+    } | {
+        root: string;
+        pattern: string;
+        error: string;
+        output?: never;
+    }>;
+    reviewWorkingTree: import("ai").Tool<{
+        cwd?: string | undefined;
+        focus?: string | undefined;
+    }, {
+        root: string;
+        review: string;
+    }>;
+    explainSymbol: import("ai").Tool<{
+        symbol: string;
+        cwd?: string | undefined;
+    }, {
+        symbol: string;
+        root: string;
+        explanation: string;
+        hits: string;
+    }>;
+    scaffoldFiles: import("ai").Tool<{
+        files: {
+            path: string;
+            content: string;
+            overwrite?: boolean | undefined;
+        }[];
+        cwd?: string | undefined;
+    }, {
+        created: string[];
+        count: number;
+    }>;
+    runProjectChecks: import("ai").Tool<{
+        cwd?: string | undefined;
+        scripts?: string[] | undefined;
+    }, {
+        root: string;
+        ran: never[];
+        note: string;
+        available: Record<string, string>;
+        results?: never;
+        allPassed?: never;
+    } | {
+        root: string;
+        results: {
+            script: string;
+            output: string;
+            ok: boolean;
+        }[];
+        allPassed: boolean;
+        ran?: never;
+        note?: never;
+        available?: never;
+    }>;
     gitStatus: import("ai").Tool<{
         short: boolean;
         cwd?: string | undefined;
@@ -348,5 +442,13 @@ export declare function createCodingAgent(runId?: string): ToolLoopAgent<never,
         timeZone: string;
         formatted: string;
     }>;
+    appBuilder: import("ai").Tool<{
+        task: string;
+        context?: string | undefined;
+    }, string>;
+    qaIntegration: import("ai").Tool<{
+        task: string;
+        context?: string | undefined;
+    }, string>;
 }, never>;
 //# sourceMappingURL=coding.agent.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"coding.agent.d.ts","sourceRoot":"","sources":["../../src/agents/coding.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,aAAa,EAAQ,MAAM,IAAI,CAAC;AA8FtD,wBAAgB,iBAAiB,CAAC,KAAK,SAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAiClD"}

package/dist/agents/coding.agent.js

@@ -1,31 +1,115 @@
-import { stepCountIs, ToolLoopAgent } from 'ai';
+import { stepCountIs, ToolLoopAgent, tool } from 'ai';
+import { z } from 'zod';
 import { models } from '../config/models.js';
 import { createScratchpadTools } from '../tools/scratchpad.tool.js';
+import { notebookTools } from '../tools/notebook.tool.js';
 import { fileSystemTools } from '../tools/filesystem.tool.js';
+import { codeIntelligenceTools } from '../tools/code-intelligence.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';
+import { emitProgress } from '../runtime/progress.js';
+function createAppBuilderAgent(runId = 'default') {
+    const scratchpadTools = createScratchpadTools(`${runId}:app-builder`);
+    return new ToolLoopAgent({
+        model: models.coding,
+        instructions: [
+            'You are ZilMate App Builder, an internal coding subagent for building complete apps, games, tools, and software projects end to end.',
+            'Use skills first when the task matches a framework or domain: searchSkills/readSkill before designing Vite, Next.js, React, shadcn, ai-elements, AI SDK, Composio, Supabase, games, or desktop workflows.',
+            'Choose the existing stack when inside a repo. For new frontend apps, prefer Vite for lightweight apps/games and Next.js when routing, server APIs, auth, SDK routes, or deployment structure matter.',
+            'Implement real working screens and workflows, not placeholder landing pages. For games, build actual gameplay. For apps, build the usable first screen and the expected controls/states.',
+            'Use file tools for targeted edits, shell tools for installs/builds/tests, and notebook tools to save durable project decisions, commands, ports, and follow-up context.',
+            'When external apps are needed, design around Composio search/link/execute workflows and keep user secrets server-side.',
+            'Return a concise builder report: files changed, commands run, dev server or build status, and what remains.',
+        ].join('\n'),
+        tools: {
+            ...timeTools,
+            ...fileSystemTools,
+            ...codeIntelligenceTools,
+            ...shellTools,
+            ...skillTools,
+            ...notebookTools,
+            ...scratchpadTools,
+        },
+        stopWhen: stepCountIs(limits.subagentSteps),
+    });
+}
+function createQaIntegrationAgent(runId = 'default') {
+    const scratchpadTools = createScratchpadTools(`${runId}:qa`);
+    return new ToolLoopAgent({
+        model: models.coding,
+        instructions: [
+            'You are ZilMate QA and Integration Builder, an internal coding subagent for verification, debugging, test coverage, dependency checks, and release readiness.',
+            'Read the implementation and repo scripts before testing. Use skills when framework-specific testing or build rules exist.',
+            'Run the narrowest useful checks first, then broaden when shared behavior or user-facing workflows are touched.',
+            'Fix build/type/lint/runtime failures when the cause is clear. Do not hide failed checks; report command, exit state, and useful error lines.',
+            'Use notebook tools to persist durable verification notes, recurring gotchas, release steps, and environment assumptions.',
+            'For Composio or external-app features, verify connection/setup paths separately from write-like actions and keep destructive actions behind confirmation.',
+            'Return a concise QA report: checks run, failures fixed, remaining risks, and exact next command for the main agent/user.',
+        ].join('\n'),
+        tools: {
+            ...timeTools,
+            ...gitTools,
+            ...codeIntelligenceTools,
+            ...fileSystemTools,
+            ...shellTools,
+            ...skillTools,
+            ...notebookTools,
+            ...scratchpadTools,
+        },
+        stopWhen: stepCountIs(limits.subagentSteps),
+    });
+}
+function codingDelegateTool(name, description, agent) {
+    return tool({
+        description,
+        inputSchema: z.object({
+            task: z.string().min(10),
+            context: z.string().optional(),
+        }),
+        execute: async ({ task, context }, { abortSignal }) => {
+            emitProgress({ type: 'subagent:start', agent: name, label: 'Delegated coding work', detail: task.slice(0, 160) });
+            emitProgress({ type: 'subagent:step', agent: name, label: 'Running focused build loop' });
+            const prompt = context ? `${context}\n\nTask:\n${task}` : task;
+            const result = await agent.generate({
+                prompt,
+                ...(abortSignal ? { abortSignal } : {}),
+            });
+            emitProgress({ type: 'subagent:end', agent: name, label: 'Delegate finished' });
+            return result.text;
+        },
+    });
+}
 export function createCodingAgent(runId = 'default') {
     const scratchpadTools = createScratchpadTools(runId);
+    const appBuilder = createAppBuilderAgent(runId);
+    const qaBuilder = createQaIntegrationAgent(runId);
     return new ToolLoopAgent({
         model: models.coding,
         instructions: [
-            'You are ZilMate Coding Agent — a focused software engineering partner for this machine.',
+            'You are ZilMate Coding Agent, the main coding orchestrator reporting back to the Manager.',
+            'You manage two internal coding delegates: appBuilder for full app/game/software implementation, and qaIntegration for testing, debugging, integration, and release checks.',
+            'Delegate substantial end-to-end build work to appBuilder. Delegate verification, failing builds, test strategy, and integration cleanup to qaIntegration. Keep ownership of the final user-facing report.',
             '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).',
+            'Workflow: gitStatus -> search/read skills -> read affected files -> plan/delegate if useful -> patch or targeted writeFile -> run tests via executeCommand or qaIntegration -> gitDiff -> 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.',
+            'Use searchSkills/readSkill when a repo skill documents conventions. For AI SDK work, verify against local ai docs/source. For Composio integrations, follow search -> link -> execute patterns and keep secrets server-side.',
+            'Use scratchpad for temporary run planning. Use notebook tools for durable project memory: architecture decisions, setup steps, known failures, ports, commands, and handoff notes.',
+            'Report what you changed, which files, subagents used, and test/build output. Keep the final concise but include failures honestly.',
             'Do not claim tests passed unless executeCommand output shows success.',
         ].join(' '),
         tools: {
+            appBuilder: codingDelegateTool('appBuilder', 'Delegate full app, game, software, Vite, Next.js, UI, or end-to-end implementation work to the internal app builder.', appBuilder),
+            qaIntegration: codingDelegateTool('qaIntegration', 'Delegate testing, debugging, build fixes, integration checks, and release-readiness verification to the internal QA/integration builder.', qaBuilder),
             ...timeTools,
             ...gitTools,
+            ...codeIntelligenceTools,
             ...fileSystemTools,
             ...shellTools,
             ...skillTools,
+            ...notebookTools,
             ...scratchpadTools,
         },
         stopWhen: stepCountIs(limits.subagentSteps),

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

@@ -1 +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"}
+{"version":3,"file":"coding.agent.js","sourceRoot":"","sources":["../../src/agents/coding.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;AACtD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,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;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEtD,SAAS,qBAAqB,CAAC,KAAK,GAAG,SAAS;IAC9C,MAAM,eAAe,GAAG,qBAAqB,CAAC,GAAG,KAAK,cAAc,CAAC,CAAC;IAEtE,OAAO,IAAI,aAAa,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC,MAAM;QACpB,YAAY,EAAE;YACZ,sIAAsI;YACtI,2MAA2M;YAC3M,sMAAsM;YACtM,0LAA0L;YAC1L,yKAAyK;YACzK,wHAAwH;YACxH,6GAA6G;SAC9G,CAAC,IAAI,CAAC,IAAI,CAAC;QACZ,KAAK,EAAE;YACL,GAAG,SAAS;YACZ,GAAG,eAAe;YAClB,GAAG,qBAAqB;YACxB,GAAG,UAAU;YACb,GAAG,UAAU;YACb,GAAG,aAAa;YAChB,GAAG,eAAe;SACnB;QACD,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,aAAa,CAAC;KAC5C,CAAC,CAAC;AACL,CAAC;AAED,SAAS,wBAAwB,CAAC,KAAK,GAAG,SAAS;IACjD,MAAM,eAAe,GAAG,qBAAqB,CAAC,GAAG,KAAK,KAAK,CAAC,CAAC;IAE7D,OAAO,IAAI,aAAa,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC,MAAM;QACpB,YAAY,EAAE;YACZ,+JAA+J;YAC/J,2HAA2H;YAC3H,gHAAgH;YAChH,8IAA8I;YAC9I,0HAA0H;YAC1H,2JAA2J;YAC3J,0HAA0H;SAC3H,CAAC,IAAI,CAAC,IAAI,CAAC;QACZ,KAAK,EAAE;YACL,GAAG,SAAS;YACZ,GAAG,QAAQ;YACX,GAAG,qBAAqB;YACxB,GAAG,eAAe;YAClB,GAAG,UAAU;YACb,GAAG,UAAU;YACb,GAAG,aAAa;YAChB,GAAG,eAAe;SACnB;QACD,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,aAAa,CAAC;KAC5C,CAAC,CAAC;AACL,CAAC;AAMD,SAAS,kBAAkB,CAAC,IAAoC,EAAE,WAAmB,EAAE,KAAqB;IAC1G,OAAO,IAAI,CAAC;QACV,WAAW;QACX,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC;YACpB,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;YACxB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;SAC/B,CAAC;QACF,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE;YACpD,YAAY,CAAC,EAAE,IAAI,EAAE,gBAAgB,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,uBAAuB,EAAE,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;YAClH,YAAY,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,4BAA4B,EAAE,CAAC,CAAC;YAC1F,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,cAAc,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;YAC/D,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,QAAQ,CAAC;gBAClC,MAAM;gBACN,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aACxC,CAAC,CAAC;YACH,YAAY,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,mBAAmB,EAAE,CAAC,CAAC;YAChF,OAAO,MAAM,CAAC,IAAI,CAAC;QACrB,CAAC;KACF,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,KAAK,GAAG,SAAS;IACjD,MAAM,eAAe,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IACrD,MAAM,UAAU,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAChD,MAAM,SAAS,GAAG,wBAAwB,CAAC,KAAK,CAAC,CAAC;IAElD,OAAO,IAAI,aAAa,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC,MAAM;QACpB,YAAY,EAAE;YACZ,2FAA2F;YAC3F,4KAA4K;YAC5K,2MAA2M;YAC3M,oIAAoI;YACpI,8OAA8O;YAC9O,2HAA2H;YAC3H,8NAA8N;YAC9N,oLAAoL;YACpL,oIAAoI;YACpI,uEAAuE;SACxE,CAAC,IAAI,CAAC,GAAG,CAAC;QACX,KAAK,EAAE;YACL,UAAU,EAAE,kBAAkB,CAAC,YAAY,EAAE,sHAAsH,EAAE,UAAU,CAAC;YAChL,aAAa,EAAE,kBAAkB,CAAC,eAAe,EAAE,0IAA0I,EAAE,SAAS,CAAC;YACzM,GAAG,SAAS;YACZ,GAAG,QAAQ;YACX,GAAG,qBAAqB;YACxB,GAAG,eAAe;YAClB,GAAG,UAAU;YACb,GAAG,UAAU;YACb,GAAG,aAAa;YAChB,GAAG,eAAe;SACnB;QACD,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,aAAa,CAAC;KAC5C,CAAC,CAAC;AACL,CAAC"}

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

@@ -1,9 +1,22 @@
 import { ToolLoopAgent } from 'ai';
 export declare function createImageAgent(): ToolLoopAgent<never, {
+    enhanceImagePrompt: import("ai").Tool<{
+        idea: string;
+        style?: "product" | "cinematic" | "ui" | "illustration" | "photoreal" | undefined;
+        mustInclude?: string[] | undefined;
+        avoid?: string[] | undefined;
+    }, {
+        prompt: string;
+        style: string;
+    }>;
     generateImage: import("ai").Tool<{
         prompt: string;
         provider?: "openai" | "gemini" | "chatgpt" | "google" | "default" | undefined;
         size?: string | undefined;
+        imagePaths?: string[] | undefined;
+        imageUrls?: string[] | undefined;
+        maskPath?: string | undefined;
+        maskUrl?: string | undefined;
     }, import("../tools/image-generate.tool.js").ImageGenerationResult>;
 }, never>;
 //# sourceMappingURL=image.agent.d.ts.map

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;AAKhD,wBAAgB,gBAAgB;;;;;;UAO/B"}
+{"version":3,"file":"image.agent.d.ts","sourceRoot":"","sources":["../../src/agents/image.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,aAAa,EAAQ,MAAM,IAAI,CAAC;AAgBtD,wBAAgB,gBAAgB;;;;;;;;;;;;;;;;;;;UAiC/B"}