@inflexa-ai/harness 0.45.1 → 0.46.2

package/dist/tools/sandbox/list-available-packages.js

@@ -20,6 +20,9 @@
  * hashes — a thousand rows of sha256 would bury the signal.
  */
 import { ok } from "neverthrow";
+import { presentGet } from "../../lib/present.js";
+import { errorMessageOf } from "../../lib/thrown.js";
+import { textOf } from "../../lib/unknown-text.js";
 import { z } from "zod";
 import { defineTool } from "../define-tool.js";
 import { identityAddress, identityKey, identityOf, parseQuery, resolveQuery, } from "../../sandbox/package-identity.js";
@@ -99,7 +102,7 @@ export function lockSections(lock) {
         .filter(([, packages]) => packages.length > 0)
         .map(([subtree, packages]) => {
         const track = trackOfLockSubtree(subtree);
-        return { title: TRACK_TITLES[subtree] ?? subtree, packages, ...(track === undefined ? {} : { track }) };
+        return { title: TRACK_TITLES[subtree] ?? subtree, packages, track };
     });
 }
 /**
@@ -160,7 +163,7 @@ function foldSections(sections) {
             open.packages.push(pkg);
         }
     }
-    return [...byTitle.values()].map(({ title, track, packages }) => ({ title, packages, ...(track === undefined ? {} : { track }) }));
+    return [...byTitle.values()].map(({ title, track, packages }) => ({ title, packages, track }));
 }
 /**
  * Default cap on a listing — high enough that the real store is never truncated.
@@ -196,7 +199,9 @@ const POOL_UNAVAILABLE_NOTE = "Package list not available — the package pool c
  */
 const LANGUAGE_MATCHERS = {
     // `CLI_TITLE` — the conda-installed bioinformatics executables.
+    // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the section heading names the executables section or the standalone word CLI, matched in display text.
     cli: (t) => /system tools|\bcli\b/i.test(t),
+    // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the heading opens with the word node, the display form of the section name.
     node: (t) => /^node\b/i.test(t),
 };
 /** Whether one section answers the `language` filter of a call. */
@@ -205,7 +210,7 @@ function matchesLanguage(section, language) {
         return true;
     if (language === "r" || language === "python")
         return section.track === language;
-    return LANGUAGE_MATCHERS[language](section.title);
+    return presentGet(LANGUAGE_MATCHERS, language, `the heading matcher for ${language}`)(section.title);
 }
 /**
  * The identity names that the Python track and the R track both hold.
@@ -295,9 +300,9 @@ function presentEntry(requested, row) {
         present: true,
         name: row.entry.name,
         section: row.section,
-        ...(row.entry.version === undefined ? {} : { version: row.entry.version }),
-        ...(row.entry.storeDir === undefined ? {} : { storeDir: row.entry.storeDir }),
-        ...(row.entry.hash === undefined ? {} : { hash: row.entry.hash }),
+        version: row.entry.version,
+        storeDir: row.entry.storeDir,
+        hash: row.entry.hash,
     };
 }
 /**
@@ -365,7 +370,7 @@ export function queryPackages(rawSections, { names, query, language, limit }) {
             if (hits.length > 0)
                 return hits;
             const suggestion = resolution.kind === "unknown" ? resolution.suggestion : undefined;
-            return [{ requested, present: false, ...(suggestion === undefined ? {} : { suggestion: suggestion.name }) }];
+            return [{ requested, present: false, suggestion: suggestion?.name }];
         });
         return { available: true, checked };
     }
@@ -379,7 +384,7 @@ export function queryPackages(rawSections, { names, query, language, limit }) {
         .map((s) => ({
         title: s.title,
         packages: needle ? s.packages.filter((p) => p.name.toLowerCase().includes(needle)) : s.packages,
-        ...(s.track === undefined ? {} : { track: s.track }),
+        track: s.track,
     }))
         .filter((s) => s.packages.length > 0);
     const total = filtered.reduce((n, s) => n + s.packages.length, 0);
@@ -422,7 +427,7 @@ export async function readInventorySections(deps, analysisId) {
     if (deps.readPoolInventory) {
         const pool = await deps.readPoolInventory().catch((cause) => ({
             kind: "unavailable",
-            reason: cause instanceof Error ? cause.message : String(cause),
+            reason: errorMessageOf(cause) ?? textOf(cause),
         }));
         if (pool.kind === "unavailable")
             return { kind: "unavailable", reason: pool.reason };
@@ -449,6 +454,22 @@ export async function readInventorySections(deps, analysisId) {
  * host-readable farm `inflexa.lock` otherwise (a sandbox agent). The image
  * record merges into either report.
  */
