qlogicagent 2.13.5 → 2.13.6

package/dist/cli/permission-approval-bridge.js

@@ -1,66 +0,0 @@
-import { promptOptionsForCategory } from "../runtime/permission-model.js";
-export async function requestPermissionApproval(request, deps) {
-    const acpSession = deps.getAcpPermissionSession();
-    if (acpSession) {
-        try {
-            const options = promptOptionsForCategory(request.category ?? "destructive")
-                .map((o) => ({ optionId: o.optionId, name: o.name, kind: o.kind }));
-            const result = await acpSession.requestPermission({
-                sessionId: acpSession.sessionId,
-                permissionId: request.approvalId,
-                toolCall: {
-                    toolCallId: request.callId,
-                    title: request.toolName,
-                    rawInput: request.arguments ?? {},
-                },
-                message: request.message,
-                category: request.category,
-                options,
-            });
-            return createApprovalResponseFromAcpOption(request, result.optionId);
-        }
-        catch {
-            return { approvalId: request.approvalId, decision: "deny" };
-        }
-    }
-    deps.sendNotification("tool.approval.request", {
-        approvalId: request.approvalId,
-        callId: request.callId,
-        toolName: request.toolName,
-        arguments: request.arguments ? JSON.stringify(request.arguments) : "",
-        message: request.message,
-        category: request.category,
-        reason: request.message,
-        options: promptOptionsForCategory(request.category ?? "destructive"),
-        rememberScope: request.rememberScope,
-    });
-    if (deps.isPetActive()) {
-        const risk = inferApprovalRisk(request.toolName);
-        deps.sendNotification("pet.confirm", {
-            confirmId: request.approvalId,
-            toolName: request.toolName,
-            description: request.message ?? `Allow ${request.toolName}`,
-            risk,
-            timeoutMs: 30_000,
-        });
-    }
-    return new Promise(() => {
-        // PermissionChecker owns pending approval resolution.
-    });
-}
-function inferApprovalRisk(toolName) {
-    if (toolName.match(/exec|bash|shell|terminal|run_command|reset|force|drop/i))
-        return "system";
-    if (toolName.match(/web|http|fetch|mcp|media|image|video|music|tts/i))
-        return "external_egress";
-    if (toolName.match(/write|delete|rm|move|patch|edit|create/i))
-        return "write";
-    return "read";
-}
-export function createApprovalResponseFromAcpOption(request, optionId) {
-    const opt = promptOptionsForCategory(request.category ?? "destructive").find((o) => o.optionId === optionId);
-    if (!opt || opt.kind.startsWith("reject")) {
-        return { approvalId: request.approvalId, decision: "deny" };
-    }
-    return { approvalId: request.approvalId, decision: "allow", scope: opt.scope };
-}

package/dist/cli/permission-approval-bridge.test.d.ts

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

package/dist/cli/permission-approval-bridge.test.js

