humanish 0.88.1 → 0.89.0

package/dist/run.d.ts

@@ -646,6 +646,20 @@ export interface SharedWorldTurn {
     seedDigest: string;
 }
 export type SharedWorldTimelineEntry = SharedWorldCheckpoint | SharedWorldTurn;
+/** Declared seats that were never started after one executed sequential role stopped the run.
+ * The executed timeline plus this ordered tail must account for every declared sim/stream. */
+export interface SharedWorldSkippedTail {
+    afterRoleId: string;
+    roles: Array<{
+        roleId: string;
+        simId: string;
+        streamId: string;
+    }>;
+    cause: "harness_error" | "session_error" | "usage_unreported" | "study_spend_limit";
+    /** Present only for a measured aggregate threshold; estimates, not provider billing. */
+    maxTotalUsd?: number;
+    estimatedTotalUsd?: number;
+}
 /**
  * The shared-world evidence block (`humanish.shared-world.v1`). TWO variants discriminated by
  * `topologyMode` (FIX-8 — renamed off `RunBundle.mode` to avoid the dry-run|live collision):
@@ -690,6 +704,8 @@ export interface SharedWorldEvidence {
     /** The role ids that actually took a turn, in declared order. */
     sequence?: string[];
     timeline?: SharedWorldTimelineEntry[];
+    /** Explicit unstarted suffix; absent on historical/full-execution bundles. */
+    skippedTail?: SharedWorldSkippedTail;
     /** Per-actor harness-clocked windows (overlap proves simultaneity). */
     laneWindows?: SharedWorldLaneWindow[];
     /** Cadence digests of the shared world under load (baseline + periodic + final). */
