@reticlehq/server 3.7.0 → 3.8.1

package/dist/features/harness/drive-runs.js

@@ -10,7 +10,8 @@
  * No I/O and no tool surface: what to run and where to write it arrive as functions, so this stays
  * a sink the surface hands things to.
  */
-import { ReticleTool } from '@reticlehq/core';
+import { HarnessRunReason } from '@reticlehq/core/telemetry';
+import { EventType, HARNESS_LINES_MAX, NetInitiator, ReticleTool, asRecord, } from '@reticlehq/core';
 export const DriveStatus = {
     RUNNING: 'running',
     DONE: 'done',
@@ -24,9 +25,22 @@ export const DriveStatus = {
  * such a run as "broken", which reads as a fault in the Harness; a refusal is a refusal.
  */
 export class DriveRefusedError extends Error {
+    reason;
+    constructor(message, 
+    /** Why, as `harness_run` reports it. */
+    reason = HarnessRunReason.OTHER) {
+        super(message);
+        this.reason = reason;
+    }
 }
 /** Who asked for the drive. */
 export const DriveOrigin = { AGENT: 'agent', HUD: 'hud', CHAT: 'chat', TRY: 'try' };
+/** The longest line the Harness page's log is sent. */
+const LINE_MAX = 300;
+/** Per tab: how its last drive ended, or why none started. Cleared when a drive starts there. */
+const lastWords = new Map();
+/** Numbers each last word, so the page can tell a new answer from one it already showed. */
+let wordSeq = 0;
 /** Finished drives kept for polling; older ones are read back from disk. */
 const MAX_FINISHED = 50;
 const LANE_SUFFIX = /-L\d+$/;
@@ -52,7 +66,10 @@ export function startDrive(start) {
         abort: new AbortController(),
         inbox: [],
         waiters: new Set(),
+        lines: [],
     };
+    if (start.sessionId !== undefined)
+        lastWords.delete(start.sessionId);
     entries.set(start.runId, entry);
     byHarness.set(start.harness, entry);
     const save = () => {
@@ -78,6 +95,7 @@ export function startDrive(start) {
     })
         .then(() => {
         entry.record.endedAt = start.now();
+        noteLastWord(entry);
         save();
         changed(entry, true);
         prune();
@@ -137,14 +155,71 @@ export function awaitDrive(runId, ms, signal, onChange) {
             done();
     });
 }
-/** Ask a running drive to stop. False when there is no such drive running. */
-export function stopDrive(runId) {
+/**
+ * Ask a running drive to stop. False when there is no such drive running. `reason` is said on the
+ * Harness page when something other than the person stopped it (the page reloaded).
+ */
+export function stopDrive(runId, reason) {
     const entry = entries.get(runId);
     if (entry === undefined || DriveStatus.RUNNING !== entry.record.status)
         return false;
+    if (reason !== undefined)
+        entry.stopReason = reason;
     entry.abort.abort();
     return true;
 }
+/** Why no drive started on this tab (a refusal, the cloud unreachable), for its Harness page. */
+export function noteHarnessWord(sessionId, said) {
+    wordSeq += 1;
+    lastWords.set(sessionId, { said, seq: wordSeq });
+}
+/** How this drive ended, for its tab's Harness page: the run's result, and why when it fell short. */
+function noteLastWord(entry) {
+    const sessionId = entry.record.sessionId;
+    if (sessionId === undefined)
+        return;
+    const runUrl = entry.record.result?.['runUrl'];
+    const fell = DriveStatus.BROKEN === entry.record.status || DriveStatus.REFUSED === entry.record.status
+        ? entry.record.error
+        : undefined;
+    const said = entry.stopReason ?? fell;
+    wordSeq += 1;
+    lastWords.set(sessionId, {
+        seq: wordSeq,
+        ...('string' === typeof runUrl ? { runUrl } : {}),
+        ...(said === undefined ? {} : { said }),
+    });
+}
+/** Said on the Harness page when a person reloads the page during a run. */
+export const MSG_RELOADED = 'The page reloaded, so this run stopped. Run again.';
+/** How long after the daemon asks a tab to reload the page's reload counts as the daemon's. */
+const OWN_RELOAD_WINDOW_MS = 60_000;
+const RELOAD = 'reload';
+/** Per tab: when the daemon last sent it a reload (a replay, a durable recheck, a navigate). */
+const ownReloads = new Map();
+/** The daemon asked this tab to reload: the page coming back is not a person reloading it. */
+export function noteOwnReload(sessionId, at) {
+    ownReloads.set(sessionId, at);
+}
+/**
+ * Read each event a tab sends. A document that arrives as a reload the daemon did not ask for is a
+ * person reloading the page, and a drive on that tab cannot go on as if the page had not started
+ * over: it is stopped, and its Harness page says why. Before, it drove on and ended "failed".
+ */
+export function notePageLoaded(sessionId, event, at) {
+    if (EventType.NET_REQUEST !== event.type)
+        return;
+    const data = asRecord(event.data);
+    if (NetInitiator.DOCUMENT !== data['initiator'] || RELOAD !== data['navigationType'])
+        return;
+    const asked = ownReloads.get(sessionId);
+    ownReloads.delete(sessionId);
+    if (asked !== undefined && at - asked <= OWN_RELOAD_WINDOW_MS)
+        return;
+    const running = runningDrive(sessionId);
+    if (running?.sessionId === sessionId)
+        stopDrive(running.harnessRun, MSG_RELOADED);
+}
 /** Queue text for the driver's next turn. False when there is no such drive running. */
 export function sayToDrive(runId, text) {
     const entry = entries.get(runId);
@@ -177,6 +252,9 @@ export function noteDriveLine(harness, line) {
     if (entry === undefined)
         return;
     entry.record.lastLine = line;
+    entry.lines.push(line.length > LINE_MAX ? `${line.slice(0, LINE_MAX)}…` : line);
+    if (entry.lines.length > HARNESS_LINES_MAX)
+        entry.lines.shift();
     changed(entry, false);
 }
 /** Hear every step a drive takes, so a panel showing its count can repaint. Returns the unsubscribe. */
@@ -205,6 +283,8 @@ export function forgetDrives() {
     entries.clear();
     byHarness.clear();
     notes.clear();
+    lastWords.clear();
+    ownReloads.clear();
 }
 function entryFor(harness) {
     return byHarness.get(harness) ?? byHarness.get(harness.replace(LANE_SUFFIX, ''));
@@ -279,11 +359,23 @@ function prune() {
         byHarness.delete(entry.harness);
     }
 }
-/** The impact snapshot, with the drive running on this tab when there is one. */
+/**
+ * The impact snapshot, with the drive running on this tab and its step log when there is one, else
+ * how the last one on this tab ended.
+ */
 export function withRunningDrive(snapshot, sessionId) {
-    const running = runningDrive(sessionId);
-    if (running === undefined || snapshot === undefined)
+    if (snapshot === undefined)
         return snapshot;
-    const drive = { runId: running.harnessRun, steps: running.steps };
+    const running = runningDrive(sessionId);
+    if (running === undefined) {
+        const last = lastWords.get(sessionId);
+        return last === undefined ? snapshot : { ...snapshot, lastDrive: last };
+    }
+    const lines = entries.get(running.harnessRun)?.lines ?? [];
+    const drive = {
+        runId: running.harnessRun,
+        steps: running.steps,
+        ...(0 === lines.length ? {} : { lines: [...lines] }),
+    };
     return { ...snapshot, harnessDrive: drive };
 }

package/dist/features/harness/drivers.d.ts

@@ -5,7 +5,7 @@
  * a module that imports nothing cannot be read half-initialised.
  *
  * There is one driver. Every Harness decision, its models and its planning run on the Reticle
- * platform, on the workspace's Harness credits; this machine executes what it is told.
+ * platform, on the workspace's credits; this machine executes what it is told.
  */
 /** The platform's Harness: it decides on its side, this machine executes. See server-driver.ts. */
 export declare const SERVER_DRIVER = "server";

package/dist/features/harness/drivers.js

@@ -5,7 +5,7 @@
  * a module that imports nothing cannot be read half-initialised.
  *
  * There is one driver. Every Harness decision, its models and its planning run on the Reticle
- * platform, on the workspace's Harness credits; this machine executes what it is told.
+ * platform, on the workspace's credits; this machine executes what it is told.
  */
 /** The platform's Harness: it decides on its side, this machine executes. See server-driver.ts. */
 export const SERVER_DRIVER = 'server';

package/dist/features/harness/harness.d.ts

@@ -96,6 +96,11 @@ export interface ModelDriver {
         tools: readonly HarnessTool[];
         history: readonly HistoryEntry[];
     }): Promise<ModelTurn>;
+    /**
+     * The credits the drive spent, asked once it ended without the driver's own `finish` saying so (a
+     * goal reached on the page, the step budget, a stop). Absent for a driver that cannot tell.
+     */
+    spent?(): Promise<number | undefined>;
 }
 /** Why a run stopped. Every one of these is a real outcome; none of them is an error. */
 export declare const StopReason: {

package/dist/features/harness/harness.js

@@ -139,8 +139,13 @@ export const FINISH_TOOL = {
         additionalProperties: false,
     },
 };
-/** Why a drive ended before the model said so. */
-const msgReachedEnd = (end) => `Reached the end the goal names ("${end}") after a check held, so the drive stopped there.`;
+/**
+ * Said to the model once the page shows the end the goal quotes. The drive used to stop right here,
+ * before the model's `finish`, and that skipped the platform's last check: it holds the finish and
+ * asserts the claim's values on the drive's own writes. On the broken checkout the page showed
+ * "charged $133.60" while the order went out at 16700, and the drive stopped as goal met.
+ */
+const msgEndReached = (end) => `The page shows the end the goal names ("${end}") and a check held. Do not drive further. Call \`finish\` now.`;
 /** A check in this turn that came back yes: the moment worth looking for the end. */
 const heldCheck = (outcome) => isProof(outcome) && Verified.YES === asRecord(outcome.result)['verified'];
 export const DEFAULT_MAX_STEPS = 40;
@@ -222,6 +227,15 @@ export function systemPrompt(focus, routes = []) {
  * through `driver` and `toolset`, which is what makes this testable against a scripted model.
  */
 export async function runHarness(driver, toolset, options = {}) {
+    const result = await driveToEnd(driver, toolset, options);
+    // A drive ended here (its goal on the page, the budget, a stop) never heard the platform's last
+    // word on spend, and a plan summed it as 0 while the workspace paid 3.5 (night 7).
+    if (result.creditsSpent !== undefined || driver.spent === undefined)
+        return result;
+    const spent = await driver.spent().catch(() => undefined);
+    return spent === undefined ? result : { ...result, creditsSpent: spent };
+}
+async function driveToEnd(driver, toolset, options) {
     const maxSteps = options.maxSteps ?? DEFAULT_MAX_STEPS;
     const tools = [...toolset.tools, FINISH_TOOL];
     const routes = options.routes ?? [];
@@ -231,6 +245,8 @@ export async function runHarness(driver, toolset, options = {}) {
     const usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
     const proved = () => toolCalls.some(isProof);
     let askedToProve = false;
+    // Set once the page showed the goal's end and the model was told to finish.
+    let endTold = false;
     // Actions that just changed nothing; forgotten as soon as any action moves the page.
     const inert = new Set();
     for (let step = 0; step < maxSteps; step += 1) {
@@ -357,18 +373,14 @@ export async function runHarness(driver, toolset, options = {}) {
         toolCalls.push(...outcomes);
         history.push({ role: 'tool', outcomes });
         const end = options.endsAt;
-        if (end !== undefined &&
+        if (!endTold &&
+            end !== undefined &&
             outcomes.some(heldCheck) &&
             (await lookFor((name, args) => toolset.invoke(name, args), end.text, end.own))) {
-            return {
-                stopReason: StopReason.FINISHED,
-                summary: msgReachedEnd(end.text),
-                steps: step + 1,
-                toolCalls,
-                usage,
-                proved: proved(),
-                goalMet: true,
-            };
+            // The verdict is the finish's, never the page's: tell the model, and let its finish (which
+            // the platform may hold to read and assert first) end the drive. The step budget bounds it.
+            history.push({ role: 'user', text: msgEndReached(end.text) });
+            endTold = true;
         }
     }
     return {

package/dist/features/harness/platform/platform-drives.d.ts

@@ -5,6 +5,11 @@
  * Both answer with a value and never throw: an unreachable platform is a sentence to show, not a
  * crash in the CLI or in the HUD's button handler.
  */
+/**
+ * How long the grant is waited for. A cloud that takes the connection and never answers held the
+ * HUD's Run on "Starting…" with no bound; past this, the person is told it did not answer.
+ */
+export declare const GRANT_TIMEOUT_MS = 5000;
 /** What the grant is for: `reticle try`'s one drive, or a drive started from the HUD or an agent. */
 export declare const FreeDriveKind: {
     readonly TRY: "try";
@@ -16,6 +21,7 @@ export type PlatformFetch = (url: string, init: {
     method: string;
     headers: Record<string, string>;
     body?: string;
+    signal?: AbortSignal;
 }) => Promise<{
     status: number;
     text(): Promise<string>;
@@ -37,7 +43,7 @@ interface Platform {
 /** The dashboard page where a trial starts, at the origin of whatever link the platform gave. */
 export declare function planUrl(dashboard: string): string;
 /** Ask the platform for a drive it will pay for. Every failure is an answer, never a throw. */
-export declare function requestFreeDrive(platform: Platform, kind: FreeDriveKind, doFetch?: PlatformFetch): Promise<FreeDrive>;
+export declare function requestFreeDrive(platform: Platform, kind: FreeDriveKind, doFetch?: PlatformFetch, timeoutMs?: number): Promise<FreeDrive>;
 /**
  * A synced run as the explore poll answers it, in the poll's own fields.
  *

package/dist/features/harness/platform/platform-drives.js

@@ -10,6 +10,11 @@ const RUNS_PATH = '/v1/runs';
 const NEEDS_CARD = 'needs_card';
 const HTTP_PAYMENT_REQUIRED = 402;
 const HTTP_NOT_FOUND = 404;
+/**
+ * How long the grant is waited for. A cloud that takes the connection and never answers held the
+ * HUD's Run on "Starting…" with no bound; past this, the person is told it did not answer.
+ */
+export const GRANT_TIMEOUT_MS = 5_000;
 /** Where a workspace starts its trial: the dashboard's billing settings, at its origin. */
 const PLAN_PATH = '/settings?group=billing';
 /** What the grant is for: `reticle try`'s one drive, or a drive started from the HUD or an agent. */
@@ -40,12 +45,13 @@ export function planUrl(dashboard) {
     }
 }
 /** Ask the platform for a drive it will pay for. Every failure is an answer, never a throw. */
-export async function requestFreeDrive(platform, kind, doFetch = defaultFetch) {
+export async function requestFreeDrive(platform, kind, doFetch = defaultFetch, timeoutMs = GRANT_TIMEOUT_MS) {
     try {
         const res = await doFetch(`${base(platform)}${FREE_DRIVE_PATH}`, {
             method: 'POST',
             headers: headers(platform),
             body: JSON.stringify({ kind }),
+            signal: AbortSignal.timeout(timeoutMs),
         });
         const body = record(await res.text());
         const driveId = str(body['driveId']);
@@ -61,14 +67,13 @@ export async function requestFreeDrive(platform, kind, doFetch = defaultFetch) {
             ...(hint === undefined ? {} : { hint }),
         };
     }
-    catch (error) {
-        return {
-            granted: false,
-            needsCard: false,
-            message: `Could not reach the Reticle platform: ${error instanceof Error ? error.message : String(error)}`,
-        };
+    catch {
+        // One line the Harness page can show as it is: the person can fix a connection, not a stack.
+        return { granted: false, needsCard: false, message: msgCloudSilent(base(platform)) };
     }
 }
+/** Said when the platform cannot be reached at all. */
+const msgCloudSilent = (url) => `Reticle Cloud at ${url} did not answer, so the Harness cannot start. Check your connection, then Run again.`;
 const DRIVE_DONE = 'done';
 const msgFromDashboard = (verdict, checks) => `From the dashboard (the drive itself is no longer on this machine): ${verdict === undefined ? 'no verdict recorded' : `verdict ${verdict}`}, ${String(checks)} check${1 === checks ? '' : 's'}.`;
 /**

package/dist/features/harness/platform/refusal.d.ts

@@ -17,7 +17,7 @@ export declare const PlatformRefusalCode: {
 export declare const RefusalLead: {
     readonly harness_locked: "Reticle Harness is locked for this project.";
     readonly harness_off: "The Reticle Harness is off for this project.";
-    readonly needs_card: "Reticle Harness credits are used up for this workspace.";
+    readonly needs_card: "This workspace has used all of its Reticle credits.";
 };
 /** A platform refusal, read from its response body. Two shapes: nested `{ error: { code, message } }` and flat `{ error, message }`. */
 export declare function readRefusal(text: string): {

package/dist/features/harness/platform/refusal.js

@@ -17,7 +17,7 @@ export const PlatformRefusalCode = {
 export const RefusalLead = {
     [PlatformRefusalCode.HARNESS_LOCKED]: 'Reticle Harness is locked for this project.',
     [PlatformRefusalCode.HARNESS_OFF]: 'The Reticle Harness is off for this project.',
-    [PlatformRefusalCode.NEEDS_CARD]: 'Reticle Harness credits are used up for this workspace.',
+    [PlatformRefusalCode.NEEDS_CARD]: 'This workspace has used all of its Reticle credits.',
 };
 /** A platform refusal, read from its response body. Two shapes: nested `{ error: { code, message } }` and flat `{ error, message }`. */
 export function readRefusal(text) {
@@ -55,9 +55,9 @@ export function refusalSentence(refusal, status) {
  * Absent means OFF. The Harness is opt-in: a new project starts with it off, and an answer that does
  * not say it is on is not a yes to spend credits on.
  */
-export const MSG_HARNESS_DISABLED = "The Reticle Harness is off for this project. The user can switch it on in the HUD's Settings " +
-    'or the Reticle dashboard (Settings → Projects → Reticle Harness on <project>); until then, drive the app yourself ' +
-    'through the MCP tools.';
+export const MSG_HARNESS_DISABLED = "The Reticle Harness is off for this project. Each drive spends the workspace's credits, so the " +
+    'user switches it on: ask them to run `npx @reticlehq/server config --harness on` in the project. ' +
+    'Until then, drive the app yourself through the MCP tools.';
 /**
  * The other reason a drive can be refused, and it is NOT the same reason.
  *

package/dist/features/harness/platform/remote-drive.js

@@ -44,11 +44,13 @@ export function startRemoteDrives(deps) {
     let busy = false;
     let stopped = false;
     const tick = async (told) => {
-        if (busy || stopped || (undefined === told && !deps.connected()))
+        if (busy || stopped || (undefined === told && !deps.connected())) {
             return;
+        }
         const platform = told ?? serverOptionsFromEnv(await deps.env());
-        if (platform === undefined)
+        if (platform === undefined) {
             return;
+        }
         const headers = {
             'content-type': 'application/json',
             authorization: `Bearer ${platform.apiKey}`,
@@ -60,13 +62,16 @@ export function startRemoteDrives(deps) {
                 headers,
                 signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
             });
-            if (!res.ok)
+            if (!res.ok) {
                 return;
+            }
             const drive = (await res.json()).drive;
-            if (null === drive || undefined === drive)
+            if (null === drive || undefined === drive) {
                 return;
-            if ('string' !== typeof drive.id || 'string' !== typeof drive.goal)
+            }
+            if ('string' !== typeof drive.id || 'string' !== typeof drive.goal) {
                 return;
+            }
             deps.log?.(`reticle: driving a request from the platform chat: ${drive.goal}`);
             const driveId = drive.id;
             const driveUrl = `${platform.url}${LinkPath.driveResult(driveId)}`;
@@ -197,24 +202,43 @@ async function runToolSession(post, tools, first, now, sleep) {
         };
         const res = await askWithRetries(() => post(body), sleep);
         // Refused, or still failing after every retry: stop. The platform ends a drive that stops asking.
-        if (res === undefined || !res.ok)
+        if (res === undefined || !res.ok) {
             return;
+        }
         const reply = parseToolSessionReply(await res.json());
-        if (reply.done)
+        if (reply.done) {
             return;
+        }
         results = [];
         for (const call of reply.calls) {
-            if (made >= TOOL_SESSION_LIMITS.MAX_CALLS)
+            if (made >= TOOL_SESSION_LIMITS.MAX_CALLS) {
                 return;
+            }
             made += 1;
             const at = now();
             try {
                 const result = await tools.invoke(call.tool, call.args);
-                results.push({ seq: call.seq, ok: true, result, ms: now() - at });
+                const end = now();
+                results.push({
+                    seq: call.seq,
+                    ok: true,
+                    result,
+                    ms: end - at,
+                    startedAt: at,
+                    endedAt: end,
+                });
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
-                results.push({ seq: call.seq, ok: false, error: message, ms: now() - at });
+                const end = now();
+                results.push({
+                    seq: call.seq,
+                    ok: false,
+                    error: message,
+                    ms: end - at,
+                    startedAt: at,
+                    endedAt: end,
+                });
             }
         }
     }
@@ -233,10 +257,12 @@ async function askWithRetries(send, sleep) {
         catch {
             res = undefined;
         }
-        if (res !== undefined && !sessionAskRetryable(res.status))
+        if (res !== undefined && !sessionAskRetryable(res.status)) {
             return res;
-        if (attempt >= TOOL_SESSION_LIMITS.RETRIES)
+        }
+        if (attempt >= TOOL_SESSION_LIMITS.RETRIES) {
             return res;
+        }
         await sleep(TOOL_SESSION_LIMITS.RETRY_BASE_MS * 2 ** attempt);
     }
 }
@@ -253,23 +279,27 @@ function film(frame, everyMs, send) {
     const shoot = async () => {
         try {
             const shot = await frame();
-            if (shot === undefined)
+            if (shot === undefined) {
                 return;
+            }
             const jpeg = Buffer.from(shot).toString('base64');
-            if (jpeg === last)
+            if (jpeg === last) {
                 return;
+            }
             last = jpeg;
             // Counted only once the platform took it: a refused picture is not a filmed drive.
-            if ((await send(jpeg)).ok)
+            if ((await send(jpeg)).ok) {
                 sent += 1;
+            }
         }
         catch {
             // The next tick tries again.
         }
     };
     const timer = setInterval(() => {
-        if (busy === undefined)
+        if (busy === undefined) {
             busy = shoot().finally(() => (busy = undefined));
+        }
     }, everyMs);
     timer.unref();
     return {
@@ -298,12 +328,14 @@ reopen) {
     const own = [];
     for (const tab of tabs) {
         const key = await keyOf(tab.sessionId).catch(() => undefined);
-        if (key === apiKey)
+        if (key === apiKey) {
             own.push(tab);
+        }
     }
     const picked = pickDriveSession(own, goal);
-    if (picked !== undefined)
+    if (picked !== undefined) {
         return picked;
+    }
     return (await reopen?.().catch(() => undefined)) ?? null;
 }
 /** The address of an http(s) URL, `host:port`, for matching a tab to the app a request names. */
@@ -331,15 +363,18 @@ export function pickDriveSession(tabs, goal) {
         for (let i = 0; i < a.length; i += 1) {
             const x = a[i] ?? 0;
             const y = b[i] ?? 0;
-            if (x !== y)
+            if (x !== y) {
                 return x < y;
+            }
         }
         return false;
     };
     let best;
-    for (const tab of tabs)
-        if (best === undefined || better(rank(tab), rank(best)))
+    for (const tab of tabs) {
+        if (best === undefined || better(rank(tab), rank(best))) {
             best = tab;
+        }
+    }
     return best?.sessionId;
 }
 /**
@@ -348,8 +383,9 @@ export function pickDriveSession(tabs, goal) {
  * is `unknown`: "it ran and nothing threw" is not "the goal was reached".
  */
 export function driveVerdict(out) {
-    if (out.error !== undefined)
+    if (out.error !== undefined) {
         return 'unknown';
+    }
     // A check that came back "no" is a failed drive whatever else held. A goal the model judged unmet
     // is its opinion, not evidence: with no check against it the drive is not proved, never failed.
     const graded = driveFlowStatus({
@@ -357,22 +393,28 @@ export function driveVerdict(out) {
         failed: out.checks?.failed ?? 0,
         goalMet: out.goalMet,
     });
-    if (RunFlowStatus.FAIL === graded)
+    if (RunFlowStatus.FAIL === graded) {
         return 'no';
+    }
     // The quoted texts are looked for on the page the drive ENDED on. None there refutes the goal;
     // some missing does not, because a goal that quotes where it starts ("from "Count is 0" to
     // "Count is 1"") loses that text by working. Then the goal's own judgement decides, as below.
     const goals = out.goals ?? [];
-    if (0 < goals.length && goals.every((g) => 'no' === g.verified))
+    if (0 < goals.length && goals.every((g) => 'no' === g.verified)) {
         return 'no';
-    if (0 < goals.length && !goals.some((g) => 'yes' === g.verified))
+    }
+    if (0 < goals.length && !goals.some((g) => 'yes' === g.verified)) {
         return 'unknown';
+    }
     // A yes needs a check that held behind it: the model saying the goal was met is not evidence.
-    if (!out.proved || RunFlowStatus.PASS !== graded)
+    if (!out.proved || RunFlowStatus.PASS !== graded) {
         return 'unknown';
-    if (true === out.goalMet)
+    }
+    if (true === out.goalMet) {
         return 'yes';
-    if (0 < goals.length && goals.every((g) => 'yes' === g.verified))
+    }
+    if (0 < goals.length && goals.every((g) => 'yes' === g.verified)) {
         return 'yes';
+    }
     return 'unknown';
 }

package/dist/features/harness/platform/server-driver.js

@@ -11,16 +11,20 @@
  * trial. A secret field travels by name only, and its value is filled in here before the call runs.
  */
 import { PlatformRefusalCode, readRefusal, refusalSentence } from './refusal.js';
-import { ReticleEnv, cloudUrlFrom } from '@reticlehq/core';
+import { ReticleEnv, asRecord, cloudUrlFrom } from '@reticlehq/core';
 import { DriveStoppedError, } from '../harness.js';
 import { DRIVE_HEADER } from '../platform-config.js';
 export { DRIVE_HEADER };
 export const SERVER_DRIVER_NAME = 'server';
 const RUNS_PATH = '/v1/harness/runs';
 const TURN_TIMEOUT_MS = 110_000;
+/** How long the run's spend is waited for once the drive ended. Its absence costs one number. */
+const SPENT_TIMEOUT_MS = 5_000;
 const RETRIES = 1;
 /** The platform's code for a run whose project had autonomous driving switched off. */
 const FINISH = 'finish';
+/** The platform's status for a run it ended without finishing: the app could not be driven. */
+const FAILED = 'failed';
 /** The platform's url and this project's key, when the machine is linked. */
 export function serverOptionsFromEnv(env) {
     const url = cloudUrlFrom(env);
@@ -85,6 +89,20 @@ export function serverDriver(options) {
         throw last instanceof Error ? last : new Error(String(last));
     };
     return {
+        // The run's own record, which carries its spend however the drive ended.
+        async spent() {
+            if (runId === undefined)
+                return undefined;
+            const res = await doFetch(`${options.url}${RUNS_PATH}/${encodeURIComponent(runId)}`, {
+                method: 'GET',
+                headers: platformHeaders(options),
+                signal: AbortSignal.timeout(SPENT_TIMEOUT_MS),
+            });
+            if (!res.ok)
+                return undefined;
+            const body = asRecord(JSON.parse(await res.text()));
+            return 'number' === typeof body['creditsSpent'] ? body['creditsSpent'] : undefined;
+        },
         async turn(input) {
             if (runId === undefined) {
                 const started = (await call(RUNS_PATH, {
@@ -118,6 +136,9 @@ export function serverDriver(options) {
             turn = reply.turn + 1;
             // The platform's spend, reported so the drive's cost is visible here as it is for a local one.
             const usage = reply.usage === undefined ? {} : { usage: reply.usage };
+            // A run the platform ended as failed is a broken drive, and its summary says why.
+            if (reply.done && FAILED === reply.status)
+                throw new ServerHarnessError(reply.summary ?? reply.text, 502);
             if (reply.done) {
                 // The platform has finished: `finish` ends the local loop the same way a local model would.
                 return {