@reticlehq/server 3.6.0 → 3.7.0

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

@@ -10,7 +10,7 @@
  * the person can fix in ten seconds (open the app), and leaving it unclaimed lets the chat tell them
  * exactly that. One drive at a time: a second request waits for the first to finish.
  */
-import { DriveMode, DriveTarget, LinkPath, PLATFORM_LINK_VERSION, PresenterTone, TOOL_SESSION_LIMITS, parseDriveSpec, parseToolSessionReply, sessionAskRetryable, } from '@reticlehq/core';
+import { DriveMode, DriveTarget, LinkPath, PLATFORM_LINK_VERSION, PresenterTone, RunFlowStatus, TOOL_SESSION_LIMITS, driveFlowStatus, parseDriveSpec, parseToolSessionReply, sessionAskRetryable, } from '@reticlehq/core';
 import { serverOptionsFromEnv } from './server-driver.js';
 /**
  * How often to ask while an app is connected.
@@ -141,7 +141,7 @@ export function startRemoteDrives(deps) {
             let outcome;
             let framesSent = 0;
             try {
-                outcome = await deps.drive(drive.goal, sessionId);
+                outcome = await deps.drive(drive.goal, sessionId, parsed.spec);
             }
             catch (error) {
                 outcome = { ok: false, summary: error instanceof Error ? error.message : String(error) };
@@ -288,14 +288,23 @@ export const NO_OWN_TAB = "No tab of this project is connected to Reticle on thi
  * daemon serves every project on the machine but polls with ONE credential, so without this a
  * request made in project A drove project B's tab and sent pictures of it to A's chat.
  */