@@ -1,100 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { createApprovalResponseFromAcpOption, requestPermissionApproval } from "./permission-approval-bridge.js";
-const req = (over = {}) => ({
-    approvalId: "a1", callId: "c1", toolName: "write", arguments: { path: "/x" }, message: "m", ...over,
-});
-describe("approval bridge options", () => {
-    it("cross_workspace → 3 ACP options incl allow_dir(allow_always), response maps to scope directory", async () => {
-        const calls = [];
-        const deps = {
-            getAcpPermissionSession: () => ({ sessionId: "s", requestPermission: async (p) => { calls.push(p); return { optionId: "allow_dir" }; } }),
-            sendNotification: () => { },
-            isPetActive: () => false,
-        };
-        const resp = await requestPermissionApproval(req({ category: "cross_workspace", rememberScope: { kind: "directory", path: "/x" } }), deps);
-        expect(calls[0].options.map((o) => o.optionId)).toEqual(["allow", "allow_dir", "deny"]);
-        expect(calls[0].options.find((o) => o.optionId === "allow_dir").kind).toBe("allow_always");
-        expect(resp).toMatchObject({ decision: "allow", scope: "directory" });
-    });
-    it("high_risk_delete allow → scope once; deny → deny", () => {
-        expect(createApprovalResponseFromAcpOption(req({ category: "high_risk_delete" }), "allow")).toMatchObject({ decision: "allow", scope: "once" });
-        expect(createApprovalResponseFromAcpOption(req(), "deny")).toMatchObject({ decision: "deny" });
-    });
-    it("unknown/undefined optionId → deny (fail-safe)", () => {
-        expect(createApprovalResponseFromAcpOption(req(), undefined).decision).toBe("deny");
-        expect(createApprovalResponseFromAcpOption(req(), "bogus").decision).toBe("deny");
-    });
-});
-describe("non-ACP path enriched notification", () => {
-    it("non-ACP path enriches the approval notification", () => {
-        const notes = [];
-        const deps = {
-            getAcpPermissionSession: () => undefined,
-            sendNotification: (method, params) => notes.push({ method, params }),
-            isPetActive: () => false,
-        };
-        void requestPermissionApproval(req({ category: "cross_workspace", rememberScope: { kind: "directory", path: "/x" } }), deps);
-        const approval = notes.find((n) => n.method === "tool.approval.request");
-        expect(approval.params.category).toBe("cross_workspace");
-        expect(approval.params.options.some((o) => o.optionId === "allow_dir")).toBe(true);
-    });
-});
-describe("ACP category propagation", () => {
-    it("carries category in ACP request params", async () => {
-        const calls = [];
-        const deps = {
-            getAcpPermissionSession: () => ({ sessionId: "s", requestPermission: async (p) => { calls.push(p); return { optionId: "deny" }; } }),
-            sendNotification: () => { },
-            isPetActive: () => false,
-        };
-        await requestPermissionApproval(req({ category: "cross_workspace" }), deps);
-        expect(calls[0].category).toBe("cross_workspace");
-    });
-});
-describe("requestPermissionApproval ACP standard shape", () => {
-    it("sends standard toolCallId/title/rawInput + options with kind (default/destructive category)", async () => {
-        let captured;
-        const deps = {
-            getAcpPermissionSession: () => ({
-                sessionId: "s1",
-                requestPermission: async (p) => {
-                    captured = p;
-                    return { optionId: "allow" };
-                },
-            }),
-            sendNotification: vi.fn(),
-            isPetActive: () => false,
-        };
-        const res = await requestPermissionApproval({
-            approvalId: "a1",
-            callId: "c1",
-            toolName: "bash",
-            arguments: { cmd: "ls" },
-            message: "run?",
-        }, deps);
-        expect(captured.toolCall).toEqual({ toolCallId: "c1", title: "bash", rawInput: { cmd: "ls" } });
-        expect(captured.toolCall.callId).toBeUndefined();
-        // category defaults to "destructive" → 2 options [allow, deny]
-        expect(captured.options.map((o) => o.optionId)).toEqual(["allow", "deny"]);
-        expect(captured.options[0].kind).toBe("allow_once");
-        expect(captured.options[1].kind).toBe("reject_once");
-        expect(res.decision).toBe("allow");
-    });
-    it("rawInput defaults to {} when arguments absent", async () => {
-        let captured;
-        const deps = {
-            getAcpPermissionSession: () => ({
-                sessionId: "s1",
-                requestPermission: async (p) => {
-                    captured = p;
-                    return { optionId: "deny" };
-                },
-            }),
-            sendNotification: vi.fn(),
-            isPetActive: () => false,
-        };
-        const res = await requestPermissionApproval({ approvalId: "a2", callId: "c2", toolName: "read", message: "?" }, deps);
-        expect(captured.toolCall).toEqual({ toolCallId: "c2", title: "read", rawInput: {} });
-        expect(res.decision).toBe("deny");
-    });
-});

package/dist/cli/permission-bootstrap.d.ts

