humanish 0.89.1 → 0.91.0

package/dist/program.d.ts

@@ -1,3 +1,4 @@
+import { type AutomaticAnalysisHooks } from "./automatic-analysis-completion.js";
 import { Command } from "commander";
 import { discoverProviderKeys } from "./key-resolution.js";
 import { type TelemetryProperties } from "./telemetry.js";
@@ -84,4 +85,8 @@ export declare function shouldServeOssMetaLabObserver(output: OssMetaLabResult,
     };
 };
 export declare function exitCodeForOssMetaLab(output: OssMetaLabResult): number;
+/** Listeners exist only while post-run analysis is active; actor signal behavior is unchanged. */
+export declare function cliAutomaticAnalysisHooks(io: Pick<CliIo, "writeErr">): AutomaticAnalysisHooks;
+/** Preserve the run's own result while making requested post-processing failures machine-visible. */
+export declare function automaticAnalysisEnvelope<T>(result: T): T;
 export {};

package/dist/program.js

@@ -1,3 +1,5 @@
+import { automaticAnalysisBudget, formatAutomaticAnalysisBudget } from "./automatic-analysis-config.js";
+import { automaticAnalysisSucceeded } from "./automatic-analysis-completion.js";
 import { formatCuaDiagnostics, formatCuaStopCause } from "./cua-diagnostics.js";
 import { existsSync, readFileSync } from "node:fs";
 import { formatOrientationHuman, readOrientation } from "./orientation.js";