-export async function pickOwnDriveSession(tabs, goal, apiKey, keyOf) {
+export async function pickOwnDriveSession(tabs, goal, apiKey, keyOf, 
+/**
+ * Open the project's app when none of its tabs is connected, and the session it opened. A
+ * dashboard Re-verify with the dev server up and no tab open was answered "Open this project's
+ * app, then ask again" by a daemon that knew the app's address.
+ */
+reopen) {
     const own = [];
     for (const tab of tabs) {
         const key = await keyOf(tab.sessionId).catch(() => undefined);
         if (key === apiKey)
             own.push(tab);
     }
-    return pickDriveSession(own, goal) ?? null;
+    const picked = pickDriveSession(own, goal);
+    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. */
 const hostOf = (url) => {
@@ -341,10 +350,14 @@ export function pickDriveSession(tabs, goal) {
 export function driveVerdict(out) {
     if (out.error !== undefined)
         return 'unknown';
-    // A goal judged unmet, or a check that came back "no", is a failed drive whatever else held.
-    if (false === out.goalMet)
-        return 'no';
-    if (0 < (out.checks?.failed ?? 0))
+    // 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({
+        held: out.checks?.held ?? 0,
+        failed: out.checks?.failed ?? 0,
+        goalMet: out.goalMet,
+    });
+    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
@@ -355,7 +368,7 @@ export function driveVerdict(out) {
     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 || 0 === (out.checks?.held ?? 0))
+    if (!out.proved || RunFlowStatus.PASS !== graded)
         return 'unknown';
     if (true === out.goalMet)
         return 'yes';

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

@@ -1,5 +1,6 @@
 import { ScriptStatus, type FlowFile, type FlowStep, type PlanView } from '@reticlehq/core';
-import { type DriveScript } from '@reticlehq/core/artifacts';
+import { type JourneyBy, type DriveScript } from '@reticlehq/core/artifacts';
+import { type PlatformCredential } from './server-driver.js';
 type FetchLike = (url: string, init: RequestInit) => Promise<Response>;
 export interface ScriptAsk {
     about: string;
@@ -25,24 +26,69 @@ export declare function personasIn(flows: readonly FlowFile[]): {
 }[];
 /** Equal for two steps that drive the same control the same way; the values never leave. */
 export declare function stepHash(step: FlowStep): string;
-export declare function proposeScript(platform: {
-    url: string;
-    apiKey: string;
-}, ask: ScriptAsk, doFetch?: FetchLike): Promise<{
+/** What a run that names nothing asks for: the whole app, which the platform splits into journeys. */
+export declare const WHOLE_APP_REQUEST = "Test my app: plan the journeys this app offers and drive them";
+export declare function proposeScript(platform: PlatformCredential, ask: ScriptAsk, doFetch?: FetchLike): Promise<{
     script: DriveScript;
     planId?: string;
+    creditsSpent?: number;
+} | {
+    refused: string;
 } | undefined>;
+/**
+ * A plan the platform saved, as it stands now: somebody may have edited it on the dashboard since it
+ * last ran. Checked like a proposed one; `undefined` when it cannot be read or cannot run.
+ */
+export declare function fetchScript(platform: PlatformCredential, planId: string, doFetch?: FetchLike): Promise<DriveScript | undefined>;
+/**
+ * A rerun replays what passed before. A journey the plan's history shows passing, with the flows it
+ * saved, replays those flows; the model drives its goal only when they decide nothing (`fallback`),
+ * and a replay that fails is a regression, never re-driven. A rerun re-drove a journey that had
+ * passed, at a model's cost, and failed it twice. Journeys that already replay are left as planned.
+ */
+export declare function replayFirst(script: DriveScript, plan: unknown): DriveScript;
 /** One journey's outcome, as the platform keeps it beside the plan. */
 export interface JourneyResult {
     id: string;
     title: string;
     status: ScriptStatus;
+    /** What happened, in a line: why a journey that never ran was blocked. */
+    line?: string;
+    /** Replayed with no model, or driven by it. Absent for a journey that never ran. */
+    by?: JourneyBy;
+    /** Model tokens it spent; 0 for a pure replay. */
+    tokens?: number;
+    /** Credits its model drives spent, when the platform said. */
+    credits?: number;
+    /** The flows it replayed or recorded: the platform links the journey to these. */
+    flows?: string[];
+    /** Whether the goals the run was asked were reached, once graded. Absent when none were judged. */
+    goalMet?: boolean;
+}
+/** How one journey that ran was answered, from the run (`JourneyRun`). */
+export interface JourneyAnswer {
+    id: string;
+    by?: JourneyBy;
+    tokens: number;
+    credits?: number;
+    flows: string[];
 }
-/** How each journey of a run plan went, once each. */
-export declare function journeyResults(view: PlanView): JourneyResult[];
+/**
+ * The plan only replays saved flows: no step anywhere, branch cases included, hands the model
+ * anything to do. Such a run spends no model turns, so the gates that guard a model drive do not
+ * apply to it.
+ */
+export declare function drivesNothing(script: DriveScript): boolean;
+/** The saved plan reads as one that only replays saved flows. Unreadable: not known to, so false. */
+export declare function savedPlanDrivesNothing(platform: PlatformCredential, planId: string, doFetch?: FetchLike): Promise<boolean>;
+/**
+ * A saved plan the run was refused for, or that broke before any journey ran, told to the plan
+ * anyway: every journey blocked, with the reason, so the plan's history records the attempt instead
+ * of showing nothing. Best-effort, like every report to the plan.
+ */
+export declare function reportPlanBlocked(platform: PlatformCredential, planId: string, reason: string, doFetch?: FetchLike): Promise<boolean>;
+/** How each journey of a run plan went, once each, matched to how it was answered by id. */
+export declare function journeyResults(view: PlanView, answers?: readonly JourneyAnswer[]): JourneyResult[];
 /** Tell the platform how its plan went. A failure costs the next plan its memory, never this run. */
-export declare function reportPlanResults(platform: {
-    url: string;
-    apiKey: string;
-}, planId: string, results: readonly JourneyResult[], doFetch?: FetchLike): Promise<boolean>;
+export declare function reportPlanResults(platform: PlatformCredential, planId: string, results: readonly JourneyResult[], runIds?: readonly string[], doFetch?: FetchLike): Promise<boolean>;
 export {};

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

@@ -12,9 +12,11 @@
  * The platform keeps every plan under an id, and is told afterwards how each journey went: that is
  * what the next plan learns from (what failed is driven first).
  */
+import { readRefusal, refusalSentence } from './refusal.js';
 import { createHash } from 'node:crypto';
-import { ScriptStatus, StepEffect, } from '@reticlehq/core';
-import { DriveScriptSchema, checkScript } from '@reticlehq/core/artifacts';
+import { ScriptStatus, asRecord, asString, StepEffect, } from '@reticlehq/core';
+import { DriveScriptSchema, ScriptStepKind, checkScript, } from '@reticlehq/core/artifacts';
+import { platformHeaders } from './server-driver.js';
 const SCRIPTS_PATH = '/v1/harness/scripts';
 const RESULTS_PATH = '/results';
 const TIMEOUT_MS = 90_000;
@@ -50,11 +52,21 @@ export function stepHash(step) {
         .digest('hex')
         .slice(0, STEP_HASH_CHARS);
 }
+/** What a run that names nothing asks for: the whole app, which the platform splits into journeys. */
+export const WHOLE_APP_REQUEST = 'Test my app: plan the journeys this app offers and drive them';
+/**
+ * The goals a plan request carries. The platform refuses one that names nothing — no journey, no
+ * persona, nothing to replay — and no longer invents personas, so such a run asks for the whole app.
+ */
+function goalsToAsk(ask) {
+    const named = 0 < ask.goals.length || 0 < ask.replay.length || 0 < (ask.personas?.length ?? 0);
+    return named ? ask.goals : [WHOLE_APP_REQUEST];
+}
 export async function proposeScript(platform, ask, doFetch = (url, init) => fetch(url, init)) {
     try {
         const res = await doFetch(`${platform.url}${SCRIPTS_PATH}`, {
             method: 'POST',
-            headers: { 'content-type': 'application/json', authorization: `Bearer ${platform.apiKey}` },
+            headers: platformHeaders(platform),
             body: JSON.stringify({
                 about: ask.about,
                 flows: ask.flows.map((flow) => ({
@@ -67,7 +79,7 @@ export async function proposeScript(platform, ask, doFetch = (url, init) => fetc
                     checks: flow.steps.filter((step) => step.expect !== undefined || true === step.steps?.some((s) => s.expect !== undefined)).length,
                 })),
                 replay: ask.replay,
-                goals: ask.goals,
+                goals: goalsToAsk(ask),
                 gaps: ask.gaps,
                 rules: ask.rules,
                 ...(ask.personas === undefined || 0 === ask.personas.length
@@ -76,8 +88,9 @@ export async function proposeScript(platform, ask, doFetch = (url, init) => fetc
             }),
             signal: AbortSignal.timeout(TIMEOUT_MS),
         });
+        // The platform's own reason, so a drive that goes on without a plan can say why.
         if (!res.ok)
-            return undefined;
+            return { refused: await refusalOf(res) };
         const body = (await res.json());
         const parsed = DriveScriptSchema.safeParse(body.script);
         if (!parsed.success || 0 < checkScript(parsed.data).length)
@@ -85,39 +98,158 @@ export async function proposeScript(platform, ask, doFetch = (url, init) => fetc
         return {
             script: parsed.data,
             ...('string' === typeof body.planId ? { planId: body.planId } : {}),
+            // What writing the plan cost: part of the run's spend, not free.
+            ...('number' === typeof body.creditsSpent ? { creditsSpent: body.creditsSpent } : {}),
         };
     }
     catch {
         return undefined;
     }
 }
+async function refusalOf(res) {
+    // The code picks the lead sentence (refusal.ts), so what this says never rests on the wording.
+    return refusalSentence(readRefusal(await res.text().catch(() => '')), res.status);
+}
+/**
+ * A plan the platform saved, as it stands now: somebody may have edited it on the dashboard since it
+ * last ran. Checked like a proposed one; `undefined` when it cannot be read or cannot run.
+ */
+export async function fetchScript(platform, planId, doFetch = (url, init) => fetch(url, init)) {
+    try {
+        const res = await doFetch(`${platform.url}${SCRIPTS_PATH}/${encodeURIComponent(planId)}`, {
+            method: 'GET',
+            headers: platformHeaders(platform),
+            signal: AbortSignal.timeout(TIMEOUT_MS),
+        });
+        if (!res.ok)
+            return undefined;
+        const plan = (await res.json());
+        const parsed = DriveScriptSchema.safeParse(plan.script);
+        return parsed.success && 0 === checkScript(parsed.data).length
+            ? replayFirst(parsed.data, plan)
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * A rerun replays what passed before. A journey the plan's history shows passing, with the flows it
+ * saved, replays those flows; the model drives its goal only when they decide nothing (`fallback`),
+ * and a replay that fails is a regression, never re-driven. A rerun re-drove a journey that had
+ * passed, at a model's cost, and failed it twice. Journeys that already replay are left as planned.
+ */
+export function replayFirst(script, plan) {
+    const passedFlows = new Map();
+    const record = asRecord(plan);
+    const runs = Array.isArray(record['runs']) ? record['runs'] : [];
+    const batches = [...runs.map((run) => asRecord(run)['results']), record['results']];
+    for (const batch of batches) {
+        if (!Array.isArray(batch))
+            continue;
+        for (const raw of batch) {
+            const result = asRecord(raw);
+            const id = asString(result['id']);
+            const flows = Array.isArray(result['flows'])
+                ? result['flows'].filter((f) => 'string' === typeof f && 0 < f.length)
+                : [];
+            if (id !== undefined && ScriptStatus.PASSED === result['status'] && 0 < flows.length)
+                passedFlows.set(id, flows);
+        }
+    }
+    if (0 === passedFlows.size)
+        return script;
+    return {
+        ...script,
+        journeys: script.journeys.map((journey) => {
+            const flows = passedFlows.get(journey.id);
+            const goals = journey.steps.map((step) => ScriptStepKind.ACT === step.kind ? step.goal : undefined);
+            if (flows === undefined || journey.fallback !== undefined || goals.includes(undefined))
+                return journey;
+            return {
+                ...journey,
+                steps: flows.map((flow) => ({ kind: ScriptStepKind.REPLAY, flow })),
+                fallback: { goal: goals.join('; ') },
+            };
+        }),
+    };
+}
+/**
+ * The plan only replays saved flows: no step anywhere, branch cases included, hands the model
+ * anything to do. Such a run spends no model turns, so the gates that guard a model drive do not
+ * apply to it.
+ */
+export function drivesNothing(script) {
+    return script.journeys.every((journey) => journey.steps.every((step) => ScriptStepKind.BRANCH === step.kind
+        ? step.cases.every((c) => c.steps.every((leaf) => ScriptStepKind.ACT !== leaf.kind))
+        : ScriptStepKind.ACT !== step.kind));
+}
+/** The saved plan reads as one that only replays saved flows. Unreadable: not known to, so false. */
+export async function savedPlanDrivesNothing(platform, planId, doFetch = (url, init) => fetch(url, init)) {
+    const script = await fetchScript(platform, planId, doFetch);
+    return script !== undefined && drivesNothing(script);
+}
+/**
+ * A saved plan the run was refused for, or that broke before any journey ran, told to the plan
+ * anyway: every journey blocked, with the reason, so the plan's history records the attempt instead
+ * of showing nothing. Best-effort, like every report to the plan.
+ */
+export async function reportPlanBlocked(platform, planId, reason, doFetch = (url, init) => fetch(url, init)) {
+    const script = await fetchScript(platform, planId, doFetch);
+    const results = (script?.journeys ?? []).map((journey) => ({
+        id: journey.id,
+        title: journey.title,
+        status: ScriptStatus.BLOCKED,
+        line: reason,
+    }));
+    return reportPlanResults(platform, planId, results, [], doFetch);
+}
 /** Worst first: a journey that ran in two lanes reports the worse of the two. */
 const SEVERITY = [
     ScriptStatus.FAILED,
     ScriptStatus.BLOCKED,
     ScriptStatus.RUNNING,
     ScriptStatus.PENDING,
+    ScriptStatus.UNDECIDED,
     ScriptStatus.NOT_TAKEN,
     ScriptStatus.PASSED,
 ];
-/** How each journey of a run plan went, once each. */
-export function journeyResults(view) {
+/** How each journey of a run plan went, once each, matched to how it was answered by id. */
+export function journeyResults(view, answers = []) {
     const byId = new Map();
     for (const lane of view.lanes)
         for (const card of lane.journeys) {
             const seen = byId.get(card.id);
             if (seen === undefined || SEVERITY.indexOf(card.status) < SEVERITY.indexOf(seen.status))
-                byId.set(card.id, { id: card.id, title: card.title, status: card.status });
+                byId.set(card.id, {
+                    id: card.id,
+                    title: card.title,
+                    status: card.status,
+                    ...(card.why === undefined ? {} : { line: card.why }),
+                });
         }
-    return [...byId.values()];
+    const answered = new Map(answers.map((a) => [a.id, a]));
+    return [...byId.values()].map((result) => {
+        const answer = answered.get(result.id);
+        if (answer === undefined)
+            return result;
+        return {
+            ...result,
+            ...(answer.by === undefined ? {} : { by: answer.by }),
+            tokens: answer.tokens,
+            ...(answer.credits === undefined ? {} : { credits: answer.credits }),
+            ...(0 === answer.flows.length ? {} : { flows: [...answer.flows] }),
+        };
+    });
 }
 /** Tell the platform how its plan went. A failure costs the next plan its memory, never this run. */
-export async function reportPlanResults(platform, planId, results, doFetch = (url, init) => fetch(url, init)) {
+export async function reportPlanResults(platform, planId, results, runIds = [], doFetch = (url, init) => fetch(url, init)) {
     try {
         const res = await doFetch(`${platform.url}${SCRIPTS_PATH}/${encodeURIComponent(planId)}${RESULTS_PATH}`, {
             method: 'POST',
-            headers: { 'content-type': 'application/json', authorization: `Bearer ${platform.apiKey}` },
-            body: JSON.stringify({ results }),
+            headers: platformHeaders(platform),
+            // The runs it made, so the plan's history opens each one.
+            body: JSON.stringify({ results, ...(0 === runIds.length ? {} : { runIds }) }),
             signal: AbortSignal.timeout(TIMEOUT_MS),
         });
         return res.ok;

package/dist/features/harness/platform/server-driver.d.ts

@@ -1,4 +1,6 @@
 import { type ModelDriver } from '../harness.js';
+import { DRIVE_HEADER } from '../platform-config.js';
+export { DRIVE_HEADER };
 export declare const SERVER_DRIVER_NAME = "server";
 type FetchLike = (url: string, init: RequestInit) => Promise<Response>;
 export interface ServerDriverOptions {
@@ -19,16 +21,28 @@ export interface ServerDriverOptions {
     }[];
     /** The signal names the app declares, so the engine can claim one by name. */
     vocabulary?: readonly string[];
+    /** The survey of the app taken before the drive: where each text and control lives. */
+    siteMap?: unknown;
     /** Where secret field values live. Only their NAMES go to the platform. Defaults to `process.env`. */
     env?: Record<string, string | undefined>;
     maxSteps?: number;
+    /** The free drive this run is billed to, sent as `DRIVE_HEADER` on every turn. */
+    driveId?: string;
     fetch?: FetchLike;
 }
-/** The platform's url and this project's key, when the machine is linked. */
-export declare function serverOptionsFromEnv(env: Record<string, string | undefined>): {
+/** Where to reach the platform, as which key, and for which free drive when there is one. */
+export interface PlatformCredential {
     url: string;
     apiKey: string;
-} | undefined;
+    driveId?: string;
+}
+/** The platform's url and this project's key, when the machine is linked. */
+export declare function serverOptionsFromEnv(env: Record<string, string | undefined>): PlatformCredential | undefined;
+/** The headers every Harness call carries: JSON, the key, and the free drive it is billed to. */
+export declare function platformHeaders(platform: {
+    apiKey: string;
+    driveId?: string | undefined;
+}): Record<string, string>;
 export declare class ServerHarnessError extends Error {
     readonly status: number;
     constructor(message: string, status: number);
@@ -38,4 +52,3 @@ export declare function serverDriver(options: ServerDriverOptions): ModelDriver;
 export declare function secretNames(env: Record<string, string | undefined>): string[];
 /** The call's arguments with every secret placeholder replaced by its value from this machine. */
 export declare function withSecrets(args: Record<string, unknown>, env: Record<string, string | undefined>): Record<string, unknown>;
-export {};

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

@@ -10,22 +10,37 @@
  * This is the only Harness driver: every decision is the platform's, for a workspace with a plan or
  * 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 { 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;
 const RETRIES = 1;
 /** The platform's code for a run whose project had autonomous driving switched off. */
-const HARNESS_OFF = 'harness_off';
 const FINISH = 'finish';
 /** The platform's url and this project's key, when the machine is linked. */
 export function serverOptionsFromEnv(env) {
     const url = cloudUrlFrom(env);
     const apiKey = env[ReticleEnv.API_KEY];
+    const driveId = env[ReticleEnv.DRIVE_ID];
     return url === undefined || apiKey === undefined || 0 === apiKey.length
         ? undefined
-        : { url: url.replace(/\/+$/, ''), apiKey };
+        : {
+            url: url.replace(/\/+$/, ''),
+            apiKey,
+            ...(driveId === undefined || 0 === driveId.length ? {} : { driveId }),
+        };
+}
+/** The headers every Harness call carries: JSON, the key, and the free drive it is billed to. */
+export function platformHeaders(platform) {
+    return {
+        'content-type': 'application/json',
+        authorization: `Bearer ${platform.apiKey}`,
+        ...(platform.driveId === undefined ? {} : { [DRIVE_HEADER]: platform.driveId }),
+    };
 }
 export class ServerHarnessError extends Error {
     status;
@@ -45,18 +60,16 @@ export function serverDriver(options) {
             try {
                 const res = await doFetch(`${options.url}${path}`, {
                     method: 'POST',
-                    headers: {
-                        'content-type': 'application/json',
-                        authorization: `Bearer ${options.apiKey}`,
-                    },
+                    headers: platformHeaders(options),
                     body: JSON.stringify(body),
                     signal: AbortSignal.timeout(TURN_TIMEOUT_MS),
                 });
                 const text = await res.text();
                 if (!res.ok) {
-                    const message = errorMessage(text) ?? `the platform answered ${String(res.status)}`;
+                    const refusal = readRefusal(text);
+                    const message = refusalSentence(refusal, res.status);
                     // A person turned it off: the drive ends, and the result says that rather than "broken".
-                    if (HARNESS_OFF === errorCode(text))
+                    if (PlatformRefusalCode.HARNESS_OFF === refusal.code)
                         throw new DriveStoppedError(message);
                     // A refusal is an answer; only a network failure is worth asking again.
                     throw new ServerHarnessError(message, res.status);
@@ -82,6 +95,7 @@ export function serverDriver(options) {
                     ...(options.maxSteps === undefined ? {} : { maxSteps: options.maxSteps }),
                     ...(options.planSteps === undefined ? {} : { planSteps: options.planSteps }),
                     ...(options.vocabulary === undefined ? {} : { vocabulary: options.vocabulary }),
+                    ...(options.siteMap === undefined ? {} : { siteMap: options.siteMap }),
                     secrets: secretNames(options.env ?? process.env),
                     tools: input.tools.filter((t) => FINISH !== t.name).map(toolSpec),
                 }));
@@ -93,9 +107,13 @@ export function serverDriver(options) {
             const fresh = input.history.slice(seen);
             seen = input.history.length;
             const outcomes = fresh.flatMap((entry) => 'tool' === entry.role ? entry.outcomes.map(outcomeOf) : []);
+            // What somebody said to the drive since the last turn. The opening line is the loop's own and
+            // the platform writes its own, so only words that arrived after it travel.
+            const say = fresh.flatMap((entry, i) => 'user' === entry.role && (0 < turn || 0 < i) ? [entry.text] : []);
             const reply = (await call(`${RUNS_PATH}/${encodeURIComponent(runId)}/turn`, {
                 turn,
                 outcomes,
+                ...(0 === say.length ? {} : { say }),
             }));
             turn = reply.turn + 1;
             // The platform's spend, reported so the drive's cost is visible here as it is for a local one.
@@ -112,6 +130,9 @@ export function serverDriver(options) {
                             args: {
                                 summary: reply.summary ?? reply.text,
                                 ...('boolean' === typeof reply.goalMet ? { goalMet: reply.goalMet } : {}),
+                                ...('number' === typeof reply.creditsSpent
+                                    ? { creditsSpent: reply.creditsSpent }
+                                    : {}),
                             },
                         },
                     ],
@@ -133,24 +154,6 @@ function toolSpec(tool) {
 function outcomeOf(o) {
     return { id: o.id, name: o.name, result: o.result, isError: o.isError };
 }
-function errorCode(text) {
-    try {
-        const body = JSON.parse(text);
-        return 'string' === typeof body.error?.code ? body.error.code : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function errorMessage(text) {
-    try {
-        const body = JSON.parse(text);
-        return 'string' === typeof body.error?.message ? body.error.message : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
 /** The prefix of a variable holding one secret field: `RETICLE_SECRET_AUTH_PASSWORD`. */
 const SECRET_ENV_PREFIX = 'RETICLE_SECRET_';
 /** What the platform types into a field whose secret this machine holds. */

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

@@ -16,11 +16,15 @@
  *   - it never overrides someone who was EXPLICIT. A driver named in the call, or set in the
  *     environment, wins over the stored preference. Precedence lives in the caller.
  */
+import { CreditKind } from '@reticlehq/core';
+import type { Credits } from '@reticlehq/core/hud';
+/** The header naming the free drive a call belongs to. See `ReticleEnv.DRIVE_ID`. */
+export declare const DRIVE_HEADER = "x-reticle-drive";
 /** The subset of the platform's answer the harness acts on. */
 export interface PlatformModelConfig {
     /** `jev` | `anthropic` | `openai`, as the platform spells it. Not validated here. */
     provider: string;
-    /** Whether the person wants autonomous driving at all. */
+    /** Whether the person switched the Harness on. Off unless the platform says on. */
     harnessEnabled: boolean;
     /**
      * Whether this workspace may drive on OUR model spend — a claimed free period, or a paid plan.
@@ -40,13 +44,42 @@ export interface PlatformModelConfig {
      * not have its silence treated as a refusal.
      */
     providerReady: boolean;
-    /** Harness credits used and held this 30 days. Absent when the plan is unbounded or the API is older. */
-    credits?: {
-        used: number;
-        limit: number;
+    /**
+     * Harness credits used and held this 30 days, and when the grant ends (`endsAt`, epoch ms) when
+     * the platform says. Absent when the plan is unbounded or the API is older.
+     */
+    credits?: Credits & {
+        endsAt?: number;
     };
     /** The platform that answered, no trailing slash: where the HUD's settings and plan links go. */
     platformUrl?: string;
+    /**
+     * The page where credits and the trial are bought (`planUrl`), on the console's origin. The API
+     * and the console are different origins on every deployment but a laptop, so a link built from
+     * the API's origin 404s. Absent from an older platform.
+     */
+    planUrl?: string;
+    /** The platform's coverage gate (`harnessUnlocked`, `coverageScore`, `harnessLock`), when it sent one. */
+    gate?: PlatformGate;
+    /** The plan in force (`plan`), for the HUD's account menu. */
+    plan?: PlatformPlan;
+    /** Harness runs the platform holds for this project (`harnessRuns.total`). */
+    harnessRuns?: number;
+    /** Memory entries the platform holds for this project (`memory.entries`). */
+    memoryEntries?: number;
+}
+/** The plan as the HUD is pushed it: which grant, and the trial's days and seats when said. */
+export interface PlatformPlan {
+    kind: CreditKind;
+    daysLeft?: number;
+    seats?: number;
+}
+/** The platform's Harness coverage gate, as the HUD is pushed it. */
+export interface PlatformGate {
+    unlocked: boolean;
+    percent?: number;
+    reason?: string;
+    prompt?: string;
 }
 /** A GET, narrowed to what this file uses, so a test can answer it without a network. */
 export type ConfigFetch = (url: string, init: {