@skrr-ai/cli 0.1.104 → 0.1.105

package/dist/lib/task-economics.d.ts

@@ -3,6 +3,8 @@ export declare function economicsFromFlags(flags: {
     per?: string;
     effort?: string;
     risk?: string;
+    confidence?: string;
+    rationale?: string;
 }, existing?: unknown): {
     savings?: {
         amount: number;
@@ -14,3 +16,16 @@ export declare function economicsFromFlags(flags: {
     confidence?: "low" | "medium" | "high" | undefined;
     rationale?: string | undefined;
 } | undefined;
+/**
+ * One readable line for an estimate: `USD 7/month · 4h effort · medium risk · Human confirmed`.
+ * `economics-compare` printed the stored object as one minified JSON line (OSK-15368). A dimension
+ * the estimate does not carry is named as not set, never skipped.
+ */
+export declare function describeEstimate(economics: unknown): string;
+/**
+ * The number `--rank economics` sorts by, so the order can be read off the screen (OSK-15374):
+ * annualized USD savings per effort hour (floored at half an hour), times the risk factor
+ * (low 1, medium 0.6, high 0.25). `—` when savings, effort or risk is missing: such a row is not
+ * scored and sorts after every row that is.
+ */
+export declare function economicsScoreText(economics: unknown): string;

package/dist/lib/task-economics.js

@@ -1,22 +1,87 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.economicsFromFlags = economicsFromFlags;
+exports.describeEstimate = describeEstimate;
+exports.economicsScoreText = economicsScoreText;
 const data_provider_1 = require("@skrr-ai/data-provider");
+/**
+ * A flag's amount as a number, or an error that names the flag and the value (OSK-15366). A raw
+ * Zod issue array named internal paths (`savings.amount`, `effortHours`) and no flag, so a person
+ * who typed `--savings 1,000` was shown a JSON dump of `too_small` and `invalid_type`.
+ */
+function amountFlag(flag, value) {
+    const amount = Number(value);
+    if (value.trim() === '' || !Number.isFinite(amount) || amount < 0) {
+        const hint = /,/.test(value) ? ' Write it without a thousands separator.' : '';
+        throw new Error(`${flag} must be a non-negative number (got '${value}').${hint}`);
+    }
+    return amount;
+}
+/** Zod's internal path, in the flag a person typed. */
+const FLAG_FOR_PATH = {
+    'savings.amount': '--savings',
+    'savings.per': '--per',
+    effortHours: '--effort',
+    risk: '--risk',
+    confidence: '--confidence',
+    rationale: '--rationale',
+};
 function economicsFromFlags(flags, existing) {
-    if ([flags.savings, flags.per, flags.effort, flags.risk].every((value) => value === undefined))
+    if ([flags.savings, flags.per, flags.effort, flags.risk, flags.confidence, flags.rationale].every((value) => value === undefined))
         return undefined;
     if ((flags.savings === undefined) !== (flags.per === undefined))
         throw new Error('--savings and --per must be supplied together (USD/month, year or once).');
-    for (const value of [flags.savings, flags.effort])
-        if (value !== undefined && value.trim() === '')
-            throw new Error('Economic amounts must be explicit nonnegative numbers.');
+    const savings = flags.savings === undefined ? undefined : amountFlag('--savings', flags.savings);
+    const effort = flags.effort === undefined ? undefined : amountFlag('--effort', flags.effort);
     const content = existing && typeof existing === 'object' ? existing : {};
-    return data_provider_1.ProposalEconomicsInputSchema.parse({
+    const parsed = data_provider_1.ProposalEconomicsInputSchema.safeParse({
         ...content,
-        ...(flags.savings !== undefined
-            ? { savings: { amount: Number(flags.savings), currency: 'USD', per: flags.per } }
+        ...(savings !== undefined
+            ? { savings: { amount: savings, currency: 'USD', per: flags.per } }
             : {}),
-        ...(flags.effort !== undefined ? { effortHours: Number(flags.effort) } : {}),
+        ...(effort !== undefined ? { effortHours: effort } : {}),
         ...(flags.risk !== undefined ? { risk: flags.risk } : {}),
+        ...(flags.confidence !== undefined ? { confidence: flags.confidence } : {}),
+        ...(flags.rationale !== undefined ? { rationale: flags.rationale } : {}),
     });
+    if (parsed.success)
+        return parsed.data;
+    // One line per refused field, in the flag when there is one, never the raw issue array.
+    throw new Error(parsed.error.issues
+        .map((issue) => {
+        const path = issue.path.join('.');
+        return `${FLAG_FOR_PATH[path] ?? `economics.${path || 'value'}`}: ${issue.message}`;
+    })
+        .join('\n'));
+}
+const BASIS_WORDS = {
+    agent_estimate: 'Agent estimate',
+    human_confirmed: 'Human confirmed',
+    measured: 'Measured',
+};
+/**
+ * One readable line for an estimate: `USD 7/month · 4h effort · medium risk · Human confirmed`.
+ * `economics-compare` printed the stored object as one minified JSON line (OSK-15368). A dimension
+ * the estimate does not carry is named as not set, never skipped.
+ */
+function describeEstimate(economics) {
+    const value = (economics && typeof economics === 'object' ? economics : {});
+    return [
+        value.savings
+            ? `${value.savings.currency ?? 'USD'} ${value.savings.amount}/${value.savings.per}`
+            : 'savings not set',
+        value.effortHours !== undefined ? `${value.effortHours}h effort` : 'effort not set',
+        value.risk ? `${value.risk} risk` : 'risk not set',
+        BASIS_WORDS[value.basis ?? ''] ?? 'basis unknown',
+    ].join(' · ');
+}
+/**
+ * The number `--rank economics` sorts by, so the order can be read off the screen (OSK-15374):
+ * annualized USD savings per effort hour (floored at half an hour), times the risk factor
+ * (low 1, medium 0.6, high 0.25). `—` when savings, effort or risk is missing: such a row is not
+ * scored and sorts after every row that is.
+ */
+function economicsScoreText(economics) {
+    const score = (0, data_provider_1.proposalEconomicsRank)(economics).score;
+    return score === null || !Number.isFinite(score) ? '—' : String(Math.round(score));
 }

package/dist/lib/task-recurrence-outcome.d.ts

@@ -0,0 +1,19 @@
+/**
+ * What completing a recurring occurrence did to its series, as a sentence (OSK-15483).
+ *
+ * `tasks complete` armed the next occurrence (or deliberately did not) and printed nothing either way, so a
+ * person could not tell that the series continued, or that the third of three runs had ended it. The server
+ * reports `recurrence` on the completion; this words it.
+ */
+export type RecurrenceOutcome = {
+    state?: string;
+    reason?: string;
+    successor?: {
+        id?: string;
+        identifier?: string | null;
+        scheduledFor?: string | null;
+    };
+    armFailure?: unknown;
+};
+/** One line, or null when the Task does not recur (or an older server did not say). */
+export declare function recurrenceOutcomeLine(outcome: RecurrenceOutcome | null | undefined): string | null;

package/dist/lib/task-recurrence-outcome.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recurrenceOutcomeLine = recurrenceOutcomeLine;
+const ENDED_BECAUSE = {
+    max_runs: 'it reached its maximum number of runs',
+    end_date: 'its end date has passed',
+    no_next_occurrence: 'its pattern has no further occurrence',
+};
+/** One line, or null when the Task does not recur (or an older server did not say). */
+function recurrenceOutcomeLine(outcome) {
+    if (!outcome || typeof outcome !== 'object')
+        return null;
+    switch (outcome.state) {
+        case 'armed': {
+            const next = outcome.successor?.identifier || outcome.successor?.id || 'the next occurrence';
+            const when = outcome.successor?.scheduledFor ? ` for ${outcome.successor.scheduledFor}` : '';
+            return `Recurrence: next occurrence ${next} is scheduled${when}.`;
+        }
+        case 'ended':
+            return `Recurrence: the series has ended; ${ENDED_BECAUSE[outcome.reason ?? ''] ?? 'nothing further is due'}.`;
+        case 'paused':
+            return 'Recurrence: the series is paused, so no next occurrence was scheduled.';
+        case 'routine_managed':
+            return 'Recurrence: a Routine owns this series, so no next occurrence was scheduled here.';
+        case 'not_armed':
+            return 'Recurrence: the series is live but no next occurrence was scheduled; check it with `tasks show`.';
+        default:
+            return null;
+    }
+}

package/dist/lib/triggers.d.ts

@@ -295,6 +295,41 @@ export declare function assertKindFlagsApply(kind: unknown, flags: Record<string
  * by itself (OSK-15492). Absent when the server reported nothing to say.
  */
 export declare function describeScheduledFire(result: Record<string, unknown>): string | undefined;
+/**
+ * Was the fire admitted? `in_progress` and `awaiting_runtime` are admissions whose terminal arrives
+ * later (every agent-turn fire answers `in_progress`), and a repeat of a fire that was admitted is
+ * `duplicate` with the original beside it; none of them is a refusal (OSK-3867 made the same mistake
+ * about `in_progress` once). Only these are success for `triggers fire --strict`.
+ */
+export declare function fireWasAccepted(result: Record<string, unknown>): boolean;
+/**
+ * The lines a fire or replay owes beyond `outcome=… reason=…` (OSK-15494): the sentence the
+ * server wrote ("Replayed fire … resolved a step that was not waiting when that fire ran:
+ * run …, step …"), or, for a debounced fire, when a retry will be accepted. Empty when the server
+ * reported nothing more.
+ */
+export declare function describeFireDetail(result: Record<string, unknown>): string[];
+/**
+ * A projected fire as the trigger's own clock reads it. The header said `America/New_York` over
+ * values that were UTC instants, so nothing on the line was in the zone it named (OSK-15407). The
+ * instant itself stays beside it, exact.
+ */
+export declare function formatFireInZone(iso: string, timeZone: string | undefined): string;
+/**
+ * The lines `triggers preflight` prints under "Next fires". A fire the trigger's own working or
+ * quiet window would skip is marked, because the gate above is evaluated at the current instant
+ * only and a window that excludes every scheduled time otherwise read as healthy (OSK-15407).
+ */
+type PreflightSchedule = NonNullable<TriggerPreflightReport['schedule']>;
+export declare function nextFireLines(schedule: PreflightSchedule | null | undefined): string[];
+/**
+ * A destination as `key=value` pairs, without Mongo's storage fields.
+ *
+ * A nested object that is longer than a short locator (`agentChat` is the Agent's whole chat row,
+ * with the preview of its last message) is named by its id, not dumped: the line printed ~700
+ * characters of unrelated chat state into a preflight (OSK-16200). `--json` carries all of it.
+ */
+export declare function destinationLine(destination: Record<string, unknown>): string;
 export declare function withQuery(path: string, params: Record<string, string | number | boolean | string[] | undefined>): string;
 /**
  * Build the universal-engine scope block for an agent-owned trigger.
@@ -349,6 +384,12 @@ export declare class AgentTriggerScopeError extends Error {
  */
 export declare function fetchAgentScopedTrigger(agentId: string, triggerId: string): Promise<TriggerDefinition>;
 export declare function scopeLabel(trigger: TriggerDefinition): string;
+/**
+ * When an armed `once` trigger is due: its `once.runAt` (or `once.at`), and only while it has not
+ * fired. A follow-up check-in due next month had no `schedule.nextRunAt`, so every table said `-` and
+ * `triggers show` said `Armed: yes` with no time (OSK-15416).
+ */
+export declare function onceDueAt(trigger: TriggerDefinition): string | null;
 export declare function nextRunLabel(trigger: TriggerDefinition): string;
 /**
  * Whether a trigger will actually fire — not merely whether someone left it on.
@@ -511,3 +552,4 @@ export declare const triggerApi: {
     setSpaceAssistant: (spaceId: string, body: Record<string, unknown>) => Promise<SpaceAssistantResponse>;
     deleteSpaceAssistant: (spaceId: string) => Promise<Record<string, unknown>>;
 };
+export {};

package/dist/lib/triggers.js

@@ -25,12 +25,18 @@ exports.mergeObjectField = mergeObjectField;
 exports.mergeTriggerKindConfig = mergeTriggerKindConfig;
 exports.assertKindFlagsApply = assertKindFlagsApply;
 exports.describeScheduledFire = describeScheduledFire;
+exports.fireWasAccepted = fireWasAccepted;
+exports.describeFireDetail = describeFireDetail;
+exports.formatFireInZone = formatFireInZone;
+exports.nextFireLines = nextFireLines;
+exports.destinationLine = destinationLine;
 exports.withQuery = withQuery;
 exports.agentScope = agentScope;
 exports.spaceSubscriberScope = spaceSubscriberScope;
 exports.agentRefEntity = agentRefEntity;
 exports.fetchAgentScopedTrigger = fetchAgentScopedTrigger;
 exports.scopeLabel = scopeLabel;
+exports.onceDueAt = onceDueAt;
 exports.nextRunLabel = nextRunLabel;
 exports.armedLabel = armedLabel;
 exports.degradedMarker = degradedMarker;
@@ -766,6 +772,116 @@ function describeScheduledFire(result) {
     }
     return undefined;
 }
+/**
+ * Was the fire admitted? `in_progress` and `awaiting_runtime` are admissions whose terminal arrives
+ * later (every agent-turn fire answers `in_progress`), and a repeat of a fire that was admitted is
+ * `duplicate` with the original beside it; none of them is a refusal (OSK-3867 made the same mistake
+ * about `in_progress` once). Only these are success for `triggers fire --strict`.
+ */
+function fireWasAccepted(result) {
+    const accepted = data_provider_1.ACCEPTED_AGENT_TRIGGER_FIRE_OUTCOMES;
+    if (typeof result.outcome === 'string' && accepted.includes(result.outcome))
+        return true;
+    return (result.outcome === 'duplicate' &&
+        typeof result.originalOutcome === 'string' &&
+        accepted.includes(result.originalOutcome));
+}
+/**
+ * The lines a fire or replay owes beyond `outcome=… reason=…` (OSK-15494): the sentence the
+ * server wrote ("Replayed fire … resolved a step that was not waiting when that fire ran:
+ * run …, step …"), or, for a debounced fire, when a retry will be accepted. Empty when the server
+ * reported nothing more.
+ */
+function describeFireDetail(result) {
+    const lines = [];
+    if (typeof result.detail === 'string' && result.detail.trim())
+        lines.push(result.detail.trim());
+    else if (typeof result.retryAt === 'string' && result.retryAt) {
+        lines.push(`Try again after ${result.retryAt}.`);
+    }
+    // A fire option the server does not read is named, because dropping it without a word left a caller
+    // unable to tell whether `--from-json` was honoured (OSK-15498).
+    if (Array.isArray(result.ignoredOptions) && result.ignoredOptions.length > 0) {
+        lines.push(`Ignored fire options (a fire does not read them): ${result.ignoredOptions.map(String).join(', ')}`);
+    }
+    // Only a fire that resolved a step: an executionRef is a job id, a message id or a
+    // notification id for every other executor, and "Resolved:" would be wrong for them.
+    if (typeof result.executionRef === 'string' &&
+        result.executionRef &&
+        result.outcome === 'succeeded' &&
+        typeof result.reason === 'string' &&
+        result.reason.startsWith('resolved:')) {
+        lines.push(`Resolved: ${result.executionRef}`);
+    }
+    return lines;
+}
+const FIRE_DENIAL_WORDS = {
+    outside_working_hours: 'outside working hours',
+    inside_quiet_hours: 'inside quiet hours',
+};
+/**
+ * A projected fire as the trigger's own clock reads it. The header said `America/New_York` over
+ * values that were UTC instants, so nothing on the line was in the zone it named (OSK-15407). The
+ * instant itself stays beside it, exact.
+ */
+function formatFireInZone(iso, timeZone) {
+    const date = new Date(iso);
+    if (!timeZone || Number.isNaN(date.getTime()))
+        return iso;
+    try {
+        const parts = new Intl.DateTimeFormat('en-CA', {
+            timeZone,
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            hourCycle: 'h23',
+            timeZoneName: 'short',
+        }).formatToParts(date);
+        const part = (type) => parts.find((entry) => entry.type === type)?.value ?? '';
+        return `${part('year')}-${part('month')}-${part('day')} ${part('hour')}:${part('minute')} ${part('timeZoneName')} (${iso})`;
+    }
+    catch {
+        return iso;
+    }
+}
+function nextFireLines(schedule) {
+    if (!schedule?.nextFires?.length)
+        return [];
+    const windows = new Map((schedule.nextFireWindows ?? []).map((entry) => [entry.at, entry]));
+    const lines = [`Next fires (${schedule.timezone}):`];
+    for (const at of schedule.nextFires) {
+        const window = windows.get(at);
+        const mark = window && !window.runs
+            ? `   ✗ would be skipped: ${FIRE_DENIAL_WORDS[window.reason ?? ''] ?? window.reason ?? 'window'}`
+            : '';
+        lines.push(`  ${formatFireInZone(at, schedule.timezone)}${mark}`);
+    }
+    return lines;
+}
+/**
+ * A destination as `key=value` pairs, without Mongo's storage fields.
+ *
+ * A nested object that is longer than a short locator (`agentChat` is the Agent's whole chat row,
+ * with the preview of its last message) is named by its id, not dumped: the line printed ~700
+ * characters of unrelated chat state into a preflight (OSK-16200). `--json` carries all of it.
+ */
+function destinationLine(destination) {
+    const fields = Object.entries(destination).filter(([key]) => key !== '_id' && key !== '__v');
+    return fields.map(([key, value]) => `${key}=${destinationValue(value)}`).join(' ');
+}
+const DESTINATION_INLINE_MAX = 80;
+function destinationValue(value) {
+    if (typeof value !== 'object' || value === null)
+        return String(value);
+    const json = JSON.stringify(value);
+    if (json.length <= DESTINATION_INLINE_MAX)
+        return json;
+    const record = value;
+    const id = [record.agentChatId, record.id, record.conversationId].find((candidate) => typeof candidate === 'string' && candidate);
+    return id ? String(id) : `{${Object.keys(record).length} fields; see --json}`;
+}
 function withQuery(path, params) {
     const search = new URLSearchParams();
     for (const [key, value] of Object.entries(params)) {
@@ -849,9 +965,24 @@ function scopeLabel(trigger) {
         .join(',');
     return refText ? `${kind}:${refText}` : kind;
 }
+/**
+ * When an armed `once` trigger is due: its `once.runAt` (or `once.at`), and only while it has not
+ * fired. A follow-up check-in due next month had no `schedule.nextRunAt`, so every table said `-` and
+ * `triggers show` said `Armed: yes` with no time (OSK-15416).
+ */
+function onceDueAt(trigger) {
+    if (trigger.kind !== 'once' || !trigger.once)
+        return null;
+    const once = trigger.once;
+    if (once.firedAt || trigger.enabled === false)
+        return null;
+    const due = once.runAt ?? once.at;
+    return due ? String(due) : null;
+}
 function nextRunLabel(trigger) {
     const next = trigger.schedule?.nextRunAt ??
         trigger.selfScheduled?.nextRunAt ??
+        onceDueAt(trigger) ??
         trigger.audit?.lastFiredAt ??
         '';
     return next ? String(next) : '-';
@@ -1073,8 +1204,11 @@ function renderTriggerSummary(trigger, log, options = {}) {
     if (effect?.writeMode)
         log(`Writes:   ${writeModeLabel(String(effect.writeMode))}`);
     const next = nextRunLabel(trigger);
-    if (next !== '-')
-        log(`Next/last:${next.length > 0 ? ` ${next}` : ''}`);
+    if (next !== '-') {
+        // `nextRunLabel` falls back to the last fire when nothing is scheduled; say which it is.
+        const upcoming = Boolean(trigger.schedule?.nextRunAt ?? trigger.selfScheduled?.nextRunAt ?? onceDueAt(trigger));
+        log(`${upcoming ? 'Next run:' : 'Last run:'}${next.length > 0 ? ` ${next}` : ''}`);
+    }
     /*
      * What actually happened when it fired.
      *

package/dist/lib/widgetTerminalText.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param text   the answer so far, widget blocks included
+ * @param final  the answer will not grow any more (release held-back text, and report
+ *               a block still open as cut off)
+ */
+export declare function widgetsAsText(text: string, { final }: {
+    final: boolean;
+}): string;

package/dist/lib/widgetTerminalText.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.widgetsAsText = widgetsAsText;
+/**
+ * An agent's answer as a TERMINAL can show it: each widget block replaced by its
+ * fallback sentence.
+ *
+ * An agent may answer with a widget: a fenced block of CSS, HTML and JavaScript
+ * that the web and mobile apps draw in a sandboxed frame. A terminal cannot draw
+ * one, and printing the block is not a faithful rendering of it: it is a program,
+ * dumped between two paragraphs of prose, that can run to hundreds of kilobytes.
+ * The design record is explicit that the CLI is one of the consumers that "gets the
+ * sentence" (docs/architecture/generative-ui-2026-10-13.md section 15.4), the same
+ * sentence the server stores as `Message.text` and sends to a channel. The block
+ * itself is in the persisted message for the app to draw.
+ *
+ * WHICH LANES THIS COVERS. The streaming lane (`text.delta`), the final answer
+ * (`run.result`, `--no-stream`, `--json`'s `response`) and the comparison against the
+ * persisted record all read the ANSWER, and now all read this. The raw lane does
+ * not: a `session.output` envelope is the wire, and `--jsonl` keeps mirroring it
+ * unchanged for a consumer that wants the block itself (a coding agent that asked a
+ * cloud agent for a widget, say). That is where the source is.
+ *
+ * ONE PARSER. The grammar is read only through the shared incremental parser
+ * (`createUiWidgetFenceParser`), the one the web client and the server use, so a
+ * block is recognised, bounded and refused identically on every surface; this file
+ * never spells the fence. What it adds is the JOIN: how a substituted sentence sits
+ * among the prose. That rule is the server's (`GenerativeUi/ingest.js`
+ * `createTextDeriver`, which produces `Message.text`) and is mirrored here, because
+ * a terminal-side answer that spaced the sentence differently would be a second,
+ * quietly different text, and the whitespace-insensitive comparison against the
+ * record (`streamShowsRecordedText`) would no longer be the only thing keeping the
+ * two honest. The join: a fallback is its own paragraph, preceded by a blank line
+ * unless the text so far already ends in one, and followed by a blank line before
+ * whatever comes next; the break is written only when something follows, so the
+ * result only ever grows by appending while the input grows, which is what a
+ * terminal that prints "what is new" needs (`renderableDelta`).
+ *
+ * `final: false` holds back a trailing line that could still turn into a block
+ * opener, so text a terminal has already printed is never retracted.
+ */
+const data_provider_1 = require("@skrr-ai/data-provider");
+const PARAGRAPH_BREAK = '\n\n';
+/** The last line of `text` starts with a colon: the shape a held-back opener has. */
+function endsInColonLine(text) {
+    const start = Math.max(text.lastIndexOf('\n'), text.lastIndexOf('\r')) + 1;
+    return text.charCodeAt(start) === 58;
+}
+/** What must precede a paragraph so a blank line separates it from `tail`. */
+function leadForBlankLine(tail) {
+    if (tail.endsWith('\n\n'))
+        return '';
+    if (tail.endsWith('\n'))
+        return '\n';
+    return PARAGRAPH_BREAK;
+}
+/** Fence-looking lines in a substituted sentence are pushed off column 0, so nothing re-reads them as a block. */
+const OPENER_AT_LINE_START = new RegExp(`^(:{${data_provider_1.UI_WIDGET_FENCE.minColons},})`, 'gm');
+function fallbackFor(event) {
+    if (event.type === 'widget-complete')
+        return (0, data_provider_1.uiWidgetFallbackText)(event.payload);
+    // A cut-off block contributes nothing: its sentence is not known yet, and adding the
+    // title now would make a later, shorter sentence shrink the text.
+    if (event.type === 'widget-error' && event.partial && event.reason !== 'truncated') {
+        return (0, data_provider_1.uiWidgetFallbackText)(event.partial);
+    }
+    return '';
+}
+/**
+ * @param text   the answer so far, widget blocks included
+ * @param final  the answer will not grow any more (release held-back text, and report
+ *               a block still open as cut off)
+ */
+function widgetsAsText(text, { final }) {
+    // Cheap necessary condition for any work at all: a block needs the fence name, and
+    // while text is still streaming a trailing colon line may be an opener not yet decided.
+    if (text.indexOf(data_provider_1.UI_WIDGET_FENCE.name) === -1 && !(!final && endsInColonLine(text))) {
+        return text;
+    }
+    const parser = (0, data_provider_1.createUiWidgetFenceParser)();
+    const events = parser.push(text).slice();
+    if (final)
+        events.push(...parser.end());
+    let out = '';
+    let tail = '';
+    let started = false;
+    let pendingBreak = false;
+    const emit = (chunk) => {
+        if (chunk === '')
+            return;
+        started = true;
+        tail = (tail + chunk).slice(-2);
+        out += chunk;
+    };
+    for (const event of events) {
+        if (event.type === 'text') {
+            if (event.text === '')
+                continue;
+            const lead = pendingBreak ? PARAGRAPH_BREAK : '';
+            pendingBreak = false;
+            emit(lead + event.text);
+            continue;
+        }
+        const fallback = fallbackFor(event);
+        if (!fallback)
+            continue;
+        let lead = '';
+        if (pendingBreak)
+            lead = PARAGRAPH_BREAK;
+        else if (started)
+            lead = leadForBlankLine(tail);
+        pendingBreak = true;
+        emit(lead + fallback.replace(OPENER_AT_LINE_START, ' $1'));
+    }
+    return out;
+}

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/cliHandoffWire.d.ts

@@ -133,3 +133,36 @@ export declare function parseCliHandoffDpopProofResponse(value: unknown): CliHan
 export declare const DELEGATED_AGENT_CLI_ID_PREFIX = "oversky-daemon-agent-cli-";
 export declare const WORKLOAD_CLI_ID_PREFIX = "oversky-daemon-workload-cli-";
 export declare function classifyCliFamilyId(id: unknown): 'agent' | 'workload' | 'person';
+/**
+ * Who keeps a daemon running, which decides how it is signed in again.
+ *  - `desktop`: the Skrr desktop app hosts it (Electron-as-Node under the
+ *    app's LaunchAgent). The app mints the daemon's credential itself at
+ *    `POST /api/daemons/token`, with a device proof, on every start of its
+ *    daemon client (OSK-15990), so reopening the app IS the sign-in. Neither
+ *    login command repairs it: `skrr daemon login` refuses an Electron-hosted
+ *    daemon (its program is the app, not a `skrrd`), and a `skrrd` on PATH is
+ *    usually not installed, or is a different build from the one running.
+ *  - `service`: `skrrd install` (launchd/systemd/schtasks) or a hand start;
+ *    `skrrd login` for that profile, server and working directory is the fix.
+ */
+export type DaemonSupervisor = 'desktop' | 'service';
+/**
+ * The ONE sentence for "only a new daemon sign-in repairs this hand-off
+ * refusal" (OSK-16216). The daemon fills it in with what it knows about
+ * itself and sends it as the loopback 503's `remedy`; the CLI uses it, with
+ * nothing filled in, when an older daemon sent none. Before this the two were
+ * written separately and disagreed — the CLI said `skrr daemon login`, the
+ * daemon said `skrrd --profile … login` — and neither was right for a daemon
+ * the desktop app runs.
+ *
+ * Returned without a leading capital or trailing period so callers can put it
+ * after "Fix: " or "— ".
+ */
+export declare function daemonSignInRemedy(opts?: {
+    /** How the daemon is run; absent when the caller cannot tell. */
+    supervisor?: DaemonSupervisor;
+    /** The exact `skrrd … login` for this profile, when the daemon knows it. */
+    loginCommand?: string;
+    /** The refusal was DEVICE_PROOF_PIN_MISMATCH: say that a sign-in re-pins. */
+    repinsDeviceKey?: boolean;
+}): string;

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/cliHandoffWire.js

@@ -27,6 +27,7 @@ exports.descriptorOffersDpop = descriptorOffersDpop;
 exports.parseCliHandoffTokenResponse = parseCliHandoffTokenResponse;
 exports.parseCliHandoffDpopProofResponse = parseCliHandoffDpopProofResponse;
 exports.classifyCliFamilyId = classifyCliFamilyId;
+exports.daemonSignInRemedy = daemonSignInRemedy;
 /**
  * What a caller may redeem the descriptor secret for.
  *  - `refresh_family`: the legacy durable mint (90-day cli-scope family).
@@ -156,3 +157,29 @@ function classifyCliFamilyId(id) {
         return 'workload';
     return 'person';
 }
+/**
+ * The ONE sentence for "only a new daemon sign-in repairs this hand-off
+ * refusal" (OSK-16216). The daemon fills it in with what it knows about
+ * itself and sends it as the loopback 503's `remedy`; the CLI uses it, with
+ * nothing filled in, when an older daemon sent none. Before this the two were
+ * written separately and disagreed — the CLI said `skrr daemon login`, the
+ * daemon said `skrrd --profile … login` — and neither was right for a daemon
+ * the desktop app runs.
+ *
+ * Returned without a leading capital or trailing period so callers can put it
+ * after "Fix: " or "— ".
+ */
+function daemonSignInRemedy(opts = {}) {
+    const repin = opts.repinsDeviceKey === true;
+    if (opts.supervisor === 'desktop') {
+        return ('quit and reopen the Skrr desktop app on the machine running the daemon (install its update ' +
+            `first if one is offered): the app signs its daemon in again on start${repin ? ' and re-pins the device key' : ''}`);
+    }
+    if (opts.supervisor === 'service') {
+        const login = opts.loginCommand ? `\`${opts.loginCommand}\`` : '`skrr daemon login`';
+        return `run ${login}${repin ? ' — an interactive login re-pins the device key' : ''}`;
+    }
+    return ('sign the daemon in again on the machine running it: if the Skrr desktop app runs it, quit ' +
+        'and reopen the app; otherwise run `skrr daemon login`' +
+        (repin ? ' (either one re-pins the device key)' : ''));
+}

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/telemetryRedaction.d.ts

@@ -16,10 +16,30 @@
  * and `api/server/services/HostedPreview/__tests__/telemetryRedaction.spec.js` against tokens the issuer really
  * mints, so a change to either side fails there rather than in a trace nobody reads.
  *
+ * THE OTHER PATH CREDENTIALS (OSK-16174). Four more bearer credentials travel in a URL, and until they were added here
+ * only the request logger's path rewrite (`requestLogger.js`) knew them, so the same address that was scrubbed from a
+ * log line reached a trace and an error report in full: a workspace invitation (`wsi_`), a platform invitation
+ * (`pinv_`), a member's invitation link (`usr_`) and an operator's (`adm2_`, and the older `adm_`). Unlike `pvw_`, whose
+ * prefix is rare enough to match on its own, `usr_` and `adm_` begin ordinary words and identifiers (`/usr_local`,
+ * `adm_users`), so each of these is recognised by the SHAPE its minting code gives it, and a lookalike is left alone:
+ *
+ *   wsi_ / pinv_ / usr_ / adm2_   `<prefix>_<32 hex>.<version>.<key id>.<43 base64url>`, from `buildCredential` in
+ *                                 `api/models/WorkspaceInvite.js` and `PlatformInvitation.js` and `buildUserCode` and
+ *                                 `buildAdminCode` in `InvitationCode.js`. The older member link, `usr_<32 hex>.<24
+ *                                 base64url>`, has the same first two fields. Matched from the prefix to the end of the
+ *                                 token's characters once the 32-hex id and its dot are there, so a credential cut off
+ *                                 later in the log line is still redacted whole.
+ *   adm_                          `adm_<43 base64url>`, the older operator code (`generateCode`: 32 random bytes).
+ *                                 Exactly 43 characters, because that is the only length it has.
+ *
+ * `api/server/services/HostedPreview/__tests__/telemetryRedaction.spec.js` mints credentials with the real minting
+ * code and requires every one to come out as the marker, so a change to either side fails there.
+ *
  * WHAT IT DOES NOT. A prefix that is itself percent-encoded (`%70vw_`) is not recognised: nothing in this
- * repository writes one, and a scan that decoded every string first would cost every sink on every record. The
- * request log's own `/[credential]` rewrite (`requestLogger.js`) covers the other credential prefixes and
- * stays as it is.
+ * repository writes one, and a scan that decoded every string first would cost every sink on every record. A
+ * credential cut off before its id is whole (`pinv_0123abc`) is an identifier, not yet the secret, and is left as it
+ * is. The request log's own `/[credential]` rewrite stays as it is, and is looser (any `wsi_`, `pinv_`, `usr_`,
+ * `adm_`, `adm2_` or `pvw_` path segment), because a path segment is a place a credential is known to be.
  *
  * COST. Linear in the input. The only nested repetition is `%(?:25)*XX`, and `XX` is never `25`, so the engine
  * cannot read one run of `25`s two ways; the tests feed it a megabyte of the worst shapes.
@@ -31,8 +51,11 @@
 /** What replaces a token. Fixed, so a trace can say a preview was involved but not which one. */
 export declare const PREVIEW_TOKEN_REDACTION: "pvw_[redacted]";
 /**
- * Replace every preview token in a string with {@link PREVIEW_TOKEN_REDACTION}. The rest of the string is
- * untouched, so a trace is still readable. Anything that is not a string comes back as it came.
+ * Replace every credential that travels in a URL with a marker: a Hosted Machine preview token with
+ * {@link PREVIEW_TOKEN_REDACTION}, and a workspace invitation, platform invitation, member link or operator code with
+ * its own prefix and `_[redacted]`. The rest of the string is untouched, so a trace is still readable. Anything
+ * that is not a string comes back as it came. (The name is the preview token's, which this began as; the sinks
+ * and the boundary specs import it by that name.)
  */
 export declare function redactPreviewTokens(value: string): string;
 export declare function redactPreviewTokens<T>(value: T): T;