humanish 0.140.0 → 0.142.0

package/dist/observer/render.d.ts

@@ -31,6 +31,8 @@ export interface ObserverServeOptions {
     /** Restrict history and evidence routes to the selected run. Exposed viewers always do this. */
     scope?: "run" | "library";
     exposed?: boolean;
+    /** Bind every interface: only a remote run's runner sandbox, behind its provider's proxy. */
+    allInterfaces?: boolean;
 }
 export interface ObserverServer {
     url: string;

package/dist/observer/render.js

@@ -293,7 +293,7 @@ export async function serveObserver(result, options = {}) {
     const server = createServer((request, response) => {
         void handleRequest(request, response);
     });
-    port = await listenOnLoopback(server, options.port ?? 0);
+    port = await listenOnLoopback(server, options.port ?? 0, undefined, options.allInterfaces === true);
     if (exposed) {
         hostAllowlist.add(`127.0.0.1:${port}`);
         hostAllowlist.add(`localhost:${port}`);

package/dist/observer/run-routes.js

@@ -15,7 +15,7 @@ import { displayedTraces, loadStreamTraces, } from "../run/stream-trace.js";
 import { isNodeError, isRecord } from "../run/type-guards.js";
 import { MAX_NOTE_FILE_BYTES, readRunNotes, RUN_NOTES_DIR, } from "../run/note-files.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, runAnalysisPhase, isRunStatusRecord, } from "../run/status.js";
 import { renderObserverHtml } from "./artifact.js";
 import { parseFeedCursors } from "./feed-cursors.js";
 import { observerFeedBody } from "./page-data.js";
@@ -98,7 +98,9 @@ export async function serveRunPath(runRoot, relativePath, response, runtimeStrea
     const derivedRoot = cleanedRelativePath.split("/")[0];
     const derivedLeaf = path.posix.basename(cleanedRelativePath);
     // Local-only files (raw sandbox ids, the recording pid) are read in process, never served.
-    if (derivedRoot === ".analysis-lock" ||
+    if (
+    // `.analysis-lock-stale-*` is a lock whose dead owner's next writer moved it aside.
+    derivedRoot?.startsWith(".analysis-lock") === true ||
         derivedLeaf.startsWith(".humanish-write-") ||
         isAnalysisRecordPath(cleanedRelativePath) ||
         isLocalOnlyRunFile(cleanedRelativePath)) {
@@ -330,9 +332,16 @@ function withLocalRunStatus(record, input, outcome) {
             state = "running";
         }
     }
+    // The run's own process analyzes it after the run ended; the bundle outcome does not say so.
+    const analysis = timestampsValid ? runAnalysisPhase(record, now) : undefined;
     return {
         ...data,
-        runtime: { state, observedAt: new Date(now).toISOString(), source: "local-run-status" },
+        runtime: {
+            state,
+            observedAt: new Date(now).toISOString(),
+            source: "local-run-status",
+            ...(analysis?.state === "running" ? { analysis: { startedAt: analysis.startedAt } } : {}),
+        },
     };
 }
 /** internal: exported for the stream lifecycle tests. */