@skrr-ai/cli 0.1.104 → 0.1.106

package/dist/lib/proposal-decision-command.js

@@ -9,9 +9,15 @@ const proposals_1 = require("./proposals");
  * before an old decision would approve content the caller never reviewed. */
 class ProposalDecisionCommand extends base_command_1.BaseCommand {
     static decision;
+    // The kind is validated in `resolveProposalRef`, not by oclif, so the KIND:ID that `proposals list`
+    // prints can be pasted whole (OSK-15371).
     static args = {
-        kind: core_1.Args.string({ required: true, options: [...data_provider_1.PROPOSAL_KINDS], ignoreStdin: true }),
-        id: core_1.Args.string({ required: true, ignoreStdin: true }),
+        kind: core_1.Args.string({
+            required: true,
+            description: 'Proposal kind, or the KIND:ID that `proposals list` prints',
+            ignoreStdin: true,
+        }),
+        id: core_1.Args.string({ required: false, description: 'Proposal id', ignoreStdin: true }),
     };
     static flags = {
         json: core_1.Flags.boolean(),
@@ -45,9 +51,18 @@ class ProposalDecisionCommand extends base_command_1.BaseCommand {
             if (until > Date.now() + data_provider_1.PROPOSAL_SNOOZE_MAX_DAYS * 86400000)
                 this.error(`--until may be at most ${data_provider_1.PROPOSAL_SNOOZE_MAX_DAYS} days ahead.`);
         }
+        const ref = (0, proposals_1.resolveProposalRef)(args.kind, args.id, this.config?.bin);
+        if ('error' in ref) {
+            this.failWithCliError({
+                message: ref.error,
+                code: 'PROPOSAL_REF_INVALID',
+                exit: 2,
+                retryable: false,
+            });
+        }
         let result;
         try {
-            result = await proposals_1.proposalApi.decide(args.kind, args.id, {
+            result = await proposals_1.proposalApi.decide(ref.kind, ref.id, {
                 decision,
                 expected,
                 reason: flags.reason,
@@ -56,6 +71,15 @@ class ProposalDecisionCommand extends base_command_1.BaseCommand {
             });
         }
         catch (error) {
+            if (error?.status === 404) {
+                this.failWithCliError({
+                    message: (0, proposals_1.describeProposalNotFound)(ref.kind, ref.id, this.config?.bin),
+                    code: 'PROPOSAL_NOT_FOUND',
+                    status: 404,
+                    exit: 4,
+                    retryable: false,
+                });
+            }
             this.handleApiError(error);
         }
         this.log(flags.json ? JSON.stringify(result, null, 2) : `Proposal ${decision} decision recorded.`);

package/dist/lib/proposals.d.ts

@@ -6,3 +6,20 @@ export declare const proposalApi: {
     show(kind: ProposalKind, id: string): Promise<ProposalView>;
     decide(kind: ProposalKind, id: string, input: ProposalDecisionParams): Promise<ProposalDecisionResponse>;
 };
+/**
+ * The proposal a person pointed at, from what they typed or pasted (OSK-15371, OSK-15354).
+ *
+ * `proposals list` prints one token, `KIND:ID`, and `show`/`keep`/`discard`/`snooze` wanted two
+ * arguments, so pasting the list's own output failed with a message listing six kinds that never
+ * said the id belonged in a second argument. Both spellings are accepted now. The kind never
+ * contains a colon, so the FIRST one splits (a Northstar intent's id is itself
+ * `<review-id>:<intent-id>`), and `KIND KIND:ID` is accepted too.
+ */
+export declare function resolveProposalRef(kindArg: string | undefined, idArg: string | undefined, bin?: string): {
+    kind: ProposalKind;
+    id: string;
+} | {
+    error: string;
+};
+/** A 404 here means no such proposal under THIS kind: the id is looked up under the kind given. */
+export declare function describeProposalNotFound(kind: string, id: string, bin?: string): string;

package/dist/lib/proposals.js

@@ -1,7 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.proposalApi = void 0;
+exports.resolveProposalRef = resolveProposalRef;
+exports.describeProposalNotFound = describeProposalNotFound;
 const data_provider_1 = require("@skrr-ai/data-provider");
+const data_provider_2 = require("@skrr-ai/data-provider");
 const triggers_1 = require("./triggers");
 const MOUNT = '/api/proposals';
 /** The unified, read-time proposal inbox. Decisions are routed by the server to
@@ -20,3 +23,41 @@ exports.proposalApi = {
         });
     },
 };
+/**
+ * The proposal a person pointed at, from what they typed or pasted (OSK-15371, OSK-15354).
+ *
+ * `proposals list` prints one token, `KIND:ID`, and `show`/`keep`/`discard`/`snooze` wanted two
+ * arguments, so pasting the list's own output failed with a message listing six kinds that never
+ * said the id belonged in a second argument. Both spellings are accepted now. The kind never
+ * contains a colon, so the FIRST one splits (a Northstar intent's id is itself
+ * `<review-id>:<intent-id>`), and `KIND KIND:ID` is accepted too.
+ */
+function resolveProposalRef(kindArg, idArg, bin = 'skrr') {
+    const kinds = [...data_provider_2.PROPOSAL_KINDS].join(', ');
+    const usage = `Pass KIND and ID (\`${bin} proposals show request <id>\`) or the KIND:ID that \`${bin} proposals list\` prints.`;
+    let kind = (kindArg ?? '').trim();
+    let id = (idArg ?? '').trim();
+    if (!id) {
+        const colon = kind.indexOf(':');
+        if (colon < 0) {
+            return { error: `Missing the proposal id. ${usage}` };
+        }
+        id = kind.slice(colon + 1);
+        kind = kind.slice(0, colon);
+    }
+    else if (id.startsWith(`${kind}:`)) {
+        id = id.slice(kind.length + 1);
+    }
+    if (!data_provider_2.PROPOSAL_KINDS.includes(kind)) {
+        return { error: `Unknown proposal kind "${kind}". Kinds: ${kinds}. ${usage}` };
+    }
+    if (!id) {
+        return { error: `Missing the proposal id after "${kind}". ${usage}` };
+    }
+    return { kind: kind, id };
+}
+/** A 404 here means no such proposal under THIS kind: the id is looked up under the kind given. */
+function describeProposalNotFound(kind, id, bin = 'skrr') {
+    return (`No ${kind} proposal ${id} is visible to you. A proposal is looked up under its kind, so an id ` +
+        `that exists under another kind is not found here; \`${bin} proposals list\` prints each as KIND:ID.`);
+}

package/dist/lib/stewardship-output.js

@@ -9,10 +9,26 @@ function printStewardshipCoverage(report, log) {
         log('Coverage: complete within the bounded sources.');
         return;
     }
-    const unreadable = report.coverage.sources.some((source) => source.status === 'unavailable' || source.truncated);
-    log(unreadable
-        ? 'Coverage: incomplete. Unreadable sources do not confirm absence.'
-        : 'Coverage: incomplete. Some Grants are not attributed to this workspace and are not listed.');
+    const unavailable = report.coverage.sources.some((source) => source.status === 'unavailable');
+    // A list cut at the row cap is READABLE and partial; calling it "unreadable" sent the reader looking
+    // for a permission problem (OSK-15355). `unattributedGrants` has its own line below.
+    const cut = report.coverage.sources.some((source) => source.status !== 'unavailable' && source.truncated && source.name !== 'unattributedGrants');
+    const unlistedGrants = report.coverage.sources.some((source) => source.unlisted);
+    if (unavailable || cut) {
+        log(`Coverage: incomplete. ${[
+            unavailable ? 'Unreadable sources do not confirm absence.' : null,
+            cut
+                ? 'Lists cut at the row cap are partial, so a row missing from them is not shown absent; this command has no paging.'
+                : null,
+        ]
+            .filter(Boolean)
+            .join(' ')}`);
+    }
+    else {
+        log(unlistedGrants
+            ? 'Coverage: incomplete. Some Grants are not attributed to this workspace and are not listed.'
+            : 'Coverage: incomplete.');
+    }
     for (const source of report.coverage.sources) {
         if (source.status === 'unavailable')
             log(`${source.name}: unavailable`);
@@ -25,6 +41,18 @@ function printStewardshipCoverage(report, log) {
         }
     }
 }
+/** Who holds the Grant, in the same `kind id` words `skrr grants list` uses. */
+function principalText(principal) {
+    const value = principal;
+    if (!value?.kind)
+        return '—';
+    const id = value.agentId ?? value.commitmentId;
+    return id ? `${value.kind} ${id}` : value.kind;
+}
+/** What the Grant allows: its capability names, or an honest dash when it lists none. */
+function accessText(capabilities) {
+    return Array.isArray(capabilities) && capabilities.length ? capabilities.join(', ') : '—';
+}
 function printWorkspaceGrants(report, log) {
     printStewardshipCoverage(report, log);
     printGrantRows(report, log);
@@ -44,16 +72,23 @@ function printGrantRows(report, log) {
     (0, format_1.renderTable)(report.grants.map((row) => ({
         id: row.id,
         label: row.label,
+        provider: row.provider || '—',
+        principal: principalText(row.principal),
+        access: accessText(row.capabilities),
         owner: row.ownerUserId,
         active: row.active ? 'yes' : 'no',
-        expires: row.expiresAt ?? '',
-        envKeys: row.credential?.envKeys.join(', ') ?? '',
+        // No expiry is a fact about the Grant; a blank cell read as "not readable" (OSK-15357).
+        expires: row.expiresAt ?? 'never',
+        envKeys: row.credential?.envKeys.length ? row.credential.envKeys.join(', ') : '—',
         referencedBy: row.referencedBy === null
             ? 'unavailable'
             : `${row.referencedBy.join(', ')}${row.referencesTruncated ? ' (truncated)' : ''}`,
     })), [
         { key: 'id', header: 'ID' },
         { key: 'label', header: 'LABEL' },
+        { key: 'provider', header: 'PROVIDER' },
+        { key: 'principal', header: 'HELD BY' },
+        { key: 'access', header: 'ACCESS' },
         { key: 'owner', header: 'OWNER' },
         { key: 'active', header: 'ACTIVE' },
         { key: 'expires', header: 'EXPIRES' },
@@ -63,12 +98,22 @@ function printGrantRows(report, log) {
 }
 function printWorkspaceStewardship(report, log) {
     printStewardshipCoverage(report, log);
-    log(`Membership: ${report.membership.status}${report.membership.role ? ` (${report.membership.role})` : ''}`);
-    for (const [name, rows] of [
-        ['Commitments', report.commitments],
-        ['Approver seats', report.approverSeats],
+    log(`Membership: ${report.membership.status}${report.membership.role ? ` (${report.membership.role})` : ''}${
+    // "Absent" is all the report knows: a removed member and an id that never existed read alike (OSK-15356).
+    report.membership.status === 'absent'
+        ? ' — not a current member; this report cannot tell a removed member from an id that never existed'
+        : ''}`);
+    const isCut = (source) => report.coverage.sources.some((entry) => entry.name === source && entry.truncated);
+    const count = (rows, source) => rows === null
+        ? 'unavailable'
+        : isCut(source)
+            ? `${rows.length} shown, cut at the row cap (there are more)`
+            : String(rows.length);
+    for (const [name, source, rows] of [
+        ['Commitments', 'commitments', report.commitments],
+        ['Approver seats', 'approverSeats', report.approverSeats],
     ]) {
-        log(`${name}: ${rows === null ? 'unavailable' : rows.length}`);
+        log(`${name}: ${count(rows, source)}`);
         if (rows?.length)
             (0, format_1.renderTable)(rows.map((row) => ({
                 id: row.id,
@@ -82,7 +127,7 @@ function printWorkspaceStewardship(report, log) {
                 { key: 'agentId', header: 'EXECUTOR' },
             ], log);
     }
-    log(`Authored Agents: ${report.agents === null ? 'unavailable' : report.agents.length}`);
+    log(`Authored Agents: ${count(report.agents, 'agents')}`);
     if (report.agents?.length)
         (0, format_1.renderTable)(report.agents.map((row) => ({ id: row.id, name: row.name ?? '' })), [
             { key: 'id', header: 'ID' },

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

@@ -0,0 +1,30 @@
+/**
+ * The Task's stored economic claim as one line for `tasks show` (OSK-15363).
+ *
+ * The detail view printed no savings, effort, risk, basis or confirmer at all: only `--json` carried
+ * them, with the confirmer as a raw user id, though `docs/cli/SKRR_TASKS.md` sends a reader to "ordinary
+ * task detail" for the claim. A claim is not a measurement, so the basis is part of the line.
+ */
+type Economics = {
+    savings?: {
+        amount?: number;
+        currency?: string;
+        per?: string;
+    };
+    effortHours?: number;
+    risk?: string;
+    confidence?: string;
+    rationale?: string;
+    basis?: string;
+    confirmedBy?: string;
+    confirmedAt?: string;
+    revision?: number;
+};
+/** Null when the Task carries no claim at all. `confirmerName` is the resolved name, if there is one. */
+export declare function economicsLine(economics: Economics | null | undefined, confirmerName?: string): string | null;
+/**
+ * The claim's rationale on its own line, or null. It is kept when a later edit changes the figures, so
+ * it is shown beside the basis it now carries rather than left to `--json`.
+ */
+export declare function economicsRationaleLine(economics: Economics | null | undefined): string | null;
+export {};

package/dist/lib/task-economics-line.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * The Task's stored economic claim as one line for `tasks show` (OSK-15363).
+ *
+ * The detail view printed no savings, effort, risk, basis or confirmer at all: only `--json` carried
+ * them, with the confirmer as a raw user id, though `docs/cli/SKRR_TASKS.md` sends a reader to "ordinary
+ * task detail" for the claim. A claim is not a measurement, so the basis is part of the line.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.economicsLine = economicsLine;
+exports.economicsRationaleLine = economicsRationaleLine;
+const format_1 = require("./format");
+const BASIS = {
+    agent_estimate: 'Agent estimate',
+    human_confirmed: 'Human confirmed',
+    measured: 'Measured',
+};
+/** Null when the Task carries no claim at all. `confirmerName` is the resolved name, if there is one. */
+function economicsLine(economics, confirmerName) {
+    if (!economics || typeof economics !== 'object')
+        return null;
+    const parts = [];
+    const savings = economics.savings;
+    if (savings && typeof savings.amount === 'number') {
+        parts.push(`${savings.currency ?? 'USD'} ${savings.amount}${savings.per ? `/${savings.per}` : ''} saved`);
+    }
+    if (typeof economics.effortHours === 'number')
+        parts.push(`${economics.effortHours}h effort`);
+    if (economics.risk)
+        parts.push(`risk ${economics.risk}`);
+    if (parts.length === 0)
+        return null;
+    // Part of the claim, and kept across a later re-estimate: a reader must see what the label covers (OSK-15372).
+    if (economics.confidence)
+        parts.push(`confidence ${economics.confidence}`);
+    const basis = economics.basis ? (BASIS[economics.basis] ?? economics.basis) : 'basis not stated';
+    const who = economics.confirmedBy ? ` by ${confirmerName || economics.confirmedBy}` : '';
+    const when = economics.confirmedAt ? ` on ${String(economics.confirmedAt).slice(0, 10)}` : '';
+    const revision = typeof economics.revision === 'number' ? ` (claim revision ${economics.revision})` : '';
+    return `${parts.join(' · ')} · ${basis}${who}${when}${revision} — a claim, not a measurement`;
+}
+/**
+ * The claim's rationale on its own line, or null. It is kept when a later edit changes the figures, so
+ * it is shown beside the basis it now carries rather than left to `--json`.
+ */
+function economicsRationaleLine(economics) {
+    const rationale = economics?.rationale;
+    return typeof rationale === 'string' && rationale.trim() ? (0, format_1.collapseWhitespace)(rationale) : null;
+}

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 {};