grok-dev 1.0.0-rc5 → 1.0.0-rc7

package/.cursor/hooks/state/continual-learning.json

@@ -0,0 +1,8 @@
+{
+  "version": 1,
+  "lastRunAtMs": 0,
+  "turnsSinceLastRun": 4,
+  "lastTranscriptMtimeMs": null,
+  "lastProcessedGenerationId": "518874b0-1435-472e-9c42-c54214a9ae4e",
+  "trialStartedAtMs": null
+}

package/.grok/settings.json

@@ -13,5 +13,9 @@
       },
       "enabled": true
     }
+  },
+  "sandboxMode": "shuru",
+  "sandbox": {
+    "allowNet": false
   }
 }

package/README.md

@@ -10,6 +10,8 @@ The rest borrowed from each other. We borrowed from *all of them*, then wired it
 
 Open source. Terminal-native. Built with **Bun** and **OpenTUI**. If you want vibes *and* velocity, you’re in the right repo.
 
+Community-built and unofficial. This project is not affiliated with or endorsed by xAI, and it is not the official Grok CLI.
+
 https://github.com/user-attachments/assets/7ca4f6df-50ca-4e9c-91b2-d4abad5c66cb
 
 ---
@@ -22,7 +24,7 @@ npm i -g grok-dev
 
 The CLI binary is **`grok`** (yes, the package name and the command differ—deal with it).
 