@@ -1,40 +0,0 @@
-import type { HookRegistry } from "../contracts/hooks.js";
-import type { NotificationMethod, NotificationMethodMap } from "../protocol/notifications.js";
-import type { AcpPermissionRequestParams } from "../protocol/wire/index.js";
-import type { ToolCatalog } from "../runtime/ports/index.js";
-import { type RuntimePermissionChecker, type RuntimePermissionRuleEngine } from "./permission-runtime-service.js";
-export { createApprovalResponseFromAcpOption } from "./permission-approval-bridge.js";
-export interface PermissionBootstrapDeps {
-    config: Record<string, unknown>;
-    toolCatalog: ToolCatalog;
-    hooks: HookRegistry;
-    log: {
-        info(message: string): void;
-        warn(message: string): void;
-    };
-    sessionId: string;
-    getTurnId(): string;
-    getActiveProjectRoot(): string;
-    /**
-     * The live active tool workdir (where file/exec relative paths resolve). The
-     * cross-workspace classifier compares tool target paths against THIS, not
-     * getActiveProjectRoot — the latter is a (possibly snapshotted) project root
-     * used for memory/sessions and does not track the per-turn tool workdir.
-     */
-    getActiveWorkdir(): string;
-    getAcpPermissionSession(): {
-        sessionId: string;
-        requestPermission(params: AcpPermissionRequestParams): Promise<{
-            optionId?: string;
-        }>;
-    } | undefined;
-    sendNotification<M extends NotificationMethod>(method: M, params: NotificationMethodMap[M]): void;
-    isPetActive(): boolean;
-    currentUnregister?: (() => void) | null;
-}
-export interface PermissionBootstrapResult {
-    permissionChecker: RuntimePermissionChecker;
-    permissionUnregister: () => void;
-    ruleEngine: RuntimePermissionRuleEngine;
-}
-export declare function configurePermissionBootstrap(deps: PermissionBootstrapDeps): PermissionBootstrapResult;

package/dist/cli/permission-bootstrap.js

@@ -1,58 +0,0 @@
-import { createDefaultCommunityTelemetryRecorder } from "../runtime/community/community-telemetry-recorder.js";
-import { DenialAuditLogger } from "../skills/permissions/denial-audit-log.js";
-import { getGroupSecurityRules } from "../skills/permissions/group-security-policy.js";
-import { isActiveProjectGroup } from "./project-context.js";
-import { setGroupSecurityMode, setSandboxPermissionSource } from "./tool-bootstrap.js";
-import { requestPermissionApproval } from "./permission-approval-bridge.js";
-import { createRuntimePermissionChecker, createRuntimePermissionRuleEngine, parseRuntimePermissionConfig, } from "./permission-runtime-service.js";
-export { createApprovalResponseFromAcpOption } from "./permission-approval-bridge.js";
-export function configurePermissionBootstrap(deps) {
-    const permConfig = parseRuntimePermissionConfig(deps.config.permissions);
-    const ruleEngine = createRuntimePermissionRuleEngine(permConfig);
-    // Cross-workspace / full_access access is owned by the permission pipeline
-    // (the `tool.before_invoke` hook); the tool layer no longer bypasses a
-    // workspace boundary, so no tool-level toggle is needed here.
-    if (isActiveProjectGroup()) {
-        const groupRules = getGroupSecurityRules();
-        for (const rule of groupRules) {
-            ruleEngine.addRule(rule);
-        }
-        setGroupSecurityMode(true);
-        deps.log.info(`[permissions] group security mode active: ${groupRules.length} rules injected`);
-    }
-    else {
-        setGroupSecurityMode(false);
-    }
-    deps.currentUnregister?.();
-    const permissionChecker = createRuntimePermissionChecker({
-        ruleEngine,
-        hookRegistry: deps.hooks,
-        // Cross-workspace classification must compare against the dir the tools
-        // actually operate in (active workdir), NOT the project root. The audit
-        // logger keeps using getActiveProjectRoot (memory/sessions location).
-        getWorkspaceRoot: deps.getActiveWorkdir,
-        auditLogger: new DenialAuditLogger(deps.getActiveProjectRoot()),
-        sessionId: deps.sessionId,
-        getTurnId: deps.getTurnId,
-        communityTelemetryRecorder: createDefaultCommunityTelemetryRecorder() ?? undefined,
-        onRequestApproval: (request) => requestPermissionApproval(request, deps),
-        onDenied: (toolName, message) => {
-            deps.log.warn(`[permissions] blocked "${toolName}": ${message}`);
-        },
-    });
-    permissionChecker.setToolMeta(deps.toolCatalog.getToolManifest());
-    // cut7c: expose the live permission single-source to the OS-sandbox builder
-    // (exec tool's resolveSandbox). Same rule engine + active workdir the prompt
-    // pipeline uses; mode/allowedDirs are read live per exec.
-    setSandboxPermissionSource(() => ({
-        mode: ruleEngine.getMode(),
-        workdir: deps.getActiveWorkdir(),
-        allowedDirs: ruleEngine.getAllowedWriteDirectories(),
-        communityTurn: permissionChecker.isCommunitySandboxTurn(),
-    }));
-    return {
-        permissionChecker,
-        permissionUnregister: permissionChecker.register(),
-        ruleEngine,
-    };
-}

