@sigrun/escalations 0.0.0-stage.1 → 0.1.1

package/CHANGELOG.md

@@ -5,6 +5,29 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.1] - 2026-11-03
+### Fixed
+- `reopenReason` is cleared on forward transitions (`resolve` done,
+  `dismiss`, `restore`) so a stale reopen badge no longer survives onto
+  resolved or dismissed items.
+- The seeded run text renders a deleted job's source as its bare id
+  (`job "api:1"`) instead of the redundant `job "api:1" (api:1)`.
+- Bulk inbox toasts pluralize (`Dismissed 2 escalations`, not the
+  invented `escalation(s)` form).
+- The findVisible-then-update race in inbox actions throws a typed
+  `TransitionError` (`not_found`) and renders the same not-found body as
+  an unknown id.
+- The 15-minute sweep dedupes `jobs.get` lookups across buckets, stops
+  cooperatively between buckets when the task's abort signal fires, and
+  signals `changedInbox` for migrated items.
+- `transferItems` no-ops on a same-bucket call and returns the moved
+  ids.
+- `userDeleted` transfer history is stamped with the injected clock.
+
+### Changed
+- The factory accepts an optional `{ now }` clock for tests (arity one
+  is preserved for the loader).
+
 ## [Unreleased]
 ### Added
 - The escalation extension factory with `escalate`, `escalation_list`, and

package/dist/dispatch.js

@@ -8,8 +8,11 @@ function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
 function sourceText(e, jobName) {
-    if (e.source.jobId !== undefined)
-        return `job "${jobName ?? e.source.jobId}" (${e.source.jobId})`;
+    if (e.source.jobId !== undefined) {
+        return jobName === undefined
+            ? `job "${e.source.jobId}"`
+            : `job "${jobName}" (${e.source.jobId})`;
+    }
     if (e.source.conversationId !== undefined)
         return `conversation #${e.source.conversationId}`;
     return "none";

package/dist/inbox.js

@@ -398,7 +398,7 @@ export function createInboxView(deps) {
             const next = items.map((item) => (item.id === id ? apply(item) : item));
             const updated = next.find((item) => item.id === id);
             if (updated === undefined)
-                throw new Error("Escalation not found");
+                throw new TransitionError("not_found");
             return { items: next, result: updated };
         });
     }
@@ -420,6 +420,11 @@ export function createInboxView(deps) {
             };
         }
         catch (error) {
+            // The item vanished between findVisible and the update: the same
+            // not-found body as an unknown id, never a raw error.
+            if (error instanceof TransitionError && error.code === "not_found") {
+                return notFound();
+            }
             return failure(error);
         }
     }
@@ -440,7 +445,7 @@ export function createInboxView(deps) {
                 // An invalid id or an inapplicable status skips that item.
             }
         }
