@skrr-ai/cli 0.1.128 → 0.1.130

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/task-schedule-notes.d.ts

@@ -0,0 +1,46 @@
+/**
+ * What a schedule command did to the schedule, as sentences.
+ *
+ * The server already knows these things and reports them as response-only fields
+ * (`schedulePaused`, `scheduleChange`, `scheduleResume`, `scheduleElapsedWhileArchived`).
+ * The commands printed "Scheduled ..." / "Resumed ..." / "unarchived" regardless, so a
+ * person could not tell that a time was recorded but nothing was armed (OSK-21521), that
+ * a slot which fell inside their pause was skipped (OSK-21513), or that a time which
+ * passed while a Task was archived was dropped rather than run (OSK-21494).
+ */
+type Instant = string | Date | null | undefined;
+export type ScheduleResult = {
+    schedulePaused?: {
+        pausedAt?: Instant;
+    };
+    scheduleChange?: {
+        changed?: boolean;
+        reason?: string;
+    };
+};
+/**
+ * Lines to print under `Scheduled task ...`. A paused series is told as such, with the one
+ * command that un-pauses it, because `schedule` never does.
+ */
+export declare function scheduleResultLines(result: ScheduleResult | null | undefined, taskRef: string, bin?: string): string[];
+export type ResumeResult = {
+    scheduleResume?: {
+        skippedScheduledFor?: Instant;
+        nextRunAt?: Instant;
+    };
+};
+/** What resuming did to the slot that fell inside the pause, or nothing when none did. */
+export declare function resumeResultLines(result: ResumeResult | null | undefined): string[];
+export type UnarchiveResult = {
+    scheduleElapsedWhileArchived?: {
+        skippedScheduledFor?: Instant;
+        nextRunAt?: Instant;
+    };
+};
+/** What unarchiving did to a schedule that came due while the Task was archived. */
+export declare function unarchiveResultLines(result: UnarchiveResult | null | undefined, taskRef: string, bin?: string): string[];
+/** At archive time: a kept time that will not fire while archived. */
+export declare function archiveResultLines(result: {
+    scheduledFor?: Instant;
+} | null | undefined): string[];
+export {};

package/dist/lib/task-schedule-notes.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * What a schedule command did to the schedule, as sentences.
+ *
+ * The server already knows these things and reports them as response-only fields
+ * (`schedulePaused`, `scheduleChange`, `scheduleResume`, `scheduleElapsedWhileArchived`).
+ * The commands printed "Scheduled ..." / "Resumed ..." / "unarchived" regardless, so a
+ * person could not tell that a time was recorded but nothing was armed (OSK-21521), that
+ * a slot which fell inside their pause was skipped (OSK-21513), or that a time which
+ * passed while a Task was archived was dropped rather than run (OSK-21494).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scheduleResultLines = scheduleResultLines;
+exports.resumeResultLines = resumeResultLines;
+exports.unarchiveResultLines = unarchiveResultLines;
+exports.archiveResultLines = archiveResultLines;
+function iso(value) {
+    if (!value)
+        return null;
+    const at = value instanceof Date ? value : new Date(value);
+    return Number.isNaN(at.getTime()) ? String(value) : at.toISOString();
+}
+/**
+ * Lines to print under `Scheduled task ...`. A paused series is told as such, with the one
+ * command that un-pauses it, because `schedule` never does.
+ */
+function scheduleResultLines(result, taskRef, bin = 'skrr') {
+    const lines = [];
+    if (result?.scheduleChange?.changed === false) {
+        lines.push('Already scheduled exactly like this; nothing changed.');
+    }
+    if (result?.schedulePaused) {
+        lines.push('The recurring series is PAUSED: this time is recorded, but nothing is armed and nothing will run.', `Resume it with \`${bin} tasks resume-schedule ${taskRef}\` (\`schedule\` never resumes a paused series).`);
+    }
+    return lines;
+}
+/** What resuming did to the slot that fell inside the pause, or nothing when none did. */
+function resumeResultLines(result) {
+    const resume = result?.scheduleResume;
+    if (!resume)
+        return [];
+    const skipped = iso(resume.skippedScheduledFor);
+    const next = iso(resume.nextRunAt);
+    return [
+        `Skipped the run that came due while paused (${skipped}); it is not replayed.`,
+        next ? `Next run: ${next}` : 'The series has no further run.',
+    ];
+}
+/** What unarchiving did to a schedule that came due while the Task was archived. */
+function unarchiveResultLines(result, taskRef, bin = 'skrr') {
+    const elapsed = result?.scheduleElapsedWhileArchived;
+    if (!elapsed)
+        return [];
+    const skipped = iso(elapsed.skippedScheduledFor);
+    const next = iso(elapsed.nextRunAt);
+    return [
+        `Its scheduled time (${skipped}) passed while it was archived, so it was skipped, not run.`,
+        next
+            ? `Next run: ${next}`
+            : `It is no longer scheduled; set a new time with \`${bin} tasks schedule ${taskRef} --at <time>\`.`,
+    ];
+}
+/** At archive time: a kept time that will not fire while archived. */
+function archiveResultLines(result) {
+    const kept = iso(result?.scheduledFor);
+    return kept
+        ? [
+            `Its scheduled time (${kept}) is kept but will not fire while archived; a time that passes meanwhile is skipped on unarchive.`,
+        ]
+        : [];
+}

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.
  *
