@astrofoundry/pi-astro 0.6.5 → 0.6.7

package/README.md

@@ -61,6 +61,8 @@ pi                # launch; confirm [Extensions] lists astro-agents, claude-glob
 - `grimoire` — registers `grimoire` tool
 - `multi-edit` — registers the enhanced `edit` tool
 - `gemini-image` — registers `gemini_image` tool (requires a Gemini API key; prompts and saves on first use)
+- `security-guard` — blocks/prompts destructive bash commands and sensitive file access; configure at `~/.pi/agent/security-guard.json` (example written on first run); `/security-guard status|reload|test`
+- `notify-on-stop` — runs a shell command when the agent finishes a turn (sound, voice, desktop notification). Configure via env `PI_STOP_NOTIFY='afplay /System/Library/Sounds/Glass.aiff && say "Done"'`. Defaults to macOS Glass sound / Linux `notify-send`. Disable with `PI_STOP_NOTIFY_OFF=1`. `/notify status|test|off`.
 - `claude-globals` — auto-injects `~/.claude/CLAUDE.md` into every pi session's system prompt
 
 **Bundled subagents** (callable via `astro_agent`):

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

@@ -371,6 +371,49 @@ describe("gemini-image extension", () => {
         rmSync(sourceDir, { recursive: true, force: true });
     });
 
