humanish 0.49.0 → 0.51.0

package/dist/cua-actor-lab.js

@@ -26,6 +26,7 @@ import { readFile, realpath, rm } from "node:fs/promises";
 import path from "node:path";
 import { runDesktopCommandOrThrow, toErrorMessage } from "./command-failure.js";
 import { pathToFileURL } from "node:url";
+import { beginRunStatus } from "./run-status.js";
 import { adapterScoreFailureMessage, applyBrowserAdapterHooks } from "./adapter-extension.js";
 import { actorRegistry, isCuaActorDescriptor } from "./actor-registry.js";
 import { CHROMIUM_EVIDENCE_HYGIENE_FLAGS, chromiumEvidenceProfilePreferencesJson } from "./browser-evidence-hygiene.js";
@@ -2261,6 +2262,17 @@ export async function runCuaActorLab(options) {
     }
     const runId = options.runId ?? makeCuaRunId();
     const runPaths = await prepareRunArtifactPaths(cwd, runId);
+    // Identity + liveness on disk from the first moment (#455): anything watching the runs
+    // directory — the TUI, another terminal, an agent — can now tell which lab this is and that
+    // it is alive, without waiting for the interactive observer flush that used to be the only
+    // mid-run write. The success path finalizes it with the real outcome; the fail-closed returns
+    // below do not, so `runLab`'s status scope finalizes those with no outcome. A crash reaches
+    // neither and leaves the record stale, which reads as interrupted rather than as a lie.
+    const runStatus = beginRunStatus(runPaths, {
+        runId,
+        mode: dryRun ? "dry-run" : "live",
+        ...(options.lab === undefined ? {} : { lab: options.lab })
+    });
     const artifactRoot = runPaths.absoluteRunRoot;
     const physicalArtifactRoot = runPaths.physicalRunRoot;
     const createdAt = new Date().toISOString();
@@ -2353,9 +2365,16 @@ export async function runCuaActorLab(options) {
     }));
     const inProgressAggregateSubject = inProgressLaneSubjects[0];
     const inProgressProvenance = subjectProvenanceArg(inProgressAggregateSubject, publicRepo, subjectEnvNames);
