@reticlehq/server 3.7.0 → 3.8.1

package/dist/surface/tools/feedback-tools.js

@@ -12,7 +12,7 @@
  * tokens on that and not on politeness.
  */
 import { z } from 'zod';
-import { FeedbackKind, FeedbackSource, FEEDBACK_RATING_MAX, FEEDBACK_RATING_MIN, } from '@reticlehq/core/telemetry';
+import { FeedbackKind, FeedbackSource, FEEDBACK_CONTACT_MAX, FEEDBACK_RATING_MAX, FEEDBACK_RATING_MIN, isFeedbackContact, } from '@reticlehq/core/telemetry';
 import { ReticleTool } from '@reticlehq/core';
 import { asNumber, asString } from '@reticlehq/core';
 import { submitFeedback, feedbackDisabled } from '../../telemetry/feedback.js';
@@ -68,6 +68,8 @@ function sessionFacts(deps, sessionId) {
 }
 /** Said when a report arrives with no body at all. Names both accepted fields so the retry can work. */
 const NO_BODY_REASON = 'the report has no body — send it as `text` (or `summary`, which is the same field). Nothing was filed.';
+/** Said when `contact` is not one plain address. Nothing is filed, so the agent can fix it and retry. */
+const BAD_CONTACT_REASON = `\`contact\` must be one email address of at most ${String(FEEDBACK_CONTACT_MAX)} characters, such as you@example.com. Send only an address the user typed for a reply, or leave \`contact\` out. Nothing was filed.`;
 /** `text`, or the `summary` alias, whichever arrived. Empty when neither did — the handler refuses. */
 function feedbackBody(args) {
     const text = asString(args['text'])?.trim();
@@ -135,6 +137,10 @@ export const FEEDBACK_TOOLS = [
                 .string()
                 .optional()
                 .describe('The literal tool calls and responses that led here, so the failure can be reproduced without guessing.'),
+            contact: z
+                .string()
+                .optional()
+                .describe('An email address for a reply from the maintainers. Only an address the user typed for this purpose. Never guess or reuse one.'),
             sessionId: z
                 .string()
                 .optional()
@@ -147,7 +153,7 @@ export const FEEDBACK_TOOLS = [
             accepted: z.boolean(),
             reason: z.string().optional(),
             redacted: z.array(z.string()),
-            context: z.unknown(),
+            context: z.unknown().optional(),
             note: z.string(),
         },
         example: {
@@ -174,6 +180,17 @@ export const FEEDBACK_TOOLS = [
                     note: 'NOT accepted (see reason). Tell the human what you found so it is not lost.',
                 };
             }
+            const contact = asString(args['contact'])?.trim();
+            if (contact !== undefined && '' !== contact && !isFeedbackContact(contact)) {
+                return {
+                    sent: false,
+                    accepted: false,
+                    reason: BAD_CONTACT_REASON,
+                    redacted: [],
+                    context: undefined,
+                    note: 'NOT accepted (see reason). Tell the human what you found so it is not lost.',
+                };
+            }
             const receipt = await submitFeedback({
                 source: FeedbackSource.AGENT,
                 kind: asString(args['kind']),
@@ -184,6 +201,7 @@ export const FEEDBACK_TOOLS = [
                 ...optionalText(args, 'currentApproach'),
                 ...optionalText(args, 'model'),
                 ...optionalRating(args),
+                ...(contact !== undefined && '' !== contact ? { contact } : {}),
             }, {
                 session: sessionFacts(deps, asString(args['sessionId'])),
                 // A report that cannot be sent is written into the project being verified, never into
@@ -232,6 +250,9 @@ export const VERDICT_TOOLS = new Set([
     // ACT_AND_WAIT has -- and the guard that checks SHAPE rather than tool NAME is what caught it
     // here rather than six months from now in a metric that had quietly read low the whole time.
     ReticleTool.ACT_SEQUENCE,
+    // `reticle_act { steps }` runs the sequence under ACT's name on the default surface (#1770).
+    // A single act carries no `verified`, so `verificationOf` counts only the sequence verdict.
+    ReticleTool.ACT,
     ReticleTool.ASSERT,
     // `reticle_assert { action: "wait" }` lands here, and grades its answer as `assert` does.
     ReticleTool.WAIT_FOR,

package/dist/surface/tools/gap-novelty.d.ts

@@ -20,6 +20,7 @@
  *
  * Scoped per session id, because a new session is a new agent that has been told nothing.
  */
+import { z } from 'zod';
 /** Just enough shape to route on. Deliberately NOT an index signature: `InstrumentationGap` is a
  *  union of concrete object types and would not be assignable to one. */
 interface GapLike {
@@ -38,4 +39,9 @@ now?: number): T[];
 export declare function forgetGapNovelty(sessionId: string): void;
 /** Test seam: drop every session's memory. */
 export declare function resetGapNovelty(): void;
+/**
+ * The output-schema entry for `engineBlindSpots`, shared by every verdict tool so they cannot word
+ * it two ways. See `EngineBlindSpotKind` in core.
+ */
+export declare const engineBlindSpotsOutput: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
 export {};

package/dist/surface/tools/gap-novelty.js

@@ -20,6 +20,7 @@
  *
  * Scoped per session id, because a new session is a new agent that has been told nothing.
  */
+import { z } from 'zod';
 import { recordGaps } from '../../portal/session/recorded-gaps.js';
 /** The fields worth repeating. Everything else on a gap is the remedy, said once. */
 const FACT_KEYS = ['kind', 'ref', 'source'];
@@ -74,3 +75,11 @@ export function forgetGapNovelty(sessionId) {
 export function resetGapNovelty() {
     toldBySession.clear();
 }
+/**
+ * The output-schema entry for `engineBlindSpots`, shared by every verdict tool so they cannot word
+ * it two ways. See `EngineBlindSpotKind` in core.
+ */
+export const engineBlindSpotsOutput = z
+    .array(z.unknown())
+    .optional()
+    .describe('What this engine could not observe in the session so far, cumulative: each entry is { kind, detail }, kind "pixels-unobserved" or "claim-arithmetic-unchecked". [] when nothing. The last verdict of a run carries the run\'s list; a host must not call a run clean while it holds an entry.');

package/dist/surface/tools/gaps/capability-absences.js

@@ -27,9 +27,10 @@ export function capabilityAbsences(session) {
     if (false === session.captureBodies) {
         absences.push({
             capability: 'network-bodies',
-            meaning: 'request and response bodies are not recorded, so an assertion that reads one cannot be ' +
-                'answered here and will be refused before it spends an action',
-            remedy: "pass captureBodies: true to connect() in this app's Reticle setup, then reload the page. " +
+            meaning: 'request bodies and successful response bodies are not recorded (a failed response keeps ' +
+                'its body by default), so an assertion that reads one cannot be answered here and will be ' +
+                'refused before it spends an action',
+            remedy: "pass captureNetworkBodies: true to connect() in this app's Reticle setup, then reload the page. " +
                 'Bodies can carry personal data, so this is off unless a project asks for it.',
         });
     }

package/dist/surface/tools/harness-explore.d.ts

@@ -17,7 +17,7 @@ import { type GoalCheck } from '../../features/harness/goals.js';
 import type { RunDisparity } from '@reticlehq/core';
 import type { HarnessMap } from '@reticlehq/core/artifacts';
 export { MSG_HARNESS_DISABLED, MSG_HARNESS_UNCLAIMED, MSG_HARNESS_UNCONFIRMED, } from '../../features/harness/platform/refusal.js';
-export { MSG_GATE_PROMPT_LEAD, MSG_NO_HARNESS_KEY, coverageRefusal, firstLine, harnessAvailable, harnessLockRefusal, refusedByPlatform, withLinkedCredential, } from './harness-gate.js';
+export { HarnessNotLinkedError, MSG_NO_HARNESS_KEY, firstLine, harnessAvailable, harnessStartRefusal, refusedByPlatform, withLinkedCredential, } from './harness-gate.js';
 export interface ExploreOptions {
     /** Who to be, or what to accomplish. Appended to the standing instruction. */
     focus?: string;

package/dist/surface/tools/harness-explore.js

@@ -30,9 +30,9 @@ import { endOf, goalOfDrive, parseGoals, readOpening, unprovedGoals, } from '../
 import { mapForPlatform } from '../../features/harness/explore/site-map.js';
 import { huntAndGrade, knownRoutes, refreshMap, siteMapFor } from './harness-hunt.js';
 export { MSG_HARNESS_DISABLED, MSG_HARNESS_UNCLAIMED, MSG_HARNESS_UNCONFIRMED, } from '../../features/harness/platform/refusal.js';
-import { MSG_NO_HARNESS_KEY, refusedForPlan } from './harness-gate.js';
+import { HarnessNotLinkedError, MSG_NO_HARNESS_KEY, refusedForPlan } from './harness-gate.js';
 // The gate a drive passes before it starts moved to its own module; its names are still asked for here.
-export { MSG_GATE_PROMPT_LEAD, MSG_NO_HARNESS_KEY, coverageRefusal, firstLine, harnessAvailable, harnessLockRefusal, refusedByPlatform, withLinkedCredential, } from './harness-gate.js';
+export { HarnessNotLinkedError, MSG_NO_HARNESS_KEY, firstLine, harnessAvailable, harnessStartRefusal, refusedByPlatform, withLinkedCredential, } from './harness-gate.js';
 /** A driver named that this build no longer has: every Harness decision is the platform's now. */
 const msgUnknownDriver = (asked) => `The Harness driver \`${asked}\` is not available: the Harness runs on the Reticle platform, ` +
     `which drives with the model set for the project in the dashboard.`;
@@ -66,7 +66,9 @@ export async function exploreApp(deps, given, asked = {}) {
     const options = named === undefined ? asked : { ...asked, focus: named.persona };
     const refusal = await refusedForPlan(env, options);
     if (refusal !== undefined)
-        throw new DriveRefusedError(refusal);
+        throw MSG_NO_HARNESS_KEY === refusal.text
+            ? new HarnessNotLinkedError()
+            : new DriveRefusedError(refusal.text, refusal.reason);
     // The flows a drive reads and diffs are the PROJECT's, which is where its saves land.
     const reads = withProjectFlows(deps, options.sessionId);
     // No journey named: plan the drive first. The platform's Harness proposes the people worth being;
@@ -491,7 +493,7 @@ siteMap) {
         throw new Error(msgUnknownDriver(requested));
     const platform = serverOptionsFromEnv(env);
     if (platform === undefined)
-        throw new Error(MSG_NO_HARNESS_KEY);
+        throw new HarnessNotLinkedError();
     return {
         driver: serverDriver({
             ...platform,

package/dist/surface/tools/harness-gate.d.ts

@@ -1,3 +1,13 @@
+/**
+ * Whether the Harness may drive at all, and with which credential — answered before a drive starts.
+ *
+ * Split from `harness-explore.ts`, which runs the drive. This is the gate every Harness start passes
+ * through (an agent's explore, Run Harness, `reticle try`, the platform's chat): the linked
+ * credential, a page and daemon from different builds, and the platform's own yes or no. No setup
+ * score gates it: the Harness runs at any instrumentation.
+ */
+import { HarnessRunReason } from '@reticlehq/core/telemetry';
+import { DriveRefusedError } from '../../features/harness/drive-runs.js';
 import type { ToolDeps } from './tool-kit.js';
 import { type ConfigFetch } from '../../features/harness/platform-config.js';
 /** What the platform half of the gate reads off a drive's options; `ExploreOptions` satisfies it. */
@@ -9,11 +19,27 @@ export interface HarnessAsk {
 /**
  * Why the harness is unavailable, phrased as the way to make it available.
  *
- * A missing key is a configuration fact, not a fault, and the sentence a user reads has to tell them
- * the one thing to do about it. Named here because both the CLI and the honest no-flows refusal
- * print it, and two copies of this sentence would drift.
+ * A missing key is a configuration fact, not a fault. This is the AGENT's sentence: who does what
+ * next, short, and no credit number (free credit is granted once per person, so the engine cannot
+ * know what is left). Named here because the CLI and the honest no-flows refusal print it too.
  */
 export declare const MSG_NO_HARNESS_KEY: string;
+/**
+ * The not-linked refusal, thrown. Its code and next steps ride on the error envelope beside the
+ * sentence (`codedRefusalOf`), so the agent reads who does what as data and error-recovery keys on
+ * the code. The person reads `HARNESS_NOT_LINKED_HUMAN` on the HUD instead.
+ */
+export declare class HarnessNotLinkedError extends DriveRefusedError {
+    readonly code: "harness_not_linked";
+    readonly next: readonly ({
+        who: "human";
+        run: string;
+    } | {
+        who: "agent";
+        tool: string;
+    })[];
+    constructor();
+}
 /**
  * The environment, plus the credential this machine already has.
  *
@@ -42,24 +68,15 @@ export declare function withLinkedCredential(deps: ToolDeps, env: Record<string,
 tab?: {
     sessionId: string | undefined;
 }): Promise<Record<string, string | undefined>>;
-/** Introduces the prompt under a coverage refusal, so the agent knows it is for itself. */
-export declare const MSG_GATE_PROMPT_LEAD = "To unlock it, do this (or hand it to your coding agent):";
-/**
- * Why the Harness must not drive this tab's app yet, or undefined when it may: below the coverage
- * gate (core's `instrumentation-coverage.ts`), one reason sentence and the prompt that closes it. Every Harness
- * start passes here (an agent's explore, Run Harness, `reticle try`, the platform's chat), so the
- * gate holds wherever a drive starts; every other tool works at any coverage. A tab that cannot be
- * resolved is not refused here: the drive itself answers for a missing tab. Counted once per refusal.
- */
-export declare function coverageRefusal(deps: ToolDeps, sessionId: string | undefined): string | undefined;
+/** Opens a refusal for version skew: the one thing to fix before a drive can decide anything. */
+export declare const MSG_SKEW_LEAD: string;
 /**
- * The gate a Harness start obeys. When the project is linked, the platform's verdict is the one
- * source of truth: it locks a run mid-drive on the same report, so a daemon that refused what the
- * platform unlocked showed two scores for one project. The daemon's own reading only refuses when
- * the platform said nothing (not linked, unreachable, an older API) or said locked too, in which
- * case the daemon's sentence names what this tab can fix.
+ * Why a Harness drive must not start on this tab, or undefined when it may. Only a page and daemon
+ * from different builds refuse here. The setup score never does: the Harness runs at any
+ * instrumentation, so an app works out of the box. A tab that cannot be resolved is not refused
+ * here: the drive itself answers for a missing tab.
  */
-export declare function harnessLockRefusal(deps: ToolDeps, sessionId: string | undefined, env: Record<string, string | undefined>, fetchConfig?: ConfigFetch): Promise<string | undefined>;
+export declare function harnessStartRefusal(deps: ToolDeps, sessionId: string | undefined): Promise<HarnessRefusal | undefined>;
 /**
  * Can this machine reach the Harness? Only through the platform: a linked project or a platform
  * key. Whether the workspace is entitled is the platform's answer, asked when the drive starts.
@@ -77,12 +94,17 @@ export declare function harnessAvailable(env: Record<string, string | undefined>
  * retry or bring a key. Fields an older platform omits still default to yes inside
  * `fetchPlatformConfig`; only an answer that never arrived is a no.
  */
-export declare function refusedByPlatform(env: Record<string, string | undefined>, options: HarnessAsk): Promise<string | undefined>;
+export declare function refusedByPlatform(env: Record<string, string | undefined>, options: HarnessAsk): Promise<HarnessRefusal | undefined>;
 /**
  * `refusedByPlatform`, for a run that may be a saved plan. A plan that only replays saved flows
  * spends no model turn, so a model drive's gates do not stop it; a refused plan is still reported to
  * the plan, every journey blocked with the reason, so its history records the attempt.
  */
-export declare function refusedForPlan(env: Record<string, string | undefined>, options: HarnessAsk): Promise<string | undefined>;
+export declare function refusedForPlan(env: Record<string, string | undefined>, options: HarnessAsk): Promise<HarnessRefusal | undefined>;
+/** A refusal: the sentence the person or agent reads, and the reason `harness_run` reports. */
+export interface HarnessRefusal {
+    text: string;
+    reason: HarnessRunReason;
+}
 /** The sentence a refusal leads with, without the prompt that follows it. */
 export declare const firstLine: (text: string) => string;

package/dist/surface/tools/harness-gate.js

@@ -3,31 +3,44 @@
  *
  * Split from `harness-explore.ts`, which runs the drive. This is the gate every Harness start passes
  * through (an agent's explore, Run Harness, `reticle try`, the platform's chat): the linked
- * credential, the instrumentation-coverage lock, and the platform's own yes or no.
+ * credential, a page and daemon from different builds, and the platform's own yes or no. No setup
+ * score gates it: the Harness runs at any instrumentation.
  */
+import { HarnessRunReason } from '@reticlehq/core/telemetry';
 import { reportAppsNow } from '../../features/harness/platform/local-apps.js';
 import { serverOptionsFromEnv } from '../../features/harness/platform/server-driver.js';
-import { ReticleEnv, cloudUrlFrom } from '@reticlehq/core';
+import { CONNECT_COMMAND, HARNESS_NOT_LINKED_NEXT, RefusalCode, ReticleEnv, ReticleTool, cloudUrlFrom, } from '@reticlehq/core';
+import { DriveRefusedError } from '../../features/harness/drive-runs.js';
 import { creditsSpent, creditsUsedLine } from '@reticlehq/core/hud';
 import { planUrl } from '../../features/harness/platform/platform-drives.js';
 import { isUnmatchedRoot } from '../../memory/project/dir/reticle-dir.js';
 import { sessionRoot } from '../../memory/project/session-root.js';
 import { fetchPlatformConfig } from '../../features/harness/platform-config.js';
 import { reportPlanBlocked, savedPlanDrivesNothing } from '../../features/harness/platform/script.js';
-import { instrumentationOf, probeMarkers } from '../../portal/session/recorded-gaps.js';
-import { getSessionMetrics } from '../../telemetry/session-metrics.js';
+import { probeMarkers } from '../../portal/session/recorded-gaps.js';
 import { MSG_HARNESS_DISABLED, MSG_HARNESS_UNCLAIMED, MSG_HARNESS_UNCONFIRMED, } from '../../features/harness/platform/refusal.js';
 /**
  * Why the harness is unavailable, phrased as the way to make it available.
  *
- * A missing key is a configuration fact, not a fault, and the sentence a user reads has to tell them
- * the one thing to do about it. Named here because both the CLI and the honest no-flows refusal
- * print it, and two copies of this sentence would drift.
+ * A missing key is a configuration fact, not a fault. This is the AGENT's sentence: who does what
+ * next, short, and no credit number (free credit is granted once per person, so the engine cannot
+ * know what is left). Named here because the CLI and the honest no-flows refusal print it too.
  */
-export const MSG_NO_HARNESS_KEY = `The Reticle Harness runs on the Reticle platform, and a new account gets 10 free credits ` +
-    `to try it: run \`reticle connect\` to link this project and sign in. ` +
-    `Without it, drive the journey yourself with reticle_act_and_wait and an \`until\` on its last step: ` +
-    `what you drive is saved as a flow just the same.`;
+export const MSG_NO_HARNESS_KEY = `The Reticle Harness runs on the Reticle platform, and this project is not linked to it. ` +
+    `Ask the person to run \`${CONNECT_COMMAND}\`, or drive the journey yourself with ` +
+    `${ReticleTool.ACT_AND_WAIT} and an \`until\` on its last step.`;
+/**
+ * The not-linked refusal, thrown. Its code and next steps ride on the error envelope beside the
+ * sentence (`codedRefusalOf`), so the agent reads who does what as data and error-recovery keys on
+ * the code. The person reads `HARNESS_NOT_LINKED_HUMAN` on the HUD instead.
+ */
+export class HarnessNotLinkedError extends DriveRefusedError {
+    code = RefusalCode.HARNESS_NOT_LINKED;
+    next = HARNESS_NOT_LINKED_NEXT;
+    constructor() {
+        super(MSG_NO_HARNESS_KEY, HarnessRunReason.NOT_LINKED);
+    }
+}
 /**
  * The environment, plus the credential this machine already has.
  *
@@ -83,21 +96,9 @@ function tabRoot(deps, tab) {
         return undefined;
     }
 }
-/** Introduces the prompt under a coverage refusal, so the agent knows it is for itself. */
-export const MSG_GATE_PROMPT_LEAD = 'To unlock it, do this (or hand it to your coding agent):';
-/**
- * Why the Harness must not drive this tab's app yet, or undefined when it may: below the coverage
- * gate (core's `instrumentation-coverage.ts`), one reason sentence and the prompt that closes it. Every Harness
- * start passes here (an agent's explore, Run Harness, `reticle try`, the platform's chat), so the
- * gate holds wherever a drive starts; every other tool works at any coverage. A tab that cannot be
- * resolved is not refused here: the drive itself answers for a missing tab. Counted once per refusal.
- */
-export function coverageRefusal(deps, sessionId) {
-    const refused = localGateRefusal(deps, sessionId);
-    if (refused !== undefined)
-        getSessionMetrics().recordHarnessRefused(refused.percent);
-    return refused?.text;
-}
+/** Opens a refusal for version skew: the one thing to fix before a drive can decide anything. */
+export const MSG_SKEW_LEAD = "The page's Reticle SDK and this daemon are different builds, so a Harness drive could only " +
+    'answer "unknown" on every step. It did not start. Fix the versions first:';
 /** This tab and every other live tab of its app, or undefined when the tab cannot be resolved. */
 function appTabsOf(deps, sessionId) {
     let tab;
@@ -107,8 +108,7 @@ function appTabsOf(deps, sessionId) {
     catch {
         return undefined;
     }
-    // Every tab of the app, the way the platform's merged report reads it, so the two name the same
-    // missing items.
+    // Every tab of the app, the way the platform's merged report reads it.
     const siblings = (deps.sessions.list?.() ?? [])
         .filter((info) => info.sessionId !== tab.id && sameApp(info.projectId, tab.projectId))
         .flatMap((info) => {
@@ -117,47 +117,23 @@ function appTabsOf(deps, sessionId) {
     });
     return { tab, siblings };
 }
-/** The daemon's own reading of the gate for this tab's app, uncounted. */
-function localGateRefusal(deps, sessionId) {
-    const app = appTabsOf(deps, sessionId);
-    if (app === undefined)
-        return undefined;
-    const { tab } = app;
-    const siblings = app.siblings.map((live) => ({
-        id: live.id,
-        url: live.url,
-        projectId: live.projectId,
-        channels: live.channels,
-        sourceMapping: live.sourceMapping,
-    }));
-    const coverage = instrumentationOf(tab, siblings);
-    const gate = coverage.harnessGate;
-    if (gate.unlocked || gate.reason === undefined)
-        return undefined;
-    const text = coverage.prompt === undefined
-        ? gate.reason
-        : `${gate.reason}\n\n${MSG_GATE_PROMPT_LEAD}\n${coverage.prompt}`;
-    return { text, percent: gate.percent };
-}
 /**
- * The gate a Harness start obeys. When the project is linked, the platform's verdict is the one
- * source of truth: it locks a run mid-drive on the same report, so a daemon that refused what the
- * platform unlocked showed two scores for one project. The daemon's own reading only refuses when
- * the platform said nothing (not linked, unreachable, an older API) or said locked too, in which
- * case the daemon's sentence names what this tab can fix.
+ * Why a Harness drive must not start on this tab, or undefined when it may. Only a page and daemon
+ * from different builds refuse here. The setup score never does: the Harness runs at any
+ * instrumentation, so an app works out of the box. A tab that cannot be resolved is not refused
+ * here: the drive itself answers for a missing tab.
  */
-export async function harnessLockRefusal(deps, sessionId, env, fetchConfig) {
-    // What the app's pages carry decides, not what an act happened to reach: ask them first.
+export async function harnessStartRefusal(deps, sessionId) {
     const app = appTabsOf(deps, sessionId);
-    // Learned something: the platform hears it before it is asked, or it refuses on its old score.
+    // A page and daemon from different builds answer every step `unknown`: a drive spends its credits
+    // and proves nothing. The handshake already knows, so say it before anything is spent.
+    const skew = app?.tab.versionSkew;
+    if (skew !== undefined && 0 < skew.length)
+        return refusal(`${MSG_SKEW_LEAD} ${skew}`, HarnessRunReason.VERSION_SKEW);
+    // Learned something: the platform hears it before the drive, so its coverage reading is current.
     if (app !== undefined && (await probeMarkers([app.tab, ...app.siblings])))
         await reportAppsNow().catch(() => undefined);
-    if (undefined === localGateRefusal(deps, sessionId))
-        return undefined;
-    const platform = await fetchPlatformConfig(env, fetchConfig);
-    if (true === platform?.gate?.unlocked)
-        return undefined;
-    return coverageRefusal(deps, sessionId);
+    return undefined;
 }
 /** Two tabs are one app when both name the same project. A tab that names none stands alone. */
 const sameApp = (a, b) => a !== undefined && a === b;
@@ -191,27 +167,22 @@ export async function refusedByPlatform(env, options) {
         return undefined;
     // No platform, no Harness: it runs there, on the workspace's credits.
     if (serverOptionsFromEnv(env) === undefined)
-        return MSG_NO_HARNESS_KEY;
+        return refusal(MSG_NO_HARNESS_KEY, HarnessRunReason.NOT_LINKED);
     const config = await platformConfig(env, options);
     // It needs a confirmed yes, not the absence of a no. The platform also checks on every turn.
     if (config === undefined)
-        return MSG_HARNESS_UNCONFIRMED;
-    // The project-wide lock before the switch: a fresh tab passes the per-tab gate with no gaps
-    // recorded, and "off" hid the one refusal that names its fix.
-    const gate = config.gate;
-    if (false === gate?.unlocked && gate.reason !== undefined)
-        return gate.prompt === undefined
-            ? gate.reason
-            : `${gate.reason}\n\n${MSG_GATE_PROMPT_LEAD}\n${gate.prompt}`;
+        return refusal(MSG_HARNESS_UNCONFIRMED, HarnessRunReason.PLATFORM_UNREACHABLE);
+    // An older platform may still send `harnessUnlocked: false`. It is not read: no setup score
+    // refuses a drive.
     if (!config.harnessEnabled)
-        return MSG_HARNESS_DISABLED;
+        return refusal(MSG_HARNESS_DISABLED, HarnessRunReason.HARNESS_OFF);
     // Before entitlement: no credits left is why most workspaces are not entitled, said as the HUD says it.
     if (config.credits !== undefined && creditsSpent(config.credits))
-        return creditsUsedLine(config.credits, 
+        return refusal(creditsUsedLine(config.credits, 
         // The platform's own page; built from the API origin only for a platform that names none.
-        config.planUrl ?? planUrl(config.platformUrl ?? cloudUrlFrom(env) ?? ''));
+        config.planUrl ?? planUrl(config.platformUrl ?? cloudUrlFrom(env) ?? '')), HarnessRunReason.NO_CREDITS);
     if (!config.harnessEntitled)
-        return MSG_HARNESS_UNCLAIMED;
+        return refusal(MSG_HARNESS_UNCLAIMED, HarnessRunReason.NOT_ENTITLED);
     return undefined;
 }
 /**
@@ -226,10 +197,13 @@ export async function refusedForPlan(env, options) {
         return refusedByPlatform(env, options);
     if (await savedPlanDrivesNothing(platform, planId))
         return undefined;
-    const refusal = await refusedByPlatform(env, options);
-    if (refusal !== undefined)
-        await reportPlanBlocked(platform, planId, firstLine(refusal));
-    return refusal;
+    const refused = await refusedByPlatform(env, options);
+    if (refused !== undefined)
+        await reportPlanBlocked(platform, planId, firstLine(refused.text));
+    return refused;
+}
+function refusal(text, reason) {
+    return { text, reason };
 }
 /** The sentence a refusal leads with, without the prompt that follows it. */
 export const firstLine = (text) => text.split('\n')[0] ?? text;

package/dist/surface/tools/harness-script.d.ts

@@ -20,6 +20,8 @@ export declare function laneSeed(deps: ToolDeps, sessionId: string | undefined,
  * nothing to plan from, so the caller drives the app with no plan, as before.
  */
 export declare function exploreScript(deps: ToolDeps, env: Record<string, string | undefined>, options: ExploreOptions, before: ReadonlySet<string>): Promise<ExploreResult | undefined>;
+/** What the project still owes, in its own words: the user's recent request, then open intents. */
+export declare function memoryGoals(deps: ToolDeps, sessionId?: string): Promise<string[]>;
 /**
  * The run's goal verdict: false if any drive missed its goal, true if all judged ones reached it.
  * Every journey passed is the page's answer, already graded at each journey's end: a driver's own

package/dist/surface/tools/harness-script.js

@@ -7,7 +7,7 @@
  * the HUD and redrawn as each part starts and ends.
  */
 import { randomUUID } from 'node:crypto';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { ReticleCommand, ReticleTool, ScriptStatus, asRecord, } from '@reticlehq/core';
 import { JourneyBy, PromptContextSchema, checkScript, } from '@reticlehq/core/artifacts';
 import { runScript, } from '../../features/harness/script/script-run.js';
@@ -17,6 +17,7 @@ import { runHarness, StopReason, } from '../../features/harness/harness.js';
 import { reticleDirPaths } from '../../memory/project/dir/reticle-dir.js';
 import { harnessRunId, noteHarnessDisparity, noteHarnessGoal, noteHarnessSpan, } from '../../judgement/runs/drive-run.js';
 import { openSessionIntents } from '../../memory/intent/open-intents.js';
+import { sharesRequests } from '../../memory/intent/record-request.js';
 import { sessionRoot, sessionTarget } from '../../memory/project/session-root.js';
 import { leasableAppUrl, sessionUrlOf } from '../../language/flows/flow-tools.js';
 import { acquireLeasedSession, suiteFixtureSeed } from './lease-tools.js';
@@ -180,7 +181,7 @@ async function runPlan(deps, env, options, before, planned) {
     let off = false;
     const poll = setInterval(() => {
         void refusedByPlatform(env, options).then((refusal) => {
-            if (MSG_HARNESS_DISABLED === refusal)
+            if (MSG_HARNESS_DISABLED === refusal?.text)
                 off = true;
         });
     }, STOP_POLL_MS);
@@ -198,7 +199,7 @@ async function runPlan(deps, env, options, before, planned) {
         // A replay-only plan started without the model's gates; a fallback is the model, so it asks now.
         fallbackRefused: async () => {
             const refusal = await refusedByPlatform(env, options);
-            return refusal === undefined ? undefined : firstLine(refusal);
+            return refusal === undefined ? undefined : firstLine(refusal.text);
         },
         ...(true === options.confirmDangerous ? { confirmDangerous: true } : {}),
         lease: async () => {
@@ -435,13 +436,17 @@ function scriptTexts(script) {
     ];
 }
 /** What the project still owes, in its own words: the user's recent request, then open intents. */
-async function memoryGoals(deps, sessionId) {
+export async function memoryGoals(deps, sessionId) {
     const goals = [];
     try {
-        const parsed = PromptContextSchema.safeParse(JSON.parse(await deps.fs.readFile(reticleDirPaths(sessionRoot(deps, sessionId)).request)));
+        const root = sessionRoot(deps, sessionId);
+        const parsed = PromptContextSchema.safeParse(JSON.parse(await deps.fs.readFile(reticleDirPaths(root).request)));
         const at = parsed.success ? parsed.data.at : undefined;
         const request = parsed.success ? parsed.data.request : undefined;
-        if (request !== undefined && at !== undefined && deps.now() - at < REQUEST_FRESH_MS) {
+        // The request goes to the platform only when a run would carry it there too: captured shared,
+        // and the project has not said `"shareRequests": false` since.
+        const shared = parsed.success && true === parsed.data.shared && sharesRequests(dirname(root), root);
+        if (shared && request !== undefined && at !== undefined && deps.now() - at < REQUEST_FRESH_MS) {
             goals.push(request);
         }
     }

package/dist/surface/tools/harness-toolset.js

@@ -8,7 +8,6 @@
  * agent can reach.
  */
 import { z } from 'zod';
-import { zodToJsonSchema } from 'zod-to-json-schema';
 import { AppRuntime, ConsequenceKind, NetInitiator, PredicateKind, ReticleTool, } from '@reticlehq/core';
 import { TOOLS } from './tools.js';
 import { runTool } from './invoke-tool.js';
@@ -98,8 +97,8 @@ const INJECTED_PARAMS = new Set(['sessionId']);
  * wedge, it would manufacture one.
  */
 const TOOL_TIMEOUT_MS = 300_000;
-/** What the MCP SDK passes its own converter, restated so the two surfaces cannot drift apart. */
-const MCP_SCHEMA_OPTIONS = { strictUnions: true, pipeStrategy: 'input' };
+/** What the MCP SDK passes zod's own converter, restated so the two surfaces cannot drift apart. */
+const MCP_SCHEMA_OPTIONS = { target: 'draft-7', io: 'input' };
 /** Convert one tool's zod shape into the JSON Schema the model wire wants. */
 function toHarnessTool(tool) {
     const asked = Object.fromEntries(Object.entries(tool.inputSchema).filter(([name]) => !INJECTED_PARAMS.has(name)));
@@ -115,7 +114,7 @@ function toHarnessTool(tool) {
          * argument that decides whether a drive proves anything. Definitions and refs are what every
          * agent driving Reticle over MCP already reads.
          */
-        inputSchema: zodToJsonSchema(z.object(asked), MCP_SCHEMA_OPTIONS),
+        inputSchema: z.toJSONSchema(z.object(asked), MCP_SCHEMA_OPTIONS),
     };
 }
 /**

package/dist/surface/tools/invoke-tool.d.ts

@@ -1,13 +1,5 @@
 import { type NoticeFold } from './agent/notices.js';
 import type { ToolCall, ToolDef, ToolDeps } from './tool-kit.js';
-export declare const SESSION_BOUND_TOOLS: ReadonlySet<string>;
-/**
- * Tools that carry a `sessionId` arg but are NOT live-session-health tools — they read/write
- * disk (capabilities/contract/flow/project), drain a buffer, or steer session lifecycle. They are
- * exempt from the health splice ON PURPOSE. Kept explicit so the guard test can force every new
- * `sessionId`-bearing tool to be classified into exactly one set (bound XOR exempt).
- */
-export declare const SESSION_EXEMPT_TOOLS: ReadonlySet<string>;
 export declare function runTool<Ext>(tool: ToolDef<Ext>, deps: ToolDeps<Ext>, given: Record<string, unknown>, call?: ToolCall): Promise<unknown>;
 /** Advisories that become once-per-session notice lines. See agent/notices.ts. */
 export declare const NOTICE_FOLD: NoticeFold;