humanish 0.110.0 → 0.110.1

package/dist/observer/render.js

@@ -11,7 +11,8 @@ import { projectShareCheckedAnalysis } from "../analysis/sharing.js";
 import { loadAnalysis } from "../analysis/load.js";
 import { physicalCwdOf, runIdOf, bindExistingRunArtifactPaths, isSafeRunIdSegment, resolveLatestRunDirectory, validatePreparedRunArtifactPaths, } from "../run/paths.js";
 import { writeContainedOutputFile } from "../run/contained-output.js";
-import { loadRunBundlePrepared } from "../run/locate.js";
+import { loadRunBundlePrepared, readRunJsonIfExists } from "../run/locate.js";
+import { RUN_STATUS_FILE } from "../run/status.js";
 import { verifyRunPrepared } from "../verify/verify.js";
 import { renderObserverHtml } from "./artifact.js";
 import { buildObserverData } from "./data.js";
@@ -99,7 +100,12 @@ export async function renderObserver(cwdInput, runInput, options = {}) {
         ...projectShareCheckedAnalysis(await loadAnalysis(preparedRunPaths)),
         ...(spend === null ? {} : { spend }),
     };
-    const observerData = buildObserverData(loaded.bundle);
+    // A run.json without an outcome is in progress, interrupted, or older than the field: its
+    // status.json says which, and holds an older run's ok.
+    const statusRecord = loaded.bundle.outcome === undefined
+        ? await readRunJsonIfExists(preparedRunPaths, RUN_STATUS_FILE)
+        : undefined;
+    const observerData = buildObserverData(loaded.bundle, undefined, statusRecord);
     observerData.publicSafety.share = {
         status: verified.shareSafety.status,
         verifiedAt: new Date().toISOString(),

package/dist/observer/run-routes.d.ts

@@ -1,4 +1,5 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
+import type { RunDisplay } from "../run/display.js";
 import { type ObserverData } from "./data.js";
 import { type PinnedDirectory } from "./pinned-files.js";
 export interface ObserverRuntimeStreamUrl {
@@ -22,6 +23,7 @@ export declare function buildHistoryIndex(proofRoot: PinnedDirectory, admitRun?:
         mode: string | null;
         href: string;
         status: string;
+        display?: RunDisplay;
         runtimeState?: NonNullable<ObserverData["runtime"]>["state"];
         streamCount: number;
         estimatedCostUsd: number | null;

package/dist/observer/run-routes.js

@@ -8,7 +8,7 @@ import { listRuns } from "../run/stored-runs.js";
 import { readAnalysisAccounting } from "../run/costs.js";
 import { bindExistingRunArtifactPaths, isPathInside, isSafeRunIdSegment, } from "../run/paths.js";
 import { analysisCostOf, runCost, runCostLabel } from "../run/run-cost.js";
-import { RUN_STATUS_FILE, RUN_STATUS_STALE_MS, isRunStatusRecord } from "../run/status.js";
+import { RUN_STATUS_FILE, RUN_STATUS_STALE_MS, isRunStatusRecord, } from "../run/status.js";
 import { renderObserverHtml } from "./artifact.js";
 import { buildObserverData, recordedStreamEmbed, withObserverEndings, } from "./data.js";
 import { buildArtifactSecurityHeaders } from "./http.js";
@@ -120,6 +120,7 @@ export async function serveRunPath(runRoot, relativePath, response, runtimeStrea
     }
 }
 async function readObserverData(runRoot, runtimeStreamUrls = []) {
+    const record = await readLocalRunStatus(runRoot);
     // Best-effort load from either source. Both reads swallow all errors on
     // purpose: this runs on every browser poll of a live run, where run.json may
     // be absent, still being written (a partial-JSON parse error), or superseded
@@ -130,57 +131,64 @@ async function readObserverData(runRoot, runtimeStreamUrls = []) {
         if (!bundleBytes)
             throw new Error("run.json unavailable");
         const bundle = JSON.parse(bundleBytes.toString("utf8"));
-        return withRuntimeStreamUrls(await withLocalRunStatus(runRoot, buildObserverData(bundle)), runtimeStreamUrls);
+        return withRuntimeStreamUrls(withLocalRunStatus(record, buildObserverData(bundle, undefined, record)), runtimeStreamUrls);
     }
     catch { }
     try {
         const observerBytes = await readContainedFile(runRoot, path.join(runRoot.physicalPath, "observer", "observer-data.json"));
         if (!observerBytes)
             throw new Error("observer-data.json unavailable");
-        return withRuntimeStreamUrls(await withLocalRunStatus(runRoot, withObserverEndings(JSON.parse(observerBytes.toString("utf8")))), runtimeStreamUrls);
+        return withRuntimeStreamUrls(withLocalRunStatus(record, withObserverEndings(JSON.parse(observerBytes.toString("utf8")))), runtimeStreamUrls);
     }
     catch { }
     return null;
 }
-/**
- * Liveness is a current read of a contained local status record, separate from run evidence.
- * A stale heartbeat means unknown: neither an old timestamp nor a persisted PID proves that a
- * process died (the evidence may have been copied from another machine). No PID is served/probed.
- */
-async function withLocalRunStatus(runRoot, input) {
-    // A served observation must never be inherited from a persisted projection or export.
-    const { runtime: _persistedRuntime, ...data } = input;
+/** The run directory's own status record, when it is well formed and names that directory. */
+async function readLocalRunStatus(runRoot) {
     try {
         const bytes = await readContainedFile(runRoot, path.join(runRoot.physicalPath, RUN_STATUS_FILE));
         if (!bytes)
-            return data;
+            return undefined;
         const record = JSON.parse(bytes.toString("utf8"));
-        if (!isRunStatusRecord(record) ||
-            record.runId !== data.run.runId ||
-            record.mode !== data.run.mode ||
-            record.runId !== path.basename(runRoot.physicalPath))
-            return data;
-        const now = Date.now();
-        const started = Date.parse(record.startedAt);
-        const updated = Date.parse(record.updatedAt);
-        const timestampsValid = Number.isFinite(started) && Number.isFinite(updated) && started <= updated && updated <= now;
-        let state = "unknown";
-        if (timestampsValid) {
-            if (record.state === "finished") {
-                state = "finished";
-            }
-            else if (record.state === "running" && now - updated <= RUN_STATUS_STALE_MS) {
-                state = "running";
-            }
-        }
-        return {
-            ...data,
-            runtime: { state, observedAt: new Date(now).toISOString(), source: "local-run-status" },
-        };
+        return isRunStatusRecord(record) && record.runId === path.basename(runRoot.physicalPath)
+            ? record
+            : undefined;
     }
     catch {
+        return undefined;
+    }
+}
+/**
+ * Liveness is a current read of a contained local status record, separate from run evidence.
+ * A stale heartbeat means unknown: neither an old timestamp nor a persisted PID proves that a
+ * process died (the evidence may have been copied from another machine). A record its stopped
+ * process wrote is interrupted. No PID is served/probed.
+ */
+function withLocalRunStatus(record, input) {
+    // A served observation must never be inherited from a persisted projection or export.
+    const { runtime: _persistedRuntime, ...data } = input;
+    if (record === undefined || record.runId !== data.run.runId || record.mode !== data.run.mode)
         return data;
+    const now = Date.now();
+    const started = Date.parse(record.startedAt);
+    const updated = Date.parse(record.updatedAt);
+    const timestampsValid = Number.isFinite(started) && Number.isFinite(updated) && started <= updated && updated <= now;
+    let state = "unknown";
+    if (timestampsValid) {
+        if (record.state === "finished") {
+            state = "finished";
+        }
+        else if (record.state === "interrupted") {
+            state = "interrupted";
+        }
+        else if (record.state === "running" && now - updated <= RUN_STATUS_STALE_MS) {
+            state = "running";
+        }
     }
+    return {
+        ...data,
+        runtime: { state, observedAt: new Date(now).toISOString(), source: "local-run-status" },
+    };
 }
 /** internal: exported for the stream lifecycle tests. */
 export function withRuntimeStreamUrls(data, runtimeStreamUrls) {
@@ -249,6 +257,7 @@ admitRun) {
             mode: admitRun ? (data?.run.mode ?? null) : run.mode,
             href: `/_humanish/runs/${encodeURIComponent(run.runId)}/observer/index.html`,
             status: data?.run.status ?? "unknown",
+            ...(data?.run.display === undefined ? {} : { display: data.run.display }),
             ...(data?.runtime ? { runtimeState: data.runtime.state } : {}),
             streamCount: data?.streams.length ?? 0,
             // Labeled run-total cost estimate (advisory; null when the run carries no cost summary).