package/dist/cli/permission-bootstrap.test.d.ts

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

package/dist/cli/permission-bootstrap.test.js

@@ -1,129 +0,0 @@
-import path from "node:path";
-import os from "node:os";
-import { describe, expect, it, vi } from "vitest";
-import { configurePermissionBootstrap, createApprovalResponseFromAcpOption } from "./permission-bootstrap.js";
-class MemoryHookRegistry {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    handlers = new Map();
-    register(registration) {
-        const list = this.handlers.get(registration.point) ?? [];
-        list.push(registration.handler);
-        this.handlers.set(registration.point, list);
-        return () => {
-            this.handlers.set(registration.point, list.filter(h => h !== registration.handler));
-        };
-    }
-    async invoke(point, context) {
-        for (const handler of this.handlers.get(point) ?? []) {
-            const result = await handler(point, context);
-            if (result?.action === "abort")
-                return result;
-        }
-        return { action: "continue" };
-    }
-}
-function approvalRequest(toolName = "write") {
-    return {
-        approvalId: "approval-1",
-        callId: "call-1",
-        toolName,
-        message: `Allow ${toolName}`,
-    };
-}
-describe("createApprovalResponseFromAcpOption", () => {
-    it("uses allow as the only approving ACP decision", () => {
-        expect(createApprovalResponseFromAcpOption(approvalRequest(), "allow")).toMatchObject({
-            approvalId: "approval-1",
-            decision: "allow",
-        });
-    });
-    it("denies unknown or missing ACP decisions", () => {
-        expect(createApprovalResponseFromAcpOption(approvalRequest(), "deny")).toMatchObject({
-            decision: "deny",
-        });
-        expect(createApprovalResponseFromAcpOption(approvalRequest(), undefined)).toMatchObject({
-            decision: "deny",
-        });
-        expect(createApprovalResponseFromAcpOption(approvalRequest(), "allow" + "Always")).toMatchObject({
-            decision: "deny",
-        });
-    });
-});
-describe("configurePermissionBootstrap workspace root wiring", () => {
-    function makeDeps(over) {
-        return {
-            config: {},
-            toolCatalog: {
-                // write tool meta: not read-only so cross-workspace gating applies.
-                getToolManifest: () => [
-                    {
-                        type: "function",
-                        function: { name: "write", description: "writes", parameters: { type: "object", properties: {} } },
-                        meta: { isReadOnly: false },
-                    },
-                ],
-            },
-            hooks: over.hooks,
-            log: { info: () => { }, warn: () => { } },
-            sessionId: "session-1",
-            getTurnId: () => "turn-1",
-            getActiveProjectRoot: over.getActiveProjectRoot,
-            getActiveWorkdir: over.getActiveWorkdir,
-            getAcpPermissionSession: () => ({
-                sessionId: "session-1",
-                requestPermission: over.onRequestApproval,
-            }),
-            sendNotification: () => { },
-            isPetActive: () => false,
-        };
-    }
-    it("classifies cross-workspace against the active workdir, not the project root", async () => {
-        // Project root and active workdir DIVERGE (the exact bug shape): a write that
-        // is INSIDE the project root but OUTSIDE the tool workdir must be treated as
-        // cross-workspace (prompt), proving getWorkspaceRoot == active workdir.
-        const projectRoot = path.join(os.tmpdir(), "qla-perm-wiring-project");
-        const activeWorkdir = path.join(projectRoot, "workspaces", "default");
-        const targetInsideProjectButOutsideWorkdir = path.join(projectRoot, "outside-the-workdir.txt");
-        const registry = new MemoryHookRegistry();
-        const approval = vi.fn(async (_params) => ({ optionId: "allow" }));
-        configurePermissionBootstrap(makeDeps({
-            hooks: registry,
-            getActiveProjectRoot: () => projectRoot,
-            getActiveWorkdir: () => activeWorkdir,
-            onRequestApproval: approval,
-        }));
-        const result = await registry.invoke("tool.before_invoke", {
-            sessionId: "session-1",
-            turnId: "turn-1",
-            callId: "call-1",
-            toolName: "write",
-            arguments: { path: targetInsideProjectButOutsideWorkdir, content: "x" },
-        });
-        // Cross-workspace ⇒ default mode prompts; approval was requested.
-        expect(approval).toHaveBeenCalledTimes(1);
-        expect(approval.mock.calls[0]?.[0].category).toBe("cross_workspace");
-        expect(result.action).toBe("continue");
-    });
-    it("does not prompt for a write inside the active workdir", async () => {
-        const projectRoot = path.join(os.tmpdir(), "qla-perm-wiring-project2");
-        const activeWorkdir = path.join(projectRoot, "workspaces", "default");
-        const insideWorkdir = path.join(activeWorkdir, "src", "app.ts");
-        const registry = new MemoryHookRegistry();
-        const approval = vi.fn(async (_params) => ({ optionId: "allow" }));
-        configurePermissionBootstrap(makeDeps({
-            hooks: registry,
-            getActiveProjectRoot: () => projectRoot,
-            getActiveWorkdir: () => activeWorkdir,
-            onRequestApproval: approval,
-        }));
-        const result = await registry.invoke("tool.before_invoke", {
-            sessionId: "session-1",
-            turnId: "turn-1",
-            callId: "call-2",
-            toolName: "write",
-            arguments: { path: insideWorkdir, content: "x" },
-        });
-        expect(approval).not.toHaveBeenCalled();
-        expect(result.action).toBe("continue");
-    });
-});

