@skrr-ai/cli 0.1.127 → 0.1.129

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

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeCronPattern = describeCronPattern;
+exports.recurrenceSummaryLines = recurrenceSummaryLines;
+/**
+ * What `skrr tasks show` says about a Task that recurs (OSK-21531).
+ *
+ * The human view printed "it is scheduled for 2026-12-01" and nothing else: no word that the Task
+ * recurs, no pattern, no zone. The rule lived only in `--json` (`recurrence.pattern`, `.timezone`,
+ * `.runsCompleted`), so the cron semantics that surprise people - a day of month AND a weekday
+ * fire on EITHER, not both - were invisible exactly where someone checks what they just set up.
+ *
+ * `describeCronPattern` reads the five-field form the scheduler runs. It is deliberately modest: a
+ * pattern it cannot read plainly (names it does not know, `L`, `?`, six fields) returns `null` and
+ * the caller prints the raw pattern alone rather than a confident wrong sentence.
+ */
+const iso_instant_1 = require("./iso-instant");
+const WEEKDAYS = [
+    'Sunday',
+    'Monday',
+    'Tuesday',
+    'Wednesday',
+    'Thursday',
+    'Friday',
+    'Saturday',
+];
+const MONTHS = [
+    'January',
+    'February',
+    'March',
+    'April',
+    'May',
+    'June',
+    'July',
+    'August',
+    'September',
+    'October',
+    'November',
+    'December',
+];
+const MINUTE = { min: 0, max: 59 };
+const HOUR = { min: 0, max: 23 };
+const DAY_OF_MONTH = { min: 1, max: 31 };
+const MONTH = {
+    min: 1,
+    max: 12,
+    names: MONTHS.map((m) => m.slice(0, 3).toUpperCase()),
+    nameBase: 1,
+};
+const DAY_OF_WEEK = {
+    min: 0,
+    max: 7,
+    names: WEEKDAYS.map((d) => d.slice(0, 3).toUpperCase()),
+    nameBase: 0,
+};
+/** The values a field names, or `null` when it is not a form this reader understands. */
+function expandField(raw, domain) {
+    const values = new Set();
+    for (const part of raw.split(',')) {
+        const [rangeText, stepText, extra] = part.split('/');
+        if (extra !== undefined || rangeText === undefined || rangeText === '')
+            return null;
+        const step = stepText === undefined ? 1 : Number(stepText);
+        if (!Number.isInteger(step) || step < 1)
+            return null;
+        const toNumber = (token) => {
+            if (/^\d+$/.test(token))
+                return Number(token);
+            const index = domain.names?.indexOf(token.toUpperCase()) ?? -1;
+            return index >= 0 ? index + (domain.nameBase ?? 0) : null;
+        };
+        let from;
+        let to;
+        if (rangeText === '*') {
+            from = domain.min;
+            to = domain === DAY_OF_WEEK ? 6 : domain.max;
+        }
+        else if (rangeText.includes('-')) {
+            const [a, b, more] = rangeText.split('-');
+            if (more !== undefined)
+                return null;
+            from = toNumber(a);
+            to = toNumber(b);
+        }
+        else {
+            from = toNumber(rangeText);
+            // `5/10` runs from 5 to the top of the field.
+            to = stepText === undefined ? from : domain === DAY_OF_WEEK ? 6 : domain.max;
+        }
+        if (from === null || to === null || from > to)
+            return null;
+        if (from < domain.min || to > domain.max)
+            return null;
+        for (let value = from; value <= to; value += step)
+            values.add(domain === DAY_OF_WEEK && value === 7 ? 0 : value);
+    }
+    return [...values].sort((a, b) => a - b);
+}
+function ordinal(n) {
+    const tail = n % 100;
+    if (tail >= 11 && tail <= 13)
+        return `${n}th`;
+    return `${n}${{ 1: 'st', 2: 'nd', 3: 'rd' }[n % 10] ?? 'th'}`;
+}
+function joinList(items, word = 'and') {
+    if (items.length <= 1)
+        return items.join('');
+    return `${items.slice(0, -1).join(', ')} ${word} ${items[items.length - 1]}`;
+}
+const pad = (n) => String(n).padStart(2, '0');
+/** Evenly spaced from the field's start, e.g. 0,15,30,45 -> 15. */
+function evenStep(values, size) {
+    if (values.length < 2 || values[0] !== 0)
+        return null;
+    const step = values[1] - values[0];
+    if (step < 2 || size % step !== 0 || values.length !== size / step)
+        return null;
+    return values.every((v, i) => v === i * step) ? step : null;
+}
+function describeTime(minute, hour) {
+    const minutes = expandField(minute, MINUTE);
+    const hours = expandField(hour, HOUR);
+    if (!minutes || !hours)
+        return null;
+    const everyHour = hours.length === 24;
+    if (everyHour && minutes.length === 60)
+        return 'every minute';
+    if (everyHour) {
+        const step = evenStep(minutes, 60);
+        if (step)
+            return `every ${step} minutes`;
+        if (minutes.length === 1)
+            return minutes[0] === 0
+                ? 'at the start of every hour'
+                : `at minute ${minutes[0]} of every hour`;
+        return `at minutes ${joinList(minutes.map(String))} of every hour`;
+    }
+    if (minutes.length === 1 && hours.length <= 6) {
+        return `at ${joinList(hours.map((h) => `${pad(h)}:${pad(minutes[0])}`))}`;
+    }
+    const hourStep = evenStep(hours, 24);
+    if (minutes.length === 1 && hourStep) {
+        return `every ${hourStep} hours, at minute ${minutes[0]}`;
+    }
+    return `at minute${minutes.length > 1 ? 's' : ''} ${joinList(minutes.map(String))} past hour${hours.length > 1 ? 's' : ''} ${joinList(hours.map(String))}`;
+}
+function describeWeekdays(values) {
+    const key = values.join(',');
+    if (key === '1,2,3,4,5')
+        return 'Monday to Friday';
+    if (key === '0,6')
+        return 'Saturday and Sunday';
+    return joinList(values.map((d) => WEEKDAYS[d]));
+}
+/**
+ * Plain language for a five-field cron pattern, or `null` when this reader cannot say it faithfully.
+ */
+function describeCronPattern(pattern) {
+    const fields = String(pattern ?? '')
+        .trim()
+        .split(/\s+/);
+    if (fields.length !== 5)
+        return null;
+    const [minute, hour, dayOfMonth, month, dayOfWeek] = fields;
+    const time = describeTime(minute, hour);
+    const months = month === '*' ? [] : expandField(month, MONTH);
+    const monthDays = dayOfMonth === '*' ? [] : expandField(dayOfMonth, DAY_OF_MONTH);
+    const weekdays = dayOfWeek === '*' ? [] : expandField(dayOfWeek, DAY_OF_WEEK);
+    if (!time || !months || !monthDays || !weekdays)
+        return null;
+    const dayParts = [];
+    if (monthDays.length > 0) {
+        dayParts.push(`on the ${joinList(monthDays.map(ordinal))} of the month`);
+    }
+    if (weekdays.length > 0) {
+        dayParts.push(`on ${describeWeekdays(weekdays)}`);
+    }
+    const dayText = dayParts.length === 0 ? 'every day' : dayParts.join(' OR ');
+    const monthText = months.length > 0 ? ` in ${joinList(months.map((m) => MONTHS[m - 1]))}` : '';
+    return {
+        text: `${time}, ${dayText}${monthText}`,
+        dayOfMonthOrWeekday: monthDays.length > 0 && weekdays.length > 0,
+    };
+}
+function instantText(value) {
+    if (typeof value !== 'string' && !(value instanceof Date))
+        return null;
+    const date = new Date(value);
+    return Number.isNaN(date.getTime())
+        ? typeof value === 'string'
+            ? value
+            : null
+        : (0, iso_instant_1.formatUtcInstant)(date);
+}
+/**
+ * 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.
+ */
+function recurrenceSummaryLines(task) {
+    const recurrence = task.recurrence;
+    const pattern = typeof recurrence?.pattern === 'string' ? recurrence.pattern.trim() : '';
+    if (!recurrence || !pattern)
+        return [];
+    const zone = typeof recurrence.timezone === 'string' && recurrence.timezone.trim()
+        ? recurrence.timezone.trim()
+        : 'UTC';
+    const reading = describeCronPattern(pattern);
+    const lines = [`Recurs:      ${pattern} (${zone})${reading ? ` - ${reading.text}` : ''}`];
+    const facts = [];
+    if (recurrence.paused === true)
+        facts.push('paused');
+    const next = instantText(recurrence.nextRunAt ?? task.scheduledFor);
+    if (next)
+        facts.push(`next ${next}`);
+    const used = Number.isFinite(Number(recurrence.runsCompleted))
+        ? Number(recurrence.runsCompleted)
+        : 0;
+    const cap = Number(recurrence.maxRuns);
+    facts.push(Number.isInteger(cap) && cap > 0 ? `${used} of ${cap} runs` : `${used} runs so far, no cap`);
+    const ends = instantText(recurrence.endDate);
+    if (ends)
+        facts.push(`ends ${ends}`);
+    lines.push(`             ${facts.join(', ')}`);
+    if (reading?.dayOfMonthOrWeekday) {
+        lines.push('             Cron note: with both a day of the month and a weekday, it fires when EITHER matches, not only when both do.');
+    }
+    return lines;
+}

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