@@ -137,6 +143,16 @@ export interface TriggerDefinition {
         recordedAt?: string;
         retiredAt?: string;
     };
+    /**
+     * Server-DERIVED and only present when the list was asked for it (`?include=autonomy`), and
+     * only on a self-reflection loop: whether its scheduled fires RUN (`runs`) or stop short of
+     * running because the agent's initiative mode applies to them (`suggests_only`, with
+     * `autonomyNote` saying why). It is the verdict `triggers preflight` prints at its initiative
+     * gate. A server that predates it, or a verdict it could not reach, sends neither field, which
+     * means UNKNOWN: a reader must never take an absent `autonomy` for `runs` (OSK-21606).
+     */
+    autonomy?: 'runs' | 'suggests_only';
+    autonomyNote?: string;
     createdAt?: string;
     updatedAt?: string;
 }
@@ -451,6 +467,14 @@ export declare function scopeLabel(trigger: TriggerDefinition): string;
  * `triggers show` said `Armed: yes` with no time (OSK-15416).
  */
 export declare function onceDueAt(trigger: TriggerDefinition): string | null;
+/**
+ * When a trigger WILL fire next: its scheduled time, and only while it is enabled. A disabled
+ * trigger keeps the `schedule.nextRunAt` it had when it was paused, and nothing will ever run
+ * at that time — `agents reflect` and `agents schedule-overview` printed it as the next run of
+ * a paused loop while `agents upcoming` correctly listed nothing (OSK-21605). Null when
+ * nothing is scheduled; never the last fire.
+ */
+export declare function scheduledRunAt(trigger: TriggerDefinition): string | null;
 export declare function nextRunLabel(trigger: TriggerDefinition): string;
 /**
  * Whether a trigger will actually fire — not merely whether someone left it on.
@@ -508,7 +532,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, lastResult?: string | null): 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

@@ -39,6 +39,7 @@ exports.agentRefEntity = agentRefEntity;
 exports.fetchAgentScopedTrigger = fetchAgentScopedTrigger;
 exports.scopeLabel = scopeLabel;
 exports.onceDueAt = onceDueAt;
+exports.scheduledRunAt = scheduledRunAt;
 exports.nextRunLabel = nextRunLabel;
 exports.armedLabel = armedLabel;
 exports.degradedMarker = degradedMarker;
@@ -66,16 +67,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 +344,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 = {};
@@ -1078,12 +1079,21 @@ function onceDueAt(trigger) {
     const due = once.runAt ?? once.at;
     return due ? String(due) : null;
 }
+/**
+ * When a trigger WILL fire next: its scheduled time, and only while it is enabled. A disabled
+ * trigger keeps the `schedule.nextRunAt` it had when it was paused, and nothing will ever run
+ * at that time — `agents reflect` and `agents schedule-overview` printed it as the next run of
+ * a paused loop while `agents upcoming` correctly listed nothing (OSK-21605). Null when
+ * nothing is scheduled; never the last fire.
+ */
+function scheduledRunAt(trigger) {
+    if (trigger.enabled === false)
+        return null;
+    const next = trigger.schedule?.nextRunAt ?? trigger.selfScheduled?.nextRunAt ?? onceDueAt(trigger);
+    return next ? String(next) : null;
+}
 function nextRunLabel(trigger) {
-    const next = trigger.schedule?.nextRunAt ??
-        trigger.selfScheduled?.nextRunAt ??
-        onceDueAt(trigger) ??
-        trigger.audit?.lastFiredAt ??
-        '';
+    const next = scheduledRunAt(trigger) ?? trigger.audit?.lastFiredAt ?? '';
     return next ? String(next) : '-';
 }
 /**
@@ -1241,7 +1251,15 @@ 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, lastResult) {
+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
@@ -1348,7 +1366,9 @@ function fireRefusalLines(metadata) {
 function renderTriggerSummary(trigger, log, options = {}) {
     log(`ID:       ${trigger.id ?? '-'}`);
     log(`Kind:     ${trigger.kind ?? '-'}`);
-    log(`Armed:    ${armedStateLabel(trigger.enabled, trigger.audit?.lastResult)}`);
+    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.
@@ -1428,7 +1448,7 @@ function renderTriggerSummary(trigger, log, options = {}) {
     const next = nextRunLabel(trigger);
     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));
+        const upcoming = Boolean(scheduledRunAt(trigger));
         log(`${upcoming ? 'Next run:' : 'Last run:'}${next.length > 0 ? ` ${next}` : ''}`);
     }
     /*

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/deviceIdentityBridge.d.ts

@@ -1,5 +1,6 @@
 import { type DeviceKeyAlg, type DevicePublicJwk } from './deviceKey.js';
 import { type DeviceKeyCustody, type DeviceKeyHandle } from './deviceKeyHandle.js';
+import { type ExecutorStopReceipt, type ExecutorStopReceiptBody } from './executorStopReceipt.js';
 import { type HardwareKeyCapability, type HardwareKeyRecord } from './deviceKeyHardware.js';
 /**
  * The `cred_envelope.read.decrypt_failed` hint for the device PRIVATE key
@@ -235,6 +236,14 @@ export declare function signServerRequest(opts: {
     refreshToken?: string;
     accessToken?: string;
 }): Promise<string | null>;
+/**
+ * Sign an executor stop receipt (OSK-20777 Gate 1) with the device key: the signed proof that a
+ * scheduled session stopped, which the server verifies against the key pinned on this machine's row.
+ * Returns null when device identity is not active or the key cannot sign right now. NEVER throws: a
+ * failed sign emits a telemetry event and the caller sends the response without a receipt, which the
+ * server treats as an unproven stop rather than as a failure of the session.
+ */
+export declare function signExecutorStopReceiptWithDeviceKey(body: ExecutorStopReceiptBody): Promise<ExecutorStopReceipt | null>;
 /** @internal Test seams — file path resolvers. */
 export declare function __publicKeyPathForTest(profile: string): string;
 export declare function __privateKeyPathForTest(profile: string): string;

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

