@inflexa-ai/harness 0.45.0 → 0.46.0

package/dist/tools/report-session/examine-page.js

@@ -49,12 +49,16 @@
  * deadline. A realization that hangs while it starts a browser would otherwise hold the whole agent turn,
  * and no outcome would ever arrive.
  */
+import { errorMessageOf } from "../../lib/thrown.js";
+import { textOf } from "../../lib/unknown-text.js";
 import { err, ok } from "neverthrow";
 import { access } from "node:fs/promises";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
+import { setTimeout as sleep } from "node:timers/promises";
 import { z } from "zod";
 import { hasBrowserUrl } from "../../lib/chrome.js";
+import { errnoOf } from "../../lib/fs-result.js";
 import { createNoopLogger } from "../../lib/console-logger.js";
 import { createStaticEyes } from "../../lib/eyes.js";
 import { defaultErrorFields } from "../../lib/logger.js";
@@ -114,7 +118,7 @@ const ACQUIRE_DEADLINE_MS = 60_000;
  * provisions.
  */
 const RELEASE_DEADLINE_MS = 10_000;
-/** The win of the timer arm. A symbol cannot collide with a value that the operation gives. */
+/** The win of the expiry arm. A symbol cannot collide with a value that the operation gives. */
 const EXPIRED = Symbol("expired");
 /**
  * Run one operation against a deadline, and give the value, the cause, or the expiry.
@@ -122,19 +126,17 @@ const EXPIRED = Symbol("expired");
  * The eyes seam takes no abort signal, thus a race is the whole bound. The loser of the race stays in
  * flight, and the caller of an expired operation owns whatever arrives late.
  *
- * Each path clears the timer. `sleep` of `async-utils.ts` holds a timer that nothing can clear. Thus an
- * operation that wins its race would still keep the process alive for the rest of the budget.
+ * The abort after the race clears the wait of a settled operation, so no armed timer outlives the budget.
  */
 async function withDeadline(work, ms) {
-    let timer;
     // The settled arm never rejects. Thus a fault that arrives after the expiry stays contained here, and it
     // never reaches the process as an unhandled rejection.
     const settled = work.then((value) => ok(value), (cause) => err({ kind: "threw", cause }));
-    const expiry = new Promise((resolve) => {
-        timer = setTimeout(() => resolve(EXPIRED), ms);
-    });
+    const gate = new AbortController();
+    // The rejection arm answers the abort of a settled race, and its value is never read.
+    const expiry = sleep(ms, undefined, { signal: gate.signal }).then(() => EXPIRED, () => EXPIRED);
     const winner = await Promise.race([settled, expiry]);
-    clearTimeout(timer);
+    gate.abort();
     return winner === EXPIRED ? err({ kind: "expired" }) : winner;
 }
 /** The cause of one such fault. An expiry names its budget, thus the detail of the outcome names it too. */
@@ -153,6 +155,7 @@ function startSeamCall(call) {
         return call();
     }
     catch (cause) {
+        // oxlint-disable-next-line typescript/prefer-promise-reject-errors -- the rejection reason is the thrown value itself; the awaiter reads its identity, and a wrapper would erase it.
         return Promise.reject(cause);
     }
 }
