@pome-sh/cli 0.19.0 → 0.21.0

package/dist/src/hosted/uploadAndFinalize.d.ts

@@ -1,85 +0,0 @@
-import type { HostedClient } from "./client.js";
-import type { FinalizeResponse, PerTwinStateKeys } from "../types/shared.js";
-import type { Score } from "./evalResultView.js";
-/** The narrow client surface the upload orchestration needs. `pome eval`
- *  mocks exactly this in tests instead of the full HostedClient. */
-export type UploadClient = Pick<HostedClient, "requestEventsUploadUrl" | "requestStateUploadUrl" | "requestSignalsUploadUrl" | "requestMetaUploadUrl">;
-export interface RunBlobs {
-    eventsJsonl: string;
-    stateInitialJson: string;
-    stateFinalJson: string;
-    /** Pre-redacted JSONL. Empty / whitespace-only skips the signals upload
-     *  entirely so cloud doesn't allocate storage for "{}" payloads (F0-4 / L7). */
-    signalsJsonl: string;
-    /** D18.1 — the run's meta.json (spec_version + twin_versions + the rest of
-     *  writeRunArtifactsCore's payload), as written to / read from disk. */
-    metaJson: string;
-    /** Multi-twin (M3): the session's twins. When >1, per-twin state upload URLs
-     *  are requested and each twin's state blobs are uploaded under its own
-     *  storage prefix. Absent / length ≤1 keeps the single-twin path unchanged. */
-    twins?: string[];
-    /** Multi-twin (M3): per-twin initial/final state JSON, keyed by twin id.
-     *  Includes the primary twin (whose blobs also go to the legacy top-level
-     *  pair). Only consumed when `twins.length > 1` and the cloud returns a
-     *  `per_twin` upload block. */
-    perTwinState?: Record<string, {
-        initialJson: string;
-        finalJson: string;
-    }>;
-}
-export interface UploadedBlobKeys {
-    eventsKey: string | null;
-    stateInitialKey: string | null;
-    stateFinalKey: string | null;
-    signalsKey: string | null;
-    /** Multi-twin (M3): per-twin state storage keys, keyed by twin id. Each entry
-     *  carries at least one uploaded key (empty entries are dropped so the
-     *  finalize contract's ">=1 key per entry" invariant holds). Undefined when
-     *  the session is single-twin or the cloud returned no `per_twin` block. */
-    perTwinStateKeys?: PerTwinStateKeys;
-    /** D18.1 — the storage key the presigned PUT landed at, or null whenever
-     *  the upload didn't happen, INCLUDING the feature-detection case (older
-     *  control plane 404s meta-upload-url). Never distinguished from any other
-     *  failure — same best-effort contract as every other blob here.
-     *
-     *  NOT threaded onto /finalize (unlike the state / signals keys): the cloud
-     *  contract auto-discovers meta.json by the conventional session-prefixed
-     *  path — see uploadRunBlobs and uploadMeta below. Returned only so callers
-     *  and tests can observe whether the upload happened. */
-    metaKey: string | null;
-}
-/**
- * Upload events.jsonl + state blobs + adapter signals.jsonl to cloud storage
- * in parallel. /finalize defaults the trace storage key to the conventional
- * `team-<>/session-<>/events.jsonl` path, so cloud's judge finds the trace
- * without an explicit override. State blobs and signals have no conventional
- * fallback today — without an explicit override the judge sees "{}" for
- * state files (FDRS-395) and skips the adapter-rich correlator (F0-4 / L7).
- * meta.json (D18.1/D18.6) DOES have a conventional fallback: cloud finalize
- * auto-discovers it at `team-<>/session-<>/meta.json`, so its key is uploaded
- * to that path and never threaded onto /finalize (see uploadMeta below).
- * All four uploads are best-effort: any failure leaves the corresponding
- * blob missing (`null` key), the judge still runs against whatever it does
- * have, and the dashboard handles nulls gracefully.
- */
-export declare function uploadRunBlobs(client: UploadClient, sessionId: string, blobs: RunBlobs): Promise<UploadedBlobKeys>;
-/**
- * Synthesize a Score shape backed by the cloud-authoritative satisfaction.
- * F0-3 / L5 — Session A added `criteria_results[]` to /finalize so the CLI
- * can render per-criterion verdicts on hosted runs (`pome inspect`,
- * `pome fix-prompt`) without a follow-up cloud round-trip. Older cloud
- * builds (pre-Session A) omit the field; default to an empty array — the
- * fix-prompt action still bails cleanly when results are missing.
- *
- * A1 CAVEAT (FDRS-618): `satisfaction` here is the CLOUD-authoritative
- * score (`finalized.score`) — the hosted judge does NOT yet implement the
- * FDRS-591/611 outcome semantics, so `evaluated`/`can_pass` are derived
- * locally only when /finalize returns per-criterion results. Older cloud
- * builds omit `criteria_results`; for those, preserve the cloud score as
- * renderable instead of inventing an empty local A5 verdict.
- */
-export declare function scoreFromFinalizeResponse(finalized: FinalizeResponse): Score;
-/** Redact a JSONL payload line-by-line before upload. Lines that fail to
- *  parse as JSON are redacted as raw strings. Moved verbatim from
- *  runTaskHosted.ts (FDRS-656). */
-export declare function redactJsonl(body: string): string;

