qlogicagent 2.13.5 → 2.13.6

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

@@ -1,110 +0,0 @@
-/**
- * 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

@@ -1,23 +0,0 @@
-/**
- * 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

@@ -1,34 +0,0 @@
-/**
- * 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

@@ -1,33 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

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

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

@@ -1,31 +0,0 @@
-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

@@ -1,20 +0,0 @@
-/**
- * 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

@@ -1,64 +0,0 @@
-/**
- * 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

@@ -1,41 +0,0 @@
-/**
- * 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

@@ -1,101 +0,0 @@
-/**
- * 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

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

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

@@ -1,99 +0,0 @@
-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();
-    });
-});