qlogicagent 2.13.3 → 2.13.5

package/dist/runtime/infra/checkpoint-backend.js

@@ -0,0 +1,110 @@
+/**
+ * Local Checkpoint Backend — git-based shadow repo implementation.
+ *
+ * Creates and manages checkpoint snapshots in `<project>/.qlogicagent/checkpoints/<sessionId>/`
+ * using a shadow git repository independent of the user's project .git.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getProjectCheckpointsDir } from "./agent-paths.js";
+export function createLocalCheckpointBackend(projectRoot, sessionId) {
+    const shadowDir = getProjectCheckpointsDir(projectRoot, sessionId);
+    return {
+        createCheckpoint: async (message) => {
+            try {
+                fs.mkdirSync(shadowDir, { recursive: true });
+                const { execSync } = await import("node:child_process");
+                const gitDir = path.join(shadowDir, ".git");
+                if (!fs.existsSync(gitDir)) {
+                    execSync("git init", { cwd: shadowDir, stdio: "pipe", timeout: 30_000 });
+                    execSync('git config user.email "checkpoint@agent"', { cwd: shadowDir, stdio: "pipe", timeout: 30_000 });
+                    execSync('git config user.name "Checkpoint"', { cwd: shadowDir, stdio: "pipe", timeout: 30_000 });
+                }
+                // Exclude .git/node_modules (any depth) AND — critically — the projectRoot's own
+                // .worktrees (Solo/Product worktrees: each a full checkout) and .qlogicagent (this
+                // checkpoint shadow itself → self-recursive copy). Without these, a checkpoint taken
+                // after a Solo run copies every worktree + the growing checkpoint history, ballooning
+                // the synchronous cpSync until it blocks the ACP event loop (agent appears hung).
+                // Top-level match via path.relative so a projectRoot located under .qlogicagent/workspaces
+                // is not wholly excluded by a naive substring test.
+                fs.cpSync(projectRoot, shadowDir, {
+                    recursive: true,
+                    filter: (src) => {
+                        if (src.includes(".git") || src.includes("node_modules"))
+                            return false;
+                        const top = path.relative(projectRoot, src).split(path.sep)[0];
+                        return top !== ".worktrees" && top !== ".qlogicagent";
+                    },
+                });
+                execSync("git add -A", { cwd: shadowDir, stdio: "pipe", timeout: 30_000 });
+                const msg = message || `checkpoint ${new Date().toISOString()}`;
+                execSync(`git commitallow-empty -m "${msg.replace(/"/g, '\\"')}"`, { cwd: shadowDir, stdio: "pipe", timeout: 30_000 });
+                const id = execSync("git rev-parse HEAD", { cwd: shadowDir, stdio: "pipe", timeout: 30_000 }).toString().trim();
+                const fileCount = parseInt(execSync("git ls-files | wc -l", { cwd: shadowDir, stdio: "pipe", timeout: 30_000 }).toString().trim(), 10) || 0;
+                return { success: true, checkpoint: { id, message: msg, timestamp: new Date().toISOString(), fileCount } };
+            }
+            catch (err) {
+                return { success: false, error: err.message };
+            }
+        },
+        listCheckpoints: async () => {
+            try {
+                const { execSync } = await import("node:child_process");
+                const gitDir = path.join(shadowDir, ".git");
+                if (!fs.existsSync(gitDir))
+                    return { success: true, checkpoints: [] };
+                const raw = execSync('git logformat="%H|%aI|%s"max-count=20', { cwd: shadowDir, stdio: "pipe", timeout: 30_000 }).toString().trim();
+                if (!raw)
+                    return { success: true, checkpoints: [] };
+                const checkpoints = raw.split("\n").map((line) => {
+                    const [id = "", timestamp = "", ...rest] = line.split("|");
+                    return { id, timestamp, message: rest.join("|"), fileCount: 0 };
+                });
+                return { success: true, checkpoints };
+            }
+            catch (err) {
+                return { success: false, error: err.message };
+            }
+        },
+        restoreCheckpoint: async (checkpointId, paths) => {
+            try {
+                const { execSync } = await import("node:child_process");
+                if (paths && paths.length > 0) {
+                    execSync(`git checkout ${checkpointId} ${paths.map(p => `"${p.replace(/"/g, '\\"')}"`).join(" ")}`, { cwd: shadowDir, stdio: "pipe", timeout: 30_000 });
+                    for (const p of paths) {
+                        const src = path.join(shadowDir, p);
+                        const dst = path.join(projectRoot, p);
+                        if (fs.existsSync(src))
+                            fs.cpSync(src, dst, { recursive: true });
+                    }
+                }
+                else {
+                    execSync(`git checkout ${checkpointId} .`, { cwd: shadowDir, stdio: "pipe", timeout: 30_000 });
+                    // Clear projectRoot before copying to ensure deleted files are removed
+                    const entries = fs.readdirSync(projectRoot);
+                    for (const entry of entries) {
+                        if (entry === ".git" || entry === "node_modules")
+                            continue;
+                        const fullPath = path.join(projectRoot, entry);
+                        fs.rmSync(fullPath, { recursive: true, force: true });
+                    }
+                    fs.cpSync(shadowDir, projectRoot, { recursive: true, filter: (s) => !s.includes(".git") });
+                }
+                return { success: true };
+            }
+            catch (err) {
+                return { success: false, error: err.message };
+            }
+        },
+        diffCheckpoint: async (checkpointId) => {
+            try {
+                const { execSync } = await import("node:child_process");
+                const diff = execSync(`git diff ${checkpointId} HEAD`, { cwd: shadowDir, stdio: "pipe", timeout: 30_000 }).toString();
+                return { success: true, diff };
+            }
+            catch (err) {
+                return { success: false, error: err.message };
+            }
+        },
+    };
+}

package/dist/runtime/infra/cleanup-registry.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Cleanup Registry — CC cleanupRegistry.ts parity.
+ *
+ * Global registry for cleanup functions that should run during graceful shutdown.
+ * Separate from stop handling to avoid circular dependencies.
+ *
+ * Reference: claude-code src/utils/cleanupRegistry.ts
+ */
+/**
+ * Register a cleanup function to run during graceful shutdown.
+ * @param cleanupFn - Function to run during cleanup (can be sync or async)
+ * @returns Unregister function that removes the cleanup handler
+ */
+export declare function registerCleanup(cleanupFn: () => Promise<void>): () => void;
+/**
+ * Run all registered cleanup functions.
+ * Used internally by graceful shutdown path.
+ */
+export declare function runCleanupFunctions(): Promise<void>;
+/**
+ * Get count of registered cleanup handlers (for diagnostics).
+ */
+export declare function getCleanupCount(): number;