package/dist/src/hosted/uploadAndFinalize.js

@@ -1,238 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-//
-// Shared presigned-upload + finalize-score orchestration for cloud sessions
-// (ADR-013). Extracted verbatim from runTaskHosted.ts (FDRS-656) so
-// `pome eval <run-dir>` reuses the exact same best-effort PUT semantics
-// without duplicating them. Behavior-preserving for the hosted run path:
-// warning text, the 30s PUT timeout, and the null-key fallbacks all match
-// the pre-extraction runner.
-import { gzipSync } from "node:zlib";
-import { outcomeOf } from "./evalResultView.js";
-import { redactSecrets } from "../recorder/redaction.js";
-// Gzip EVERY blob before PUT. The storage edge (Cloudflare in front of
-// Supabase) runs a WAF managed rule that 403-blocks any PUT whose plaintext
-// body contains certain literal keys (e.g. an admin-flag key present in slack
-// twin state exports), which silently drops per-twin state uploads and makes
-// their criteria skip as state_missing. Gzipped bodies sail past the rule.
-// One code path here so every caller (events, per-twin state, signals,
-// meta.json) inherits it; the cloud's blob readers transparently gunzip via
-// the content-encoding header (shipped in the paired reader release before
-// this CLI change is released).
-async function putBlob(url, body, contentType, label) {
-    const ctrl = new AbortController();
-    const timer = setTimeout(() => ctrl.abort(), 30_000);
-    try {
-        const putRes = await fetch(url, {
-            method: "PUT",
-            headers: {
-                "content-type": contentType,
-                "content-encoding": "gzip",
-            },
-            body: gzipSync(Buffer.from(body, "utf8")),
-            signal: ctrl.signal,
-        });
-        if (!putRes.ok) {
-            console.warn(`[pome] ${label} upload PUT ${url} → ${putRes.status}; continuing with key=null`);
-            return false;
-        }
-        return true;
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
-/**
- * Upload events.jsonl + state blobs + adapter signals.jsonl to cloud storage
- * in parallel. /finalize defaults the trace storage key to the conventional
- * `team-<>/session-<>/events.jsonl` path, so cloud's judge finds the trace
- * without an explicit override. State blobs and signals have no conventional
- * fallback today — without an explicit override the judge sees "{}" for
- * state files (FDRS-395) and skips the adapter-rich correlator (F0-4 / L7).
- * meta.json (D18.1/D18.6) DOES have a conventional fallback: cloud finalize
- * auto-discovers it at `team-<>/session-<>/meta.json`, so its key is uploaded
- * to that path and never threaded onto /finalize (see uploadMeta below).
- * All four uploads are best-effort: any failure leaves the corresponding
- * blob missing (`null` key), the judge still runs against whatever it does
- * have, and the dashboard handles nulls gracefully.
- */
-export async function uploadRunBlobs(client, sessionId, blobs) {
-    async function uploadEvents() {
-        try {
-            const upload = await client.requestEventsUploadUrl(sessionId);
-            const ok = await putBlob(upload.url, blobs.eventsJsonl, "application/x-ndjson", "events.jsonl");
-            return ok ? upload.key : null;
-        }
-        catch (err) {
-            console.warn(`[pome] events.jsonl upload skipped (${err instanceof Error ? err.message : String(err)}); continuing with events_jsonl_url=null`);
-            return null;
-        }
-    }
-    // F0-4 / L7 — upload adapter signals if the agent emitted any. When the
-    // payload is empty (no withPome() wrap, or no hooks fired), skip the
-    // upload entirely.
-    async function uploadSignals() {
-        try {
-            if (blobs.signalsJsonl.trim().length === 0) {
-                return null;
-            }
-            const upload = await client.requestSignalsUploadUrl(sessionId);
-            const ok = await putBlob(upload.url, blobs.signalsJsonl, "application/x-ndjson", "signals.jsonl");
-            return ok ? upload.key : null;
-        }
-        catch (err) {
-            console.warn(`[pome] signals.jsonl upload skipped (${err instanceof Error ? err.message : String(err)}); continuing with signals_storage_key=null`);
-            return null;
-        }
-    }
-    async function uploadStates() {
-        const multiTwin = (blobs.twins?.length ?? 0) > 1;
-        try {
-            // Multi-twin (M3): ask for a per-twin URL block; single-twin passes
-            // nothing so the request body stays `{}` (byte-identical to pre-M3).
-            const upload = await client.requestStateUploadUrl(sessionId, multiTwin ? blobs.twins : undefined);
-            // Top-level (primary-twin) pair — always uploaded, legacy state_*_storage_key.
-            const [initialOk, finalOk] = await Promise.all([
-                putBlob(upload.state_initial.url, blobs.stateInitialJson, "application/json", "state_initial.json"),
-                putBlob(upload.state_final.url, blobs.stateFinalJson, "application/json", "state_final.json"),
-            ]);
-            // Multi-twin: upload each twin's blobs to its own storage prefix and
-            // collect the keys. Only when the cloud actually returned a `per_twin`
-            // block (an older cloud omits it → we fall back to the primary-only
-            // top-level keys, degrading gracefully). Entries with no uploaded key are
-            // dropped so the finalize contract's ">=1 key per entry" holds.
-            let perTwinStateKeys;
-            if (multiTwin && upload.per_twin) {
-                const collected = {};
-                for (const twin of blobs.twins ?? []) {
-                    const pair = upload.per_twin[twin];
-                    const state = blobs.perTwinState?.[twin];
-                    if (!pair || !state)
-                        continue;
-                    const [iOk, fOk] = await Promise.all([
-                        putBlob(pair.state_initial.url, state.initialJson, "application/json", `state_initial.${twin}.json`),
-                        putBlob(pair.state_final.url, state.finalJson, "application/json", `state_final.${twin}.json`),
-                    ]);
-                    const entry = {};
-                    if (iOk)
-                        entry.state_initial_key = pair.state_initial.key;
-                    if (fOk)
-                        entry.state_final_key = pair.state_final.key;
-                    if (entry.state_initial_key !== undefined || entry.state_final_key !== undefined) {
-                        collected[twin] = entry;
-                    }
-                }
-                if (Object.keys(collected).length > 0)
-                    perTwinStateKeys = collected;
-            }
-            return {
-                initialKey: initialOk ? upload.state_initial.key : null,
-                finalKey: finalOk ? upload.state_final.key : null,
-                perTwinStateKeys,
-            };
-        }
-        catch (err) {
-            console.warn(`[pome] state blob upload skipped (${err instanceof Error ? err.message : String(err)}); continuing with state_*_storage_key=null`);
-            return { initialKey: null, finalKey: null };
-        }
-    }
-    // D18.1 / D18.6 — upload meta.json via the presigned route. The mint route
-    // signs the CONVENTIONAL `team-<>/session-<>/meta.json` path, and cloud's
-    // /finalize AUTO-DISCOVERS the blob at that same conventional path (it
-    // downloads it unconditionally when no explicit override is given — see
-    // pome-cloud services/finalize-run.ts, which defaults `metaStorageKey` to
-    // the conventional path). So — unlike the state / signals keys — the
-    // returned meta key is deliberately NOT threaded onto the /finalize body:
-    // uploading to the conventional path is the whole contract. There is no
-    // `meta_storage_key` finalize field to null out.
-    //
-    // FEATURE-DETECT: a control plane that predates
-    // `POST /v1/sessions/:id/meta-upload-url` 404s the mint call, which lands
-    // in this same catch as any other failure — warn and continue. Identical
-    // best-effort shape to the other three uploads; never surfaced to the
-    // caller as distinct from "upload failed".
-    async function uploadMeta() {
-        try {
-            const upload = await client.requestMetaUploadUrl(sessionId);
-            const ok = await putBlob(upload.url, blobs.metaJson, "application/json", "meta.json");
-            return ok ? upload.key : null;
-        }
-        catch (err) {
-            console.warn(`[pome] meta.json upload skipped (${err instanceof Error ? err.message : String(err)}); cloud will finalize without producing-twin metadata for this run`);
-            return null;
-        }
-    }
-    const [eventsKey, stateKeys, signalsKey, metaKey] = await Promise.all([
-        uploadEvents(),
-        uploadStates(),
-        uploadSignals(),
-        uploadMeta(),
-    ]);
-    return {
-        eventsKey,
-        stateInitialKey: stateKeys.initialKey,
-        stateFinalKey: stateKeys.finalKey,
-        perTwinStateKeys: stateKeys.perTwinStateKeys,
-        metaKey,
-        signalsKey,
-    };
-}
-/**
- * Synthesize a Score shape backed by the cloud-authoritative satisfaction.
- * F0-3 / L5 — Session A added `criteria_results[]` to /finalize so the CLI
- * can render per-criterion verdicts on hosted runs (`pome inspect`,
- * `pome fix-prompt`) without a follow-up cloud round-trip. Older cloud
- * builds (pre-Session A) omit the field; default to an empty array — the
- * fix-prompt action still bails cleanly when results are missing.
- *
- * A1 CAVEAT (FDRS-618): `satisfaction` here is the CLOUD-authoritative
- * score (`finalized.score`) — the hosted judge does NOT yet implement the
- * FDRS-591/611 outcome semantics, so `evaluated`/`can_pass` are derived
- * locally only when /finalize returns per-criterion results. Older cloud
- * builds omit `criteria_results`; for those, preserve the cloud score as
- * renderable instead of inventing an empty local A5 verdict.
- */
-export function scoreFromFinalizeResponse(finalized) {
-    const hasCriteriaResults = finalized.criteria_results !== undefined;
-    const results = finalized.criteria_results ?? [];
-    const passed = results.filter((r) => outcomeOf(r) === "passed").length;
-    const failed = results.filter((r) => outcomeOf(r) === "failed").length;
-    const errored = results.filter((r) => outcomeOf(r) === "errored").length;
-    const skipped = results.filter((r) => outcomeOf(r) === "skipped").length;
-    const totalRequired = passed + failed;
-    return {
-        satisfaction: finalized.score,
-        passed,
-        failed,
-        skipped,
-        errored,
-        total_required: totalRequired,
-        evaluated: hasCriteriaResults ? totalRequired > 0 : true,
-        can_pass: hasCriteriaResults
-            ? totalRequired > 0 && skipped === 0 && errored === 0
-            : true,
-        results,
-        judge_model: finalized.judge_model ?? null,
-        judge_tokens_in: null,
-        judge_tokens_out: null,
-    };
-}
-/** Redact a JSONL payload line-by-line before upload. Lines that fail to
- *  parse as JSON are redacted as raw strings. Moved verbatim from
- *  runTaskHosted.ts (FDRS-656). */
-export function redactJsonl(body) {
-    const lines = body.split("\n");
-    const redacted = lines
-        // Whitespace-only lines are dropped (not just empty ones) so validation
-        // (`validateJsonl`, which trims) and upload agree on what counts as a
-        // row — a " " line must never reach cloud as a non-JSON record.
-        .filter((line) => line.trim().length > 0)
-        .map((line) => {
-        try {
-            return JSON.stringify(redactSecrets(JSON.parse(line)));
-        }
-        catch {
-            return redactSecrets(line);
-        }
-    });
-    return redacted.length > 0 ? `${redacted.join("\n")}\n` : "";
-}

package/dist/src/recorder/artifacts.d.ts

@@ -1,34 +0,0 @@
-import { toTwinHttpEventRow } from "@pome-sh/sdk/server";
-import type { Task } from "../task/taskSchema.js";
-import type { RecorderEvent } from "@pome-sh/shared-types";
-export declare const toTwinHttpEvent: typeof toTwinHttpEventRow;
-export type RunArtifacts = {
-    runId: string;
-    runDir: string;
-};
-export type RunArtifactCoreInput = {
-    artifactsDir: string;
-    runId: string;
-    scenario: Task;
-    startedAt: string;
-    completedAt: string;
-    stdout: string;
-    stderr: string;
-    exitCode: number | null;
-    events: RecorderEvent[];
-    stateInitial: unknown;
-    stateFinal: unknown;
-};
-export declare function writeRunArtifactsCore(input: RunArtifactCoreInput): Promise<RunArtifacts>;
-export declare function readLatestRun(artifactsDir: string): Promise<{
-    run_id: string;
-    task: string;
-    run_dir: string;
-} | undefined>;
-export type RunMetaSummary = {
-    run_id?: string;
-    scenario?: string;
-    title?: string;
-    twins: string[];
-};
-export declare function readMetaSummary(runDir: string): Promise<RunMetaSummary>;

package/dist/src/recorder/artifacts.js

@@ -1,153 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { toTwinHttpEventRow } from "@pome-sh/sdk/server";
-import { redactEvent, redactSecrets } from "./redaction.js";
-import { META_SPEC_VERSION, resolveTwinPackageVersions } from "./specMeta.js";
-// FDRS-399 / FDRS-398 — wrap a legacy RecorderEvent into the unified
-// events.jsonl shape. Delegates to twin-core `toTwinHttpEventRow` so durable
-// stream rows and finalize appends stay byte-identical (F-698).
-export const toTwinHttpEvent = toTwinHttpEventRow;
-// FDRS-657 / F-689 — the OSS CLI is CAPTURE-ONLY: it writes raw trace + state
-// artifacts and NEVER a score.json. Local artifacts are trace/audit only; a
-// verdict comes only from the cloud and is printed ephemerally to the
-// terminal (hosted `pome run`, `pome eval`) — never persisted next to the
-// trace. There is no `writeScoreJson`/`readScore` anymore.
-//
-// F-689 remainder (D6) — a completed run dir contains EXACTLY these six
-// files: `meta.json`, `events.jsonl`, `state_initial.json`,
-// `state_final.json`, `stdout.txt`, `stderr.log`. The intermediate
-// correlation artifacts this CLI used to also write (`tool_calls.jsonl`,
-// `state-before.json`, `state-after.json`, `state-diff.json`) were deleted —
-// they duplicated `events.jsonl`/`state_*.json` and existed only to feed the
-// local correlator/evaluator, which no longer runs here. `stdout.txt` and
-// `stderr.log` are NOT part of the trace contract cloud judges against; they
-// are non-trace debug sidecars — raw agent-process output, kept only so a
-// human (or `pome inspect`) can read what the agent printed when a run needs
-// forensics.
-export async function writeRunArtifactsCore(input) {
-    const runDir = join(input.artifactsDir, input.scenario.slug, input.runId);
-    await mkdir(runDir, { recursive: true });
-    await writeJson(join(runDir, "meta.json"), {
-        run_id: input.runId,
-        scenario: input.scenario.slug,
-        title: input.scenario.title,
-        started_at: input.startedAt,
-        completed_at: input.completedAt,
-        exit_code: input.exitCode,
-        twins: input.scenario.config.twins,
-        // D18.1 — the meta.json contract half: spec_version lets cloud's ingest
-        // (a parallel PR) validate the shape it's parsing; twin_versions lets it
-        // attribute the captured behavior to the exact twin build that produced
-        // it. Both additive — an older CLI's meta.json simply omits them.
-        spec_version: META_SPEC_VERSION,
-        twin_versions: resolveTwinPackageVersions(input.scenario.config.twins),
-    });
-    // events.jsonl is the unified discriminated-union view (FDRS-398). The
-    // in-process twin recorders still expose legacy RecorderEvent rows via
-    // `events()`; wrap each into a TwinHttpEvent before serializing so
-    // `pome inspect` (FDRS-403) and dashboard ingest (FDRS-415) can parse them.
-    //
-    // F-698: the durable recorder may already have appended TwinHttpEvent rows
-    // during the run. Skip re-appending any event whose `event_id`/`request_id`
-    // is already on disk so finalize does not duplicate crash-streamed rows.
-    // APPEND (not truncate) so capture-server LlmCallEvent rows also survive.
-    const existingIds = await readExistingEventIds(join(runDir, "events.jsonl"));
-    const freshEvents = input.events.filter((event) => {
-        const id = event.request_id;
-        const maybeEventId = event.event_id;
-        if (typeof maybeEventId === "string" && existingIds.has(maybeEventId))
-            return false;
-        if (existingIds.has(id))
-            return false;
-        return true;
-    });
-    const eventsPath = join(runDir, "events.jsonl");
-    if (freshEvents.length > 0) {
-        const eventsJsonl = freshEvents.map((event) => JSON.stringify(redactEvent(toTwinHttpEvent(event)))).join("\n") +
-            "\n";
-        await appendFile(eventsPath, eventsJsonl);
-    }
-    else if (!existsSync(eventsPath)) {
-        // Preserve the six-file run-dir contract when nothing was streamed and
-        // the recorder emitted no events (F-689 / D6).
-        await writeFile(eventsPath, "");
-    }
-    await writeJson(join(runDir, "state_initial.json"), input.stateInitial);
-    await writeJson(join(runDir, "state_final.json"), input.stateFinal);
-    await writeFile(join(runDir, "stdout.txt"), redactText(input.stdout));
-    await writeFile(join(runDir, "stderr.log"), redactText(input.stderr));
-    // F-933 — `task`, not `scenario`. latest.json is a purely local pointer:
-    // every run overwrites it and its only readers are `pome eval` / `pome
-    // inspect`, which dereference `run_dir`/`run_id`. Nothing on the wire and
-    // nothing in the cloud parses it, so the rename needs no compat window.
-    // meta.json's `scenario` key is deliberately NOT renamed here — that one is
-    // uploaded to cloud finalize and read back out of older run dirs (see
-    // AGENTS.md's sanctioned-survivor list).
-    await writeJson(join(input.artifactsDir, "latest.json"), {
-        run_id: input.runId,
-        task: input.scenario.slug,
-        run_dir: runDir
-    });
-    return { runId: input.runId, runDir };
-}
-export async function readLatestRun(artifactsDir) {
-    const latestPath = join(artifactsDir, "latest.json");
-    if (!existsSync(latestPath))
-        return undefined;
-    return JSON.parse(await readFile(latestPath, "utf8"));
-}
-export async function readMetaSummary(runDir) {
-    try {
-        const raw = await readFile(join(runDir, "meta.json"), "utf8");
-        const parsed = JSON.parse(raw);
-        const twins = Array.isArray(parsed.twins)
-            ? parsed.twins.filter((t) => typeof t === "string")
-            : [];
-        return { ...parsed, twins };
-    }
-    catch (err) {
-        if (err.code === "ENOENT")
-            return { twins: [] };
-        throw err;
-    }
-}
-async function writeJson(path, value) {
-    await writeFile(path, `${JSON.stringify(redactSecrets(value), null, 2)}\n`);
-}
-async function readExistingEventIds(eventsPath) {
-    const ids = new Set();
-    if (!existsSync(eventsPath))
-        return ids;
-    try {
-        const raw = await readFile(eventsPath, "utf8");
-        for (const line of raw.split("\n")) {
-            if (!line.trim())
-                continue;
-            try {
-                const row = JSON.parse(line);
-                // Only TwinHttpEvent rows participate in finalize dedupe. Other kinds
-                // (LlmCallEvent, HookEvent, …) may carry request_id/event_id values
-                // that must not suppress a twin HTTP row.
-                if (row.kind !== "TwinHttpEvent")
-                    continue;
-                if (typeof row.event_id === "string")
-                    ids.add(row.event_id);
-                if (typeof row.request_id === "string")
-                    ids.add(row.request_id);
-            }
-            catch {
-                // Corrupt/partial trailing line from a crash — ignore for dedupe.
-            }
-        }
-    }
-    catch (err) {
-        if (err.code !== "ENOENT")
-            throw err;
-    }
-    return ids;
-}
-function redactText(value) {
-    return redactSecrets(value);
-}

package/dist/src/recorder/inspect.d.ts

@@ -1,37 +0,0 @@
-import { type Event } from "../types/shared.js";
-/**
- * Result of reading + classifying a run's `events.jsonl`. The reader can take
- * three paths:
- *   - `kind: "events"` — every row parsed cleanly against the discriminated
- *     union; the renderer walks `events` to print sections + trace health.
- *   - `kind: "legacy"` — at least one row is missing the `kind` discriminator
- *     (pre-FDRS-398 shape). `pome inspect` prints the legacy error and exits 2.
- *   - `kind: "missing"` — `events.jsonl` does not exist (run never produced
- *     trace blobs). Renderer prints a one-line note; no exit-2.
- */
-export type ReadEventsResult = {
-    kind: "events";
-    events: Event[];
-} | {
-    kind: "legacy";
-} | {
-    kind: "missing";
-};
-export declare const LEGACY_EVENTS_MESSAGE = "this run was produced by an older CLI version (pre-M0); rerun against current CLI to view";
-export declare function readEventsJsonl(runDir: string): Promise<ReadEventsResult>;
-export type TraceHealthLayer = {
-    name: string;
-    count: number;
-    expectedAtLeast: number;
-    status: "ok" | "warning" | "none";
-    note: string | null;
-};
-export type TraceHealthInput = {
-    events: Event[];
-    taskUsesTwin?: boolean;
-    taskExpectsLlm?: boolean;
-    taskExpectsCas?: boolean;
-};
-export declare function computeTraceHealth(input: TraceHealthInput): TraceHealthLayer[];
-export declare function renderTraceHealth(layers: TraceHealthLayer[]): string[];
-export declare function renderEvents(events: Event[]): string[];