humanish 0.140.0 → 0.142.0

package/dist/run/preflight-receipts.js

@@ -3,11 +3,10 @@
 // removes the journal. A journal that stays means the probe's sandbox may still be running, and
 // `humanish reclaim --preflight` kills it by the recorded id once it is safe to.
 import { randomBytes } from "node:crypto";
-import { existsSync, readFileSync, readlinkSync } from "node:fs";
 import { readdir, rmdir, unlink } from "node:fs/promises";
-import { hostname } from "node:os";
 import path from "node:path";
 import { parseSandboxReceipts, SANDBOX_RECEIPTS_ARTIFACT } from "./sandbox-receipts.js";
+import { currentProcessOwner, processOwnerGone, processOwnerOf, } from "./process-owner.js";
 import { assertPreparedSelectedOutputDirectory, bindExistingManagedHumanishOutputDirectory, prepareManagedHumanishOutputDirectory, readContainedRegularFile, RUN_ARTIFACT_MAX_BYTES, writeContainedOutputFile, } from "./contained-output.js";
 const PREFLIGHT_DIR = "preflight";
 // Written when the probe finished without confirming its kill: the owner no longer holds the
@@ -15,39 +14,13 @@ const PREFLIGHT_DIR = "preflight";
 const ABANDONED_MARKER = "abandoned";
 const OWNER_FILE = "owner.json";
 const JOURNAL_NAME = /^preflight-\d+-[a-z0-9-]+$/;
