humanish 0.111.4 → 0.112.0

package/dist/cli/io.js

@@ -15,12 +15,13 @@ export const JSON_OPTION_DESCRIPTION = "Print a machine-readable JSON response."
 export const CWD_OPTION_DESCRIPTION = "Project directory.";
 export const RUN_OPTION_DESCRIPTION = "Run id, or latest.";
 export const DOTENV_OPTION_DESCRIPTION = "Load unset variables from this dotenv file. Values are never printed or saved.";
-const ENV_FILE_RENAMED = "`--env-file` is now `--dotenv`; `--env-file` is removed in 0.112.0.";
+const ENV_FILE_RENAMED = "`--env-file` is now `--dotenv`; `--env-file` is removed in the first minor release on or after 2026-11-03.";
 /**
  * The hidden `--env-file <path>` that `--dotenv` replaced. Node scans the whole argv for
  * `--env-file` before a script runs, and stops only at `--` (src/node_dotenv.cc), so a missing file
  * exits 9 through Node and never reaches humanish. `--dotenv` does not collide.
- * Removed in 0.112.0: deprecated in 0.110.0 on 2026-10-03, it stays 30 days and one minor release.
+ * Removed in the first minor release on or after 2026-11-03: deprecated in 0.110.0 on 2026-10-03, it stays at least 30 days and one
+ * minor release.
  */
 export function envFileAliasOption() {
     return new Option("--env-file <path>").hideHelp().conflicts("dotenv");

package/dist/feedback/draft.js

@@ -120,7 +120,8 @@ export async function buildAnalysisDraft(context, options) {
     const root = path.dirname(context.loaded.bundlePath);
     const evidenceIds = new Set(finding.observations.flatMap((item) => item.evidenceIds));
     const evidence = analysis.evidence.filter((item) => evidenceIds.has(item.id));
-    const claim = correction?.status === "amended" ? correction.replacementClaim : finding.title;
+    const amended = correction?.status === "amended";
+    const claim = amended ? correction.replacementClaim : (finding.headline ?? finding.title);
     const firstLine = claim.trim().split(/\r?\n/)[0] || `Reviewed finding ${finding.id}`;
     const summary = Array.from(firstLine).length > 160
         ? Array.from(firstLine).slice(0, 159).join("") + "…"
@@ -144,10 +145,19 @@ export async function buildAnalysisDraft(context, options) {
         summary,
         expected: "Review the cited behavior against the participant assignment and confirm the expected product behavior.",
         actual: [
+            // The plain account leads; an amendment makes it stale, so the draft says so in its place.
+            ...(finding.headline === undefined
+                ? []
+                : amended
+                    ? [
+                        "This finding was corrected in human review. The reviewer's claim above replaces its original headline and account.",
+                        "",
+                    ]
+                    : finding.experience === undefined
+                        ? []
+                        : [finding.experience, ""]),
             "Independent study analysis; does not replace participant feedback or recorded completion outcomes.",
-            correction?.status === "amended"
-                ? `Amended claim: ${claim}. Original analysis: ${finding.summary}`
-                : finding.summary,
+            amended ? `Amended claim: ${claim}. Original analysis: ${finding.summary}` : finding.summary,
             `Impact: ${finding.impact}. ${finding.affectedStreamIds.length} affected / ${finding.exposedStreamIds.length} observed exposed participants. ${finding.exposureReason}`,
             `Recovery: ${finding.recovery}. Confidence: ${finding.confidence}.`,
             ...finding.observations.map((item) => `${item.basis}: ${item.claim}${item.limitation ? ` Limitation: ${item.limitation}` : ""}`),

package/dist/observer/run-routes.js

@@ -8,6 +8,7 @@ import { isLocalOnlyRunFile, isLocalOnlyRunFileIdentity } from "../run/local-onl
 import { listRuns } from "../run/stored-runs.js";
 import { readAnalysisAccounting } from "../run/costs.js";
 import { bindExistingRunArtifactPaths, isPathInside, isSafeRunIdSegment, } from "../run/paths.js";
+import { isRunOutcome } from "../run/bundle-shape.js";
 import { analysisCostOf, runCost, runCostLabel } from "../run/run-cost.js";
 import { RUN_STATUS_FILE, RUN_STATUS_STALE_MS, isRunStatusRecord, } from "../run/status.js";
 import { renderObserverHtml } from "./artifact.js";
@@ -138,7 +139,7 @@ async function readObserverData(runRoot, runtimeStreamUrls = []) {
         if (!bundleBytes)
             throw new Error("run.json unavailable");
         const bundle = JSON.parse(bundleBytes.toString("utf8"));
-        return withRuntimeStreamUrls(withLocalRunStatus(record, buildObserverData(bundle, undefined, record)), runtimeStreamUrls);
+        return withRuntimeStreamUrls(withLocalRunStatus(record, buildObserverData(bundle, undefined, record), bundle.outcome), runtimeStreamUrls);
     }
     catch { }
     try {
@@ -166,12 +167,12 @@ async function readLocalRunStatus(runRoot) {
     }
 }
 /**
- * Liveness is a current read of a contained local status record, separate from run evidence.
+ * A recorded bundle outcome wins; otherwise runtime status reads the contained local heartbeat.
  * 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) {
+function withLocalRunStatus(record, input, outcome) {
     // 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)
@@ -181,7 +182,10 @@ function withLocalRunStatus(record, input) {
     const updated = Date.parse(record.updatedAt);
     const timestampsValid = Number.isFinite(started) && Number.isFinite(updated) && started <= updated && updated <= now;
     let state = "unknown";
-    if (timestampsValid) {
+    if (isRunOutcome(outcome)) {
+        state = outcome.state;
+    }
+    else if (timestampsValid) {
         if (record.state === "finished") {
             state = "finished";
         }