package/dist/runtime/infra/cleanup-registry.js

@@ -0,0 +1,34 @@
+/**
+ * Cleanup Registry — CC cleanupRegistry.ts parity.
+ *
+ * Global registry for cleanup functions that should run during graceful shutdown.
+ * Separate from stop handling to avoid circular dependencies.
+ *
+ * Reference: claude-code src/utils/cleanupRegistry.ts
+ */
+// Global registry for cleanup functions
+const cleanupFunctions = new Set();
+/**
+ * Register a cleanup function to run during graceful shutdown.
+ * @param cleanupFn - Function to run during cleanup (can be sync or async)
+ * @returns Unregister function that removes the cleanup handler
+ */
+export function registerCleanup(cleanupFn) {
+    cleanupFunctions.add(cleanupFn);
+    return () => {
+        cleanupFunctions.delete(cleanupFn);
+    };
+}
+/**
+ * Run all registered cleanup functions.
+ * Used internally by graceful shutdown path.
+ */
+export async function runCleanupFunctions() {
+    await Promise.all(Array.from(cleanupFunctions).map(fn => fn()));
+}
+/**
+ * Get count of registered cleanup handlers (for diagnostics).
+ */
+export function getCleanupCount() {
+    return cleanupFunctions.size;
+}

package/dist/runtime/infra/default-path-service.d.ts