@@ -0,0 +1,28 @@
+export type ReminderOutcome = {
+    /** The Task already had a live reminder with these words, and that row was returned. */
+    reused?: boolean;
+    /** ...and it was moved to the requested time. */
+    moved?: boolean;
+    /** Where it was before it moved. */
+    previousRunAt?: string;
+};
+export type ReminderTrigger = {
+    id?: string;
+    once?: {
+        runAt?: string;
+    };
+    reminderOutcome?: ReminderOutcome;
+};
+/**
+ * The lines to print after a successful `POST /api/triggers`.
+ *
+ * `requested` is the instant the user asked for; the stored `once.runAt` wins when the
+ * server returned one, because that is the time that will fire.
+ */
+export declare function reminderReceiptLines(input: {
+    title: string;
+    trigger: ReminderTrigger | null | undefined;
+    requested: Date;
+    bin?: string;
+    timeZone?: string;
+}): string[];

package/dist/lib/task-reminder.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reminderReceiptLines = reminderReceiptLines;
+/**
+ * The receipt `skrr tasks remind` prints (OSK-21505).
+ *
+ * It used to say "Reminder set for <title> at <toLocaleString()>." for every outcome: a
+ * local time with no zone and a doubled full stop, no id to cancel with, and the same
+ * words when the server had silently MOVED the Task's one existing reminder ("two
+ * identical reminders are one reminder") - so a person who set "2 days before" and then
+ * "1 hour before" lost the first and was never told.
+ *
+ * The server now answers `reminderOutcome` beside the trigger (additive; an older server
+ * omits it, and the receipt falls back to the plain "set" wording rather than guessing).
+ */
+const iso_instant_1 = require("./iso-instant");
+function readInstant(value) {
+    if (typeof value !== 'string' && !(value instanceof Date))
+        return null;
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date;
+}
+/**
+ * The lines to print after a successful `POST /api/triggers`.
+ *
+ * `requested` is the instant the user asked for; the stored `once.runAt` wins when the
+ * server returned one, because that is the time that will fire.
+ */
+function reminderReceiptLines(input) {
+    const { title, trigger, requested, bin = 'skrr', timeZone } = input;
+    const stored = readInstant(trigger?.once?.runAt) ?? requested;
+    const at = (0, iso_instant_1.describeInstant)(stored, timeZone);
+    const outcome = trigger?.reminderOutcome;
+    const lines = [];
+    if (outcome?.reused && outcome.moved) {
+        const previous = readInstant(outcome.previousRunAt);
+        lines.push(`Reminder moved for ${title} to ${at}${previous ? ` (was ${(0, iso_instant_1.describeInstant)(previous, timeZone)})` : ''}`);
+        lines.push('  A Task keeps one reminder per wording, so the earlier time no longer fires.');
+    }
+    else if (outcome?.reused) {
+        lines.push(`Reminder already set for ${title} at ${at}; nothing changed`);
+    }
+    else {
+        lines.push(`Reminder set for ${title} at ${at}`);
+    }
+    if (trigger?.id) {
+        lines.push(`  Reminder id: ${trigger.id}   Cancel it with: ${bin} followups cancel ${trigger.id}`);
+    }
+    return lines;
+}