@@ -965,7 +967,7 @@ function analysisSelection(options, command) {
 function registerAnalyzeCommand(parent, io) {
     const analyze = parent.command("analyze")
         .enablePositionalOptions()
-        .description("Analyze retained participant evidence into versioned findings. Explicit opt-in: sends selected text and captures to OpenAI. Opening Observer never starts analysis.")
+        .description("Analyze retained participant evidence into versioned findings. This request sends selected text and captures to OpenAI. Opening Observer never starts analysis.")
         .summary("Generate evidence-linked study findings.")
         .option("--run <id>", "Completed run id or latest pointer.", "latest")
         .option("--cwd <path>", "Target project directory.", ".")
@@ -2419,6 +2421,10 @@ async function runLabCommand(args) {
         // visibly so the invoker (who may not be the manifest author) knows executable code just ran.
         args.io.writeErr(`warning: review scorer ${scorer.provenance.ref} (${scorer.provenance.source}) is executable host code loaded and run in-process — review it as code, not config.\n`);
     }
+    const analysisBudget = automaticAnalysisBudget(config.review?.analysis, backend);
+    if (analysisBudget && resolveLabDryRun(config, args.options.dryRun, true) === false) {
+        args.io.writeErr(`${formatAutomaticAnalysisBudget(analysisBudget)}\n`);
+    }
     switch (backend) {
         case "synthetic":
             await runSyntheticBackend({ ...args, config, labProvenance: lab });
@@ -2597,6 +2603,7 @@ async function runCuaBackend(args) {
     let outcome;
     try {
         outcome = await runLab(args.config, {
+            automaticAnalysis: cliAutomaticAnalysisHooks(args.io),
             cwd: args.options.cwd,
             ...(args.labProvenance === undefined ? {} : { lab: args.labProvenance }),
             // Watch mode opens the served Observer below (or prints the phone target under --expose)
@@ -2695,7 +2702,7 @@ async function runCuaBackend(args) {
         };
     }
     writeResult(args.command, args.io, output, formatCuaLabHuman);
-    args.io.setExitCode(result.ok ? 0 : 2);
+    args.io.setExitCode(result.ok && automaticAnalysisSucceeded(result) ? 0 : 2);
     if (server && (result.observer?.ok || attachedObserver)) {
         const activeServer = server;
         const followResult = output.observer?.ok ? output.observer : withObserverServer(attachedObserver, activeServer);
@@ -2733,6 +2740,7 @@ async function runScriptedBackend(args) {
         wantsMachine
     });
     const outcome = await runLab(args.config, {
+        automaticAnalysis: cliAutomaticAnalysisHooks(args.io),
         cwd: args.options.cwd,
         ...(args.labProvenance === undefined ? {} : { lab: args.labProvenance }),
         // Watch mode opens the served Observer below instead of the static render.
@@ -2745,7 +2753,7 @@ async function runScriptedBackend(args) {
     }
     const result = outcome.result;
     writeResult(args.command, args.io, result, formatScriptedLabHuman);
-    args.io.setExitCode(result.ok ? 0 : 2);
+    args.io.setExitCode(result.ok && automaticAnalysisSucceeded(result) ? 0 : 2);
     // Watch mode serves the freshly rendered Observer (and opens it unless told not to).
     if (args.mode === "watch" && result.ok && !wantsMachine) {
         await renderAndMaybeFollowObserver({
@@ -2770,6 +2778,7 @@ async function runTerminalBackend(args) {
         wantsMachine
     });
     const outcome = await runLab(args.config, {
+        automaticAnalysis: cliAutomaticAnalysisHooks(args.io),
         cwd: args.options.cwd,
         ...(args.labProvenance === undefined ? {} : { lab: args.labProvenance }),
         open: args.mode === "watch" ? false : shouldOpen,
@@ -2782,7 +2791,7 @@ async function runTerminalBackend(args) {
     }
     const result = outcome.result;
     writeResult(args.command, args.io, result, formatTerminalLabHuman);
-    args.io.setExitCode(result.ok ? 0 : 2);
+    args.io.setExitCode(result.ok && automaticAnalysisSucceeded(result) ? 0 : 2);
     if (args.mode === "watch" && result.ok && !wantsMachine) {
         await renderAndMaybeFollowObserver({
             command: args.command,
@@ -2804,6 +2813,7 @@ async function runSharedWorldBackend(args) {
         wantsMachine
     });
     const outcome = await runLab(args.config, {
+        automaticAnalysis: cliAutomaticAnalysisHooks(args.io),
         cwd: args.options.cwd,
         ...(args.labProvenance === undefined ? {} : { lab: args.labProvenance }),
         open: args.mode === "watch" ? false : shouldOpen,
@@ -2816,7 +2826,7 @@ async function runSharedWorldBackend(args) {
     }
     const result = outcome.result;
     writeResult(args.command, args.io, result, formatSharedWorldLabHuman);
-    args.io.setExitCode(result.ok ? 0 : 2);
+    args.io.setExitCode(result.ok && automaticAnalysisSucceeded(result) ? 0 : 2);
     if (args.mode === "watch" && result.ok && !wantsMachine) {
         await renderAndMaybeFollowObserver({
             command: args.command,
@@ -2886,6 +2896,7 @@ async function runConcurrentSharedWorldBackend(args) {
     let outcome;
     try {
         outcome = await runLab(args.config, {
+            automaticAnalysis: cliAutomaticAnalysisHooks(args.io),
             cwd: args.options.cwd,
             ...(args.labProvenance === undefined ? {} : { lab: args.labProvenance }),
             open: wantsFollow ? false : shouldOpen,
@@ -2932,7 +2943,7 @@ async function runConcurrentSharedWorldBackend(args) {
         };
     }
     writeResult(args.command, args.io, output, formatConcurrentSharedWorldLabHuman);
-    args.io.setExitCode(result.ok ? 0 : 2);
+    args.io.setExitCode(result.ok && automaticAnalysisSucceeded(result) ? 0 : 2);
     if (server && output.observer?.ok) {
         await followObserver(args.io, output.observer, server);
     }
@@ -3306,11 +3317,17 @@ function withOssMetaLabServer(result, server) {
 // funnel every real command uses, without duplicating its stdout-vs-formatHuman
 // branching. Not re-exported from src/index.ts; this stays an internal seam.
 export function writeResult(command, io, result, formatHuman) {
+    const output = automaticAnalysisEnvelope(result);
     if (wantsJson(command)) {
-        io.writeOut(`${JSON.stringify(result, null, 2)}\n`);
+        io.writeOut(`${JSON.stringify(output, null, 2)}\n`);
     }
     else {
-        io.writeOut(formatHuman(result));
+        io.writeOut(formatHuman(output));
+        if (output !== null && typeof output === "object" && "automaticAnalysis" in output) {
+            const analysis = output.automaticAnalysis;
+            if (analysis)
+                io.writeOut(`analysis: ${analysis.state}${analysis.reason ? ` (${analysis.reason})` : ""}\n`);
+        }
     }
     markInvocationEnvelopeWritten(command);
     // Every backend's result passes through here, so this is where a study's facts get read for
@@ -3466,6 +3483,7 @@ function formatLabPreflightHuman(result) {
         `targets: ${checkedTargets.length ? `${reachableTargets.length}/${checkedTargets.length} reachable` : `${result.targets.length} declared, not checked`}`,
         ...(blockedTargets.length ? [`blocked-targets: ${blockedTargets.length}`] : []),
         `spend: ${result.spend.e2bDesktop ? "one e2b desktop, no model calls" : "none"}`,
+        ...(result.analysis ? [formatAutomaticAnalysisBudget(result.analysis)] : []),
         ...(result.sandbox.created
             ? [`sandbox: created=yes killed=${result.sandbox.killed === true ? "yes" : "no"}`]
             : []),
@@ -3757,4 +3775,27 @@ function wantsJson(command) {
     }
     return false;
 }
+/** Listeners exist only while post-run analysis is active; actor signal behavior is unchanged. */
+export function cliAutomaticAnalysisHooks(io) {
+    const controller = new AbortController();
+    return {
+        deps: { signal: controller.signal },
+        onStart: () => {
+            const cancel = () => { controller.abort(); };
+            const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
+            io.writeErr("Participants finished; preparing analysis…\n");
+            for (const signal of signals)
+                process.on(signal, cancel);
+            return () => { for (const signal of signals)
+                process.off(signal, cancel); };
+        }
+    };
+}
+/** Preserve the run's own result while making requested post-processing failures machine-visible. */
+export function automaticAnalysisEnvelope(result) {
+    if (result === null || typeof result !== "object" || !("automaticAnalysis" in result) || !("ok" in result))
+        return result;
+    const run = result;
+    return { ...run, runOk: run.ok, ok: run.ok && automaticAnalysisSucceeded(run) };
+}
 //# sourceMappingURL=program.js.map