@getpaseo/cli 0.1.101 → 0.1.102-beta.2

package/dist/commands/agent/attach.js

@@ -4,7 +4,7 @@ export function addAttachOptions(cmd) {
         .argument("<id>", "Agent ID (or prefix)");
 }
 import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
-import { fetchProjectedTimelineItems } from "../../utils/timeline.js";
+import { fetchProjectedTimelineItems, LIVE_HISTORY_FETCH_TIMEOUT_MS, } from "../../utils/timeline.js";
 /**
  * Format and print a timeline item to the terminal
  */
@@ -91,7 +91,7 @@ export async function runAttachCommand(id, options, _command) {
         process.exit(1);
     }
     try {
-        const fetchResult = await client.fetchAgent(id);
+        const fetchResult = await client.fetchAgent({ agentId: id });
         if (!fetchResult) {
             console.error(`Error: No agent found matching: ${id}`);
             console.error("Use `paseo ls` to list available agents");
@@ -107,6 +107,7 @@ export async function runAttachCommand(id, options, _command) {
             const timelineItems = await fetchProjectedTimelineItems({
                 client,
                 agentId: resolvedId,
+                timeoutMs: LIVE_HISTORY_FETCH_TIMEOUT_MS,
             });
             for (const item of timelineItems) {
                 printTimelineItem(item);

package/dist/commands/agent/delete.js

@@ -49,7 +49,7 @@ export async function runDeleteCommand(id, options, _command) {
             });
         }
         else if (id) {
-            const fetchResult = await client.fetchAgent(id);
+            const fetchResult = await client.fetchAgent({ agentId: id });
             if (!fetchResult) {
                 const error = {
                     code: "AGENT_NOT_FOUND",

package/dist/commands/agent/inspect.js

@@ -175,7 +175,7 @@ export async function runInspectCommand(agentIdArg, options, _command) {
         throw error;
     }
     try {
-        const fetchResult = await client.fetchAgent(agentIdArg);
+        const fetchResult = await client.fetchAgent({ agentId: agentIdArg });
         if (!fetchResult) {
             const error = {
                 code: "AGENT_NOT_FOUND",

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

@@ -11,7 +11,9 @@ 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): Promise<AgentTimelineItem[]>;
+export declare function fetchAgentTimelineItems(client: DaemonClient, agentId: string, options?: {
+    timeoutMs?: number;
+}): Promise<AgentTimelineItem[]>;
 export declare function formatAgentActivityTranscript(timelineItems: AgentTimelineItem[], tailCount?: number): string;
 export declare function runLogsCommand(id: string, options: AgentLogsOptions, _command: Command): Promise<AgentLogsResult>;
 //# sourceMappingURL=logs.d.ts.map

package/dist/commands/agent/logs.js

@@ -1,5 +1,5 @@
 import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
-import { fetchProjectedTimelineItems } from "../../utils/timeline.js";
+import { fetchProjectedTimelineItems, LIVE_HISTORY_FETCH_TIMEOUT_MS, } from "../../utils/timeline.js";
 import { curateAgentActivity } from "@getpaseo/server";
 export function addLogsOptions(cmd) {
     return cmd
@@ -11,8 +11,8 @@ export function addLogsOptions(cmd) {
         .option("--since <time>", "Show logs since timestamp");
 }
 export const NO_ACTIVITY_MESSAGE = "No activity to display.";
-export async function fetchAgentTimelineItems(client, agentId) {
-    return fetchProjectedTimelineItems({ client, agentId });
+export async function fetchAgentTimelineItems(client, agentId, options) {
+    return fetchProjectedTimelineItems({ client, agentId, timeoutMs: options?.timeoutMs });
 }
 export function formatAgentActivityTranscript(timelineItems, tailCount) {
     if (tailCount === 0) {
@@ -70,7 +70,7 @@ export async function runLogsCommand(id, options, _command) {
         process.exit(1);
     }
     try {
-        const fetchResult = await client.fetchAgent(id);
+        const fetchResult = await client.fetchAgent({ agentId: id });
         if (!fetchResult) {
             console.error(`Error: No agent found matching: ${id}`);
             console.error("Use `paseo ls` to list available agents");
@@ -124,7 +124,15 @@ async function runFollowMode(client, agentId, options) {
     const DEFAULT_FOLLOW_TAIL = 10;
     const tailCount = parseTailCount(options.tail) ?? DEFAULT_FOLLOW_TAIL;
     // First, get existing timeline.
-    let existingItems = await fetchAgentTimelineItems(client, agentId);
+    let existingItems = [];
+    try {
+        existingItems = await fetchAgentTimelineItems(client, agentId, {
+            timeoutMs: LIVE_HISTORY_FETCH_TIMEOUT_MS,
+        });
+    }
+    catch (error) {
+        console.warn("Warning: failed to fetch existing timeline", error);
+    }
     // Apply filter to existing items
     if (options.filter) {
         existingItems = existingItems.filter((item) => matchesFilter(item, options.filter));

package/dist/commands/agent/mode.js

@@ -31,7 +31,7 @@ export async function runModeCommand(id, mode, options, _command) {
     let client;
     try {
         client = await connectToDaemon({ host: options.host });
-        const fetchResult = await client.fetchAgent(id);
+        const fetchResult = await client.fetchAgent({ agentId: id });
         if (!fetchResult) {
             const error = {
                 code: "AGENT_NOT_FOUND",

package/dist/commands/agent/stop.js

@@ -55,7 +55,7 @@ export async function runStopCommand(id, options, _command) {
         }
         else if (id) {
             // Stop specific agent
-            const fetchResult = await client.fetchAgent(id);
+            const fetchResult = await client.fetchAgent({ agentId: id });
             if (!fetchResult) {
                 const error = {
                     code: "AGENT_NOT_FOUND",

package/dist/commands/agent/update.js

@@ -93,7 +93,7 @@ export async function runUpdateCommand(agentIdArg, options, _command) {
         throw error;
     }
     try {
-        const fetchResult = await client.fetchAgent(agentIdArg);
+        const fetchResult = await client.fetchAgent({ agentId: agentIdArg });
         if (!fetchResult) {
             const error = {
                 code: "AGENT_NOT_FOUND",
@@ -107,7 +107,7 @@ export async function runUpdateCommand(agentIdArg, options, _command) {
             ...(name ? { name } : {}),
             ...(Object.keys(labels).length > 0 ? { labels } : {}),
         });
-        const updatedResult = await client.fetchAgent(agentId);
+        const updatedResult = await client.fetchAgent({ agentId });
         if (!updatedResult) {
             throw new Error(`Agent not found after update: ${agentId}`);
         }

package/dist/commands/agent/wait.js

@@ -11,6 +11,7 @@ export const agentWaitSchema = {
     ],
 };
 const WAIT_ACTIVITY_PREVIEW_COUNT = 5;
+const WAIT_ACTIVITY_PREVIEW_TIMEOUT_MS = 2000;
 function appendRecentActivity(message, transcript) {
     if (!transcript || transcript.trim().length === 0) {
         return message;
@@ -19,7 +20,9 @@ function appendRecentActivity(message, transcript) {
 }
 async function getRecentActivityTranscript(client, agentId) {
     try {
-        const timelineItems = await fetchAgentTimelineItems(client, agentId);
+        const timelineItems = await fetchAgentTimelineItems(client, agentId, {
+            timeoutMs: WAIT_ACTIVITY_PREVIEW_TIMEOUT_MS,
+        });
         return formatAgentActivityTranscript(timelineItems, WAIT_ACTIVITY_PREVIEW_COUNT);
     }
     catch {

package/dist/commands/chat/shared.d.ts

@@ -8,7 +8,10 @@ export declare function connectChatClient(host?: string): Promise<{
     client: import("@getpaseo/client/internal/daemon-client").DaemonClient;
     daemonHost: string;
 }>;
-export declare function attachAgentNamesToMessages(client: Awaited<ReturnType<typeof connectToDaemon>>, messages: ChatMessageRow[]): Promise<ChatMessageRow[]>;
+export declare function attachAgentNamesToMessages(client: Awaited<ReturnType<typeof connectToDaemon>>, messages: ChatMessageRow[], options?: {
+    timeout?: number;
+    bestEffort?: boolean;
+}): Promise<ChatMessageRow[]>;
 export declare function toChatCommandError(code: string, action: string, err: unknown): CommandError;
 export declare function parseSinceValue(input?: string): string | undefined;
 export declare function parseTimeoutMs(input?: string): number | undefined;

package/dist/commands/chat/shared.js

@@ -16,7 +16,7 @@ export async function connectChatClient(host) {
         throw error;
     }
 }
-export async function attachAgentNamesToMessages(client, messages) {
+export async function attachAgentNamesToMessages(client, messages, options = {}) {
     const agentIds = new Set();
     for (const message of messages) {
         agentIds.add(message.author);
@@ -27,9 +27,19 @@ export async function attachAgentNamesToMessages(client, messages) {
     if (agentIds.size === 0) {
         return messages;
     }
-    const payload = await client.fetchAgents({
-        filter: { includeArchived: true },
-    });
+    let payload;
+    try {
+        payload = await client.fetchAgents({
+            filter: { includeArchived: true },
+            ...(typeof options.timeout === "number" ? { timeout: options.timeout } : {}),
+        });
+    }
+    catch (error) {
+        if (options.bestEffort) {
+            return messages;
+        }
+        throw error;
+    }
     const agentNames = new Map();
     for (const entry of payload.entries) {
         const title = entry.agent.title?.trim();

package/dist/commands/chat/wait.js

@@ -1,19 +1,34 @@
 import { attachAgentNamesToMessages, connectChatClient, parseTimeoutMs, toChatCommandError, } from "./shared.js";
 import { chatMessageSchema, toChatMessageRow } from "./schema.js";
+const CHAT_WAIT_PREFLIGHT_TIMEOUT_MS = 2000;
 export async function runWaitCommand(room, options, _command) {
+    const timeoutMs = parseTimeoutMs(options.timeout);
     const { client } = await connectChatClient(options.host);
+    const deadline = typeof timeoutMs === "number" ? Date.now() + timeoutMs : null;
+    const hasExplicitTimeout = deadline !== null;
+    const remainingTimeoutMs = () => deadline === null ? undefined : Math.max(1, deadline - Date.now());
     try {
         const latest = await client.readChatMessages({
             room,
             limit: 1,
+            ...(hasExplicitTimeout
+                ? {
+                    timeout: Math.min(remainingTimeoutMs() ?? 1, CHAT_WAIT_PREFLIGHT_TIMEOUT_MS),
+                }
+                : {}),
         });
         const afterMessageId = latest.messages[0]?.id;
         const payload = await client.waitForChatMessages({
             room,
             afterMessageId,
-            timeoutMs: parseTimeoutMs(options.timeout),
+            timeoutMs: remainingTimeoutMs() ?? timeoutMs,
         });
-        const messages = await attachAgentNamesToMessages(client, payload.messages.map(toChatMessageRow));
+        const messages = await attachAgentNamesToMessages(client, payload.messages.map(toChatMessageRow), hasExplicitTimeout
+            ? {
+                timeout: remainingTimeoutMs(),
+                bestEffort: true,
+            }
+            : {});
         return {
             type: "list",
             data: messages,

package/dist/commands/daemon/index.js

@@ -36,6 +36,8 @@ export function createDaemonCommand() {
         .option("--no-relay", "Disable relay on restarted daemon")
         .option("--no-mcp", "Disable Agent MCP on restarted daemon")
         .option("--no-inject-mcp", "Disable auto-injecting the Paseo MCP into created agents")
+        .option("--web-ui", "Enable the bundled daemon web UI on restarted daemon")
+        .option("--no-web-ui", "Disable the bundled daemon web UI on restarted daemon")
         .option("--hostnames <hosts>", 'Daemon hostnames (comma-separated, e.g. "myhost,.example.com" or "true" for any)')
         .addOption(new Option("--allowed-hosts <hosts>").hideHelp())
         .action(withOutput((...args) => {

package/dist/commands/daemon/local-daemon.d.ts

@@ -9,6 +9,7 @@ export interface DaemonStartOptions {
     relayUseTls?: boolean;
     mcp?: boolean;
     injectMcp?: boolean;
+    webUi?: boolean;
     hostnames?: string;
 }
 export interface LocalDaemonPidInfo {
@@ -47,6 +48,8 @@ export interface StopLocalDaemonResult {
     home: string;
     pid: number | null;
     forced: boolean;
+    usedLifecycleRpc: boolean;
+    reason: "not_running" | "lifecycle_shutdown_rpc" | "owner_pid_signal" | "owner_pid_sigkill";
     message: string;
 }
 export interface DetachedDaemonProcess extends Pick<ChildProcess, "once" | "pid" | "unref"> {

package/dist/commands/daemon/local-daemon.js

@@ -43,6 +43,12 @@ function buildRunnerArgs(options) {
     if (options.injectMcp === false) {
         args.push("--no-inject-mcp");
     }
+    if (options.webUi === true) {
+        args.push("--web-ui");
+    }
+    if (options.webUi === false) {
+        args.push("--no-web-ui");
+    }
     return args;
 }
 function buildChildEnv(options) {
@@ -62,6 +68,12 @@ function buildChildEnv(options) {
     if (options.relayUseTls === true) {
         childEnv.PASEO_RELAY_USE_TLS = "true";
     }
+    if (options.webUi === true) {
+        childEnv.PASEO_WEB_UI_ENABLED = "true";
+    }
+    if (options.webUi === false) {
+        childEnv.PASEO_WEB_UI_ENABLED = "false";
+    }
     return childEnv;
 }
 function resolveServerRunnerFromDir(currentDir) {
@@ -115,6 +127,13 @@ function resolveStopMessage(forced, lifecycleRequested, fallbackMessage) {
         return "Daemon stopped gracefully";
     return fallbackMessage ?? "Daemon stopped via owner PID signal";
 }
+function resolveStopReason(forced, lifecycleRequested) {
+    if (forced)
+        return "owner_pid_sigkill";
+    if (lifecycleRequested)
+        return "lifecycle_shutdown_rpc";
+    return "owner_pid_signal";
+}
 function readPidFile(pidPath) {
     try {
         const parsed = JSON.parse(readFileSync(pidPath, "utf-8"));
@@ -285,6 +304,8 @@ function createNotRunningStopResult(state, pid, message) {
         home: state.home,
         pid,
         forced: false,
+        usedLifecycleRpc: false,
+        reason: "not_running",
         message,
     };
 }
@@ -455,7 +476,9 @@ async function requestLifecycleShutdown(state, timeoutMs) {
             reason: "daemon listen target is not TCP, falling back to owner PID signal",
         };
     }
-    const client = await tryConnectToDaemon({ host, timeout: Math.min(timeoutMs, 5000) });
+    const deadline = Date.now() + timeoutMs;
+    const remainingTimeoutMs = () => Math.max(1, deadline - Date.now());
+    const client = await tryConnectToDaemon({ host, timeout: Math.min(remainingTimeoutMs(), 5000) });
     if (!client) {
         return {
             requested: false,
@@ -463,7 +486,7 @@ async function requestLifecycleShutdown(state, timeoutMs) {
         };
     }
     try {
-        await client.shutdownServer();
+        await client.shutdownServer({ timeout: Math.min(remainingTimeoutMs(), 5000) });
         return { requested: true };
     }
     catch (error) {
@@ -480,7 +503,9 @@ export async function stopLocalDaemon(options = {}) {
     const timeoutMs = options.timeoutMs ?? DEFAULT_STOP_TIMEOUT_MS;
     const killTimeoutMs = options.killTimeoutMs ?? DEFAULT_KILL_TIMEOUT_MS;
     const state = resolveLocalDaemonState({ home: options.home });
-    const shutdownAttempt = await requestLifecycleShutdown(state, timeoutMs);
+    const deadline = Date.now() + timeoutMs;
+    const remainingTimeoutMs = () => Math.max(1, deadline - Date.now());
+    const shutdownAttempt = await requestLifecycleShutdown(state, remainingTimeoutMs());
     const lifecycleRequested = shutdownAttempt.requested;
     if (!state.pidInfo || (!state.running && !lifecycleRequested)) {
         const staleSuffix = state.stalePidFile && state.pidInfo ? ` (stale PID file for ${state.pidInfo.pid})` : "";
@@ -496,7 +521,7 @@ export async function stopLocalDaemon(options = {}) {
     const { stopped, forced } = await waitForStopAfterRequest({
         state,
         pid,
-        timeoutMs,
+        timeoutMs: remainingTimeoutMs(),
         killTimeoutMs,
         force: options.force,
     });
@@ -511,6 +536,8 @@ export async function stopLocalDaemon(options = {}) {
         home: state.home,
         pid,
         forced,
+        usedLifecycleRpc: lifecycleRequested,
+        reason: resolveStopReason(forced, lifecycleRequested),
         message: resolveStopMessage(forced, lifecycleRequested, fallbackMessage),
     };
 }

package/dist/commands/daemon/pair.js

@@ -4,6 +4,7 @@ import { generateLocalPairingOffer, loadConfig, resolvePaseoHome } from "@getpas
 import { tryConnectToDaemon } from "../../utils/client.js";
 import { resolveLocalDaemonState, resolveTcpHostFromListen } from "./local-daemon.js";
 import { addJsonOption } from "../../utils/command-options.js";
+const PAIRING_DAEMON_RPC_TIMEOUT_MS = 1500;
 export function pairCommand() {
     return addJsonOption(new Command("pair").description("Print the daemon pairing QR code and link"))
         .option("--home <path>", "Paseo home directory (default: ~/.paseo)")
@@ -25,7 +26,9 @@ export async function runPairCommand(options) {
             const supportsDaemonStatusRpc = client.getLastServerInfoMessage()?.features?.daemonStatusRpc === true;
             if (supportsDaemonStatusRpc) {
                 try {
-                    const offer = await client.getDaemonPairingOffer();
+                    const offer = await client.getDaemonPairingOffer({
+                        timeout: PAIRING_DAEMON_RPC_TIMEOUT_MS,
+                    });
                     await client.close().catch(() => { });
                     outputPairingResult({ relayEnabled: offer.relayEnabled, url: offer.url, qr: offer.qr ?? null }, options);
                     return;

package/dist/commands/daemon/restart.js

@@ -35,6 +35,7 @@ function toStartOptions(options) {
         relay: typeof options.relay === "boolean" ? options.relay : undefined,
         mcp: typeof options.mcp === "boolean" ? options.mcp : undefined,
         injectMcp: typeof options.injectMcp === "boolean" ? options.injectMcp : undefined,
+        webUi: typeof options.webUi === "boolean" ? options.webUi : undefined,
         hostnames: typeof options.hostnames === "string" ? options.hostnames : undefined,
     };
     if (startOptions.listen && startOptions.port) {

package/dist/commands/daemon/start.js

@@ -13,6 +13,8 @@ export function startCommand() {
         .option("--relay-use-tls", "Use wss:// for the relay connection and pairing offers")
         .option("--no-mcp", "Disable the Agent MCP HTTP endpoint")
         .option("--no-inject-mcp", "Disable auto-injecting the Paseo MCP into created agents")
+        .option("--web-ui", "Enable the bundled daemon web UI")
+        .option("--no-web-ui", "Disable the bundled daemon web UI")
         .option("--hostnames <hosts>", 'Daemon hostnames (comma-separated, e.g. "myhost,.example.com" or "true" for any)')
         .addOption(new Option("--allowed-hosts <hosts>").hideHelp())
         .action(async (options) => {

package/dist/commands/daemon/status.js

@@ -3,6 +3,7 @@ import { getOrCreateServerId, findExecutable, execCommand } from "@getpaseo/serv
 import { connectToDaemon } from "../../utils/client.js";
 import { resolveLocalDaemonState, resolveTcpHostFromListen } from "./local-daemon.js";
 import { resolveNodePathFromPid } from "./runtime-toolchain.js";
+const DAEMON_STATUS_PROBE_TIMEOUT_MS = 1500;
 const require = createRequire(import.meta.url);
 function normalizeError(error) {
     if (error instanceof Error) {
@@ -91,18 +92,6 @@ function toStatusRows(status) {
         { key: "CLI", value: status.cliVersion },
         { key: "Daemon Version", value: status.daemonVersion ?? "-" },
     ];
-    if (status.runningAgents !== null && status.idleAgents !== null) {
-        rows.push({
-            key: "Agents",
-            value: `${status.runningAgents} running, ${status.idleAgents} idle`,
-        });
-    }
-    else {
-        rows.push({
-            key: "Agents",
-            value: `Unavailable (${status.agentsUnavailableReason ?? "daemon API not reachable"})`,
-        });
-    }
     if (status.note) {
         rows.push({ key: "Note", value: status.note });
     }
@@ -179,11 +168,6 @@ function describeDaemonAuthProbeFailure(host, failure) {
     }
     return `Daemon is reachable at ${host} but the supplied password was rejected. Check PASEO_PASSWORD and retry.`;
 }
-function describeAgentsUnavailableReason(failure) {
-    if (failure === "auth_required")
-        return "password required";
-    return "incorrect password";
-}
 async function probeDaemonOverWebsocket(args) {
     const { host, state } = args;
     let client;
@@ -195,7 +179,6 @@ async function probeDaemonOverWebsocket(args) {
         if (authFailure) {
             return {
                 connectedDaemon: authFailure,
-                agentsUnavailableReason: describeAgentsUnavailableReason(authFailure),
                 note: describeDaemonAuthProbeFailure(host, authFailure),
             };
         }
@@ -209,37 +192,22 @@ async function probeDaemonOverWebsocket(args) {
         return { connectedDaemon: "unreachable" };
     }
     const daemonVersion = client.getLastServerInfoMessage()?.version ?? null;
-    const supportsDaemonStatusRpc = client.getLastServerInfoMessage()?.features?.daemonStatusRpc === true;
     try {
-        const agentsPayload = await client.fetchAgents({ filter: { includeArchived: true } });
-        const agents = agentsPayload.entries.map((entry) => entry.agent);
-        const runningAgents = agents.filter((a) => a.status === "running").length;
-        const idleAgents = agents.filter((a) => a.status === "idle").length;
-        let daemonProviders;
-        if (supportsDaemonStatusRpc) {
-            try {
-                const statusPayload = await client.getDaemonStatus();
-                const labelMap = new Map(PROVIDER_BINARIES.map((p) => [p.binary, p.label]));
-                daemonProviders = statusPayload.providers.map((p) => ({
-                    label: labelMap.get(p.provider) ?? p.provider,
-                    path: p.available ? "available" : null,
-                    version: p.available ? null : (p.error ?? null),
-                    source: "daemon",
-                }));
-            }
-            catch {
-                // COMPAT(daemon-rpc-rollout): fall back to CLI-side provider resolution while
-                // old daemons lack daemonStatusRpc. Remove once the daemon floor is past
-                // v0.1.76; status should come from daemon.get_status.
-            }
-        }
+        const statusPayload = await client.getDaemonStatus({
+            timeout: DAEMON_STATUS_PROBE_TIMEOUT_MS,
+        });
+        const labelMap = new Map(PROVIDER_BINARIES.map((p) => [p.binary, p.label]));
+        const daemonProviders = statusPayload.providers.map((p) => ({
+            label: labelMap.get(p.provider) ?? p.provider,
+            path: p.available ? "available" : null,
+            version: p.available ? null : (p.error ?? null),
+            source: "daemon",
+        }));
         if (!state.running) {
             return {
                 connectedDaemon: "reachable",
-                daemonVersion,
-                runningAgents,
-                idleAgents,
-                daemonNodeOverride: "unknown (API reachable, PID unresolved)",
+                daemonVersion: statusPayload.version ?? daemonVersion,
+                daemonNodeOverride: statusPayload.nodePath,
                 daemonProviders,
                 note: state.pidInfo
                     ? `Connected daemon is reachable at ${host} even though local daemon PID ${state.pidInfo.pid} is stale`
@@ -248,9 +216,8 @@ async function probeDaemonOverWebsocket(args) {
         }
         return {
             connectedDaemon: "reachable",
-            daemonVersion,
-            runningAgents,
-            idleAgents,
+            daemonVersion: statusPayload.version ?? daemonVersion,
+            daemonNodeOverride: statusPayload.nodePath,
             daemonProviders,
         };
     }
@@ -258,10 +225,9 @@ async function probeDaemonOverWebsocket(args) {
         return {
             connectedDaemon: "reachable",
             daemonVersion,
-            localDaemonOverride: state.running ? "unresponsive" : undefined,
             note: state.running
-                ? `Local daemon PID is running but API requests to ${host} failed`
-                : `Connected daemon websocket is reachable at ${host} but fetch_agents failed`,
+                ? `Local daemon PID is running but daemon detail request to ${host} failed`
+                : `Connected daemon websocket is reachable at ${host} but daemon status request failed`,
         };
     }
     finally {
@@ -275,10 +241,7 @@ function applyProbeToStatus(input) {
         localDaemon: probe.localDaemonOverride ?? input.localDaemon,
         daemonNode: probe.daemonNodeOverride ?? input.daemonNode,
         daemonVersion: probe.daemonVersion !== undefined ? probe.daemonVersion : input.daemonVersion,
-        runningAgents: probe.runningAgents !== undefined ? probe.runningAgents : input.runningAgents,
-        idleAgents: probe.idleAgents !== undefined ? probe.idleAgents : input.idleAgents,
         daemonProviders: probe.daemonProviders ?? input.daemonProviders,
-        agentsUnavailableReason: probe.agentsUnavailableReason ?? input.agentsUnavailableReason,
         note: probe.note ? appendNote(input.note, probe.note) : input.note,
     };
 }
@@ -316,11 +279,8 @@ export async function runStatusCommand(options, _command) {
     const cliNode = process.execPath;
     let localDaemon = state.running ? "running" : "stopped";
     let connectedDaemon = "not_probed";
-    let runningAgents = null;
-    let idleAgents = null;
     let daemonVersion = null;
     let daemonProviders;
-    let agentsUnavailableReason;
     let note;
     if (!state.running && state.stalePidFile && state.pidInfo) {
         localDaemon = "stale_pid";
@@ -328,28 +288,16 @@ export async function runStatusCommand(options, _command) {
     }
     if (host) {
         const probe = await probeDaemonOverWebsocket({ host, state });
-        ({
-            connectedDaemon,
-            localDaemon,
-            daemonNode,
-            daemonVersion,
-            runningAgents,
-            idleAgents,
-            daemonProviders,
-            agentsUnavailableReason,
-            note,
-        } = applyProbeToStatus({
-            probe,
-            connectedDaemon,
-            localDaemon,
-            daemonNode,
-            daemonVersion,
-            runningAgents,
-            idleAgents,
-            daemonProviders,
-            agentsUnavailableReason,
-            note,
-        }));
+        ({ connectedDaemon, localDaemon, daemonNode, daemonVersion, daemonProviders, note } =
+            applyProbeToStatus({
+                probe,
+                connectedDaemon,
+                localDaemon,
+                daemonNode,
+                daemonVersion,
+                daemonProviders,
+                note,
+            }));
     }
     else {
         note = appendNote(note, "Daemon is configured for unix socket listen; API probe skipped");
@@ -373,15 +321,12 @@ export async function runStatusCommand(options, _command) {
         startedAt: state.pidInfo?.startedAt ?? null,
         owner,
         logPath: state.logPath,
-        runningAgents,
-        idleAgents,
         daemonNode,
         cliNode,
         cliVersion,
         daemonVersion,
         desktopManaged: state.pidInfo?.desktopManaged === true,
         providers,
-        agentsUnavailableReason,
         note,
     };
     return {

package/dist/commands/daemon/stop.d.ts

@@ -5,6 +5,8 @@ interface StopResult {
     home: string;
     pid: string;
     forced: boolean;
+    usedLifecycleRpc: boolean;
+    reason: "not_running" | "lifecycle_shutdown_rpc" | "owner_pid_signal" | "owner_pid_sigkill";
     message: string;
 }
 export type StopCommandResult = SingleResult<StopResult>;

package/dist/commands/daemon/stop.js

@@ -41,6 +41,8 @@ export async function runStopCommand(options, _command) {
                 home: result.home,
                 pid: result.pid === null ? "-" : String(result.pid),
                 forced: result.forced,
+                usedLifecycleRpc: result.usedLifecycleRpc,
+                reason: result.reason,
                 message: result.message,
             },
             schema: stopResultSchema,

package/dist/commands/onboard.js

@@ -6,6 +6,7 @@ import { generateLocalPairingOffer, loadConfig, loadPersistedConfig, } from "@ge
 import { resolveLocalPaseoHome, resolveLocalDaemonState, resolveTcpHostFromListen, startLocalDaemonDetached, tailDaemonLog, } from "./daemon/local-daemon.js";
 import { tryConnectToDaemon } from "../utils/client.js";
 const DEFAULT_READY_TIMEOUT_MS = 10 * 60 * 1000;
+const READY_PROBE_TIMEOUT_MS = 1200;
 class OnboardCancelledError extends Error {
 }
 const plainNoteFormat = (line) => line;
@@ -129,14 +130,21 @@ function renderProgressLine(progress) {
     }
     return `Downloading speech model${modelSuffix}: ${progress.pct}%`;
 }
-async function probeDaemonReady(home) {
+async function probeDaemonReady(home, timeoutMs) {
     const state = resolveLocalDaemonState({ home });
     const host = resolveTcpHostFromListen(state.listen);
+    const deadline = Date.now() + timeoutMs;
+    const remainingTimeoutMs = () => Math.max(1, deadline - Date.now());
     if (state.running && host) {
-        const client = await tryConnectToDaemon({ host, timeout: 1200 });
+        const client = await tryConnectToDaemon({
+            host,
+            timeout: Math.min(remainingTimeoutMs(), READY_PROBE_TIMEOUT_MS),
+        });
         if (client) {
             try {
-                await client.fetchAgents();
+                await client.fetchAgents({
+                    timeout: Math.min(remainingTimeoutMs(), READY_PROBE_TIMEOUT_MS),
+                });
                 return { kind: "ready", listen: state.listen, host };
             }
             catch {
@@ -168,20 +176,26 @@ function announceProgress(home, state, onStatus) {
 }
 async function waitForDaemonReady(args) {
     const deadline = Date.now() + args.timeoutMs;
+    const createTimeoutError = () => {
+        const recentLogs = tailDaemonLog(args.home, 60);
+        return new Error([
+            `Timed out after ${Math.ceil(args.timeoutMs / 1000)}s waiting for daemon readiness.`,
+            recentLogs ? `Recent daemon logs:\n${recentLogs}` : null,
+        ]
+            .filter(Boolean)
+            .join("\n\n"));
+    };
     async function poll(state) {
-        const probe = await probeDaemonReady(args.home);
+        if (Date.now() >= deadline) {
+            throw createTimeoutError();
+        }
+        const probe = await probeDaemonReady(args.home, Math.max(1, deadline - Date.now()));
         if (probe.kind === "ready") {
             return { listen: probe.listen, host: probe.host };
         }
         const nextState = announceProgress(args.home, state, args.onStatus);
         if (Date.now() >= deadline) {
-            const recentLogs = tailDaemonLog(args.home, 60);
-            throw new Error([
-                `Timed out after ${Math.ceil(args.timeoutMs / 1000)}s waiting for daemon readiness.`,
-                recentLogs ? `Recent daemon logs:\n${recentLogs}` : null,
-            ]
-                .filter(Boolean)
-                .join("\n\n"));
+            throw createTimeoutError();
         }
         await sleep(200);
         return poll(nextState);

package/dist/commands/permit/allow.js

@@ -52,7 +52,7 @@ export async function runAllowCommand(agentIdOrPrefix, reqId, options, _command)
         throw error;
     }
     try {
-        const fetchResult = await client.fetchAgent(agentIdOrPrefix);
+        const fetchResult = await client.fetchAgent({ agentId: agentIdOrPrefix });
         if (!fetchResult) {
             await client.close();
             const error = {

package/dist/commands/permit/deny.js

@@ -25,7 +25,7 @@ export async function runDenyCommand(agentIdOrPrefix, reqId, options, _command)
         throw error;
     }
     try {
-        const fetchResult = await client.fetchAgent(agentIdOrPrefix);
+        const fetchResult = await client.fetchAgent({ agentId: agentIdOrPrefix });
         if (!fetchResult) {
             await client.close();
             const error = {

package/dist/utils/timeline.d.ts

@@ -1,8 +1,10 @@
 import type { DaemonClient } from "@getpaseo/client/internal/daemon-client";
 import type { AgentTimelineItem } from "@getpaseo/protocol/agent-types";
+export declare const LIVE_HISTORY_FETCH_TIMEOUT_MS = 2000;
 interface FetchProjectedTimelineItemsInput {
     client: DaemonClient;
     agentId: string;
+    timeoutMs?: number;
 }
 export declare function fetchProjectedTimelineItems(input: FetchProjectedTimelineItemsInput): Promise<AgentTimelineItem[]>;
 export {};

package/dist/utils/timeline.js

@@ -1,8 +1,10 @@
+export const LIVE_HISTORY_FETCH_TIMEOUT_MS = 2000;
 export async function fetchProjectedTimelineItems(input) {
     const timeline = await input.client.fetchAgentTimeline(input.agentId, {
         direction: "tail",
         limit: 0,
         projection: "projected",
+        timeout: input.timeoutMs,
     });
     return timeline.entries.map((entry) => entry.item);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/cli",
-  "version": "0.1.101",
+  "version": "0.1.102-beta.2",
   "description": "Paseo CLI - control your AI coding agents from the command line",
   "bin": {
     "paseo": "bin/paseo"
@@ -27,9 +27,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.0.0",
-    "@getpaseo/client": "0.1.101",
-    "@getpaseo/protocol": "0.1.101",
-    "@getpaseo/server": "0.1.101",
+    "@getpaseo/client": "0.1.102-beta.2",
+    "@getpaseo/protocol": "0.1.102-beta.2",
+    "@getpaseo/server": "0.1.102-beta.2",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "mime-types": "^2.1.35",