@sigrun/sigrun 0.10.2 → 0.11.0

package/dist/server/conversation-watch.js

@@ -0,0 +1,49 @@
+/**
+ * The full-history conversation watch (pi-durable 1.5.0 Task 2, D1-A).
+ *
+ * D1-A: a conversation view's `entries` is the append-only, fork-aware RAW
+ * HISTORY keyed by entry id — never the model's context — and nothing in
+ * core cuts entries at a `pi.compaction`/`pi.reset` head marker. Upstream
+ * windows DEFAULT to sliding (`{min: 50, max: 100}`), which would drop the
+ * oldest entries once a conversation outgrows 100; pinning the window to
+ * {@link FULL_HISTORY_WINDOW} makes the watch never slide.
+ *
+ * One window for every server-side watch: the SSE view stream
+ * (`routes/stream.ts`), the host bridge's `conversations.watch`
+ * (`host-bridge.ts`), and one-shot reads (`helpers.ts` `readView`).
+ */
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+/**
+ * The never-sliding window: `min`/`max` at the upstream cap (`2 ** 31`
+ * validation ceiling), so the watch holds every entry the transcript ever
+ * gains and never drops its oldest.
+ */
+export const FULL_HISTORY_WINDOW = {
+    min: 2 ** 30,
+    max: 2 ** 31,
+};
+/**
+ * Watch a conversation's full history. The returned handle's `value` is the
+ * acquisition revision (every entry so far); later revisions keep the whole
+ * history because the window never slides.
+ */
+export function watchFullHistory(conversation, context) {
+    return conversation.watch(context, FULL_HISTORY_WINDOW);
+}
+/**
+ * Read one conversation's current full-history view; disposes the watch
+ * handle (the temporary Task-1 `readView` shape, now never-sliding).
+ */
+export async function readFullView(conversation, context) {
+    const watch = await watchFullHistory(conversation, context);
+    try {
+        return watch.value;
+    }
+    finally {
+        await watch.stop();
+    }
+}
+/** Convenience: the background-context read (helpers.ts `readView`). */
+export function readFullConversationView(conversation) {
+    return readFullView(conversation, BACKGROUND_CONTEXT);
+}

package/dist/server/helpers.js