-    if (!dryRun && options.onObserverReady) {
+    // A live run writes what it is doing AS IT DOES IT, whether or not anyone is currently watching.
+    // This used to be gated on `options.onObserverReady` — the interactive Observer callback — so a
+    // run launched by an agent (`lab run --json`), detached, or from the terminal surface recorded
+    // nothing at all until it completed, and anything asking "what is this participant doing right
+    // now" got silence for the whole run. Who reads the evidence is not the run's business; the
+    // callback below stays conditional, the writing does not.
+    if (!dryRun) {
         const inProgressBundle = laneCount === 1 && rerunLineage === undefined
             ? buildSingleLaneBundle({
+                ...(options.lab === undefined ? {} : { lab: options.lab }),
                 spec: laneSpecs[0],
                 outcome: undefined,
                 descriptor,
@@ -2372,6 +2391,7 @@ export async function runCuaActorLab(options) {
                 localAppSubject
             })
             : buildCuaFanoutBundle({
+                ...(options.lab === undefined ? {} : { lab: options.lab }),
                 specs: laneSpecs,
                 laneSubjects: inProgressLaneSubjects,
                 aggregateSubject: inProgressAggregateSubject,
@@ -2394,7 +2414,8 @@ export async function runCuaActorLab(options) {
         liveObserver = observerResultForCuaArtifacts(cwd, runId, artifactRoot, [
             "Live CUA Observer is attached before final verification; stream auth URLs are runtime-only and are not persisted."
         ]);
-        await options.onObserverReady(liveObserver);
+        if (options.onObserverReady)
+            await options.onObserverReady(liveObserver);
         // Incremental live flush (#441): as each lane's loop reports its recorded-so-far items,
         // rewrite the in-progress bundle with per-stream `liveActor` partials so the attached
         // Observer's 5s poll sees the timeline grow. Throttled (one write per interval, trailing
@@ -2402,6 +2423,10 @@ export async function runCuaActorLab(options) {
         // write so a stale flush can never resurrect the in-progress bundle. A flush failure is
         // swallowed: mid-run observability must never break the run itself.
         const streamIdByLane = new Map(laneSpecs.map((spec) => [spec.laneId, spec.streamId]));
+        // The persona each lane is running, so the live flush can say who is in it.
+        const personaByStream = new Map(laneSpecs
+            .map((spec) => [spec.streamId, spec.persona?.id])
+            .filter((entry) => typeof entry[1] === "string"));
         const liveItemsByStream = new Map();
         let flushWriting;
         let flushDirty = false;
@@ -2420,7 +2445,20 @@ export async function runCuaActorLab(options) {
                         const liveItems = liveItemsByStream.get(stream.id);
                         return liveItems === undefined
                             ? stream
-                            : { ...stream, liveActor: { schema: "humanish.live-actor.v1", updatedAt, items: [...liveItems] } };
+                            : {
+                                ...stream,
+                                liveActor: {
+                                    schema: "humanish.live-actor.v1",
+                                    updatedAt,
+                                    // WHO is in this lane, carried while the run is live. Without it a surface
+                                    // watching a live run can only name the lane, and "CUA browser — observer-live-
+                                    // check" is the harness talking about itself where the participant should be.
+                                    ...(personaByStream.get(stream.id) === undefined
+                                        ? {}
+                                        : { persona: { id: personaByStream.get(stream.id) } }),
+                                    items: [...liveItems]
+                                }
+                            };
                     })
                 };
                 try {
@@ -2585,6 +2623,7 @@ export async function runCuaActorLab(options) {
     const finalProvenance = subjectProvenanceArg(aggregateSubject, publicRepo, subjectEnvNames);
     const bundle = laneCount === 1 && rerunLineage === undefined
         ? buildSingleLaneBundle({
+            ...(options.lab === undefined ? {} : { lab: options.lab }),
             spec: laneSpecs[0],
             outcome: outcomes?.[0],
             descriptor,
@@ -2600,6 +2639,7 @@ export async function runCuaActorLab(options) {
             localAppSubject
         })
         : buildCuaFanoutBundle({
+            ...(options.lab === undefined ? {} : { lab: options.lab }),
             specs: laneSpecs,
             ...(outcomes === undefined ? {} : { outcomes }),
             laneSubjects,
@@ -2639,6 +2679,24 @@ export async function runCuaActorLab(options) {
         ...(options.scorerProvenance === undefined ? {} : { scorerProvenance: options.scorerProvenance })
     });
     await writeCuaRunArtifacts(bundle, createdAt, runPaths);
+    // Finalize the status record from the bundle that was just written, so the index can never
+    // claim an outcome the evidence does not carry. A run that throws before reaching here leaves
+    // its record `running` and goes stale — read as interrupted, which is the truth.
+    await runStatus.finish({
+        ...(bundle.review?.verdict === undefined ? {} : { verdict: bundle.review.verdict }),
+        ...(bundle.review?.participants === undefined
+            ? {}
+            : {
+                participants: {
+                    total: bundle.review.participants.total,
+                    reachedGoal: bundle.review.participants.reachedGoal,
+                    ...(bundle.review.participants.reportedFriction === undefined
+                        ? {}
+                        : { reportedFriction: bundle.review.participants.reportedFriction })
+                }
+            }),
+        ...(bundle.cost?.estimatedTotalUsd === undefined ? {} : { estimatedCostUsd: bundle.cost.estimatedTotalUsd })
+    });
     const observer = await render(cwd, runId, { open: options.open === true });
     if (observer.ok && runtimeStreamUrls.length > 0) {
         attachObserverRuntimeStreamUrls(observer, runtimeStreamUrls);
@@ -2801,6 +2859,7 @@ function observerResultForCuaArtifacts(cwd, runId, artifactRoot, warnings = [])
 function buildSingleLaneBundle(args) {
     const { spec, outcome, config } = args;
     return buildCuaBundle({
+        ...(args.lab === undefined ? {} : { lab: args.lab }),
         actorId: args.descriptor.id,
         appUrl: args.appUrl,
         laneId: spec.laneId,
@@ -3606,6 +3665,7 @@ export function buildCuaBundle(args) {
         createdAt: args.createdAt,
         cwd: PUBLIC_TARGET_CWD,
         artifactRoot: path.join(".humanish", "runs", args.runId),
+        ...(args.lab === undefined ? {} : { lab: args.lab }),
         source: args.source,
         persona: {
             id: args.persona.id,
@@ -4078,6 +4138,7 @@ export function buildCuaFanoutBundle(args) {
         createdAt: args.createdAt,
         cwd: PUBLIC_TARGET_CWD,
         artifactRoot: path.join(".humanish", "runs", args.runId),
+        ...(args.lab === undefined ? {} : { lab: args.lab }),
         source: args.source,
         persona: {
             id: specs[0].persona.id,