+    it("summary includes exact cost for Imagen (flat pricing)", async () => {
+        generateImagesMock.mockResolvedValue({
+            generatedImages: [
+                { image: { imageBytes: "A", mimeType: "image/png" } },
+                { image: { imageBytes: "B", mimeType: "image/png" } },
+            ],
+        });
+        const { tool } = await load();
+        const res = await tool.execute(
+            "t",
+            {
+                prompt: "x",
+                model: "imagen-4.0-fast-generate-001",
+                number_of_images: 2,
+                skip_confirm: true,
+            },
+            undefined,
+            undefined,
+            makeCtx({ cwd: fakeCwd }),
+        );
+        const text = (res.content as Array<{ type: string; text?: string }>)[0].text as string;
+        expect(text).toMatch(/Cost:\s+\$0\.0400/); // 2 × 0.02
+        expect(res.details.actualCostUsd).toBeCloseTo(0.04, 4);
+    });
+
+    it("summary includes cost using usageMetadata.promptTokenCount when present", async () => {
+        generateContentMock.mockResolvedValue({
+            candidates: [{ content: { parts: [{ inlineData: { mimeType: "image/png", data: "X" } }] } }],
+            usageMetadata: { promptTokenCount: 1000 },
+        });
+        const { tool } = await load();
+        const res = await tool.execute(
+            "t",
+            { prompt: "x", model: "gemini-3-pro-image-preview", skip_confirm: true },
+            undefined,
+            undefined,
+            makeCtx({ cwd: fakeCwd }),
+        );
+        const text = (res.content as Array<{ type: string; text?: string }>)[0].text as string;
+        expect(text).toMatch(/Cost:/);
+        expect(text).toContain("1000 input tokens");
+    });
+
     it("Imagen config: numberOfImages + negative_prompt + seed + person_generation all pass through", async () => {
         generateImagesMock.mockResolvedValue({
             generatedImages: [{ image: { imageBytes: "X", mimeType: "image/png" } }],

package/extensions/gemini-image/index.ts

@@ -19,7 +19,7 @@ import {
     type ImageModel,
 } from "./models.ts";
 import { parseTweaks } from "./parseTweaks.ts";
-import { estimateCost, formatUsd, hasPricing } from "./pricing.ts";
+import { computeActualCost, estimateCost, formatUsd, hasPricing } from "./pricing.ts";
 import { formatResolution, resolveResolution } from "./resolution.ts";
 
 const DEFAULT_SAVE_SUBDIR = ".gemini-images";
@@ -131,12 +131,17 @@ interface DecodedImage {
     mimeType: string;
 }
 
+interface CallResult {
+    images: DecodedImage[];
+    inputTokens?: number;
+}
+
 async function callGeminiNative(
     ai: GoogleGenAI,
     model: string,
     p: Params,
     signal: AbortSignal | undefined,
-): Promise<DecodedImage[]> {
+): Promise<CallResult> {
     const imageConfig: Record<string, string> = {};
     if (p.aspect_ratio) imageConfig.aspectRatio = p.aspect_ratio;
     if (p.image_size) imageConfig.imageSize = p.image_size;
@@ -176,7 +181,9 @@ async function callGeminiNative(
             }
         }
     }
-    return images;
+    const inputTokens = (response as { usageMetadata?: { promptTokenCount?: number } }).usageMetadata
+        ?.promptTokenCount;
+    return { images, inputTokens };
 }
 
 async function callImagen(
@@ -184,7 +191,7 @@ async function callImagen(
     model: string,
     p: Params,
     signal: AbortSignal | undefined,
-): Promise<DecodedImage[]> {
+): Promise<CallResult> {
     const config: Record<string, unknown> = {};
     if (p.aspect_ratio) config.aspectRatio = p.aspect_ratio;
     if (p.image_size) config.imageSize = p.image_size;
@@ -209,7 +216,7 @@ async function callImagen(
             });
         }
     }
-    return images;
+    return { images };
 }
 
 function saveImages(images: DecodedImage[], dir: string, prompt: string): string[] {
@@ -342,19 +349,27 @@ export default function geminiImageExtension(pi: ExtensionAPI): void {
             const finalModel = (final.model as ImageModel | undefined) ?? DEFAULT_MODEL;
 
             const ai = new GoogleGenAI({ apiKey });
-            const images = isImagen(finalModel)
+            const call = isImagen(finalModel)
                 ? await callImagen(ai, finalModel, final, signal)
                 : await callGeminiNative(ai, finalModel, final, signal);
 
-            if (images.length === 0) {
+            if (call.images.length === 0) {
                 throw new Error("Model returned no images.");
             }
 
             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 savedPaths = saveImages(call.images, saveDir, final.prompt);
+
+            const actual = hasPricing(finalModel)
+                ? computeActualCost(finalModel, {
+                      numberOfImages: call.images.length,
+                      imageSize: final.image_size,
+                      inputTokens: call.inputTokens,
+                  })
+                : undefined;
 
             const summaryLines = [
-                `Generated ${images.length} image${images.length > 1 ? "s" : ""} with ${finalModel}.`,
+                `Generated ${call.images.length} image${call.images.length > 1 ? "s" : ""} with ${finalModel}.`,
                 `Prompt: "${final.prompt}"`,
             ];
             if (final.aspect_ratio) summaryLines.push(`Aspect ratio: ${final.aspect_ratio}`);
@@ -362,16 +377,25 @@ export default function geminiImageExtension(pi: ExtensionAPI): void {
             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}`);
+            if (actual) {
+                const exact = isImagen(finalModel) || call.inputTokens !== undefined;
+                summaryLines.push(`Cost: ${exact ? formatUsd(actual.usd) : `~${formatUsd(actual.usd)}`} (${actual.breakdown})`);
+            }
             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 })),
+                ...call.images.map((img) => ({ type: "image" as const, data: img.data, mimeType: img.mimeType })),
             ];
 
             return {
                 content,
-                details: { model: finalModel, images: images.length, savedPaths },
+                details: {
+                    model: finalModel,
+                    images: call.images.length,
+                    savedPaths,
+                    actualCostUsd: actual?.usd,
+                },
             };
         },
     });

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

@@ -93,3 +93,46 @@ describe("hasPricing", () => {
         expect(hasPricing("imagen-4.0-fast-generate-001")).toBe(true);
     });
 });
+
+describe("computeActualCost", () => {
+    it("Imagen: flat × count, exact", async () => {
+        const { computeActualCost } = await import("./pricing.ts");
+        const r = computeActualCost("imagen-4.0-fast-generate-001", { numberOfImages: 3 });
+        expect(r.usd).toBeCloseTo(0.06, 5);
+        expect(r.breakdown).toContain("0.02");
+    });
+
+    it("Gemini native with real input tokens: exact formula", async () => {
+        const { computeActualCost } = await import("./pricing.ts");
+        const r = computeActualCost("gemini-3-pro-image-preview", {
+            numberOfImages: 2,
+            imageSize: "2K",
+            inputTokens: 500,
+        });
+        // output: 2 × 0.134 = 0.268; input: 500 / 1M × 2.00 = 0.001; total ~0.269
+        expect(r.usd).toBeCloseTo(0.269, 3);
+        expect(r.breakdown).toContain("500 input tokens");
+    });
+
+    it("Gemini native with missing input tokens: falls back to 0", async () => {
+        const { computeActualCost } = await import("./pricing.ts");
+        const r = computeActualCost("gemini-2.5-flash-image", { numberOfImages: 1 });
+        expect(r.usd).toBeGreaterThanOrEqual(0);
+        expect(r.breakdown).toContain("0 input tokens");
+    });
+
+    it("4K output uses higher rate", async () => {
+        const { computeActualCost } = await import("./pricing.ts");
+        const at2k = computeActualCost("gemini-3-pro-image-preview", {
+            numberOfImages: 1,
+            imageSize: "2K",
+            inputTokens: 0,
+        });
+        const at4k = computeActualCost("gemini-3-pro-image-preview", {
+            numberOfImages: 1,
+            imageSize: "4K",
+            inputTokens: 0,
+        });
+        expect(at4k.usd).toBeGreaterThan(at2k.usd);
+    });
+});

package/extensions/gemini-image/pricing.ts

@@ -97,6 +97,38 @@ export function formatUsd(usd: number): string {
     return `$${usd.toFixed(4)}`;
 }
 
+export interface ActualUsage {
+    inputTokens?: number;
+    numberOfImages: number;
+    imageSize?: "1K" | "2K" | "4K";
+}
+
+export interface ActualCostResult {
+    usd: number;
+    breakdown: string;
+}
+
+export function computeActualCost(model: ImageModel, usage: ActualUsage): ActualCostResult {
+    const price = PRICES[model];
+    if (price.kind === "flat") {
+        return {
+            usd: price.perImage * usage.numberOfImages,
+            breakdown: `${usage.numberOfImages} × $${price.perImage.toFixed(2)}/image`,
+        };
+    }
+    const perImage =
+        usage.imageSize === "4K" ? price.outputPerImage4K : price.outputPerImage1Kor2K;
+    const outputCost = perImage * usage.numberOfImages;
+    const inputTokens = usage.inputTokens ?? 0;
+    const inputCost = (inputTokens / 1_000_000) * price.inputPer1M;
+    return {
+        usd: inputCost + outputCost,
+        breakdown:
+            `${usage.numberOfImages} × $${perImage.toFixed(3)} (${usage.imageSize ?? "1K/2K"}) + ` +
+            `${inputTokens} input tokens`,
+    };
+}
+
 export function hasPricing(model: ImageModel): boolean {
     return model in PRICES;
 }

package/extensions/notify-on-stop/index.test.ts

@@ -0,0 +1,179 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const execMock = vi.fn();
+
+vi.mock("node:child_process", () => ({
+    exec: (cmd: string, opts: unknown, cb?: unknown) => {
+        execMock(cmd, opts, cb);
+        // Return a chainable fake child with on/stdout/stderr
+        const fake = {
+            on: vi.fn(),
+            stdout: { on: vi.fn() },
+            stderr: { on: vi.fn() },
+        };
+        return fake;
+    },
+}));
+
+type Handler = (event: unknown, ctx: unknown) => void | Promise<void>;
+type CommandHandler = (args: string, ctx: unknown) => Promise<void> | void;
+
+function makePi(): {
+    handlers: Record<string, Handler>;
+    commands: Map<string, { handler: CommandHandler }>;
+    on: (event: string, h: Handler) => void;
+    registerCommand: (name: string, opts: { description?: string; handler: CommandHandler }) => void;
+} {
+    const handlers: Record<string, Handler> = {};
+    const commands = new Map();
+    return {
+        handlers,
+        commands,
+        on: (event, h) => {
+            handlers[event] = h;
+        },
+        registerCommand: (name, opts) => {
+            commands.set(name, { handler: opts.handler });
+        },
+    };
+}
+
+function makeCtx(): { ui: { notify: ReturnType<typeof vi.fn> } } {
+    return { ui: { notify: vi.fn() } };
+}
+
+const origPlatform = Object.getOwnPropertyDescriptor(process, "platform")!;
+
+function setPlatform(p: NodeJS.Platform): void {
+    Object.defineProperty(process, "platform", { value: p, configurable: true });
+}
+
+describe("notify-on-stop", () => {
+    const origCmd = process.env.PI_STOP_NOTIFY;
+    const origOff = process.env.PI_STOP_NOTIFY_OFF;
+
+    beforeEach(() => {
+        vi.resetModules();
+        execMock.mockReset();
+        delete process.env.PI_STOP_NOTIFY;
+        delete process.env.PI_STOP_NOTIFY_OFF;
+    });
+
+    afterEach(() => {
+        Object.defineProperty(process, "platform", origPlatform);
+        if (origCmd === undefined) delete process.env.PI_STOP_NOTIFY;
+        else process.env.PI_STOP_NOTIFY = origCmd;
+        if (origOff === undefined) delete process.env.PI_STOP_NOTIFY_OFF;
+        else process.env.PI_STOP_NOTIFY_OFF = origOff;
+    });
+
+    it("runs default command on agent_end (macOS)", async () => {
+        setPlatform("darwin");
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        pi.handlers.agent_end({}, makeCtx());
+        expect(execMock).toHaveBeenCalled();
+        expect(execMock.mock.calls[0][0]).toMatch(/afplay/);
+    });
+
+    it("runs custom PI_STOP_NOTIFY over default", async () => {
+        setPlatform("darwin");
+        process.env.PI_STOP_NOTIFY = "my custom --cmd";
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        pi.handlers.agent_end({}, makeCtx());
+        expect(execMock.mock.calls[0][0]).toBe("my custom --cmd");
+    });
+
+    it("does NOT run anything when PI_STOP_NOTIFY_OFF=1", async () => {
+        setPlatform("darwin");
+        process.env.PI_STOP_NOTIFY_OFF = "1";
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        pi.handlers.agent_end({}, makeCtx());
+        expect(execMock).not.toHaveBeenCalled();
+    });
+
+    it("does nothing on an unsupported platform with no env", async () => {
+        setPlatform("win32");
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        pi.handlers.agent_end({}, makeCtx());
+        expect(execMock).not.toHaveBeenCalled();
+    });
+
+    it("Linux default uses notify-send", async () => {
+        setPlatform("linux");
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        pi.handlers.agent_end({}, makeCtx());
+        expect(execMock.mock.calls[0][0]).toMatch(/notify-send/);
+    });
+
+    it("trims whitespace on PI_STOP_NOTIFY and ignores empty strings", async () => {
+        setPlatform("darwin");
+        process.env.PI_STOP_NOTIFY = "   ";
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        pi.handlers.agent_end({}, makeCtx());
+        expect(execMock.mock.calls[0][0]).toMatch(/afplay/);
+    });
+
+    it("/notify status reports current command", async () => {
+        setPlatform("darwin");
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        const ctx = makeCtx();
+        await pi.commands.get("notify")!.handler("status", ctx);
+        expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringMatching(/afplay/), "info");
+    });
+
+    it("/notify status reports disabled when PI_STOP_NOTIFY_OFF", async () => {
+        setPlatform("darwin");
+        process.env.PI_STOP_NOTIFY_OFF = "1";
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        const ctx = makeCtx();
+        await pi.commands.get("notify")!.handler("", ctx);
+        expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringMatching(/disabled/), "info");
+    });
+
+    it("/notify test runs the command immediately", async () => {
+        setPlatform("darwin");
+        process.env.PI_STOP_NOTIFY = "test-cmd";
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        const ctx = makeCtx();
+        await pi.commands.get("notify")!.handler("test", ctx);
+        expect(execMock.mock.calls[0][0]).toBe("test-cmd");
+    });
+
+    it("/notify test warns when nothing configured", async () => {
+        setPlatform("win32");
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        const ctx = makeCtx();
+        await pi.commands.get("notify")!.handler("test", ctx);
+        expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringMatching(/nothing configured/), "warning");
+    });
+
+    it("/notify off gives persistence guidance", async () => {
+        setPlatform("darwin");
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        const ctx = makeCtx();
+        await pi.commands.get("notify")!.handler("off", ctx);
+        expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringMatching(/PI_STOP_NOTIFY_OFF/), "info");
+    });
+});

package/extensions/notify-on-stop/index.ts

@@ -0,0 +1,71 @@
+import { exec } from "node:child_process";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+const ENV_CMD = "PI_STOP_NOTIFY";
+const ENV_OFF = "PI_STOP_NOTIFY_OFF";
+const TIMEOUT_MS = 10_000;
+
+function defaultCommand(): string | undefined {
+    if (process.platform === "darwin") {
+        return "afplay /System/Library/Sounds/Glass.aiff";
+    }
+    if (process.platform === "linux") {
+        return 'command -v notify-send >/dev/null 2>&1 && notify-send "pi" "Agent done"';
+    }
+    return undefined;
+}
+
+function resolveCommand(): string | undefined {
+    if (process.env[ENV_OFF] === "1") return undefined;
+    const custom = process.env[ENV_CMD]?.trim();
+    if (custom) return custom;
+    return defaultCommand();
+}
+
+function runNotify(cmd: string): void {
+    const child = exec(cmd, { shell: "/bin/sh", timeout: TIMEOUT_MS });
+    // Swallow errors so a broken notify command never surfaces into pi output.
+    child.on("error", () => {});
+    child.stderr?.on("data", () => {});
+    child.stdout?.on("data", () => {});
+}
+
+export default function notifyOnStopExtension(pi: ExtensionAPI): void {
+    pi.on("agent_end", () => {
+        const cmd = resolveCommand();
+        if (!cmd) return;
+        runNotify(cmd);
+    });
+
+    pi.registerCommand("notify", {
+        description:
+            "Stop-notify status/test. Usage: /notify [status|test|off]. Configure via env PI_STOP_NOTIFY, disable with PI_STOP_NOTIFY_OFF=1.",
+        handler: async (args, ctx) => {
+            const sub = args.trim().toLowerCase() || "status";
+            if (sub === "test") {
+                const cmd = resolveCommand();
+                if (!cmd) {
+                    ctx.ui.notify("notify: nothing configured / disabled", "warning");
+                    return;
+                }
+                runNotify(cmd);
+                ctx.ui.notify(`notify: ran "${cmd}"`, "info");
+                return;
+            }
+            if (sub === "off") {
+                ctx.ui.notify(
+                    `notify: to disable persistently, set ${ENV_OFF}=1 in your shell rc; this session's behavior is driven by env at startup.`,
+                    "info",
+                );
+                return;
+            }
+            const cmd = resolveCommand();
+            ctx.ui.notify(
+                cmd
+                    ? `notify: will run "${cmd}" on agent_end`
+                    : `notify: disabled (no default for this platform or ${ENV_OFF}=1)`,
+                "info",
+            );
+        },
+    });
+}