-**Prerequisites:** Node 18+ (for the global install), and a **Grok API key** from [x.ai](https://x.ai).
+**Prerequisites:** Node 18+ (for the global install), a **Grok API key** from [x.ai](https://x.ai), and a modern terminal emulator for the interactive OpenTUI experience. Headless `--prompt` mode does not depend on terminal UI support.
 
 ---
 
@@ -34,6 +36,17 @@ The CLI binary is **`grok`** (yes, the package name and the command differ—dea
 grok
 ```
 
+### Supported terminals
+
+For the most reliable interactive OpenTUI experience, use a modern terminal emulator. We currently document and recommend:
+
+- **WezTerm** (cross-platform)
+- **Alacritty** (cross-platform)
+- **Ghostty** (macOS and Linux)
+- **Kitty** (macOS and Linux)
+
+Other modern terminals may work, but these are the terminal apps we currently recommend and document for interactive use.
+
 **Pick a project directory:**
 
 ```bash
@@ -68,6 +81,26 @@ grok --prompt "summarize the repo state" --format json
 default human-readable text output. Events are semantic, step-level records such
 as `step_start`, `text`, `tool_use`, `step_finish`, and `error`.
 
+### Scheduling
+
+Schedules let Grok run a headless prompt on a recurring schedule or once. Ask
+for it in natural language, for example:
+
+```text
+Create a schedule named daily-changelog-update that runs every weekday at 9am
+and updates CHANGELOG.md from the latest merged commits.
+```
+
+Recurring schedules require the background daemon:
+
+```bash
+grok daemon --background
+```
+
+Use `/schedule` in the TUI to browse saved schedules. One-time schedules start
+immediately in the background; recurring schedules keep running as long as the
+daemon is active.
+
 **List Grok models and pricing hints:**
 
 ```bash
@@ -80,6 +113,18 @@ grok models
 grok fix the flaky test in src/foo.test.ts
 ```
 
+**Generate images or short videos from chat:**
+
+```bash
+grok "Generate a retro-futuristic logo for my CLI called Grok Forge"
+grok "Edit ./assets/hero.png into a watercolor poster"
+grok "Animate ./assets/cover.jpg into a 6 second cinematic push-in"
+```
+
+Image and video generation are exposed as agent tools inside normal chat sessions.
+You keep using a text model for the session, and Grok saves generated media under
+`.grok/generated-media/` by default unless you ask for a specific output path.
+
 ---
 
 ## What you actually get
@@ -88,6 +133,7 @@ grok fix the flaky test in src/foo.test.ts
 |--------|----------------|
 | **Grok-native** | Defaults tuned for Grok; models like **`grok-code-fast-1`**, **`grok-4-1-fast-reasoning`**, **`grok-4.20-multi-agent-0309`**, plus flagship and fast variants—run `grok models` for the full menu. |
 | **X + web search** | **`search_x`** and **`search_web`** tools—live posts and docs without pretending the internet stopped in 2023. |
+| **Media generation** | Built-in **`generate_image`** and **`generate_video`** tools for text-to-image, image editing, text-to-video, and image-to-video flows. Generated files are saved locally so you can reuse them after the xAI URLs expire. |
 | **Sub-agents (default behavior)** | Foreground **`task`** delegation (e.g. explore vs general) plus background **`delegate`** for read-only deep dives—parallelize like you mean it. |
 | **Custom sub-agents** | Define named agents with **`subAgents`** in **`~/.grok/user-settings.json`** and manage them from the TUI with **`/agents`**. |
 | **Remote control** | Pair **Telegram** from the TUI (`/remote-control` → Telegram): DM your bot, **`/pair`**, approve the code in-terminal. Keep the CLI running while you ping it from your phone. |
@@ -157,6 +203,69 @@ Optional: **`GROK_BASE_URL`** (default `https://api.x.ai/v1`), **`GROK_MODEL`**,
 3. Start **`grok`**, open **`/remote-control`** → **Telegram** if needed, then in Telegram DM your bot: **`/pair`**, enter the **6-character code** in the terminal when asked.
 4. First user must be approved once; after that, it’s remembered. **Keep the CLI process running** while you use the bot (long polling lives in that process).
 
+### Voice & audio messages
+
+Send a voice note or audio attachment in Telegram and Grok will transcribe it locally with **[whisper.cpp](https://github.com/ggml-org/whisper.cpp)** before passing the text to the agent. No cloud STT service is involved — everything runs on your machine.
+
+#### Prerequisites
+
+| Dependency | Why | Install (macOS) |
+|---|---|---|
+| **whisper-cli** | Runs the actual speech-to-text inference | `brew install whisper-cpp` |
+| **ffmpeg** | Converts Telegram voice notes (OGG/Opus) to WAV for whisper.cpp | `brew install ffmpeg` |
+
+After installing, verify both are available:
+
+```bash
+whisper-cli -h
+ffmpeg -version
+```
+
+#### Download a Whisper model
+
+Grok CLI auto-downloads the configured model on first use, but you can pre-download it:
+
+```bash
+mkdir -p ~/.grok/models/stt/whisper.cpp
+curl -L https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-tiny.en.bin \
+  -o ~/.grok/models/stt/whisper.cpp/ggml-tiny.en.bin
+```
+
+Available models (trade size for accuracy): `tiny.en` (75 MB), `base.en` (142 MB), `small.en` (466 MB).
+
+#### Configure in `~/.grok/user-settings.json`
+
+```json
+{
+  "telegram": {
+    "botToken": "YOUR_BOT_TOKEN",
+    "audioInput": {
+      "enabled": true,
+      "binaryPath": "/opt/homebrew/bin/whisper-cli",
+      "model": "tiny.en",
+      "modelPath": "~/.grok/models/stt/whisper.cpp/ggml-tiny.en.bin",
+      "autoDownloadModel": true,
+      "language": "en"
+    }
+  }
+}
+```
+
+| Setting | Default | Description |
+|---|---|---|
+| `enabled` | `true` | Set to `false` to ignore voice/audio messages entirely. |
+| `binaryPath` | `whisper-cli` | Absolute path or command name for the whisper.cpp CLI binary. |
+| `model` | `tiny.en` | Model alias used for auto-download resolution. |
+| `modelPath` | _(auto-resolved)_ | Explicit path to a `.bin` model file. Overrides `model` + auto-download. |
+| `autoDownloadModel` | `true` | Download the model into `~/.grok/models/stt/whisper.cpp` on first use. |
+| `language` | `en` | Whisper language code passed to the CLI. |
+
+Optional headless flow when you do not want the TUI open:
+
+```bash
+grok telegram-bridge
+```
+
 Treat the bot token like a password.
 
 ---
@@ -173,6 +282,26 @@ Project file: **`.grok/settings.json`** — e.g. the current model for this proj
 
 ---
 
+## Sandbox
+
+Grok CLI can run shell commands inside a [Shuru](https://github.com/superhq-ai/shuru) microVM sandbox so the agent can't touch your host filesystem or network.
+
+**Requires macOS 14+ on Apple Silicon.**
+
+Enable it with `--sandbox` on the CLI, or toggle it from the TUI with `/sandbox`.
+
+When sandbox mode is active you can configure:
+
+- **Network** — off by default; enable with `--allow-net`, restrict with `--allow-host`
+- **Port forwards** — `--port 8080:80`
+- **Resource limits** — CPUs, memory, disk size (via settings or `/sandbox` panel)
+- **Checkpoints** — start from a saved environment snapshot
+- **Secrets** — inject API keys without exposing them inside the VM
+
+All settings are saved in `~/.grok/user-settings.json` (user) and `.grok/settings.json` (project).
+
+---
+
 ## Development
 
 From a clone:

package/dist/agent/agent.d.ts

@@ -1,7 +1,11 @@
+import { type ScheduleDaemonStatus, type StoredSchedule } from "../tools/schedule";
 import type { AgentMode, ChatEntry, SessionInfo, SessionSnapshot, StreamChunk, SubagentStatus, TaskRequest, ToolCall, ToolResult } from "../types/index";
+import { type SandboxMode, type SandboxSettings } from "../utils/settings";
 interface AgentOptions {
     persistSession?: boolean;
     session?: string;
+    sandboxMode?: SandboxMode;
+    sandboxSettings?: SandboxSettings;
 }
 type ProcessMessageFinishReason = "stop" | "length" | "content-filter" | "tool-calls" | "error" | "other";
 export interface ProcessMessageUsage {
@@ -45,6 +49,7 @@ export declare class Agent {
     private baseURL;
     private bash;
     private delegations;
+    private schedules;
     private sessionStore;
     private workspace;
     private session;
@@ -57,15 +62,24 @@ export declare class Agent {
     private maxTokens;
     private planContext;
     private subagentStatusListeners;
+    private sendTelegramFile;
     constructor(apiKey: string | undefined, baseURL?: string, model?: string, maxToolRounds?: number, options?: AgentOptions);
     getModel(): string;
     setModel(model: string): void;
     getMode(): AgentMode;
+    getSandboxMode(): SandboxMode;
+    setSandboxMode(mode: SandboxMode): void;
+    getSandboxSettings(): SandboxSettings;
+    setSandboxSettings(settings: SandboxSettings): void;
     setMode(mode: AgentMode): void;
     setPlanContext(ctx: string | null): void;
+    setSendTelegramFile(fn: ((filePath: string) => Promise<ToolResult>) | null): void;
     hasApiKey(): boolean;
     setApiKey(apiKey: string, baseURL?: string | undefined): void;
     getCwd(): string;
+    listSchedules(): Promise<StoredSchedule[]>;
+    removeSchedule(id: string): Promise<string>;
+    getScheduleDaemonStatus(): Promise<ScheduleDaemonStatus>;
     getContextStats(contextWindow: number, inFlightText?: string): {
         contextWindow: number;
         usedTokens: number;

package/dist/agent/agent.js

@@ -5,13 +5,16 @@ import { createTools } from "../grok/tools";
 import { buildMcpToolSet } from "../mcp/runtime";
 import { appendCompaction, appendMessages, appendSystemMessage, buildChatEntries, getNextMessageSequence, getSessionTotalTokens, loadTranscript, loadTranscriptState, recordUsageEvent, SessionStore, } from "../storage/index";
 import { BashTool } from "../tools/bash";
+import { ScheduleManager } from "../tools/schedule";
 import { loadCustomInstructions } from "../utils/instructions";
-import { loadMcpServers, loadValidSubAgents } from "../utils/settings";
+import { loadMcpServers, loadValidSubAgents, } from "../utils/settings";
 import { discoverSkills, formatSkillsForPrompt } from "../utils/skills";
 import { createCompactionSummaryMessage, DEFAULT_KEEP_RECENT_TOKENS, DEFAULT_RESERVE_TOKENS, estimateConversationTokens, generateCompactionSummary, prepareCompaction, relaxCompactionSettings, shouldCompactContext, } from "./compaction";
 import { DelegationManager } from "./delegations";
 import { containsEncryptedReasoning, sanitizeModelMessages } from "./reasoning";
+import { buildVisionUserMessages } from "./vision-input";
 const MAX_TOOL_ROUNDS = 400;
+const VISION_MODEL = "grok-4-1-fast-reasoning";
 const ENVIRONMENT = `ENVIRONMENT:
 You are running inside a terminal (CLI). Your text output is rendered in a plain terminal — not a browser, not a rich text editor.
 - Use plain text only. No markdown tables, no HTML, no images, no colored text.
@@ -37,8 +40,17 @@ TOOLS:
 - delegate: Launch a read-only background agent for longer research while you continue working.
 - delegation_read: Retrieve a completed background delegation result by ID.
 - delegation_list: List running and completed background delegations. Do not poll it repeatedly.
+- schedule_create: Create a recurring or one-time scheduled headless run.
+- schedule_list: List saved schedules and their status.
+- schedule_remove: Remove a saved schedule.
+- schedule_read_log: Read recent log output from a schedule.
+- schedule_daemon_status: Check whether the schedule daemon is running.
+- schedule_daemon_start: Start the schedule daemon in the background.
+- schedule_daemon_stop: Stop the schedule daemon.
 - search_web: Search the web for current information, documentation, APIs, tutorials, etc.
 - search_x: Search X/Twitter for real-time posts, discussions, opinions, and trends.
+- generate_image: Generate a new image or edit an existing image. It saves image files locally and returns their paths.
+- generate_video: Generate a new video or animate an existing image. It saves video files locally and returns their paths.
 - MCP tools: Enabled servers appear as tools named like mcp_<server>__<tool>.
 
 WORKFLOW:
@@ -68,12 +80,19 @@ EXAMPLES:
 - "research how auth works" -> delegate to explore first
 - "investigate why this test fails" -> delegate to explore first, then continue with findings
 - "refactor this module" -> delegate a focused part to general when helpful
+- "generate a logo" -> use generate_image
+- "animate this still image" -> use generate_video
 - Recurring specialized workflows -> use the matching custom sub-agent via task
+- "every weekday at 9am run this check" -> use schedule_create with a cron expression
+- "run this once automatically" -> use schedule_create with the right timing
+- "make sure scheduled jobs keep running" -> use schedule_daemon_status and schedule_daemon_start
 
 IMPORTANT:
 - Prefer edit_file for surgical changes to existing files — it shows a clean diff.
 - Use write_file only for new files or when most of the file is changing.
 - Use read_file instead of cat/head/tail for reading files.
+- When the user asks for an automated recurring or one-time run, use the schedule tools instead of only describing the setup.
+- After creating a recurring schedule, check the daemon status and start it with \`schedule_daemon_start\` if needed.
 
 Be direct. Execute, don't just describe. Show results, not plans.`,
     plan: `You are Grok CLI in Plan mode — you analyze and plan but DO NOT execute changes.
@@ -123,7 +142,7 @@ function formatCustomSubagentsPromptSection(subagents) {
     });
     return `\n\nCUSTOM SUB-AGENTS:\nUser-defined foreground sub-agents from ~/.grok/user-settings.json. When one matches the task, call the task tool with agent set to the exact name.\n\n${lines.join("\n\n")}\n`;
 }
-function buildSystemPrompt(cwd, mode, planContext, subagents) {
+function buildSystemPrompt(cwd, mode, sandboxMode, planContext, subagents, sandboxSettings) {
     const custom = loadCustomInstructions(cwd);
     const customSection = custom
         ? `\n\nCUSTOM INSTRUCTIONS:\n${custom}\n\nFollow the above alongside standard instructions.\n`
@@ -131,32 +150,38 @@ function buildSystemPrompt(cwd, mode, planContext, subagents) {
     const skillsText = formatSkillsForPrompt(discoverSkills(cwd));
     const skillsSection = skillsText ? `\n\n${skillsText}\n` : "";
     const subagentsSection = formatCustomSubagentsPromptSection(subagents ?? loadValidSubAgents());
+    const sandboxSection = formatSandboxPromptSection(sandboxMode, sandboxSettings);
     const planSection = planContext
         ? `\n\nAPPROVED PLAN:\nThe following plan has been approved by the user. Execute it now.\n${planContext}\n`
         : "";
-    return `${MODE_PROMPTS[mode]}${customSection}${skillsSection}${subagentsSection}${planSection}
+    return `${MODE_PROMPTS[mode]}${sandboxSection}${customSection}${skillsSection}${subagentsSection}${planSection}
 
 Current working directory: ${cwd}`;
 }
-function buildSubagentPrompt(request, cwd, custom, subagents) {
+function buildSubagentPrompt(request, cwd, custom, sandboxMode, subagents, sandboxSettings) {
     const isExplore = request.agent === "explore";
+    const isVision = request.agent === "vision";
     const mode = isExplore ? "ask" : "agent";
     const role = custom
         ? `You are the custom sub-agent "${custom.name}". You can investigate, edit files, and run commands unless the delegated task says otherwise.`
         : request.agent === "explore"
             ? "You are the Explore sub-agent. You are read-only and focus on fast codebase research."
-            : "You are the General sub-agent. You can investigate, edit files, and run commands to complete delegated work.";
+            : isVision
+                ? "You are the Vision sub-agent."
+                : "You are the General sub-agent. You can investigate, edit files, and run commands to complete delegated work.";
     const rules = isExplore
         ? [
             "Do not create, modify, or delete files.",
             "Prefer `read_file` and search commands over broad shell exploration.",
             "Return concise findings for the parent agent.",
         ]
-        : [
-            "Work only on the delegated task below.",
-            "Use tools directly instead of narrating your intent.",
-            "Return a concise summary for the parent agent with key outcomes and any open risks.",
-        ];
+        : isVision
+            ? ["Validate the image."]
+            : [
+                "Work only on the delegated task below.",
+                "Use tools directly instead of narrating your intent.",
+                "Return a concise summary for the parent agent with key outcomes and any open risks.",
+            ];
     const instructionLines = custom?.instruction.trim() ? ["", "SUB-AGENT INSTRUCTIONS:", custom.instruction.trim()] : [];
     return [
         role,
@@ -169,9 +194,40 @@ function buildSubagentPrompt(request, cwd, custom, subagents) {
         "",
         `Delegated task: ${request.description}`,
         "",
-        buildSystemPrompt(cwd, mode, undefined, subagents),
+        buildSystemPrompt(cwd, mode, sandboxMode, undefined, subagents, sandboxSettings),
     ].join("\n");
 }
+function formatSandboxPromptSection(sandboxMode, settings) {
+    if (sandboxMode === "off")
+        return "";
+    const s = settings ?? {};
+    let networkLine;
+    if (s.allowNet) {
+        networkLine = s.allowedHosts?.length
+            ? `- Network access is restricted to: ${s.allowedHosts.join(", ")}.`
+            : "- Network access is enabled.";
+    }
+    else {
+        networkLine = "- Network is disabled.";
+    }
+    const lines = [
+        "",
+        "SANDBOX MODE:",
+        "- Bash commands run inside a Shuru sandbox.",
+        networkLine,
+        "- The current workspace is mounted inside the sandbox at `/workspace`.",
+        "- Shell-side workspace file changes do not persist back to the host in this version.",
+        "- Use `read_file`, `edit_file`, and `write_file` for durable source edits.",
+        "- If a task needs a host-persistent shell mutation, explain that sandbox mode blocks that workflow and ask whether to disable sandbox mode.",
+    ];
+    if (s.ports?.length) {
+        lines.push(`- Port forwards: ${s.ports.join(", ")}.`);
+    }
+    if (s.from) {
+        lines.push(`- Starting from checkpoint: ${s.from}.`);
+    }
+    return lines.join("\n");
+}
 function applyModelConstraints(system, modelId) {
     const modelInfo = getModelInfo(modelId);
     if (modelInfo?.supportsClientTools !== false) {
@@ -192,6 +248,7 @@ export class Agent {
     baseURL = null;
     bash;
     delegations;
+    schedules;
     sessionStore = null;
     workspace = null;
     session = null;
@@ -204,14 +261,19 @@ export class Agent {
     maxTokens;
     planContext = null;
     subagentStatusListeners = new Set();
+    sendTelegramFile = null;
     constructor(apiKey, baseURL, model, maxToolRounds, options = {}) {
         this.baseURL = baseURL || null;
         if (apiKey) {
             this.setApiKey(apiKey, baseURL);
         }
-        this.bash = new BashTool();
+        this.bash = new BashTool(process.cwd(), {
+            sandboxMode: options.sandboxMode ?? "off",
+            sandboxSettings: options.sandboxSettings,
+        });
         this.delegations = new DelegationManager(() => this.bash.getCwd());
         this.modelId = normalizeModelId(model || DEFAULT_MODEL);
+        this.schedules = new ScheduleManager(() => this.bash.getCwd(), () => this.modelId);
         this.maxToolRounds = maxToolRounds || MAX_TOOL_ROUNDS;
         const envMax = Number(process.env.GROK_MAX_TOKENS);
         this.maxTokens = Number.isFinite(envMax) && envMax > 0 ? envMax : 16_384;
@@ -239,6 +301,18 @@ export class Agent {
     getMode() {
         return this.mode;
     }
+    getSandboxMode() {
+        return this.bash.getSandboxMode();
+    }
+    setSandboxMode(mode) {
+        this.bash.setSandboxMode(mode);
+    }
+    getSandboxSettings() {
+        return this.bash.getSandboxSettings();
+    }
+    setSandboxSettings(settings) {
+        this.bash.setSandboxSettings(settings);
+    }
     setMode(mode) {
         if (mode !== this.mode) {
             this.mode = mode;
@@ -251,6 +325,9 @@ export class Agent {
     setPlanContext(ctx) {
         this.planContext = ctx;
     }
+    setSendTelegramFile(fn) {
+        this.sendTelegramFile = fn;
+    }
     hasApiKey() {
         return !!this.apiKey;
     }
@@ -262,8 +339,18 @@ export class Agent {
     getCwd() {
         return this.bash.getCwd();
     }
+    async listSchedules() {
+        return this.schedules.list();
+    }
+    async removeSchedule(id) {
+        const removed = await this.schedules.remove(id);
+        return removed ? `Removed schedule "${removed.name}".` : `Schedule "${id}" not found.`;
+    }
+    async getScheduleDaemonStatus() {
+        return this.schedules.getDaemonStatus();
+    }
     getContextStats(contextWindow, inFlightText = "") {
-        const system = buildSystemPrompt(this.bash.getCwd(), this.mode, this.planContext);
+        const system = buildSystemPrompt(this.bash.getCwd(), this.mode, this.bash.getSandboxMode(), this.planContext, undefined, this.bash.getSandboxSettings());
         const usedTokens = Math.min(contextWindow, estimateConversationTokens(system, this.messages, inFlightText));
         const remainingTokens = Math.max(0, contextWindow - usedTokens);
         return {
@@ -380,10 +467,11 @@ export class Agent {
         const agentKey = String(request.agent);
         const isExplore = agentKey === "explore";
         const isGeneral = agentKey === "general";
+        const isVision = agentKey === "vision";
         const subagents = loadValidSubAgents();
-        const custom = !isExplore && !isGeneral ? findCustomSubagent(agentKey, subagents) : undefined;
-        if (!isExplore && !isGeneral && !custom) {
-            const message = `Unknown sub-agent "${agentKey}". Use general, explore, or a configured name from ~/.grok/user-settings.json.`;
+        const custom = !isExplore && !isGeneral && !isVision ? findCustomSubagent(agentKey, subagents) : undefined;
+        if (!isExplore && !isGeneral && !isVision && !custom) {
+            const message = `Unknown sub-agent "${agentKey}". Use general, explore, vision, or a configured name from ~/.grok/user-settings.json.`;
             return {
                 success: false,
                 output: message,
@@ -395,16 +483,21 @@ export class Agent {
             };
         }
         const childMode = isExplore ? "ask" : "agent";
-        const childBash = new BashTool(this.bash.getCwd());
+        const childBash = new BashTool(this.bash.getCwd(), {
+            sandboxMode: this.bash.getSandboxMode(),
+            sandboxSettings: this.bash.getSandboxSettings(),
+        });
         const childBaseTools = createTools(childBash, provider, childMode);
         const initialDetail = isExplore ? "Scanning the codebase" : "Planning delegated work";
         let assistantText = "";
         let lastActivity = initialDetail;
         let childTools = childBaseTools;
         let closeMcp;
-        const childModelId = normalizeModelId(isExplore ? DEFAULT_MODEL : custom ? custom.model : this.modelId);
-        const childRuntime = resolveModelRuntime(provider, childModelId);
-        const childSystem = applyModelConstraints(buildSubagentPrompt(request, childBash.getCwd(), custom ?? null, subagents), childRuntime.modelId);
+        const childModelId = normalizeModelId(isVision ? VISION_MODEL : isExplore ? DEFAULT_MODEL : custom ? custom.model : this.modelId);
+        const childRuntime = isVision
+            ? { ...resolveModelRuntime(provider, childModelId), model: provider.responses(childModelId) }
+            : resolveModelRuntime(provider, childModelId);
+        const childSystem = applyModelConstraints(buildSubagentPrompt(request, childBash.getCwd(), custom ?? null, childBash.getSandboxMode(), subagents, childBash.getSandboxSettings()), childRuntime.modelId);
         onActivity?.(initialDetail);
         try {
             if (childMode === "agent" && childRuntime.modelInfo?.supportsClientTools !== false) {
@@ -416,10 +509,13 @@ export class Agent {
                     onActivity?.(lastActivity);
                 }
             }
+            const childMessages = isVision
+                ? await buildVisionUserMessages(request.prompt, childBash.getCwd(), signal)
+                : [{ role: "user", content: request.prompt }];
             const result = streamText({
                 model: childRuntime.model,
                 system: childSystem,
-                messages: [{ role: "user", content: request.prompt }],
+                messages: childMessages,
                 tools: childRuntime.modelInfo?.supportsClientTools === false ? {} : childTools,
                 stopWhen: stepCountIs(Math.min(this.maxToolRounds, isExplore ? 60 : 120)),
                 maxRetries: 0,
@@ -505,6 +601,8 @@ export class Agent {
             }
             return await this.delegations.start(request, {
                 model: this.modelId,
+                sandboxMode: this.bash.getSandboxMode(),
+                sandboxSettings: this.bash.getSandboxSettings(),
                 maxToolRounds: this.maxToolRounds,
                 maxTokens: this.maxTokens,
             });
@@ -614,7 +712,7 @@ export class Agent {
         this.messageSeqs.push(null);
         const provider = this.requireProvider();
         const subagents = loadValidSubAgents();
-        const system = applyModelConstraints(buildSystemPrompt(this.bash.getCwd(), this.mode, this.planContext, subagents), this.modelId);
+        const system = applyModelConstraints(buildSystemPrompt(this.bash.getCwd(), this.mode, this.bash.getSandboxMode(), this.planContext, subagents, this.bash.getSandboxSettings()), this.modelId);
         const runtime = resolveModelRuntime(provider, this.modelId);
         const modelInfo = runtime.modelInfo;
         this.planContext = null;
@@ -639,7 +737,9 @@ export class Agent {
                         runDelegation: (request, abortSignal) => this.runDelegation(request, combineAbortSignals(signal, abortSignal)),
                         readDelegation: (id) => this.readDelegation(id),
                         listDelegations: () => this.listDelegations(),
+                        scheduleManager: this.schedules,
                         subagents,
+                        sendTelegramFile: this.sendTelegramFile ?? undefined,
                     });
                     let tools = runtime.modelInfo?.supportsClientTools === false ? {} : baseTools;
                     if (this.mode === "agent" && runtime.modelInfo?.supportsClientTools !== false) {
@@ -876,12 +976,13 @@ function toToolResult(output) {
         return {
             success: r.success,
             output: r.output,
-            error: r.success ? undefined : r.output,
+            error: r.error ?? (r.success ? undefined : r.output),
             diff: r.diff,
             plan: r.plan,
             task: r.task,
             delegation: r.delegation,
             backgroundProcess: r.backgroundProcess,
+            media: r.media,
         };
     }
     return { success: true, output: String(output) };
@@ -898,6 +999,10 @@ function formatSubagentActivity(toolName, args) {
         return `Web search "${truncate(parsed.query || "", 50)}"`;
     if (toolName === "search_x")
         return `X search "${truncate(parsed.query || "", 50)}"`;
+    if (toolName === "generate_image")
+        return `Generate image "${truncate(parsed.prompt || "", 50)}"`;
+    if (toolName === "generate_video")
+        return `Generate video "${truncate(parsed.prompt || "", 50)}"`;
     if (toolName === "bash")
         return truncate(parsed.command || "Run command", 70);
     return truncate(`${toolName}`, 70);