@skrr-ai/cli 0.1.40 → 0.1.42

package/dist/commands/token/list.d.ts

@@ -11,11 +11,19 @@ import { BaseCommand } from '../../base-command';
  *
  * `GET /api/auth/sessions/refresh` has served exactly this list all along; it
  * was simply not reachable from the CLI.
+ *
+ * The server returns at most `--limit` rows and says whether it left any out.
+ * It used to stop at 100 without saying so, and the session somebody went
+ * looking for — an old daemon's, still holding the login a purge refusal named
+ * — was exactly the one past the cut (OSK-9980). So a partial list says it is
+ * partial, and `--kind daemon` is the short way to the row that matters.
  */
 export default class TokenList extends BaseCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        kind: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        limit: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;

package/dist/commands/token/list.js

@@ -4,6 +4,7 @@ const core_1 = require("@oclif/core");
 const base_command_1 = require("../../base-command");
 const api_fetch_1 = require("../../lib/api-fetch");
 const format_1 = require("../../lib/format");
+const SESSION_KINDS = ['web', 'daemon', 'cli', 'ci'];
 /**
  * `skrr token list`
  *
@@ -16,20 +17,44 @@ const format_1 = require("../../lib/format");
  *
  * `GET /api/auth/sessions/refresh` has served exactly this list all along; it
  * was simply not reachable from the CLI.
+ *
+ * The server returns at most `--limit` rows and says whether it left any out.
+ * It used to stop at 100 without saying so, and the session somebody went
+ * looking for — an old daemon's, still holding the login a purge refusal named
+ * — was exactly the one past the cut (OSK-9980). So a partial list says it is
+ * partial, and `--kind daemon` is the short way to the row that matters.
  */
 class TokenList extends base_command_1.BaseCommand {
     static description = 'List the active sessions a minted token belongs to — the other half of `token mint`';
     static examples = [
         '<%= config.bin %> token list',
-        '<%= config.bin %> token list --json',
+        '<%= config.bin %> token list --kind daemon',
+        '<%= config.bin %> token list --kind cli --limit 500 --json',
     ];
-    static flags = { json: core_1.Flags.boolean({ description: 'Output JSON' }) };
+    static flags = {
+        kind: core_1.Flags.string({
+            description: 'Only sessions of this kind',
+            options: [...SESSION_KINDS],
+        }),
+        limit: core_1.Flags.integer({
+            description: 'Most sessions to list (server maximum 500)',
+            min: 1,
+            max: 500,
+        }),
+        json: core_1.Flags.boolean({ description: 'Output JSON' }),
+    };
     async run() {
         this.requireAuth();
         const { flags } = await this.parse(TokenList);
+        const query = new URLSearchParams();
+        if (flags.kind)
+            query.set('kind', flags.kind);
+        if (flags.limit)
+            query.set('limit', String(flags.limit));
+        const suffix = query.toString() ? `?${query.toString()}` : '';
         let data = null;
         try {
-            data = await (0, api_fetch_1.apiFetch)('/api/auth/sessions/refresh', {
+            data = await (0, api_fetch_1.apiFetch)(`/api/auth/sessions/refresh${suffix}`, {
                 method: 'GET',
                 credential: this.resolvedCredential,
             });
@@ -37,9 +62,17 @@ class TokenList extends base_command_1.BaseCommand {
         catch (err) {
             this.handleApiError(err);
         }
-        const sessions = data?.sessions || [];
-        if (flags.json)
-            return this.log(JSON.stringify({ sessions, count: sessions.length }, null, 2));
+        // Filtered here as well: a server from before `kind` existed ignores the
+        // parameter and returns every kind, and `--kind daemon` must never list a
+        // web session as if it were one.
+        const sessions = (data?.sessions || []).filter((session) => !flags.kind || session.kind === flags.kind);
+        // A server from before `hasMore` stopped at 100 and said nothing about it,
+        // and ignores `--limit` too — so it gets its own, weaker statement.
+        const olderServer = data?.hasMore === undefined;
+        const hasMore = olderServer ? (data?.sessions?.length ?? 0) >= 100 : data?.hasMore === true;
+        if (flags.json) {
+            return this.log(JSON.stringify({ sessions, count: sessions.length, hasMore }, null, 2));
+        }
         if (!sessions.length)
             return this.log('No active sessions.');
         (0, format_1.renderTable)(sessions.map((session) => ({
@@ -48,6 +81,8 @@ class TokenList extends base_command_1.BaseCommand {
             // The operator's own name for the credential wins over a derived
             // device string — it is what they would search by.
             device: session.label || session.device || '-',
+            // What `instructions`, `machines` and a purge refusal call it.
+            daemon: session.daemonId || '-',
             ip: session.ip || '-',
             lastActive: session.lastActiveAt || session.createdAt || '-',
             // The session you are typing in. Revoking it signs THIS machine out,
@@ -57,11 +92,21 @@ class TokenList extends base_command_1.BaseCommand {
             { key: 'id', header: 'ID' },
             { key: 'kind', header: 'KIND' },
             { key: 'device', header: 'DEVICE', maxWidth: 34 },
+            { key: 'daemon', header: 'DAEMON', maxWidth: 40 },
             { key: 'ip', header: 'IP' },
             { key: 'lastActive', header: 'LAST ACTIVE' },
             { key: 'current', header: 'CURRENT' },
         ], (line) => this.log(line));
         this.log('');
+        if (hasMore && olderServer) {
+            this.log('This server lists at most 100 sessions and does not say whether it left any out, so older ones may be missing.');
+        }
+        else if (hasMore) {
+            const remedy = flags.kind
+                ? 'Raise --limit (up to 500) to see them.'
+                : 'Narrow the list with --kind, or raise --limit (up to 500).';
+            this.log(`Showing the ${sessions.length} most recently active sessions; older ones were left out. ${remedy}`);
+        }
         this.log('Retire one with: skrr token revoke <id>');
     }
 }

package/dist/help.js

@@ -46,26 +46,22 @@ class SkrrHelp extends core_1.Help {
      */
     async showRootHelp() {
         this.log('GETTING STARTED');
-        this.log('  skrr login             Sign in. Offers to set this machine up if it has no runtime.');
-        this.log('  skrr daemon install    Install the runtime by hand (fetches the signed release).');
+        this.log('  skrr login             Sign in. Offers to install the background service if this computer has none.');
+        this.log('  skrr daemon install    Install the background service by hand (fetches the signed release).');
         this.log('');
         return super.showRootHelp();
     }
     async showHelp(argv) {
-        // Mirror oclif's own id resolution: the topic separator is a space here, so
-        // the id is the leading non-flag tokens joined with `:`.
-        const tokens = [];
-        for (const token of argv) {
-            if (token.startsWith('-'))
-                break;
-            tokens.push(token);
-        }
-        const id = tokens.join(':');
+        // Resolve the id exactly as running the same words would — a word after a
+        // command that takes arguments is an argument, not part of the name
+        // (OSK-10099: `harnesses install devin --help` was refused).
+        const lookup = (0, command_miss_1.lookupFromConfig)(this.config);
+        const id = (0, command_miss_1.helpSubjectId)(argv, lookup);
         // A bare topic (`skrr daemon`) has no command but DOES have help to show,
         // so it must fall through — only an id that is neither a command nor a
         // topic is a miss.
         if (id && !this.config.findCommand(id) && !this.config.findTopic(id)) {
-            throw new Error((0, command_miss_1.describeCommandMiss)((0, command_miss_1.lookupFromConfig)(this.config), id));
+            throw new Error((0, command_miss_1.describeCommandMiss)(lookup, id));
         }
         return super.showHelp(argv);
     }

package/dist/lib/agent-home-workspace.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The workspace an `agents chat` turn runs in when the caller named none.
+ *
+ * A turn with no workspace context reaches the server without `X-Workspace-Id`.
+ * The server lets it through after checking membership in the agent's own
+ * workspace, but the agent runtime then has no workspace, so the shared
+ * workspace memory tier refuses with "no workspace context" (OSK-9937). By
+ * owner decision the CLI now uses the agent's home workspace in that case: the
+ * same thing the web app sends, and the only workspace the server would accept
+ * for that agent anyway.
+ *
+ * Never applied when anything already chose: `--workspace`, an exported
+ * `OVERSKY_WORKSPACE_ID`, or `skrr workspaces use` (all arrive as that env var),
+ * and never inside an autonomous Agent process, whose workspace belongs to its
+ * daemon session.
+ */
+export declare function applyAgentHomeWorkspaceDefault(agentId: string, lookup: (agentId: string) => Promise<{
+    workspaceId?: string | null;
+} | null | undefined>, env?: NodeJS.ProcessEnv): Promise<string | null>;

package/dist/lib/agent-home-workspace.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyAgentHomeWorkspaceDefault = applyAgentHomeWorkspaceDefault;
+/**
+ * The workspace an `agents chat` turn runs in when the caller named none.
+ *
+ * A turn with no workspace context reaches the server without `X-Workspace-Id`.
+ * The server lets it through after checking membership in the agent's own
+ * workspace, but the agent runtime then has no workspace, so the shared
+ * workspace memory tier refuses with "no workspace context" (OSK-9937). By
+ * owner decision the CLI now uses the agent's home workspace in that case: the
+ * same thing the web app sends, and the only workspace the server would accept
+ * for that agent anyway.
+ *
+ * Never applied when anything already chose: `--workspace`, an exported
+ * `OVERSKY_WORKSPACE_ID`, or `skrr workspaces use` (all arrive as that env var),
+ * and never inside an autonomous Agent process, whose workspace belongs to its
+ * daemon session.
+ */
+async function applyAgentHomeWorkspaceDefault(agentId, lookup, env = process.env) {
+    if (env.OVERSKY_AUTONOMOUS_SESSION === '1')
+        return null;
+    if (env.OVERSKY_WORKSPACE_ID?.trim())
+        return null;
+    let agent;
+    try {
+        agent = await lookup(agentId);
+    }
+    catch {
+        // Unreadable agent: keep the headerless request. The server still decides
+        // access, and the chat call itself reports a missing or forbidden agent.
+        return null;
+    }
+    const workspaceId = typeof agent?.workspaceId === 'string' ? agent.workspaceId.trim() : '';
+    if (!workspaceId)
+        return null;
+    env.OVERSKY_WORKSPACE_ID = workspaceId;
+    return workspaceId;
+}

package/dist/lib/agent-resolver.js

@@ -38,7 +38,7 @@ async function resolveAgentIdentity(explicitAgentId) {
         if (explicitAgentId && explicitAgentId !== runtime.agent.id) {
             throw new AgentResolutionError({
                 code: 'AGENT_CONTEXT_CONFLICT',
-                message: 'This local runtime is bound to OVERSKY_SESSION_AGENT_ID. Do not override it with another agent ID.',
+                message: 'This session is bound to the agent in OVERSKY_SESSION_AGENT_ID. Do not override it with another agent ID.',
                 suggestion: 'Use the bound session agent, or start a new daemon session for a different agent.',
                 details: {
                     explicitAgentId,
@@ -129,7 +129,7 @@ function resolveSessionAgentIdentity(explicitAgentId, env = process.env) {
     if (explicitAgentId && explicitAgentId !== runtime.agent.id) {
         throw new AgentResolutionError({
             code: 'AGENT_CONTEXT_CONFLICT',
-            message: 'This local runtime is bound to OVERSKY_SESSION_AGENT_ID. Do not override it with another agent ID.',
+            message: 'This session is bound to the agent in OVERSKY_SESSION_AGENT_ID. Do not override it with another agent ID.',
             suggestion: 'Use the bound session agent, or start a new daemon session for a different agent.',
             details: {
                 explicitAgentId,

package/dist/lib/agentic-stream.d.ts

@@ -85,6 +85,8 @@ export type AgenticStreamOptions = {
     reconcileTerminal?: () => Promise<ReconciledTerminal | null>;
     /** Silence before the first durable-record probe. Default 20s. */
     idleTerminalProbeMs?: number;
+    /** How long to keep trying to attach before reporting a detach. Default 30s. */
+    attachTimeoutMs?: number;
 };
 /**
  * Small Node-side adapter for the existing Agentic Socket.IO contract.
@@ -95,7 +97,12 @@ export type AgenticStreamOptions = {
  * The assistant text inside a `session:output` frame's envelopes.
  *
  * Envelope shape: `{ ev: { t: 'text', text: '…' } }`. Frames whose `ev.t` is
- * anything else (tool calls, status) are not the answer and are skipped.
+ * anything else (tool calls, status) are not the answer and are skipped, and so
+ * is text marked `thinking: true` — the model's reasoning, which the session
+ * protocol carries in the same `text` event. Folded in, a Devin turn asked for
+ * one word printed "I need to output only the word SECOND, … single
+ * word.SECOND" as its answer, and `run.result.text` kept it, because the
+ * stream then held the final result as a suffix and the longer text won.
  */
 export declare function envelopesText(event: AgenticStreamEvent): string;
 /**
@@ -281,6 +288,8 @@ export declare class AgenticStreamClient {
     /** Text already written to the terminal, for suffix-only rendering. */
     private renderedText;
     private idleTimer;
+    /** Releases a connect wait still in flight; `close()` calls it. */
+    private abandonConnectWait;
     private reconciling;
     private responseMessageId;
     private lastEvent;
@@ -307,6 +316,14 @@ export declare class AgenticStreamClient {
      * rather than giving up — a 200-second tool call is silence, not a failure —
      * so the cost of being wrong is one cheap read, while the cost of not asking
      * was an interactive session that never returned.
+     *
+     * The timer is deliberately NOT unref'd. It exists for the moment the socket
+     * stops holding the process open — a server-side disconnect, or a reconnect
+     * the server refuses, after which socket.io does not retry. Unref'd, it was
+     * the last thing pending at exactly that moment, so Node's event loop emptied
+     * and the CLI exited 0 with the run unsettled: `--no-stream --json` printed
+     * nothing at all for a turn the record said had failed (OSK-10061). A run
+     * that has not settled is a reason to stay alive; `close()` clears the timer.
      */
     private armIdleProbe;
     /**
@@ -364,6 +381,10 @@ export declare class AgenticStreamClient {
      * Now errors are surfaced as events and retried until a bounded deadline, so
      * only a sustained inability to attach gives up — and the caller turns that
      * into "accepted but detached", never "failed".
+     *
+     * The deadline and retry timers hold the process open (see `armDeadline`), so
+     * `close()` is what releases them — and it ends the wait too, whether the
+     * caller gave up or the durable record settled the run first (OSK-10061).
      */
     private waitForConnect;
 }

package/dist/lib/agentic-stream.js

@@ -51,7 +51,12 @@ function writeJsonLine(output, value) {
  * The assistant text inside a `session:output` frame's envelopes.
  *
  * Envelope shape: `{ ev: { t: 'text', text: '…' } }`. Frames whose `ev.t` is
- * anything else (tool calls, status) are not the answer and are skipped.
+ * anything else (tool calls, status) are not the answer and are skipped, and so
+ * is text marked `thinking: true` — the model's reasoning, which the session
+ * protocol carries in the same `text` event. Folded in, a Devin turn asked for
+ * one word printed "I need to output only the word SECOND, … single
+ * word.SECOND" as its answer, and `run.result.text` kept it, because the
+ * stream then held the final result as a suffix and the longer text won.
  */
 function envelopesText(event) {
     const envelopes = event.envelopes;
@@ -59,9 +64,11 @@ function envelopesText(event) {
         return '';
     let out = '';
     for (const envelope of envelopes) {
-        const ev = envelope?.ev;
-        if (ev && ev.t === 'text' && typeof ev.text === 'string')
+        const ev = envelope
+            ?.ev;
+        if (ev && ev.t === 'text' && ev.thinking !== true && typeof ev.text === 'string') {
             out += ev.text;
+        }
     }
     return out;
 }
@@ -306,6 +313,8 @@ class AgenticStreamClient {
     /** Text already written to the terminal, for suffix-only rendering. */
     renderedText = '';
     idleTimer = null;
+    /** Releases a connect wait still in flight; `close()` calls it. */
+    abandonConnectWait = null;
     reconciling = false;
     responseMessageId;
     lastEvent;
@@ -351,7 +360,13 @@ class AgenticStreamClient {
             reconnectionDelayMax: 10_000,
         });
         this.installHandlers();
-        await this.waitForConnect();
+        await this.waitForConnect(this.options.attachTimeoutMs);
+        // A refused handshake asks the durable record, and the record can settle
+        // the run before any attach succeeds. `close()` then ends the wait, and
+        // there is nothing left to join: returning here is what lets the caller see
+        // the result instead of awaiting an attach nobody is still attempting.
+        if (this.settled || this.closed || !this.socket)
+            return result;
         this.socket.emit('session:join', { sessionId: this.options.sessionId });
         this.emit({ type: 'session.joined', sessionId: this.options.sessionId });
         this.armIdleProbe();
@@ -365,6 +380,14 @@ class AgenticStreamClient {
      * rather than giving up — a 200-second tool call is silence, not a failure —
      * so the cost of being wrong is one cheap read, while the cost of not asking
      * was an interactive session that never returned.
+     *
+     * The timer is deliberately NOT unref'd. It exists for the moment the socket
+     * stops holding the process open — a server-side disconnect, or a reconnect
+     * the server refuses, after which socket.io does not retry. Unref'd, it was
+     * the last thing pending at exactly that moment, so Node's event loop emptied
+     * and the CLI exited 0 with the run unsettled: `--no-stream --json` printed
+     * nothing at all for a turn the record said had failed (OSK-10061). A run
+     * that has not settled is a reason to stay alive; `close()` clears the timer.
      */
     armIdleProbe() {
         if (!this.options.reconcileTerminal)
@@ -374,7 +397,6 @@ class AgenticStreamClient {
         if (this.idleTimer)
             clearTimeout(this.idleTimer);
         this.idleTimer = setTimeout(() => void this.probeTerminal('idle'), this.options.idleTerminalProbeMs ?? 20_000);
-        this.idleTimer.unref?.();
     }
     /**
      * Settle from the durable record, if it has reached a terminal state.
@@ -438,6 +460,7 @@ class AgenticStreamClient {
             clearTimeout(this.idleTimer);
             this.idleTimer = null;
         }
+        this.abandonConnectWait?.();
         const socket = this.socket;
         this.socket = null;
         // Stop dispatch BEFORE tearing anything down. socket.io can deliver a
@@ -838,6 +861,11 @@ class AgenticStreamClient {
         if (finalText && finalText !== this.accumulated && !accumulationIsSuperset) {
             this.accumulated = finalText;
         }
+        // The finished answer, as every other surface shows it: the web applies
+        // this same sanitizer, so a scheduling JSON block or leaked function-call
+        // XML the model wrote into its reply is removed here too instead of being
+        // printed as part of the agent's answer.
+        this.accumulated = (0, data_provider_1.sanitizeFinalText)(this.accumulated);
         if (!this.options.quiet && !this.options.jsonl && this.accumulated) {
             const output = this.options.output ?? process.stdout;
             const { append, shown } = renderableDelta(this.renderedText, this.accumulated);
@@ -872,6 +900,10 @@ class AgenticStreamClient {
      * Now errors are surfaced as events and retried until a bounded deadline, so
      * only a sustained inability to attach gives up — and the caller turns that
      * into "accepted but detached", never "failed".
+     *
+     * The deadline and retry timers hold the process open (see `armDeadline`), so
+     * `close()` is what releases them — and it ends the wait too, whether the
+     * caller gave up or the durable record settled the run first (OSK-10061).
      */
     waitForConnect(timeoutMs = 30_000) {
         if (this.socket?.connected)
@@ -889,7 +921,12 @@ class AgenticStreamClient {
                     reject(Object.assign(new Error(`Could not attach to the run stream within ${Math.round(ms / 1000)}s` +
                         `${lastError ? `: ${lastError.message}` : ''}`), { code: 'STREAM_ATTACH_TIMEOUT', lastError }));
                 }, ms);
-                handle.unref?.();
+                // Deliberately NOT unref'd, nor is the retry timer below. A connect
+                // refused by middleware leaves no live socket, so these timers are the
+                // only thing keeping the process alive while it waits. Unref'd, Node's
+                // event loop drained and `agents chat` exited 0 right after printing
+                // "Retrying in 30s" — before the retry, without the answer the run had
+                // produced, and without the detach notice a script needs.
                 return handle;
             }
             const onConnect = () => {
@@ -933,7 +970,6 @@ class AgenticStreamClient {
                         // must not reject here and turn a pause into a failure.
                     }
                 }, jitteredRetryDelay(refusal.retryAfterMs));
-                retryTimer.unref?.();
             };
             const cleanup = () => {
                 clearTimeout(timer);
@@ -941,6 +977,11 @@ class AgenticStreamClient {
                     clearTimeout(retryTimer);
                 socket.off('connect', onConnect);
                 socket.off('connect_error', onError);
+                this.abandonConnectWait = null;
+            };
+            this.abandonConnectWait = () => {
+                cleanup();
+                resolve();
             };
             socket.once('connect', onConnect);
             socket.on('connect_error', onError);

package/dist/lib/cli-installers.d.ts

@@ -25,6 +25,13 @@ export interface ManagedCliProviderState {
     source?: string;
     installable?: boolean;
     installDisabledReason?: string | null;
+    /**
+     * Whether the daemon can update this installed CLI in place, and why not.
+     * ABSENT from a daemon older than managed updates (OSK-10096) — read that as
+     * "this daemon cannot say", never as `false`.
+     */
+    updatable?: boolean;
+    updateDisabledReason?: string | null;
     platformSupported?: boolean;
     authentication?: ManagedCliAuthentication | null;
     job?: {
@@ -44,7 +51,7 @@ export interface CliInstallersResponse {
  * Providers the platform knows about that this daemon did not offer.
  *
  * The inventory is whatever the CONNECTED daemon supports, and an older daemon
- * legitimately supports fewer: `devin` arrived in daemon 0.8.43, so a machine
+ * legitimately supports fewer: `devin` arrived in the 0.8.45 daemon release, so a machine
  * running 0.8.35 answers with six providers instead of seven. Observed here —
  * the desktop app restarted the daemon from its bundled 0.8.35 copy and Devin
  * disappeared from the install list between two page loads, with nothing on
@@ -56,8 +63,28 @@ export interface CliInstallersResponse {
  * is already on this side of the wire. Naming the gap is what turns "Devin is
  * gone" into "this daemon is older than Devin".
  */
+/**
+ * The first STABLE daemon release (`daemon-v*` tag) whose
+ * MANAGED_CLI_PROVIDER_IDS included each provider. Release tags, not
+ * package.json at the commit that added it: the version is bumped before a
+ * release is cut, so the commit that added devin already read 0.8.43 while the
+ * 0.8.43 release did not contain it — this table said "added in 0.8.43" to a
+ * 0.8.43 user (OSK-9537 verifier). Derived with, per provider:
+ *   for t in $(git tag -l 'daemon-v*' | sort -V); do
+ *     git show "$t:daemon/src/cli-installers.ts" | grep -q "'devin'" && echo "$t" && break
+ *   done
+ * Providers present since managed installers first shipped (0.8.1) are omitted.
+ */
+export declare const MANAGED_CLI_PROVIDER_SINCE: Readonly<Record<string, string>>;
+/**
+ * "Not offered" with the release that added each provider, so a reader learns
+ * WHICH update fixes it rather than only that one might (OSK-9537).
+ */
+export declare function describeProvidersNotOffered(missing: readonly string[]): string;
 export declare function providersNotOffered(offered: readonly ManagedCliProviderState[] | undefined, known: readonly string[]): string[];
-export declare function listCliInstallers(daemonId: string, credential?: unknown): Promise<CliInstallersResponse>;
+export declare function listCliInstallers(daemonId: string, credential?: unknown, opts?: {
+    signal?: AbortSignal;
+}): Promise<CliInstallersResponse>;
 /**
  * The one-word readiness verdict for a provider, and whether it is good news.
  *
@@ -74,14 +101,82 @@ export declare function readinessOf(provider: ManagedCliProviderState): {
     ok: boolean;
 };
 /** A job the daemon runs to install one managed provider. */
+/**
+ * Readiness per provider for one daemon, keyed by CANONICAL provider — or null
+ * when the daemon could not be asked (disconnected, older, refused).
+ *
+ * The harness row's `authStatus` is the DAEMON's standing with skrr, written
+ * across every row of a daemon at once, so `harnesses show`, `machines show`
+ * and `ping` answered "ok" per provider for a Devin its own CLI called "Not
+ * logged in" (OSK-9263, OSK-9265). This is the per-provider answer those
+ * surfaces print instead. Best-effort by design: a failure here must never
+ * fail the command that asked.
+ */
+export declare function readinessByProvider(daemonId: string, credential?: unknown, opts?: {
+    signal?: AbortSignal;
+}): Promise<Map<string, ReturnType<typeof readinessOf>> | null>;
+/** The canonical provider a harness row names, for looking it up in that map. */
+export declare function readinessKey(provider: string | null | undefined): string;
+export type ProviderReadiness = ReturnType<typeof readinessOf>;
+/** The fields of a harness row that decide whether, and whom, to ask. */
+export interface ReadinessRow {
+    daemonId?: string | null;
+    provider?: string | null;
+    status?: string | null;
+    superseded?: boolean;
+}
+/** How long one daemon may take to answer before a list prints `-` for it. */
+export declare const ROW_READINESS_TIMEOUT_MS = 5000;
+/**
+ * Readiness for many harness rows at once: ONE installer read per connected
+ * daemon, all in parallel, however many rows each daemon has.
+ *
+ * Only a row whose daemon can answer is asked for — online and not superseded;
+ * an offline or replaced registration has nobody on the other end. Each read is
+ * bounded, because a list must not hang on one slow machine; a daemon that does
+ * not answer in time reads as unknown (`undefined`), never as `ready`.
+ *
+ * `asked` and `answered` let a caller tell "this daemon does not report it"
+ * from "nothing could be asked", which call for different next steps.
+ */
+export declare function readinessForRows(rows: readonly ReadinessRow[], credential?: unknown, opts?: {
+    timeoutMs?: number;
+}): Promise<{
+    lookup: (row: ReadinessRow) => ProviderReadiness | undefined;
+    /** Whether this row's daemon answered at all — so a `-` can say why. */
+    daemonAnswered: (row: ReadinessRow) => boolean;
+    asked: number;
+    answered: number;
+}>;
 export interface ManagedCliInstallJob {
     id: string;
+    provider?: string;
+    displayName?: string;
     status: 'queued' | 'running' | 'succeeded' | 'failed';
+    /** `update` for an in-place update; absent from an older daemon, meaning install. */
+    kind?: 'install' | 'update';
+    previousVersion?: string | null;
+    installedVersion?: string | null;
     error?: string;
+    /**
+     * The daemon's job log: the LAST lines only (a sliding window, 200 lines in
+     * `daemon/src/cli-installers.ts`). This is the field the daemon sends.
+     */
+    logTail?: string[];
+    /**
+     * Lines the job has EVER logged (daemons with OSK-10179). With it, the lines
+     * new since the last poll are exactly the last `count − printed` of the tail,
+     * even when they repeat.
+     */
+    logLineCount?: number;
+    /** Never sent by any daemon; kept so an older caller's shape still types. */
     log?: string[];
 }
 export interface StartInstallResponse {
     started?: boolean;
+    /** The daemon declined because the CLI is already there. */
+    alreadyInstalled?: boolean;
+    alreadyRunning?: boolean;
     provider?: ManagedCliProviderState;
     job?: {
         id?: string;
@@ -89,9 +184,36 @@ export interface StartInstallResponse {
     };
 }
 export declare function startManagedCliInstall(daemonId: string, provider: string, credential?: unknown): Promise<StartInstallResponse>;
+/** Ask the daemon to update an installed CLI in place (OSK-10096). */
+export declare function startManagedCliUpdate(daemonId: string, provider: string, credential?: unknown): Promise<StartInstallResponse>;
+/**
+ * How an update job ended, from the versions the daemon recorded on it:
+ * "Updated Claude Code 2.1.270 → 2.1.280." or "Claude Code is still 2.1.270:
+ * its updater found nothing newer." Null when the job does not carry both.
+ */
+export declare function updateOutcomeLine(job: ManagedCliInstallJob): string | null;
 export declare function readManagedCliInstallJob(daemonId: string, jobId: string, credential?: unknown): Promise<{
     job?: ManagedCliInstallJob;
 }>;
+/**
+ * The lines of a job's log tail not yet printed.
+ *
+ * The tail is a SLIDING window: once an installer writes more than the daemon
+ * keeps, earlier lines fall off the front, so an index into it skips or repeats
+ * lines. Instead, find the longest run at the start of the new tail that matches
+ * the end of what was already printed, and print only what follows it.
+ */
+export declare function unseenLogLines(printed: readonly string[], tail: readonly string[]): string[];
+/**
+ * The new lines of a job's tail when the daemon reports its running line count:
+ * exactly the last `total − printedCount`, and how many of those already fell
+ * out of the window (the daemon keeps the last 200). Unlike overlap matching,
+ * this cannot mistake a repeated line for one already printed.
+ */
+export declare function newLogLinesByCount(printedCount: number, tail: readonly string[], total: number): {
+    lines: string[];
+    skipped: number;
+};
 /** A 100 MB download over a hotel connection is the case this has to survive. */
 export declare const INSTALL_MAX_WAIT_MS: number;
 export declare const INSTALL_POLL_INTERVAL_MS = 2000;