-        return { ok: true, toast: `${label} ${count} escalation(s)` };
+        return { ok: true, toast: `${label} ${count} escalation${count === 1 ? "" : "s"}` };
     }
     return {
         id: "inbox",

package/dist/index.d.ts

@@ -1,6 +1,10 @@
 import type { SigrunExtensionResult, SigrunHost } from "@sigrun/sigrun/extension";
+export interface EscalationsOptions {
+    /** Injectable clock for tests; every timestamp the extension stamps. */
+    readonly now?: () => Date;
+}
 /**
  * Build the complete escalation surface over one shared durable store.
  * The required host parameter keeps the factory at arity one for the loader.
  */
-export default function createEscalations(host: SigrunHost): SigrunExtensionResult;
+export default function createEscalations(host: SigrunHost, options?: EscalationsOptions): SigrunExtensionResult;

package/dist/index.js

@@ -10,9 +10,9 @@ import { createTools } from "./tools.js";
  * Build the complete escalation surface over one shared durable store.
  * The required host parameter keeps the factory at arity one for the loader.
  */
-export default function createEscalations(host) {
+export default function createEscalations(host, options = {}) {
     const store = new EscalationStore(host);
-    const deps = { host, store };
+    const deps = { host, store, now: options.now };
     return {
         extension: defineExtension({
             name: "escalations",
@@ -30,7 +30,7 @@ export default function createEscalations(host) {
             // (src/server/routes/users.ts:303-305): host.stores.user(u) throws for
             // unknown users, so both bucket paths must be available here.
             const sourceItems = await store.list(source);
-            await transferItems(store, source, target, new Set(sourceItems.map((item) => item.id)), new Date());
+            await transferItems(store, source, target, new Set(sourceItems.map((item) => item.id)), deps.now?.() ?? new Date());
         },
     };
 }

package/dist/lifecycle.js

@@ -71,7 +71,9 @@ export function resolve(e, conversationId, outcome, note, now) {
         throw new TransitionError("wrong_claimant");
     }
     if (outcome === "done") {
-        return changed(e, now, { event: "resolved", note }, { status: "resolved", resolvedAt: now.toISOString() });
+        // Forward transition: the stale reopen badge must not survive onto
+        // the terminal resolved state (inbox.ts renders it as a warn badge).
+        return changed(e, now, { event: "resolved", note }, { status: "resolved", resolvedAt: now.toISOString(), reopenReason: undefined });
     }
     return changed(e, now, {
         event: "failed",
@@ -113,12 +115,12 @@ export function dismiss(e, now) {
     if (e.status !== "open" && e.status !== "answered") {
         throw new TransitionError("not_dismissable");
     }
-    return changed(e, now, { event: "dismissed" }, { status: "dismissed", answer: undefined });
+    return changed(e, now, { event: "dismissed" }, { status: "dismissed", answer: undefined, reopenReason: undefined });
 }
 export function restore(e, now) {
     if (e.status !== "dismissed")
         throw new TransitionError("not_dismissed");
-    return changed(e, now, { event: "restored" }, { status: "open" });
+    return changed(e, now, { event: "restored" }, { status: "open", reopenReason: undefined });
 }
 export function snooze(e, days, now) {
     if (!Number.isInteger(days) || days < 1 || days > 365) {

package/dist/store.js

@@ -41,6 +41,10 @@ export async function bucketFor(host, owner) {
     if (owner !== undefined && (await host.users.get(owner)) !== undefined) {
         return { kind: "user", user: owner };
     }
+    // The primary-admin fallback. Core guarantees a non-empty directory
+    // holds at least one admin (last_admin 409 guards on both demote and
+    // delete, src/server/routes/users.ts); the shared bucket is reached
+    // only by the empty directory, where list() is empty.
     const primaryAdmin = (await host.users.list()).find((user) => user.admin);
     return primaryAdmin === undefined
         ? { kind: "shared" }

package/dist/sweep.d.ts

@@ -34,11 +34,15 @@ export interface SweepReport {
     claimsExpired: number;
     pruned: number;
     errors: string[];
+    /** Buckets skipped after the abort signal fired. */
+    stops?: number;
 }
 export interface SweepDeps {
     readonly host: SigrunHost;
     readonly store: EscalationStore;
     readonly now?: () => Date;
+    /** Cooperative cancellation, checked between buckets (the task phase passes the invocation's runtime.signal). */
+    readonly signal?: AbortSignal;
 }
 /** The sweep body, shared by the task phase and directly unit-testable. */
 export declare function runSweep(deps: SweepDeps): Promise<SweepReport>;

package/dist/sweep.js

@@ -37,26 +37,38 @@ function jobIdOf(e) {
         : undefined;
 }
 /** Read-only planning pass: which jobs exist. Never holds the bucket queue. */
-async function planSweep(deps, bucket) {
+async function planSweep(deps, bucket, cache) {
     const items = await deps.store.list(bucket);
     const jobs = new Map();
     for (const item of items) {
         const jobId = jobIdOf(item);
         if (jobId === undefined || jobs.has(jobId))
             continue;
-        jobs.set(jobId, await deps.host.jobs.get(jobId));
+        // The cache is sweep-wide: a job that spans two buckets is looked
+        // up once, since host.jobs.get is idempotent.
+        const cached = cache.get(jobId);
+        if (cached !== undefined || cache.has(jobId)) {
+            jobs.set(jobId, cached);
+            continue;
+        }
+        const job = await deps.host.jobs.get(jobId);
+        cache.set(jobId, job);
+        jobs.set(jobId, job);
     }
     return { items, jobs };
 }
 /** Reconcile job-owned items into the buckets of their jobs' current owners. */
 async function migrateTransferredJobs(deps, bucket, plan, now) {
     const owner = bucket.kind === "user" ? bucket.user : undefined;
+    const moved = [];
     for (const [jobId, job] of plan.jobs) {
         if (job === undefined || job.owner === owner)
             continue;
         const ids = new Set(plan.items.filter((item) => jobIdOf(item) === jobId).map((item) => item.id));
-        await transferItems(deps.store, bucket, await bucketFor(deps.host, job.owner), ids, now);
+        const transferred = await transferItems(deps.store, bucket, await bucketFor(deps.host, job.owner), ids, now);
+        moved.push(...transferred);
     }
+    return moved;
 }
 /** One atomic lifecycle update per source bucket: the four phases in order. */
 async function sweepBucket(deps, bucket, plan, now) {
@@ -114,10 +126,18 @@ export async function runSweep(deps) {
         pruned: 0,
         errors: [],
     };
+    const jobs = new Map();
     for (const bucket of await allBuckets(deps.host)) {
+        if (deps.signal?.aborted === true) {
+            // Cooperative stop: the harness is closing or the task was
+            // aborted; the next 15-minute tick sweeps the rest. `stops`
+            // is set only on a real stop, keeping the base report shape.
+            report.stops = (report.stops ?? 0) + 1;
+            continue;
+        }
         try {
-            const plan = await planSweep(deps, bucket);
-            await migrateTransferredJobs(deps, bucket, plan, now);
+            const plan = await planSweep(deps, bucket, jobs);
+            const moved = await migrateTransferredJobs(deps, bucket, plan, now);
             const outcome = await sweepBucket(deps, bucket, plan, now);
             report.snoozesEnded += outcome.report.snoozesEnded;
             report.orphaned += outcome.report.orphaned;
@@ -132,6 +152,10 @@ export async function runSweep(deps) {
                 await notifyOrphaned(deps.host, item);
                 changedInbox(deps.host, item.id);
             }
+            // Migrated items changed bucket contents like a deletion does;
+            // wake the inbox instances so the moved items render at once.
+            for (const id of moved)
+                changedInbox(deps.host, id);
         }
         catch (error) {
             const path = deps.store.fileOf(bucket);
@@ -150,7 +174,7 @@ export function createSweepTask(deps) {
         initial: () => ({ phase: "sweep" }),
         phases: {
             sweep: async (_task, runtime, context) => {
-                await runSweep(deps);
+                await runSweep({ ...deps, signal: runtime.signal });
                 // REQUIRED: a phase returning without durable progress faults the
                 // task. The sweep's bookkeeping lives in the store files; the
                 // task's own terminal outcome is the durable progress.

package/dist/tools.js

@@ -228,6 +228,9 @@ export function createTools(deps) {
                     next[index] = resolved;
                     return { items: next, result: resolved };
                 });
+                // The model reads these texts; keep them pinned in sync with
+                // the exact seedText expectation in dispatch.test.ts, which
+                // names escalation_resolve as the resolution path.
                 if (args.outcome === "failed")
                     await notifyReopened(deps.host, item);
                 changedInbox(deps.host, item.id);

package/dist/transfer.d.ts

@@ -5,4 +5,4 @@ import type { Bucket } from "./types.js";
  * A crash between the updates leaves duplicates; the id check makes retrying
  * the copy idempotent, so a later delivery can finish without losing items.
  */
-export declare function transferItems(store: EscalationStore, source: Bucket, target: Bucket, ids: ReadonlySet<string>, now: Date): Promise<void>;
+export declare function transferItems(store: EscalationStore, source: Bucket, target: Bucket, ids: ReadonlySet<string>, now: Date): Promise<readonly string[]>;

package/dist/transfer.js

@@ -4,11 +4,18 @@
  * the copy idempotent, so a later delivery can finish without losing items.
  */
 export async function transferItems(store, source, target, ids, now) {
+    // Same-bucket transfer is a no-op; unreachable through bucketFor (a
+    // job's owner resolves to its own bucket), but the guard keeps the
+    // copy-then-remove shape honest for direct callers.
+    if ((source.kind === "shared" && target.kind === "shared") ||
+        (source.kind === "user" && target.kind === "user" && source.user === target.user)) {
+        return [];
+    }
     if (ids.size === 0)
-        return;
+        return [];
     const sourceItems = (await store.list(source)).filter((item) => ids.has(item.id));
     if (sourceItems.length === 0)
-        return;
+        return [];
     const sourceOwner = source.kind === "user" ? source.user : "shared";
     const targetOwner = target.kind === "user" ? target.user : undefined;
     const idsInTarget = await store.update(target, (targetItems) => {
@@ -38,4 +45,5 @@ export async function transferItems(store, source, target, ids, now) {
         items: items.filter((item) => !idsInTarget.has(item.id)),
         result: undefined,
     }));
+    return [...idsInTarget].filter((id) => ids.has(id));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sigrun/escalations",
-	"version": "0.0.0-stage.1",
+	"version": "0.1.1",
 	"description": "Escalation inbox extension for sigrun: async decisions for jobs and agents",
 	"type": "module",
 	"engines": {