@skrr-ai/cli 0.1.122 → 0.1.123

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

@@ -155,6 +155,12 @@ export declare function noOutputFailureMessage(input: {
     text?: string;
     conversationId?: string | null;
 }): string | null;
+/**
+ * What a failed run says for itself. The reason is whatever the terminal event
+ * carries (see `terminalFailureMessage`); only a failure that carries none gets
+ * the generic sentence.
+ */
+export declare function agentRunFailureMessage(result: Pick<AgenticStreamResult, 'lastEvent'>): string;
 export declare function noStreamJsonPayload(input: {
     result: AgenticStreamResult;
     conversationId?: string;
@@ -222,6 +228,7 @@ export default class AgentsChat extends BaseCommand {
         'thread-root': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'no-stream': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         quick: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        incremental: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         jsonl: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'repair-wait': import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;

package/dist/commands/agents/chat.js

@@ -9,6 +9,7 @@ exports.handoverInterruptMessage = handoverInterruptMessage;
 exports.interruptAction = interruptAction;
 exports.inspectTurnCommand = inspectTurnCommand;
 exports.noOutputFailureMessage = noOutputFailureMessage;
+exports.agentRunFailureMessage = agentRunFailureMessage;
 exports.noStreamJsonPayload = noStreamJsonPayload;
 exports.chatStreamHeaderLines = chatStreamHeaderLines;
 exports.daemonPinFields = daemonPinFields;
@@ -259,6 +260,14 @@ function noOutputFailureMessage(input) {
     return (`The turn ended with no output (status: ${input.status}). ` +
         `It may have failed on the runtime. Inspect it with: ${inspectTurnCommand(input.conversationId)}`);
 }
+/**
+ * What a failed run says for itself. The reason is whatever the terminal event
+ * carries (see `terminalFailureMessage`); only a failure that carries none gets
+ * the generic sentence.
+ */
+function agentRunFailureMessage(result) {
+    return (0, agentic_stream_1.terminalFailureMessage)(result.lastEvent) ?? 'Agent run failed';
+}
 function noStreamJsonPayload(input) {
     const { result, conversationId, agentId, baseURL, threadRootMessageId } = input;
     return {
@@ -281,9 +290,9 @@ function noStreamJsonPayload(input) {
             ? {
                 failureReason: result.lastEvent?.reason ??
                     result.lastEvent?.code ??
-                    result.lastEvent?.message ??
+                    (0, agentic_stream_1.terminalFailureMessage)(result.lastEvent) ??
                     'agent_run_failed',
-                error: result.lastEvent?.message ?? 'Agent run failed',
+                error: agentRunFailureMessage(result),
                 terminalEvent: result.lastEvent,
             }
             : {}),
@@ -370,10 +379,20 @@ class AgentsChat extends base_command_1.BaseCommand {
                 'agent’s runtime, tools, session, or working directory and cannot perform work — ' +
                 'it is for inline text assistance. Use --no-stream for a real turn.',
         }),
+        incremental: core_1.Flags.boolean({
+            description: 'With --jsonl, make `text.delta` a real delta: it carries only `delta`, the characters ' +
+                'it adds, instead of the whole answer so far, and leaves out the envelopes that ' +
+                '`session.output` already carries. A rewrite that is not an append arrives as ' +
+                '`replace`, the new full text. `run.result` still holds the whole answer. Without it ' +
+                'a long answer written as JSON lines grows with the square of its length.',
+            dependsOn: ['jsonl'],
+        }),
         jsonl: core_1.Flags.boolean({
             description: 'Emit one JSON event per line while streaming. Every line is a complete JSON value. ' +
                 'Assistant text arrives as `text.delta` whose `text` is the CUMULATIVE answer so far, ' +
-                'not a delta — take the last one, or `run.result` at the end. The same text is ' +
+                'not a delta — take the last one, or `run.result` at the end. Each `text.delta` also ' +
+                'carries `delta`, the characters it adds, when it only appends to the one before; ' +
+                'with --incremental it carries nothing else of the text (see that flag). The same text is ' +
                 'mirrored inside `session.output` envelopes for consumers that want the raw stream, ' +
                 'so folding both doubles the answer: pick ONE lane. A widget the agent wrote ' +
                 '(a block of CSS, HTML and JavaScript the apps draw) is its text description in ' +
@@ -392,7 +411,11 @@ class AgentsChat extends base_command_1.BaseCommand {
                 'and local-harness runs alike. A `session.notice` with `notice: ' +
                 '"harness-session-reset"` means the local harness could not resume its previous ' +
                 'session and started a new one, which does not see earlier turns of the ' +
-                'conversation; `message` says why. A `permission.resolved` says ' +
+                'conversation; `message` says why. `notice: "model-request-retrying"` means the ' +
+                'model rejected or could not answer a request and the harness is retrying it: ' +
+                '`message` names the cause (for example the model rejecting the credentials on ' +
+                'this machine, HTTP 403) and the attempt, a few times per retry episode, so a ' +
+                'run that looks quiet is not. A `permission.resolved` says ' +
                 'how a local harness permission request was decided: `decidedBy` in words, and ' +
                 '`basis` — `person` (with `surface`), `mode` (with `mode`), `policy` or ' +
                 '`session-grant` — beside the wire `by`. When a platform update restarts the server ' +
@@ -404,7 +427,9 @@ class AgentsChat extends base_command_1.BaseCommand {
                 'the machine finished; `run.failed` with `handover.outcome: "machine_failed"` and the ' +
                 'machine\'s reason when it did not; or `run.failed` with `handover.outcome: "expired"` ' +
                 'and the original failure when --repair-wait ran out (exit 1 for both). Ctrl-C during ' +
-                'the wait emits `run.detached` with `handedOver: true` and exits 130.',
+                'the wait emits `run.detached` with `handedOver: true` and exits 130. Whenever a run ' +
+                'fails, `run.failed` carries `message`, the reason in words as the platform gave it (the ' +
+                'same sentence a terminal prints after `Error:`), beside the short `reason`.',
         }),
         json: core_1.Flags.boolean({
             description: 'Emit the final one-shot response as JSON (use with --no-stream)',
@@ -788,6 +813,7 @@ class AgentsChat extends base_command_1.BaseCommand {
             sessionId: started.sessionId,
             conversationId,
             jsonl: flags.jsonl,
+            incrementalText: flags.incremental,
             quiet,
             approveTools: flags['approve-tools'],
             reconcileTerminal,
@@ -966,7 +992,7 @@ class AgentsChat extends base_command_1.BaseCommand {
                     process.exitCode = 1;
             }
             else if (result.status === 'failed') {
-                this.error(String(result.lastEvent?.message ?? 'Agent run failed'), { exit: 1 });
+                this.error(agentRunFailureMessage(result), { exit: 1 });
             }
             else if (quiet) {
                 // Non-streaming human output: the answer the turn produced.

package/dist/commands/followups/act.js

@@ -100,6 +100,9 @@ class FollowupsAct extends base_command_1.BaseCommand {
             this.log(JSON.stringify(response, null, 2));
             return;
         }
+        const producerNotice = (0, followups_1.producerDowngradeNotice)(response);
+        if (producerNotice)
+            this.log(producerNotice);
         const row = response.followup;
         if (response.reused) {
             this.log(`Already armed: ${row?.id} — the same act exists and was not duplicated.`);

package/dist/commands/followups/checkin.js

@@ -126,6 +126,9 @@ class FollowupsCheckin extends base_command_1.BaseCommand {
             this.log(JSON.stringify(response, null, 2));
             return;
         }
+        const producerNotice = (0, followups_1.producerDowngradeNotice)(response);
+        if (producerNotice)
+            this.log(producerNotice);
         const row = response.followup;
         if (response.reused) {
             this.log(reusedMessage(row, subject, flags.why));

package/dist/commands/followups/remind.js

@@ -102,6 +102,9 @@ class FollowupsRemind extends base_command_1.BaseCommand {
             this.log(JSON.stringify(response, null, 2));
             return;
         }
+        const producerNotice = (0, followups_1.producerDowngradeNotice)(response);
+        if (producerNotice)
+            this.log(producerNotice);
         const row = response.followup;
         if (response.reused && response.rescheduled) {
             this.log(`Moved: ${row?.id} now fires at ${row?.nextRunAt ?? at} — the same reminder already existed, so it was rescheduled rather than duplicated.`);

package/dist/commands/followups/show.js

@@ -42,7 +42,7 @@ class FollowupsShow extends base_command_1.BaseCommand {
             ['says', row.content],
             ['why', row.why],
             ['intent', row.intentKey],
-            ['producer', row.producer],
+            ['producer', row.producerLabel ? `${row.producer} (${row.producerLabel})` : row.producer],
             ['gate', row.gate ? (GATE_LABEL[row.gate] ?? row.gate) : undefined],
             ['terminal', row.terminal ? `${row.terminal} (${row.terminalReason ?? '—'})` : undefined],
             [

package/dist/commands/followups/watch.js

@@ -237,6 +237,9 @@ class FollowupsWatch extends base_command_1.BaseCommand {
             this.log(JSON.stringify(response, null, 2));
             return;
         }
+        const producerNotice = (0, followups_1.producerDowngradeNotice)(response);
+        if (producerNotice)
+            this.log(producerNotice);
         const row = response.followup;
         if (response.reused) {
             this.log(`Already armed: ${row?.id} — an identical watch exists and was not duplicated.`);

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

@@ -11,11 +11,31 @@ import { type PublicProjection, type AssistantTextJoiner } from '@skrr-ai/data-p
  * — consent nobody gave, on a form nobody saw (OSK-10274).
  */
 export declare const NON_INTERACTIVE_QUESTION_DISMISSAL: string;
+/**
+ * A terminal that has printed the header and nothing else for several seconds looks hung. The
+ * first line comes after this long with no output at all, and then again at this interval
+ * (OSK-20427). Typical waits are 4 to 6 seconds before the first words, so a quick reply
+ * prints nothing extra.
+ */
+export declare const WAITING_NOTICE_AFTER_MS = 2500;
+export declare const WAITING_NOTICE_EVERY_MS = 10000;
 export type AgenticStreamEvent = {
     type: string;
     sessionId?: string;
     [key: string]: unknown;
 };
+/**
+ * The sentence a failed run's terminal event gives for why it failed.
+ *
+ * The server's failure funnel (`handleSessionFailure`) sends `errors: [<sentence>]`
+ * and a short `reason`, never a `message`; other terminal events carry `message`,
+ * and a few an `error` string. Every reader used to look at `message` alone, so a
+ * run the platform refused ("no valid release package", "insufficient balance", a
+ * runtime that was not there) ended as `Error: Agent run failed` with the reason
+ * sitting unread in the same event (OSK-20410). One reader, in one order: the
+ * explicit `message`, then `error`, then the first entry of `errors`.
+ */
+export declare function terminalFailureMessage(event: Record<string, unknown> | null | undefined): string | undefined;
 export type AgenticStreamResult = {
     sessionId: string;
     responseMessageId?: string;
@@ -161,6 +181,12 @@ export type AgenticStreamOptions = {
     /** Action-required notices when stdout is reserved for a final result. */
     statusOutput?: NodeJS.WritableStream;
     jsonl?: boolean;
+    /**
+     * With `jsonl`, a `text.delta` carries only the characters it adds (`delta`), not the whole
+     * answer so far, and not the envelopes `session.output` already carries. A rewrite that is not
+     * an append arrives as `replace`, the new full text. `run.result` still holds the whole answer.
+     */
+    incrementalText?: boolean;
     approveTools?: boolean;
     input?: NodeJS.ReadableStream;
     output?: NodeJS.WritableStream;
@@ -579,6 +605,12 @@ export declare class AgenticStreamClient {
     private readonly openQuestionPrompts;
     /** Text already written to the terminal, for suffix-only rendering. */
     private renderedText;
+    /** The "still waiting" line for a terminal run with no output yet (OSK-20427). */
+    private waitingTimer;
+    private waitingStartedAt;
+    private outputSeen;
+    /** The cumulative text of the last `text.delta` written as JSON, for `delta`/`replace`. */
+    private lastJsonlText;
     private idleTimer;
     /** Releases a connect wait still in flight; `close()` calls it. */
     private abandonConnectWait;
@@ -777,6 +809,20 @@ export declare class AgenticStreamClient {
      * passed through, preserving prior behaviour.
      */
     private emitToolEvent;
+    /**
+     * Say so when a terminal run has been quiet since it started. Human output only: a script
+     * reading --jsonl has the events, and --quiet asked for nothing but the answer.
+     */
+    private trackWaiting;
+    private stopWaiting;
+    /**
+     * A `text.delta` is named for a delta and carries the whole answer so far (`text`), so a long
+     * answer written as JSON lines grows with the square of its length: 207 events for a 2.4 KB
+     * answer came to about 250 KB (OSK-20428). The contract stays, since scripts take the last one;
+     * `delta` is added to it, and `incrementalText` turns the cumulative text and the duplicated
+     * envelopes off for a consumer that wants only what is new.
+     */
+    private jsonlView;
     private emit;
     /**
      * Human-mode lines for the hand-over wait. Returns true when the event is

package/dist/lib/agentic-stream.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgenticStreamClient = exports.USER_CONNECTION_CAP_CODE = exports.CODEX_DECLINED_TOOL_OUTPUTS = exports.TYPE_AHEAD_DISCARD_MS = exports.HANDOVER_POLL_INTERVAL_MS = exports.DAEMON_HANDOVER_REASON = exports.WORKER_REPLACED_CODE = exports.NON_INTERACTIVE_QUESTION_DISMISSAL = void 0;
+exports.AgenticStreamClient = exports.USER_CONNECTION_CAP_CODE = exports.CODEX_DECLINED_TOOL_OUTPUTS = exports.TYPE_AHEAD_DISCARD_MS = exports.HANDOVER_POLL_INTERVAL_MS = exports.DAEMON_HANDOVER_REASON = exports.WORKER_REPLACED_CODE = exports.WAITING_NOTICE_EVERY_MS = exports.WAITING_NOTICE_AFTER_MS = exports.NON_INTERACTIVE_QUESTION_DISMISSAL = void 0;
+exports.terminalFailureMessage = terminalFailureMessage;
 exports.isDaemonHandoverFailure = isDaemonHandoverFailure;
 exports.formatWaitDuration = formatWaitDuration;
 exports.writeJsonLine = writeJsonLine;
@@ -46,6 +47,47 @@ const dpop_auth_1 = require("./dpop-auth");
  */
 exports.NON_INTERACTIVE_QUESTION_DISMISSAL = 'No answer: this turn was started non-interactively (no terminal), so nobody can reply to ' +
     'questions. Proceed with your best judgement, or finish by stating exactly what you need.';
+/**
+ * A terminal that has printed the header and nothing else for several seconds looks hung. The
+ * first line comes after this long with no output at all, and then again at this interval
+ * (OSK-20427). Typical waits are 4 to 6 seconds before the first words, so a quick reply
+ * prints nothing extra.
+ */
+exports.WAITING_NOTICE_AFTER_MS = 2500;
+exports.WAITING_NOTICE_EVERY_MS = 10_000;
+/** What counts as the run having said something, so the waiting line stops. */
+const OUTPUT_EVENT_TYPES = new Set([
+    'text.delta',
+    'tool.started',
+    'tool.completed',
+    'session.notice',
+    'permission.requested',
+    'run.completed',
+    'run.failed',
+    'run.aborted',
+    'run.handed_over',
+]);
+/**
+ * The sentence a failed run's terminal event gives for why it failed.
+ *
+ * The server's failure funnel (`handleSessionFailure`) sends `errors: [<sentence>]`
+ * and a short `reason`, never a `message`; other terminal events carry `message`,
+ * and a few an `error` string. Every reader used to look at `message` alone, so a
+ * run the platform refused ("no valid release package", "insufficient balance", a
+ * runtime that was not there) ended as `Error: Agent run failed` with the reason
+ * sitting unread in the same event (OSK-20410). One reader, in one order: the
+ * explicit `message`, then `error`, then the first entry of `errors`.
+ */
+function terminalFailureMessage(event) {
+    if (!event)
+        return undefined;
+    const sentence = (value) => typeof value === 'string' && value.trim() ? value : undefined;
+    const entryText = (entry) => sentence(entry) ?? sentence(entry?.message);
+    const fromList = Array.isArray(event.errors)
+        ? event.errors.map(entryText).find((entry) => entry !== undefined)
+        : undefined;
+    return sentence(event.message) ?? sentence(event.error) ?? fromList;
+}
 /**
  * OSK-13517 / OSK-13543 — the one failure that is not an ending.
  *
@@ -807,6 +849,12 @@ class AgenticStreamClient {
     openQuestionPrompts = new Map();
     /** Text already written to the terminal, for suffix-only rendering. */
     renderedText = '';
+    /** The "still waiting" line for a terminal run with no output yet (OSK-20427). */
+    waitingTimer = null;
+    waitingStartedAt = 0;
+    outputSeen = false;
+    /** The cumulative text of the last `text.delta` written as JSON, for `delta`/`replace`. */
+    lastJsonlText = '';
     idleTimer = null;
     /** Releases a connect wait still in flight; `close()` calls it. */
     abandonConnectWait = null;
@@ -1012,6 +1060,7 @@ class AgenticStreamClient {
         if (this.replayTimer)
             clearTimeout(this.replayTimer);
         this.replayTimer = null;
+        this.stopWaiting();
         this.stopHandoverTimers();
         this.pendingEnvelopes.clear();
         this.browserPermissionRequests.clear();
@@ -1079,10 +1128,7 @@ class AgenticStreamClient {
         const deadlineTimer = setTimeout(() => void this.expireHandover(), opts.maxWaitMs);
         const pollTimer = setInterval(() => this.requestHandoverRead(), opts.pollIntervalMs ?? exports.HANDOVER_POLL_INTERVAL_MS);
         this.handover = { event, startedAt, deadlineTimer, pollTimer, reading: null, readAgain: false };
-        const firstError = Array.isArray(event.errors) && typeof event.errors[0] === 'string'
-            ? event.errors[0]
-            : undefined;
-        const message = typeof event.message === 'string' && event.message ? event.message : firstError;
+        const message = terminalFailureMessage(event);
         this.emit({
             type: 'run.handed_over',
             sessionId: this.options.sessionId,
@@ -1745,6 +1791,10 @@ class AgenticStreamClient {
             return;
         }
         if (!this.options.approveTools || !this.socket) {
+            // This CLI makes the decision and nobody is asked, so it says so FIRST. The bound path used
+            // to return before any event, and the only lines a person saw were the server's "The
+            // response was admitted. Tool execution is not confirmed.", which read like an approval.
+            this.emit({ ...event, type: 'permission.denied', reason: 'noninteractive_or_not_enabled' });
             if (event.toolUseId) {
                 if (await this.sendBoundPermissionDecision(event, false, { reason: 'CLI was not started with --approve-tools', automatic: true }))
                     return;
@@ -1759,7 +1809,6 @@ class AgenticStreamClient {
                     automatic: true,
                 });
             }
-            this.emit({ ...event, type: 'permission.denied', reason: 'noninteractive_or_not_enabled' });
             return;
         }
         /**
@@ -1782,6 +1831,14 @@ class AgenticStreamClient {
          */
         const interactive = this.options.input !== undefined || Boolean(process.stdin.isTTY);
         if (!interactive) {
+            // Announced before it is sent, as the denial is: the bound path used to return first, so
+            // "allowed by --approve-tools" never reached a person who used the flag.
+            this.emit({
+                ...event,
+                type: 'permission.approved',
+                auto: true,
+                reason: 'approved by --approve-tools, which was given with no terminal to ask at',
+            });
             if (await this.sendBoundPermissionDecision(event, true))
                 return;
             this.socket.emit('permission:approve', {
@@ -1789,12 +1846,6 @@ class AgenticStreamClient {
                 toolUseId: event.toolUseId,
                 toolName: event.toolName,
             });
-            this.emit({
-                ...event,
-                type: 'permission.approved',
-                auto: true,
-                reason: 'approved by --approve-tools, which was given with no terminal to ask at',
-            });
             return;
         }
         const prompt = new AbortController();
@@ -2084,6 +2135,60 @@ class AgenticStreamClient {
             return;
         this.emit(event);
     }
+    /**
+     * Say so when a terminal run has been quiet since it started. Human output only: a script
+     * reading --jsonl has the events, and --quiet asked for nothing but the answer.
+     */
+    trackWaiting(event, output) {
+        if (OUTPUT_EVENT_TYPES.has(event.type)) {
+            this.outputSeen = true;
+            this.stopWaiting();
+            return;
+        }
+        if (event.type !== 'run.started' || this.outputSeen || this.waitingTimer)
+            return;
+        this.waitingStartedAt = Date.now();
+        const schedule = (first) => {
+            this.waitingTimer = setTimeout(() => {
+                this.waitingTimer = null;
+                if (this.outputSeen || this.closed)
+                    return;
+                const seconds = Math.floor((Date.now() - this.waitingStartedAt) / 1000);
+                output.write(first
+                    ? '[run] waiting for the agent to start answering…\n'
+                    : `[run] still waiting for the agent (${seconds} s)…\n`);
+                schedule(false);
+            }, first ? exports.WAITING_NOTICE_AFTER_MS : exports.WAITING_NOTICE_EVERY_MS);
+            // A reminder must never be the reason the process stays alive.
+            this.waitingTimer.unref?.();
+        };
+        schedule(true);
+    }
+    stopWaiting() {
+        if (this.waitingTimer)
+            clearTimeout(this.waitingTimer);
+        this.waitingTimer = null;
+    }
+    /**
+     * A `text.delta` is named for a delta and carries the whole answer so far (`text`), so a long
+     * answer written as JSON lines grows with the square of its length: 207 events for a 2.4 KB
+     * answer came to about 250 KB (OSK-20428). The contract stays, since scripts take the last one;
+     * `delta` is added to it, and `incrementalText` turns the cumulative text and the duplicated
+     * envelopes off for a consumer that wants only what is new.
+     */
+    jsonlView(event) {
+        if (event.type !== 'text.delta' || typeof event.text !== 'string')
+            return event;
+        const previous = this.lastJsonlText;
+        const text = event.text;
+        this.lastJsonlText = text;
+        const appended = text.startsWith(previous) ? text.slice(previous.length) : undefined;
+        if (!this.options.incrementalText) {
+            return appended === undefined ? event : { ...event, delta: appended };
+        }
+        const { text: _text, envelopes: _envelopes, ...rest } = event;
+        return appended === undefined ? { ...rest, replace: text } : { ...rest, delta: appended };
+    }
     emit(event) {
         this.lastEvent = event;
         this.options.onEvent?.(event);
@@ -2108,9 +2213,10 @@ class AgenticStreamClient {
             return;
         const output = this.options.output ?? process.stdout;
         if (this.options.jsonl) {
-            writeJsonLine(output, event);
+            writeJsonLine(output, this.jsonlView(event));
             return;
         }
+        this.trackWaiting(event, output);
         if (event.type === 'run.started') {
             const permission = describeRunPermission(event);
             if (permission)
@@ -2192,6 +2298,12 @@ class AgenticStreamClient {
             output.write(`\n[question] ${why}\n`);
             this.renderedText = this.answerText();
         }
+        else if (event.type === 'permission.denied' && event.reason === 'noninteractive_or_not_enabled') {
+            // Said out loud, because nobody was asked and the agent will not say it plainly: this run
+            // had no terminal to ask at and was not given --approve-tools, so the call was refused.
+            output.write(`\n[permission] ${describePermission(event)} denied: nobody could be asked, and this run was not started with --approve-tools\n`);
+            this.renderedText = this.answerText();
+        }
         else if (event.type === 'permission.approved' && event.auto === true) {
             // Said out loud, because nobody was asked: the flag approved it, and a
             // reader of this log should see which tools that covered (OSK-10323).
@@ -2379,7 +2491,16 @@ class AgenticStreamClient {
                 output.write(append);
             output.write('\n');
         }
-        this.emit({ ...event, type: `run.${status}` });
+        // A failed run states why under the one key a script reads (`message`), whichever
+        // shape the terminal event used. `lastEvent` below stays the event as received.
+        const failureMessage = status === 'failed' && !(typeof event.message === 'string' && event.message.trim())
+            ? terminalFailureMessage(event)
+            : undefined;
+        this.emit({
+            ...event,
+            ...(failureMessage ? { message: failureMessage } : {}),
+            type: `run.${status}`,
+        });
         this.close();
         this.terminalResult = {
             sessionId: this.options.sessionId,

package/dist/lib/auth-failure.js

@@ -98,6 +98,18 @@ function describeRefreshRefusal(refusal, opts) {
                 `server treats that as possible theft and revokes the whole family. ${relogin}`,
         };
     }
+    // The server wanted a device proof and this machine had no key to sign one
+    // with. `skrr login` signs the CLI in on its own and never creates a device
+    // key, so naming it here sends the person round the same loop (OSK-20472): the
+    // daemon's interactive sign-in is what mints a key and re-pins the server to it.
+    if (code === 'DEVICE_KEY_UNAVAILABLE') {
+        return {
+            code,
+            message: `This sign-in could not be renewed${said}. This machine's device key is missing or ` +
+                `unreadable, so requests carry no device proof. \`${bin} login\` cannot create one; ` +
+                `sign the background service in again with \`${bin} daemon login\`.`,
+        };
+    }
     return {
         code,
         message: `This sign-in could not be renewed${said}. ${relogin}`,

package/dist/lib/exec-runtime-binary.d.ts

@@ -65,6 +65,15 @@ export declare function normalizeRuntimeGlobalArgs(args: readonly string[]): str
  * part of a copy sweep.
  */
 export declare function notInstalledMessage(): string;
+/**
+ * Marks the `skrrd` process that `skrr daemon …` launches, so the daemon can print its recovery
+ * commands in the spelling the person can run: `skrr daemon login`, not `skrrd login`. The
+ * daemon lives in `~/.skrr/bin`, which this wrapper finds by itself and nothing puts on PATH.
+ * Spelled the same in `daemon/src/auth/login-hint.ts`; `scripts/__tests__/invoked-via-parity.spec.js`
+ * holds the two together.
+ */
+export declare const INVOKED_VIA_ENV = "SKRR_INVOKED_VIA";
+export declare const INVOKED_VIA_CLI = "skrr-cli";
 /**
  * Spawn `oversky <args>` with stdio inherited. Resolves with the child's
  * exit code so the caller can `process.exit()` with the same code,

package/dist/lib/exec-runtime-binary.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RUNTIME_BINARY_NAMES = void 0;
+exports.INVOKED_VIA_CLI = exports.INVOKED_VIA_ENV = exports.RUNTIME_BINARY_NAMES = void 0;
 exports.forwardedFlagsNote = forwardedFlagsNote;
 exports.findRuntimeBinary = findRuntimeBinary;
 exports.isCurrentRuntimeBinary = isCurrentRuntimeBinary;
@@ -206,6 +206,18 @@ function notInstalledMessage() {
         'Once installed, re-run your command.',
     ].join('\n');
 }
+/**
+ * Marks the `skrrd` process that `skrr daemon …` launches, so the daemon can print its recovery
+ * commands in the spelling the person can run: `skrr daemon login`, not `skrrd login`. The
+ * daemon lives in `~/.skrr/bin`, which this wrapper finds by itself and nothing puts on PATH.
+ * Spelled the same in `daemon/src/auth/login-hint.ts`; `scripts/__tests__/invoked-via-parity.spec.js`
+ * holds the two together.
+ */
+exports.INVOKED_VIA_ENV = 'SKRR_INVOKED_VIA';
+exports.INVOKED_VIA_CLI = 'skrr-cli';
+function runtimeEnv() {
+    return { ...process.env, [exports.INVOKED_VIA_ENV]: exports.INVOKED_VIA_CLI };
+}
 /**
  * Spawn `oversky <args>` with stdio inherited. Resolves with the child's
  * exit code so the caller can `process.exit()` with the same code,
@@ -230,6 +242,7 @@ function execRuntimeBinary(args, opts = {}) {
         const isWinShim = process.platform === 'win32' && /\.(cmd|bat)$/i.test(bin);
         const child = (0, node_child_process_1.spawn)(bin, normalizeRuntimeGlobalArgs(args), {
             stdio: 'inherit',
+            env: runtimeEnv(),
             ...(isWinShim ? { shell: true } : {}),
         });
         child.on('error', reject);
@@ -261,6 +274,7 @@ function execRuntimeBinaryCapture(args, opts = {}) {
         const isWinShim = process.platform === 'win32' && /\.(cmd|bat)$/i.test(bin);
         const child = (0, node_child_process_1.spawn)(bin, normalizeRuntimeGlobalArgs(args), {
             stdio: ['ignore', 'pipe', 'pipe'],
+            env: runtimeEnv(),
             ...(isWinShim ? { shell: true } : {}),
         });
         let stdout = '';

package/dist/lib/followups.d.ts

@@ -49,6 +49,8 @@ export interface FollowUpRow {
     kind?: string;
     form?: string | null;
     producer?: string;
+    /** The producer in words (`describeFollowUpProducer`), so no surface prints a bare enum. */
+    producerLabel?: string;
     why?: string;
     /** A reminder's own words. */
     content?: string | null;
@@ -86,7 +88,18 @@ export interface FollowUpCreateResponse {
     proposal?: boolean;
     budget?: Json;
     fallbackTriggerId?: string | null;
+    /**
+     * Set when the credential could not carry the producer the request claimed: the
+     * server recorded `recorded` instead (never a higher one) and says why.
+     */
+    producerDowngraded?: {
+        requested: string;
+        recorded: string;
+        note: string;
+    };
 }
+/** One line telling a person the follow-up was recorded with weaker provenance than claimed. */
+export declare function producerDowngradeNotice(response: FollowUpCreateResponse): string | undefined;
 export interface FollowUpObservability {
     generatedAt?: string;
     agents?: Array<{

package/dist/lib/followups.js

@@ -4,6 +4,7 @@ exports.followupsApi = exports.FOLLOWUP_SUBJECT_FLAG_HELP = exports.FOLLOWUP_SUB
 exports.whenFlagProblem = whenFlagProblem;
 exports.settledLine = settledLine;
 exports.recipeWatchBoundsRefusal = recipeWatchBoundsRefusal;
+exports.producerDowngradeNotice = producerDowngradeNotice;
 exports.resolveFollowUpAgent = resolveFollowUpAgent;
 exports.parseSubjectRef = parseSubjectRef;
 exports.followupSummaryLine = followupSummaryLine;
@@ -127,6 +128,13 @@ function recipeWatchBoundsRefusal(waitKind, passed) {
             : 'A recipe watch ends through its --wait.',
     ].join(' ');
 }
+/** One line telling a person the follow-up was recorded with weaker provenance than claimed. */
+function producerDowngradeNotice(response) {
+    const downgraded = response.producerDowngraded;
+    if (!downgraded)
+        return undefined;
+    return `Note: recorded as ${downgraded.recorded}, not ${downgraded.requested}. ${downgraded.note}`;
+}
 /**
  * A trigger subject becomes a durable concurrency key, so it cannot be prose.
  * Keep this grammar aligned with TriggerEngine's subject validation and the

package/dist/lib/profile-machine-identity-guard.js

@@ -5,6 +5,7 @@ exports.describeLegacySharedProfile = describeLegacySharedProfile;
 const machine_uuid_1 = require("@skrr-ai/auth-core/machine-uuid");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const keychain_1 = require("./keychain");
+const daemon_command_hint_1 = require("./daemon-command-hint");
 /** An old profile may still share the default machine row and its device pin. */
 function legacyProfileSharesDefaultMachine() {
     const profile = (0, keychain_1.getActiveProfile)();
@@ -47,6 +48,6 @@ function describeLegacySharedProfile(profile) {
             `computer the same machine identity, and it still has it. ${why}Signing in here would replace the default ` +
             "profile's device-key pin and sign the default daemon out. Nothing was changed.",
         `Use a new profile name instead: skrr login --profile ${next}`,
-        `(For the background service alone: skrrd --profile ${next} login)`,
+        `(For the background service alone: ${(0, daemon_command_hint_1.daemonCommandHint)('login', { profile: next })})`,
     ];
 }

package/dist/lib/runtime-start-verification.js

@@ -49,7 +49,12 @@ function parseRuntimeStartStatus(value, fallbackProfile) {
     return {
         profile: asString(profile?.name) ?? fallbackProfile,
         serverUrl: asString(root.serverUrl),
-        cwd: asString(root.cwd),
+        // `root.cwd` is where THIS `status` ran from (the person's shell), not where
+        // the daemon runs. The recovery command binds a login to its `--cwd`, and
+        // `skrrd status` itself prints `effectiveCwd` (live daemon, then installed
+        // service, then the stored binding) for exactly that. A runtime binary that
+        // predates `effectiveCwd` only has `cwd`.
+        cwd: asString(root.effectiveCwd) ?? asString(root.cwd),
         reauth: {
             needed: reauth?.needed === true,
             reason: asString(reauth?.reason),