@@ -51,6 +51,7 @@ __export(deviceIdentityBridge_exports, {
   persistPendingHardwareKey: () => persistPendingHardwareKey,
   prepareHardwareKeyCandidate: () => prepareHardwareKeyCandidate,
   resetDeviceIdentity: () => resetDeviceIdentity,
+  signExecutorStopReceiptWithDeviceKey: () => signExecutorStopReceiptWithDeviceKey,
   signServerRequest: () => signServerRequest,
   signWithCandidate: () => signWithCandidate
 });
@@ -60,6 +61,7 @@ var import_node_path = __toESM(require("node:path"), 1);
 var import_proper_lockfile = __toESM(require("proper-lockfile"), 1);
 var import_deviceKey = require("./deviceKey.js");
 var import_deviceKeyHandle = require("./deviceKeyHandle.js");
+var import_executorStopReceipt = require("./executorStopReceipt.js");
 var import_deviceKeyHardware = require("./deviceKeyHardware.js");
 var import_credentialEnvelopeBridge = require("./credentialEnvelopeBridge.js");
 var import_profileStateDir = require("./profileStateDir.js");
@@ -827,6 +829,25 @@ async function signServerRequest(opts) {
     return null;
   }
 }
+async function signExecutorStopReceiptWithDeviceKey(body) {
+  reloadIfRecovered();
+  const state = _state;
+  if (state.kind !== "active")
+    return null;
+  try {
+    return await (0, import_executorStopReceipt.signExecutorStopReceipt)(state.key, body);
+  } catch (err) {
+    emit("sign_failed", false, {
+      profile: state.profile,
+      thumbprint: state.key.thumbprint,
+      custody: state.key.custody,
+      method: "executor_stop_receipt",
+      ...err instanceof import_deviceKeyHardware.HardwareDeviceKeyError ? { hardwareFailure: err.code } : {},
+      message: err?.message ?? "unknown"
+    });
+    return null;
+  }
+}
 function __publicKeyPathForTest(profile) {
   return publicKeyPath(profile);
 }
@@ -1040,6 +1061,7 @@ async function enrollWithServer(opts) {
   persistPendingHardwareKey,
   prepareHardwareKeyCandidate,
   resetDeviceIdentity,
+  signExecutorStopReceiptWithDeviceKey,
   signServerRequest,
   signWithCandidate
 });

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