@inflexa-ai/harness 0.37.0 → 0.39.0

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

@@ -350,7 +350,7 @@ async function sweepAssets(assetsDir, staged, logger) {
  *
  * An absent factory gives no grant, and the arm carries no access field — the page path stays the whole
  * local contract. The tool builds the publisher over the scope of the call, thus the mint runs under the
- * auth of the caller. A refusal, a thrown construction, and a thrown realization each become the
+ * auth of the caller. An `err`, a thrown construction, and a rejected realization each become the
  * not-granted arm, thus a broken grant surface never costs the render. The URL spells through
  * `buildReportSessionUrl`, thus the formula lives in the contract and the seam gives the content-server
  * base alone.
@@ -359,22 +359,24 @@ async function mintAccess(makeSessionPages, analysisId, threadId, auth, logger)
     if (makeSessionPages === undefined) {
         return undefined;
     }
-    let minted;
+    let grant;
     try {
-        minted = await makeSessionPages({ analysisId, auth }).mintSessionPageAccess(threadId);
+        const minted = await makeSessionPages({ analysisId, auth }).mintSessionPageAccess(threadId);
+        if (minted.isErr()) {
+            const detail = describeSessionPageMintFailure(minted.error);
+            logger.warn("the session-page mint refused", { threadId, analysisId, detail });
+            return { granted: false, detail };
+        }
+        grant = minted.value;
     }
     catch (cause) {
         logger.warn("the session-page mint threw", { threadId, analysisId, ...defaultErrorFields(cause) });
         return { granted: false, detail: "session-page-access mint failed" };
     }
-    if (!minted.ok) {
-        logger.warn("the session-page mint refused", { threadId, analysisId, detail: describeSessionPageMintFailure(minted) });
-        return { granted: false, detail: describeSessionPageMintFailure(minted) };
-    }
     return {
         granted: true,
-        url: buildReportSessionUrl(minted.data.baseUrl, analysisId, threadId, "index.html", minted.data.token),
-        expiresAt: minted.data.expiresAt,
+        url: buildReportSessionUrl(grant.baseUrl, analysisId, threadId, "index.html", grant.token),
+        expiresAt: grant.expiresAt,
     };
 }
 /**

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

@@ -11,28 +11,24 @@
  * tool call, thus the composition binds a factory and the preview tool builds the publisher over the
  * scope of the call — exactly as it builds the reference resolver. A boot-time singleton could not
  * carry that credential, and a host that bans ambient state could not bind one at all. The local
- * default (`UnavailableSessionPagePublisher`) returns not-ok, thus the preview tool attaches no URL
+ * default (`UnavailableSessionPagePublisher`) gives an `err`, thus the preview tool attaches no URL
  * and the render still lands — the page path stays the whole local contract.
  */
+import { type ResultAsync } from "neverthrow";
 import type { AuthContext } from "../../auth/types.js";
-export type SessionPageMintResult = {
-    ok: true;
-    data: {
-        baseUrl: string;
-        token: string;
-        expiresAt: string;
-    };
-} | {
-    ok: false;
-    status?: number;
-    error: {
-        message?: string;
+/** The grant of one session page: the content-server base, the token, and its expiry. */
+export interface SessionPageGrant {
+    readonly baseUrl: string;
+    readonly token: string;
+    readonly expiresAt: string;
+}
+/** What a failed mint is allowed to carry. */
+export interface SessionPageMintFailure {
+    readonly status?: number;
+    readonly error: {
+        readonly message?: string;
     };
-};
-/** The not-ok arm of the seam's result — what a failed mint is allowed to carry. */
-export type SessionPageMintFailure = Extract<SessionPageMintResult, {
-    ok: false;
-}>;
+}
 /**
  * Renders a failed mint as the line an agent reads back from the preview tool.
  *
@@ -49,7 +45,7 @@ export interface SessionPagePublisher {
      * caller spells the whole URL through `buildReportSessionUrl`, thus the formula lives in the
      * contract and never in a realization.
      */
-    mintSessionPageAccess(threadId: string): Promise<SessionPageMintResult>;
+    mintSessionPageAccess(threadId: string): ResultAsync<SessionPageGrant, SessionPageMintFailure>;
 }
 /**
  * The per-call construction of the publisher. The factory binds one analysis and the auth of the tool
@@ -60,9 +56,9 @@ export type MakeSessionPagePublisher = (scope: {
     auth: AuthContext;
 }) => SessionPagePublisher;
 /**
- * Local default — no hosted view of a session page. Returns not-ok, thus the preview tool carries the
+ * Local default — no hosted view of a session page. Gives an `err`, thus the preview tool carries the
  * refusal as data and the page path stays the whole result.
  */
 export declare class UnavailableSessionPagePublisher implements SessionPagePublisher {
-    mintSessionPageAccess(_threadId: string): Promise<SessionPageMintResult>;
+    mintSessionPageAccess(_threadId: string): ResultAsync<SessionPageGrant, SessionPageMintFailure>;
 }

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