+const ListAvailablePackagesInputSchema = z.object({
+    names: z
+        .array(z.string())
+        .max(100)
+        .optional()
+        .describe("Check these packages for presence. Each entry is a query in the one grammar, `[python:|r:]<name>`. Returns one entry for each track that holds the name: present/absent + the language track it lives in. An absent name carries the spelling the pool holds, where there is one."),
+    query: z.string().optional().describe("Case-insensitive substring filter over package names."),
+    language: z.enum(["r", "python", "cli", "node"]).optional().describe("Restrict results to one language track."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(DEFAULT_LIMIT)
+        .optional()
+        .describe(`Cap the packages listed. Omit to get the whole set — the store fits well within the ${DEFAULT_LIMIT} ceiling. Ignored when \`names\` is given.`),
+});
 export function createListAvailablePackagesTool(deps = {}) {
     const readPoolInventory = deps.readPoolInventory;
     // The scope decides the framing sentence: a sandbox agent reads what it can
@@ -473,22 +494,7 @@ export function createListAvailablePackagesTool(deps = {}) {
             "`language`: restrict to one track (r | python | cli | node). " +
             "`limit`: cap the packages listed; the response always carries the true `total` and a `hasMore` flag, so truncation is never silent. " +
             "Each entry renders as `name==version` where the source pins a version, and a `names` check also reports the store directory and the content hash where the source records them.",
-        inputSchema: z.object({
-            names: z
-                .array(z.string())
-                .max(100)
-                .optional()
-                .describe("Check these packages for presence. Each entry is a query in the one grammar, `[python:|r:]<name>`. Returns one entry for each track that holds the name: present/absent + the language track it lives in. An absent name carries the spelling the pool holds, where there is one."),
-            query: z.string().optional().describe("Case-insensitive substring filter over package names."),
-            language: z.enum(["r", "python", "cli", "node"]).optional().describe("Restrict results to one language track."),
-            limit: z
-                .number()
-                .int()
-                .min(1)
-                .max(DEFAULT_LIMIT)
-                .optional()
-                .describe(`Cap the packages listed. Omit to get the whole set — the store fits well within the ${DEFAULT_LIMIT} ceiling. Ignored when \`names\` is given.`),
-        }),
+        inputSchema: ListAvailablePackagesInputSchema,
         // `queryPackages` returns on `names` before it reads another field, thus
         // the presence check comes first. An empty array is not a presence check.
         // `names` are exact identifiers a caller checks for, thus they name the

package/dist/tools/sandbox/list-available-refs.d.ts

@@ -27,9 +27,17 @@
  * only ever ENRICHES an entry — a file with no receipt and no catalog match is
  * still returned, because a user-provided store is as valid as a managed one.
  */
+import { z } from "zod";
 import type { EnvironmentStorePaths } from "../../config/environment-stores.js";
+import { type Tool } from "../define-tool.js";
+declare const ListAvailableRefsInputSchema: z.ZodObject<{
+    path: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+    query: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
 export type ListAvailableRefsDeps = Pick<EnvironmentStorePaths, "refStorePath">;
-export interface ReferenceInventoryMetadata {
+export type ReferenceInventoryMetadata = {
     readonly datasetId?: string;
     readonly version?: string;
     readonly title?: string;
@@ -45,11 +53,11 @@ export interface ReferenceInventoryMetadata {
     readonly contents?: string;
     readonly rows?: number;
     readonly endpoint?: string;
-}
-interface ReferenceInventoryEntryBase {
+};
+type ReferenceInventoryEntryBase = {
     readonly path: string;
     readonly metadata?: ReferenceInventoryMetadata;
-}
+};
 /** A bounded, no-follow observation of the reference store. */
 export type ReferenceInventoryEntry = (ReferenceInventoryEntryBase & {
     readonly kind: "file";
@@ -69,7 +77,7 @@ export type ReferenceInventoryEntry = (ReferenceInventoryEntryBase & {
  * is explicit: `returned`/`total`/`hasMore` describe how much of the match set
  * this response carries, and `categories` is the drill-in index.
  */
-export interface ReferenceInventoryResult {
+export type ReferenceInventoryResult = {
     readonly available: boolean;
     readonly state: RawScan["state"] | "out_of_scope";
     readonly path: string;
@@ -81,15 +89,15 @@ export interface ReferenceInventoryResult {
     readonly hasMore: boolean;
     readonly categories: readonly string[];
     readonly content: string;
-}
-interface RawScan {
+};
+type RawScan = {
     readonly state: "unavailable" | "empty" | "populated" | "not_found" | "not_a_directory" | "symlink";
     readonly entries: ReferenceInventoryEntry[];
     readonly scannedEntries: number;
     readonly truncated: boolean;
     readonly receipts?: unknown[];
     readonly legacyEntries?: unknown[];
-}
+};
 /**
  * The dataset ids the install receipts of the store report, for a caller that must know whether a
  * declared dataset is present BEFORE a run starts.
@@ -112,10 +120,5 @@ export declare function readReferenceInventory(storeRoot: string): Promise<{
     readonly available: boolean;
     readonly entries: readonly ReferenceInventoryEntry[];
 }>;
-export declare function createListAvailableRefsTool(deps: ListAvailableRefsDeps): import("../define-tool.js").Tool<{
-    path?: string | undefined;
-    category?: string | undefined;
-    query?: string | undefined;
-    limit?: number | undefined;
-}, ReferenceInventoryResult>;
+export declare function createListAvailableRefsTool(deps: ListAvailableRefsDeps): Tool<z.infer<typeof ListAvailableRefsInputSchema>, ReferenceInventoryResult>;
 export {};

package/dist/tools/sandbox/list-available-refs.js

@@ -32,6 +32,10 @@ import { join as hostJoin, posix as posixPath } from "node:path";
 import { ok } from "neverthrow";
 import { z } from "zod";
 import { capCodePoints, DETAIL_MAX_LENGTH, DETAIL_NEEDLE_MAX_LENGTH } from "../../loop/tool-detail.js";
+import { errnoOf } from "../../lib/fs-result.js";
+import { parseJsonAs } from "../../lib/parse-json.js";
+import { isUnknownArray } from "../../lib/unknown-array.js";
+import { parseUnknownRecord } from "../../lib/unknown-containers.js";
 import { REFERENCE_DATA_CATALOG } from "../../reference-data/catalog.js";
 import { parseReferenceInstallReceipt } from "../../reference-data/receipt.js";
 import { REFS_CONTAINER_PATH } from "../../sandbox/mount-plan.js";
@@ -158,6 +162,8 @@ async function summarizeDirectory(directory, scanned) {
     const stack = [directory];
     while (stack.length > 0 && scanned < MAX_SCANNED_ENTRIES) {
         const current = stack.pop();
+        if (current === undefined)
+            break;
         const { values, cut } = await cappedEntries(current, MAX_SCANNED_ENTRIES - scanned);
         truncated = truncated || cut;
         const childDirectories = [];
@@ -196,7 +202,7 @@ async function readReceipts(root) {
         // A shared try would abandon the loop and silently drop every receipt sorting
         // after the bad one, quietly stripping metadata from datasets that are fine.
         try {
-            receipts.push(JSON.parse(await readFile(hostJoin(receiptsDirectory, entry.name), "utf-8")));
+            receipts.push(parseJsonAs(await readFile(hostJoin(receiptsDirectory, entry.name), "utf-8"), z.json()));
             totalBytes += entry.bytes;
         }
         catch {
@@ -234,7 +240,7 @@ export async function readInstalledDatasetIds(deps) {
     catch (error) {
         // An absent directory is a readable store with nothing installed. Any other failure is the
         // store declining to answer, which is a different fact and gets the honest `undefined`.
-        if (error.code === "ENOENT")
+        if (errnoOf(error) === "ENOENT")
             return new Set();
         return undefined;
     }
@@ -243,7 +249,7 @@ export async function readInstalledDatasetIds(deps) {
         // Per-file, so one malformed receipt costs only its own dataset. A shared try would drop
         // every receipt after the bad one and read as a store that holds almost nothing.
         try {
-            const receipt = parseReferenceInstallReceipt(JSON.parse(await readFile(hostJoin(receiptsDirectory, name), "utf-8")));
+            const receipt = parseReferenceInstallReceipt(parseJsonAs(await readFile(hostJoin(receiptsDirectory, name), "utf-8"), z.json()));
             if (receipt)
                 ids.add(receipt.datasetId);
         }
@@ -262,21 +268,24 @@ async function readLegacyEntries(root) {
         const registryPath = hostJoin(root, "registry.json");
         if ((await lstat(registryPath)).size > MAX_REGISTRY_BYTES)
             return [];
-        const registry = JSON.parse(await readFile(registryPath, "utf-8"));
-        if (!registry || typeof registry !== "object")
+        const registry = parseJsonAs(await readFile(registryPath, "utf-8"), z.json());
+        const registryRecord = parseUnknownRecord(registry);
+        if (!registryRecord)
             return [];
-        const byCategory = registry.files?.by_category;
-        if (!byCategory || typeof byCategory !== "object")
+        const files = parseUnknownRecord(registryRecord.files);
+        const categories = parseUnknownRecord(files?.by_category);
+        if (!categories)
             return [];
-        for (const category of Object.keys(byCategory).sort()) {
-            const values = byCategory[category];
-            if (!Array.isArray(values))
+        for (const category of Object.keys(categories).sort()) {
+            const values = categories[category];
+            if (!isUnknownArray(values))
                 continue;
             for (const item of values) {
                 if (legacyEntries.length >= MAX_LEGACY_ENTRIES)
                     break;
-                if (item && typeof item === "object" && typeof item.local_path === "string") {
-                    legacyEntries.push({ ...item, category });
+                const itemRecord = parseUnknownRecord(item);
+                if (itemRecord && typeof itemRecord.local_path === "string") {
+                    legacyEntries.push({ ...itemRecord, category });
                 }
             }
         }
@@ -301,6 +310,8 @@ async function collectFiles(directory, relative, budget) {
     const stack = [{ path: directory, relative }];
     while (stack.length > 0 && budget.scanned < MAX_SCANNED_ENTRIES) {
         const current = stack.pop();
+        if (current === undefined)
+            break;
         const { values, cut } = await cappedEntries(current.path, MAX_SCANNED_ENTRIES - budget.scanned);
         truncated = truncated || cut;
         for (const child of values) {
@@ -439,41 +450,55 @@ function enrichEntries(entries, raw) {
             // Per-artifact, not per-dataset: format and contents differ between files of the
             // same dataset (a Seurat object and its Annoy index are read nothing alike).
             const catalogArtifact = dataset?.artifacts.find((candidate) => candidate.path === artifact.path);
-            metadata.set(`${REFS_ROOT}/managed/${receipt.datasetId}/${receipt.datasetVersion}/${artifact.path}`, {
+            const managedMetadata = {
                 datasetId: receipt.datasetId,
                 version: receipt.datasetVersion,
-                ...(dataset
-                    ? {
-                        title: dataset.title,
-                        description: dataset.description,
-                        sourceUrl: dataset.sourceUrl,
-                        license: dataset.license.url ?? dataset.license.identifier,
-                        category: dataset.recommendation.group,
-                        ...(dataset.organism ? { organism: dataset.organism } : {}),
-                    }
-                    : {}),
-                ...(catalogArtifact ? { format: catalogArtifact.format, contents: catalogArtifact.contents } : {}),
-            });
+            };
+            if (dataset) {
+                managedMetadata.title = dataset.title;
+                managedMetadata.description = dataset.description;
+                managedMetadata.sourceUrl = dataset.sourceUrl;
+                managedMetadata.license = dataset.license.url ?? dataset.license.identifier;
+                managedMetadata.category = dataset.recommendation.group;
+                if (dataset.organism)
+                    managedMetadata.organism = dataset.organism;
+            }
+            if (catalogArtifact) {
+                managedMetadata.format = catalogArtifact.format;
+                managedMetadata.contents = catalogArtifact.contents;
+            }
+            metadata.set(`${REFS_ROOT}/managed/${receipt.datasetId}/${receipt.datasetVersion}/${artifact.path}`, managedMetadata);
         }
     }
     for (const value of raw.legacyEntries ?? []) {
-        if (!value || typeof value !== "object")
+        const item = parseUnknownRecord(value);
+        if (!item)
             continue;
-        const item = value;
         const localPath = stringValue(item.local_path);
         if (!localPath)
             continue;
         const resolved = resolveRequestedPath(localPath);
         if (!resolved.ok)
             continue;
-        const legacyMetadata = {
-            ...(stringValue(item.dataset) ? { datasetId: stringValue(item.dataset) } : {}),
-            ...(stringValue(item.category) ? { category: stringValue(item.category) } : {}),
-            ...(stringValue(item.subtype) ? { subtype: stringValue(item.subtype) } : {}),
-            ...(stringValue(item.organism) ? { organism: stringValue(item.organism) } : {}),
-            ...(numberValue(item.rows) !== undefined ? { rows: numberValue(item.rows) } : {}),
-            ...(stringValue(item.endpoint) ? { endpoint: stringValue(item.endpoint) } : {}),
-        };
+        const datasetId = stringValue(item.dataset);
+        const category = stringValue(item.category);
+        const subtype = stringValue(item.subtype);
+        const organism = stringValue(item.organism);
+        const rows = numberValue(item.rows);
+        const endpoint = stringValue(item.endpoint);
+        const legacyMetadata = {};
+        if (datasetId)
+            legacyMetadata.datasetId = datasetId;
+        if (category)
+            legacyMetadata.category = category;
+        if (subtype)
+            legacyMetadata.subtype = subtype;
+        if (organism)
+            legacyMetadata.organism = organism;
+        if (rows !== undefined)
+            legacyMetadata.rows = rows;
+        if (endpoint)
+            legacyMetadata.endpoint = endpoint;
         metadata.set(resolved.path, { ...legacyMetadata, ...metadata.get(resolved.path) });
     }
     return entries.map((entry) => {
@@ -608,7 +633,7 @@ export function createListAvailableRefsTool(deps) {
             // The budget comes off the rendered filter, never off a count of its
             // parts, thus it cannot drift from the template above. One code point
             // pays for the joining space.
-            return `${capCodePoints(named, DETAIL_MAX_LENGTH - [...filter].length - 1)} ${filter}`;
+            return `${capCodePoints(named, DETAIL_MAX_LENGTH - Array.from(filter).length - 1)} ${filter}`;
         },
         execute: async ({ path, category, query, limit }) => {
             // `category` is shorthand for a top-level path; an explicit `path` wins.

package/dist/tools/sandbox/report-blocker.d.ts

@@ -10,57 +10,50 @@
  * sandbox step agent, the planner (`tools/research/generate-plan.ts`), the
  * run synthesizer (`execution/run-synthesis.ts`) and the analogical reasoner
  * (`tools/research/generate-analogy-report.ts`) — and all four share one id,
- * one input schema and one terminal contract via `createReportBlockerToolFor`.
- * What differs per loop is only what a blocker *means* there, so each call site
- * injects its own `blockedWhen` prose and its own capture closure. The tool
- * records the reason and tells the agent to stop; the driving body reads the
- * outcome after the loop and decides the terminal status. The sandbox step body
- * runs in durable steps, so it reads the blocker back from the transcript
- * (`recordedBlocker`) on replay, not only from its cell.
+ * one input schema and one result via `createReportBlockerToolFor`. What
+ * differs per loop is only what a blocker *means* there, so each call site
+ * injects its own `blockedWhen` prose. The result of the call carries the
+ * reason, and the driving body selects the blocker from the recorded calls of
+ * the run (`blockerOf`). Thus a replay selects the same blocker.
  */
-import type { ModelMessage } from "ai";
+import { z } from "zod";
+import type { LoopStep } from "../../loop/run-loop.js";
 import { type Tool } from "../define-tool.js";
 export declare const REPORT_BLOCKER_TOOL_ID = "report_blocker";
-export interface BlockerOutcome {
+export type BlockerOutcome = {
     readonly kind: "blocker";
     readonly reason: string;
-}
-/** Per-run mutable cell the sandbox-step body reads after the loop. */
-export interface BlockerHolder {
-    outcome: BlockerOutcome | null;
-}
-export declare function createBlockerHolder(): BlockerHolder;
-export interface ReportBlockerDeps {
-    /**
-     * The calling loop's blocker-capture side effect — writes the outcome into
-     * whatever cell that body reads after its loop. Invoked on every call; the
-     * closure owns the first-call-wins guard, because only the call site knows
-     * what else may already have terminated its loop.
-     */
-    readonly record: (outcome: BlockerOutcome) => void;
+};
+/** The one input every `report_blocker` takes, wherever it is offered. */
+declare const ReportBlockerInputSchema: z.ZodObject<{
+    reason: z.ZodString;
+}, z.core.$strip>;
+/** The result of a call: the blocker that the call recorded. */
+declare const BlockerResultSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"blocker">;
+    reason: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>;
+type BlockerResult = z.infer<typeof BlockerResultSchema>;
+export type ReportBlockerDeps = {
     /**
      * What a blocker means in THIS loop: which loop the call ends and the
      * conditions that warrant it. Composed into the shared terminal contract,
      * so a description can never promise a loop this instance does not end.
      */
     readonly blockedWhen: string;
-}
+};
 /**
  * Build the `report_blocker` tool for one loop. The id, the input schema and
  * the terminal contract ("pass a reason, then stop") are fixed here; the call
- * site supplies only the per-loop meaning and the capture closure.
- */
-export declare function createReportBlockerToolFor(deps: ReportBlockerDeps): Tool;
-/**
- * The blocker that a run recorded, read from its transcript: the reason of the
- * first `report_blocker` call, in call order, whose result is ok.
- *
- * A replay returns each tool step's cached result without re-running
- * `execute`, so the in-memory cell is empty on replay; the transcript is not.
+ * site supplies only the per-loop meaning.
  */
-export declare function recordedBlocker(messages: readonly ModelMessage[]): BlockerOutcome | null;
+export declare function createReportBlockerToolFor(deps: ReportBlockerDeps): Tool<z.infer<typeof ReportBlockerInputSchema>, BlockerResult>;
+/** The blocker that a run recorded: the reason of the first `report_blocker` call, in call order, whose result is ok. */
+export declare function blockerOf(steps: readonly LoopStep[]): BlockerOutcome | null;
 /**
- * The sandbox step agent's `report_blocker`, bound to the step body's holder.
- * A blocker here ends the step with no deliverables and a blocked reason.
+ * The sandbox step agent's `report_blocker`. A blocker here ends the step with
+ * no deliverables and a blocked reason.
  */
-export declare function createReportBlockerTool(holder: BlockerHolder): Tool;
+export declare function createReportBlockerTool(): Tool;
+export {};

package/dist/tools/sandbox/report-blocker.js

@@ -10,35 +10,27 @@
  * sandbox step agent, the planner (`tools/research/generate-plan.ts`), the
  * run synthesizer (`execution/run-synthesis.ts`) and the analogical reasoner
  * (`tools/research/generate-analogy-report.ts`) — and all four share one id,
- * one input schema and one terminal contract via `createReportBlockerToolFor`.
- * What differs per loop is only what a blocker *means* there, so each call site
- * injects its own `blockedWhen` prose and its own capture closure. The tool
- * records the reason and tells the agent to stop; the driving body reads the
- * outcome after the loop and decides the terminal status. The sandbox step body
- * runs in durable steps, so it reads the blocker back from the transcript
- * (`recordedBlocker`) on replay, not only from its cell.
+ * one input schema and one result via `createReportBlockerToolFor`. What
+ * differs per loop is only what a blocker *means* there, so each call site
+ * injects its own `blockedWhen` prose. The result of the call carries the
+ * reason, and the driving body selects the blocker from the recorded calls of
+ * the run (`blockerOf`). Thus a replay selects the same blocker.
  */
-import { err, ok } from "neverthrow";
+import { ok } from "neverthrow";
 import { z } from "zod";
-import { repairToolInput } from "../../lib/zod-issues.js";
-import { toolOutcomeForOutputType } from "../../loop/tool-outcome.js";
-import { degenerateTerminalText } from "../terminal-text.js";
+import { terminalTextSchema } from "../terminal-text.js";
 import { defineTool } from "../define-tool.js";
 export const REPORT_BLOCKER_TOOL_ID = "report_blocker";
-export function createBlockerHolder() {
-    return { outcome: null };
-}
 /** The one input every `report_blocker` takes, wherever it is offered. */
 const ReportBlockerInputSchema = z.object({
-    reason: z
-        .string()
-        .min(1)
-        .describe("What blocks the work, stated as a fact: the missing or unreadable input, or the capability that is not available, and what you tried."),
+    reason: terminalTextSchema("What blocks the work, stated as a fact: the missing or unreadable input, or the capability that is not available, and what you tried."),
 });
+/** The result of a call: the blocker that the call recorded. */
+const BlockerResultSchema = z.object({ kind: z.literal("blocker"), reason: z.string(), message: z.string() });
 /**
  * Build the `report_blocker` tool for one loop. The id, the input schema and
  * the terminal contract ("pass a reason, then stop") are fixed here; the call
- * site supplies only the per-loop meaning and the capture closure.
+ * site supplies only the per-loop meaning.
  */
 export function createReportBlockerToolFor(deps) {
     return defineTool({
@@ -46,70 +38,28 @@ export function createReportBlockerToolFor(deps) {
         description: `Terminal. ${deps.blockedWhen} Pass a clear reason. Stop immediately after calling — take no further actions.`,
         inputSchema: ReportBlockerInputSchema,
         describeCall: "none",
-        execute: async (input) => {
-            const degenerate = degenerateTerminalText(input.reason);
-            if (degenerate)
-                return err({ error: `${degenerate} Give the real reason, or continue the work.`, retryable: true });
-            deps.record({ kind: "blocker", reason: input.reason });
-            return ok({
-                recorded: true,
-                message: "Blocker recorded. You are done — stop now and do not take further actions.",
-            });
-        },
+        execute: (input) => Promise.resolve(ok({ kind: "blocker", reason: input.reason, message: "Blocker recorded. You are done — stop now and do not take further actions." })),
     });
 }
-/**
- * The blocker that a run recorded, read from its transcript: the reason of the
- * first `report_blocker` call, in call order, whose result is ok.
- *
- * A replay returns each tool step's cached result without re-running
- * `execute`, so the in-memory cell is empty on replay; the transcript is not.
- */
-export function recordedBlocker(messages) {
-    const recorded = new Set();
-    for (const message of messages) {
-        if (message.role !== "tool")
-            continue;
-        for (const part of message.content) {
-            if (part.type === "tool-result" && part.toolName === REPORT_BLOCKER_TOOL_ID && toolOutcomeForOutputType(part.output.type) === "ok") {
-                recorded.add(part.toolCallId);
-            }
-        }
-    }
-    for (const message of messages) {
-        if (message.role !== "assistant" || typeof message.content === "string")
-            continue;
-        for (const part of message.content) {
-            if (part.type !== "tool-call" || part.toolName !== REPORT_BLOCKER_TOOL_ID || !recorded.has(part.toolCallId))
+/** The blocker that a run recorded: the reason of the first `report_blocker` call, in call order, whose result is ok. */
+export function blockerOf(steps) {
+    for (const step of steps) {
+        for (const call of step.calls) {
+            if (call.toolName !== REPORT_BLOCKER_TOOL_ID || call.output?.outcome !== "ok")
                 continue;
-            const reason = blockerReason(part.input);
-            if (reason !== undefined)
-                return { kind: "blocker", reason };
+            const result = BlockerResultSchema.safeParse(call.output.value);
+            if (result.success)
+                return { kind: "blocker", reason: result.data.reason };
         }
     }
     return null;
 }
-/** The reason of a `report_blocker` input, validated as the dispatch validates it. */
-function blockerReason(input) {
-    const parsed = ReportBlockerInputSchema.safeParse(input);
-    if (parsed.success)
-        return parsed.data.reason;
-    const repaired = repairToolInput(input, parsed.error);
-    if (repaired === undefined)
-        return undefined;
-    const reparsed = ReportBlockerInputSchema.safeParse(repaired);
-    return reparsed.success ? reparsed.data.reason : undefined;
-}
 /**
- * The sandbox step agent's `report_blocker`, bound to the step body's holder.
- * A blocker here ends the step with no deliverables and a blocked reason.
+ * The sandbox step agent's `report_blocker`. A blocker here ends the step with
+ * no deliverables and a blocked reason.
  */
-export function createReportBlockerTool(holder) {
+export function createReportBlockerTool() {
     return createReportBlockerToolFor({
-        record: (outcome) => {
-            if (holder.outcome === null)
-                holder.outcome = outcome;
-        },
         blockedWhen: "Ends this analysis step with no deliverables. Call it when you cannot " +
             "fulfil the step — required inputs are missing or unreadable, the " +
             "requested analysis is infeasible with the available data/packages, or " +