@frockbot/plugin-routines 0.3.8 → 0.3.10

package/src/client/index.test.ts

@@ -3,6 +3,8 @@ import type {
   ClientPluginContext,
   ClientSlotRegistration,
 } from "@frockbot/client-core";
+import { frockBotWebDataKey } from "@frockbot/plugin-shell/shared";
+import { ref } from "vue";
 import { routinesClientPlugin } from "./index.js";
 import { routinesStateKey, type RoutinesClientState } from "./state.js";
 
@@ -207,3 +209,87 @@ describe("Routines client contribution", () => {
     mounted.dispose();
   });
 });
+
+describe("the completion badge and the state channel", () => {
+  /**
+   * A Routine that finishes cannot speak in the transcript, so the badge is
+   * the only place a completion becomes visible — and it used to read the
+   * inbox only on a Bot switch and on opening the drawer. A firing that
+   * completed while the app sat open left the count stale until something else
+   * happened to reload it, which for a `@every 1m` Routine is most of the day.
+   */
+  test("reads the inbox again when the Bot's runs change", async () => {
+    const inboxReads: string[] = [];
+    let invalidate:
+      ((topic: "computer" | "runs" | undefined) => Promise<void>) | undefined;
+    let stopped = 0;
+    const shell = ref({ activeBotId: "scout" });
+    const context: ClientPluginContext = {
+      transport: {
+        turn: () => Promise.resolve({ runId: "run", text: "", events: [] }),
+        hostedRequest: (path) => {
+          if (path.endsWith("/inbox")) {
+            inboxReads.push(path);
+            return Promise.resolve({
+              schemaVersion: 1,
+              botId: "scout",
+              entries: [],
+              unacknowledged: inboxReads.length,
+            });
+          }
+          return Promise.resolve({
+            schemaVersion: 1,
+            botId: "scout",
+            routines: [],
+          });
+        },
+        watchBotState: (_botId, listener) => {
+          invalidate = listener.invalidate;
+          return () => {
+            stopped += 1;
+          };
+        },
+      },
+      inject: (key) => {
+        if (key === frockBotWebDataKey) return shell as never;
+        throw new Error("unexpected client provider");
+      },
+      provide: () => () => {},
+      slot: () => () => {},
+    };
+    const disposers = routinesClientPlugin(context);
+    if (!Array.isArray(disposers)) throw new Error("expected registrations");
+
+    expect(invalidate).toBeDefined();
+    // A Turn settling on this Bot — an automation Turn is one — refreshes it.
+    await invalidate!("runs");
+    // A resynchronise carries no topic and must not be filtered out.
+    await invalidate!(undefined);
+    // Another subsystem's news is not the badge's business.
+    await invalidate!("computer");
+    expect(inboxReads).toHaveLength(2);
+
+    shell.value = { activeBotId: "other" };
+    await Promise.resolve();
+    expect(stopped).toBe(1);
+    for (const dispose of disposers.toReversed()) dispose();
+  });
+
+  test("does not reach for the shell when the client has no state channel", () => {
+    // The Cordis local host has no channel. Injecting the shell there would
+    // throw on mount and take the whole Contribution with it.
+    const context: ClientPluginContext = {
+      transport: {
+        turn: () => Promise.resolve({ runId: "run", text: "", events: [] }),
+        hostedRequest: () =>
+          Promise.resolve({ schemaVersion: 1, botId: "scout", routines: [] }),
+      },
+      inject: () => {
+        throw new Error("unexpected client provider");
+      },
+      provide: () => () => {},
+      slot: () => () => {},
+    };
+    expect(() => routinesClientPlugin(context)).not.toThrow();
+  });
+});

package/src/client/index.ts

@@ -7,7 +7,8 @@
 // versioned command with its own idempotency key, and every read is decoded at
 // the seam before a component sees it.
 import type { ClientPlugin } from "@frockbot/client-core";
-import { ref } from "vue";
+import { frockBotWebDataKey } from "@frockbot/plugin-shell/shared";
+import { ref, watch } from "vue";
 import {
   decodeRoutineCommandReceiptV1,
   decodeRoutineInboxReceiptV1,
@@ -262,6 +263,40 @@ export const routinesClientPlugin: ClientPlugin = (ctx) => {
     },
   });
 