package/dist/cli/permission-runtime-service.d.ts

@@ -1,9 +0,0 @@
-import { PermissionChecker } from "../skills/permissions/hook-runner.js";
-import { PermissionRuleEngine } from "../skills/permissions/rule-engine.js";
-import type { PermissionEngineConfig } from "../runtime/ports/index.js";
-import type { PermissionCheckerDeps } from "../skills/permissions/hook-runner.js";
-export type RuntimePermissionChecker = PermissionChecker;
-export type RuntimePermissionRuleEngine = PermissionRuleEngine;
-export declare function parseRuntimePermissionConfig(raw: unknown): PermissionEngineConfig;
-export declare function createRuntimePermissionRuleEngine(raw: unknown): PermissionRuleEngine;
-export declare function createRuntimePermissionChecker(deps: PermissionCheckerDeps): PermissionChecker;

package/dist/cli/permission-runtime-service.js

@@ -1,11 +0,0 @@
-import { PermissionChecker } from "../skills/permissions/hook-runner.js";
-import { parsePermissionConfig, PermissionRuleEngine } from "../skills/permissions/rule-engine.js";
-export function parseRuntimePermissionConfig(raw) {
-    return parsePermissionConfig(raw);
-}
-export function createRuntimePermissionRuleEngine(raw) {
-    return new PermissionRuleEngine(parseRuntimePermissionConfig(raw));
-}
-export function createRuntimePermissionChecker(deps) {
-    return new PermissionChecker(deps);
-}

package/dist/cli/permission-settings-store.d.ts

@@ -1 +0,0 @@
-export declare function persistPermissionUpdateToSettings(_update: unknown, _settingsPath?: string): void;

package/dist/cli/permission-settings-store.js

@@ -1,3 +0,0 @@
-export function persistPermissionUpdateToSettings(_update, _settingsPath) {
-    return;
-}

package/dist/cli/permission-settings-store.test.d.ts

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

package/dist/cli/permission-settings-store.test.js

