@skrr-ai/cli 0.1.127 → 0.1.129

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

@@ -82,7 +82,27 @@ class ProposalDecisionCommand extends base_command_1.BaseCommand {
             }
             this.handleApiError(error);
         }
-        this.log(flags.json ? JSON.stringify(result, null, 2) : `Proposal ${decision} decision recorded.`);
+        // A retry whose first response was lost lands on the decision that already took effect; the
+        // server marks it, so it is not worded like a first success (OSK-21191).
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+        }
+        else if (result.replayed) {
+            // The receipt repeats the decision that was ASKED for; what the intent's outcome actually is
+            // (applied, still waiting to be applied, rejected) is on the proposal, so read it (OSK-21250).
+            // Best effort: when that read fails the message names the decision, as before.
+            let view;
+            try {
+                view = await proposals_1.proposalApi.show(ref.kind, ref.id);
+            }
+            catch {
+                view = undefined;
+            }
+            this.log((0, proposals_1.describeReplay)(decision, result, view));
+        }
+        else {
+            this.log(`Proposal ${decision} decision recorded.`);
+        }
     }
 }
 exports.ProposalDecisionCommand = ProposalDecisionCommand;

package/dist/lib/proposals.d.ts

@@ -1,4 +1,4 @@
-import type { ProposalDecisionParams, ProposalDecisionResponse, ProposalKind, ProposalListParams, ProposalListResponse, ProposalView } from '@skrr-ai/data-provider';
+import type { ProposalDecision, ProposalDecisionParams, ProposalDecisionResponse, ProposalKind, ProposalListParams, ProposalListResponse, ProposalView } from '@skrr-ai/data-provider';
 /** The unified, read-time proposal inbox. Decisions are routed by the server to
  * each family's own writer; the CLI never writes a source row. */
 export declare const proposalApi: {
@@ -23,3 +23,28 @@ export declare function resolveProposalRef(kindArg: string | undefined, idArg: s
 };
 /** 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;
+/**
+ * The intent's title in words: what it would DO, to what. Any other kind of proposal, and an
+ * intent the server sent no context for, keeps the view's own title.
+ */
+export declare function proposalTitleFor(view: ProposalView): string;
+/**
+ * The inbox files a rejection nobody on the owner's side made under `discarded`. For a Northstar
+ * intent the verdict, and who made it, is said in the NOTE column, so a policy refusal is not
+ * read as something the person threw away.
+ */
+export declare function northstarIntentNote(view: ProposalView): string;
+/**
+ * `proposals show` for a Northstar intent, as lines a person can read. Null for every other kind,
+ * which keeps printing the full JSON as before (a script reading it does not change).
+ */
+export declare function renderNorthstarIntentView(view: ProposalView): string[] | null;
+/**
+ * What a replayed decision says. The replay receipt names the decision that was asked for ("keep"), but a
+ * Northstar intent that was kept has gone on: it may be applied, or approved and not applied yet, and a
+ * discard lands as `rejected`. "Already kept" for an intent that was in fact applied understated what
+ * had happened (OSK-21250), so the intent's own verdict is named when the proposal could be read.
+ */
+export declare function describeReplay(decision: ProposalDecision, receipt: {
+    decidedAt?: string;
+}, view?: ProposalView): string;

package/dist/lib/proposals.js

@@ -3,8 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.proposalApi = void 0;
 exports.resolveProposalRef = resolveProposalRef;
 exports.describeProposalNotFound = describeProposalNotFound;
+exports.proposalTitleFor = proposalTitleFor;
+exports.northstarIntentNote = northstarIntentNote;
+exports.renderNorthstarIntentView = renderNorthstarIntentView;
+exports.describeReplay = describeReplay;
 const data_provider_1 = require("@skrr-ai/data-provider");
 const data_provider_2 = require("@skrr-ai/data-provider");
+const northstars_1 = require("./northstars");
 const triggers_1 = require("./triggers");
 const MOUNT = '/api/proposals';
 /** The unified, read-time proposal inbox. Decisions are routed by the server to
@@ -61,3 +66,165 @@ 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.`);
 }
+/* --------------------------------------------------------------------------
+ * A Northstar intent, in words
+ *
+ * `proposals list` showed the intent's TITLE as its kind code (`pause_commitment`),
+ * `proposals show` printed the raw JSON, `rejected` read as `discarded` (the inbox's
+ * own vocabulary, which says a person discarded something), and the sentence the
+ * governor wrote lived only inside the JSON. Everything below renders fields the
+ * view already carries; no new data is needed.
+ * ------------------------------------------------------------------------ */
+/** What each kind of intent does, as a phrase a target can follow. A new kind fails the build. */
+const INTENT_PHRASE = {
+    pause_commitment: 'Pause',
+    resume_commitment: 'Resume',
+    reprioritize_commitment: 'Reprioritize',
+    request_commitment_check: 'Check now:',
+    set_execution_bounds: 'Change the run bounds of',
+    create_commitment_proposal: 'Start a new commitment',
+    reassign_commitment_proposal: 'Reassign',
+};
+/** The intent's own verdict, which the inbox flattens into proposed/kept/discarded/expired. */
+const VERDICT_WORDS = {
+    advisory: 'advisory: recorded for you to read, nothing to decide',
+    awaiting_approval: 'waiting for your decision',
+    approved: 'approved, not applied yet',
+    applying: 'being applied',
+    applied: 'applied',
+    rejected: 'rejected',
+    invalidated: 'invalidated: it went stale before it was applied',
+};
+function isNorthstarIntentView(view) {
+    return view.kind === 'northstar_intent' && Boolean(view.decisionContext?.snapshot);
+}
+function intentTarget(view) {
+    const id = view.decisionContext?.snapshot.targetCommitmentId ?? view.commitmentId;
+    if (view.commitmentTitle)
+        return id ? `${view.commitmentTitle} (${id})` : view.commitmentTitle;
+    return id ?? 'a commitment';
+}
+/**
+ * The intent's title in words: what it would DO, to what. Any other kind of proposal, and an
+ * intent the server sent no context for, keeps the view's own title.
+ */
+function proposalTitleFor(view) {
+    if (!isNorthstarIntentView(view))
+        return view.title;
+    const snapshot = view.decisionContext.snapshot;
+    const phrase = INTENT_PHRASE[snapshot.kind] ?? snapshot.kind;
+    if (snapshot.kind === 'create_commitment_proposal') {
+        const title = snapshot.payload?.title;
+        return typeof title === 'string' && title.trim() ? `${phrase}: ${title.trim()}` : phrase;
+    }
+    if (snapshot.kind === 'reassign_commitment_proposal') {
+        const agent = snapshot.payload?.agentId;
+        const to = typeof agent === 'string' && agent ? ` to agent ${agent}` : '';
+        return `${phrase} ${intentTarget(view)}${to}`;
+    }
+    return `${phrase} ${intentTarget(view)}`;
+}
+/**
+ * The inbox files a rejection nobody on the owner's side made under `discarded`. For a Northstar
+ * intent the verdict, and who made it, is said in the NOTE column, so a policy refusal is not
+ * read as something the person threw away.
+ */
+function northstarIntentNote(view) {
+    if (!isNorthstarIntentView(view))
+        return '';
+    const verdict = view.sourceStatus;
+    const reason = view.decision?.reason ? `: ${view.decision.reason}` : '';
+    if (verdict === 'rejected') {
+        return view.decision?.by ? `rejected by you${reason}` : `rejected by policy${reason}`;
+    }
+    if (verdict === 'invalidated') {
+        return `invalidated: it went stale, nothing was discarded${reason}`;
+    }
+    if (verdict === 'advisory')
+        return 'advisory: nothing to decide';
+    return '';
+}
+/**
+ * `proposals show` for a Northstar intent, as lines a person can read. Null for every other kind,
+ * which keeps printing the full JSON as before (a script reading it does not change).
+ */
+function renderNorthstarIntentView(view) {
+    if (!isNorthstarIntentView(view))
+        return null;
+    const context = view.decisionContext;
+    const verdict = view.sourceStatus;
+    // The intent's own rating (`intentRisk`), the one `northstars intents list` prints under RISK.
+    const risk = (0, northstars_1.intentRisk)({ riskLevel: context.riskLevel ?? context.snapshot.riskLevel });
+    const hasTarget = Boolean(context.snapshot.targetCommitmentId || view.commitmentId);
+    const lines = [proposalTitleFor(view), ''];
+    lines.push(`Proposal    ${view.id}`);
+    lines.push(`Kind        ${context.snapshot.kind}`);
+    // Said once, here, because this is where a person who saw a lower "recommendation risk" on the
+    // recommendation this came from looks for the reason the two differ.
+    lines.push(`Risk        ${risk}  (rated for this change; the recommendation behind it has its own "recommendation risk")`);
+    lines.push(`Target      ${hasTarget ? intentTarget(view) : 'none (a new commitment)'}`);
+    if (context.reason)
+        lines.push(`Why         ${context.reason}`);
+    lines.push(`Status      ${VERDICT_WORDS[verdict] ?? verdict}  (the inbox files it under "${view.disposition}")`);
+    const decision = view.decision;
+    if (verdict === 'awaiting_approval' || verdict === 'advisory') {
+        // Nobody has decided: `decision.reason` here is the policy that HELD it (or kept it advisory),
+        // and printing it as "Decided … by policy" read as a recorded decision (OSK-21251).
+        if (decision?.reason) {
+            const words = (0, northstars_1.describeNorthstarReason)(decision.reason);
+            lines.push(verdict === 'awaiting_approval' ? `Waiting for you: ${words}` : `Not decided: ${words}`);
+        }
+    }
+    else if (decision && (decision.at || decision.by || decision.reason)) {
+        const at = decision.at ? `${(0, northstars_1.shortDate)(decision.at)} UTC` : 'at an unrecorded time';
+        const by = decision.by ? ` by user ${decision.by}` : ' by policy';
+        const via = decision.via ? ` via ${decision.via}` : '';
+        const reason = decision.reason ? `: ${decision.reason}` : '';
+        lines.push(`Decided     ${at}${by}${via}${reason}`);
+    }
+    if (view.canDecide) {
+        lines.push(`Can decide  ${view.availableDecisions.join(', ')}`);
+    }
+    else {
+        const why = view.undecidableReason
+            ? data_provider_2.PROPOSAL_UNDECIDABLE_TEXT[view.undecidableReason]
+            : 'not now';
+        lines.push(`Can decide  no: ${why}`);
+    }
+    const continuation = view.continuation;
+    if (continuation) {
+        const bits = [continuation.status, continuation.commitmentId, continuation.reason].filter(Boolean);
+        lines.push(`Continued   ${bits.join(' · ')}`);
+    }
+    lines.push(`Revision    ${JSON.stringify(view.revision)}`);
+    // The hint is for a proposal that can still be decided: beside "Can decide  no" it contradicts
+    // the line above it (OSK-21255).
+    if (view.canDecide) {
+        lines.push('            (pass this exact JSON as --expected to keep, discard or snooze)');
+    }
+    lines.push(`Web         ${view.links.web}`);
+    return lines;
+}
+/**
+ * What a replayed decision says. The replay receipt names the decision that was asked for ("keep"), but a
+ * Northstar intent that was kept has gone on: it may be applied, or approved and not applied yet, and a
+ * discard lands as `rejected`. "Already kept" for an intent that was in fact applied understated what
+ * had happened (OSK-21250), so the intent's own verdict is named when the proposal could be read.
+ */
+function describeReplay(decision, receipt, view) {
+    let outcome = { keep: 'kept', discard: 'discarded', snooze: 'snoozed' }[decision];
+    if (view && isNorthstarIntentView(view)) {
+        const settled = INTENT_REPLAY_WORDS[view.sourceStatus];
+        if (settled)
+            outcome = settled;
+    }
+    const when = receipt.decidedAt ? ` at ${(0, northstars_1.shortDate)(receipt.decidedAt)} UTC` : '';
+    return `Already ${outcome}${when} — nothing changed.`;
+}
+/** The verdicts a replayed keep or discard can find an intent in. */
+const INTENT_REPLAY_WORDS = {
+    applied: 'applied',
+    approved: 'approved (not applied yet)',
+    applying: 'approved and being applied',
+    rejected: 'rejected',
+};

package/dist/lib/rate-limit-retry.d.ts

@@ -10,6 +10,11 @@
  * `X-Idempotency-Key` (every `request.ts` / adapter write does). A 429 means the
  * request was refused before it ran, so the key is belt and braces.
  *
+ * Never retried when the body says it cannot help: a 429 that declares
+ * `retryable: false` (a follow-up budget refusal, which says the day resets at
+ * 00:00 UTC) is a refusal to keep, not a limiter to wait out. Retrying it sent the
+ * same refused request three times and told the server about three intents (OSK-21266).
+ *
  * Bounded twice: at most `maxRetries` extra attempts and a per-wait ceiling, so
  * a stuck limiter costs a script seconds, not minutes. `SKRR_RATE_LIMIT_RETRIES=0`
  * turns it off.

package/dist/lib/rate-limit-retry.js

@@ -11,6 +11,11 @@
  * `X-Idempotency-Key` (every `request.ts` / adapter write does). A 429 means the
  * request was refused before it ran, so the key is belt and braces.
  *
+ * Never retried when the body says it cannot help: a 429 that declares
+ * `retryable: false` (a follow-up budget refusal, which says the day resets at
+ * 00:00 UTC) is a refusal to keep, not a limiter to wait out. Retrying it sent the
+ * same refused request three times and told the server about three intents (OSK-21266).
+ *
  * Bounded twice: at most `maxRetries` extra attempts and a per-wait ceiling, so
  * a stuck limiter costs a script seconds, not minutes. `SKRR_RATE_LIMIT_RETRIES=0`
  * turns it off.
@@ -65,6 +70,18 @@ function retryAfterOf(response) {
         ? parseRetryAfterMs(response.headers.get('retry-after'))
         : undefined;
 }
+/** A 429 whose body declares `retryable: false`. Reads a clone, so the caller still gets the body. */
+async function declaresNotRetryable(response) {
+    if (response.status !== 429)
+        return false;
+    try {
+        const body = (await response.clone().json());
+        return body?.retryable === false;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Run `attemptFetch` and, on a 429 for a replay-safe request, wait and run it
  * again. Returns the last response, with `retryAfterMs` of the final 429 (so the
@@ -80,6 +97,8 @@ async function fetchWithRateLimitRetry(attemptFetch, options) {
     for (let attempt = 0; attempt < max && response.status === 429; attempt++) {
         if (options.signal?.aborted)
             break;
+        if (await declaresNotRetryable(response))
+            break;
         await sleep(rateLimitWaitMs(attempt, retryAfterMs, options.random));
         response = await attemptFetch();
         retryAfterMs = retryAfterOf(response);

package/dist/lib/roles.d.ts

@@ -53,7 +53,7 @@ export declare const roleApi: {
                 config?: Record<string, unknown> | undefined;
             }[];
             sources: {
-                source: "space" | "tasks" | "memory" | "daemon" | "email" | "goal" | "files" | "local" | "browser" | "conversations" | "slack" | "github" | "messages" | "calendar" | "agent_run" | "docs" | "metrics" | "agent_initiatives" | "documents" | "product_metrics" | "business_metrics" | "state_monitor" | "monitor";
+                source: "space" | "tasks" | "memory" | "daemon" | "email" | "goal" | "files" | "local" | "browser" | "conversations" | "slack" | "github" | "messages" | "calendar" | "docs" | "metrics" | "agent_run" | "agent_initiatives" | "documents" | "product_metrics" | "business_metrics" | "state_monitor" | "monitor";
                 enabled: boolean;
                 config?: Record<string, unknown> | undefined;
             }[];

package/dist/lib/space-charter.js

@@ -51,6 +51,15 @@ function charterLines(charter, { binName, spaceId, full = false }) {
     if (lead) {
         for (const line of lead.split('\n'))
             lines.push(`  ${line}`);
+        // Agents are handed about the first `leadContextChars` characters of the lead, then a pointer
+        // to the rest. The page printed all of it under "read by every agent", so a long lead looked
+        // fully delivered (the web card warns; the CLI said nothing). Measured like the server does.
+        const cap = charter.leadContextChars;
+        if (typeof cap === 'number' && cap > 0 && lead.length > cap) {
+            lines.push('');
+            lines.push(`  Over the cap: this lead is ${lead.length} characters and agents get about the first ${cap}, ` +
+                'then a pointer to the rest. Put the essentials first, or move detail below a ## heading.');
+        }
     }
     else {
         lines.push('  (empty: the page opens with a ## heading, so agents receive no charter lead. ' +

package/dist/lib/store-artifact-releases.d.ts

@@ -0,0 +1,39 @@
+/**
+ * `/api/store/artifacts/skill/:entityId/releases` — the seller's own
+ * publication history for one skill, newest release first.
+ *
+ * It answers the question a headless seller has after `store artifacts release`:
+ * where did my releases land, and did a curator admit or refuse one (with the
+ * note they left)? The source snapshot and its private storage references are
+ * never in this projection. One release in full is `store artifacts receipt`.
+ *
+ * The route is written out at its own call site rather than composed from a
+ * builder, like the rest of the Store CLI: the parity checker reads the LITERAL
+ * at the call site.
+ */
+export type StoreArtifactReleaseSummary = {
+    releaseId: string;
+    releaseNumber: number;
+    versionLabel?: string;
+    status?: string;
+    admission?: {
+        state?: string;
+        review?: {
+            note?: string;
+            decidedAt?: string;
+        };
+    };
+    createdAt?: string;
+    updatedAt?: string;
+    publishedAt?: string;
+};
+export type StoreArtifactReleaseHistory = {
+    data: StoreArtifactReleaseSummary[];
+    /** Pass as `before` for the next (older) page; null when this is the last. */
+    nextBefore: number | null;
+};
+/** `GET /artifacts/skill/:entityId/releases` — `limit` 1-50 (default 10), `before` a release number. */
+export declare function listSkillArtifactReleases(entityId: string, params?: {
+    limit?: number;
+    before?: number;
+}): Promise<StoreArtifactReleaseHistory>;

package/dist/lib/store-artifact-releases.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listSkillArtifactReleases = listSkillArtifactReleases;
+const api_fetch_1 = require("./api-fetch");
+const triggers_1 = require("./triggers");
+/** `GET /artifacts/skill/:entityId/releases` — `limit` 1-50 (default 10), `before` a release number. */
+async function listSkillArtifactReleases(entityId, params = {}) {
+    return (0, api_fetch_1.apiFetch)((0, triggers_1.withQuery)(`/api/store/artifacts/skill/${encodeURIComponent(entityId)}/releases`, {
+        limit: params.limit,
+        before: params.before,
+    }));
+}

package/dist/lib/store-library.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `/api/store/library/items` — the Skill, Action and Service copies the signed-in
+ * buyer holds in the active workspace, with whether each copy can still be used.
+ *
+ * Agent purchases are NOT here: `skrr store installs` reads those. This is the
+ * other three artifact kinds, which the web Library page lists and which had no
+ * headless read at all.
+ *
+ * The route is written out at its own call site rather than composed from a
+ * builder, like the rest of the Store CLI: the parity checker reads the LITERAL
+ * at the call site.
+ */
+/** One bought copy. `copyAvailable` is false once the copy is suspended, revoked or uninstalled. */
+export type StoreLibraryItem = {
+    /** The listing or release the buyer bought. */
+    sourceId: string;
+    /** The buyer's own installed copy; null while fulfillment has not produced one. */
+    copyId: string | null;
+    name: string | null;
+    copyAvailable: boolean;
+    /** The Agent the copy was installed onto (Skills and Actions only). */
+    targetAgentId?: string | null;
+    entitlementState?: string;
+    fulfillmentState?: string;
+    purchasedAt?: string;
+};
+export type StoreLibraryItems = {
+    skills: StoreLibraryItem[];
+    actions: StoreLibraryItem[];
+    services: StoreLibraryItem[];
+};
+/**
+ * `GET /library/items`. The workspace is required by the server (400
+ * `A workspace is required` without one), so it travels as the explicit
+ * header, the way `store installs` sends it.
+ */
+export declare function getStoreLibraryItems(workspaceId?: string): Promise<StoreLibraryItems>;

package/dist/lib/store-library.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStoreLibraryItems = getStoreLibraryItems;
+const api_fetch_1 = require("./api-fetch");
+/**
+ * `GET /library/items`. The workspace is required by the server (400
+ * `A workspace is required` without one), so it travels as the explicit
+ * header, the way `store installs` sends it.
+ */
+async function getStoreLibraryItems(workspaceId) {
+    return (0, api_fetch_1.apiFetch)('/api/store/library/items', workspaceId ? { headers: { 'X-Workspace-Id': workspaceId } } : undefined);
+}

package/dist/lib/task-asset-upload.js

@@ -68,7 +68,6 @@ const fs = __importStar(require("node:fs"));
 const http = __importStar(require("node:http"));
 const https = __importStar(require("node:https"));
 const path = __importStar(require("node:path"));
-const node_buffer_1 = require("node:buffer");
 const node_crypto_1 = require("node:crypto");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../base-command");
@@ -223,7 +222,7 @@ function taskAssetMarkdownRef(asset) {
  */
 function fileFormData(filePath, filename, mimeType, role, ledger) {
     const fd = new FormData();
-    fd.append('file', new node_buffer_1.Blob([fs.readFileSync(filePath)], { type: mimeType }), filename);
+    fd.append('file', new Blob([fs.readFileSync(filePath)], { type: mimeType }), filename);
     if (role)
         fd.append('role', role);
     if (ledger?.identity) {

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

@@ -0,0 +1,19 @@
+/**
+ * What `skrr tasks list --calendar` tells a person about the answer it printed.
+ *
+ * The calendar read used to end with "Note: calendar occurrence expansion reached its safety cap."
+ * whatever had been cut, and "No calendar occurrences." whatever had been missed (OSK-21382,
+ * OSK-21510): no limit, no cutoff, no Task, no remedy, and the server's warning codes were never
+ * shown. The server now says which bounds it reached (`truncations`) and which access warnings
+ * apply; this words them.
+ */
+import type { TaskCalendarResponse, TaskCalendarTruncation } from '@skrr-ai/data-provider';
+export declare function describeCalendarTruncation(truncation: TaskCalendarTruncation): string;
+export declare function describeCalendarWarning(code: string): string;
+/**
+ * The lines to print after a calendar answer: empty when the read was complete. A calendar that
+ * was cut short never reads as complete, and every cut says what it was.
+ */
+export declare function calendarNoticeLines(calendar: TaskCalendarResponse): string[];
+/** The window that was actually read, in UTC, and what a date-only range stood for. */
+export declare function calendarWindowLine(calendar: Pick<TaskCalendarResponse, 'from' | 'to'>): string;

package/dist/lib/task-calendar.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeCalendarTruncation = describeCalendarTruncation;
+exports.describeCalendarWarning = describeCalendarWarning;
+exports.calendarNoticeLines = calendarNoticeLines;
+exports.calendarWindowLine = calendarWindowLine;
+const who = (t) => t.ref || t.taskId || 'A task';
+/**
+ * One sentence per bound. A `Record` over the shared vocabulary, so a code added to
+ * `TASK_CALENDAR_TRUNCATION_CODES` cannot be forgotten here.
+ */
+const TRUNCATION_TEXT = {
+    task_occurrence_limit: (t) => `${who(t)} fires more than ${t.limit} times in this window (the limit is ${t.limit} per task)` +
+        `${t.cutoffAt ? `; its fires are listed up to ${t.cutoffAt} and later ones are not shown` : ''}. ` +
+        'Narrow the range to see the rest.',
+    task_skipped_receipt_limit: (t) => `${who(t)} has more than ${t.limit} skipped-fire receipts in this window; only the latest ${t.limit} are shown.`,
+    task_recurrence_walk_limit: (t) => `${who(t)} has a run limit too far from this window to count what remains of it (more than ${t.limit} fires walked), so its fires in this window are not shown. ` +
+        'Narrow the range to start closer to its next run.',
+    calendar_row_limit: (t) => `More than ${t.limit} rows matched${typeof t.omitted === 'number' ? `; ${t.omitted} are not shown` : ''}` +
+        `${t.cutoffAt ? `, and the rows are listed only up to ${t.cutoffAt}` : ''}. ` +
+        'Narrow the range, or add --space or --project.',
+    task_candidate_limit: (t) => `More than ${t.limit} tasks are candidates for this window and not all were read. Narrow the range, or add --space or --project.`,
+};
+function describeCalendarTruncation(truncation) {
+    const words = TRUNCATION_TEXT[truncation.code];
+    // A code a newer server sent: say it rather than drop it.
+    return words
+        ? words(truncation)
+        : `The server reached a limit (${String(truncation.code)}, ${truncation.limit}) and did not describe it.`;
+}
+const WARNING_TEXT = {
+    space_cascade_capped: 'You can reach more spaces than one read covers, so tasks you did not create in the rest are not listed. Narrow with --space.',
+    space_access_capped: 'You can reach more spaces than one read covers, so tasks in the rest are not listed. Narrow with --space.',
+};
+function describeCalendarWarning(code) {
+    if (WARNING_TEXT[code])
+        return WARNING_TEXT[code];
+    if (code.endsWith('_partial')) {
+        return 'An access lookup failed, so some tasks may be missing. Retry the command.';
+    }
+    return `The server flagged this answer (${code}); it may be incomplete.`;
+}
+/**
+ * The lines to print after a calendar answer: empty when the read was complete. A calendar that
+ * was cut short never reads as complete, and every cut says what it was.
+ */
+function calendarNoticeLines(calendar) {
+    const truncations = calendar.truncations ?? [];
+    const warnings = calendar.warnings ?? [];
+    const lines = [];
+    if (truncations.length > 0) {
+        lines.push('The calendar is incomplete:');
+        for (const truncation of truncations)
+            lines.push(`  - ${describeCalendarTruncation(truncation)}`);
+    }
+    else if (calendar.truncated && warnings.length === 0) {
+        // A server that predates `truncations` flagged the answer and said nothing more.
+        lines.push('The calendar is incomplete: the server cut it short but did not say which limit it reached. Narrow the range, or add --space.');
+    }
+    if (warnings.length > 0) {
+        if (lines.length === 0)
+            lines.push('The calendar may be incomplete:');
+        for (const code of warnings) {
+            lines.push(`  - Warning ${code}: ${describeCalendarWarning(code)}`);
+        }
+    }
+    return lines;
+}
+/** The window that was actually read, in UTC, and what a date-only range stood for. */
+function calendarWindowLine(calendar) {
+    return `Window (UTC): ${calendar.from} .. ${calendar.to}. A date-only range is a whole UTC day.`;
+}

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

@@ -22,7 +22,9 @@ function recurrenceRearmHint(code, taskRef = '<task-id>', bin = 'skrr') {
 }
 const ENDED_BECAUSE = {
     max_runs: 'it reached its maximum number of runs',
-    end_date: 'its end date has passed',
+    // The end date is exclusive: it ends the series when it has passed AND when the next slot would
+    // land on or after it, so "has passed" would be false for a series ended one day early (OSK-21552).
+    end_date: 'its end date leaves no further occurrence',
     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). */

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

@@ -0,0 +1,15 @@
+export type CronReading = {
+    /** "at 09:00 on the 13th of the month or on Friday" */
+    text: string;
+    /** True when both a day of month and a weekday are set: cron fires on EITHER. */
+    dayOfMonthOrWeekday: boolean;
+};
+/**
+ * Plain language for a five-field cron pattern, or `null` when this reader cannot say it faithfully.
+ */
+export declare function describeCronPattern(pattern: string): CronReading | null;
+/**
+ * The block `tasks show` prints for a recurring Task: the rule, its zone, a plain reading, when it
+ * next fires, how many runs it has used, and when it ends. Empty for a Task that does not recur.
+ */
+export declare function recurrenceSummaryLines(task: Record<string, unknown>): string[];