-function ownerContext() {
-    let pidNamespace;
-    try {
-        pidNamespace = readlinkSync("/proc/self/ns/pid");
-    }
-    catch {
-        // No procfs: this platform has no pid namespaces to tell apart.
-    }
-    return { hostname: hostname(), ...(pidNamespace === undefined ? {} : { pidNamespace }) };
-}
-/** The process's start ticks; null when procfs says it is gone; undefined without procfs. */
-function startTicks(pid) {
-    if (!existsSync("/proc/self/stat"))
-        return undefined;
-    try {
-        const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
-        // Field 22; the command name before it is parenthesized and may contain spaces.
-        return stat.slice(stat.lastIndexOf(")") + 2).split(" ")[19] ?? null;
-    }
-    catch {
-        return null;
-    }
-}
 /** Create this process's journal directory for one probe with the given lease. */
 export async function openPreflightJournal(cwd, leaseMs) {
     const stamp = new Date().toISOString().replace(/[:.]/g, "-").toLowerCase();
     const id = `preflight-${process.pid}-${stamp}-${randomBytes(4).toString("hex")}`;
     const root = await prepareManagedHumanishOutputDirectory(cwd, PREFLIGHT_DIR, id);
-    const ticks = startTicks(process.pid);
     const owner = {
-        ...ownerContext(),
-        pid: process.pid,
-        ...(typeof ticks === "string" ? { startTicks: ticks } : {}),
+        ...currentProcessOwner(),
         createdAt: new Date().toISOString(),
         leaseMs,
     };
@@ -60,19 +33,12 @@ function parseOwner(read) {
         return undefined;
     try {
         const value = JSON.parse(read.bytes.toString("utf8"));
-        if (typeof value.hostname !== "string" ||
-            typeof value.pid !== "number" ||
+        const owner = processOwnerOf(value);
+        if (owner === undefined ||
             typeof value.createdAt !== "string" ||
             typeof value.leaseMs !== "number")
             return undefined;
-        return {
-            hostname: value.hostname,
-            ...(typeof value.pidNamespace === "string" ? { pidNamespace: value.pidNamespace } : {}),
-            pid: value.pid,
-            ...(typeof value.startTicks === "string" ? { startTicks: value.startTicks } : {}),
-            createdAt: value.createdAt,
-            leaseMs: value.leaseMs,
-        };
+        return { ...owner, createdAt: value.createdAt, leaseMs: value.leaseMs };
     }
     catch {
         return undefined;
@@ -133,34 +99,8 @@ export async function preflightReclaimDecision(journal, nowMs) {
     const owner = journal.owner;
     if (owner === undefined)
         return { reclaim: false, reason: `its owner record is missing or unreadable${until}` };
-    const here = ownerContext();
-    if (owner.hostname !== here.hostname || owner.pidNamespace !== here.pidNamespace)
-        return {
-            reclaim: false,
-            reason: `it was opened on host ${owner.hostname} in another host or pid namespace, where this process cannot see whether it is still running${until}`,
-        };
-    const running = `process ${owner.pid} is still running${until}`;
-    if (owner.pid === process.pid)
-        return { reclaim: false, reason: running };
-    const ticks = startTicks(owner.pid);
-    if (ticks === null)
-        return { reclaim: true };
-    if (typeof ticks === "string") {
-        // The pid now belongs to a different process: the owner is gone.
-        return owner.startTicks !== undefined && ticks !== owner.startTicks
-            ? { reclaim: true }
-            : { reclaim: false, reason: running };
-    }
-    try {
-        process.kill(owner.pid, 0);
-        return { reclaim: false, reason: running };
-    }
-    catch (error) {
-        // EPERM: the process exists but belongs to someone else.
-        return error.code === "EPERM"
-            ? { reclaim: false, reason: running }
-            : { reclaim: true };
-    }
+    const gone = processOwnerGone(owner);
+    return gone.gone ? { reclaim: true } : { reclaim: false, reason: `${gone.reason}${until}` };
 }
 /**
  * Remove a journal whose sandbox is confirmed gone. Only the files humanish writes there and the

package/dist/run/pricing.d.ts

@@ -25,6 +25,11 @@ export interface ModelRate {
         inputMultiplier: number;
         outputMultiplier: number;
     };
+    /** The last day (`YYYY-MM-DD`, UTC) these rates apply, when the sheet already publishes the
+     *  rates that follow. A request is priced at the rates of the day it is sent. */
+    until?: string;
+    /** The rates the sheet publishes from the day after `until`. */
+    after?: Pick<ModelRate, "inputUsdPerToken" | "outputUsdPerToken" | "cachedInputUsdPerToken">;
     /** The `YYYY-MM-DD` date the entry was last checked against `source`. */
     asOf: string;
     /** Public pricing page the number came from (a comment/URL, never a secret). */
@@ -32,6 +37,8 @@ export interface ModelRate {
     /** true = a stand-in that was not copied from a live sheet; the estimate carries this flag so a
      *  placeholder rate is never mistaken for a confirmed one. */
     placeholder?: boolean;
+    /** true = priced for study analysis only: no participant route runs this model. */
+    analysisOnly?: true;
 }
 export interface DesktopRate {
     usdPerMinute: number;
@@ -120,6 +127,8 @@ export declare const MODAL_SANDBOX_RESOURCE_RATE: DesktopResourceRate;
  * since an npm install cannot edit this file.
  */
 export declare function unpricedCapMessage(model: string): string;
+/** A participant model's rate; undefined for a model without one or priced for analysis only. */
+export declare function participantRate(model: string): ModelRate | undefined;
 export declare const DESKTOP_RATE: DesktopRate;
 export declare function isDesktopResources(value: unknown): value is DesktopResources;
 /** Price one observed allocation. Missing quantities/rates stay unknown, never a stock guess. */
@@ -141,7 +150,10 @@ export declare function estimateActorCostForExecution(usage: ActorTokenUsage | u
  * whole turn, so the per-turn records are dropped and the totals price on the base tier.
  */
 export declare function estimateAggregatedTurnCost(tokenUsage: ActorTokenUsage | undefined, modelId: string | undefined): ActorEstimatedCost;
-export declare function estimateActorCost(tokenUsage: ActorTokenUsage | undefined, modelId: string | undefined, rates?: Record<string, ModelRate>): ActorEstimatedCost;
+/** A model's rates on the day of `at` (UTC), or undefined when the table has none. Lookup is
+ *  case-insensitive on a trimmed id. */
+export declare function modelRate(modelId: string, at?: Date, rates?: Record<string, ModelRate>): ModelRate | undefined;
+export declare function estimateActorCost(tokenUsage: ActorTokenUsage | undefined, modelId: string | undefined, rates?: Record<string, ModelRate>, at?: Date): ActorEstimatedCost;
 /**
  * Estimate the E2B desktop-minute cost from a host-side create->teardown span (minutes). The rate
  * is injectable. Returns a declared-absent estimate (null + "no_duration") when no duration was

package/dist/run/pricing.js

@@ -21,7 +21,8 @@ const LONG_CONTEXT_TIER_272K = {
 };
 const GPT56_SOURCE = "developers.openai.com/api/docs/pricing (gpt-5.6 family, standard tier)";
 const GPT6_ASTRA_SOURCE = "developers.openai.com/api/docs/pricing (gpt-6-astra, standard tier)";
-// One entry for a model on the gpt-5.6 pricing mechanics (the 5.6 family and gpt-6-astra): rates
+const GPT6_SOL_LUNA_SOURCE = "developers.openai.com/api/docs/pricing (gpt-6.1-sol and gpt-6-luna, standard tier)";
+// One entry for a model on the gpt-5.6 pricing mechanics (the 5.6 and 6 families): rates
 // in USD-per-1M for legibility, converted once. Cache writes bill at 1.25x the uncached input rate
 // (`cache_write_tokens`, prompt-caching guide), and the 272K long-context tier applies. The
 // built-in `computer` tool has no per-call fee on the live sheet.
@@ -36,10 +37,28 @@ function rateWithLongContextTier(inPer1M, cachedPer1M, writePer1M, outPer1M, asO
         source,
     };
 }
+/** Gemini prices per 1M tokens: input, cached input and output (thinking included). */
+function geminiPrices(inPer1M, cachedPer1M, outPer1M) {
+    return {
+        inputUsdPerToken: inPer1M * 1e-6,
+        cachedInputUsdPerToken: cachedPer1M * 1e-6,
+        outputUsdPerToken: outPer1M * 1e-6,
+    };
+}
+function geminiRate(inPer1M, cachedPer1M, outPer1M, change = {}) {
+    return {
+        ...geminiPrices(inPer1M, cachedPer1M, outPer1M),
+        ...change,
+        analysisOnly: true,
+        asOf: "2026-10-21",
+        source: "ai.google.dev/gemini-api/docs/pricing (paid tier, standard)",
+    };
+}
 // gpt-5.6-sol promotional rates (live sheet 2026-09-03: $4 / $0.40 cached / $5 write / $20 out,
 // "available at least through November 21, 2026"). Re-verify against the sheet after Nov 21.
 const GPT56_SOL_PROMO_AS_OF = "2026-09-03";
 const GPT6_ASTRA_AS_OF = "2026-09-03";
+const GPT6_SOL_LUNA_AS_OF = "2026-10-21";
 // Per-model rates, keyed on the model id that lands in trace.ids.model (lookup is
 // case-insensitive on a trimmed id). An id missing here is declared absent, never guessed.
 export const MODEL_RATES = {
@@ -82,6 +101,17 @@ export const MODEL_RATES = {
     // output ($20 / $2 / $25 / $75 long-context columns). These rates cover explicit study
     // model choices and the study-analysis default; the computer-use default is separate.
     "gpt-6-astra": rateWithLongContextTier(10, 1, 12.5, 50, GPT6_ASTRA_AS_OF, GPT6_ASTRA_SOURCE),
+    // gpt-6.1-sol and gpt-6-luna: the same write and long-context mechanics on the sheet and each
+    // model page. 6.1 Sol bills cache reads at 5% of input ($0.10), where the others bill 10%.
+    "gpt-6.1-sol": rateWithLongContextTier(2, 0.1, 2.5, 10, GPT6_SOL_LUNA_AS_OF, GPT6_SOL_LUNA_SOURCE),
+    "gpt-6-luna": rateWithLongContextTier(0.1, 0.01, 0.125, 0.5, GPT6_SOL_LUNA_AS_OF, GPT6_SOL_LUNA_SOURCE),
+    // Gemini analysis models, paid standard tier. Thinking tokens bill as output. No long-context
+    // tier is published for them. Cached input is the implicit context-cache rate. On the free tier
+    // these requests bill nothing, so the estimate is the paid-tier cost.
+    "gemini-3.8-flash": geminiRate(0.75, 0.075, 3.75, {
+        until: "2026-12-31",
+        after: geminiPrices(1.5, 0.15, 7.5),
+    }),
 };
 // Current public incremental running-compute rates. Subscription fees/credits, negotiated
 // enterprise prices, and unobserved allocation/startup time are outside this estimate.
@@ -114,7 +144,13 @@ export const MODAL_SANDBOX_RESOURCE_RATE = {
  * since an npm install cannot edit this file.
  */
 export function unpricedCapMessage(model) {
-    return `caps sets a spend cap (maxUsd or maxTotalUsd), but humanish has no rate for model "${model}", so it cannot enforce the cap and refuses to start. Priced models: ${Object.keys(MODEL_RATES).sort().join(", ")}. Use one of them, or remove maxUsd and maxTotalUsd to run without a cap.`;
+    const priced = Object.keys(MODEL_RATES).filter((id) => participantRate(id) !== undefined);
+    return `caps sets a spend cap (maxUsd or maxTotalUsd), but humanish has no rate for model "${model}", so it cannot enforce the cap and refuses to start. Priced models: ${priced.sort().join(", ")}. Use one of them, or remove maxUsd and maxTotalUsd to run without a cap.`;
+}
+/** A participant model's rate; undefined for a model without one or priced for analysis only. */
+export function participantRate(model) {
+    const rate = MODEL_RATES[model.trim().toLowerCase()];
+    return rate?.analysisOnly ? undefined : rate;
 }
 export const DESKTOP_RATE = {
     usdPerMinute: 0.00888,
@@ -204,7 +240,17 @@ export function estimateAggregatedTurnCost(tokenUsage, modelId) {
         ? estimate
         : { ...estimate, basis: "aggregated_turns_base_rate" };
 }
-export function estimateActorCost(tokenUsage, modelId, rates = MODEL_RATES) {
+/** A model's rates on the day of `at` (UTC), or undefined when the table has none. Lookup is
+ *  case-insensitive on a trimmed id. */
+export function modelRate(modelId, at = new Date(), rates = MODEL_RATES) {
+    const rate = rates[modelId.trim().toLowerCase()];
+    if (rate?.until === undefined || at.toISOString().slice(0, 10) <= rate.until)
+        return rate;
+    const { until: _until, after, cachedInputUsdPerToken: _cached, ...rest } = rate;
+    // Past its last day with no published successor, the entry no longer prices anything.
+    return after === undefined ? undefined : { ...rest, ...after };
+}
+export function estimateActorCost(tokenUsage, modelId, rates = MODEL_RATES, at = new Date()) {
     if (!tokenUsage || (tokenUsage.input === undefined && tokenUsage.output === undefined)) {
         return {
             schema: ACTOR_ESTIMATED_COST_SCHEMA,
@@ -213,7 +259,7 @@ export function estimateActorCost(tokenUsage, modelId, rates = MODEL_RATES) {
             ratesAsOf: null,
         };
     }
-    const rate = modelId ? rates[modelId.trim().toLowerCase()] : undefined;
+    const rate = modelId ? modelRate(modelId, at, rates) : undefined;
     if (!rate) {
         return {
             schema: ACTOR_ESTIMATED_COST_SCHEMA,

package/dist/run/process-owner.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A process, as recorded by itself. A pid means nothing outside its host and pid namespace (a
+ * process in a container writing to a bind-mounted checkout has a pid the host cannot see), so a
+ * dead pid is trusted only when both match the reader's own.
+ */
+export interface ProcessOwner {
+    hostname: string;
+    /** `pid:[inode]` from /proc/self/ns/pid, where the platform has one. */
+    pidNamespace?: string;
+    pid: number;
+    /** Start time in clock ticks since boot (/proc/<pid>/stat), which tells a reused pid apart. */
+    startTicks?: string;
+}
+/** This process, as an owner record names it. */
+export declare function currentProcessOwner(): ProcessOwner;
+/** The owner fields of a parsed record, or undefined when `hostname` or `pid` is missing. */
+export declare function processOwnerOf(value: Record<string, unknown>): ProcessOwner | undefined;
+/**
+ * Whether `owner` is gone: it ran in this host and pid namespace, and its pid is free or now
+ * belongs to a process that started at another time. Otherwise the reason says why it may still
+ * be running.
+ */
+export declare function processOwnerGone(owner: ProcessOwner): {
+    gone: true;
+} | {
+    gone: false;
+    reason: string;
+};

package/dist/run/process-owner.js

@@ -0,0 +1,83 @@
+// Which process owns a file humanish leaves on disk, and whether that process is still running.
+// `reclaim --preflight` reads it from a probe's journal and the analysis lock from its owner file,
+// so both decide "the owner is gone" by one rule.
+import { existsSync, readFileSync, readlinkSync } from "node:fs";
+import { hostname } from "node:os";
+function ownerContext() {
+    let pidNamespace;
+    try {
+        pidNamespace = readlinkSync("/proc/self/ns/pid");
+    }
+    catch {
+        // No procfs: this platform has no pid namespaces to tell apart.
+    }
+    return { hostname: hostname(), ...(pidNamespace === undefined ? {} : { pidNamespace }) };
+}
+/** The process's start ticks; null when procfs says it is gone; undefined without procfs. */
+function startTicks(pid) {
+    if (!existsSync("/proc/self/stat"))
+        return undefined;
+    try {
+        const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+        // Field 22; the command name before it is parenthesized and may contain spaces.
+        return stat.slice(stat.lastIndexOf(")") + 2).split(" ")[19] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** This process, as an owner record names it. */
+export function currentProcessOwner() {
+    const ticks = startTicks(process.pid);
+    return {
+        ...ownerContext(),
+        pid: process.pid,
+        ...(typeof ticks === "string" ? { startTicks: ticks } : {}),
+    };
+}
+/** The owner fields of a parsed record, or undefined when `hostname` or `pid` is missing. */
+export function processOwnerOf(value) {
+    if (typeof value.hostname !== "string" || typeof value.pid !== "number")
+        return undefined;
+    return {
+        hostname: value.hostname,
+        ...(typeof value.pidNamespace === "string" ? { pidNamespace: value.pidNamespace } : {}),
+        pid: value.pid,
+        ...(typeof value.startTicks === "string" ? { startTicks: value.startTicks } : {}),
+    };
+}
+/**
+ * Whether `owner` is gone: it ran in this host and pid namespace, and its pid is free or now
+ * belongs to a process that started at another time. Otherwise the reason says why it may still
+ * be running.
+ */
+export function processOwnerGone(owner) {
+    const here = ownerContext();
+    if (owner.hostname !== here.hostname || owner.pidNamespace !== here.pidNamespace)
+        return {
+            gone: false,
+            reason: `it was opened on host ${owner.hostname} in another host or pid namespace, where this process cannot see whether it is still running`,
+        };
+    const running = `process ${owner.pid} is still running`;
+    if (owner.pid === process.pid)
+        return { gone: false, reason: running };
+    const ticks = startTicks(owner.pid);
+    if (ticks === null)
+        return { gone: true };
+    if (typeof ticks === "string") {
+        // The pid now belongs to a different process: the owner is gone.
+        return owner.startTicks !== undefined && ticks !== owner.startTicks
+            ? { gone: true }
+            : { gone: false, reason: running };
+    }
+    try {
+        process.kill(owner.pid, 0);
+        return { gone: false, reason: running };
+    }
+    catch (error) {
+        // EPERM: the process exists but belongs to someone else.
+        return error.code === "EPERM"
+            ? { gone: false, reason: running }
+            : { gone: true };
+    }
+}

package/dist/run/projection.js

@@ -84,7 +84,7 @@ export function expectationFor(entries, mode) {
         .filter((value) => value !== undefined)
         .sort((a, b) => a - b);
     // A cost is unknown whether it was declared absent (`null`) or never recorded at all
-    // (`undefined`: every fail-closed exit finalized with no outcome). Counting only the first
+    // (`undefined`, as earlier versions left a run closed without a bundle). Counting only the first
     // reports "~$1.20 median · 3 runs" for a sample where two runs were never priced, which claims a
     // denominator the figure does not have.
     const costUnknown = finished.filter((entry) => entry.estimatedCostUsd === null || entry.estimatedCostUsd === undefined).length;

package/dist/run/reclaim.d.ts

@@ -25,6 +25,12 @@ export interface ReclaimResult {
      * route created none for this run. Reclaim then contacts E2B for nothing.
      */
     reason?: NoSandboxReason;
+    /**
+     * True when this reclaim found the run's status.json still `running` with a stale heartbeat and
+     * recorded it `interrupted` (reason `reclaimed`): the process is gone or no longer updating it,
+     * and its sandboxes are being stopped. Absent when it changed nothing.
+     */
+    markedInterrupted?: true;
     warnings: string[];
     error?: {
         code: "HUMANISH_RECLAIM_RUN_NOT_FOUND" | "HUMANISH_RECLAIM_E2B_DEBUG" | "HUMANISH_RECLAIM_MODULE_UNAVAILABLE" | "HUMANISH_RECLAIM_RECEIPTS_UNREADABLE";

package/dist/run/reclaim.js

@@ -12,11 +12,11 @@
 import { e2bAccount, e2bConnection } from "../substrates/e2b/connection.js";
 import { modalAccount } from "../substrates/modal/sandbox.js";
 import { E2B_DEBUG_ENV, e2bDebugMode, loadE2BDesktopModule, } from "../substrates/e2b/sdk.js";
-import { readContainedRegularFile, refusalText, RUN_ARTIFACT_MAX_BYTES, } from "./contained-output.js";
+import { readContainedRegularFile, refusalText, RUN_ARTIFACT_MAX_BYTES, writeContainedOutputFile, } from "./contained-output.js";
 import { discardPreflightJournal, listPreflightJournals, preflightReclaimDecision, } from "./preflight-receipts.js";
 import { readRunJsonIfExists, resolveRunPath, runJsonValue } from "./locate.js";
 import { RUN_BUNDLE_FILE } from "./bundle.js";
-import { RUN_STATUS_FILE } from "./status.js";
+import { classifyRunStatus, isRunStatusRecord, RUN_STATUS_FILE, } from "./status.js";
 import { isRecord } from "./type-guards.js";
 import { isRunOutcome } from "./bundle-shape.js";
 import { parseSandboxOwners, parseSandboxReceipts, SANDBOX_RECEIPTS_ARTIFACT, } from "./sandbox-receipts.js";
@@ -66,6 +66,15 @@ async function reclaimRun(cwd, runInput, locate, hooks) {
             },
         };
     }
+    // A kill by hand, not a check and not the signal handler (whose run is alive and records its
+    // own interrupt): a run whose heartbeat stopped is over once its sandboxes are stopped.
+    const marked = hooks.check !== true &&
+        hooks.creates === undefined &&
+        (await markStaleRunInterrupted(runPaths, Date.now()).catch(() => false));
+    const result = await reclaimLocated(runPaths, base, hooks, warnings);
+    return marked ? { ...result, markedInterrupted: true } : result;
+}
+async function reclaimLocated(runPaths, base, hooks, warnings) {
     const runId = runIdOf(runPaths);
     // The signal handler passes the creates it stopped and decides from what they reported.
     const reason = hooks.creates === undefined ? await recordedNoSandbox(runPaths) : undefined;
@@ -424,3 +433,24 @@ async function reclaimRoot(root, label, hooks, warnings) {
         createsInFlight,
     };
 }
+/**
+ * For `humanish reclaim`, which stops the run's sandboxes: a `running` record whose heartbeat is
+ * stale becomes `interrupted` with reason `reclaimed` and `completedAt` at its last heartbeat. A
+ * fresh record belongs to a live owner and is left alone, as is one that already ended. True when
+ * it wrote one.
+ */
+async function markStaleRunInterrupted(runPaths, nowMs) {
+    const record = runJsonValue(await readRunJsonIfExists(runPaths, RUN_STATUS_FILE));
+    if (!isRunStatusRecord(record) || record.state !== "running")
+        return false;
+    if (classifyRunStatus(record, nowMs) === "running")
+        return false;
+    const marked = {
+        ...record,
+        state: "interrupted",
+        reason: "reclaimed",
+        completedAt: record.updatedAt,
+    };
+    await writeContainedOutputFile(runPaths, RUN_STATUS_FILE, `${JSON.stringify(marked, null, 2)}\n`, "utf8");
+    return true;
+}

package/dist/run/results.d.ts

@@ -32,7 +32,7 @@ export interface RunResult {
     observer?: ObserverResult;
     warnings: string[];
     error?: {
-        code: "HUMANISH_STUDY_ANALYSIS_INVALID" | "HUMANISH_STUDY_ANALYSIS_UNSUPPORTED" | "HUMANISH_STUDY_TASKS_UNSUPPORTED" | "HUMANISH_STUDY_OPTION_UNSUPPORTED" | "HUMANISH_STUDY_V2_UNSUPPORTED" | "HUMANISH_STUDY_INVALID" | "HUMANISH_STUDY_COMMS_UNSUPPORTED" | "HUMANISH_LIVE_RUN_UNIMPLEMENTED" | "HUMANISH_INVALID_CWD" | "HUMANISH_RUN_ID_IN_USE" | "HUMANISH_INVALID_PARTICIPANT_COUNT" | "HUMANISH_INVALID_PORT" | "HUMANISH_UNSUPPORTED_RERUN_FLAGS" | "HUMANISH_WATCH_OPTION_CONFLICT" | "HUMANISH_WATCH_SAFE_NOT_APPLICABLE" | "HUMANISH_RUN_OPTION_CONFLICT" | "HUMANISH_OBSERVE_OPTION_CONFLICT" | "HUMANISH_STUDY_SCORER_BAD_REF" | "HUMANISH_STUDY_SCORER_NOT_FOUND" | "HUMANISH_STUDY_SCORER_LOAD_FAILED" | "HUMANISH_STUDY_SCORER_NO_HOOKS" | "HUMANISH_STUDY_SCORER_UNSUPPORTED_BACKEND";
+        code: "HUMANISH_STUDY_ANALYSIS_INVALID" | "HUMANISH_STUDY_ANALYSIS_UNSUPPORTED" | "HUMANISH_STUDY_TASKS_UNSUPPORTED" | "HUMANISH_STUDY_OPTION_UNSUPPORTED" | "HUMANISH_STUDY_V2_UNSUPPORTED" | "HUMANISH_STUDY_INVALID" | "HUMANISH_STUDY_COMMS_UNSUPPORTED" | "HUMANISH_LIVE_RUN_UNIMPLEMENTED" | "HUMANISH_INVALID_CWD" | "HUMANISH_RUN_ID_IN_USE" | "HUMANISH_INVALID_PARTICIPANT_COUNT" | "HUMANISH_INVALID_PORT" | "HUMANISH_UNSUPPORTED_RERUN_FLAGS" | "HUMANISH_WATCH_OPTION_CONFLICT" | "HUMANISH_WATCH_SAFE_NOT_APPLICABLE" | "HUMANISH_RUN_OPTION_CONFLICT" | "HUMANISH_OBSERVE_OPTION_CONFLICT" | "HUMANISH_REMOTE_REFUSED" | "HUMANISH_REMOTE_FAILED" | "HUMANISH_STUDY_SCORER_BAD_REF" | "HUMANISH_STUDY_SCORER_NOT_FOUND" | "HUMANISH_STUDY_SCORER_LOAD_FAILED" | "HUMANISH_STUDY_SCORER_NO_HOOKS" | "HUMANISH_STUDY_SCORER_UNSUPPORTED_BACKEND";
         message: string;
     };
 }

package/dist/run/route-shell.js

@@ -30,7 +30,7 @@ export async function admitRoute(shell) {
             // The scorer joins the input only; whatever the checks admitted stays what the run uses.
             const input = shell.withScorer?.(shell.input, scorer) ?? shell.input;
             const run = async () => {
-                const { result, finished } = await runScope((scope) => shell.runInScope(admitted, input, scope));
+                const { result, finished } = await runScope((scope) => shell.runInScope(admitted, input, scope), { onStart: (runId) => input.emit?.({ type: "run-started", runId }) });
                 return complete(input, result, finished);
             };
             return routeOutcome(shell.route, await (shell.commsSecrets ? withTransientCommsSecrets(run) : run()));

package/dist/run/run-cost.d.ts

@@ -1,6 +1,7 @@
 import type { RunCostSummary } from "./bundle.js";
 import type { AnalysisAccounting } from "./costs.js";
 import type { RunIndexEntry } from "./run-index.js";
+import type { AnalysisProviderName } from "../analysis/types.js";
 /** The fields of run.json's `cost` that the run cost reads. Completeness is unknown when absent. */
 export type RunCostSubtotal = Pick<RunCostSummary, "estimatedTotalUsd"> & Partial<Pick<RunCostSummary, "fullyEstimated" | "ratesAsOf" | "placeholder">>;
 /** A run's analysis spend, every attempt counted once, as `readAnalysisAccounting` reads it. */
@@ -12,7 +13,7 @@ export interface RunAnalysisCost {
     /** True when every request has a complete price and the history was read whole. */
     complete: boolean;
     /** Who billed the requests that recorded usage. */
-    providers: Array<"openai" | "codex">;
+    providers: AnalysisProviderName[];
 }
 /** Complete, a lower bound, or unknown (`null`) when only the subtotal's dollars are at hand. */
 type Completeness = boolean | null;

package/dist/run/run-cost.js

@@ -77,8 +77,13 @@ function estimateText(usd, complete) {
 function analysesNoun(requests) {
     return requests === 1 ? "analysis" : `${requests} analyses`;
 }
+const BILLED_BY = {
+    openai: "OpenAI API key",
+    gemini: "Gemini API key",
+    codex: "Codex account",
+};
 function billedBy(providers) {
-    const names = providers.map((provider) => provider === "openai" ? "OpenAI API key" : "Codex account");
+    const names = providers.map((provider) => BILLED_BY[provider]);
     return names.length === 0 ? "" : ` (${names.join(" and ")})`;
 }
 /**

package/dist/run/run-index.d.ts

@@ -1,6 +1,6 @@
 import { AnalysisCostCache } from "./run-index-analysis.js";
 import type { RunAnalysisCost } from "./run-cost.js";
-import { type RunLiveness } from "./status.js";
+import { type RunAnalysisPhase, type RunLiveness } from "./status.js";
 import { type RunStudyProvenance } from "./study-provenance.js";
 import type { ExecutionFailure } from "./judge.js";
 declare const RUN_INDEX_SCHEMA = "humanish.run-index.v1";
@@ -42,6 +42,8 @@ export interface RunIndexEntry {
     analysisCost?: RunAnalysisCost;
     /** Wall-clock span when both ends are known; used for per-study medians. */
     durationMs?: number;
+    /** The automatic analysis the run's own process started after the run ended, from status.json. */
+    analysis?: RunAnalysisPhase;
 }
 export interface RunIndexResult {
     schema: typeof RUN_INDEX_SCHEMA;

package/dist/run/run-index.js

@@ -5,7 +5,7 @@ import { readdir, readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { runLiveness } from "./liveness.js";
 import { AnalysisCostCache, readIndexedAnalysisCost } from "./run-index-analysis.js";
-import { RUN_STATUS_FILE, classifyRunStatus, isRunStatusRecord, } from "./status.js";
+import { RUN_STATUS_FILE, classifyRunStatus, isRunStatusRecord, runAnalysisPhase, } from "./status.js";
 import { studyProvenanceOf } from "./study-provenance.js";
 import { RUN_BUNDLE_FILE } from "./bundle.js";
 import { isRunOutcome } from "./bundle-shape.js";
@@ -63,6 +63,7 @@ async function readJson(file) {
 function entryFromStatus(record, nowMs) {
     const started = Date.parse(record.startedAt);
     const ended = record.completedAt === undefined ? Number.NaN : Date.parse(record.completedAt);
+    const analysis = runAnalysisPhase(record, nowMs);
     return {
         runId: record.runId,
         derivedFrom: "status",
@@ -88,6 +89,7 @@ function entryFromStatus(record, nowMs) {
             ? { estimatedCostComplete: record.outcome.estimatedCostComplete }
             : {}),
         ...(Number.isFinite(started) && Number.isFinite(ended) ? { durationMs: ended - started } : {}),
+        ...(analysis === undefined ? {} : { analysis }),
     };
 }
 /** A status record this run can be classified from: well formed and naming this run. */
@@ -168,16 +170,8 @@ async function readEntry(runId, runDir, cache, nowMs) {
     const [statusKey, bundleKey] = await Promise.all([statKey(statusFile), statKey(bundleFile)]);
     const key = JSON.stringify([statusKey, bundleKey]);
     const cached = cache?.get(runId, key);
-    if (cached !== undefined) {
-        return cached.derivedFrom === "status" &&
-            cached.updatedAt !== undefined &&
-            cached.completedAt === undefined
-            ? {
-                ...cached,
-                liveness: classifyRunStatus({ state: "running", updatedAt: cached.updatedAt }, nowMs),
-            }
-            : cached;
-    }
+    if (cached !== undefined)
+        return withCurrentLiveness(cached, nowMs);
     const [status, raw] = await Promise.all([
         statusKey === null ? undefined : readJson(statusFile),
         bundleKey === null ? undefined : readJson(bundleFile),
@@ -196,6 +190,7 @@ async function readEntry(runId, runDir, cache, nowMs) {
                     updatedAt: metadata.updatedAt,
                     ...(metadata.completedAt === undefined ? {} : { completedAt: metadata.completedAt }),
                     ...(metadata.durationMs === undefined ? {} : { durationMs: metadata.durationMs }),
+                    ...(metadata.analysis === undefined ? {} : { analysis: metadata.analysis }),
                     ...studyEntry(metadata.study),
                 }),
             ...entryFromBundle(runId, bundle),
@@ -216,6 +211,23 @@ async function readEntry(runId, runDir, cache, nowMs) {
     cache?.set(runId, key, entry);
     return entry;
 }
+/**
+ * A cached entry read again at `nowMs`. Its file has not changed, but a live run or a running
+ * analysis goes stale with time alone, so both are classified again from the cached heartbeat.
+ */
+function withCurrentLiveness(cached, nowMs) {
+    if (cached.updatedAt === undefined)
+        return cached;
+    if (cached.derivedFrom === "status" && cached.completedAt === undefined)
+        return {
+            ...cached,
+            liveness: classifyRunStatus({ state: "running", updatedAt: cached.updatedAt }, nowMs),
+        };
+    if (cached.analysis === undefined || cached.analysis.state === "ended")
+        return cached;
+    const analysis = runAnalysisPhase({ updatedAt: cached.updatedAt, analysis: { startedAt: cached.analysis.startedAt } }, nowMs);
+    return analysis === undefined ? cached : { ...cached, analysis };
+}
 /** Newest-first ordering: the most recent thing known about a run, else its id's own timestamp. */
 function sortKey(entry) {
     for (const candidate of [entry.completedAt, entry.updatedAt, entry.startedAt]) {