@@ -0,0 +1,33 @@
+import type { PathService } from "../ports/index.js";
+export interface DefaultPathServiceOptions {
+    getActiveProjectRoot?: () => string;
+    setActiveWorkdir?: (dir: string) => void;
+    resolveProjectDir?: (projectId?: string) => string | undefined;
+}
+export declare class DefaultPathService implements PathService {
+    private readonly options;
+    /** Last directory set via setActiveWorkdir — the dir tool paths resolve against. */
+    private lastActiveWorkdir;
+    constructor(options?: DefaultPathServiceOptions);
+    getActiveProjectRoot(): string;
+    setActiveWorkdir(dir: string): void;
+    getActiveWorkdir(): string;
+    resolveProjectDir(projectId?: string): string | undefined;
+    resolveActiveOwnerUserId(): string;
+    getUserAgentHome(): string;
+    getOwnerProfileDir(ownerUserId?: string): string;
+    getProfileMemoryDir(ownerUserId?: string): string;
+    getUserSettingsPath(): string;
+    getUserSkillsDir(): string;
+    getUserPluginsDir(): string;
+    getUserMcpConfigPath(): string;
+    getUserPluginCacheDir(): string;
+    getUserMarketplaceConfigPath(): string;
+    getProjectAgentDir(projectRoot?: string): string;
+    getProjectSettingsPath(projectRoot?: string): string;
+    getProjectInstructionsPath(projectRoot?: string): string;
+    getProjectPluginsDir(projectRoot?: string): string;
+    getProjectRulesDir(projectRoot?: string): string;
+    getProjectSessionsRoot(projectRoot?: string): string;
+}
+export declare function getDefaultPathService(): PathService;

package/dist/runtime/infra/default-path-service.js

@@ -0,0 +1,76 @@
+import { resolve } from "node:path";
+import { getOwnerProfileDir, getProfileMemoryDir, getProjectAgentDir, getProjectInstructionsPath, getProjectPluginsDir, getProjectRulesDir, getProjectSessionsRoot, getProjectSettingsPath, getUserAgentHome, getUserMarketplaceConfigPath, getUserMcpConfigPath, getUserPluginCacheDir, getUserPluginsDir, getUserSettingsPath, getUserSkillsDir, resolveActiveOwnerUserId, } from "./agent-paths.js";
+export class DefaultPathService {
+    options;
+    /** Last directory set via setActiveWorkdir — the dir tool paths resolve against. */
+    lastActiveWorkdir = null;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    getActiveProjectRoot() {
+        return this.options.getActiveProjectRoot?.() ?? process.cwd();
+    }
+    setActiveWorkdir(dir) {
+        const resolved = resolve(dir);
+        this.lastActiveWorkdir = resolved;
+        this.options.setActiveWorkdir?.(resolved);
+    }
+    getActiveWorkdir() {
+        return this.lastActiveWorkdir ?? this.getActiveProjectRoot();
+    }
+    resolveProjectDir(projectId) {
+        return this.options.resolveProjectDir?.(projectId);
+    }
+    resolveActiveOwnerUserId() {
+        return resolveActiveOwnerUserId();
+    }
+    getUserAgentHome() {
+        return getUserAgentHome();
+    }
+    getOwnerProfileDir(ownerUserId) {
+        return getOwnerProfileDir(ownerUserId);
+    }
+    getProfileMemoryDir(ownerUserId) {
+        return getProfileMemoryDir(ownerUserId);
+    }
+    getUserSettingsPath() {
+        return getUserSettingsPath();
+    }
+    getUserSkillsDir() {
+        return getUserSkillsDir();
+    }
+    getUserPluginsDir() {
+        return getUserPluginsDir();
+    }
+    getUserMcpConfigPath() {
+        return getUserMcpConfigPath();
+    }
+    getUserPluginCacheDir() {
+        return getUserPluginCacheDir();
+    }
+    getUserMarketplaceConfigPath() {
+        return getUserMarketplaceConfigPath();
+    }
+    getProjectAgentDir(projectRoot = this.getActiveProjectRoot()) {
+        return getProjectAgentDir(projectRoot);
+    }
+    getProjectSettingsPath(projectRoot = this.getActiveProjectRoot()) {
+        return getProjectSettingsPath(projectRoot);
+    }
+    getProjectInstructionsPath(projectRoot = this.getActiveProjectRoot()) {
+        return getProjectInstructionsPath(projectRoot);
+    }
+    getProjectPluginsDir(projectRoot = this.getActiveProjectRoot()) {
+        return getProjectPluginsDir(projectRoot);
+    }
+    getProjectRulesDir(projectRoot = this.getActiveProjectRoot()) {
+        return getProjectRulesDir(projectRoot);
+    }
+    getProjectSessionsRoot(projectRoot = this.getActiveProjectRoot()) {
+        return getProjectSessionsRoot(projectRoot);
+    }
+}
+const defaultPathService = new DefaultPathService();
+export function getDefaultPathService() {
+    return defaultPathService;
+}

