@astrofoundry/pi-astro 0.6.0 → 0.6.1

package/extensions/gemini-image/index.test.ts

@@ -40,7 +40,9 @@ function makePi(): { tools: ToolDef[]; registerTool: (t: ToolDef) => void } {
     return { tools, registerTool: (t) => tools.push(t) };
 }
 
-function makeCtx(override: Partial<{ hasUI: boolean; confirm: boolean; inputValue: string | undefined }> = {}): {
+type InputResponse = string | undefined;
+
+function makeCtx(opts: { hasUI?: boolean; cwd?: string; inputs?: InputResponse[] } = {}): {
     cwd: string;
     hasUI: boolean;
     ui: {
@@ -49,25 +51,27 @@ function makeCtx(override: Partial<{ hasUI: boolean; confirm: boolean; inputValu
         input: ReturnType<typeof vi.fn>;
     };
 } {
-    const hasUI = override.hasUI ?? true;
+    const responses = [...(opts.inputs ?? [])];
     return {
-        cwd: "/tmp/cwd",
-        hasUI,
+        cwd: opts.cwd ?? "/tmp/cwd",
+        hasUI: opts.hasUI ?? true,
         ui: {
             notify: vi.fn(),
-            confirm: vi.fn().mockResolvedValue(override.confirm ?? true),
-            input: vi.fn().mockResolvedValue(override.inputValue ?? "abc-key-from-paste"),
+            confirm: vi.fn().mockResolvedValue(true),
+            input: vi.fn().mockImplementation(() => Promise.resolve(responses.shift())),
         },
     };
 }
 
 describe("gemini-image extension", () => {
     let fakeHome: string;
+    let fakeCwd: string;
     const originalHome = process.env.HOME;
     const originalKey = process.env.GEMINI_API_KEY;
 
     beforeEach(() => {
         fakeHome = mkdtempSync(join(tmpdir(), "gem-ext-"));
+        fakeCwd = mkdtempSync(join(tmpdir(), "gem-cwd-"));
         process.env.HOME = fakeHome;
         process.env.GEMINI_API_KEY = "test-key";
         vi.resetModules();
@@ -77,6 +81,7 @@ describe("gemini-image extension", () => {
 
     afterEach(() => {
         rmSync(fakeHome, { recursive: true, force: true });
+        rmSync(fakeCwd, { recursive: true, force: true });
         process.env.HOME = originalHome;
         if (originalKey === undefined) delete process.env.GEMINI_API_KEY;
         else process.env.GEMINI_API_KEY = originalKey;
@@ -89,78 +94,214 @@ describe("gemini-image extension", () => {
         return { tool: pi.tools[0] };
     }
 
-    it("registers a tool named gemini_image", async () => {
-        const { tool } = await load();
-        expect(tool.name).toBe("gemini_image");
-    });
-
-    it("uses default model gemini-2.5-flash-image and calls generateContent", async () => {
+    function pngImageResponse(): void {
         generateContentMock.mockResolvedValue({
             candidates: [
                 { content: { parts: [{ inlineData: { mimeType: "image/png", data: "BASE64DATA" } }] } },
             ],
         });
+    }
+
+    it("registers tool named gemini_image", async () => {
+        const { tool } = await load();
+        expect(tool.name).toBe("gemini_image");
+    });
+
+    it("skip_confirm bypasses review and calls generateContent", async () => {
+        pngImageResponse();
         const { tool } = await load();
-        const ctx = makeCtx();
-        const res = await tool.execute("t", { prompt: "a cat" }, undefined, undefined, ctx);
+        const ctx = makeCtx({ cwd: fakeCwd });
+        const res = await tool.execute("t", { prompt: "a cat", skip_confirm: true }, undefined, undefined, ctx);
         expect(res.details.model).toBe("gemini-2.5-flash-image");
-        expect(res.content[0]).toMatchObject({ type: "image", data: "BASE64DATA" });
+        // ui.input should NOT be called — skip_confirm bypasses the review loop
+        expect(ctx.ui.input).not.toHaveBeenCalled();
+    });
+
+    it("images + text returned in content; image AFTER text", async () => {
+        pngImageResponse();
+        const { tool } = await load();
+        const res = await tool.execute(
+            "t",
+            { prompt: "x", skip_confirm: true },
+            undefined,
+            undefined,
+            makeCtx({ cwd: fakeCwd }),
+        );
+        expect((res.content as Array<{ type: string }>)[0].type).toBe("text");
+        expect((res.content as Array<{ type: string }>)[1].type).toBe("image");
+    });
+
+    it("always saves to <cwd>/.gemini-images by default", async () => {
+        pngImageResponse();
+        const { tool } = await load();
+        const res = await tool.execute(
+            "t",
+            { prompt: "a-thing", skip_confirm: true },
+            undefined,
+            undefined,
+            makeCtx({ cwd: fakeCwd }),
+        );
+        const paths = res.details.savedPaths as string[];
+        expect(paths).toHaveLength(1);
+        expect(paths[0]).toContain(".gemini-images");
+        expect(readdirSync(join(fakeCwd, ".gemini-images"))).toHaveLength(1);
+    });
+
+    it("save_to override writes into that directory (resolved against cwd)", async () => {
+        pngImageResponse();
+        const { tool } = await load();
+        const res = await tool.execute(
+            "t",
+            { prompt: "x", skip_confirm: true, save_to: "out" },
+            undefined,
+            undefined,
+            makeCtx({ cwd: fakeCwd }),
+        );
+        const paths = res.details.savedPaths as string[];
+        expect(paths[0]).toContain(join(fakeCwd, "out"));
+    });
+
+    it("silently saves API key on first paste (no confirm prompt)", async () => {
+        delete process.env.GEMINI_API_KEY;
+        pngImageResponse();
+        const { tool } = await load();
+        const ctx = makeCtx({ cwd: fakeCwd, inputs: ["pasted-key"] });
+        await tool.execute("t", { prompt: "x", skip_confirm: true }, undefined, undefined, ctx);
+        // Only ONE input call (the key paste). confirm never used.
+        expect(ctx.ui.input).toHaveBeenCalledTimes(1);
+        expect(ctx.ui.confirm).not.toHaveBeenCalled();
+        expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringMatching(/saved/i), "info");
     });
 
-    it("calls Imagen for imagen-4.0-generate-001 with numberOfImages", async () => {
+    it("errors when API key missing and no UI available", async () => {
+        delete process.env.GEMINI_API_KEY;
+        const { tool } = await load();
+        const ctx = makeCtx({ hasUI: false, cwd: fakeCwd });
+        await expect(tool.execute("t", { prompt: "x" }, undefined, undefined, ctx)).rejects.toThrow(/no interactive UI/);
+    });
+
+    it("errors when user provides empty key at prompt", async () => {
+        delete process.env.GEMINI_API_KEY;
+        const { tool } = await load();
+        const ctx = makeCtx({ cwd: fakeCwd, inputs: ["   "] });
+        await expect(tool.execute("t", { prompt: "x" }, undefined, undefined, ctx)).rejects.toThrow(/No API key/);
+    });
+
+    it("review loop: empty input confirms and proceeds", async () => {
+        pngImageResponse();
+        const { tool } = await load();
+        const ctx = makeCtx({ cwd: fakeCwd, inputs: [""] });
+        await tool.execute("t", { prompt: "hello" }, undefined, undefined, ctx);
+        expect(ctx.ui.input).toHaveBeenCalledTimes(1);
+    });
+
+    it("review loop: 'cancel' throws cancelled", async () => {
+        const { tool } = await load();
+        const ctx = makeCtx({ cwd: fakeCwd, inputs: ["cancel"] });
+        await expect(tool.execute("t", { prompt: "x" }, undefined, undefined, ctx)).rejects.toThrow(/cancelled/i);
+    });
+
+    it("review loop: undefined input (escape) throws cancelled", async () => {
+        const { tool } = await load();
+        const ctx = makeCtx({ cwd: fakeCwd, inputs: [undefined] });
+        await expect(tool.execute("t", { prompt: "x" }, undefined, undefined, ctx)).rejects.toThrow(/cancelled/i);
+    });
+
+    it("review loop: tweak '2K' updates size then Enter confirms", async () => {
+        pngImageResponse();
+        const { tool } = await load();
+        const ctx = makeCtx({ cwd: fakeCwd, inputs: ["2K", ""] });
+        await tool.execute("t", { prompt: "x" }, undefined, undefined, ctx);
+        // Two input calls: one for 2K tweak, one empty confirm
+        expect(ctx.ui.input).toHaveBeenCalledTimes(2);
+        // The second input's preview message should mention 2K
+        const secondPreview = ctx.ui.input.mock.calls[1][1] as string;
+        expect(secondPreview).toContain("2K");
+    });
+
+    it("review loop: tweak 'use imagen ultra, 16:9, 3 images' + empty confirms and calls Imagen", async () => {
         generateImagesMock.mockResolvedValue({
             generatedImages: [
                 { image: { imageBytes: "IMG1", mimeType: "image/png" } },
                 { image: { imageBytes: "IMG2", mimeType: "image/png" } },
+                { image: { imageBytes: "IMG3", mimeType: "image/png" } },
             ],
         });
         const { tool } = await load();
-        const ctx = makeCtx();
-        const res = await tool.execute(
-            "t",
-            {
-                prompt: "landscape",
-                model: "imagen-4.0-generate-001",
-                number_of_images: 2,
-            },
-            undefined,
-            undefined,
-            ctx,
-        );
-        expect(res.details.images).toBe(2);
-        const args = generateImagesMock.mock.calls[0][0];
-        expect(args.config.numberOfImages).toBe(2);
+        const ctx = makeCtx({ cwd: fakeCwd, inputs: ["use imagen ultra 16:9 3 images", ""] });
+        const res = await tool.execute("t", { prompt: "landscape" }, undefined, undefined, ctx);
+        expect(res.details.model).toBe("imagen-4.0-ultra-generate-001");
+        expect(res.details.images).toBe(3);
+        const cfg = generateImagesMock.mock.calls[0][0].config;
+        expect(cfg.numberOfImages).toBe(3);
+        expect(cfg.aspectRatio).toBe("16:9");
     });
 
-    it("rejects unknown model", async () => {
+    it("review loop: tweak that fails validation is rejected with notify warning, user can re-tweak", async () => {
+        pngImageResponse();
+        generateImagesMock.mockResolvedValue({
+            generatedImages: [{ image: { imageBytes: "IMG", mimeType: "image/png" } }],
+        });
+        const { tool } = await load();
+        // user tries 4K with Imagen → rejected; then switches back and confirms
+        const ctx = makeCtx({ cwd: fakeCwd, inputs: ["imagen fast 4K", "imagen fast 2K", ""] });
+        await tool.execute("t", { prompt: "x" }, undefined, undefined, ctx);
+        expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringMatching(/Change rejected/), "warning");
+    });
+
+    it("review loop: unrecognized token surfaces as warning", async () => {
+        pngImageResponse();
+        const { tool } = await load();
+        const ctx = makeCtx({ cwd: fakeCwd, inputs: ["frobnicate plz", ""] });
+        await tool.execute("t", { prompt: "x" }, undefined, undefined, ctx);
+        expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringMatching(/Didn't understand/), "warning");
+    });
+
+    it("rejects unknown model at call time", async () => {
         const { tool } = await load();
         await expect(
-            tool.execute("t", { prompt: "x", model: "bogus-model" }, undefined, undefined, makeCtx()),
+            tool.execute(
+                "t",
+                { prompt: "x", model: "bogus-model", skip_confirm: true },
+                undefined,
+                undefined,
+                makeCtx({ cwd: fakeCwd }),
+            ),
         ).rejects.toThrow(/Unknown model/);
     });
 
-    it("rejects invalid aspect_ratio for Imagen (e.g. 21:9)", async () => {
+    it("rejects invalid aspect_ratio for Imagen at validate time", async () => {
         const { tool } = await load();
         await expect(
             tool.execute(
                 "t",
-                { prompt: "x", model: "imagen-4.0-generate-001", aspect_ratio: "21:9" },
+                {
+                    prompt: "x",
+                    model: "imagen-4.0-generate-001",
+                    aspect_ratio: "21:9",
+                    skip_confirm: true,
+                },
                 undefined,
                 undefined,
-                makeCtx(),
+                makeCtx({ cwd: fakeCwd }),
             ),
         ).rejects.toThrow(/aspect_ratio .* Imagen/);
     });
 
-    it("rejects 4K image_size for Imagen", async () => {
+    it("rejects 4K for Imagen", async () => {
         const { tool } = await load();
         await expect(
             tool.execute(
                 "t",
-                { prompt: "x", model: "imagen-4.0-generate-001", image_size: "4K" },
+                {
+                    prompt: "x",
+                    model: "imagen-4.0-generate-001",
+                    image_size: "4K",
+                    skip_confirm: true,
+                },
                 undefined,
                 undefined,
-                makeCtx(),
+                makeCtx({ cwd: fakeCwd }),
             ),
         ).rejects.toThrow(/image_size .* Imagen/);
     });
@@ -174,10 +315,11 @@ describe("gemini-image extension", () => {
                     prompt: "x",
                     model: "imagen-4.0-generate-001",
                     input_images: ["/tmp/x.png"],
+                    skip_confirm: true,
                 },
                 undefined,
                 undefined,
-                makeCtx(),
+                makeCtx({ cwd: fakeCwd }),
             ),
         ).rejects.toThrow(/input_images/);
     });
@@ -187,10 +329,10 @@ describe("gemini-image extension", () => {
         await expect(
             tool.execute(
                 "t",
-                { prompt: "x", negative_prompt: "ugly" },
+                { prompt: "x", negative_prompt: "ugly", skip_confirm: true },
                 undefined,
                 undefined,
-                makeCtx(),
+                makeCtx({ cwd: fakeCwd }),
             ),
         ).rejects.toThrow(/negative_prompt/);
     });
@@ -198,135 +340,37 @@ describe("gemini-image extension", () => {
     it("rejects seed on Gemini native", async () => {
         const { tool } = await load();
         await expect(
-            tool.execute("t", { prompt: "x", seed: 42 }, undefined, undefined, makeCtx()),
+            tool.execute("t", { prompt: "x", seed: 42, skip_confirm: true }, undefined, undefined, makeCtx({ cwd: fakeCwd })),
         ).rejects.toThrow(/seed/);
     });
 
-    it("rejects number_of_images > 1 on Gemini native", async () => {
-        const { tool } = await load();
-        await expect(
-            tool.execute("t", { prompt: "x", number_of_images: 3 }, undefined, undefined, makeCtx()),
-        ).rejects.toThrow(/number_of_images/);
-    });
-
-    it("prompts for API key when none configured and saves if confirmed", async () => {
-        delete process.env.GEMINI_API_KEY;
-        generateContentMock.mockResolvedValue({
-            candidates: [{ content: { parts: [{ inlineData: { mimeType: "image/png", data: "X" } }] } }],
-        });
-        const { tool } = await load();
-        const ctx = makeCtx({ inputValue: "pasted-key" });
-        await tool.execute("t", { prompt: "x" }, undefined, undefined, ctx);
-        expect(ctx.ui.input).toHaveBeenCalled();
-        // Confirm was called for both the save prompt and the cost confirmation
-        expect(ctx.ui.confirm.mock.calls.length).toBeGreaterThanOrEqual(1);
-    });
-
-    it("errors when API key missing and no UI available", async () => {
-        delete process.env.GEMINI_API_KEY;
-        const { tool } = await load();
-        const ctx = makeCtx({ hasUI: false });
-        await expect(tool.execute("t", { prompt: "x" }, undefined, undefined, ctx)).rejects.toThrow(/no interactive UI/);
-    });
-
-    it("errors when user provides empty key at prompt", async () => {
-        delete process.env.GEMINI_API_KEY;
-        const { tool } = await load();
-        const ctx = makeCtx({ inputValue: "   " });
-        await expect(tool.execute("t", { prompt: "x" }, undefined, undefined, ctx)).rejects.toThrow(/No API key/);
-    });
-
-    it("cost confirmation: throws when user rejects", async () => {
-        generateContentMock.mockResolvedValue({
-            candidates: [{ content: { parts: [{ inlineData: { mimeType: "image/png", data: "X" } }] } }],
-        });
-        const { tool } = await load();
-        const ctx = makeCtx({ confirm: false });
-        await expect(tool.execute("t", { prompt: "x" }, undefined, undefined, ctx)).rejects.toThrow(/User cancelled/);
-    });
-
-    it("skip_confirm bypasses cost prompt", async () => {
-        generateContentMock.mockResolvedValue({
-            candidates: [{ content: { parts: [{ inlineData: { mimeType: "image/png", data: "X" } }] } }],
-        });
-        const { tool } = await load();
-        const ctx = makeCtx();
-        await tool.execute("t", { prompt: "x", skip_confirm: true }, undefined, undefined, ctx);
-        // confirm should not be called for cost
-        expect(ctx.ui.confirm).not.toHaveBeenCalled();
-    });
-
-    it("save_to writes PNG files and reports paths", async () => {
-        generateImagesMock.mockResolvedValue({
-            generatedImages: [
-                { image: { imageBytes: Buffer.from("fakeimage").toString("base64"), mimeType: "image/png" } },
-            ],
-        });
-        const saveDir = mkdtempSync(join(tmpdir(), "gem-save-"));
-        const { tool } = await load();
-        const ctx = makeCtx();
-        const res = await tool.execute(
-            "t",
-            {
-                prompt: "a-landscape",
-                model: "imagen-4.0-fast-generate-001",
-                save_to: saveDir,
-            },
-            undefined,
-            undefined,
-            ctx,
-        );
-        const paths = res.details.savedPaths as string[];
-        expect(paths).toHaveLength(1);
-        expect(readdirSync(saveDir)).toHaveLength(1);
-        rmSync(saveDir, { recursive: true, force: true });
-    });
-
     it("throws when model returns no images", async () => {
         generateContentMock.mockResolvedValue({ candidates: [] });
         const { tool } = await load();
-        await expect(tool.execute("t", { prompt: "x" }, undefined, undefined, makeCtx())).rejects.toThrow(/no images/);
+        await expect(
+            tool.execute("t", { prompt: "x", skip_confirm: true }, undefined, undefined, makeCtx({ cwd: fakeCwd })),
+        ).rejects.toThrow(/no images/);
     });
 
     it("input_images are read from disk and passed as inlineData", async () => {
         const sourceDir = mkdtempSync(join(tmpdir(), "gem-input-"));
         const imgPath = join(sourceDir, "input.png");
         writeFileSync(imgPath, "binary-image");
-        generateContentMock.mockResolvedValue({
-            candidates: [{ content: { parts: [{ inlineData: { mimeType: "image/png", data: "OUT" } }] } }],
-        });
+        pngImageResponse();
         const { tool } = await load();
-        const ctx = makeCtx();
+        const ctx = makeCtx({ cwd: fakeCwd });
         await tool.execute(
             "t",
-            { prompt: "edit", input_images: [imgPath] },
+            { prompt: "edit", input_images: [imgPath], skip_confirm: true },
             undefined,
             undefined,
             ctx,
         );
         const callArgs = generateContentMock.mock.calls[0][0];
-        // First content is the text, subsequent are inlineData parts
         expect(callArgs.contents.some((c: Record<string, unknown>) => "inlineData" in c)).toBe(true);
         rmSync(sourceDir, { recursive: true, force: true });
     });
 
-    it("passes aspect_ratio + image_size into imageConfig for Gemini native", async () => {
-        generateContentMock.mockResolvedValue({
-            candidates: [{ content: { parts: [{ inlineData: { mimeType: "image/png", data: "X" } }] } }],
-        });
-        const { tool } = await load();
-        await tool.execute(
-            "t",
-            { prompt: "x", aspect_ratio: "16:9", image_size: "2K" },
-            undefined,
-            undefined,
-            makeCtx(),
-        );
-        const cfg = generateContentMock.mock.calls[0][0].config;
-        expect(cfg.imageConfig.aspectRatio).toBe("16:9");
-        expect(cfg.imageConfig.imageSize).toBe("2K");
-    });
-
     it("Imagen config: numberOfImages + negative_prompt + seed + person_generation all pass through", async () => {
         generateImagesMock.mockResolvedValue({
             generatedImages: [{ image: { imageBytes: "X", mimeType: "image/png" } }],
@@ -341,10 +385,11 @@ describe("gemini-image extension", () => {
                 negative_prompt: "blurry",
                 seed: 1337,
                 person_generation: "allow_adult",
+                skip_confirm: true,
             },
             undefined,
             undefined,
-            makeCtx(),
+            makeCtx({ cwd: fakeCwd }),
         );
         const cfg = generateImagesMock.mock.calls[0][0].config;
         expect(cfg.numberOfImages).toBe(2);
@@ -352,18 +397,4 @@ describe("gemini-image extension", () => {
         expect(cfg.seed).toBe(1337);
         expect(cfg.personGeneration).toBe("allow_adult");
     });
-
-    it("rejects invalid Gemini aspect_ratio", async () => {
-        const { tool } = await load();
-        await expect(
-            tool.execute("t", { prompt: "x", aspect_ratio: "17:3" }, undefined, undefined, makeCtx()),
-        ).rejects.toThrow(/aspect_ratio .* Gemini native/);
-    });
-
-    it("rejects invalid Gemini image_size", async () => {
-        const { tool } = await load();
-        await expect(
-            tool.execute("t", { prompt: "x", image_size: "8K" as "4K" }, undefined, undefined, makeCtx()),
-        ).rejects.toThrow(/image_size/);
-    });
 });

package/extensions/gemini-image/index.ts

@@ -1,4 +1,5 @@
-import { readFileSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import type { AgentToolResult } from "@mariozechner/pi-agent-core";
 import { GoogleGenAI } from "@google/genai";
@@ -17,8 +18,11 @@ import {
     isImagen,
     type ImageModel,
 } from "./models.ts";
+import { parseTweaks } from "./parseTweaks.ts";
 import { estimateCost, formatUsd, hasPricing } from "./pricing.ts";
 
+const DEFAULT_SAVE_SUBDIR = ".gemini-images";
+
 const params = Type.Object({
     prompt: Type.String({ description: "Text prompt describing the image to generate." }),
     model: Type.Optional(
@@ -45,8 +49,10 @@ const params = Type.Object({
             description: "Gemini native only. Absolute paths to images for editing.",
         }),
     ),
-    save_to: Type.Optional(Type.String({ description: "Optional directory to write generated PNG(s)." })),
-    skip_confirm: Type.Optional(Type.Boolean({ description: "Skip the cost confirmation prompt." })),
+    save_to: Type.Optional(
+        Type.String({ description: `Directory to save PNG(s). Default: <cwd>/${DEFAULT_SAVE_SUBDIR}/.` }),
+    ),
+    skip_confirm: Type.Optional(Type.Boolean({ description: "Skip the review/confirm prompt and call the API directly." })),
 });
 
 type Params = {
@@ -76,11 +82,8 @@ async function ensureApiKey(ctx: ExtensionContext): Promise<string> {
         throw new Error("No API key provided.");
     }
     const key = pasted.trim();
-
-    const save = await ctx.ui.confirm("Save for future use?", "The key will be kept locally for later calls.");
-    if (save) {
-        persistApiKey(key);
-    }
+    persistApiKey(key);
+    ctx.ui.notify("Gemini API key saved.", "info");
     return key;
 }
 
@@ -123,7 +126,7 @@ function validateForModel(model: ImageModel, p: Params): void {
 }
 
 interface DecodedImage {
-    data: string; // base64
+    data: string;
     mimeType: string;
 }
 
@@ -209,104 +212,163 @@ async function callImagen(
 }
 
 function saveImages(images: DecodedImage[], dir: string, prompt: string): string[] {
-    const slug = prompt
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "")
-        .slice(0, 40) || "image";
+    mkdirSync(dir, { recursive: true });
+    const slug =
+        prompt
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, "-")
+            .replace(/^-+|-+$/g, "")
+            .slice(0, 40) || "image";
     const ts = new Date().toISOString().replace(/[:.]/g, "-");
     const paths: string[] = [];
     for (let i = 0; i < images.length; i++) {
         const ext = images[i].mimeType === "image/jpeg" ? "jpg" : "png";
         const base = images.length > 1 ? `${slug}-${ts}-${i + 1}.${ext}` : `${slug}-${ts}.${ext}`;
-        const full = `${dir.replace(/\/$/, "")}/${base}`;
+        const full = join(dir, base);
         writeFileSync(full, Buffer.from(images[i].data, "base64"));
         paths.push(full);
     }
     return paths;
 }
 
+function renderPreview(model: ImageModel, p: Params, estimate: { estimatedUsd: number; breakdown: string }): string {
+    const nImages = isImagen(model) ? p.number_of_images ?? 1 : 1;
+    const lines: string[] = [];
+    lines.push(`Model: ${model}`);
+    lines.push(`Prompt: "${p.prompt.length > 160 ? `${p.prompt.slice(0, 160)}…` : p.prompt}"`);
+    if (p.image_size) lines.push(`Size: ${p.image_size}`);
+    if (p.aspect_ratio) lines.push(`Aspect ratio: ${p.aspect_ratio}`);
+    lines.push(`Images: ${nImages}`);
+    if (p.negative_prompt) lines.push(`Negative: "${p.negative_prompt.slice(0, 80)}"`);
+    if (p.seed !== undefined) lines.push(`Seed: ${p.seed}`);
+    if (p.person_generation) lines.push(`People: ${p.person_generation}`);
+    lines.push(`Estimated: ~${formatUsd(estimate.estimatedUsd)} (${estimate.breakdown})`);
+    return lines.join(" | ");
+}
+
+async function reviewAndConfirm(
+    ctx: ExtensionContext,
+    p: Params,
+): Promise<Params> {
+    let current = { ...p };
+    while (true) {
+        const model = (current.model as ImageModel | undefined) ?? DEFAULT_MODEL;
+        const est = hasPricing(model)
+            ? estimateCost({
+                  model,
+                  prompt: current.prompt,
+                  numberOfImages: isImagen(model) ? current.number_of_images ?? 1 : 1,
+                  imageSize: current.image_size,
+              })
+            : { estimatedUsd: 0, breakdown: "unknown pricing" };
+
+        const preview = renderPreview(model, current, est);
+        const input = await ctx.ui.input(
+            "Review — Enter to confirm, type changes, or 'cancel'",
+            preview,
+        );
+        if (input === undefined) {
+            throw new Error("User cancelled image generation.");
+        }
+        const parsed = parseTweaks(input);
+        if (parsed.intent === "cancel") {
+            throw new Error("User cancelled image generation.");
+        }
+        if (parsed.intent === "confirm") {
+            return current;
+        }
+
+        // Apply patch. Re-validate before looping.
+        const next: Params = { ...current };
+        if (parsed.patch.prompt !== undefined) next.prompt = parsed.patch.prompt;
+        if (parsed.patch.model !== undefined) next.model = parsed.patch.model;
+        if (parsed.patch.aspect_ratio !== undefined) next.aspect_ratio = parsed.patch.aspect_ratio;
+        if (parsed.patch.image_size !== undefined) next.image_size = parsed.patch.image_size;
+        if (parsed.patch.number_of_images !== undefined) next.number_of_images = parsed.patch.number_of_images;
+        if (parsed.patch.negative_prompt !== undefined) next.negative_prompt = parsed.patch.negative_prompt;
+        if (parsed.patch.seed !== undefined) next.seed = parsed.patch.seed;
+        if (parsed.patch.person_generation !== undefined) next.person_generation = parsed.patch.person_generation;
+        if (parsed.patch.save_to !== undefined) next.save_to = parsed.patch.save_to;
+
+        try {
+            validateForModel((next.model as ImageModel | undefined) ?? DEFAULT_MODEL, next);
+            current = next;
+        } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            ctx.ui.notify(`Change rejected: ${msg}`, "warning");
+        }
+
+        if (parsed.unrecognized.length > 0) {
+            ctx.ui.notify(
+                `Didn't understand: ${parsed.unrecognized.join(" ")}. Try keywords like 2K, 16:9, 'imagen ultra', 'prompt: ...'.`,
+                "warning",
+            );
+        }
+    }
+}
+
 export default function geminiImageExtension(pi: ExtensionAPI): void {
     pi.registerTool({
         name: "gemini_image",
         label: "Gemini Image",
         description:
-            "Generate or edit images via Google's Gemini (native) and Imagen models. Supports aspect ratios, resolutions, image editing, negative prompts, and seeds.",
+            "Generate or edit images via Google Gemini native and Imagen 4 models. Call this tool directly — it runs its own review/tweak/confirm gate before hitting the API, so there is no need to ask the user for a prompt or model in advance.",
         promptGuidelines: [
-            "Use gemini-2.5-flash-image (default) for general-purpose generation.",
-            "Use gemini-3-pro-image-preview for studio-quality 4K, complex layouts, or precise text rendering.",
-            "Use imagen-4.0-*-generate-001 models for batch text-to-image (1-4 per call) or when negative_prompt / seed is needed.",
-            "Image editing (input_images) is only supported by Gemini native models.",
-            "4K output is only supported by Gemini native models.",
+            "When the user asks to generate or edit an image, CALL THIS TOOL IMMEDIATELY. Do not ask them to confirm the prompt or model first — the tool shows a preview (prompt, model, size, estimated cost) and lets the user tweak or confirm inside its own UI.",
+            "By default, enhance the user's casual request into a stronger image-gen prompt (style, lighting, composition, detail qualifiers appropriate to what they asked for). The preview shows the final prompt so the user can catch unwanted enhancements and tweak before confirming.",
+            "If the user signals verbatim intent — wraps the prompt in backticks, or says 'as-is' / 'verbatim' / 'exactly' / 'don't change' / 'use my words' — pass the prompt UNCHANGED.",
+            "NEVER override explicit user parameters. If the user specifies model, resolution, aspect ratio, image count, negative prompt, seed, person-generation policy, or save path, pass those exact values through: 'use pro' → model=gemini-3-pro-image-preview; 'imagen ultra' → imagen-4.0-ultra-generate-001; '4K' → image_size=4K; '16:9' → aspect_ratio=16:9; 'give me 4' → number_of_images=4; 'save to <path>' → save_to=<path>.",
+            "Model selection when the user didn't specify one: gemini-2.5-flash-image for general use (default); gemini-3-pro-image-preview for studio-quality 4K, complex layouts, or precise text; imagen-4.0-*-generate-001 for batch (1-4 images per call), negative_prompt, or seeded reproducibility; image editing (input_images) is only supported by Gemini native models.",
         ],
         parameters: params,
         async execute(_toolCallId, input, signal, _onUpdate, ctx) {
-            const p = input as Params;
-            const model = (p.model as ImageModel | undefined) ?? DEFAULT_MODEL;
+            const requested = input as Params;
+            const model = (requested.model as ImageModel | undefined) ?? DEFAULT_MODEL;
 
             if (!(ALL_MODELS as readonly string[]).includes(model)) {
                 throw new Error(`Unknown model "${model}". Valid: ${ALL_MODELS.join(", ")}.`);
             }
-
-            validateForModel(model, p);
+            validateForModel(model, requested);
 
             const apiKey = await ensureApiKey(ctx);
 
-            const numImages = isImagen(model) ? p.number_of_images ?? 1 : 1;
-
-            if (!p.skip_confirm && hasPricing(model) && ctx.hasUI) {
-                const est = estimateCost({
-                    model,
-                    prompt: p.prompt,
-                    numberOfImages: numImages,
-                    imageSize: p.image_size,
-                });
-                const proceed = await ctx.ui.confirm(
-                    "Confirm image generation",
-                    `Model: ${model}\nImages: ${numImages}${p.image_size ? `\nSize: ${p.image_size}` : ""}\nEstimated: ~${formatUsd(est.estimatedUsd)} (${est.breakdown})`,
-                );
-                if (!proceed) {
-                    throw new Error("User cancelled image generation.");
-                }
-            }
+            const final = requested.skip_confirm || !ctx.hasUI
+                ? requested
+                : await reviewAndConfirm(ctx, requested);
 
-            const ai = new GoogleGenAI({ apiKey });
+            const finalModel = (final.model as ImageModel | undefined) ?? DEFAULT_MODEL;
 
-            const images = isImagen(model)
-                ? await callImagen(ai, model, p, signal)
-                : await callGeminiNative(ai, model, p, signal);
+            const ai = new GoogleGenAI({ apiKey });
+            const images = isImagen(finalModel)
+                ? await callImagen(ai, finalModel, final, signal)
+                : await callGeminiNative(ai, finalModel, final, signal);
 
             if (images.length === 0) {
                 throw new Error("Model returned no images.");
             }
 
-            const savedPaths = p.save_to ? saveImages(images, p.save_to, p.prompt) : [];
+            const saveDir = final.save_to ? resolve(ctx.cwd, final.save_to) : join(ctx.cwd, DEFAULT_SAVE_SUBDIR);
+            const savedPaths = saveImages(images, saveDir, final.prompt);
 
             const summaryLines = [
-                `Generated ${images.length} image${images.length > 1 ? "s" : ""} with ${model}.`,
-                `Prompt: "${p.prompt}"`,
+                `Generated ${images.length} image${images.length > 1 ? "s" : ""} with ${finalModel}.`,
+                `Prompt: "${final.prompt}"`,
+            ];
+            if (final.aspect_ratio) summaryLines.push(`Aspect ratio: ${final.aspect_ratio}`);
+            if (final.image_size) summaryLines.push(`Size: ${final.image_size}`);
+            if (final.negative_prompt) summaryLines.push(`Negative: "${final.negative_prompt}"`);
+            if (final.person_generation) summaryLines.push(`People: ${final.person_generation}`);
+            if (final.seed !== undefined) summaryLines.push(`Seed: ${final.seed}`);
+            summaryLines.push(`Saved to:\n  ${savedPaths.join("\n  ")}`);
+
+            const content: AgentToolResult<unknown>["content"] = [
+                { type: "text", text: summaryLines.join("\n") },
+                ...images.map((img) => ({ type: "image" as const, data: img.data, mimeType: img.mimeType })),
             ];
-            if (p.aspect_ratio) summaryLines.push(`Aspect ratio: ${p.aspect_ratio}`);
-            if (p.image_size) summaryLines.push(`Size: ${p.image_size}`);
-            if (p.negative_prompt) summaryLines.push(`Negative: "${p.negative_prompt}"`);
-            if (p.person_generation) summaryLines.push(`People: ${p.person_generation}`);
-            if (p.seed !== undefined) summaryLines.push(`Seed: ${p.seed}`);
-            if (savedPaths.length > 0) summaryLines.push(`Saved to:\n  ${savedPaths.join("\n  ")}`);
-
-            const content: AgentToolResult<unknown>["content"] = images.map((img) => ({
-                type: "image",
-                data: img.data,
-                mimeType: img.mimeType,
-            }));
-            content.push({ type: "text", text: summaryLines.join("\n") });
 
             return {
                 content,
-                details: {
-                    model,
-                    images: images.length,
-                    savedPaths,
-                },
+                details: { model: finalModel, images: images.length, savedPaths },
             };
         },
     });

package/extensions/gemini-image/parseTweaks.test.ts

@@ -0,0 +1,119 @@
+import { describe, expect, it } from "vitest";
+import { parseTweaks } from "./parseTweaks.ts";
+
+describe("parseTweaks intent", () => {
+    it("empty string = confirm", () => {
+        expect(parseTweaks("").intent).toBe("confirm");
+        expect(parseTweaks("   ").intent).toBe("confirm");
+    });
+
+    it("'yes' / 'y' / 'go' / 'ok' / 'proceed' / 'confirm' = confirm", () => {
+        for (const word of ["yes", "y", "go", "ok", "proceed", "confirm", "YES"]) {
+            expect(parseTweaks(word).intent).toBe("confirm");
+        }
+    });
+
+    it("'cancel' / 'abort' / 'no' / 'n' / 'quit' = cancel", () => {
+        for (const word of ["cancel", "abort", "no", "n", "quit", "CANCEL"]) {
+            expect(parseTweaks(word).intent).toBe("cancel");
+        }
+    });
+});
+
+describe("parseTweaks patches", () => {
+    it("recognizes image sizes 1K / 2K / 4K", () => {
+        expect(parseTweaks("2K").patch.image_size).toBe("2K");
+        expect(parseTweaks("4K").patch.image_size).toBe("4K");
+        expect(parseTweaks("use 1K please").patch.image_size).toBe("1K");
+    });
+
+    it("recognizes aspect ratios", () => {
+        expect(parseTweaks("16:9").patch.aspect_ratio).toBe("16:9");
+        expect(parseTweaks("4:3").patch.aspect_ratio).toBe("4:3");
+    });
+
+    it("recognizes full model ids", () => {
+        expect(parseTweaks("gemini-3-pro-image-preview").patch.model).toBe("gemini-3-pro-image-preview");
+        expect(parseTweaks("imagen-4.0-ultra-generate-001").patch.model).toBe("imagen-4.0-ultra-generate-001");
+    });
+
+    it("recognizes model aliases", () => {
+        expect(parseTweaks("use pro").patch.model).toBe("gemini-3-pro-image-preview");
+        expect(parseTweaks("imagen ultra").patch.model).toBe("imagen-4.0-ultra-generate-001");
+        expect(parseTweaks("flash").patch.model).toBe("gemini-2.5-flash-image");
+        expect(parseTweaks("imagen fast").patch.model).toBe("imagen-4.0-fast-generate-001");
+    });
+
+    it("longer aliases win over shorter (e.g. 'nano banana pro' over 'pro')", () => {
+        expect(parseTweaks("nano banana pro").patch.model).toBe("gemini-3-pro-image-preview");
+    });
+
+    it("recognizes image counts", () => {
+        expect(parseTweaks("3 images").patch.number_of_images).toBe(3);
+        expect(parseTweaks("give me 4").patch.number_of_images).toBe(4);
+        expect(parseTweaks("n=2").patch.number_of_images).toBe(2);
+    });
+
+    it("clamps number_of_images to 1-4", () => {
+        expect(parseTweaks("10 images").patch.number_of_images).toBe(4);
+        expect(parseTweaks("0 images").patch.number_of_images).toBe(1);
+    });
+
+    it("recognizes prompt: form", () => {
+        expect(parseTweaks("prompt: a purple squirrel").patch.prompt).toBe("a purple squirrel");
+    });
+
+    it("recognizes 'use prompt ...' form", () => {
+        expect(parseTweaks("use prompt a purple squirrel").patch.prompt).toBe("a purple squirrel");
+    });
+
+    it("strips quotes around prompt", () => {
+        expect(parseTweaks(`prompt: "a cat"`).patch.prompt).toBe("a cat");
+        expect(parseTweaks(`prompt: 'a cat'`).patch.prompt).toBe("a cat");
+    });
+
+    it("recognizes negative_prompt", () => {
+        expect(parseTweaks("negative: blurry").patch.negative_prompt).toBe("blurry");
+        expect(parseTweaks("negative_prompt: ugly, blurry").patch.negative_prompt).toBe("ugly, blurry");
+    });
+
+    it("recognizes seed", () => {
+        expect(parseTweaks("seed: 42").patch.seed).toBe(42);
+        expect(parseTweaks("seed 1337").patch.seed).toBe(1337);
+    });
+
+    it("recognizes save to <path>", () => {
+        expect(parseTweaks("save to ./out").patch.save_to).toBe("./out");
+    });
+
+    it("recognizes verbatim / as-is / raw", () => {
+        expect(parseTweaks("verbatim").patch.verbatim).toBe(true);
+        expect(parseTweaks("as-is").patch.verbatim).toBe(true);
+        expect(parseTweaks("raw").patch.verbatim).toBe(true);
+    });
+
+    it("recognizes person_generation tokens", () => {
+        expect(parseTweaks("allow_adult").patch.person_generation).toBe("allow_adult");
+        expect(parseTweaks("dont_allow").patch.person_generation).toBe("dont_allow");
+    });
+
+    it("combines multiple changes in one utterance", () => {
+        const p = parseTweaks("use imagen ultra 16:9 3 images");
+        expect(p.patch.model).toBe("imagen-4.0-ultra-generate-001");
+        expect(p.patch.aspect_ratio).toBe("16:9");
+        expect(p.patch.number_of_images).toBe(3);
+    });
+
+    it("unrecognized tokens are returned", () => {
+        const p = parseTweaks("frobnicate plz");
+        expect(p.unrecognized.length).toBeGreaterThan(0);
+    });
+
+    it("filler words 'use', 'and', 'with' don't count as unrecognized", () => {
+        const p = parseTweaks("use 2K and 16:9 with allow_adult");
+        expect(p.unrecognized).toEqual([]);
+        expect(p.patch.image_size).toBe("2K");
+        expect(p.patch.aspect_ratio).toBe("16:9");
+        expect(p.patch.person_generation).toBe("allow_adult");
+    });
+});

package/extensions/gemini-image/parseTweaks.ts

@@ -0,0 +1,191 @@
+/**
+ * Parse a free-text review/tweak utterance into partial parameter updates.
+ *
+ * Intentionally conservative: we recognize a known vocabulary (models,
+ * aspect ratios, sizes, numeric counts, person-gen tokens, and explicit
+ * `prompt:` / `negative:` / `seed:` / `save to <path>` phrases). Unknown
+ * tokens are returned in `unrecognized` so the caller can surface them.
+ */
+
+import {
+    ALL_MODELS,
+    GEMINI_ASPECT_RATIOS,
+    IMAGEN_ASPECT_RATIOS,
+    GEMINI_IMAGE_SIZES,
+    PERSON_GENERATION_VALUES,
+    type ImageModel,
+} from "./models.ts";
+
+export interface TweakPatch {
+    prompt?: string;
+    model?: ImageModel;
+    aspect_ratio?: string;
+    image_size?: "1K" | "2K" | "4K";
+    number_of_images?: number;
+    negative_prompt?: string;
+    person_generation?: (typeof PERSON_GENERATION_VALUES)[number];
+    seed?: number;
+    save_to?: string;
+    verbatim?: boolean;
+}
+
+export interface ParseOutcome {
+    patch: TweakPatch;
+    unrecognized: string[];
+    intent: "confirm" | "cancel" | "tweak";
+}
+
+const MODEL_ALIASES: Record<string, ImageModel> = {
+    flash: "gemini-2.5-flash-image",
+    "flash image": "gemini-2.5-flash-image",
+    "gemini flash": "gemini-2.5-flash-image",
+    "2.5 flash": "gemini-2.5-flash-image",
+    "nano banana 2": "gemini-3.1-flash-image-preview",
+    "nano banana": "gemini-3.1-flash-image-preview",
+    "3.1 flash": "gemini-3.1-flash-image-preview",
+    pro: "gemini-3-pro-image-preview",
+    "pro model": "gemini-3-pro-image-preview",
+    "gemini pro": "gemini-3-pro-image-preview",
+    "3 pro": "gemini-3-pro-image-preview",
+    "nano banana pro": "gemini-3-pro-image-preview",
+    imagen: "imagen-4.0-generate-001",
+    "imagen standard": "imagen-4.0-generate-001",
+    "imagen 4": "imagen-4.0-generate-001",
+    "imagen fast": "imagen-4.0-fast-generate-001",
+    "imagen 4 fast": "imagen-4.0-fast-generate-001",
+    "imagen ultra": "imagen-4.0-ultra-generate-001",
+    "imagen 4 ultra": "imagen-4.0-ultra-generate-001",
+};
+
+const ALL_ASPECT_RATIOS = [
+    ...new Set([...GEMINI_ASPECT_RATIOS, ...IMAGEN_ASPECT_RATIOS]),
+];
+const ALL_SIZES = [...GEMINI_IMAGE_SIZES];
+
+function trimQuotes(s: string): string {
+    return s.replace(/^['"`](.*)['"`]$/s, "$1").trim();
+}
+
+export function parseTweaks(raw: string): ParseOutcome {
+    const patch: TweakPatch = {};
+    const unrecognized: string[] = [];
+    const trimmed = raw.trim();
+
+    if (trimmed === "") {
+        return { patch, unrecognized, intent: "confirm" };
+    }
+    if (/^(y|yes|ok|go|confirm|proceed)$/i.test(trimmed)) {
+        return { patch, unrecognized, intent: "confirm" };
+    }
+    if (/^(n|no|cancel|abort|quit|exit)$/i.test(trimmed)) {
+        return { patch, unrecognized, intent: "cancel" };
+    }
+
+    let rest = trimmed;
+
+    const extract = (pattern: RegExp, onMatch: (m: RegExpExecArray) => void): void => {
+        const match = pattern.exec(rest);
+        if (match) {
+            onMatch(match);
+            rest = (rest.slice(0, match.index) + rest.slice(match.index + match[0].length)).trim();
+        }
+    };
+
+    // prompt: <rest> / use prompt <rest>  (greedy — takes rest of string unless another keyword follows)
+    extract(
+        /(?:^|\s)(?:use\s+prompt\s*[:=]?|prompt\s*[:=])\s*(.+?)(?=(?:\s+(?:model|size|image_size|aspect|ratio|images?|n=|count|negative|seed|save|person|verbatim|raw|as-?is|dont_allow|allow_adult|allow_all)\b)|$)/i,
+        (m) => {
+            patch.prompt = trimQuotes(m[1]);
+        },
+    );
+
+    extract(/(?:^|\s)(?:negative(?:_prompt)?)\s*[:=]\s*(.+?)(?=$|\s+(?:model|size|aspect|ratio|images?|n=|count|seed|save|person|verbatim|raw)\b)/i, (m) => {
+        patch.negative_prompt = trimQuotes(m[1]);
+    });
+
+    extract(/(?:^|\s)seed\s*[:=]?\s*(-?\d+)/i, (m) => {
+        patch.seed = Number(m[1]);
+    });
+
+    extract(/(?:^|\s)save\s+to\s+(\S+)/i, (m) => {
+        patch.save_to = m[1];
+    });
+
+    extract(/(?:^|\s)(verbatim|as-?is|raw)\b/i, () => {
+        patch.verbatim = true;
+    });
+
+    extract(/(?:^|\s)(\d+)\s*(?:images?|imgs?)\b/i, (m) => {
+        patch.number_of_images = Math.max(1, Math.min(4, Number(m[1])));
+    });
+    extract(/(?:^|\s)(?:n|count)\s*[:=]\s*(\d+)/i, (m) => {
+        patch.number_of_images = Math.max(1, Math.min(4, Number(m[1])));
+    });
+    extract(/(?:^|\s)give\s+me\s+(\d+)\b/i, (m) => {
+        patch.number_of_images = Math.max(1, Math.min(4, Number(m[1])));
+    });
+
+    for (const size of ALL_SIZES) {
+        const re = new RegExp(`(?:^|\\s)${size}(?=\\s|$)`, "i");
+        const m = re.exec(rest);
+        if (m) {
+            patch.image_size = size;
+            rest = (rest.slice(0, m.index) + rest.slice(m.index + m[0].length)).trim();
+            break;
+        }
+    }
+
+    for (const ratio of ALL_ASPECT_RATIOS) {
+        const re = new RegExp(`(?:^|\\s)${ratio.replace(":", "\\s*:\\s*")}(?=\\s|$)`);
+        const m = re.exec(rest);
+        if (m) {
+            patch.aspect_ratio = ratio;
+            rest = (rest.slice(0, m.index) + rest.slice(m.index + m[0].length)).trim();
+            break;
+        }
+    }
+
+    for (const pg of PERSON_GENERATION_VALUES) {
+        const re = new RegExp(`(?:^|\\s)${pg}(?=\\s|$)`, "i");
+        const m = re.exec(rest);
+        if (m) {
+            patch.person_generation = pg;
+            rest = (rest.slice(0, m.index) + rest.slice(m.index + m[0].length)).trim();
+            break;
+        }
+    }
+
+    // Full model id exact match
+    for (const model of ALL_MODELS) {
+        const idx = rest.toLowerCase().indexOf(model.toLowerCase());
+        if (idx !== -1) {
+            patch.model = model;
+            rest = (rest.slice(0, idx) + rest.slice(idx + model.length)).trim();
+            break;
+        }
+    }
+
+    // Model aliases (only if model not set yet) — check longest first so "nano banana pro" beats "pro"
+    if (!patch.model) {
+        const aliases = Object.keys(MODEL_ALIASES).sort((a, b) => b.length - a.length);
+        for (const alias of aliases) {
+            const re = new RegExp(`(?:^|\\s)${alias.replace(/\s+/g, "\\s+")}(?=\\s|$|[.,])`, "i");
+            const m = re.exec(rest);
+            if (m) {
+                patch.model = MODEL_ALIASES[alias];
+                rest = (rest.slice(0, m.index) + rest.slice(m.index + m[0].length)).trim();
+                break;
+            }
+        }
+    }
+
+    // Split leftover into whitespace-separated tokens; non-filler ones are "unrecognized".
+    const leftover = rest.split(/\s+/).filter((t) => t.length > 0 && !/^(use|and|with|,)$/i.test(t));
+    if (leftover.length > 0) unrecognized.push(...leftover);
+
+    return {
+        patch,
+        unrecognized,
+        intent: Object.keys(patch).length > 0 ? "tweak" : "tweak",
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrofoundry/pi-astro",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Personal pi customizations (extensions, skills, prompts, themes) for the pi coding agent.",
   "keywords": [
     "pi-package"