humanish 0.110.0 → 0.110.2

package/dist/observer/library.js

@@ -1,14 +1,16 @@
-const STATUS_TONES = {
-    passed: "#3fb970",
-    running: "#4f8ff7",
-    failed: "#e5534b",
-    blocked: "#d29922",
-    timed_out: "#d29922",
+import { cli } from "../cli/invocation.js";
+// The pip color for each RunDisplay tone; a run with no display gets the neutral gray.
+const DISPLAY_TONES = {
+    pass: "#3fb970",
+    live: "#4f8ff7",
+    fail: "#e5534b",
+    warn: "#d29922",
+    neutral: "#57606f",
 };
 export function renderLibraryHtml(history, opts) {
     const emptyState = opts.safe
-        ? "No share_ready runs yet. Run `humanish verify` to see why."
-        : "No runs yet. Run `humanish watch` to create one.";
+        ? `No share_ready runs yet. Run \`${cli("verify")}\` to see why.`
+        : `No runs yet. Run \`${cli("run first-run")}\` to create one.`;
     return `<!doctype html>
 <html lang="en" data-theme="dark">
 <head>
@@ -83,7 +85,7 @@ main { padding: 1rem 1.1rem 3rem; max-width: 44rem; margin: 0 auto; }
 }
 // prose-check: script (the library page's JavaScript)
 function libraryClientJs() {
-    const tones = JSON.stringify(STATUS_TONES);
+    const tones = JSON.stringify(DISPLAY_TONES);
     return `
 (function () {
   var TONES = ${tones};
@@ -103,9 +105,11 @@ function libraryClientJs() {
       link.href = run.href;
       var top = document.createElement("div");
       top.className = "run-top";
+      var display = run.display || null;
+      var live = display !== null && display.state === "running";
       var pip = document.createElement("span");
-      pip.className = run.status === "running" ? "pip running" : "pip";
-      pip.style.background = TONES[run.status] || "#57606f";
+      pip.className = live ? "pip running" : "pip";
+      pip.style.background = (display && TONES[display.tone]) || TONES.neutral;
       var id = document.createElement("span");
       id.className = "run-id";
       id.textContent = run.runId;
@@ -116,15 +120,15 @@ function libraryClientJs() {
         latest.className = "badge latest";
         latest.textContent = "latest";
         top.appendChild(latest);
-      } else if (run.status === "running") {
-        var live = document.createElement("span");
-        live.className = "badge";
-        live.textContent = "live";
-        top.appendChild(live);
+      } else if (live) {
+        var badge = document.createElement("span");
+        badge.className = "badge";
+        badge.textContent = "live";
+        top.appendChild(badge);
       }
       var meta = document.createElement("div");
       meta.className = "run-meta";
-      var metaBits = [run.mode || "unknown", run.streamCount + " participants", run.createdAt || ""];
+      var metaBits = [display ? display.label : "", run.mode || "unknown", run.streamCount + " participants", run.createdAt || ""];
       // Labeled cost token: ALWAYS "~$X est." (never a bare "$X"), so the library never implies an
       // authoritative charge. Null = omitted (advisory, fail-open on display).
       if (run.costLabel) {

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";
@@ -19,6 +20,7 @@ import { buildServeSecurityHeaders, hostAllowed, parsePublicOrigin } from "./htt
 import { listenOnLoopback } from "./listen.js";
 import { pinDirectChildDirectory, pinDirectory, readContainedFile, } from "./pinned-files.js";
 import { buildHistoryIndex, matchRunRoute, serveRunPath, writeResponse, } from "./run-routes.js";
+import { cli } from "../cli/invocation.js";
 const OBSERVER_SCHEMA = "humanish.observer-result.v1";
 const observerRuntimeStreamUrls = new WeakMap();
 const observerPreparedRunPaths = new WeakMap();
@@ -99,7 +101,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(),
@@ -130,7 +137,7 @@ export async function renderObserver(cwdInput, runInput, options = {}) {
             loaded.bundle.mode === "live"
                 ? "Observer renders verified local evidence artifacts; runtime stream auth URLs are not persisted."
                 : "This is a dry run: its participants are synthetic and no product behavior was tested.",
-            "Before filing public feedback, use `humanish feedback issue` so redaction and public-safety checks gate the payload.",
+            `Before filing public feedback, use \`${cli("feedback issue")}\` so redaction and public-safety checks gate the payload.`,
             ...(openResult.warning ? [openResult.warning] : []),
         ],
     };

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

@@ -4,11 +4,12 @@
 import path from "node:path";
 import { isAnalysisRecordPath, projectShareCheckedAnalysis } from "../analysis/sharing.js";
 import { loadAnalysis } from "../analysis/load.js";
+import { isLocalOnlyRunFile, isLocalOnlyRunFileIdentity } from "../run/local-only-files.js";
 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";
@@ -70,9 +71,11 @@ export async function serveRunPath(runRoot, relativePath, response, runtimeStrea
     // file serving bypass its current-content checks or a warmed source-only admission cache.
     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" ||
         derivedLeaf.startsWith(".humanish-write-") ||
-        isAnalysisRecordPath(cleanedRelativePath)) {
+        isAnalysisRecordPath(cleanedRelativePath) ||
+        isLocalOnlyRunFile(cleanedRelativePath)) {
         writeResponse(response, 404, "Not found", "text/plain; charset=utf-8");
         return;
     }
@@ -103,6 +106,10 @@ export async function serveRunPath(runRoot, relativePath, response, runtimeStrea
         await serveContainedMedia(runRoot, filePath, response, request);
         return;
     }
+    if (await isLocalOnlyRunFileIdentity(root, filePath)) {
+        writeResponse(response, 404, "Not found", "text/plain; charset=utf-8");
+        return;
+    }
     try {
         const body = await readContainedFile(runRoot, filePath);
         if (!body) {
@@ -120,6 +127,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 +138,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 +264,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).

package/dist/observer/serve.js

@@ -10,6 +10,7 @@ import { buildServeSecurityHeaders, hostAllowed, parsePublicOrigin, } from "./ht
 import { isSafeRunIdSegment } from "../run/paths.js";
 import { listRuns } from "../run/stored-runs.js";
 import { verifyRun } from "../verify/verify.js";
+import { cli } from "../cli/invocation.js";
 export const SERVE_SCHEMA = "humanish.serve-result.v1";
 export function createShareSafetyAdmission(cwd, options = {}) {
     const verifyImpl = options.verifyImpl ?? verifyRun;
@@ -196,7 +197,7 @@ export async function serveObserverLibrary(cwdInput, options) {
             ok: false,
             error: {
                 code: "HUMANISH_RUN_NOT_FOUND",
-                message: "No run library found under .humanish/runs. Run `humanish watch` to create the first run.",
+                message: `No run library found under .humanish/runs. Run \`${cli("run first-run")}\` to create the first run.`,
             },
         };
     }