@camerontaylor/paseo-cli 0.11.2-fork.2 → 0.12.0-beta.1.fork.1

package/dist/cli.js

@@ -3,6 +3,7 @@ import { Command, Option } from "commander";
 import { createAgentCommand } from "./commands/agent/index.js";
 import { createDaemonCommand } from "./commands/daemon/index.js";
 import { createPermitCommand } from "./commands/permit/index.js";
+import { createUsageCommand } from "./commands/usage/index.js";
 import { createProviderCommand } from "./commands/provider/index.js";
 import { createPluginCommand } from "./commands/plugin/index.js";
 import { createProjectCommand } from "./commands/project/index.js";
@@ -93,6 +94,7 @@ export function createCli() {
     program.addCommand(createPermitCommand());
     // Provider commands
     program.addCommand(createProviderCommand());
+    program.addCommand(createUsageCommand());
     program.addCommand(createPluginCommand());
     // Speech model commands
     program.addCommand(createSpeechCommand());

package/dist/commands/agent/logs.d.ts

@@ -11,9 +11,26 @@ export interface AgentLogsOptions extends CommandOptions {
 }
 export type AgentLogsResult = void;
 export declare const NO_ACTIVITY_MESSAGE = "No activity to display.";
-export declare function fetchAgentTimelineItems(client: DaemonClient, agentId: string, options?: {
+interface FetchAgentTimelineItemsOptions {
     timeoutMs?: number;
-}): Promise<AgentTimelineItem[]>;
+    sinceTimestampMs?: number;
+}
+export declare function fetchAgentTimelineItems(client: DaemonClient, agentId: string, options?: FetchAgentTimelineItemsOptions): Promise<AgentTimelineItem[]>;
 export declare function formatAgentActivityTranscript(timelineItems: AgentTimelineItem[], tailCount?: number): string;
+export interface FollowTranscriptWriter {
+    push(item: AgentTimelineItem, turnId?: string): void;
+    end(): void;
+}
+/**
+ * Follow mode receives one streaming fragment per event, while the one-shot
+ * transcript sees the whole timeline and merges consecutive assistant and
+ * reasoning fragments with exact concatenation (`projectTimelineRows`). Printing
+ * each fragment on its own line splits words at fragment boundaries and
+ * reprints the reasoning prefix, so a chain of fragments is written as one
+ * stream instead: text goes out as it arrives, and only the trailing whitespace
+ * is held back so the message ends trimmed the way the transcript does.
+ */
+export declare function createFollowTranscriptWriter(write?: (chunk: string) => void, filter?: string): FollowTranscriptWriter;
 export declare function runLogsCommand(id: string, options: AgentLogsOptions, _command: Command): Promise<AgentLogsResult>;
+export {};
 //# sourceMappingURL=logs.d.ts.map

package/dist/commands/agent/logs.js

@@ -13,7 +13,12 @@ export function addLogsOptions(cmd) {
 }
 export const NO_ACTIVITY_MESSAGE = "No activity to display.";
 export async function fetchAgentTimelineItems(client, agentId, options) {
-    return fetchProjectedTimelineItems({ client, agentId, timeoutMs: options?.timeoutMs });
+    return fetchProjectedTimelineItems({
+        client,
+        agentId,
+        timeoutMs: options?.timeoutMs,
+        sinceTimestampMs: options?.sinceTimestampMs,
+    });
 }
 export function formatAgentActivityTranscript(timelineItems, tailCount) {
     if (tailCount === 0) {
@@ -21,6 +26,104 @@ export function formatAgentActivityTranscript(timelineItems, tailCount) {
     }
     return curateAgentActivity(timelineItems, tailCount !== undefined ? { maxItems: tailCount } : undefined);
 }
+const THOUGHT_PREFIX = "[Thought] ";
+function lastNonWhitespaceIndex(text) {
+    for (let index = text.length - 1; index >= 0; index -= 1) {
+        if (!/\s/.test(text[index])) {
+            return index;
+        }
+    }
+    return -1;
+}
+/**
+ * Follow mode receives one streaming fragment per event, while the one-shot
+ * transcript sees the whole timeline and merges consecutive assistant and
+ * reasoning fragments with exact concatenation (`projectTimelineRows`). Printing
+ * each fragment on its own line splits words at fragment boundaries and
+ * reprints the reasoning prefix, so a chain of fragments is written as one
+ * stream instead: text goes out as it arrives, and only the trailing whitespace
+ * is held back so the message ends trimmed the way the transcript does.
+ */
+export function createFollowTranscriptWriter(write = (chunk) => void process.stdout.write(chunk), filter) {
+    let pending = null;
+    const emit = (chain, text) => {
+        if (!chain.emitted) {
+            chain.emitted = true;
+            if (chain.type === "reasoning") {
+                write(THOUGHT_PREFIX);
+            }
+        }
+        write(text);
+    };
+    const flushContent = (chain) => {
+        if (!chain.emitted) {
+            chain.buffer = chain.buffer.replace(/^\s+/, "");
+        }
+        const lastContent = lastNonWhitespaceIndex(chain.buffer);
+        if (lastContent < 0) {
+            return;
+        }
+        emit(chain, chain.buffer.slice(0, lastContent + 1));
+        chain.buffer = chain.buffer.slice(lastContent + 1);
+    };
+    const closePending = () => {
+        const chain = pending;
+        pending = null;
+        if (!chain) {
+            return;
+        }
+        const tail = chain.emitted ? chain.buffer.trimEnd() : chain.buffer.trim();
+        if (tail) {
+            emit(chain, tail);
+        }
+        if (chain.emitted) {
+            write("\n");
+        }
+    };
+    const continuesChain = (item, turnId) => {
+        if (!pending || pending.type !== item.type || pending.turnId !== turnId) {
+            return false;
+        }
+        if (item.type !== "assistant_message") {
+            return true;
+        }
+        return item.messageId === undefined || item.messageId === pending.messageId;
+    };
+    const startChain = (item, turnId) => {
+        closePending();
+        const chain = {
+            type: item.type,
+            turnId,
+            messageId: item.type === "assistant_message" ? item.messageId : undefined,
+            buffer: "",
+            emitted: false,
+        };
+        pending = chain;
+        return chain;
+    };
+    return {
+        push(item, turnId) {
+            if (!matchesFilter(item, filter)) {
+                closePending();
+                return;
+            }
+            if (item.type === "assistant_message" || item.type === "reasoning") {
+                const chain = continuesChain(item, turnId) && pending ? pending : startChain(item, turnId);
+                chain.buffer += item.text;
+                flushContent(chain);
+                return;
+            }
+            closePending();
+            const transcript = formatAgentActivityTranscript([item]);
+            if (transcript && transcript !== NO_ACTIVITY_MESSAGE) {
+                write(`${transcript}\n`);
+            }
+        },
+        end() {
+            closePending();
+        },
+    };
+}
 function parseTailCount(raw) {
     if (raw === undefined)
         return undefined;
@@ -30,6 +133,19 @@ function parseTailCount(raw) {
     }
     return parsed;
 }
+function parseSinceTimestamp(raw) {
+    if (raw === undefined)
+        return undefined;
+    const timestampMs = Date.parse(raw);
+    if (Number.isNaN(timestampMs)) {
+        throw {
+            code: "INVALID_TIMESTAMP",
+            message: `Invalid --since value: ${raw}`,
+            details: "Use a timestamp such as 2026-01-01T00:00:00Z.",
+        };
+    }
+    return timestampMs;
+}
 /**
  * Check if a timeline item matches the filter type
  */
@@ -59,6 +175,7 @@ export async function runLogsCommand(id, options, _command) {
         console.error("Usage: paseo agent logs <id>");
         process.exit(1);
     }
+    const sinceTimestampMs = parseSinceTimestamp(options.since);
     const client = await connectToDaemon({ target: options.daemonTarget });
     try {
         const fetchResult = await client.fetchAgent({ agentId: id });
@@ -77,11 +194,18 @@ export async function runLogsCommand(id, options, _command) {
                 await client.close().catch(() => { });
                 process.exit(1);
             }
-            await runFollowMode(client, resolvedId, options);
+            await runFollowMode({
+                client,
+                agentId: resolvedId,
+                options,
+                sinceTimestampMs,
+            });
             return;
         }
         // Fetch timeline directly via cursor RPC.
-        let timelineItems = await fetchAgentTimelineItems(client, resolvedId);
+        let timelineItems = await fetchAgentTimelineItems(client, resolvedId, {
+            sinceTimestampMs,
+        });
         // Apply filter
         if (options.filter) {
             timelineItems = timelineItems.filter((item) => matchesFilter(item, options.filter));
@@ -113,7 +237,7 @@ export async function runLogsCommand(id, options, _command) {
 /**
  * Follow mode: stream logs in real-time until interrupted
  */
-async function runFollowMode(client, agentId, options) {
+async function runFollowMode({ client, agentId, options, sinceTimestampMs, }) {
     const DEFAULT_FOLLOW_TAIL = 10;
     const tailCount = parseTailCount(options.tail) ?? DEFAULT_FOLLOW_TAIL;
     // First, get existing timeline.
@@ -121,6 +245,7 @@ async function runFollowMode(client, agentId, options) {
     try {
         existingItems = await fetchAgentTimelineItems(client, agentId, {
             timeoutMs: LIVE_HISTORY_FETCH_TIMEOUT_MS,
+            sinceTimestampMs,
         });
     }
     catch (error) {
@@ -139,35 +264,41 @@ async function runFollowMode(client, agentId, options) {
     }
     // Subscribe to new events
     const tailLabel = tailCount === 0 ? "no history" : `last ${tailCount} entr${tailCount === 1 ? "y" : "ies"}`;
+    const writer = createFollowTranscriptWriter(undefined, options.filter);
     const unsubscribe = client.subscribeAgentTimeline(agentId, (message) => {
         if (message.type === "agent.timeline.replacement") {
+            writer.end();
             console.log("\n[Timeline replaced; earlier output is no longer current]");
             return;
         }
         if (message.type === "agent.timeline.error") {
+            writer.end();
             console.error(`Timeline observation stopped: ${message.payload.error}`);
             return;
         }
         if (message.type === "agent.timeline.subscription_restored") {
+            writer.end();
             console.log("\n[Reconnected; live output resumed. Events may have been missed.]");
             return;
         }
         if (message.payload.event.type === "timeline") {
-            const item = message.payload.event.item;
-            // Apply filter
-            if (options.filter && !matchesFilter(item, options.filter)) {
+            const matchesSince = sinceTimestampMs === undefined || Date.parse(message.payload.timestamp) >= sinceTimestampMs;
+            if (!matchesSince) {
                 return;
             }
-            // Print each timeline item as it arrives using the curator format
-            const transcript = formatAgentActivityTranscript([item]);
-            if (transcript !== NO_ACTIVITY_MESSAGE) {
-                console.log(transcript);
-            }
+            const item = message.payload.event.item;
+            writer.push(item, message.payload.event.turnId);
+        }
+        else if (message.payload.event.type === "turn_completed" ||
+            message.payload.event.type === "turn_failed" ||
+            message.payload.event.type === "turn_canceled") {
+            writer.end();
         }
     });
     await unsubscribe.ready;
     console.log(`\n--- Following logs (${tailLabel}; Ctrl+C to stop) ---\n`);
     await waitForStop();
+    writer.end();
     unsubscribe();
     await client.close();
 }

package/dist/commands/agent/ls.d.ts

@@ -1,4 +1,5 @@
 import type { Command } from "commander";
+import type { AgentSnapshotPayload } from "@camerontaylor/paseo-protocol/messages";
 import { connectToDaemon } from "../../utils/client.js";
 import type { CommandOptions, ListResult, OutputSchema } from "../../output/index.js";
 type FetchAgentsOptions = NonNullable<Parameters<Awaited<ReturnType<typeof connectToDaemon>>["fetchAgents"]>[0]>;
@@ -22,6 +23,8 @@ export interface AgentLsOptions extends CommandOptions {
     all?: boolean;
     /** -g: List agents across all directories */
     global?: boolean;
+    /** --background: Include background workspace agents */
+    background?: boolean;
     /** Filter by specific status */
     status?: string;
     /** Filter by specific cwd */
@@ -31,14 +34,26 @@ export interface AgentLsOptions extends CommandOptions {
     /** Filter by thinking option ID */
     thinking?: string;
 }
-export declare function buildAgentLsFetchOptions(options: Pick<AgentLsOptions, "all" | "global" | "label" | "thinking">): FetchAgentsOptions;
+export declare function buildAgentLsFetchOptions(options: Pick<AgentLsOptions, "all" | "global" | "background" | "label" | "thinking">): FetchAgentsOptions;
+interface AgentLsClient {
+    fetchAgents(options?: FetchAgentsOptions): Promise<{
+        entries: {
+            agent: AgentSnapshotPayload;
+        }[];
+        pageInfo: {
+            nextCursor: string | null;
+        };
+    }>;
+    close(): Promise<void>;
+}
 /**
  * Agent ls command semantics:
  * - `paseo agent ls`    → active non-archived agents
  * - `paseo agent ls -g` → global non-archived agents
- * - `paseo agent ls -a` → active agents, including archived
+ * - `paseo agent ls -a` → all agents, including archived and background
  * - `paseo agent ls -ag` → global agents, including archived
  */
 export declare function runLsCommand(options: AgentLsOptions, _command: Command): Promise<AgentLsResult>;
+export declare function listAgents(options: AgentLsOptions, connect?: (options: Parameters<typeof connectToDaemon>[0]) => Promise<AgentLsClient>): Promise<AgentLsResult>;
 export {};
 //# sourceMappingURL=ls.d.ts.map

package/dist/commands/agent/ls.js

@@ -4,8 +4,9 @@ import { isSameOrDescendantPath } from "../../utils/paths.js";
 export function addLsOptions(cmd) {
     return cmd
         .description("List agents. By default excludes archived agents.")
-        .option("-a, --all", "Include archived agents")
+        .option("-a, --all", "Include archived and background agents")
         .option("-g, --global", "List agents across all directories")
+        .option("--background", "Include background workspace agents")
         .option("--label <key=value>", "Filter by label (can be used multiple times)", collectMultiple, [])
         .option("--thinking <id>", "Filter by thinking option ID");
 }
@@ -97,6 +98,9 @@ export function buildAgentLsFetchOptions(options) {
     if (options.all) {
         daemonFilter.includeArchived = true;
     }
+    if (options.background || options.all) {
+        daemonFilter.includeBackground = true;
+    }
     if (Object.keys(labelFilters).length > 0) {
         daemonFilter.labels = labelFilters;
     }
@@ -104,7 +108,7 @@ export function buildAgentLsFetchOptions(options) {
         daemonFilter.thinkingOptionId = normalizedThinkingOptionId;
     }
     const fetchOptions = {};
-    if (!options.global) {
+    if (!options.global && !options.all) {
         fetchOptions.scope = "active";
     }
     if (Object.keys(daemonFilter).length > 0) {
@@ -116,11 +120,14 @@ export function buildAgentLsFetchOptions(options) {
  * Agent ls command semantics:
  * - `paseo agent ls`    → active non-archived agents
  * - `paseo agent ls -g` → global non-archived agents
- * - `paseo agent ls -a` → active agents, including archived
+ * - `paseo agent ls -a` → all agents, including archived and background
  * - `paseo agent ls -ag` → global agents, including archived
  */
 export async function runLsCommand(options, _command) {
-    const client = await connectToDaemon({ target: options.daemonTarget });
+    return listAgents(options);
+}
+export async function listAgents(options, connect = connectToDaemon) {
+    const client = await connect({ target: options.daemonTarget });
     try {
         const normalizedThinkingOptionId = options.thinking?.trim();
         if (options.thinking !== undefined && !normalizedThinkingOptionId) {
@@ -131,8 +138,19 @@ export async function runLsCommand(options, _command) {
             throw error;
         }
         const labelFilters = parseLabelFilters(options.label);
-        const fetchPayload = await client.fetchAgents(buildAgentLsFetchOptions(options));
-        let agents = fetchPayload.entries.map((entry) => entry.agent);
+        const fetchOptions = buildAgentLsFetchOptions(options);
+        let agents = [];
+        let cursor;
+        // createdAt never changes, so agents cannot move past the cursor while the pages are read.
+        do {
+            const payload = await client.fetchAgents({
+                ...fetchOptions,
+                sort: [{ key: "created_at", direction: "desc" }],
+                page: { limit: 200, ...(cursor ? { cursor } : {}) },
+            });
+            agents.push(...payload.entries.map((entry) => entry.agent));
+            cursor = payload.pageInfo.nextCursor ?? undefined;
+        } while (cursor);
         // By default, exclude archived agents. `-a` includes them.
         if (!options.all) {
             agents = agents.filter((a) => !a.archivedAt);

package/dist/commands/agent/run.d.ts

@@ -1,5 +1,4 @@
 import { Command } from "commander";
-import { type DaemonClient } from "@camerontaylor/paseo-client/internal/daemon-client";
 import { connectToDaemon } from "../../utils/client.js";
 import type { CommandOptions, SingleResult, OutputSchema } from "../../output/index.js";
 import { type ResolvedProviderModel } from "../../utils/provider-model.js";
@@ -16,6 +15,7 @@ export interface AgentRunResult {
 /** Schema for agent run output */
 export declare const agentRunSchema: OutputSchema<AgentRunResult>;
 export interface AgentRunOptions extends CommandOptions {
+    wait?: boolean;
     background?: boolean;
     detach?: boolean;
     title?: string;
@@ -50,6 +50,7 @@ export declare function resolveStructuredResponseMessage(options: {
     agentId: string;
     lastMessage: string | null;
 }): Promise<string | null>;
+export declare function waitsForFinish(options: Pick<AgentRunOptions, "wait" | "background" | "detach">): boolean;
 interface RunWorkspace {
     id?: string;
     cwd: string;
@@ -77,18 +78,6 @@ interface ResolveRunThinkingOptionInput extends ResolvedProviderModel {
     cwd: string;
     thinking: string | undefined;
 }
-export declare function resolveRunThinkingOption(client: Pick<DaemonClient, "listProviderModels">, input: ResolveRunThinkingOptionInput): Promise<string | undefined>;
+export declare function resolveRunThinkingOption(client: Pick<ConnectedDaemonClient, "listProviderModels">, input: ResolveRunThinkingOptionInput): Promise<string | undefined>;
 export declare function runRunCommand(prompt: string, options: AgentRunOptions, _command: Command): Promise<SingleResult<AgentRunResult>>;
-export interface RunCallerLookupClient {
-    fetchAgent(options: {
-        agentId: string;
-    }): Promise<{
-        agent: {
-            id: string;
-        };
-    } | null>;
-}
-export declare function resolveRunCallerAgentId(client: RunCallerLookupClient, env?: {
-    PASEO_AGENT_ID?: string;
-}): Promise<string | undefined>;
 //# sourceMappingURL=run.d.ts.map

package/dist/commands/agent/run.js

@@ -1,6 +1,6 @@
 import { Option } from "commander";
 import { getStructuredAgentResponse, StructuredAgentResponseError, } from "@camerontaylor/paseo-server/agent-response";
-import { DaemonConnectionError } from "@camerontaylor/paseo-client/internal/daemon-client";
+import { resolveCallerAgentId } from "../../utils/caller-agent.js";
 import { connectToDaemon } from "../../utils/client.js";
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
@@ -14,10 +14,13 @@ export function addRunOptions(cmd) {
     return (cmd
         .description("Create and start an agent with a task")
         .argument("<prompt>", "The task/prompt for the agent")
-        .option("-d, --background", "Run in background")
+        .option("--no-wait", "Return immediately without waiting for completion")
+        // COMPAT(backgroundRunFlag): --background was the documented spelling of
+        // --no-wait. Added in v0.2.0; remove after 2027-04-01.
+        .addOption(new Option("-d, --background", "Legacy alias for --no-wait").hideHelp())
         // COMPAT(detachRunFlag): --detach used to mean background execution, not
         // ownership transfer. Added in v0.2.0; remove after 2027-01-17.
-        .addOption(new Option("--detach", "Legacy alias for --background").hideHelp())
+        .addOption(new Option("--detach", "Legacy alias for --no-wait").hideHelp())
         .option("--title <title>", "Assign a title to the agent")
         .addOption(new Option("--name <name>", "Hidden alias for --title").hideHelp())
         .option("--provider <provider>", "Agent provider, or provider/model (e.g. codex or codex/gpt-5.4)")
@@ -268,17 +271,20 @@ function validateRunOptions(prompt, options, outputSchema) {
             details: "Usage: paseo agent run [options] <prompt>",
         };
     }
+    if (options.background) {
+        console.error("Warning: --background (-d) is deprecated. Use --no-wait instead.");
+    }
     validateRunWorkspaceOptions(options);
-    if (outputSchema && runsInBackground(options)) {
+    if (outputSchema && !waitsForFinish(options)) {
         throw {
             code: "INVALID_OPTIONS",
-            message: "--output-schema cannot be used with --background",
+            message: "--output-schema cannot be used with --no-wait",
             details: "Structured output requires waiting for the agent to finish",
         };
     }
 }
-function runsInBackground(options) {
-    return Boolean(options.background || options.detach);
+export function waitsForFinish(options) {
+    return options.wait !== false && !options.background && !options.detach;
 }
 function parseWaitTimeoutOption(waitTimeout) {
     if (!waitTimeout)
@@ -397,7 +403,10 @@ async function resolveRunWorkspace(client, options, cwd, callerAgentId) {
     // TODO: thread the run `prompt` as firstAgentContext so workspace-level
     // title/branch generation picks up the task description (U8/U6 deferred).
     const source = buildRunWorkspaceSource(options, cwd);
-    const result = await client.createWorkspace({ source });
+    const result = await client.createWorkspace({
+        source,
+        ...(callerAgentId ? { callerAgentId } : {}),
+    });
     if (!result.workspace) {
         throw {
             code: "WORKSPACE_CREATE_FAILED",
@@ -448,7 +457,7 @@ export async function runRunCommand(prompt, options, _command) {
         const labels = parseRunLabels(options.label);
         const env = parseRunEnv(options.env);
         const requestEnv = Object.keys(env).length > 0 ? env : undefined;
-        const callerAgentId = await resolveRunCallerAgentId(client);
+        const callerAgentId = await resolveCallerAgentId(client);
         const workspace = await resolveRunWorkspace(client, options, cwd, callerAgentId);
         const workspaceId = workspace.id;
         const runCwd = workspace.cwd;
@@ -530,8 +539,8 @@ export async function runRunCommand(prompt, options, _command) {
             env: requestEnv,
             labels: Object.keys(labels).length > 0 ? labels : undefined,
         });
-        // Default run behavior is foreground: wait for completion unless background execution is set.
-        if (!runsInBackground(options)) {
+        // Default run behavior is foreground: wait for completion unless --no-wait is set.
+        if (waitsForFinish(options)) {
             const state = await client.waitForFinish(agent.id, waitTimeoutMs);
             await client.close();
             const finalAgent = state.final ?? agent;
@@ -562,22 +571,4 @@ export async function runRunCommand(prompt, options, _command) {
         throw error;
     }
 }
-// PASEO_AGENT_ID names an agent on the daemon that launched this shell. A run
-// sent to another daemon (--host or --home) has no caller there, so it runs as
-// a top-level agent instead of failing on an unknown caller.
-export async function resolveRunCallerAgentId(client, env = process.env) {
-    const agentId = env.PASEO_AGENT_ID?.trim();
-    if (!agentId) {
-        return undefined;
-    }
-    const caller = await client.fetchAgent({ agentId }).catch((error) => {
-        // A daemon without this agent answers with an error. A lost or timed-out
-        // connection is not an answer, so it must not drop the caller.
-        if (error instanceof DaemonConnectionError) {
-            throw error;
-        }
-        return null;
-    });
-    return caller?.agent.id === agentId ? agentId : undefined;
-}
 //# sourceMappingURL=run.js.map

package/dist/commands/agent/send.js

@@ -139,7 +139,10 @@ export async function runSendCommand(agentIdArg, prompt, options, _command) {
         // Read image files if provided
         const images = options.image && options.image.length > 0 ? await readImageFiles(options.image) : undefined;
         // Send the message
-        await client.sendAgentMessage(agentIdArg, promptInput, { images });
+        await client.sendAgentMessage(agentIdArg, promptInput, {
+            images,
+            sourceAgentId: process.env.PASEO_AGENT_ID?.trim() || undefined,
+        });
         // If --no-wait, return immediately
         if (options.wait === false) {
             await client.close();

package/dist/commands/permit/allow.d.ts

@@ -1,5 +1,6 @@
 import type { Command } from "commander";
-import type { AgentPermissionRequest } from "@camerontaylor/paseo-protocol/agent-types";
+import type { AgentPermissionRequest, AgentPermissionResponse } from "@camerontaylor/paseo-protocol/agent-types";
+import { connectToDaemon } from "../../utils/client.js";
 import type { CommandOptions, ListResult, OutputSchema } from "../../output/index.js";
 /** Permission response item for display */
 export interface PermissionResponseItem {
@@ -19,5 +20,19 @@ export interface PermitAllowOptions extends CommandOptions {
     input?: string;
     host?: string;
 }
-export declare function runAllowCommand(agentIdOrPrefix: string, reqId: string | undefined, options: PermitAllowOptions, _command: Command): Promise<PermitAllowResult>;
+export interface PermitClient {
+    fetchAgent(options: {
+        agentId: string;
+    }): Promise<{
+        agent: {
+            id: string;
+            pendingPermissions?: AgentPermissionRequest[];
+        };
+    } | null>;
+    respondToPermissionAndWait(agentId: string, requestId: string, response: AgentPermissionResponse): Promise<unknown>;
+    close(): Promise<void>;
+}
+export type PermitClientConnector = (options: Parameters<typeof connectToDaemon>[0]) => Promise<PermitClient>;
+export declare function createAllowCommand(connect?: PermitClientConnector): (agentIdOrPrefix: string, reqId: string | undefined, options: PermitAllowOptions, _command: Command) => Promise<PermitAllowResult>;
+export declare const runAllowCommand: (agentIdOrPrefix: string, reqId: string | undefined, options: PermitAllowOptions, _command: Command) => Promise<PermitAllowResult>;
 //# sourceMappingURL=allow.d.ts.map