@@ -11,9 +11,10 @@
  * tool call, thus the composition binds a factory and the preview tool builds the publisher over the
  * scope of the call — exactly as it builds the reference resolver. A boot-time singleton could not
  * carry that credential, and a host that bans ambient state could not bind one at all. The local
- * default (`UnavailableSessionPagePublisher`) returns not-ok, thus the preview tool attaches no URL
+ * default (`UnavailableSessionPagePublisher`) gives an `err`, thus the preview tool attaches no URL
  * and the render still lands — the page path stays the whole local contract.
  */
+import { errAsync } from "neverthrow";
 /**
  * Renders a failed mint as the line an agent reads back from the preview tool.
  *
@@ -32,14 +33,11 @@ export function describeSessionPageMintFailure(failure) {
     return detail.length > 0 ? `session-page-access mint failed: ${detail.join(" ")}` : "session-page-access mint failed";
 }
 /**
- * Local default — no hosted view of a session page. Returns not-ok, thus the preview tool carries the
+ * Local default — no hosted view of a session page. Gives an `err`, thus the preview tool carries the
  * refusal as data and the page path stays the whole result.
  */
 export class UnavailableSessionPagePublisher {
-    async mintSessionPageAccess(_threadId) {
-        return {
-            ok: false,
-            error: { message: "the hosted view of a session page is unavailable in this environment" },
-        };
+    mintSessionPageAccess(_threadId) {
+        return errAsync({ error: { message: "the hosted view of a session page is unavailable in this environment" } });
     }
 }

package/dist/tools/research/inspect-run.d.ts

@@ -53,7 +53,7 @@ declare function formatRun(r: CortexRunRow, verbose: boolean, exposePaths?: bool
     synthesisReason?: string | undefined;
     runId: string;
     workflowName: string;
-    status: "running" | "completed" | "failed" | "partial" | "canceled" | "suspended_insufficient_funds";
+    status: "failed" | "running" | "completed" | "partial" | "canceled" | "suspended_insufficient_funds";
     startedAt: string;
     completedAt: string | null;
     planId: string | null;

package/dist/tools/sandbox/link-packages.d.ts

@@ -13,6 +13,8 @@
  * capability, thus the agent learns one grammar for the plan, the tool, and
  * the prompt layer.
  */
+import { type Result } from "neverthrow";
+import { type PackageQuery } from "../../sandbox/package-identity.js";
 import type { ExtendAnalysisFarm, PackageRequestOutcome } from "../../sandbox/types.js";
 export interface LinkPackagesDeps {
     readonly extendAnalysisFarm: ExtendAnalysisFarm;
@@ -22,6 +24,12 @@ export interface LinkPackagesDeps {
 export interface LinkPackagesResult {
     readonly outcomes: readonly PackageRequestOutcome[];
 }
+/**
+ * Call the seam, and give the outcomes or the one reason that the call gave
+ * no answer. An `err` and a rejected realization each give that reason, thus
+ * no call site sees a throw.
+ */
+export declare function callExtendAnalysisFarm(extendAnalysisFarm: ExtendAnalysisFarm, analysisId: string, queries: readonly PackageQuery[]): Promise<Result<readonly PackageRequestOutcome[], string>>;
 export declare function createLinkPackagesTool(deps: LinkPackagesDeps): import("../define-tool.js").Tool<{
     packages: string[];
 }, LinkPackagesResult>;

package/dist/tools/sandbox/link-packages.js

@@ -34,6 +34,19 @@ function describeParseError(entry, error) {
             return `"${entry}" pins with the specifier "${error.specifier}", which this tool cannot honor — pass a bare name, or name==version with one exact version`;
     }
 }
+/**
+ * Call the seam, and give the outcomes or the one reason that the call gave
+ * no answer. An `err` and a rejected realization each give that reason, thus
+ * no call site sees a throw.
+ */
+export async function callExtendAnalysisFarm(extendAnalysisFarm, analysisId, queries) {
+    try {
+        return (await extendAnalysisFarm(analysisId, queries)).mapErr((failure) => failure.reason);
+    }
+    catch (cause) {
+        return err(cause instanceof Error ? cause.message : String(cause));
+    }
+}
 export function createLinkPackagesTool(deps) {
     return defineTool({
         id: "link_packages",
@@ -67,17 +80,14 @@ export function createLinkPackagesTool(deps) {
                 }
                 queries.push(parsed.value);
             }
-            // A realization throw reads as `unavailable` per query. The loop
-            // would render the throw as a raw tool error, and a raw driver
-            // message teaches the agent nothing that `reason` does not.
-            try {
-                const outcomes = await deps.extendAnalysisFarm(deps.analysisId, queries);
-                return ok({ outcomes });
-            }
-            catch (cause) {
-                const reason = cause instanceof Error ? cause.message : String(cause);
+            // A call that gave no answer reads as `unavailable` per query. A
+            // raw tool error teaches the agent nothing that `reason` does not.
+            const linked = await callExtendAnalysisFarm(deps.extendAnalysisFarm, deps.analysisId, queries);
+            if (linked.isErr()) {
+                const reason = linked.error;
                 return ok({ outcomes: queries.map((query) => ({ kind: "unavailable", spelling: query.spelling, reason })) });
             }
+            return ok({ outcomes: linked.value });
         },
     });
 }

package/dist/workflows/execute-analysis.d.ts

@@ -31,23 +31,30 @@
  *     - await child results via `getResult` (these are themselves cached
  *       in DBOS, so parent recovery does NOT re-run completed children)
  *  3. Failure isolation
- *     - a child settling `failed`/`blocked` (or throwing for a non-budget
- *       cause) dooms only its transitive dependents: they can never become
- *       dependency-satisfied, are marked `skipped` on the dag-state part, and
- *       are never dispatched. In-flight siblings and independent ready steps
- *       continue; the loop drains and the run finalises (typically `partial`).
+ *     - a child settling `failed`/`blocked` (or throwing for a cause that is
+ *       not a suspension) dooms only its transitive dependents: they can never
+ *       become dependency-satisfied, are marked `skipped` on the dag-state
+ *       part, and are never dispatched. In-flight siblings and independent
+ *       ready steps continue; the loop drains and the run finalises (typically
+ *       `partial`).
  *     - the halt cascade (cancel in-flight via
  *       `Promise.allSettled(handles.map(h => DBOS.cancelWorkflow(h.workflowID)))`,
- *       stop scheduling) survives only for the budget paths: a
- *       `budget_exceeded` settlement and the `neverFits` plan-validation guard.
- *  4. Pause cascade (402)
- *     - on a child cancelling itself with `budget_exceeded`: cancel siblings
- *       then self-cancel the parent to `CANCELLED` (NOT `ERROR` — ERROR
- *       isn't resumable; NOTES #3)
+ *       stop scheduling) survives only for a suspension of a child and the
+ *       `neverFits` plan-validation guard.
+ *  4. Suspension cascade (workflow-suspension spec)
+ *     - a child that suspends sends a typed message on `CHILD_SUSPENDED_TOPIC`
+ *       and cancels itself. The parent reads the kind of the message, never a
+ *       reason string: it cancels the siblings, then self-cancels to
+ *       `CANCELLED` (NOT `ERROR` — ERROR isn't resumable; NOTES #3)
+ *     - a refusal of the `RunCharge.open` gate with the suspend flag suspends
+ *       the run before any step starts
+ *     - a `suspend` error of a synthesis model request suspends the run in
+ *       place of the synthesis failure
  *     - the analysis flips to `suspended_insufficient_funds` in
  *       `collectAndComplete`. The paused parent lands in `CANCELLED`, a
- *       durably reschedulable state; re-driving it after a top-up is a
- *       future enhancement, not yet wired here.
+ *       durably reschedulable state; re-driving it is a future enhancement,
+ *       not yet wired here. The reason of the host rides to the run row, the
+ *       charge close, the metric, and the terminal part, unread.
  *  5. `synthesizeFindings` (single sequential block, no sandbox)
  *  6. `collectAndComplete` (terminal — runs on ALL paths)
  *     - determine final status from completed/cancelled/failed counts
@@ -77,6 +84,7 @@ import type { RunCharge } from "../billing/run-charge.js";
 import { type ResolveWorkspaceRoot } from "../workspace/paths.js";
 import { type PlanStep } from "./execute-analysis-scheduler.js";
 import { type SandboxStepInput, type SandboxStepResult } from "./sandbox-step.js";
+import { type Suspension } from "./suspension.js";
 /** Registered child sandbox-step callable the parent's child-dispatch closes over. */
 type SandboxStepCallable = (input: SandboxStepInput) => Promise<SandboxStepResult>;
 /** Quick-display finding on the run-completed card. Mirrors the wire schema's RunCompletedFinding. */
@@ -320,13 +328,14 @@ export declare function composeStepSeed(args: {
  * its reason in `blockedReason` — an honest agent-declared blocker, not an
  * error — and a failure carries the same reason string
  * `persist-synthesis-outcome` writes to `cortex_runs.synthesis_reason`, so the
- * two ledgers cannot disagree about why synthesis died. Exported for the
- * projection tests (the `buildChildInput` pattern).
+ * two ledgers cannot disagree about why synthesis died. A suspension is not an
+ * outcome: the row is canceled, as the row of a suspended step. Exported for
+ * the projection tests (the `buildChildInput` pattern).
  */
 export declare function synthesisRowUpdate(outcome: {
     status: SynthesisStatus;
     reason: string | null;
-}, durationMs: number): UpdateStepExecutionInput;
+} | Suspension, durationMs: number): UpdateStepExecutionInput;
 /**
  * Run-level literature-grounded synthesis (no sandbox). Returns the
  * quick-display findings for the run-completed card; empty when synthesis is