@@ -4,6 +4,7 @@
  * the route modules consume.
  */
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { readFullConversationView } from "./conversation-watch.js";
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { isAbsolute, resolve } from "node:path";
@@ -232,12 +233,11 @@ export function conversationId(id) {
 export function submissionId(id) {
     return id;
 }
-/** Read one conversation's current view frame; disposes the state handle. */
+/** Read one conversation's current view frame; disposes the watch handle. */
 export async function readView(conversation) {
-    const state = await conversation.viewState(BACKGROUND_CONTEXT);
-    const view = serializeConversationView(state.value);
-    await state.dispose();
-    return view;
+    // Task 2 (D1-A): the full-history read — the window never slides, so
+    // `entries` is the raw append-only history, never cut at a head marker.
+    return serializeConversationView(await readFullConversationView(conversation));
 }
 /**
  * Stamp the resolved caller identity onto a fresh conversation's

package/dist/server/host-bridge.js

@@ -16,6 +16,7 @@
  * superuser's HTTP list does: every row visible, `access: "write"`.
  */
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { watchFullHistory } from "./conversation-watch.js";
 import { accessOf as accessOfShared } from "@sigrun/shared/access";
 import { completeOnce } from "../harness/complete.js";
 import { effectiveAdmin } from "../harness/identity/groups.js";
@@ -83,14 +84,16 @@ export function createHostBridge(ctx) {
                 // acquisition revision is the first listener call, then every
                 // watch revision after (pending frames flow because start
                 // never invokes the listener inline).
-                const watch = await conversation.watch(BACKGROUND_CONTEXT);
+                const watch = await watchFullHistory(conversation, BACKGROUND_CONTEXT);
                 listener(serializeConversationView(watch.value));
-                watch.start((value) => {
+                watch.start((call) => {
+                    if (call.kind !== "value")
+                        return Promise.resolve();
                     // An extension listener that throws (or returns a rejecting
                     // promise — async listeners) must not end the watch or the
                     // process — warn and keep delivering.
                     return Promise.resolve()
-                        .then(() => listener(serializeConversationView(value)))
+                        .then(() => listener(serializeConversationView(call.value)))
                         .catch((cause) => {
                         console.warn(`host bridge: watch listener failed: ${cause instanceof Error ? cause.message : String(cause)}`);
                     });

package/dist/server/routes/admin.js

@@ -18,15 +18,13 @@
  * graceful-shutdown + `process.exit(0)`) owns the exit — the route
  * never calls exit itself.
  *
- * D5 parked-task recovery (pi-durable 1.4.0, Task B6):
+ * D5 blocked-task visibility (pi-durable 1.5.0):
  * `GET /v1/admin/tasks?state=blocked` lists blocked tasks from
  * `harness.inspect()` (id, kind, reason, conversationId, owner from the
- * conversation's SessionMeta when present); `POST /v1/admin/tasks/:id/retry`
- * returns 404 unknown_task / 409 not_parked unless the task is blocked
- * with reason restart_limit, else calls `harness.retryTask(id)` → 204.
- * The inspect-first check is load-bearing: retryTask rejects an unknown
- * id but SILENTLY no-ops for a task that isn't parked. Both endpoints
- * are admin-only (403 forbidden).
+ * conversation's SessionMeta when present). Admin-only (403 forbidden).
+ * The LISTING stays; the retry route is gone — 1.5.0 removed
+ * task_parked/retryTask, and its replacement recovery surface is the
+ * job-level `POST /v1/jobs/:id/resume` (Task 4, D2).
  *
  * Durability (Review Focus 4): the restart rides the SAME ordered
  * shutdown as the SIGTERM path — the event bus drains pending settles
@@ -67,9 +65,8 @@ export function registerAdminRoutes(app, ctx) {
         });
         return await reply.code(202).send({ restarting: true });
     });
-    // D5 parked-task recovery. `GET /v1/admin/tasks?state=blocked` lists
-    // blocked tasks from `harness.inspect()`; `POST /v1/admin/tasks/:id/retry`
-    // re-runs a restart-parked task. Both admin-only (403 before any
+    // D5 blocked-task visibility. `GET /v1/admin/tasks?state=blocked` lists
+    // blocked tasks from `harness.inspect()` — admin-only (403 before any
     // inspection, so a non-admin learns nothing about the task graph).
     app.get("/v1/admin/tasks", async (request, reply) => {
         if (!request.principal.admin) {
@@ -126,30 +123,4 @@ export function registerAdminRoutes(app, ctx) {
         });
         return await reply.send({ tasks });
     });
-    app.post("/v1/admin/tasks/:id/retry", async (request, reply) => {
-        if (!request.principal.admin) {
-            return await reply.code(403).send({ error: "forbidden" });
-        }
-        const { id } = request.params;
-        const taskId = Number(id);
-        if (!Number.isInteger(taskId) || taskId < 0 || String(taskId) !== id) {
-            return await reply.code(404).send({ error: "unknown_task" });
-        }
-        // Check inspect() FIRST: pi-durable's retryTask rejects an unknown
-        // id but SILENTLY no-ops for a task that isn't parked — the 409
-        // must come from the inspection, not from retryTask.
-        const inspection = await ctx.opened.harness.inspect(BACKGROUND_CONTEXT);
-        const task = inspection.tasks.find((candidate) => String(candidate.record.id) === id);
-        if (task === undefined) {
-            return await reply.code(404).send({ error: "unknown_task" });
-        }
-        if (task.state.kind !== "blocked" || task.state.reason !== "restart_limit") {
-            return await reply.code(409).send({ error: "not_parked" });
-        }
-        // For a schedule task the job's status fields return to `waiting`
-        // on the task's next committed state (the task's own phases patch
-        // the record) — the route deliberately does NOT hand-patch the job.
-        await ctx.opened.harness.retryTask(task.record.id, BACKGROUND_CONTEXT);
-        return await reply.code(204).send();
-    });
 }

package/dist/server/routes/jobs.js

@@ -24,7 +24,7 @@
  */
 import { accessPrincipalOf } from "../auth/access-principal.js";
 import { jobAccess, resolveJob, } from "../jobs-access.js";
-import { JobDeclaredError, JobNotFoundError } from "../../jobs/index.js";
+import { JobDeclaredError, JobNotBlockedError, JobNotFoundError } from "../../jobs/index.js";
 import { validateJobSpec } from "../../jobs/spec.js";
 /**
  * The shared `:id` error mapping: unknown/hidden → 404 `job_not_found`;
@@ -45,6 +45,9 @@ async function domainError(reply, error) {
     if (error instanceof JobNotFoundError) {
         return await reply.code(404).send({ error: "job_not_found" });
     }
+    if (error instanceof JobNotBlockedError) {
+        return await reply.code(409).send({ error: "not_blocked" });
+    }
     throw error;
 }
 /** Register the `/v1/jobs` routes. */
@@ -229,6 +232,32 @@ export function registerJobRoutes(app, ctx) {
         }
         return await jobs.runNow(id);
     });