@@ -1,65 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { persistPermissionUpdateToSettings } from "./permission-settings-store.js";
-const tempDirs = [];
-function createSettingsFile(initial) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "qlogicagent-permissions-"));
-    tempDirs.push(dir);
-    const file = path.join(dir, "settings.json");
-    fs.writeFileSync(file, JSON.stringify(initial, null, 2), "utf-8");
-    return file;
-}
-function readSettings(file) {
-    return JSON.parse(fs.readFileSync(file, "utf-8"));
-}
-afterEach(() => {
-    for (const dir of tempDirs.splice(0)) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-});
-describe("persistPermissionUpdateToSettings", () => {
-    it("does not persist per-tool permission updates", () => {
-        const settingsPath = createSettingsFile({
-            permissions: {
-                mode: "auto",
-                rules: [
-                    { pattern: "execute_command", behavior: "ask", source: "config" },
-                    { pattern: "read", behavior: "allow", source: "config" },
-                ],
-            },
-        });
-        persistPermissionUpdateToSettings({
-            pattern: "execute_command",
-            behavior: "allow",
-            scope: "persistent",
-            description: "Always allow execute_command",
-        }, settingsPath);
-        expect(readSettings(settingsPath).permissions).toEqual({
-            mode: "auto",
-            rules: [
-                { pattern: "execute_command", behavior: "ask", source: "config" },
-                { pattern: "read", behavior: "allow", source: "config" },
-            ],
-        });
-    });
-    it("does not persist session-scoped permission updates", () => {
-        const settingsPath = createSettingsFile({
-            permissions: {
-                mode: "default",
-                rules: [],
-            },
-        });
-        persistPermissionUpdateToSettings({
-            pattern: "write",
-            behavior: "allow",
-            scope: "session",
-            description: "Allow write for this session",
-        }, settingsPath);
-        expect(readSettings(settingsPath).permissions).toEqual({
-            mode: "default",
-            rules: [],
-        });
-    });
-});

package/dist/cli/pet-confirm-coordinator.d.ts

@@ -1,20 +0,0 @@
-import type { NotificationMethod, NotificationMethodMap } from "../protocol/notifications.js";
-import type { ApprovalResponse, PermissionRiskLevel } from "../runtime/ports/index.js";
-export interface PetConfirmPermissionResolver {
-    resolveApproval(response: ApprovalResponse): void;
-}
-export interface PetConfirmCoordinatorDeps {
-    getPermissionResolver(): PetConfirmPermissionResolver | null | undefined;
-    sendNotification<M extends NotificationMethod>(method: M, params: NotificationMethodMap[M]): void;
-}
-export interface PetConfirmResponse {
-    confirmId: string;
-    approved: boolean;
-}
-export declare class PetConfirmCoordinator {
-    private readonly deps;
-    private readonly pendingConfirms;
-    constructor(deps: PetConfirmCoordinatorDeps);
-    requestConfirm(toolName: string, description: string, risk: PermissionRiskLevel, timeoutMs?: number): Promise<boolean>;
-    handleResponse({ confirmId, approved }: PetConfirmResponse): void;
-}

package/dist/cli/pet-confirm-coordinator.js