package/dist/lib/triggers.d.ts

@@ -1,6 +1,12 @@
 import { type EmbeddedActionRef, type TriggerIntentUnsupportedItem, type TriggerPreflightReport, type TriggerSensorConfig } from '@skrr-ai/data-provider';
 export declare const TRIGGER_KINDS: readonly ["schedule", "once", "event", "stochastic", "self_scheduled", "on_demand", "form", "chat_message"];
-export declare const TRIGGER_SCOPE_KINDS: readonly ["agent", "group_chat_subscriber", "space_oracle", "space_subscriber", "key_result_watcher", "task_watcher", "goal_watcher", "entity_reminder"];
+/**
+ * The scope kinds the trigger endpoints accept. NOT a list of its own: `@skrr-ai/data-provider` owns it
+ * (`TRIGGER_API_SCOPE_KINDS`) and the API route reads the same array. The hand-written copy that stood here
+ * lacked `commitment_watcher` and `space_cycle`, so `triggers list --scope commitment_watcher` was refused locally
+ * for a scope the server serves (OSK-21518). `trigger-scope-kinds-parity.spec.ts` pins it.
+ */
+export declare const TRIGGER_SCOPE_KINDS: readonly ["agent", "group_chat_subscriber", "space_oracle", "space_subscriber", "key_result_watcher", "task_watcher", "goal_watcher", "commitment_watcher", "entity_reminder", "space_cycle"];
 /**
  * Executor modes this CLI will let you author.
  *
@@ -508,7 +514,12 @@ export declare function formatDuplicateSubscriptionWarning(trigger: unknown): {
  * "armed" when it will fire and "inert" until enabled — so a freshly-created
  * trigger did not plainly confirm it is live.
  */