@@ -1055,6 +1071,8 @@ export interface RunResult {
 export interface VerifyResult {
     schema: typeof VERIFY_SCHEMA;
     ok: boolean;
+    /** Only present when source evidence verifies but derived analysis failed the public-safety scan. */
+    recordingOk?: boolean;
     cwd: string;
     run: string;
     bundlePath?: string;
@@ -1066,7 +1084,7 @@ export interface VerifyResult {
     shareSafety: {
         status: "share_ready" | "local_only" | "blocked";
         reasons: Array<{
-            code: "VERIFY_FAILED" | "PUBLIC_SAFETY_FINDINGS" | "RAW_SCREENSHOTS";
+            code: "VERIFY_FAILED" | "PUBLIC_SAFETY_FINDINGS" | "ANALYSIS_UNVERIFIED" | "RAW_SCREENSHOTS";
             message: string;
         }>;
     };

package/dist/run.js

@@ -22,6 +22,8 @@ import { screenshotEvidenceError } from "./image-evidence.js";
 import { buildObserverData } from "./observer-data.js";
 import { parseResolvedPersona, personaToDirectives, renderPersonaPromptSection } from "./persona.js";
 import { round6 } from "./pricing.js";
+import { loadStudyAnalysis, listStudyAnalysisExecutions } from "./study-analysis-store.js";
+import { isStudyAnalysisRecordPath, studyAnalysisSharingProblems } from "./study-analysis-sharing.js";
 import { containsSensitive, digestText, redactText, redactToSecretLabel, tailText } from "./redaction.js";
 import { bindExistingRunArtifactPaths, RUNS_RELATIVE_ROOT, isSafeRunIdSegment, prepareRunArtifactPaths, resolveExistingRunDirectory, resolveLatestRunDirectory, resolveRunsRoot, validatePreparedRunArtifactPaths } from "./run-paths.js";
 import { probeKeySources } from "./key-resolution.js";
@@ -2612,7 +2614,13 @@ async function verifyPreparedRun(cwd, runInput, runPaths) {
         ok: reviewJson !== null && reviewMarkdown !== null,
         message: "review.json and review.md must exist"
     });
-    const publicSafetyFindings = await scanRunPublicSafetyArtifacts(runPaths);
+    const derivedPublicSafetyFindings = [];
+    const publicSafetyFindings = await scanRunPublicSafetyArtifacts(runPaths, derivedPublicSafetyFindings);
+    // JSON escapes can hide a sensitive value from the byte scan while the
+    // decoded recording exposes it to Observer, feedback, or analysis input.
+    if (publicSafetyFindings.length < 50 && bundle !== null && containsSensitivePattern(JSON.stringify(bundle))) {
+        publicSafetyFindings.push("sensitive decoded run.json");
+    }
     checks.push({
         name: "public-safety scan",
         ok: publicSafetyFindings.length === 0,
@@ -2716,6 +2724,10 @@ async function verifyPreparedRun(cwd, runInput, runPaths) {
             ? "cost figures are absent, or every claimed estimate carries its ratesAsOf date + source and the total matches its known lines (estimates never presented as exact)"
             : `cost labeling findings: ${costFindings.join(", ")}`
     });
+    const recordingOk = checks.every((check) => check.ok);
+    if (derivedPublicSafetyFindings.length > 0)
+        checks.push({ name: "derived analysis public-safety scan", ok: false,
+            message: "Derived analysis contains sensitive text or unsafe artifact paths; sharing is blocked, original recording remains independently verifiable." });
     const ok = checks.every((check) => check.ok);
     const warnings = isRunBundle(bundle)
         ? [...rawScreenshotPostureWarnings(bundle), ...undeclaredSubjectStateWarnings(bundle), ...desktopGeometryWarnings(bundle)]
@@ -2731,9 +2743,23 @@ async function verifyPreparedRun(cwd, runInput, runPaths) {
                 }
             ]
         };
+    // Interpretation validity is independent of run validity. Keep recordings usable,
+    // while refusing to silently promote stale or malformed derived text into sharing.
+    const analysis = await loadStudyAnalysis(runPaths);
+    const analysisSharing = studyAnalysisSharingProblems(analysis);
+    const executionHistory = await listStudyAnalysisExecutions(runPaths);
+    if (analysisSharing.unverified || analysisSharing.sensitive || executionHistory.warnings.length > 0) {
+        warnings.push("Some study analysis or correction records could not be validated against current evidence.");
+        shareSafety.reasons.push({ code: "ANALYSIS_UNVERIFIED", message: "Derived analysis or corrections need review against the current evidence before sharing." });
+        if (analysisSharing.sensitive)
+            shareSafety.status = "blocked";
+        else if (shareSafety.status === "share_ready")
+            shareSafety.status = "local_only";
+    }
     return {
         schema: VERIFY_SCHEMA,
         ok,
+        ...(!ok && recordingOk ? { recordingOk: true } : {}),
         cwd,
         run: runInput,
         bundlePath: path.relative(cwd, bundlePath),
@@ -4414,7 +4440,7 @@ const SHARED_WORLD_STATESERIES_KEYS = new Set(["timestamp", "digest"]);
  */
 function sharedWorldEvidenceFindings(bundle) {
     if (bundle.mode !== "live") {
-        return [];
+        return bundle.sharedWorld?.skippedTail === undefined ? [] : ["skippedTail requires a live executed interruption"];
     }
     const sw = bundle.sharedWorld;
     if (!sw) {
@@ -4426,6 +4452,9 @@ function sharedWorldEvidenceFindings(bundle) {
     }
     // FIX-8: dispatch on topologyMode FIRST; unknown/missing → fail closed.
     const topologyMode = sw.topologyMode;
+    if (topologyMode !== "sequential" && sw.skippedTail !== undefined) {
+        return ["skippedTail is only valid on sequential shared-world evidence"];
+    }
     if (topologyMode === "sequential") {
         return sequentialSharedWorldFindings(bundle, sw);
     }
@@ -4457,6 +4486,95 @@ function sharedWorldCommonFindings(bundle, sw) {
     }
     return findings;
 }
+/** Validate the declared suffix against the executed prefix and existing participant evidence. */
+function sequentialSkippedTailFindings(bundle, sw, sequence, turns) {
+    const failures = [];
+    const reject = (message) => { failures.push(`skippedTail: ${message}`); };
+    const tail = sw.skippedTail;
+    if (!isRecord(tail) || !Array.isArray(tail.roles) || tail.roles.length === 0 || !tail.roles.every(isRecord)) {
+        return ["skippedTail: a nonempty declared role suffix is required"];
+    }
+    const roster = [...turns, ...tail.roles];
+    if (!Number.isSafeInteger(sw.roleCount) || sw.roleCount < 1
+        || roster.length !== sw.roleCount || bundle.simCount !== sw.roleCount
+        || bundle.simulations.length !== sw.roleCount || bundle.streams.length !== sw.roleCount
+        || sequence.length !== turns.length || turns.length === 0) {
+        reject("executed prefix and blocked suffix must account for every declared simulation and stream");
+    }
+    for (const key of ["roleId", "simId", "streamId"]) {
+        const ids = roster.map(role => role[key]);
+        if (ids.some(id => typeof id !== "string" || id.length === 0) || new Set(ids).size !== ids.length) {
+            reject(`declared ${key} values must be nonempty and unique`);
+        }
+    }
+    if (tail.afterRoleId !== sequence.at(-1) || tail.afterRoleId !== turns.at(-1)?.roleId) {
+        reject("blocker must be the immediately preceding executed role");
+    }
+    if (bundle.review.verdict === "pass")
+        reject("blocked participants cannot accompany a passed run review");
+    roster.forEach((role, index) => {
+        const sim = bundle.simulations[index], stream = bundle.streams[index];
+        if (!sim || !stream || sim.index !== index + 1 || role.simId !== sim.id || role.streamId !== stream.id
+            || stream.simId !== sim.id || sim.streamIds.length !== 1 || sim.streamIds[0] !== stream.id) {
+            reject("ordered role, simulation and stream identities must agree");
+            return;
+        }
+        const roleEvents = bundle.events.filter(event => event.simId === sim.id && event.streamId === stream.id);
+        if (index < turns.length) {
+            if (!stream.actor && !roleEvents.some(event => event.type === "shared-world.session.error")) {
+                reject("an executed role needs an actor or an explicit attempted-session error");
+            }
+            return;
+        }
+        if (sim.status !== "blocked" || stream.status !== "blocked"
+            || stream.actor !== undefined || stream.liveActor !== undefined || stream.embed?.kind !== "placeholder"
+            || stream.ui?.actorStatus !== undefined || stream.ui?.screenshotUrl !== undefined
+            || stream.artifacts.some(artifact => artifact.kind === "trace" || artifact.kind === "screenshot")
+            || typeof sim.currentStep !== "string" || sim.currentStep.length === 0 || stream.ui?.state !== sim.currentStep) {
+            reject("an unstarted role must be blocked with a reason and no actor, trace or screenshot");
+        }
+        const sessionEvents = roleEvents.filter(event => event.type.startsWith("shared-world.session."));
+        if (sessionEvents.length !== 1 || sessionEvents[0]?.type !== "shared-world.session.blocked") {
+            reject("each unstarted role needs exactly one blocked session event");
+        }
+    });
+    const predecessor = bundle.streams[turns.length - 1];
+    const actor = predecessor?.actor;
+    if (tail.cause === "session_error") {
+        if (!predecessor || !bundle.events.some(event => event.type === "shared-world.session.error"
+            && event.simId === predecessor.simId && event.streamId === predecessor.id)) {
+            reject("session_error requires the predecessor's explicit orchestration error");
+        }
+    }
+    else if (tail.cause === "harness_error") {
+        if (actor?.completionReason !== "harness_error")
+            reject("harness_error must match the predecessor actor");
+    }
+    else if (tail.cause === "usage_unreported") {
+        if (!actor || !(actor.interactionUsageIncomplete === true || actor.debrief?.usageReported === false
+            || actor.estimatedCost?.estimatedCostUsd === null))
+            reject("usage_unreported requires recorded unavailable usage");
+    }
+    else if (tail.cause === "study_spend_limit") {
+        const estimates = bundle.streams.slice(0, turns.length).map(stream => stream.actor?.estimatedCost?.estimatedCostUsd);
+        const allKnown = estimates.every(value => typeof value === "number" && Number.isFinite(value) && value >= 0)
+            && bundle.streams.slice(0, turns.length).every(stream => stream.actor?.interactionUsageIncomplete !== true
+                && stream.actor?.debrief?.usageReported !== false);
+        const sum = estimates.reduce((total, value) => total + (value ?? 0), 0);
+        if (!allKnown || typeof tail.maxTotalUsd !== "number" || !Number.isFinite(tail.maxTotalUsd) || tail.maxTotalUsd < 0
+            || typeof tail.estimatedTotalUsd !== "number" || !Number.isFinite(tail.estimatedTotalUsd)
+            || tail.estimatedTotalUsd !== sum || !(sum > tail.maxTotalUsd)) {
+            reject("study_spend_limit requires known prefix estimates exceeding the recorded finite threshold");
+        }
+    }
+    else {
+        reject("a supported typed interruption cause is required");
+    }
+    if (tail.cause !== "study_spend_limit" && (tail.maxTotalUsd !== undefined || tail.estimatedTotalUsd !== undefined)) {
+        reject("budget figures require a measured study_spend_limit cause");
+    }
+    return failures;
+}
 /**
  * SEQUENTIAL branch (the PoC #164): the alternating timeline must be well-formed, single-plane,
  * digest-only, and carry the sequential attributionLimits. FIX-8: a sequential bundle must NOT
@@ -4485,8 +4603,12 @@ function sequentialSharedWorldFindings(bundle, sw) {
     }
     const checkpoints = rawTimeline.filter((entry) => isRecord(entry) && entry.kind === "checkpoint");
     const turns = rawTimeline.filter((entry) => isRecord(entry) && entry.kind === "turn");
-    // Phantom/dropped role: sequence length == roleCount == executed-turn count.
-    if (!(sequence.length === sw.roleCount && turns.length === sw.roleCount)) {
+    // Historical full-execution bundles keep the original equality rule. A shorter executed
+    // prefix requires explicit blocked-tail evidence, never an inference from absent actors.
+    if (sw.skippedTail !== undefined) {
+        findings.push(...sequentialSkippedTailFindings(bundle, sw, sequence, turns));
+    }
+    else if (!(sequence.length === sw.roleCount && turns.length === sw.roleCount)) {
         findings.push(`phantom/dropped role: sequence length (${sequence.length}), roleCount (${sw.roleCount}), and timeline turn count (${turns.length}) must all match`);
     }
     // Timeline well-formed: starts with cp-baseline, strictly alternates checkpoint → turn →
@@ -4517,6 +4639,12 @@ function sequentialSharedWorldFindings(bundle, sw) {
         if (turn.roleId !== sequence[index]) {
             findings.push(`turn order does not match the declared sequence at position ${index} (turn "${String(turn.roleId)}" vs sequence "${String(sequence[index])}")`);
         }
+        if (sw.skippedTail !== undefined) {
+            const checkpoint = rawTimeline[index * 2 + 2];
+            if (!isRecord(checkpoint) || checkpoint.name !== `cp-after-${String(turn.roleId)}`) {
+                findings.push("skippedTail: each after-checkpoint must belong to its executed role, never an unstarted seat");
+            }
+        }
     });
     // Checkpoints: digest is sha256-16 and the record carries NO value-shaped field (digest-only).
     for (const checkpoint of checkpoints) {
@@ -4938,15 +5066,17 @@ const riskyPublicArtifactPathSegments = new Set([
     "Secure Preferences",
     "profiles"
 ]);
-async function scanRunPublicSafetyArtifacts(runPaths) {
+async function scanRunPublicSafetyArtifacts(runPaths, derivedFindings) {
     const findings = [];
     await validatePreparedRunArtifactPaths(runPaths);
-    await scanRunPublicSafetyDirectory(runPaths, "", findings);
+    await scanRunPublicSafetyDirectory(runPaths, "", findings, derivedFindings);
     await validatePreparedRunArtifactPaths(runPaths);
     return findings;
 }
-async function scanRunPublicSafetyDirectory(runPaths, relativeDirectory, findings) {
-    if (findings.length >= 50) {
+async function scanRunPublicSafetyDirectory(runPaths, relativeDirectory, findings, derivedFindings) {
+    // Each authority has its own finding budget. Derived files must never consume
+    // the source scan's budget and make an unscanned recording appear verified.
+    if (findings.length >= 50 && derivedFindings.length >= 50) {
         return;
     }
     const current = relativeDirectory
@@ -4955,33 +5085,33 @@ async function scanRunPublicSafetyDirectory(runPaths, relativeDirectory, finding
     const entries = await readdir(current).catch(() => []);
     for (const entryName of entries) {
         const relativePath = relativeDirectory ? `${relativeDirectory}/${entryName}` : entryName;
+        const stats = await lstat(path.join(current, entryName), { bigint: true }).catch(() => null);
+        const selectedFindings = !stats?.isDirectory()
+            && (relativePath === "observer/study-analysis.json" || isStudyAnalysisRecordPath(relativePath)) ? derivedFindings : findings;
         if (isRiskyPublicArtifactPath(relativePath) || containsSensitivePattern(relativePath)) {
-            findings.push(`risky artifact path ${relativePath}`);
-            if (findings.length >= 50)
-                return;
+            if (selectedFindings.length < 50)
+                selectedFindings.push(`risky artifact path ${relativePath}`);
         }
-        const stats = await lstat(path.join(current, entryName), { bigint: true }).catch(() => null);
         if (!stats || stats.isSymbolicLink() || (!stats.isDirectory() && !stats.isFile()) || (stats.isFile() && stats.nlink > 1n)) {
-            findings.push(`unsafe artifact leaf ${relativePath}`);
-            if (findings.length >= 50)
-                return;
+            if (selectedFindings.length < 50)
+                selectedFindings.push(`unsafe artifact leaf ${relativePath}`);
             continue;
         }
         if (stats.isDirectory()) {
-            await scanRunPublicSafetyDirectory(runPaths, relativePath, findings);
-            if (findings.length >= 50)
-                return;
+            // A directory named analysis.json is not an owned record. Its children
+            // can contain source evidence even after derived findings are saturated.
+            await scanRunPublicSafetyDirectory(runPaths, relativePath, findings, derivedFindings);
             continue;
         }
+        if (selectedFindings.length >= 50)
+            continue;
         if (!shouldScanTextArtifact(relativePath)) {
             continue;
         }
         const bytes = await readSafeRunArtifactBytes(runPaths, relativePath);
         const text = bytes?.toString("utf8") ?? null;
         if (text !== null && containsSensitivePattern(text)) {
-            findings.push(`sensitive text ${relativePath}`);
-            if (findings.length >= 50)
-                return;
+            selectedFindings.push(`sensitive text ${relativePath}`);
         }
     }
 }