+    // POST /v1/jobs/:id/resume — restart-limit recovery (D2). EXACTLY
+    // the run route's access checks: unknown or hidden → 404
+    // job_not_found; read-only → 403 forbidden. A job that is not
+    // restart-limited → 409 not_blocked; a blocked/restart_limit job
+    // re-arms (state waiting, executor recreated) → 200 with the wire.
+    app.post("/v1/jobs/:id/resume", async (request, reply) => {
+        const { id } = request.params;
+        const wire = await jobs.get(id);
+        if (wire === undefined) {
+            return await deny(reply, "job_not_found");
+        }
+        const access = jobAccess(accessPrincipal(request), wire);
+        if (access === "none") {
+            return await deny(reply, "job_not_found");
+        }
+        if (access === "read") {
+            return await deny(reply, "forbidden");
+        }
+        try {
+            const resumed = await jobs.resume(id);
+            return { job: resumed };
+        }
+        catch (error) {
+            return await domainError(reply, error);
+        }
+    });
     // GET /v1/jobs/:id/runs?limit= — newest first; answers for retired
     // jobs (the revision-resolved access) until retention trims them.
     app.get("/v1/jobs/:id/runs", async (request, reply) => {

package/dist/server/routes/metrics.js

@@ -55,14 +55,14 @@
  * type is `text/plain; version=0.0.4; charset=utf-8`.
  */
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
-import { REPORT_TYPES } from "../../harness/reports.js";
+import { REPORT_KINDS } from "../../harness/reports.js";
 import { readBackupMarker } from "../../backup/marker.js";
 import { scanJobs } from "../../jobs/docs.js";
 import { providerAuthStatus } from "../helpers.js";
 import { checkStorage } from "../readiness.js";
 /** The exposition content type (spec §6.9's format rule). */
 const EXPOSITION_CONTENT_TYPE = "text/plain; version=0.0.4; charset=utf-8";
-const BLOCKED_REASONS = ["missing_task", "task_too_old", "migration_failed", "restart_limit"];
+const BLOCKED_REASONS = ["missing_task", "task_too_old", "migration_failed"];
 /** Escape one label value per the exposition format: `\` → `\\`,
  *  `"` → `\"`, newline → `\n`. */
 function escapeLabelValue(value) {
@@ -124,11 +124,12 @@ export function registerMetricsRoutes(app, ctx) {
             const oldestMs = opened.eventBus.oldestLiveAdmissionMs();
             family("sigrun_inflight_submission_oldest_seconds", "Age of the oldest in-flight submission's admission (0 when none; in-process clock — a pre-restart run is invisible until it settles)", [{ labels: {}, value: Math.round((oldestMs ?? 0) / 1000) }]);
             // Live tasks by scheduler state kind. The full six-kind
-            // vocabulary is emitted (0s included) for label stability
-            // (1.4.0 adds `sleeping` — the durable-sleep state).
+            // vocabulary is emitted (0s included) for label stability.
+            // pi-durable 1.5.0 renamed `ready` to `pending` (the queued,
+            // runnable-but-not-yet-admitted state).
             const taskStatuses = {
                 running: 0,
-                ready: 0,
+                pending: 0,
                 waiting: 0,
                 sleeping: 0,
                 completing: 0,
@@ -171,6 +172,26 @@ export function registerMetricsRoutes(app, ctx) {
                         value: epochSeconds(record.nextRun),
                     },
                 ]));
+            // D2: the job-record blocked gauge. pi-durable 1.5.0 has no
+            // task park state — a restart-limited schedule task ends
+            // faulted and its JOB record carries blocked/restart_limit —
+            // so the alertable signal lives on the job records. Emitted
+            // for restart_limit plus zero-valued label stability; other
+            // blocked reasons (fire-time blocks) ride the same gauge when
+            // they occur.
+            const jobBlockedReasons = {
+                restart_limit: 0,
+            };
+            for (const { record } of jobRecords) {
+                if (record.state !== "blocked")
+                    continue;
+                const reason = record.reason ?? "unknown";
+                jobBlockedReasons[reason] = (jobBlockedReasons[reason] ?? 0) + 1;
+            }
+            family("sigrun_jobs_blocked", "Jobs blocked by record reason", Object.entries(jobBlockedReasons).map(([reason, count]) => ({
+                labels: { reason },
+                value: count,
+            })));
         }
         catch (error) {
             up = 0;
@@ -185,10 +206,13 @@ export function registerMetricsRoutes(app, ctx) {
         // failure even while inspection (and the whole scrape) stays green.
         const storage = await checkStorage(ctx);
         family("sigrun_ready", "1 when the readiness storage check (the /readyz root-conversation read) succeeds", [{ labels: {}, value: storage === "ok" ? 1 : 0 }]);
-        // D5: process-local durable failure reports. Every known type is
+        // D5: process-local durable failure reports. Every known kind is
         // emitted, including zeros, for scrape-stable alert expressions.
+        // pi-durable 1.5.0 kinds: `task_parked`/`session_failed` are gone;
+        // `storage_failed`/`task_interrupted` replaced them (label name
+        // `type` kept — a metrics-label rename would break alert queries).
         const reportCounts = opened.reports.counts();
-        family("sigrun_durable_reports_total", "Durable failure reports since process start", REPORT_TYPES.map((type) => ({ labels: { type }, value: reportCounts[type] })), "counter");
+        family("sigrun_durable_reports_total", "Durable failure reports since process start", REPORT_KINDS.map((kind) => ({ labels: { type: kind }, value: reportCounts[kind] })), "counter");
         // Provider readiness: the shared derivation (`GET /v1/auth/check`'s
         // exact chain), one 1-valued sample per (provider, current status).
         const producersByName = new Map(opened.providerHealth.map((producer) => [producer.name, producer]));

package/dist/server/routes/stream.js

@@ -11,6 +11,7 @@ import { loadConversation } from "../conversation-handler.js";
 import { ID_PARAMS_SCHEMA } from "../helpers.js";
 import { serializeConversationView, } from "../views.js";
 import { diffViews, isEmptyDelta, } from "@sigrun/shared/view-delta";
+import { watchFullHistory } from "../conversation-watch.js";
 /** Register the SSE view stream route. */
 export function registerStreamRoutes(app, ctx) {
     // SSE view stream (spec §5 "Views + watch frames over SSE", §7.3 ruling
@@ -35,7 +36,7 @@ export function registerStreamRoutes(app, ctx) {
         // error event. `value` is the acquisition revision (the snapshot
         // source); frames published between here and start() are held by the
         // watch's bounded pending delivery, so nothing is lost.
-        const watch = await conversation.watch(BACKGROUND_CONTEXT);
+        const watch = await watchFullHistory(conversation, BACKGROUND_CONTEXT);
         // Watcher bookkeeping (W5 Task 6, spec §9.6): one attached client.
         // The exactly-once `finish` below decrements — the notifications
         // surface's `"unwatched"` runSettled rule reads this count.
@@ -115,10 +116,12 @@ export function registerStreamRoutes(app, ctx) {
         // view the diff loop measures against.
         let prev = serializeConversationView(watch.value);
         send("snapshot", prev);
-        watch.start(async (value) => {
+        watch.start(async (call) => {
             if (finished)
                 return; // the stream is over; drop the frame
-            const next = serializeConversationView(value);
+            if (call.kind !== "value")
+                return;
+            const next = serializeConversationView(call.value);
             const delta = diffViews(prev, next);
             prev = next;
             // Not representable as entries append/remove + changed docs (a

package/dist/server/schema-fixture.js

@@ -223,6 +223,9 @@ export const VIEW_SCHEMA = {
                                         },
                                         "timestamp": {
                                             "kind": "number"
+                                        },
+                                        "thinkingLevel": {
+                                            "kind": "string"
                                         }
                                     }
                                 }
@@ -292,14 +295,6 @@ export const VIEW_SCHEMA = {
                                                                 "type": {
                                                                     "kind": "string"
                                                                 },
-                                                                "required": {
-                                                                    "kind": "array",
-                                                                    "variants": [
-                                                                        {
-                                                                            "kind": "string"
-                                                                        }
-                                                                    ]
-                                                                },
                                                                 "properties": {
                                                                     "kind": "object",
                                                                     "fields": {
@@ -315,6 +310,14 @@ export const VIEW_SCHEMA = {
                                                                             }
                                                                         }
                                                                     }
+                                                                },
+                                                                "required": {
+                                                                    "kind": "array",
+                                                                    "variants": [
+                                                                        {
+                                                                            "kind": "string"
+                                                                        }
+                                                                    ]
                                                                 }
                                                             }
                                                         },
@@ -519,14 +522,6 @@ export const VIEW_SCHEMA = {
                                                                 "type": {
                                                                     "kind": "string"
                                                                 },
-                                                                "required": {
-                                                                    "kind": "array",
-                                                                    "variants": [
-                                                                        {
-                                                                            "kind": "string"
-                                                                        }
-                                                                    ]
-                                                                },
                                                                 "properties": {
                                                                     "kind": "object",
                                                                     "fields": {
@@ -553,6 +548,14 @@ export const VIEW_SCHEMA = {
                                                                             }
                                                                         }
                                                                     }
+                                                                },
+                                                                "required": {
+                                                                    "kind": "array",
+                                                                    "variants": [
+                                                                        {
+                                                                            "kind": "string"
+                                                                        }
+                                                                    ]
                                                                 }
                                                             }
                                                         }
@@ -573,14 +576,6 @@ export const VIEW_SCHEMA = {
                                                                 "type": {
                                                                     "kind": "string"
                                                                 },
-                                                                "required": {
-                                                                    "kind": "array",
-                                                                    "variants": [
-                                                                        {
-                                                                            "kind": "string"
-                                                                        }
-                                                                    ]
-                                                                },
                                                                 "properties": {
                                                                     "kind": "object",
                                                                     "fields": {
@@ -607,6 +602,14 @@ export const VIEW_SCHEMA = {
                                                                             }
                                                                         }
                                                                     }
+                                                                },
+                                                                "required": {
+                                                                    "kind": "array",
+                                                                    "variants": [
+                                                                        {
+                                                                            "kind": "string"
+                                                                        }
+                                                                    ]
                                                                 }
                                                             }
                                                         }
@@ -686,14 +689,6 @@ export const VIEW_SCHEMA = {
                                                                 "type": {
                                                                     "kind": "string"
                                                                 },
-                                                                "required": {
-                                                                    "kind": "array",
-                                                                    "variants": [
-                                                                        {
-                                                                            "kind": "string"
-                                                                        }
-                                                                    ]
-                                                                },
                                                                 "properties": {
                                                                     "kind": "object",
                                                                     "fields": {
@@ -720,14 +715,6 @@ export const VIEW_SCHEMA = {
                                                                                         "type": {
                                                                                             "kind": "string"
                                                                                         },
-                                                                                        "required": {
-                                                                                            "kind": "array",
-                                                                                            "variants": [
-                                                                                                {
-                                                                                                    "kind": "string"
-                                                                                                }
-                                                                                            ]
-                                                                                        },
                                                                                         "properties": {
                                                                                             "kind": "object",
                                                                                             "fields": {
@@ -754,6 +741,14 @@ export const VIEW_SCHEMA = {
                                                                                                     }
                                                                                                 }
                                                                                             }
+                                                                                        },
+                                                                                        "required": {
+                                                                                            "kind": "array",
+                                                                                            "variants": [
+                                                                                                {
+                                                                                                    "kind": "string"
+                                                                                                }
+                                                                                            ]
                                                                                         }
                                                                                     }
                                                                                 },
@@ -763,6 +758,14 @@ export const VIEW_SCHEMA = {
                                                                             }
                                                                         }
                                                                     }
+                                                                },
+                                                                "required": {
+                                                                    "kind": "array",
+                                                                    "variants": [
+                                                                        {
+                                                                            "kind": "string"
+                                                                        }
+                                                                    ]
                                                                 }
                                                             }
                                                         }