@@ -1,32 +0,0 @@
-export class PetConfirmCoordinator {
-    deps;
-    pendingConfirms = new Map();
-    constructor(deps) {
-        this.deps = deps;
-    }
-    requestConfirm(toolName, description, risk, timeoutMs = 30_000) {
-        const confirmId = `confirm_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-        this.deps.sendNotification("pet.confirm", { confirmId, toolName, description, risk, timeoutMs });
-        return new Promise((resolve) => {
-            const timer = setTimeout(() => {
-                this.pendingConfirms.delete(confirmId);
-                resolve(false);
-            }, timeoutMs + 2_000);
-            this.pendingConfirms.set(confirmId, (approved) => {
-                clearTimeout(timer);
-                resolve(approved);
-            });
-        });
-    }
-    handleResponse({ confirmId, approved }) {
-        this.deps.getPermissionResolver()?.resolveApproval({
-            approvalId: confirmId,
-            decision: approved ? "allow" : "deny",
-        });
-        const resolve = this.pendingConfirms.get(confirmId);
-        if (resolve) {
-            this.pendingConfirms.delete(confirmId);
-            resolve(!!approved);
-        }
-    }
-}

package/dist/cli/pet-confirm-coordinator.test.d.ts

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

package/dist/cli/pet-confirm-coordinator.test.js

@@ -1,34 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { PetConfirmCoordinator } from "./pet-confirm-coordinator.js";
-describe("PetConfirmCoordinator", () => {
-    it("routes confirm responses to permission approval and pending requester", async () => {
-        const notifications = [];
-        const approvals = [];
-        const coordinator = new PetConfirmCoordinator({
-            getPermissionResolver: () => ({
-                resolveApproval: (response) => approvals.push(response),
-            }),
-            sendNotification: (method, params) => notifications.push({ method, params }),
-        });
-        const pending = coordinator.requestConfirm("write", "Allow write?", "write", 10);
-        const confirmId = (notifications[0]?.params).confirmId;
-        coordinator.handleResponse({ confirmId, approved: true });
-        await expect(pending).resolves.toBe(true);
-        expect(notifications[0]).toMatchObject({
-            method: "pet.confirm",
-            params: { toolName: "write", description: "Allow write?", risk: "write", timeoutMs: 10 },
-        });
-        expect(approvals).toEqual([{ approvalId: confirmId, decision: "allow" }]);
-    });
-    it("denies stale confirmations after timeout", async () => {
-        vi.useFakeTimers();
-        const coordinator = new PetConfirmCoordinator({
-            getPermissionResolver: () => null,
-            sendNotification: () => { },
-        });
-        const pending = coordinator.requestConfirm("delete", "Allow delete?", "system", 10);
-        await vi.advanceTimersByTimeAsync(2_010);
-        await expect(pending).resolves.toBe(false);
-        vi.useRealTimers();
-    });
-});

package/dist/cli/pet-runtime.d.ts

@@ -1,55 +0,0 @@
-import type { ChatMessage } from "../agent/types.js";
-import type { ModelPurpose } from "../runtime/infra/model-registry.js";
-import { type PetStats, type PetdexPetAsset, type PetdexValidationReport } from "../runtime/pet/index.js";
-import { type PetdexProductionRun } from "../runtime/pet/petdex-forge-service.js";
-import type { LLMTransport } from "./provider-core-facade.js";
-export type PetSoulGenerator = (rarity: string, stats: PetStats) => Promise<{
-    name: string;
-    personality: string;
-    catchphrase: string;
-}>;
-export type SmallLlmCall = (prompt: string, maxTokens: number) => Promise<string | null>;
-export interface PetdexForgeInput {
-    id?: string;
-    name: string;
-    description: string;
-    prompt?: string | null;
-    referenceImageUrl?: string;
-    referenceMode?: "identity" | "refine";
-    baseSpritesheet?: Buffer;
-}
-export interface PetdexForgeOutput {
-    asset: PetdexPetAsset;
-    spritesheet: Buffer;
-    validation: PetdexValidationReport;
-    productionRun?: PetdexProductionRun;
-    mediaUsage?: {
-        provider: string;
-        model: string;
-        billingUnit: string;
-        billingQuantity: number;
-    };
-}
-export interface PetLlmClient {
-    transport: LLMTransport;
-    apiKey: string;
-    model: string;
-}
-export interface PetRuntime {
-    createPetSoulGenerator(): PetSoulGenerator | undefined;
-    createSmallLLMCall(): SmallLlmCall | undefined;
-    forgeAnalyzeImage(imageBase64: string, hint?: string): Promise<string>;
-    isImageGenerationAvailable(): boolean;
-    isPetdexForgeAvailable(): boolean;
-    forgeGeneratePetdexAtlas(input: PetdexForgeInput): Promise<PetdexForgeOutput>;
-    awardXp(event: string): Promise<void>;
-    reactAfterTurn(messages: ChatMessage[]): Promise<void>;
-    isActive(): boolean;
-}
-export interface PetRuntimeDeps {
-    getActiveProjectRoot(): string;
-    resolveOwnerUserId?: () => string;
-    resolveClientForPurpose(purpose: ModelPurpose): PetLlmClient | null;
-    sendNotification(method: string, params: Record<string, unknown>): void;
-}
-export declare function createPetRuntime(deps: PetRuntimeDeps): PetRuntime;