@lazyingart/agintiflow 0.8.11 → 0.9.0

package/README.md

@@ -28,7 +28,7 @@ It is designed for workflows where an AI agent should act, but every tool, log,
 | Core loop | Plan -> use tools -> log events -> finish or resume |
 | Browser control | Playwright, lazy browser startup, domain allowlists |
 | Model layer | Smart routing over DeepSeek fast/pro presets with manual OpenAI-compatible fallback |
-| Local tools | Guarded workspace file tools, optional shell commands, Docker sandbox support, and advisory agent wrappers |
+| Local tools | Guarded workspace file tools, Codex-style patching, optional shell commands, Docker sandbox support, and advisory agent wrappers |
 | Memory | Session state, persisted web settings, chat continuation |
 | Operator UX | Multilingual web UI with provider selection, run output, and conversation history |
 
@@ -53,6 +53,10 @@ aginti login deepseek
 # inside chat, use /login or /auth
 # or non-interactively:
 printf '%s' "$DEEPSEEK_API_KEY" | aginti keys set deepseek --stdin
+
+# optional image-generation auxiliary skill:
+aginti login grsai
+# inside chat, use /auxilliary grsai or /auxiliary grsai
 ```
 
 Start an interactive Codex-style CLI chat from any project folder:
@@ -65,6 +69,10 @@ aginti chat
 
 Inside chat, type normal requests such as `write a small Python CLI app with tests`. The default is Docker workspace mode with approved package installs, so coding, plotting, and LaTeX tasks can set up project-local tools without touching the host. Use `/help` for commands, `/login` or `/auth` to paste a provider key, `/latex on` for PDF work, `/docker off` only when you intentionally want host mode, `/sessions` to list project runs, and `/resume latest` or `/resume <session-id>` to continue work. Type `/` then Tab for command completion. Esc or Ctrl+C stops the active run cleanly and prints the resume command.
 
+For code edits, AgInTiFlow routes patch/refactor/database-style tasks to DeepSeek v4 pro by default and exposes `apply_patch` as a deterministic workspace tool. It supports exact replacements, Codex-style patch envelopes, and unified diffs, with preflight checks, path guardrails, hashes, and compact per-file diffs. See [docs/patch-tools.md](docs/patch-tools.md).
+
+For raster image work, AgInTiFlow has an optional `image_generation` skill backed by the `generate_image` tool and a local `GRSAI` key. The skill tells DeepSeek when image generation is appropriate; the tool calls GRS AI Nano Banana, saves manifests/images under `artifacts/images`, and sends the result to the canvas. See [docs/auxiliary-image-generation.md](docs/auxiliary-image-generation.md).
+
 Launch the local web UI from an installed package:
 
 ```bash

package/docs/auxiliary-image-generation.md

@@ -0,0 +1,62 @@
+# Auxiliary Image Generation
+
+AgInTiFlow separates **skills** from **tools**:
+
+- A skill is instruction and routing context that teaches the agent when a capability is useful.
+- A tool is the deterministic callable function that performs the action and writes auditable artifacts.
+
+The optional image-generation skill is `image_generation`. Its tool is `generate_image`.
+
+## Setup
+
+Store the GRS AI key project-locally:
+
+```bash
+aginti login grsai
+# or
+printf '%s' "$GRSAI" | aginti keys set grsai --stdin
+```
+
+Inside interactive chat, use either spelling:
+
+```text
+/auxilliary grsai
+/auxiliary grsai
+```
+
+The key is saved in `.aginti/.env` as `GRSAI` with `0600` permissions. The CLI and web app only report whether the key exists; they never return the raw value.
+
+## Runtime Flow
+
+For image, cover, poster, illustration, photo, or logo-concept requests, the model can call:
+
+```json
+{
+  "prompt": "A polished cyan robot painting a circuit-board river, high-end product illustration",
+  "outputDir": "artifacts/images/robot-cover",
+  "outputStem": "robot-cover",
+  "aspectRatio": "1:1",
+  "imageSize": "2K"
+}
+```
+
+The tool uses the GRS AI Nano Banana API:
+
+- `POST https://grsaiapi.com/v1/draw/nano-banana`
+- `POST https://grsaiapi.com/v1/draw/result`
+- `Authorization: Bearer <GRSAI>`
+
+Saved workspace artifacts:
+
+- `prompt.txt`
+- `request_payload.redacted.json`
+- `submit_response.json`
+- `result_response.json`
+- `task_manifest.json`
+- generated image files, for example `image.png`
+
+Generated images are sent to the canvas automatically when available.
+
+## Guardrails
+
+Output paths must stay inside the project workspace. Secret paths, `.git`, `node_modules` writes, and oversized reference images are blocked. Reference images may be workspace files, HTTPS URLs, or data URLs.