package/extensions/security-guard/config.test.ts

@@ -0,0 +1,107 @@
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+describe("config", () => {
+    let root: string;
+    const originalDir = process.env.PI_CODING_AGENT_DIR;
+    const originalDryRun = process.env.PI_SECURITY_GUARD_DRY_RUN;
+
+    beforeEach(() => {
+        root = mkdtempSync(join(tmpdir(), "sg-cfg-"));
+        process.env.PI_CODING_AGENT_DIR = root;
+        delete process.env.PI_SECURITY_GUARD_DRY_RUN;
+        vi.resetModules();
+    });
+
+    afterEach(() => {
+        rmSync(root, { recursive: true, force: true });
+        process.env.PI_CODING_AGENT_DIR = originalDir;
+        if (originalDryRun === undefined) delete process.env.PI_SECURITY_GUARD_DRY_RUN;
+        else process.env.PI_SECURITY_GUARD_DRY_RUN = originalDryRun;
+    });
+
+    it("uses defaults when config file missing", async () => {
+        const { loadConfig } = await import("./config.ts");
+        const r = loadConfig();
+        expect(r.configExists).toBe(false);
+        expect(r.rules.operations.length).toBeGreaterThan(0);
+        expect(r.errors).toEqual([]);
+    });
+
+    it("loads user JSON rules overriding defaults when non-empty", async () => {
+        writeFileSync(
+            join(root, "security-guard.json"),
+            JSON.stringify({
+                operations: [{ pattern: "myop", action: "block" }],
+                writes: [{ pattern: "*.secret", action: "prompt" }],
+            }),
+            "utf-8",
+        );
+        const { loadConfig } = await import("./config.ts");
+        const r = loadConfig();
+        expect(r.configExists).toBe(true);
+        expect(r.rules.operations).toEqual([{ pattern: "myop", action: "block" }]);
+        expect(r.rules.writes).toEqual([{ pattern: "*.secret", action: "prompt" }]);
+        // reads missing → defaults used
+        expect(r.rules.reads.length).toBeGreaterThan(0);
+    });
+
+    it("invalid JSON falls back to defaults and records error", async () => {
+        writeFileSync(join(root, "security-guard.json"), "{not json", "utf-8");
+        const { loadConfig } = await import("./config.ts");
+        const r = loadConfig();
+        expect(r.errors.length).toBeGreaterThan(0);
+        expect(r.rules.operations.length).toBeGreaterThan(0);
+    });
+
+    it("malformed rule (bad action) is skipped with error", async () => {
+        writeFileSync(
+            join(root, "security-guard.json"),
+            JSON.stringify({
+                operations: [
+                    { pattern: "ok", action: "block" },
+                    { pattern: "bad", action: "nuke-from-orbit" },
+                    { pattern: "", action: "prompt" }, // empty pattern
+                    "not-an-object",
+                ],
+            }),
+            "utf-8",
+        );
+        const { loadConfig } = await import("./config.ts");
+        const r = loadConfig();
+        expect(r.rules.operations).toEqual([{ pattern: "ok", action: "block" }]);
+        expect(r.errors.length).toBeGreaterThanOrEqual(3);
+    });
+
+    it("non-array section logs error and falls back to default for that section", async () => {
+        writeFileSync(
+            join(root, "security-guard.json"),
+            JSON.stringify({ operations: "not an array" }),
+            "utf-8",
+        );
+        const { loadConfig } = await import("./config.ts");
+        const r = loadConfig();
+        expect(r.errors.some((e) => e.includes("operations"))).toBe(true);
+    });
+
+    it("ensureExampleConfig creates .example file once", async () => {
+        const { ensureExampleConfig } = await import("./config.ts");
+        mkdirSync(root, { recursive: true });
+        ensureExampleConfig();
+        const p = join(root, "security-guard.json.example");
+        expect(existsSync(p)).toBe(true);
+        const first = readFileSync(p, "utf-8");
+        // Running again doesn't overwrite / doesn't throw
+        ensureExampleConfig();
+        expect(readFileSync(p, "utf-8")).toBe(first);
+    });
+
+    it("isDryRun flips with env var", async () => {
+        const { isDryRun } = await import("./config.ts");
+        expect(isDryRun()).toBe(false);
+        process.env.PI_SECURITY_GUARD_DRY_RUN = "1";
+        expect(isDryRun()).toBe(true);
+    });
+});