package/dist/runtime/infra/default-path-service.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/infra/default-path-service.test.js

@@ -0,0 +1,31 @@
+import { resolve } from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import { DefaultPathService } from "./default-path-service.js";
+describe("DefaultPathService.getActiveWorkdir", () => {
+    it("returns the last setActiveWorkdir value (resolved), not the project root", () => {
+        const projectRoot = resolve("/some/project/root");
+        const service = new DefaultPathService({ getActiveProjectRoot: () => projectRoot });
+        service.setActiveWorkdir("/home/user/.qlogicagent/workspaces/default");
+        expect(service.getActiveWorkdir()).toBe(resolve("/home/user/.qlogicagent/workspaces/default"));
+        // getActiveProjectRoot stays its own value — the two roots are distinct.
+        expect(service.getActiveProjectRoot()).toBe(projectRoot);
+    });
+    it("tracks the latest setActiveWorkdir (changes per turn)", () => {
+        const service = new DefaultPathService();
+        service.setActiveWorkdir("/ws/a");
+        expect(service.getActiveWorkdir()).toBe(resolve("/ws/a"));
+        service.setActiveWorkdir("/ws/b");
+        expect(service.getActiveWorkdir()).toBe(resolve("/ws/b"));
+    });
+    it("falls back to getActiveProjectRoot before any setActiveWorkdir", () => {
+        const projectRoot = resolve("/fallback/root");
+        const service = new DefaultPathService({ getActiveProjectRoot: () => projectRoot });
+        expect(service.getActiveWorkdir()).toBe(projectRoot);
+    });
+    it("still forwards setActiveWorkdir to the options callback (resolved)", () => {
+        const setActiveWorkdir = vi.fn();
+        const service = new DefaultPathService({ setActiveWorkdir });
+        service.setActiveWorkdir("/ws/x");
+        expect(setActiveWorkdir).toHaveBeenCalledWith(resolve("/ws/x"));
+    });
+});

package/dist/runtime/infra/disk-storage.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Disk Storage Manager — unified atomic file I/O for agent self-managed storage.
+ *
+ * Provides:
+ * - Atomic write (tmp + rename) with dir auto-creation
+ * - JSON read/write helpers
+ */
+/**
+ * Write data atomically: write to a temp file in the same directory,
+ * then rename over the target. This prevents partial/corrupted reads.
+ */
+export declare function atomicWriteFile(filePath: string, data: string | Buffer): Promise<void>;
+/**
+ * Read a JSON file. Returns `undefined` if the file does not exist.
+ */
+export declare function readJsonFile<T = unknown>(filePath: string): Promise<T | undefined>;
+/**
+ * Write a JSON file atomically.
+ */
+export declare function writeJsonFile(filePath: string, data: unknown): Promise<void>;

package/dist/runtime/infra/disk-storage.js