@@ -914,14 +917,6 @@ export const VIEW_SCHEMA = {
                                                                 "type": {
                                                                     "kind": "string"
                                                                 },
-                                                                "required": {
-                                                                    "kind": "array",
-                                                                    "variants": [
-                                                                        {
-                                                                            "kind": "string"
-                                                                        }
-                                                                    ]
-                                                                },
                                                                 "properties": {
                                                                     "kind": "object",
                                                                     "fields": {
@@ -959,6 +954,14 @@ export const VIEW_SCHEMA = {
                                                                             }
                                                                         }
                                                                     }
+                                                                },
+                                                                "required": {
+                                                                    "kind": "array",
+                                                                    "variants": [
+                                                                        {
+                                                                            "kind": "string"
+                                                                        }
+                                                                    ]
                                                                 }
                                                             }
                                                         }
@@ -979,14 +982,6 @@ export const VIEW_SCHEMA = {
                                                                 "type": {
                                                                     "kind": "string"
                                                                 },
-                                                                "required": {
-                                                                    "kind": "array",
-                                                                    "variants": [
-                                                                        {
-                                                                            "kind": "string"
-                                                                        }
-                                                                    ]
-                                                                },
                                                                 "properties": {
                                                                     "kind": "object",
                                                                     "fields": {
@@ -1013,6 +1008,14 @@ export const VIEW_SCHEMA = {
                                                                             }
                                                                         }
                                                                     }
+                                                                },
+                                                                "required": {
+                                                                    "kind": "array",
+                                                                    "variants": [
+                                                                        {
+                                                                            "kind": "string"
+                                                                        }
+                                                                    ]
                                                                 }
                                                             }
                                                         }