+  // The badge is the only place a firing that finished becomes visible, and it
+  // used to load only on a Bot switch and on opening the drawer: a Routine that
+  // completed while the app was open left the count stale until something else
+  // happened to reload it. The state channel already says when this Bot's runs
+  // changed — an automation Turn settling is one of those — so the badge reads
+  // the inbox again on that signal rather than polling or waiting for a click.
+  const watchBotState = ctx.transport.watchBotState;
+  if (watchBotState) {
+    const shell = ctx.inject(frockBotWebDataKey);
+    let stopWatching: (() => void) | undefined;
+    watch(
+      () => shell.value.activeBotId,
+      (activeBotId) => {
+        stopWatching?.();
+        stopWatching = undefined;
+        if (!activeBotId) return;
+        stopWatching = watchBotState(activeBotId, {
+          async invalidate(topic) {
+            // `undefined` is a resynchronise, so it is not filtered out.
+            if (topic !== undefined && topic !== "runs") return;
+            if (shell.value.activeBotId !== activeBotId) return;
+            await state.value.loadInbox(activeBotId);
+          },
+          status() {
+            // The badge has nothing to say about the socket itself; a closed
+            // channel simply stops refreshing it, and opening the drawer still
+            // reads the inbox.
+          },
+        });
+      },
+      { immediate: true },
+    );
+  }
+
   return [
     ctx.provide(routinesStateKey, state),
     ctx.slot({

package/src/hook.test.ts

@@ -66,7 +66,19 @@ describe("the hook token", () => {
       (error: unknown) => error,
     );
     expect(refusal).toBeInstanceOf(RoutineHookError);
-    expect((refusal as RoutineHookError).status).toBe(500);
+    // A door that was never given a key is unavailable, not broken, and the
+    // caller is told that and nothing more: the reason names the deployment's
+    // secret variable and stays in the log.
+    expect((refusal as RoutineHookError).status).toBe(503);
+    expect((refusal as RoutineHookError).message).toContain(
+      "ROUTINE_HOOK_SECRET",
+    );
+    expect((refusal as RoutineHookError).publicMessage).toBe(
+      "webhook delivery is not configured",
+    );
+    expect((refusal as RoutineHookError).publicMessage).not.toContain(
+      "ROUTINE_HOOK_SECRET",
+    );
   });
 
   test("a key version is part of the token, so a rotation is a new token", async () => {
@@ -92,14 +104,13 @@ describe("the hook token", () => {
 });
 
 describe("delivery identity", () => {
-  test("is the content when the caller sent no idempotency key", async () => {
-    expect(await routineDeliveryIdV1("brief", '{"a":1}')).toBe(
-      await routineDeliveryIdV1("brief", '{"a":1}'),
+  test("is unique per request when the caller sent no idempotency key", async () => {
+    // Two real events with the same payload are two deliveries. Hashing the
+    // body used to turn the second one into a `duplicate` receipt and no
+    // firing, with nothing anywhere saying an event had been swallowed.
+    expect(await routineDeliveryIdV1("brief", '{"ping":true}')).not.toBe(
+      await routineDeliveryIdV1("brief", '{"ping":true}'),
     );
-    expect(await routineDeliveryIdV1("brief", '{"a":1}')).not.toBe(
-      await routineDeliveryIdV1("brief", '{"a":2}'),
-    );
-    // Two Routines receiving the same body are two deliveries.
     expect(await routineDeliveryIdV1("brief", "{}")).not.toBe(
       await routineDeliveryIdV1("other", "{}"),
     );
@@ -235,9 +246,11 @@ describe("the durable half of the check", () => {
     const receipt = await store.execute(create, USER);
     const token = (receipt as { hook: { token: string } }).hook.token;
 
-    const first = await deliver(store, token, '{"event":"push"}');
+    // A replay is a delivery the caller itself said was the same one, by
+    // sending the key twice.
+    const first = await deliver(store, token, '{"event":"push"}', "evt-1");
     expect(first.status).toBe("accepted");
-    const second = await deliver(store, token, '{"event":"push"}');
+    const second = await deliver(store, token, '{"event":"push"}', "evt-1");
     expect(second).toEqual({ status: "duplicate", fireId: first.fireId });
 
     const fired: string[] = [];
@@ -250,6 +263,29 @@ describe("the durable half of the check", () => {
     expect(fired).toEqual([first.fireId]);
   });
 
+  test("two distinct deliveries with identical bodies are two firings", async () => {
+    const { scheduler, store, create } = harness();
+    const receipt = await store.execute(create, USER);
+    const token = (receipt as { hook: { token: string } }).hook.token;
+
+    // A provider that sends `{"event":"push"}` twice sent two events. Without
+    // an `Idempotency-Key` nothing has claimed they are the same delivery, and
+    // the second used to be answered `duplicate` and never fired — a swallowed
+    // event with no trace anywhere.
+    const first = await deliver(store, token, '{"event":"push"}');
+    const second = await deliver(store, token, '{"event":"push"}');
+    expect(first.status).toBe("accepted");
+    expect(second.status).toBe("accepted");
+    expect(second.fireId).not.toBe(first.fireId);
+
+    const fired: string[] = [];
+    await scheduler.settle(async (fire) => {
+      fired.push(fire.fireId);
+      return { status: "ok" };
+    });
+    expect(fired.sort()).toEqual([first.fireId, second.fireId].sort());
+  });
+
   test("a rotated key retires the one before it", async () => {
     const { store, create } = harness();
     const created = await store.execute(create, USER);

package/src/hook.ts

@@ -70,9 +70,18 @@ export interface RoutineDeliveryReceiptV1 {
 export class RoutineHookError extends Error {
   override readonly name = "RoutineHookError";
   readonly status: number;
-  constructor(status: number, message: string) {
+  /**
+   * What an anonymous caller is told. It is deliberately separate from
+   * `message`: the delivery route answers the open internet, and a refusal
+   * used to hand back the raw reason — including the name of the deployment's
+   * signing-secret variable and whether it was missing or merely short. The
+   * detail stays in `message` for the log; this is the wire body.
+   */
+  readonly publicMessage: string;
+  constructor(status: number, message: string, publicMessage?: string) {
     super(message);
     this.status = status;
+    this.publicMessage = publicMessage ?? message;
   }
 }
 
@@ -124,8 +133,10 @@ export function constantTimeEqualsV1(left: string, right: string): boolean {
 async function signingKey(secret: string): Promise<CryptoKey> {
   if (typeof secret !== "string" || secret.length < 16) {
     throw new RoutineHookError(
-      500,
+      503,
       "ROUTINE_HOOK_SECRET is missing or too short for webhook delivery",
+      // The caller learns the door is shut, not how it is built.
+      "webhook delivery is not configured",
     );
   }
   return crypto.subtle.importKey(
@@ -282,30 +293,39 @@ export function decodeRoutineHookKeyV1(value: unknown): RoutineHookKeyV1 {
 }
 
 /**
- * The delivery id one request is remembered by: the caller's `Idempotency-Key`
- * when it sent one, and otherwise the content itself. Either way the same
- * delivery twice is one firing.
+ * The delivery id one request is remembered by.
+ *
+ * Idempotency is the caller's claim to make, and only the caller can make it:
+ * an `Idempotency-Key` says "this is the same delivery I already sent", and
+ * two deliveries under one key are one firing. Without a key the id is unique
+ * per request, so two deliveries are two firings.
+ *
+ * It used to hash the body when no key was sent. That reads as a safety net
+ * and is really a silent decision about someone else's data: a provider
+ * POSTing `{"ping":true}` twice — two real events, identical payloads — got
+ * one firing and a `duplicate` receipt for the second, with nothing anywhere
+ * saying an event had been dropped. Coalescing without being asked to is worse
+ * than firing twice, because the caller can see a double firing and cannot see
+ * a swallowed one.
  */
 export async function routineDeliveryIdV1(
   routineId: string,
   body: string,
   idempotencyKey?: string | null,
 ): Promise<string> {
-  if (idempotencyKey) {
-    const trimmed = idempotencyKey.trim().slice(0, 256);
-    if (trimmed.length > 0) {
-      return hex(
-        await crypto.subtle.digest(
-          "SHA-256",
-          TEXT.encode(`key${routineId}${trimmed}`),
-        ),
-      );
-    }
+  const trimmed = idempotencyKey?.trim().slice(0, 256) ?? "";
+  if (trimmed.length > 0) {
+    return hex(
+      await crypto.subtle.digest(
+        "SHA-256",
+        TEXT.encode(`key${routineId}${trimmed}`),
+      ),
+    );
   }
   return hex(
     await crypto.subtle.digest(
       "SHA-256",
-      TEXT.encode(`body${routineId}${body}`),
+      TEXT.encode(`delivery${routineId}${crypto.randomUUID()}`),
     ),
   );
 }

package/src/inbox-store.ts

@@ -82,6 +82,8 @@ export interface RoutineTerminalInputV1 {
   /** The Turn's own response text, used when it handed off nothing. */
   responseText?: string;
   now: string;
+  /** The firing did not work; the entry is a complaint, not a completion. */
+  failure?: true;
   read<T>(key: string): Promise<T | undefined>;
 }
 
@@ -129,6 +131,7 @@ export async function routineTerminalRecordsV1(
     createdAt: input.now,
     acknowledged: false,
     ...(input.handoff === undefined ? {} : { wakeId }),
+    ...(input.failure === undefined ? {} : { failure: input.failure }),
   };
   const records: Record<string, unknown> = {
     [routineInboxKeyV1(inbox.nextSeq)]: entry,
@@ -205,6 +208,33 @@ export interface StoredPendingInputV1 {
   input: PendingBotInputV1;
 }
 
+/**
+ * The inputs one drain carries, under the pending-input bound.
+ *
+ * The bound exists so a burst cannot hand a single Turn an unbounded prompt,
+ * and it used to be a flat `slice(-16)` over everything queued. But the four
+ * input kinds are not interchangeable. A dropped `wake` still has an inbox
+ * entry, so the user can read it and nothing is lost; an `approval`, a
+ * `machine-result` or a `superseded-turn` writes no entry anywhere, so
+ * dropping one silently loses a decision the user made or a result a machine
+ * produced. Those are kept whole and the cap falls on the wakes alone — the
+ * only kind that can be dropped and still be read.
+ */
+export function retainedPendingInputsV1(
+  inputs: readonly PendingBotInputV1[],
+): PendingBotInputV1[] {
+  if (inputs.length <= ROUTINE_PENDING_INPUT_LIMIT) return [...inputs];
+  const durable = inputs.filter((input) => input.kind !== "wake");
+  const budget = ROUTINE_PENDING_INPUT_LIMIT - durable.length;
+  if (budget <= 0) return durable;
+  const keptWakes = new Set(
+    inputs.filter((input) => input.kind === "wake").slice(-budget),
+  );
+  return inputs.filter(
+    (input) => input.kind !== "wake" || keptWakes.has(input),
+  );
+}
+
 export class RoutineInboxStore {
   readonly #storage: RoutineStorageV1;
   readonly #now: () => Date;
@@ -362,7 +392,7 @@ export class RoutineInboxStore {
       // active run, so no firing can settle while it runs and no wake can
       // arrive behind this read; an empty receipt would be a record of nothing.
       if (inputs.length === 0) return [];
-      const retained = inputs.slice(-ROUTINE_PENDING_INPUT_LIMIT);
+      const retained = retainedPendingInputsV1(inputs);
       await transaction.put(receiptKey, {
         schemaVersion: 1,
         runId,
@@ -374,15 +404,40 @@ export class RoutineInboxStore {
     });
   }
 
-  /** Trim the inbox to its retention bound, oldest first. */
+  /** Trim the inbox to its retention bound, acknowledged entries first. */
   async #trimInbox(): Promise<void> {
     const stored = await this.#storage.list<unknown>({
       prefix: ROUTINE_INBOX_PREFIX,
     });
-    const keys = [...stored.keys()].sort();
-    if (keys.length <= ROUTINE_INBOX_LIMIT) return;
-    for (const key of keys.slice(ROUTINE_INBOX_LIMIT)) {
+    // Inbox keys are descending, so ascending key order is newest first and
+    // the oldest entry is the last of them.
+    const entries = [...stored.entries()]
+      .sort(([left], [right]) => left.localeCompare(right))
+      .reverse();
+    let excess = entries.length - ROUTINE_INBOX_LIMIT;
+    if (excess <= 0) return;
+    // Read entries go first, oldest read before newest, and only then unread
+    // ones. Trimming purely by age used to drop a completion the reader had
+    // never seen while a dozen they had already acknowledged sat beside it —
+    // the inbox is the only place a firing ever speaks, so what has not been
+    // read is the last thing to lose.
+    const acknowledged: string[] = [];
+    const unread: string[] = [];
+    for (const [key, value] of entries) {
+      let read = false;
+      try {
+        read = decodeRoutineInboxEntryV1(value).acknowledged;
+      } catch {
+        // An entry nothing can decode says nothing to anyone; it is the first
+        // thing worth reclaiming space from.
+        read = true;
+      }
+      (read ? acknowledged : unread).push(key);
+    }
+    for (const key of [...acknowledged, ...unread]) {
+      if (excess <= 0) return;
       await this.#storage.delete(key);
+      excess -= 1;
     }
   }
 

package/src/inbox.test.ts

@@ -7,11 +7,16 @@ import {
   routineHandoffTextV1,
   subagentAttributionV1,
 } from "./inbox.js";
-import { RoutineInboxStore, routineTerminalRecordsV1 } from "./inbox-store.js";
+import {
+  retainedPendingInputsV1,
+  RoutineInboxStore,
+  routineTerminalRecordsV1,
+} from "./inbox-store.js";
 import { createMemoryRoutineStorageV1 } from "./testing.js";
 import {
   ROUTINE_INBOX_LIMIT,
   ROUTINE_INBOX_PREFIX,
+  ROUTINE_PENDING_INPUT_LIMIT,
   ROUTINE_WAKE_PREFIX,
 } from "./storage-keys.js";
 
@@ -435,3 +440,99 @@ describe("a Turn the User's next message replaced", () => {
     ).not.toContain("Subagents");
   });
 });
+
+describe("the pending-input cap", () => {
+  /**
+   * The four input kinds are not interchangeable. A dropped `wake` still has
+   * an inbox entry the user can read; an `approval`, a `machine-result` or a
+   * `superseded-turn` writes no entry anywhere, so dropping one loses a
+   * decision the user made or a result a machine produced, silently.
+   */
+  test("keeps every non-wake input and spends the budget on the wakes", async () => {
+    const store = storage();
+    const inbox = new RoutineInboxStore(store);
+    for (let index = 0; index < ROUTINE_PENDING_INPUT_LIMIT + 4; index += 1) {
+      await settle(store, { runId: `rf-${index}`, handoff: `wake ${index}` });
+    }
+    await inbox.enqueue({
+      schemaVersion: 1,
+      kind: "approval",
+      approvalId: "ap-1",
+      decision: "approved",
+      createdAt: NOW,
+    });
+    await inbox.enqueue({
+      schemaVersion: 1,
+      kind: "superseded-turn",
+      runId: "run-9",
+      unfinishedWork: true,
+      createdAt: NOW,
+    });
+
+    const drained = await inbox.drainInto("chat-run-1");
+    expect(drained).toHaveLength(ROUTINE_PENDING_INPUT_LIMIT);
+    // The approval decision and the superseded Turn survive; a flat
+    // `slice(-16)` used to drop whichever of them sat behind enough wakes.
+    expect(drained.filter((input) => input.kind === "approval")).toHaveLength(
+      1,
+    );
+    expect(
+      drained.filter((input) => input.kind === "superseded-turn"),
+    ).toHaveLength(1);
+    expect(drained.filter((input) => input.kind === "wake")).toHaveLength(
+      ROUTINE_PENDING_INPUT_LIMIT - 2,
+    );
+  });
+
+  test("keeps every durable input even when they alone exceed the bound", () => {
+    const approvals = Array.from(
+      { length: ROUTINE_PENDING_INPUT_LIMIT + 3 },
+      (_unused, index) =>
+        ({
+          schemaVersion: 1,
+          kind: "approval",
+          approvalId: `ap-${index}`,
+          decision: "approved",
+          createdAt: NOW,
+        }) as const,
+    );
+    // Over the bound is a problem worth having; losing an approval decision
+    // with nothing anywhere recording it is not.
+    expect(retainedPendingInputsV1(approvals)).toHaveLength(approvals.length);
+  });
+});
+
+describe("inbox retention", () => {
+  test("gives up read entries before unread ones", async () => {
+    const store = storage();
+    const inbox = new RoutineInboxStore(store);
+    for (let index = 0; index < ROUTINE_INBOX_LIMIT; index += 1) {
+      await settle(store, {
+        runId: `rf-${String(index).padStart(4, "0")}`,
+        responseText: `run ${index}`,
+      });
+    }
+    // The reader has caught up on everything so far.
+    await inbox.acknowledge([]);
+    // Five more land while they are away.
+    for (let index = 0; index < 5; index += 1) {
+      await settle(store, {
+        runId: `rf-new-${index}`,
+        responseText: `fresh ${index}`,
+      });
+    }
+
+    const entries = await inbox.list();
+    expect(entries).toHaveLength(ROUTINE_INBOX_LIMIT);
+    // Trimming purely by age used to drop whatever was oldest regardless of
+    // whether it had ever been read. Nothing unread is gone here.
+    const unread = entries.filter((entry) => !entry.acknowledged);
+    expect(unread.map((entry) => entry.text)).toEqual([
+      "fresh 4",
+      "fresh 3",
+      "fresh 2",
+      "fresh 1",
+      "fresh 0",
+    ]);
+  });
+});

package/src/inbox.ts

@@ -58,6 +58,42 @@ export function subagentAttributionV1(description: string): string {
 
 /** Longest hand-off an inbox entry or a pending wake carries. */
 export const ROUTINE_INBOX_TEXT_MAX = 4_000;
+
+/**
+ * What a person is told a firing failed for.
+ *
+ * A failure summary is whatever the kernel had to hand — the run's `failure`
+ * string, a thrown message, a lease timeout. Some of those are sentences a
+ * person can act on ("the model is unavailable"); others are invariants
+ * addressed to this codebase, like `tool occurrence "tool:1:1:1" was not
+ * settled before step end`, which told a User nothing except that something
+ * they cannot see is broken. The raw string stays on the run-log row, which is
+ * where an operator looks; what reaches the inbox and the notification is a
+ * sentence.
+ *
+ * The test is deliberately coarse: anything carrying the shape of an internal
+ * identifier — a quoted occurrence, a `foo:1:2:3` coordinate, a stack frame —
+ * is not for a person. Everything else is passed through, because a provider
+ * saying "rate limited" is exactly what the User wants to read.
+ */
+const INTERNAL_FAILURE_MARKERS = [
+  /\btool occurrence\b/i,
+  /\b[a-z-]+:\d+:\d+:\d+\b/i,
+  /\bat [\w$.]+ \(/,
+  /\bschemaVersion\b/,
+  /\boutcome model-error\b/i,
+  /\binvariant\b/i,
+];
+
+/** The sentence a person reads instead of a kernel string. Never empty. */
+export function routineFailureSentenceV1(summary: string | undefined): string {
+  const text = (summary ?? "").trim();
+  if (text.length === 0) return "It stopped without saying why.";
+  if (INTERNAL_FAILURE_MARKERS.some((marker) => marker.test(text))) {
+    return "Something inside FrockBot went wrong; the run log has the details.";
+  }
+  return text;
+}
 /** Longest title a pending wake carries. */
 export const ROUTINE_WAKE_TITLE_MAX = 200;
 
@@ -78,6 +114,23 @@ export interface RoutineInboxEntryV1 {
   /** Present when the Turn also handed off, naming the wake it queued. */
   wakeId?: string;
   acknowledgedAt?: string;
+  /**
+   * How many firings this entry stands for. Absent means one.
+   *
+   * A Routine that fails every minute wrote a fresh entry every minute, and a
+   * user who had not looked in an hour found sixty rows of the same sentence.
+   * Consecutive failures of the same Routine with the same failure fold into
+   * the entry already there and raise this count, so the inbox says what is
+   * wrong once and how often it has happened.
+   */
+  repeatCount?: number;
+  /**
+   * Set when the entry is a firing that did not work. A completion is routine
+   * and deliberately badges nothing; a failure is the Bot telling its User
+   * that an automation they set up has stopped, which is exactly what the
+   * sidebar badge is for.
+   */
+  failure?: true;
   /**
    * What produced this entry. Absent means `routine`; `routineId` then carries
    * the task id, because the field names the automation the entry came from
@@ -210,7 +263,7 @@ export function decodeRoutineInboxEntryV1(
       "createdAt",
       "acknowledged",
     ],
-    ["wakeId", "acknowledgedAt", "source"],
+    ["wakeId", "acknowledgedAt", "source", "repeatCount", "failure"],
     label,
   );
   if (candidate.schemaVersion !== 1) {
@@ -249,9 +302,25 @@ export function decodeRoutineInboxEntryV1(
     ...(candidate.source === undefined
       ? {}
       : { source: completionSourceV1(candidate.source, `${label} source`) }),
+    ...(candidate.repeatCount === undefined
+      ? {}
+      : {
+          repeatCount: routineRepeatCountV1(
+            candidate.repeatCount,
+            `${label} repeatCount`,
+          ),
+        }),
+    ...(candidate.failure === undefined ? {} : { failure: true as const }),
   };
 }
 
+function routineRepeatCountV1(value: unknown, label: string): number {
+  if (!Number.isSafeInteger(value) || (value as number) < 1) {
+    throw new RoutineDecodeError(`${label} is invalid`);
+  }
+  return value as number;
+}
+
 export function decodePendingBotInputV1(
   value: unknown,
   label = "pending Bot input",