package/docs/patch-tools.md

@@ -0,0 +1,17 @@
+# Patch Tools
+
+AgInTiFlow exposes a deterministic `apply_patch` workspace tool for coding-agent edits. It is designed for DeepSeek v4 pro and other routed models to make auditable code changes without relying on free-form shell redirection.
+
+## Supported Patch Modes
+
+- Exact replacement: pass `path`, `search`, `replace`, and optionally `expectedReplacements` or `baseHash`.
+- Codex-style patch envelope: pass `patch` with `*** Begin Patch`, `*** Update File`, `*** Add File`, `*** Delete File`, and `*** End Patch`.
+- Unified diff: pass `patch` with standard `--- a/file`, `+++ b/file`, and `@@` hunks.
+
+All paths must stay inside the configured workspace. Secret-like paths, `.git`, `node_modules` writes, binary files, and huge files are blocked. Multi-file patches are preflighted before writing, and each changed file records before/after hashes plus a compact diff in the session events.
+
+## Agent Workflow
+
+For large codebases, the model should first use `list_files`, `search_files`, and `read_file` to identify the relevant files. It should then call `apply_patch`, run safe tests or linters when available, and summarize changed files and residual risk.
+
+Smart routing treats patch/refactor/edit/database tasks as complex work, so DeepSeek v4 pro is selected by default unless the user explicitly chooses another route.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.8.11",
+  "version": "0.9.0",
   "type": "module",
   "description": "AgInTiFlow is a resumable Playwright website-control agent with OpenAI-compatible tool calling.",
   "license": "Apache-2.0",
@@ -41,6 +41,7 @@
     "scripts/install-docker-ubuntu.sh",
     "scripts/setup-agent-toolchain-docker.sh",
     "scripts/real-deepseek-capabilities.js",
+    "scripts/smoke-auxiliary-tools.js",
     "scripts/smoke-cli-chat.js",
     "scripts/smoke-coding-tools.js",
     "scripts/smoke-capabilities.js",
@@ -61,12 +62,13 @@
     "check": "node --check run.js && node --check web.js && node --check bin/aginti-cli.js && node --check src/*.js",
     "setup:toolchain-docker": "scripts/setup-agent-toolchain-docker.sh",
     "smoke:coding-tools": "node scripts/smoke-coding-tools.js",
+    "smoke:auxiliary-tools": "node scripts/smoke-auxiliary-tools.js",
     "smoke:cli-chat": "node scripts/smoke-cli-chat.js",
     "smoke:toolchain-docker": "node scripts/smoke-toolchain-docker.js",
     "smoke:inbox": "node scripts/smoke-inbox.js",
     "smoke:web-api": "node scripts/smoke-web-api.js",
     "real:deepseek": "node scripts/real-deepseek-capabilities.js",