package/dist/skills/index.js

@@ -60,7 +60,7 @@
  * (the reserved-section owner is unchanged) and never goes through the
  * extension loader.
  */
-import { Type } from "@earendil-works/pi-ai";
+import { Type } from "typebox";
 import { defineExtension, defineTool, section, } from "@earendil-works/pi-durable";
 import { readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";

package/node_modules/@sigrun/shared/CHANGELOG.md

@@ -6,6 +6,10 @@ 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.11.0] - 2026-11-07
+
+- Version-locked bump with the 0.11.0 core line (the pi-durable 1.5.0 release).
+
 ## [0.10.2] - 2026-11-06
 
 - Version-locked bump with the 0.10.2 core line (no changes).

package/node_modules/@sigrun/shared/dist/live.d.ts

@@ -42,6 +42,17 @@ export interface LiveDocWire {
     readonly compactionFailure?: {
         readonly error?: unknown;
     };
+    /**
+     * Why the newest run ended without an answer (pi-durable 1.5.0
+     * `LiveState.runFailure`): set in the commit that ends the run,
+     * removed when a later commit starts one. The clients narrow it to
+     * `{reason, detail?}` — taskId/inputs/first are the harness's
+     * bookkeeping, not display data.
+     */
+    readonly runFailure?: {
+        readonly reason?: unknown;
+        readonly detail?: unknown;
+    };
 }
 /**
  * The view's `pi.live` doc, or undefined when absent (idle and never-run
@@ -69,3 +80,17 @@ export declare function liveGenerationText(view: ConversationViewBase): string;
 export declare function liveCompactions(view: ConversationViewBase): number;
 /** The newest compaction failure's error text, when one is surfaced. */
 export declare function liveCompactionFailure(view: ConversationViewBase): string | undefined;