@@ -0,0 +1,64 @@
+/**
+ * Disk Storage Manager — unified atomic file I/O for agent self-managed storage.
+ *
+ * Provides:
+ * - Atomic write (tmp + rename) with dir auto-creation
+ * - JSON read/write helpers
+ */
+import { readFile, writeFile, mkdir, rename, unlink } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { randomUUID } from "node:crypto";
+// ── Atomic File Operations ──────────────────────────────────
+/**
+ * Write data atomically: write to a temp file in the same directory,
+ * then rename over the target. This prevents partial/corrupted reads.
+ */
+export async function atomicWriteFile(filePath, data) {
+    const dir = dirname(filePath);
+    await mkdir(dir, { recursive: true });
+    const tmpPath = join(dir, `.tmp-${randomUUID()}`);
+    try {
+        await writeFile(tmpPath, data, "utf-8");
+        // Windows EPERM: rename can transiently fail when antivirus or another
+        // process holds a handle on the target. Retry up to 3 times with backoff.
+        let lastErr;
+        for (let attempt = 0; attempt < 3; attempt++) {
+            try {
+                await rename(tmpPath, filePath);
+                return;
+            }
+            catch (err) {
+                lastErr = err;
+                if (err.code !== "EPERM")
+                    throw err;
+                await new Promise(r => setTimeout(r, 50 * (attempt + 1)));
+            }
+        }
+        throw lastErr;
+    }
+    catch (err) {
+        // Clean up tmp file on failure
+        await unlink(tmpPath).catch(() => { });
+        throw err;
+    }
+}
+/**
+ * Read a JSON file. Returns `undefined` if the file does not exist.
+ */
+export async function readJsonFile(filePath) {
+    try {
+        const raw = await readFile(filePath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return undefined;
+        throw err;
+    }
+}
+/**
+ * Write a JSON file atomically.
+ */
+export async function writeJsonFile(filePath, data) {
+    await atomicWriteFile(filePath, JSON.stringify(data, null, 2) + "\n");
+}

package/dist/runtime/infra/external-agent-approvals.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Pending interactive-approval registry for EXTERNAL agents.
+ *
+ * When a spawned external agent (Codex/Claude/…) asks for permission (ACP session/request_permission),
+ * the host handler forwards the request to the frontend and parks the ACP response here until the user
+ * decides. The gateway delivers the decision via the agents.approvalResponse RPC, which resolves the
+ * matching pending promise so the host handler can return the chosen optionId to the external agent.
+ *
+ * This is the qlogicagent-side mirror of the gateway adapter's pendingPermissionRequests map.
+ */
+/**
+ * Park an approval until the user decides. Resolves with the chosen optionId, or null on timeout
+ * (the caller then applies a safe default). Idempotent per approvalId — a duplicate replaces the old.
+ */
+export declare function awaitApprovalDecision(approvalId: string, timeoutMs: number): Promise<string | null>;
+/** Deliver the user's decision. Returns false if no approval was pending for this id (no-op). */
+export declare function resolveApprovalDecision(approvalId: string, optionId: string): boolean;
+/** Cancel all pending approvals (e.g. on shutdown) — resolves them as null so awaiters unblock. */
+export declare function cancelAllApprovals(): void;
+export declare function pendingApprovalCount(): number;
+export interface ApprovalForwardDeps {
+    agentId: string;
+    /** Current streaming turn identity (read fresh each call, since members are reused across turns). */
+    turnContext: () => {
+        sessionId?: string;
+        turnId?: string;
+        requestId?: string;
+    } | null;
+    /** Emit the forward notification to the gateway (→ turn.approval_request → UI card). */
+    sendNotification?: (method: string, params: Record<string, unknown>) => void;
+    timeoutMs?: number;
+}
+/**
+ * Drive one interactive approval for an external agent: forward the ACP session/request_permission
+ * to the user (agents.prompt.approval), await the decision, and return the chosen optionId. Falls
+ * back to a reject option if there's no streaming turn context or the user doesn't decide in time.
+ * Pure + injectable so the bidirectional loop is unit-testable without a live agent.
+ */
+export declare function forwardExternalApproval(params: Record<string, unknown>, deps: ApprovalForwardDeps): Promise<{
+    optionId: string;
+}>;

package/dist/runtime/infra/external-agent-approvals.js

@@ -0,0 +1,101 @@
+/**
+ * Pending interactive-approval registry for EXTERNAL agents.
+ *
+ * When a spawned external agent (Codex/Claude/…) asks for permission (ACP session/request_permission),
+ * the host handler forwards the request to the frontend and parks the ACP response here until the user
+ * decides. The gateway delivers the decision via the agents.approvalResponse RPC, which resolves the
+ * matching pending promise so the host handler can return the chosen optionId to the external agent.
+ *
+ * This is the qlogicagent-side mirror of the gateway adapter's pendingPermissionRequests map.
+ */
+import { randomUUID } from "node:crypto";
+const PENDING = new Map();
+/**
+ * Park an approval until the user decides. Resolves with the chosen optionId, or null on timeout
+ * (the caller then applies a safe default). Idempotent per approvalId — a duplicate replaces the old.
+ */
+export function awaitApprovalDecision(approvalId, timeoutMs) {
+    // Replace any stale entry for the same id (e.g. a retried request).
+    const prev = PENDING.get(approvalId);
+    if (prev) {
+        clearTimeout(prev.timer);
+        prev.resolve(null);
+        PENDING.delete(approvalId);
+    }
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            PENDING.delete(approvalId);
+            resolve(null);
+        }, timeoutMs);
+        if (typeof timer.unref === "function")
+            timer.unref();
+        PENDING.set(approvalId, { resolve, timer });
+    });
+}
+/** Deliver the user's decision. Returns false if no approval was pending for this id (no-op). */
+export function resolveApprovalDecision(approvalId, optionId) {
+    const entry = PENDING.get(approvalId);
+    if (!entry)
+        return false;
+    clearTimeout(entry.timer);
+    PENDING.delete(approvalId);
+    entry.resolve(optionId);
+    return true;
+}
+/** Cancel all pending approvals (e.g. on shutdown) — resolves them as null so awaiters unblock. */
+export function cancelAllApprovals() {
+    for (const [id, entry] of [...PENDING.entries()]) {
+        clearTimeout(entry.timer);
+        PENDING.delete(id);
+        entry.resolve(null);
+    }
+}
+export function pendingApprovalCount() {
+    return PENDING.size;
+}
+function serializeArgs(raw) {
+    if (raw === undefined || raw === null)
+        return "";
+    if (typeof raw === "string")
+        return raw;
+    try {
+        return JSON.stringify(raw);
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Drive one interactive approval for an external agent: forward the ACP session/request_permission
+ * to the user (agents.prompt.approval), await the decision, and return the chosen optionId. Falls
+ * back to a reject option if there's no streaming turn context or the user doesn't decide in time.
+ * Pure + injectable so the bidirectional loop is unit-testable without a live agent.
+ */
+export async function forwardExternalApproval(params, deps) {
+    const cur = deps.turnContext();
+    const tc = (params.toolCall && typeof params.toolCall === "object" ? params.toolCall : {});
+    const approvalId = typeof params.permissionId === "string" && params.permissionId ? params.permissionId : randomUUID();
+    const options = Array.isArray(params.options) ? params.options : [];
+    if (cur?.turnId && deps.sendNotification) {
+        deps.sendNotification("agents.prompt.approval", {
+            agentId: deps.agentId,
+            sessionId: cur.sessionId,
+            turnId: cur.turnId,
+            requestId: cur.requestId,
+            approvalId,
+            callId: typeof tc.toolCallId === "string" ? tc.toolCallId : approvalId,
+            toolName: typeof tc.title === "string" ? tc.title : (typeof params.toolName === "string" ? params.toolName : "operation"),
+            arguments: serializeArgs(tc.rawInput),
+            message: typeof params.message === "string" ? params.message : undefined,
+            category: typeof params.category === "string" ? params.category : "destructive",
+            options,
+        });
+        const chosen = await awaitApprovalDecision(approvalId, deps.timeoutMs ?? 5 * 60_000);
+        if (chosen)
+            return { optionId: chosen };
+    }
+    // No interactive context, or no decision in time → reject if offered, else first/"reject".
+    const reject = options.find((o) => o?.kind === "reject_once" || o?.kind === "reject" ||
+        /reject|deny|no|cancel/i.test(String(o?.optionId ?? o?.name ?? "")));
+    return { optionId: reject?.optionId ?? options[0]?.optionId ?? "reject" };
+}

package/dist/runtime/infra/external-agent-approvals.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/infra/external-agent-approvals.test.js

@@ -0,0 +1,99 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { awaitApprovalDecision, cancelAllApprovals, forwardExternalApproval, pendingApprovalCount, resolveApprovalDecision, } from "./external-agent-approvals.js";
+import { createAcpHostHandler } from "./acp-host-handler.js";
+afterEach(() => {
+    cancelAllApprovals();
+    vi.useRealTimers();
+});
+describe("external-agent-approvals registry", () => {
+    it("resolves the awaiting promise with the user's chosen optionId", async () => {
+        const p = awaitApprovalDecision("a1", 60_000);
+        expect(pendingApprovalCount()).toBe(1);
+        const delivered = resolveApprovalDecision("a1", "allow_once");
+        expect(delivered).toBe(true);
+        await expect(p).resolves.toBe("allow_once");
+        expect(pendingApprovalCount()).toBe(0);
+    });
+    it("resolveApprovalDecision returns false for an unknown approval (no-op)", () => {
+        expect(resolveApprovalDecision("missing", "allow")).toBe(false);
+    });
+    it("resolves to null on timeout (caller applies a safe default)", async () => {
+        vi.useFakeTimers();
+        const p = awaitApprovalDecision("t1", 1000);
+        vi.advanceTimersByTime(1001);
+        await expect(p).resolves.toBeNull();
+        expect(pendingApprovalCount()).toBe(0);
+    });
+    it("a duplicate approvalId replaces the prior pending (resolves it null)", async () => {
+        const first = awaitApprovalDecision("dup", 60_000);
+        const second = awaitApprovalDecision("dup", 60_000);
+        await expect(first).resolves.toBeNull(); // superseded
+        resolveApprovalDecision("dup", "reject_once");
+        await expect(second).resolves.toBe("reject_once");
+    });
+    it("cancelAll unblocks every awaiter with null", async () => {
+        const a = awaitApprovalDecision("x", 60_000);
+        const b = awaitApprovalDecision("y", 60_000);
+        cancelAllApprovals();
+        await expect(a).resolves.toBeNull();
+        await expect(b).resolves.toBeNull();
+        expect(pendingApprovalCount()).toBe(0);
+    });
+});
+describe("external-agent approval — full host-handler bidirectional loop", () => {
+    it("forwards session/request_permission and returns the user's chosen optionId", async () => {
+        const sent = [];
+        // Real host handler with the real forwarder injected (exactly the handleAgentsPrompt wiring).
+        const host = createAcpHostHandler({
+            cwd: process.cwd(),
+            requestPermission: (params) => forwardExternalApproval(params, {
+                agentId: "codex",
+                turnContext: () => ({ sessionId: "s1", turnId: "t1", requestId: "r1" }),
+                sendNotification: (method, params) => sent.push({ method, params }),
+                timeoutMs: 5000,
+            }),
+        });
+        // 1. External agent asks (don't await yet — it parks until the user decides).
+        const pending = host.requestPermission({
+            permissionId: "appr-1",
+            toolCall: { toolCallId: "c1", title: "rm -rf /tmp/x", rawInput: { cmd: "rm" } },
+            message: "Delete files?",
+            category: "destructive",
+            options: [
+                { optionId: "allow_once", name: "Allow once", kind: "allow_once" },
+                { optionId: "reject_once", name: "Reject", kind: "reject_once" },
+            ],
+        });
+        // 2. The approval was forwarded to the UI with the right shape (what the gateway re-emits).
+        await Promise.resolve();
+        expect(sent).toHaveLength(1);
+        expect(sent[0].method).toBe("agents.prompt.approval");
+        expect(sent[0].params.approvalId).toBe("appr-1");
+        expect(sent[0].params.toolName).toBe("rm -rf /tmp/x");
+        expect(sent[0].params.category).toBe("destructive");
+        expect(sent[0].params.options.length).toBe(2);
+        // 3. User decides (what the gateway delivers via agents.approvalResponse → resolveApprovalDecision).
+        expect(resolveApprovalDecision("appr-1", "allow_once")).toBe(true);
+        // 4. The host handler returns the chosen option to the external agent.
+        await expect(pending).resolves.toEqual({ optionId: "allow_once" });
+        host.disposeAll();
+    });
+    it("rejects safely when there is no streaming turn to forward into", async () => {
+        const host = createAcpHostHandler({
+            cwd: process.cwd(),
+            requestPermission: (params) => forwardExternalApproval(params, {
+                agentId: "codex",
+                turnContext: () => null, // no active streaming turn → cannot route a decision back
+                sendNotification: () => { throw new Error("should not forward"); },
+            }),
+        });
+        const res = await host.requestPermission({
+            options: [
+                { optionId: "allow", kind: "allow_once" },
+                { optionId: "reject_once", kind: "reject_once" },
+            ],
+        });
+        expect(res).toEqual({ optionId: "reject_once" });
+        host.disposeAll();
+    });
+});