-    "test": "npm run check && npm run smoke:web-api && npm run smoke:coding-tools && npm run smoke:capabilities && npm run smoke:cli-chat && npm run smoke:inbox",
+    "test": "npm run check && npm run smoke:web-api && npm run smoke:coding-tools && npm run smoke:auxiliary-tools && npm run smoke:capabilities && npm run smoke:cli-chat && npm run smoke:inbox",
     "pack:dry-run": "npm pack --dry-run",
     "smoke:capabilities": "node scripts/smoke-capabilities.js"
   },

package/public/app.js

@@ -24,7 +24,7 @@ const translations = {
     setupHelp:
       "DeepSeek/OpenAI keys are missing. Use mock mode, export an env var, or save a project-local DeepSeek key.",
     setupEnvHelp:
-      "Env vars: DEEPSEEK_API_KEY, OPENAI_API_KEY, or LLM_API_KEY. Mock mode remains available for local tests.",
+      "Env vars: DEEPSEEK_API_KEY, OPENAI_API_KEY, LLM_API_KEY, and optional GRSAI for image generation. Mock mode remains available for local tests.",
     setupProviderLabel: "Provider",
     setupKeyLabel: "API key",
     saveKeyButton: "Save local key",
@@ -68,6 +68,7 @@ const translations = {
     headlessLabel: "Headless browser",
     shellToolLabel: "Enable shell tool",
     fileToolLabel: "Enable file tools",
+    auxiliaryToolLabel: "Enable auxiliary skills",
     wrapperToolLabel: "Enable agent wrappers",
     preferredWrapperLabel: "Preferred wrapper",
     dockerSandboxLabel: "Use Docker sandbox",
@@ -648,6 +649,7 @@ const logsEl = document.querySelector("#logs");
 const runMetaEl = document.querySelector("#run-meta");
 const stopRunButton = document.querySelector("#stop-run");
 const keyStatusEl = document.querySelector("#key-status");
+const allowAuxiliaryToolsField = document.querySelector("#allowAuxiliaryTools");
 const allowWrapperToolsField = document.querySelector("#allowWrapperTools");
 const preferredWrapperField = document.querySelector("#preferredWrapper");
 const wrapperStatusEl = document.querySelector("#wrapper-status");
@@ -744,7 +746,9 @@ function renderKeyStatus(status = lastKeyStatus) {
   if (!status) return;
   keyStatusEl.textContent = `${t("keysLabel")}: OpenAI ${
     status.openai ? t("availableLabel") : t("missingLabel")
-  } · DeepSeek ${status.deepseek ? t("availableLabel") : t("missingLabel")} · ${t("mockLabel")} ${
+  } · DeepSeek ${status.deepseek ? t("availableLabel") : t("missingLabel")} · GRS AI ${
+    status.grsai ? t("availableLabel") : t("missingLabel")
+  } · ${t("mockLabel")} ${
     status.mock ? t("availableLabel") : t("missingLabel")
   }`;
   if (setupCardEl) setupCardEl.hidden = Boolean(status.openai || status.deepseek);
@@ -979,6 +983,7 @@ function formPayload() {
     headless: document.querySelector("#headless").checked,
     allowShellTool: document.querySelector("#allowShellTool").checked,
     allowFileTools: document.querySelector("#allowFileTools").checked,
+    allowAuxiliaryTools: allowAuxiliaryToolsField?.checked ?? true,
     allowWrapperTools: allowWrapperToolsField.checked,
     preferredWrapper: preferredWrapperField.value,
     taskProfile: taskProfileField?.value || "auto",
@@ -2167,6 +2172,7 @@ async function loadConfig() {
   packageInstallPolicyField.value = prefs.packageInstallPolicy || "allow";
   document.querySelector("#allowShellTool").checked = prefs.allowShellTool ?? true;
   document.querySelector("#allowFileTools").checked = prefs.allowFileTools ?? true;
+  if (allowAuxiliaryToolsField) allowAuxiliaryToolsField.checked = prefs.allowAuxiliaryTools ?? true;
   allowWrapperToolsField.checked = prefs.allowWrapperTools ?? false;
   preferredWrapperField.value = prefs.preferredWrapper || "codex";
   document.querySelector("#dockerSandboxImage").value = prefs.dockerSandboxImage || "agintiflow-sandbox:latest";

package/public/index.html

@@ -57,6 +57,7 @@
               <select id="setup-provider">
                 <option value="deepseek">DeepSeek</option>
                 <option value="openai">OpenAI</option>
+                <option value="grsai">GRS AI image</option>
               </select>
             </label>
             <label>
@@ -175,6 +176,11 @@
               <span class="switch" aria-hidden="true"></span>
               <span data-i18n="fileToolLabel">Enable file tools</span>
             </label>
+            <label class="switch-label">
+              <input id="allowAuxiliaryTools" name="allowAuxiliaryTools" type="checkbox" checked />
+              <span class="switch" aria-hidden="true"></span>
+              <span data-i18n="auxiliaryToolLabel">Enable auxiliary skills</span>
+            </label>
             <label class="switch-label">
               <input id="allowPasswords" name="allowPasswords" type="checkbox" />
               <span class="switch" aria-hidden="true"></span>

package/scripts/smoke-auxiliary-tools.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { runAgent } from "../src/agent-runner.js";
+import { generateImage, listAuxiliarySkills } from "../src/auxiliary-tools.js";
+import { resolveRuntimeConfig } from "../src/config.js";
+import { providerKeyStatus, setProviderKey } from "../src/project.js";
+import { SessionStore } from "../src/session-store.js";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "agintiflow-auxiliary-"));
+const runtimeDir = path.join(tempRoot, "runtime");
+const workspace = path.join(tempRoot, "workspace");
+await fs.mkdir(workspace, { recursive: true });
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+try {
+  await setProviderKey(workspace, "grsai", "test-grsai-key");
+  const keyStatus = providerKeyStatus(workspace);
+  assert(keyStatus.grsai, "GRSAI key status was not detected");
+  assert(keyStatus.envVars.grsai.includes("GRSAI"), "GRSAI env var name was not reported");
+  assert(listAuxiliarySkills().some((skill) => skill.id === "image_generation"), "image_generation skill missing");
+
+  const dryRun = await generateImage(
+    {
+      prompt: "A small cyan robot holding a paintbrush, clean bright product illustration.",
+      outputDir: "artifacts/images/dry-run",
+      outputStem: "robot",
+      dryRun: true,
+    },
+    {
+      commandCwd: workspace,
+      allowFileTools: true,
+    }
+  );
+  assert(dryRun.ok && dryRun.dryRun, "generate_image dry run failed");
+  await fs.access(path.join(workspace, "artifacts/images/dry-run/task_manifest.json"));
+  const payloadText = await fs.readFile(path.join(workspace, "artifacts/images/dry-run/request_payload.redacted.json"), "utf8");
+  assert(payloadText.includes("nano-banana-2"), "redacted image payload was not written");
+
+  const blocked = await generateImage(
+    {
+      prompt: "blocked",
+      outputDir: ".env/images",
+      dryRun: true,
+    },
+    {
+      commandCwd: workspace,
+      allowFileTools: true,
+    }
+  );
+  assert(blocked.blocked, "generate_image did not block sensitive output path");
+
+  const config = resolveRuntimeConfig(
+    {
+      provider: "mock",
+      routingMode: "manual",
+      model: "mock-agent",
+      goal: "Generate an image of a panda astronaut.",
+      commandCwd: workspace,
+      allowFileTools: true,
+      allowAuxiliaryTools: true,
+      maxSteps: 4,
+    },
+    {
+      baseDir: runtimeDir,
+      packageDir: repoRoot,
+      provider: "mock",
+    }
+  );
+  const run = await runAgent(config);
+  const store = new SessionStore(config.sessionsDir, run.sessionId);
+  const events = await store.loadEvents();
+  assert(events.some((event) => event.type === "tool.completed" && event.data?.toolName === "generate_image"), "mock run did not call generate_image");
+  await fs.access(path.join(workspace, "artifacts/images/mock-image/task_manifest.json"));
+
+  console.log(
+    JSON.stringify(
+      {
+        ok: true,
+        workspace,
+        checks: ["grsai_key_status", "image_skill_listed", "generate_image_dry_run", "generate_image_guardrail", "mock_agent_image_tool"],
+      },
+      null,
+      2
+    )
+  );
+} finally {
+  await fs.rm(tempRoot, { recursive: true, force: true });
+}

package/scripts/smoke-coding-tools.js

@@ -5,7 +5,9 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { repairModelMessageHistory, runAgent } from "../src/agent-runner.js";
 import { resolveRuntimeConfig } from "../src/config.js";
+import { selectModelRoute } from "../src/model-routing.js";
 import { SessionStore } from "../src/session-store.js";
+import { executeWorkspaceTool } from "../src/workspace-tools.js";
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "agintiflow-coding-tools-"));
@@ -78,6 +80,12 @@ try {
     !staleDeepSeekState.messages.some((message) => message.role === "tool" && message.tool_call_id === "stale-call"),
     "repaired DeepSeek history retained an orphan stale tool message"
   );
+  const patchRoute = selectModelRoute({
+    routingMode: "smart",
+    provider: "deepseek",
+    goal: "patch this large codebase and migrate the database tests",
+  });
+  assert(/pro/i.test(patchRoute.model), "patch/refactor task did not route to DeepSeek pro");
 
   const writeRun = await runMock("Create notes/hello.md with a short coding smoke message.", "coding-write");
   const written = await fs.readFile(path.join(workspace, "notes/hello.md"), "utf8");
@@ -106,6 +114,78 @@ try {
   assert(patched === "new\n", "mock patch did not update expected file");
   assert(patchRun.events.some((event) => event.type === "file.changed"), "patch run did not persist file.changed event");
 
+  await fs.writeFile(path.join(workspace, "patch-target.txt"), "old\n", "utf8");
+  const multiPatchRun = await runMock("Apply multi-file Codex patch to replace old and add a note.", "coding-patch-multi");
+  const multiPatched = await fs.readFile(path.join(workspace, "patch-target.txt"), "utf8");
+  const patchNote = await fs.readFile(path.join(workspace, "notes/patch-note.md"), "utf8");
+  assert(multiPatched === "new\n", "mock multi-file patch did not update expected file");
+  assert(patchNote.includes("multi-file patch smoke"), "mock multi-file patch did not add expected file");
+  assert(
+    multiPatchRun.events.filter((event) => event.type === "file.changed").length >= 2,
+    "multi-file patch did not persist per-file change events"
+  );
+
+  await fs.writeFile(path.join(workspace, "unified-target.txt"), "alpha\nold\nomega\n", "utf8");
+  const unified = await executeWorkspaceTool(
+    "apply_patch",
+    {
+      patch: [
+        "--- a/unified-target.txt",
+        "+++ b/unified-target.txt",
+        "@@ -1,3 +1,3 @@",
+        " alpha",
+        "-old",
+        "+new",
+        " omega",
+      ].join("\n"),
+    },
+    {
+      commandCwd: workspace,
+      allowFileTools: true,
+    }
+  );
+  const unifiedText = await fs.readFile(path.join(workspace, "unified-target.txt"), "utf8");
+  assert(unified.ok && unifiedText === "alpha\nnew\nomega\n", "unified apply_patch did not update expected file");
+
+  const blockedPatch = await executeWorkspaceTool(
+    "apply_patch",
+    {
+      patch: ["*** Begin Patch", "*** Add File: .env", "+TOKEN=blocked", "*** End Patch"].join("\n"),
+    },
+    {
+      commandCwd: workspace,
+      allowFileTools: true,
+    }
+  );
+  assert(blockedPatch.blocked, "patch document to sensitive path was not blocked by guardrail");
+
+  await fs.writeFile(path.join(workspace, "move-source.txt"), "source\n", "utf8");
+  await fs.writeFile(path.join(workspace, "move-target.txt"), "target\n", "utf8");
+  const moveOverResult = await executeWorkspaceTool(
+    "apply_patch",
+    {
+      patch: [
+        "*** Begin Patch",
+        "*** Update File: move-source.txt",
+        "*** Move to: move-target.txt",
+        "@@",
+        "-source",
+        "+moved",
+        "*** End Patch",
+      ].join("\n"),
+    },
+    {
+      commandCwd: workspace,
+      allowFileTools: true,
+    }
+  )
+    .then(() => "")
+    .catch((error) => String(error?.message || error));
+  assert(
+    /move over an existing file/.test(moveOverResult),
+    "patch move over an existing file was not rejected"
+  );
+
   const envRun = await runMock("Create file: .env with blocked content.", "coding-block-env");
   await fs
     .access(path.join(workspace, ".env"))
@@ -135,11 +215,16 @@ try {
         workspace,
         checks: [
           "deepseek_history_repair",
+          "deepseek_pro_patch_route",
           "write_file",
           "duplicate_write_failed",
           "resume_session_write",
           "virtual_workspace_path",
           "apply_patch",
+          "multi_file_patch",
+          "unified_patch",
+          "patch_guardrail",
+          "patch_move_no_overwrite",
           "block_env",
           "block_outside",
         ],

package/src/agent-runner.js

@@ -17,6 +17,7 @@ import { redactSensitiveText, redactValue } from "./redaction.js";
 import { executeWorkspaceTool, resolveWorkspacePath, summarizeWorkspaceTools, WORKSPACE_TOOL_NAMES } from "./workspace-tools.js";
 import { normalizeCanvasPayload } from "./artifact-tunnel.js";
 import { getTaskProfile } from "./task-profiles.js";
+import { generateImage, listAuxiliarySkills } from "./auxiliary-tools.js";
 
 const exec = promisify(execCallback);
 const BROWSER_TOOLS = new Set(["open_url", "open_workspace_file", "preview_workspace", "click", "type", "scroll", "press", "back"]);
@@ -271,15 +272,20 @@ function createInitialState(config, sessionId) {
               : "A host shell command tool is available under the configured trust policy."
             : "No shell command tool is available.",
           config.allowFileTools
-            ? `Workspace file tools are available in ${config.commandCwd}: list_files, read_file, search_files, write_file, apply_patch, open_workspace_file, and preview_workspace. Always use workspace-relative paths such as plot_fx.svg or docs/report.tex, never absolute host paths. Secret paths, .git internals, node_modules writes, and huge files are blocked. For generated local websites/pages, use open_workspace_file or preview_workspace instead of starting a localhost server inside Docker.`
+            ? `Workspace file tools are available in ${config.commandCwd}: list_files, read_file, search_files, write_file, apply_patch, open_workspace_file, and preview_workspace. apply_patch supports exact single-file replacements plus Codex-style/unified multi-file patches; prefer it for source edits after reading/searching the relevant context. Always use workspace-relative paths such as plot_fx.svg or docs/report.tex, never absolute host paths. Secret paths, .git internals, node_modules writes, and huge files are blocked. For generated local websites/pages, use open_workspace_file or preview_workspace instead of starting a localhost server inside Docker.`
             : "No workspace file tools are available.",
           config.allowWrapperTools
             ? `External coding-agent wrappers are available as advisory tools only. Use the selected wrapper only: ${normalizeWrapperName(config.preferredWrapper)}. Wrapper status: ${wrapperStatusText()}.`
             : "External coding-agent wrappers are disabled.",
+          config.allowAuxiliaryTools
+            ? `Auxiliary skills are available: ${listAuxiliarySkills()
+                .map((skill) => `${skill.id} via ${skill.toolName} (${skill.available ? "key available" : `needs ${skill.keyName}`})`)
+                .join(", ")}. Use generate_image for real raster image/photo/illustration/cover/poster/logo requests when appropriate; if the key is missing, ask the user to run /auxilliary grsai or aginti login grsai.`
+            : "Auxiliary skills are disabled for this run.",
           `Task profile: ${taskProfile.label}. ${taskProfile.prompt}`,
           "A frontend canvas/artifacts tunnel exists. Use send_to_canvas when important markdown, diffs, screenshots, images, or workspace files should be highlighted in the UI. It is optional and ordinary final text can still go directly to finish.",
           "For visual-output requests such as draw, plot, graph, chart, diagram, figure, image, or visualization, proactively publish a canvas artifact even when the user does not mention canvas. If workspace file tools are enabled, prefer creating a small SVG or markdown artifact and call send_to_canvas with selected=true.",
-          "Work like a practical coding agent: inspect when useful, edit with file tools, run safe checks when they add confidence, and keep outputs inside the workspace.",
+          "Work like a practical coding agent: inspect when useful, patch code with apply_patch, run safe checks when they add confidence, iterate on failures, and keep outputs inside the workspace.",
           "For large projects, decompose into useful files and milestones, implement a coherent minimal version first, then iterate with checks rather than only describing what you would do.",
           "For website/app/code/LaTeX/Python/C/shell tasks, create or edit real workspace files, run available build/compile/test commands, and surface artifacts through the canvas when useful.",
           "For research or web-search tasks, use browser tools or safe shell network tools when the current policy allows; cite or save useful sources in workspace notes when the task needs traceability.",
@@ -304,11 +310,16 @@ function createInitialState(config, sessionId) {
               : `Shell working directory: ${config.commandCwd}`
             : "",
           config.allowFileTools
-            ? `Workspace file tools enabled in: ${config.commandCwd}. Use workspace-relative paths. Local preview tools available: open_workspace_file and preview_workspace.`
+            ? `Workspace file tools enabled in: ${config.commandCwd}. Use workspace-relative paths. Use apply_patch for code edits; it accepts exact replacements or Codex-style/unified multi-file patches. Local preview tools available: open_workspace_file and preview_workspace.`
             : "",
           config.allowWrapperTools
             ? `Agent wrappers: selected=${normalizeWrapperName(config.preferredWrapper)}; ${wrapperStatusText()}`
             : "",
+          config.allowAuxiliaryTools
+            ? `Auxiliary skills: ${listAuxiliarySkills()
+                .map((skill) => `${skill.id}:${skill.available ? "available" : "missing-key"}`)
+                .join(" ")}`
+            : "",
           `Task profile: ${taskProfile.label}. ${taskProfile.prompt}`,
           "Canvas/artifacts tunnel: available through send_to_canvas for optional frontend rendering.",
           "Visual-output requests should produce a canvas artifact without requiring the user to ask for canvas explicitly.",
@@ -499,10 +510,20 @@ function sanitizeToolArgs(toolName, args) {
   if (toolName === "apply_patch") {
     return {
       ...safeArgs,
+      patch: typeof args.patch === "string" ? `[${Buffer.byteLength(args.patch, "utf8")} bytes sha256=${hashForLog(args.patch)}]` : safeArgs.patch,
       search: typeof args.search === "string" ? redactSensitiveText(args.search).slice(0, 160) : safeArgs.search,
       replace: typeof args.replace === "string" ? redactSensitiveText(args.replace).slice(0, 160) : safeArgs.replace,
     };
   }
+  if (toolName === "generate_image") {
+    return {
+      ...safeArgs,
+      prompt: typeof args.prompt === "string" ? `[${Buffer.byteLength(args.prompt, "utf8")} bytes sha256=${hashForLog(args.prompt)}]` : safeArgs.prompt,
+      referenceImages: Array.isArray(args.referenceImages)
+        ? args.referenceImages.map((item) => (String(item || "").startsWith("data:") ? `[data-uri ${String(item).length} chars]` : redactSensitiveText(item)))
+        : safeArgs.referenceImages,
+    };
+  }
   return safeArgs;
 }
 
@@ -610,7 +631,7 @@ async function captureSyntheticSnapshot(store, step, config) {
           : `Shell tool available in: ${config.commandCwd}`
         : "Shell tool disabled.",
       config.allowFileTools
-        ? `Workspace file tools available in: ${config.commandCwd}. Use workspace-relative paths.`
+        ? `Workspace file tools available in: ${config.commandCwd}. Use workspace-relative paths. Use apply_patch for code edits; it supports exact single-file replacement and multi-file Codex-style/unified patches.`
         : "Workspace file tools disabled.",
       config.allowWrapperTools
         ? `Agent wrappers available: selected=${normalizeWrapperName(config.preferredWrapper)}; ${wrapperStatusText()}`
@@ -819,9 +840,10 @@ async function executeTool(browserState, toolCall, snapshot, config, store, obse
 
         await store.appendEvent("tool.completed", eventResult);
         observers.event("tool.completed", eventResult);
-        if (result.change) {
+        const changes = Array.isArray(result.changes) && result.changes.length ? result.changes : result.change ? [result.change] : [];
+        for (const item of changes) {
           const change = {
-            ...result.change,
+            ...item,
             toolName: toolCall.function.name,
             commandCwd: config.commandCwd,
           };
@@ -872,6 +894,67 @@ async function executeTool(browserState, toolCall, snapshot, config, store, obse
         observers.event("tool.completed", result);
         return result;
       }
+      case "generate_image": {
+        const imageResult = await generateImage(args, config);
+        const result = {
+          ok: Boolean(imageResult.ok),
+          toolName: "generate_image",
+          args: safeArgs,
+          ...imageResult,
+        };
+        const eventResult = sanitizeToolResult(result);
+        await store.appendEvent("tool.completed", eventResult);
+        observers.event("tool.completed", eventResult);
+
+        if (result.ok) {
+          const generated = {
+            path: result.path,
+            imagePaths: result.imagePaths || [],
+            manifestPath: result.manifestPath || "",
+            promptPath: result.promptPath || "",
+            requestPayloadPath: result.requestPayloadPath || "",
+            commandCwd: config.commandCwd,
+          };
+          await store.appendEvent("image.generated", generated);
+          observers.event("image.generated", generated);
+
+          const selectedPath = result.imagePaths?.[0] || result.manifestPath || "";
+          if (selectedPath) {
+            const normalized = normalizeCanvasPayload(
+              {
+                title: result.imagePaths?.length ? "Generated image" : "Image generation payload",
+                kind: result.imagePaths?.length ? "image" : "json",
+                path: selectedPath,
+                note: result.summary || "Generated image artifact.",
+                selected: Boolean(result.imagePaths?.length),
+              },
+              config
+            );
+            if (normalized.ok) {
+              const canvasItem = {
+                ...normalized.payload,
+                toolName: "generate_image",
+                commandCwd: config.commandCwd,
+              };
+              await store.appendEvent("canvas.item", canvasItem);
+              observers.event("canvas.item", canvasItem);
+              if (canvasItem.selected) {
+                await store.appendEvent("canvas.selected", {
+                  artifactId: canvasItem.artifactId,
+                  title: canvasItem.title,
+                  source: "generate_image",
+                });
+                observers.event("canvas.selected", {
+                  artifactId: canvasItem.artifactId,
+                  title: canvasItem.title,
+                  source: "generate_image",
+                });
+              }
+            }
+          }
+        }
+        return result;
+      }
       case "send_to_canvas": {
         const normalized = normalizeCanvasPayload(args, config);
         if (!normalized.ok) {