@@ -251,7 +254,6 @@ export function createExaminePageTool(deps) {
             "The outcomes no-page and missed-stamp mean that no preview rendered the current page: run preview_report, then look again. " +
             "The outcome no-browser means that this host gives no browser, and a repeat gives the same outcome.",
         inputSchema: examinePageInput,
-        executionMode: "inline",
         describeCall: (input) => {
             const blockId = input.blockId ?? undefined;
             return blockId === undefined ? "look at the page" : `look at ${blockId}`;
@@ -288,7 +290,7 @@ export function createExaminePageTool(deps) {
                 await access(pagePath);
             }
             catch (cause) {
-                if (cause.code === "ENOENT") {
+                if (errnoOf(cause) === "ENOENT") {
                     // No preview wrote the page yet. The agent runs the preview first.
                     return ok({ outcome: "no-page" });
                 }
@@ -330,7 +332,7 @@ export function createExaminePageTool(deps) {
             if (looked.isErr()) {
                 const { stage, cause } = looked.error;
                 logger.warn(LOOK_FAULT_MESSAGE[stage], { threadId, analysisId, ...defaultErrorFields(cause) });
-                return ok({ outcome: "capture-failed", detail: cause instanceof Error ? cause.message : String(cause) });
+                return ok({ outcome: "capture-failed", detail: errorMessageOf(cause) ?? textOf(cause) });
             }
             const captured = looked.value;
             if (blockId !== undefined && captured.coverage.kind === "no-block") {
@@ -360,7 +362,7 @@ export function createExaminePageTool(deps) {
             return ok(withToolResultImages({
                 outcome: "examined",
                 coverage: captured.coverage,
-                ...(tiles.length === 0 ? {} : { tiles }),
+                tiles: tiles.length === 0 ? undefined : tiles,
                 ...digestPageFaults(captured.consoleErrors, captured.failedRequests),
                 pagePath: relativePagePath,
             }, captured.screenshots.map((shot) => ({ base64: shot.base64, mediaType: SCREENSHOT_MEDIA_TYPE }))));

package/dist/tools/report-session/list-artifacts.d.ts

@@ -38,12 +38,12 @@ export type ListPinnedArtifactsInput = z.infer<typeof listPinnedArtifactsInput>;
  * only for a header that the read recovered, thus their absence says nothing about the content of the file.
  * The listing gives `columnCount`, and a call with a path gives `columns` as well.
  */
-export interface PinnedArtifact {
+export type PinnedArtifact = {
     path: string;
     fileType?: string;
     columnCount?: number;
     columns?: string[];
-}
+};
 /**
  * One pinned citation of the listing: the key, and the short citation of its pinned record.
  *
@@ -51,10 +51,10 @@ export interface PinnedArtifact {
  * the pin recorded no citation for carries none, because absence is a normal condition. The description of
  * the record stays out, because the listing is an orientation surface.
  */
-export interface PinnedCitation {
+export type PinnedCitation = {
     key: string;
     citation?: string;
-}
+};
 /**
  * The typed outcome of the listing tool. Each arm is ok-channel data, thus the tool never throws for one
  * of them.
@@ -87,11 +87,11 @@ export type ListPinnedArtifactsResult = {
  * `resolveWorkspaceRoot` maps the analysis of the call onto its workspace root, thus one singleton tool
  * serves every analysis and it resolves the root per call from the scope.
  */
-export interface ListPinnedArtifactsToolDeps {
+export type ListPinnedArtifactsToolDeps = {
     readonly gateway: ReportSessionStateGateway;
     readonly resolveWorkspaceRoot: ResolveWorkspaceRoot;
     readonly logger?: Logger;
-}
+};
 /**
  * The header columns of a file on disk, or `undefined` when the file gives none.
  *

package/dist/tools/report-session/list-artifacts.js

@@ -27,9 +27,10 @@ import { extname } from "node:path";
 import { z } from "zod";
 import { resolveWorkspacePath } from "../../workspace/paths.js";
 import { createNoopLogger } from "../../lib/console-logger.js";
+import { splitLines } from "../../lib/text.js";
 import { tryFs } from "../../lib/fs-result.js";
 import { defaultErrorFields } from "../../lib/logger.js";
-import { citationRecordOf, fileTypeHoldsNoCell } from "../../report-model/reference-resolver.js";
+import { citationRecordOf, fileTypeHoldsNoCell, snapshotEntry } from "../../report-model/reference-resolver.js";
 import { defineTool } from "../define-tool.js";
 import { openReportThread } from "../report-authoring/authoring-tools.js";
 /** No path lists the pinned set. A path gives the header columns of that one pinned artifact. */
@@ -87,7 +88,7 @@ async function readHeaderLine(absolute) {
     if (head === undefined) {
         return undefined;
     }
-    const line = head.text.split(/\r?\n/, 1)[0];
+    const [line = ""] = splitLines(head.text).slice(0, 1);
     if (line.length === 0) {
         return undefined;
     }
@@ -147,7 +148,6 @@ export function createListPinnedArtifactsTool(deps) {
             "Read the listing to orient before you bind a block. Read the columns of one artifact to choose the column that a locator names. " +
             "A reference names the path alone: the session stamps the hash from this evidence, thus the tool gives no hash.",
         inputSchema: listPinnedArtifactsInput,
-        executionMode: "inline",
         describeCall: (input) => input.path ?? "the pinned set",
         // The size of the listing is what a watcher reads, and the cap makes that size differ from the
         // pinned set. Thus a truncated listing names the total beside the count, and a whole listing names
@@ -180,8 +180,8 @@ export function createListPinnedArtifactsTool(deps) {
                 logger.warn("the workspace root did not resolve", { threadId, analysisId, ...defaultErrorFields(cause) });
             }
             const describe = async (path) => {
-                const fileType = state.snapshot.artifacts[path].fileType;
-                const artifact = { path, ...(typeof fileType === "string" ? { fileType } : {}) };
+                const fileType = snapshotEntry(state.snapshot, path)?.fileType ?? undefined;
+                const artifact = { path, fileType };
                 if (root === undefined || fileTypeHoldsNoCell(fileType)) {
                     return { artifact };
                 }

package/dist/tools/report-session/page-faults.d.ts

@@ -4,25 +4,25 @@
  */
 import type { FailedRequest } from "../../lib/page-capture.js";
 /** One distinct console error of a look, and how many times the page logged it. */
-export interface ConsoleErrorEntry {
+export type ConsoleErrorEntry = {
     text: string;
     count: number;
-}
+};
 /** One distinct failed request of a look, and how many times the page made it. */
-export interface FailedRequestEntry {
+export type FailedRequestEntry = {
     url: string;
     reason: string;
     count: number;
-}
+};
 /** The digest of one look. `omittedFaults` counts the distinct entries that the cap left out, thus a cut is never silent. */
-export interface PageFaults {
+export type PageFaults = {
     consoleErrors: ConsoleErrorEntry[];
     failedRequests: FailedRequestEntry[];
     omittedFaults?: {
         consoleErrors: number;
         failedRequests: number;
     };
-}
+};
 /** Shorten one fault text: the inline data becomes placeholders, and the text stops at the cap. */
 export declare function shortenFaultText(text: string): string;
 /** Digest the raw faults of one capture into the short lists that the agent reads. */

package/dist/tools/report-session/page-faults.js

@@ -8,8 +8,10 @@ const MAX_FAULT_TEXT = 300;
 /** The most distinct entries of one list. */
 const MAX_FAULT_ENTRIES = 20;
 /** A data URI. A fault text quotes a URI in quotes or parentheses, thus those characters end the data. */
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- the data-URI grammar of an inlined fault (media type, parameters, payload) with the quote and bracket characters that end it.
 const DATA_URI = /data:([a-z0-9.+-]+\/[a-z0-9.+-]+)?((?:;[^,;\s'"()<>]*)*),([^\s'"()<>]*)/gi;
 /** A base64 run of 100 characters or more. A content hash in hex is 64 characters, thus a hash stays. */
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- the base64 charset run with its padding; the length floor keeps a 64-character hex hash outside the match.
 const BASE64_RUN = /[A-Za-z0-9+/]{100,}={0,2}/g;
 /** Shorten one fault text: the inline data becomes placeholders, and the text stops at the cap. */
 export function shortenFaultText(text) {
@@ -43,6 +45,6 @@ export function digestPageFaults(consoleErrors, failedRequests) {
     return {
         consoleErrors: errors.slice(0, MAX_FAULT_ENTRIES),
         failedRequests: requests.slice(0, MAX_FAULT_ENTRIES),
-        ...(omittedErrors + omittedRequests > 0 ? { omittedFaults: { consoleErrors: omittedErrors, failedRequests: omittedRequests } } : {}),
+        omittedFaults: omittedErrors + omittedRequests > 0 ? { consoleErrors: omittedErrors, failedRequests: omittedRequests } : undefined,
     };
 }

package/dist/tools/report-session/preview-report.d.ts

@@ -39,7 +39,7 @@
  */
 import { z } from "zod";
 import { type ResolveWorkspaceRoot } from "../../workspace/paths.js";
-import type { AuthContext } from "../../auth/types.js";
+import type { AuthContext, Identity } from "../../auth/types.js";
 import { type Logger } from "../../lib/logger.js";
 import type { ThreadStore } from "../../memory/thread-store.js";
 import { type ReportWarning } from "../../report-model/block-walk.js";
@@ -134,10 +134,11 @@ export type ResolvePageAsset = (specifier: string) => string;
  * lands, and attaches the URL beside the path. A refused mint rides the `rendered` arm as data, and it
  * never fails the render.
  */
-export interface PreviewReportToolDeps {
+export type PreviewReportToolDeps = {
     readonly gateway: ReportSessionStateGateway;
     readonly makeResolver?: (scope: {
         analysisId: string;
+        identity: Identity;
         auth: AuthContext;
     }) => Promise<ReferenceResolver>;
     readonly resolveWorkspaceRoot: ResolveWorkspaceRoot;
@@ -152,7 +153,7 @@ export interface PreviewReportToolDeps {
     /** Names the report thread after the rendered document. Omitted, the thread keeps its title. */
     readonly threads?: Pick<ThreadStore, "setAutoTitle">;
     readonly logger?: Logger;
-}
+};
 /**
  * Make the render-and-preview tool over the session-state gateway and the render seams.
  *

package/dist/tools/report-session/preview-report.js

@@ -38,7 +38,6 @@
  * control-flow exception propagate.
  */
 import { err, ok } from "neverthrow";
-import { randomUUID } from "node:crypto";
 import { copyFile, mkdir, readdir, rm, writeFile } from "node:fs/promises";
 import { extname, join } from "node:path";
 import { relative as relativePosix } from "node:path/posix";
@@ -70,9 +69,26 @@ const previewReportInput = z.object({});
  * collide on the staged name.
  */
 function assetFileName(file) {
-    const slug = file.hash.replace(/[^a-z0-9]+/gi, "-");
+    const slug = dashUnsafeRuns(file.hash);
     return slug + extname(file.path);
 }
+/** Each run of characters outside the letters and digits becomes one dash. */
+function dashUnsafeRuns(text) {
+    let out = "";
+    let inRun = false;
+    for (const char of text) {
+        const isNameChar = (char >= "a" && char <= "z") || (char >= "A" && char <= "Z") || (char >= "0" && char <= "9");
+        if (isNameChar) {
+            out += char;
+            inRun = false;
+        }
+        else if (!inRun) {
+            out += "-";
+            inRun = true;
+        }
+    }
+    return out;
+}
 /** The relative source of a staged figure. The page directory is self-contained, thus the source is `assets/<name>`. */
 function figureSourcePolicy(file) {
     return `assets/${assetFileName(file)}`;
@@ -360,7 +376,6 @@ export function createPreviewReportTool(deps) {
             "The render marks the page that examine_page looks at next. " +
             "Use it to see the report, and to confirm that each reference resolves.",
         inputSchema: previewReportInput,
-        executionMode: "inline",
         describeCall: "none",
         // The page path is the one fact of a preview that a watcher wants, and it exists only in the
         // result. Each other arm is a degraded condition whose kind already names it, thus the kind
@@ -387,7 +402,7 @@ export function createPreviewReportTool(deps) {
             // control-flow exception propagates and the unresolvable root does not.
             let resolver;
             try {
-                resolver = await deps.makeResolver({ analysisId, auth: ctx.session.auth });
+                resolver = await deps.makeResolver({ analysisId, identity: ctx.session.identity, auth: ctx.session.auth });
             }
             catch (cause) {
                 logger.warn("the workspace root did not resolve", { threadId, analysisId, ...defaultErrorFields(cause) });
@@ -464,16 +479,20 @@ export function createPreviewReportTool(deps) {
                 }
             }
             // The part rides the rendered arm only. Each degraded arm shows no
-            // fresh page, thus it emits nothing.
+            // fresh page, thus it emits nothing. The part id is the id of the call,
+            // thus a rerun of the call gives the same part again.
             await ctx.emit({
                 type: "data-report-rendered",
-                data: { id: randomUUID(), renderedAt: new Date().toISOString(), title: document.title },
+                data: { id: ctx.invocationId, renderedAt: new Date().toISOString(), title: document.title },
             });
             // The event rides the rendered arm alone, the same as the part above. The hash is the hash of
             // the draft that the page shows, thus a consumer ties the page to the document that made it.
             observe({ type: "preview", analysisId, threadId, pagePath: written.value, documentHash: renderedHash });
             const access = await mintAccess(deps.makeSessionPages, analysisId, threadId, ctx.session.auth, logger);
-            return ok({ outcome: "rendered", pagePath: written.value, ...(access !== undefined ? { access } : {}), warnings: finished.warnings });
+            const renderedOk = { outcome: "rendered", pagePath: written.value, warnings: finished.warnings };
+            if (access !== undefined)
+                return ok({ ...renderedOk, access });
+            return ok(renderedOk);
         },
     });
 }

package/dist/tools/report-session/record-version.d.ts

@@ -21,7 +21,9 @@
  * the thread row. A record on a thread that holds a version replaces that version whole, under the same
  * version id. Thus the loop is unbounded: the agent amends, looks again, and records again, and the stored
  * version equals the page that the last look accepted. A refused record leaves the stored version as it was.
- * The outcome of a pass carries the version id, and it names a replacement.
+ * The outcome of a pass carries the version id, and it names a replacement. Inside a durable step, the id
+ * of a new version is the UUIDv5 of the key of the step. Thus a rerun of the step gives the same version, and
+ * it does not read as a replacement.
  *
  * The prune runs after the version lands. It removes the output file of each derivation that the recorded
  * document does not reference, under the `derived/` directory of the session alone. The records stay
@@ -29,7 +31,7 @@
  * changes no outcome.
  */
 import { z } from "zod";
-import type { AuthContext } from "../../auth/types.js";
+import type { AuthContext, Identity } from "../../auth/types.js";
 import type { Logger } from "../../lib/logger.js";
 import type { ThreadStore } from "../../memory/thread-store.js";
 import { type ReportWarning } from "../../report-model/block-walk.js";
@@ -97,19 +99,22 @@ export type RecordVersionResult = {
  * derived directory of the session under that root, thus the seam is mandatory: a composition that bound
  * none would record a version and leave every unused derivation on disk.
  */
-export interface RecordVersionToolDeps {
+export type RecordVersionToolDeps = {
     readonly gateway: ReportSessionStateGateway;
     readonly store: ReportVersionStore;
     readonly threads: Pick<ThreadStore, "getThread">;
     readonly resolveWorkspaceRoot: ResolveWorkspaceRoot;
     readonly makeResolver?: (scope: {
         analysisId: string;
+        identity: Identity;
         auth: AuthContext;
     }) => Promise<ReferenceResolver>;
     /** The provenance seam; an unbound session emit emits nothing and the record runs the same. */
     readonly provenance?: ProvenanceSeam;
     readonly logger?: Logger;
-}
+    /** The key of the durable step that runs the call, `undefined` outside one. Defaults to {@link durableStepKey}. */
+    readonly stepKey?: () => string | undefined;
+};
 /**
  * Make the record tool over the session-state gateway, the version store, the thread store, and the
  * resolver.

package/dist/tools/report-session/record-version.js

@@ -21,7 +21,9 @@
  * the thread row. A record on a thread that holds a version replaces that version whole, under the same
  * version id. Thus the loop is unbounded: the agent amends, looks again, and records again, and the stored
  * version equals the page that the last look accepted. A refused record leaves the stored version as it was.
- * The outcome of a pass carries the version id, and it names a replacement.
+ * The outcome of a pass carries the version id, and it names a replacement. Inside a durable step, the id
+ * of a new version is the UUIDv5 of the key of the step. Thus a rerun of the step gives the same version, and
+ * it does not read as a replacement.
  *
  * The prune runs after the version lands. It removes the output file of each derivation that the recorded
  * document does not reference, under the `derived/` directory of the session alone. The records stay
@@ -41,6 +43,7 @@ import { computeDraftHash } from "../../report-model/draft-hash.js";
 import { validateReport } from "../../report-model/validate.js";
 import { reportSessionDerivedDir, resolveWorkspacePath } from "../../workspace/paths.js";
 import { defineTool } from "../define-tool.js";
+import { durableStepKey, stepUuid } from "../workspace/edit-file.js";
 import { openReportThread } from "../report-authoring/authoring-tools.js";
 import { bindSessionEmit } from "../../provenance/seam.js";
 /** The empty input. The tool records the current draft of the thread, thus it needs no field. */
@@ -124,6 +127,7 @@ async function pruneUnusedDerivations(args) {
 export function createRecordVersionTool(deps) {
     const logger = (deps.logger ?? createNoopLogger()).named("record-report-version");
     const observe = bindSessionEmit(deps.provenance, logger);
+    const stepKey = deps.stepKey ?? durableStepKey;
     return defineTool({
         id: "record_report_version",
         description: "Record the current draft as one report version. The tool runs the whole gate first: it finishes the draft, " +
@@ -134,7 +138,6 @@ export function createRecordVersionTool(deps) {
             "A thread holds one version, thus a later record replaces it whole. Amend the draft, look at the page again, and record again. " +
             "After the version lands, the tool removes the file of each derived table that no block of the recorded report binds.",
         inputSchema: recordVersionInput,
-        executionMode: "inline",
         describeCall: "none",
         // The version id is the one durable product of the first record, thus the created arm names it. A
         // later record writes over that same id, thus the line names the update and never reads as a
@@ -174,7 +177,7 @@ export function createRecordVersionTool(deps) {
             // control-flow exception propagates and the unresolvable root does not.
             let resolver;
             try {
-                resolver = await deps.makeResolver({ analysisId, auth: ctx.session.auth });
+                resolver = await deps.makeResolver({ analysisId, identity: ctx.session.identity, auth: ctx.session.auth });
             }
             catch (cause) {
                 logger.warn("the workspace root did not resolve", { threadId, analysisId, ...logger.errorFields(cause) });
@@ -182,12 +185,14 @@ export function createRecordVersionTool(deps) {
             }
             const validation = await validateReport(finished.document, snapshot, resolver);
             if (!validation.valid) {
-                return ok({
-                    outcome: "invalid",
-                    ...(validation.schemaIssues ? { schemaIssues: validation.schemaIssues } : {}),
-                    ...(validation.duplicateIds ? { duplicateIds: validation.duplicateIds } : {}),
-                    ...(validation.resolutionFailures ? { resolutionFailures: validation.resolutionFailures } : {}),
-                });
+                const invalid = { outcome: "invalid" };
+                if (validation.schemaIssues)
+                    invalid.schemaIssues = validation.schemaIssues;
+                if (validation.duplicateIds)
+                    invalid.duplicateIds = validation.duplicateIds;
+                if (validation.resolutionFailures)
+                    invalid.resolutionFailures = validation.resolutionFailures;
+                return ok(invalid);
             }
             const thread = await deps.threads.getThread(threadId);
             if (thread.isErr()) {
@@ -205,6 +210,8 @@ export function createRecordVersionTool(deps) {
                 threadId,
                 parentThreadId: thread.value.parentThreadId,
                 parentSeq: thread.value.parentSeq,
+                // A rerun of the step gives the same id, thus the version that its first run made reads as created.
+                versionId: stepUuid(stepKey()),
             });
             if (recorded.isOk()) {
                 // The version stands from here, thus the event states a version that a reader can open.

package/dist/tools/report-session/session-page-publisher.d.ts

@@ -17,18 +17,18 @@
 import { type ResultAsync } from "neverthrow";
 import type { AuthContext } from "../../auth/types.js";
 /** The grant of one session page: the content-server base, the token, and its expiry. */
-export interface SessionPageGrant {
+export type SessionPageGrant = {
     readonly baseUrl: string;
     readonly token: string;
     readonly expiresAt: string;
-}
+};
 /** What a failed mint is allowed to carry. */
-export interface SessionPageMintFailure {
+export type SessionPageMintFailure = {
     readonly status?: number;
     readonly error: {
         readonly message?: string;
     };
-}
+};
 /**
  * Renders a failed mint as the line an agent reads back from the preview tool.
  *
@@ -38,7 +38,7 @@ export interface SessionPageMintFailure {
  * It lives beside the type because its whole job is to honour that type's optionality.
  */
 export declare function describeSessionPageMintFailure(failure: SessionPageMintFailure): string;
-export interface SessionPagePublisher {
+export type SessionPagePublisher = {
     /**
      * Mint the access grant of one session page. The publisher binds the analysis, thus the mint takes
      * the thread id alone. `baseUrl` is the base URL of the content server, with no res path — the
@@ -46,7 +46,7 @@ export interface SessionPagePublisher {
      * contract and never in a realization.
      */
     mintSessionPageAccess(threadId: string): ResultAsync<SessionPageGrant, SessionPageMintFailure>;
-}
+};
 /**
  * The per-call construction of the publisher. The factory binds one analysis and the auth of the tool
  * call, thus a realization mints under the credential of the caller and holds no ambient state.

package/dist/tools/research/generate-analogy-report.d.ts

@@ -2,18 +2,25 @@
  * generateAnalogyReport — cross-domain analogy report as a sub-agent tool.
  *
  * An inline harness `AgentDefinition` (mirroring `createLiteratureReviewerTool`)
- * driven by `runToTerminal`. The result reaches the wrapper through one of two
- * terminal tools because the output envelope is a union and `defineTool` takes
- * only a top-level object. A run with no outcome gets one salvage continuation,
- * then an `extraction-failed` envelope, so the frontend never renders raw prose.
+ * driven by `runWithSalvage`. The result reaches the wrapper through one of two
+ * submit tools because the output envelope is a union and `defineTool` takes
+ * only a top-level object. Neither tool ends the run: the wrapper selects the
+ * last accepted report from the recorded calls, else the first blocker. A run
+ * with no outcome gets one salvage request, then an `extraction-failed`
+ * envelope, so the frontend never renders raw prose.
  */
 import { z } from "zod";
+import { type AnalogyReport } from "@inflexa-ai/harness/contracts/analogy-report.js";
 import type { Logger } from "../../lib/logger.js";
+import { type LoopStep } from "../../loop/run-loop.js";
+import type { SubAgentRegistrar } from "../../loop/sub-agent.js";
 import type { ToolOutputStore } from "../../loop/tool-output.js";
 import type { ChatProvider } from "../../providers/types.js";
 import type { UsageRecorder } from "../../billing/usage-recorder.js";
 import { type Tool } from "../define-tool.js";
 import { type BioToolKeys } from "../bio/keys.js";
+/** The last report of a run that its call accepted. The input schema of the tool checked it. */
+export declare function acceptedReportOf(steps: readonly LoopStep[]): AnalogyReport | undefined;
 export declare const generateAnalogyReportInputSchema: z.ZodObject<{
     problem: z.ZodString;
     context: z.ZodOptional<z.ZodString>;
@@ -29,7 +36,7 @@ export type GenerateAnalogyReportInput = z.infer<typeof generateAnalogyReportInp
  * Exported for unit testing.
  */
 export declare function buildResearchPrompt(input: GenerateAnalogyReportInput): string;
-export interface GenerateAnalogyReportDeps {
+export type GenerateAnalogyReportDeps = {
     /** The LLM seam the child loop runs on. */
     readonly provider: ChatProvider;
     /** Model id — provenance / metric label; the provider owns the wire model. */
@@ -42,6 +49,6 @@ export interface GenerateAnalogyReportDeps {
     readonly toolOutputStore?: ToolOutputStore;
     /** Logging seam; omitted falls back to no-op. Logs the salvage warning and an accounting error of the reasoner loop. */
     readonly logger?: Logger;
-}
+};
 /** Build the `generate_analogy_report` delegation tool bound to its provider. */
-export declare function createGenerateAnalogyReportTool(deps: GenerateAnalogyReportDeps): Tool;
+export declare function createGenerateAnalogyReportTool(deps: GenerateAnalogyReportDeps, registerSubAgent: SubAgentRegistrar): Tool;