-export declare function armedStateLabel(enabled: boolean | undefined): string;
+export declare function armedStateLabel(enabled: boolean | undefined, lastResult?: string | null, 
+/** Pass for a `once` trigger: how often its single fire ran. A spent one-shot is not waiting to be enabled (OSK-21509). */
+oneShot?: {
+    fires?: number;
+    failures?: number;
+} | null): string;
 /**
  * Human phrasing for an effect trigger's write mode (OSK-4886).
  *

package/dist/lib/triggers.js

@@ -66,16 +66,13 @@ exports.TRIGGER_KINDS = [
     'form',
     'chat_message',
 ];
-exports.TRIGGER_SCOPE_KINDS = [
-    'agent',
-    'group_chat_subscriber',
-    'space_oracle',
-    'space_subscriber',
-    'key_result_watcher',
-    'task_watcher',
-    'goal_watcher',
-    'entity_reminder',
-];
+/**
+ * The scope kinds the trigger endpoints accept. NOT a list of its own: `@skrr-ai/data-provider` owns it
+ * (`TRIGGER_API_SCOPE_KINDS`) and the API route reads the same array. The hand-written copy that stood here
+ * lacked `commitment_watcher` and `space_cycle`, so `triggers list --scope commitment_watcher` was refused locally
+ * for a scope the server serves (OSK-21518). `trigger-scope-kinds-parity.spec.ts` pins it.
+ */
+exports.TRIGGER_SCOPE_KINDS = data_provider_1.TRIGGER_API_SCOPE_KINDS;
 /**
  * Executor modes this CLI will let you author.
  *
@@ -346,12 +343,15 @@ exports.SCOPE_IMPLIED_REF_KEY = {
     space_oracle: 'spaceId',
     goal_watcher: 'goalId',
     group_chat_subscriber: 'groupChatId',
+    space_cycle: 'spaceId',
 };
 /** Ref keys each multi-ref scope expects, so the error can name them. */
 const SCOPE_EXPECTED_REF_KEYS = {
     task_watcher: ['taskId', 'watcherAgentId'],
     key_result_watcher: ['keyResultId', 'watcherAgentId'],
     space_subscriber: ['spaceId', 'agentId', 'subscriberUserId'],
+    // `commitmentId` is the one the resolver requires; it also reads optional agentId/goalId/spaceId/... refs.
+    commitment_watcher: ['commitmentId'],
 };
 function parseKeyValueFlags(values, flagName, scopeKind) {
     const refs = {};
@@ -1241,8 +1241,24 @@ function formatDuplicateSubscriptionWarning(trigger) {
  * "armed" when it will fire and "inert" until enabled — so a freshly-created
  * trigger did not plainly confirm it is live.
  */
-function armedStateLabel(enabled) {
-    return enabled === false ? 'no — inert until enabled' : 'yes — will fire';
+function armedStateLabel(enabled, lastResult, 
+/** Pass for a `once` trigger: how often its single fire ran. A spent one-shot is not waiting to be enabled (OSK-21509). */
+oneShot) {
+    if (enabled === false && oneShot && (oneShot.fires ?? 0) > 0) {
+        return 'no — already fired (a one-shot trigger is spent once it fires)';
+    }
+    if (enabled === false && oneShot && (oneShot.failures ?? 0) > 0) {
+        return 'no — its one fire already ran and did not succeed (a one-shot trigger is spent; see `skrr triggers audit`)';
+    }
+    if (enabled === false)
+        return 'no — inert until enabled';
+    // "Will fire" is the row's intent. A platform-managed row whose owner is fenced (Always-On off) ticks on
+    // schedule and is skipped every time, and the same screen's `Fires:` line says so; the first line a reader
+    // meets must not say the opposite (dogfood df-261031-commitment-authoring, OSK-21103).
+    const skipped = typeof lastResult === 'string' ? /^skipped:(.+)$/.exec(lastResult) : null;
+    return skipped
+        ? `yes — but its last tick was skipped (${skipped[1]}), so it did not run`
+        : 'yes — will fire';
 }
 /**
  * Human phrasing for an effect trigger's write mode (OSK-4886).
@@ -1340,7 +1356,9 @@ function fireRefusalLines(metadata) {
 function renderTriggerSummary(trigger, log, options = {}) {
     log(`ID:       ${trigger.id ?? '-'}`);
     log(`Kind:     ${trigger.kind ?? '-'}`);
-    log(`Armed:    ${armedStateLabel(trigger.enabled)}`);
+    log(`Armed:    ${armedStateLabel(trigger.enabled, trigger.audit?.lastResult, trigger.kind === 'once'
+        ? { fires: trigger.audit?.fireCount, failures: trigger.audit?.failureCount }
+        : undefined)}`);
     log(`Scope:    ${scopeLabel(trigger)}`);
     /*
      * Say when the row is not yours to change.

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

@@ -69,6 +69,7 @@ const SESSION_TURN_DIFF_LIVE = "session_turn_diff_live_v1";
 const WORKSPACE_ISOLATION_PROBE = "workspace_isolation_probe_v1";
 const TOOL_RESPONSE_OUTBOX = "tool_response_outbox_v1";
 const SESSION_STEER = "session_steer_v1";
+const QUESTION_ACK = "question_ack_v1";
 const CONNECTION = [
   toServer("daemon:register", "The daemon introduces itself: identity, version, capabilities, sessions it holds.", {
     delivery: "acked",
@@ -226,7 +227,16 @@ const SESSIONS = [
     delivery: "acked",
     answeredBy: "daemon:claude:question:response"
   }),
-  toDaemon("daemon:claude:question:response", "A person's answer to a question.")
+  // A daemon that announces `question_ack_v1` says whether it TOOK the answer: the
+  // question was still pending and the harness has it ('delivered'), or the daemon had
+  // already timed out or been cancelled ('not_pending'). Without the capability the
+  // worker settles an answer at the relay handoff, as it always did.
+  toDaemon("daemon:claude:question:response", "A person's answer to a question.", {
+    delivery: "acked",
+    answeredBy: "daemon:claude:question:ack",
+    capability: QUESTION_ACK
+  }),
+  toServer("daemon:claude:question:ack", "Whether this daemon took a person's answer to a question, or had already stopped waiting.", { capability: QUESTION_ACK, payload: { kind: "zod", schema: "daemonQuestionAckSchema" } })
 ];
 const TOOLS = [
   toDaemon("daemon:tool:request", "Run one tool call on this machine.", {

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

@@ -0,0 +1,123 @@
+/**
+ * executorStopReceipt.ts — a daemon-signed proof that a scheduled session stopped.
+ *
+ * OSK-20777, Gate 1 (docs/architecture/scheduled-publication-custody-enrollment-2026-11-01.md).
+ * Today the executor's terminal proof is the daemon reporting about itself over its own socket: the
+ * dispatch tuple is checked for consistency but nothing is signed, nothing covers descendant
+ * processes, and nothing says what was erased. A receipt is that report, signed with the device key
+ * the server already pins on the daemon's row, so a settlement that depends on it depends on the
+ * machine and not on whoever reached the socket.
+ *
+ * No new cryptography. A receipt is a DPoP-shaped device proof (`deviceKey.ts`) under its OWN header
+ * `typ`, so the two can never stand in for each other: a request proof fails here with `bad_typ`, and a
+ * receipt fails the request verifier the same way. The proof's `ath` commits to the SHA-256 of the
+ * canonical receipt body, its `htu` names the dispatch, and the pin decides which key may sign it.
+ *
+ * Verification is deliberately strict and returns a reason, never a boolean:
+ *   - a pin is REQUIRED (a receipt with no key to compare against has no authority);
+ *   - the algorithm admitted is the algorithm of the pin, never a list, so a receipt cannot choose a
+ *     weaker algorithm than the device enrolled with;
+ *   - the body is a closed shape with bounded fields;
+ *   - every field the caller expects (the dispatch the server issued) must match exactly;
+ *   - a descendant that survived is `not_quiescent`, not a valid receipt with a footnote;
+ *   - erasure is claimed only for the one scope the owner allowed, `session_temp`.
+ *
+ * Freshness is the caller's decision (`maxAgeSeconds`). A receipt can legitimately arrive hours after it
+ * was signed, replayed from the daemon's response WAL after a reconnect, so it has no short window of its
+ * own. Replay protection is the dispatch binding: the server accepts one receipt per `dispatchId`.
+ */
+import { type DeviceKeyAlg, type DeviceKeySigner, type DevicePublicJwk, type VerifyFailureReason } from './deviceKey.js';
+/** Header `typ` of an executor stop receipt. Distinct from `DEVICE_PROOF_TYP` on purpose. */
+export declare const EXECUTOR_STOP_RECEIPT_TYP = "skrr-executor-stop-receipt+jwt";
+/** What the daemon may claim to have erased. One scope, decided by the owner (2026-11-01). */
+export declare const EXECUTOR_STOP_RECEIPT_ERASURE_SCOPES: readonly ["session_temp"];
+export type ExecutorStopReceiptErasureScope = (typeof EXECUTOR_STOP_RECEIPT_ERASURE_SCOPES)[number];
+/** Default ceiling on a receipt's age, for a caller that does not decide: one day. */
+export declare const EXECUTOR_STOP_RECEIPT_DEFAULT_MAX_AGE_SECONDS: number;
+export type ExecutorStopReceiptStatus = 'completed' | 'failed' | 'cancelled';
+export interface ExecutorStopReceiptBody {
+    version: 1;
+    daemonId: string;
+    /** The scheduled Run (or Source) the dispatch belongs to. */
+    sourceId: string;
+    sessionId: string;
+    requestId: string;
+    dispatchId: string;
+    status: ExecutorStopReceiptStatus;
+    /** ISO-8601, when the session's process tree was last observed stopped. */
+    stoppedAt: string;
+    /** Counted after the stop, not assumed. `observed === stopped + survivors`. */
+    descendants: {
+        observed: number;
+        stopped: number;
+        survivors: number;
+    };
+    /** `performed: false` carries no scope: nothing was erased and nothing is claimed. */
+    erasure: {
+        performed: false;
+    } | {
+        performed: true;
+        scope: ExecutorStopReceiptErasureScope;
+        artifacts: number;
+        bytes: number;
+    };
+}
+export interface ExecutorStopReceipt {
+    body: ExecutorStopReceiptBody;
+    /** The device-key proof (JWS compact) that commits to `body`. */
+    proof: string;
+}
+export type ExecutorStopReceiptFailureReason = VerifyFailureReason | 'bad_receipt' | 'no_pin' | 'binding_mismatch' | 'not_quiescent';
+export type VerifyExecutorStopReceiptResult = {
+    valid: true;
+    body: ExecutorStopReceiptBody;
+    alg: DeviceKeyAlg;
+    thumbprint: string;
+    signedAtSeconds: number;
+} | {
+    valid: false;
+    reason: ExecutorStopReceiptFailureReason;
+};
+declare const BINDING_KEYS: readonly ["daemonId", "sourceId", "sessionId", "requestId", "dispatchId"];
+/**
+ * Stable JSON: object keys sorted at every level, no whitespace. The signer and the verifier must
+ * produce the same bytes from the same body, whatever order a transport reordered its keys into.
+ */
+export declare function canonicalReceiptJson(value: unknown): string;
+/** The URI a receipt's proof names. Reserved `.invalid` host: it can never be a real request target. */
+export declare function executorStopReceiptHtu(dispatchId: string): string;
+/** Shape check only. Returns the body as typed, or null when it is not exactly a v1 receipt body. */
+export declare function parseExecutorStopReceiptBody(value: unknown): ExecutorStopReceiptBody | null;
+export interface SignExecutorStopReceiptOptions {
+    /** Test hooks; production leaves both unset. */
+    iat?: number;
+    jti?: string;
+}
+/**
+ * Sign a receipt with any `DeviceKeySigner` (a software key, or a hardware handle). Throws on a body
+ * that is not exactly a v1 receipt body, so a daemon bug cannot produce a signed receipt the server
+ * would only reject later.
+ */
+export declare function signExecutorStopReceipt(signer: DeviceKeySigner, body: ExecutorStopReceiptBody, options?: SignExecutorStopReceiptOptions): Promise<ExecutorStopReceipt>;
+export interface VerifyExecutorStopReceiptOptions {
+    /** The key pinned on the daemon's row. REQUIRED: without it nothing authorizes the signature. */
+    pinnedPublicJwk: DevicePublicJwk | undefined;
+    /**
+     * What the server issued for this dispatch. Every key given must equal the receipt's, so a receipt for
+     * another daemon, Run, session, request or dispatch is `binding_mismatch`.
+     */
+    expected?: Partial<Pick<ExecutorStopReceiptBody, (typeof BINDING_KEYS)[number]>>;
+    /** Ceiling on the receipt's age in seconds. Defaults to one day. */
+    maxAgeSeconds?: number;
+    /** Tolerated clock skew in seconds. Defaults to the proof verifier's. */
+    clockSkewSeconds?: number;
+    /** Testing hook. */
+    now?: number;
+}
+/**
+ * Verify a receipt against the pinned key. Order matters: shape, then signature and pin, then the
+ * binding to the dispatch, then what the body claims. A forged receipt is reported as the forgery it
+ * is (`sig_invalid`, `pin_mismatch`, `ath_mismatch`), not as a quiescence failure.
+ */
+export declare function verifyExecutorStopReceipt(receipt: unknown, options: VerifyExecutorStopReceiptOptions): VerifyExecutorStopReceiptResult;
+export {};