+/**
+ * The newest run's failure (`pi.live.runFailure`, pi-durable 1.5.0), as
+ * the clients display it: `{reason, detail?}`, or undefined when no
+ * failure is recorded, when `run` is present (a newer run started — the
+ * recorded failure is stale), when the reason is user-caused
+ * (`aborted`/`reset` — the user watched themselves do it), or when the
+ * doc shape drifted (fail soft to absent, like
+ * {@link liveCompactionFailure}). A non-string detail is dropped, never
+ * surfaced.
+ */
+export declare function liveRunFailure(view: ConversationViewBase): {
+    readonly reason: string;
+    readonly detail?: string;
+} | undefined;

package/node_modules/@sigrun/shared/dist/live.js

@@ -80,3 +80,33 @@ export function liveCompactionFailure(view) {
     const error = failure.error;
     return typeof error === "string" && error !== "" ? error : undefined;
 }
+/** The run-failure reasons the USER caused — hidden by design. */
+const USER_CAUSED_RUN_FAILURES = new Set(["aborted", "reset"]);
+/**
+ * The newest run's failure (`pi.live.runFailure`, pi-durable 1.5.0), as
+ * the clients display it: `{reason, detail?}`, or undefined when no
+ * failure is recorded, when `run` is present (a newer run started — the
+ * recorded failure is stale), when the reason is user-caused
+ * (`aborted`/`reset` — the user watched themselves do it), or when the
+ * doc shape drifted (fail soft to absent, like
+ * {@link liveCompactionFailure}). A non-string detail is dropped, never
+ * surfaced.
+ */
+export function liveRunFailure(view) {
+    const doc = liveDoc(view);
+    if (doc === undefined || doc.run !== undefined)
+        return undefined;
+    const failure = doc.runFailure;
+    if (typeof failure !== "object" || failure === null)
+        return undefined;
+    const reason = failure.reason;
+    if (typeof reason !== "string" || reason === "")
+        return undefined;
+    if (USER_CAUSED_RUN_FAILURES.has(reason))
+        return undefined;
+    const detail = failure.detail;
+    if (typeof detail === "string" && detail !== "") {
+        return { reason, detail };
+    }
+    return { reason };
+}