@reticlehq/server 3.7.0 → 3.8.1

package/dist/surface/tools/assert/assert-verdict.js

@@ -12,7 +12,7 @@ import { declaredExpectations, declaresBodyIndependentChannel, } from '@reticleh
 import { absenceBlindSpotNote, blindSpotsFromState, buildCoverageStatement, restsOnCompleteWindow, Coverage, impeachesCapture, transportGapNote, } from '@reticlehq/engine/evidence/blind-spots.js';
 import { buildHonestyBlock } from '@reticlehq/engine/evidence/honesty.js';
 import { acceptedWriteLabels, hasAcceptedWrite, } from '@reticlehq/engine/evidence/accepted-write.js';
-import { unreadWriteLabels } from '@reticlehq/engine/evidence/unread-outcome.js';
+import { unreadWriteLabels, unreadWriteReason } from '@reticlehq/engine/evidence/unread-outcome.js';
 import { decideVerified } from '@reticlehq/engine/evidence/verified.js';
 import { describeWaitTarget, namedNetIsInFlight } from '@reticlehq/engine/evidence/unsettled.js';
 import { inFlightRequestLabels, repeatedRequestLabels, } from '../act/settle-in-flight.js';
@@ -204,7 +204,9 @@ changeUndeclared) {
         }),
         contradictions,
         ...(0 === outcomePending.length ? {} : { outcomePending }),
-        ...(outcomeUnread.length > 0 ? { outcomeUnread } : {}),
+        ...(outcomeUnread.length > 0
+            ? { outcomeUnread, outcomeUnreadReason: unreadWriteReason(windowEvents) }
+            : {}),
         // Same detail the act path supplies: this route reaches UNSETTLED through an absence-derived
         // contradiction, and "the window closed before the app finished" is no more actionable here.
         unsettled: {

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

@@ -1,7 +1,7 @@
 import { carryReticleIdentity } from './lease-tools.js';
 import { z } from 'zod';
 import { navigateResult } from './act/navigation/navigate-result.js';
-import { absoluteTarget, awaitArrival, idsAtTarget, ARRIVAL_TIMEOUT_MS, } from './act/navigation/navigate-arrival.js';
+import { absoluteTarget, awaitArrival, idsOpenAtDispatch, ARRIVAL_TIMEOUT_MS, } from './act/navigation/navigate-arrival.js';
 import { reloadResult } from './act/navigation/reload-result.js';
 import { waitForReconnect, RELOAD_RECONNECT_TIMEOUT_MS, } from '../../portal/session/session-reconnect.js';
 import { ReticleCommand } from '@reticlehq/core';
@@ -9,6 +9,7 @@ import { ReticleTool } from '@reticlehq/core';
 import { asNumber, asString } from '@reticlehq/core';
 import { sessionIdShape, commandOrThrow } from './tool-kit.js';
 import { timeoutMsSchema } from './args/numeric-bounds.js';
+import { assertNotPaymentNavigation } from './act/act-danger.js';
 /** Said when a lease's page now has no Reticle SDK: only the browser can still act on it. */
 const MSG_LEASE_WITHOUT_SDK = 'This page has no Reticle SDK, so only browser-level actions apply here (navigate, screenshot). ' +
     'The lease is kept: navigate back to the app and it reattaches.';
@@ -111,6 +112,7 @@ export const BROWSER_TOOLS = [
             const requested = asString(args['url']);
             if (requested === undefined || 0 === requested.length)
                 return { ok: false, reason: 'url required' };
+            assertNotPaymentNavigation(requested);
             const named = asString(args['sessionId']);
             // A lease whose page has no SDK right now (it was navigated to an image, a PDF, another site):
             // the page is still the lease's, so it is navigated through the browser and reattaches when it
@@ -128,10 +130,11 @@ export const BROWSER_TOOLS = [
             // lease — see carryReticleIdentity. A tab that claims no identity is untouched.
             const url = carryReticleIdentity(session.url, requested);
             // Sampled BEFORE dispatch, because that is the only moment it can be known. A session already
-            // sitting on the target is not evidence that THIS navigation arrived — and the arrival scan,
-            // which reads whatever is at the target afterwards, cannot tell the two apart on its own.
+            // connected is not evidence that THIS navigation arrived: one on the target was there before,
+            // and another tab (a lease) can reach the target during the wait. The arrival scan, which
+            // reads whatever is at the target afterwards, cannot tell them apart on its own.
             const target = absoluteTarget(url, session.url);
-            const priorIds = idsAtTarget(deps.sessions, target);
+            const priorIds = idsOpenAtDispatch(deps.sessions);
             // The document the tab is on NOW. Sampled before dispatch because the replacement can
             // connect while the NAVIGATE reply is still pending, and reading it after the await would
             // record the replacement as the starting document (#1320).

package/dist/surface/tools/chat-drives.js

@@ -21,13 +21,13 @@ import { REMOTE_DRIVE_JPEG_QUALITY, endDrivenTab, pickOwnDriveSession, startRemo
 import { appKeyOf, appsByPlatform, homeRelative, machineOf, mayOpen, NOT_AN_APP_ADDRESS, nameFromProjectId, pickAppTab, startAppReports, withoutMarks, } from '../../features/harness/platform/local-apps.js';
 import { serverOptionsFromEnv } from '../../features/harness/platform/server-driver.js';
 import { EXPLORE_TOOLS, driveForChat } from './explore-tools.js';
-import { MSG_NO_HARNESS_KEY, harnessLockRefusal, withLinkedCredential } from './harness-explore.js';
+import { harnessStartRefusal, withLinkedCredential } from './harness-explore.js';
 import { runTool } from './invoke-tool.js';
 import { announcedChannels, probeMarkers, notApplicableOf, recordedGaps, } from '../../portal/session/recorded-gaps.js';
 import { probeDevServers } from '../../portal/session/dev-server/dev-server-probe.js';
-import { DriveOrigin, onDriveChange, onDriveStep, runningDrive, stopDrive, } from '../../features/harness/drive-runs.js';
+import { DriveOrigin, noteHarnessWord, onDriveChange, onDriveStep, runningDrive, stopDrive, } from '../../features/harness/drive-runs.js';
 import { FreeDriveKind, planUrl, requestFreeDrive, } from '../../features/harness/platform/platform-drives.js';
-import { HumanControlKind } from '@reticlehq/core';
+import { CONNECT_COMMAND, HARNESS_NOT_LINKED_HUMAN, HumanControlKind, } from '@reticlehq/core';
 import { onAgentsChange } from '../../hooks/coding-agents.js';
 /** Why a platform drive with no tab of its own runs no tool. */
 const NO_DRIVEN_TAB = 'No tab was picked for this drive, so no tool runs.';
@@ -293,7 +293,7 @@ const MSG_LINKED = 'Linked. This project now reports to your dashboard.';
 const MSG_LINK_FAILED = 'Could not link this project. Run `reticle connect` in its folder.';
 /** A page with no projectId: linking it would bind a hash-named project nothing here reads. */
 const MSG_LINK_NEEDS_PROJECT = 'This page did not say which project it is, so there is nothing to link yet. Run `npx @reticlehq/server init` in your app (or pass `projectId` to `connect()`), then Link.';
-const MSG_LINK_UNAVAILABLE = 'This Reticle cannot link from the panel. Run `reticle connect` in the project folder.';
+const MSG_LINK_UNAVAILABLE = `This Reticle cannot link from the panel. Run \`${CONNECT_COMMAND}\` in the project folder.`;
 /** Said on the HUD when Stop finds nothing to stop. */
 const MSG_NOTHING_DRIVING = 'No Harness drive is running in this tab.';
 const msgStartTrial = (url) => `Start your trial: ${url}`;
@@ -312,21 +312,41 @@ applySwitch, grant = (platform) => requestFreeDrive(platform, FreeDriveKind.EXPL
     if (HumanControlKind.HARNESS === request.kind)
         return applySwitch(request.enabled);
     // What the panel's Run and Stop answer belongs in the Harness log, and in the Agent Log as a summary.
-    const say = (text) => deps.sessions.get?.(sessionId)?.pushNarration(text, true, { harness: true, summary: true });
+    const said = [];
+    const say = (text) => {
+        said.push(text);
+        deps.sessions.get?.(sessionId)?.pushNarration(text, true, { harness: true, summary: true });
+    };
     if (HumanControlKind.HARNESS_STOP === request.kind) {
         const running = runningDrive(sessionId);
         if (running === undefined || !stopDrive(running.harnessRun))
             say(MSG_NOTHING_DRIVING);
         return;
     }
-    // Before the grant: a drive the gate refuses must not take one. The panel shows the prompt.
+    // Whatever stops a run before it drives is said on the Run row too, not only in the log: with the
+    // cloud unreachable, Run went to Starting… and back with no word on the page.
+    try {
+        await startHudRun(deps, sessionId, request, say, grant);
+    }
+    catch (error) {
+        say(error instanceof Error ? error.message : String(error));
+    }
+    finally {
+        if (0 < said.length)
+            noteHarnessWord(sessionId, said.join(' '));
+    }
+}
+/** Run Harness: the build check, the platform's grant, then the drive, saying why at each refusal. */
+async function startHudRun(deps, sessionId, request, say, grant) {
+    // Before the grant: a drive refused for version skew must not take one.
     const env = await withLinkedCredential(deps, process.env, { sessionId });
-    const locked = await harnessLockRefusal(deps, sessionId, env);
+    const locked = await harnessStartRefusal(deps, sessionId);
     if (locked !== undefined)
-        return say(locked.split('\n')[0] ?? locked);
+        return say(locked.text.split('\n')[0] ?? locked.text);
     const platform = serverOptionsFromEnv(env);
+    // The person's sentence: the agent's (`MSG_NO_HARNESS_KEY`) names tools they never call.
     if (platform === undefined)
-        return say(MSG_NO_HARNESS_KEY);
+        return say(HARNESS_NOT_LINKED_HUMAN);
     const granted = await grant(platform);
     if (!granted.granted) {
         say(granted.message);
@@ -338,18 +358,13 @@ applySwitch, grant = (platform) => requestFreeDrive(platform, FreeDriveKind.EXPL
     const explore = EXPLORE_TOOLS.find((tool) => ReticleTool.VERIFY_EXPLORE === tool.name);
     if (explore === undefined)
         return;
-    try {
-        await runTool(explore, deps, {
-            sessionId,
-            driveId: granted.driveId,
-            origin: DriveOrigin.HUD,
-            wait: 0,
-            ...(request.persona === undefined ? {} : { persona: request.persona }),
-        });
-    }
-    catch (error) {
-        say(error instanceof Error ? error.message : String(error));
-    }
+    await runTool(explore, deps, {
+        sessionId,
+        driveId: granted.driveId,
+        origin: DriveOrigin.HUD,
+        wait: 0,
+        ...(request.persona === undefined ? {} : { persona: request.persona }),
+    });
 }
 /**
  * The link a panel sign-in makes once it lands: the tab's project, never a page that did not say
@@ -370,18 +385,28 @@ link) {
     bridge.attachHarnessRequest((request, s) => {
         const root = s.artifactRoot ?? daemon.root;
         if (HumanControlKind.HARNESS_LINK === request.kind) {
-            const say = (text) => daemon.deps().sessions.get?.(s.id)?.pushNarration(text);
+            // On the Harness page, where Link was pressed, and in the Agent Log. Said only in the log, a
+            // refusal left the page saying "Linking…" and nothing else.
+            const say = (text) => daemon
+                .deps()
+                .sessions.get?.(s.id)
+                ?.pushNarration(text, true, { harness: true, summary: true });
+            const refuse = (text) => {
+                say(text);
+                daemon.repaint();
+            };
             if (link === undefined)
-                return say(MSG_LINK_UNAVAILABLE);
+                return refuse(MSG_LINK_UNAVAILABLE);
             if (isUnmatchedRoot(root))
-                return say(MSG_LINK_NEEDS_PROJECT);
+                return refuse(MSG_LINK_NEEDS_PROJECT);
             void link(root)
                 .then((code) => say(0 === code ? MSG_LINKED : MSG_LINK_FAILED))
                 .catch(() => say(MSG_LINK_FAILED))
                 .finally(daemon.repaint);
             return;
         }
-        void hudDrive(daemon.deps(), s.id, request, (on) => applySwitch(root, on));
+        // Repainted after, so a refusal said on the Run row shows without waiting for another push.
+        void hudDrive(daemon.deps(), s.id, request, (on) => applySwitch(root, on)).finally(daemon.repaint);
     });
     onDriveChange(daemon.repaint);
     // Each step too, so the panel's "N steps so far" counts up instead of sitting at zero.

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

@@ -69,7 +69,7 @@ export function buildCoverageTools() {
             outputSchema: {
                 // The app-wide ledger — see features/exhaust/ledger.ts. Loose: run-only, and the levels
                 // carry their own shape.
-                app: z.record(z.unknown()).optional(),
+                app: z.record(z.string(), z.unknown()).optional(),
                 total: z.number(),
                 exercised: z.number(),
                 untouched: z.array(z.object({ ref: z.string(), label: z.string() })),

package/dist/surface/tools/dynamic-tools.d.ts

@@ -1,5 +1,13 @@
+import { z } from 'zod';
 import type { ToolDef } from './tool-kit.js';
 import { type ToolSurfaceOrigin } from './tool-surface.js';
+/**
+ * A parameter's description, wherever in its wrappers it was written.
+ *
+ * zod 4 keeps a description on the schema `.describe()` was called on. `z.string().describe(d)
+ * .optional()` has none on the outside, although the JSON Schema an agent reads still carries `d`.
+ */
+export declare function descriptionOf(schema: z.ZodTypeAny): string | undefined;
 /**
  * Build the two dynamic meta-tools over the full tool table. `reticle_run` dispatches through the same
  * `runTool` chokepoint as a direct call, so session-health splicing and every other invariant hold.

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

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { runTool } from './invoke-tool.js';
-import { buildErrorPayload } from './error-recovery.js';
+import { buildErrorPayload, codedRefusalOf } from './error-recovery.js';
 import { mergedNameRedirect, mergedNameMessage, retiredToolNames } from './merged-name-redirect.js';
 import { CATALOGUE_SUMMARY_LENGTH, firstSentence } from './first-sentence.js';
 import { takeVersionSkewOnto } from '../../command/version/version-nudge.js';
@@ -8,6 +8,43 @@ import { ReticleTool } from '@reticlehq/core';
 import { ADVERTISE_ALL_ENV } from './tool-surface.js';
 import { getSessionMetrics } from '../../telemetry/session-metrics.js';
 import { isPredicateParam, predicateGrammar, } from '@reticlehq/engine/question/predicate/predicate-eval.js';
+/** One wrapper that does not change the value a schema accepts, peeled off; undefined at the core. */
+function unwrapOnce(schema) {
+    if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable) {
+        return schema.unwrap();
+    }
+    if (schema instanceof z.ZodDefault) {
+        return schema.removeDefault();
+    }
+    if (schema instanceof z.ZodPipe) {
+        // A transform pipes the schema into the transform; a preprocess pipes the other way round.
+        return (schema.in instanceof z.ZodTransform ? schema.out : schema.in);
+    }
+    return undefined;
+}
+/** The schema without the wrappers that do not change the value it accepts. */
+function unwrappedOf(schema) {
+    let inner = schema;
+    for (let next = unwrapOnce(inner); next !== undefined; next = unwrapOnce(inner)) {
+        inner = next;
+    }
+    return inner;
+}
+/**
+ * A parameter's description, wherever in its wrappers it was written.
+ *
+ * zod 4 keeps a description on the schema `.describe()` was called on. `z.string().describe(d)
+ * .optional()` has none on the outside, although the JSON Schema an agent reads still carries `d`.
+ */
+export function descriptionOf(schema) {
+    for (let current = schema; current !== undefined;) {
+        if (current.description !== undefined) {
+            return current.description;
+        }
+        current = unwrapOnce(current);
+    }
+    return undefined;
+}
 /**
  * A numeric parameter's enforced bounds, read off the schema that enforces them (#1537).
  *
@@ -16,34 +53,46 @@ import { isPredicateParam, predicateGrammar, } from '@reticlehq/engine/question/
  * prose, so the number shown is the number checked and cannot drift from it.
  */
 function boundsOf(schema) {
-    let inner = schema;
-    for (;;) {
-        if (inner instanceof z.ZodOptional || inner instanceof z.ZodNullable) {
-            inner = inner.unwrap();
-        }
-        else if (inner instanceof z.ZodDefault) {
-            inner = inner.removeDefault();
-        }
-        else if (inner instanceof z.ZodEffects) {
-            inner = inner.innerType();
-        }
-        else
-            break;
-    }
-    if (!(inner instanceof z.ZodNumber))
+    const inner = unwrappedOf(schema);
+    if (!(inner instanceof z.ZodNumber)) {
         return {};
-    const { minValue: min, maxValue: max } = inner;
+    }
+    // `.int()` reports the safe-integer range as its bounds. That range bounds nothing an agent sends.
+    const min = Number.MIN_SAFE_INTEGER < (inner.minValue ?? Number.MIN_SAFE_INTEGER) ? inner.minValue : null;
+    const max = Number.MAX_SAFE_INTEGER > (inner.maxValue ?? Number.MAX_SAFE_INTEGER) ? inner.maxValue : null;
     return { ...(null === min ? {} : { min }), ...(null === max ? {} : { max }) };
 }
+/**
+ * An enum parameter's accepted values, read off the enum that enforces them (#1775).
+ *
+ * `claim` on reticle_session takes `pass | fail | partial`, but its description said only what the
+ * value means, so an agent sent a sentence and the call was refused. Read here rather than written
+ * into prose, so the values shown are the values checked and cannot drift from them.
+ */
+function valuesOf(schema) {
+    const inner = unwrappedOf(schema);
+    if (!(inner instanceof z.ZodEnum)) {
+        return undefined;
+    }
+    const options = inner.options;
+    if (!Array.isArray(options)) {
+        return undefined;
+    }
+    return options.filter((option) => 'string' === typeof option);
+}
 /** Compact param list from a tool's zod shape — name/required/description (the description already
- * carries the type and any enum hints, so no JSON-Schema machinery is needed), plus numeric bounds. */
+ * carries the type, so no JSON-Schema machinery is needed), plus closed values and numeric bounds. */
 function paramInfo(shape) {
-    return Object.entries(shape).map(([name, schema]) => ({
-        name,
-        required: !schema.isOptional(),
-        description: schema.description ?? '',
-        ...boundsOf(schema),
-    }));
+    return Object.entries(shape).map(([name, schema]) => {
+        const values = valuesOf(schema);
+        return {
+            name,
+            required: !schema.isOptional(),
+            description: descriptionOf(schema) ?? '',
+            ...(values === undefined ? {} : { values }),
+            ...boundsOf(schema),
+        };
+    });
 }
 /**
  * The one wording for "you named a parameter that does not exist", shared by both checks in
@@ -141,24 +190,25 @@ callable) {
             .array(z.string())
             .optional()
             .describe('Tool names to load full params for. Omit to list all tools with summaries.'),
+        name: z.string().optional().describe('One tool name: the same as names:[name].'),
     };
     const reticleTools = {
         name: ReticleTool.TOOLS,
         // The "invoke them with reticle_run" half is true only where reticle_run exists. On a closed
         // surface it is the first thing an agent reads about this tool and it names a tool that is not
         // there, so it is said only where it can be acted on.
-        description: 'Discover Reticle tools on demand. Call with no arguments to list every tool (name + one-line summary); call with names:["reticle_network", …] to load full descriptions and parameters for specific tools.' +
+        description: 'Discover Reticle tools on demand. Call with no arguments to list every tool (name + one-line summary); call with names:["reticle_screenshot", …] to load full descriptions and parameters for specific tools.' +
             (callable === undefined
                 ? ' Then invoke them with reticle_run.'
                 : ' Every tool it lists is callable directly by name.') +
             ' This avoids paying for every tool definition on every turn.' +
-            // The flow workflow is taught ONLY where it can be followed. Three of its four calls —
+            // The flow workflow is taught ONLY where it can be followed. Most of its calls —
             // reticle_record, reticle_flow_save, reticle_verify { action: "heal" } — are in the merged table but are not
             // advertised, and a closed surface has no dispatch hatch to reach them, so naming them here
-            // hands the reader a four-step recipe of which one step works. Replaying flows that already
+            // hands the reader a recipe of which one step works. Replaying flows that already
             // exist is reachable either way, via reticle_verify, so that half is still offered.
             (callable === undefined
-                ? ' To make a verification REUSABLE (record once, replay free forever), the flow workflow lives here: reticle_record{action:"start"} → act → reticle_flow_save → reticle_verify{action:"flows"} (and reticle_verify { action: "heal" } on drift). Load those names when you want to save or re-run a flow.'
+                ? ' To make a verification REUSABLE (record once, replay free forever), the flow workflow lives here: reticle_record{action:"start"} → act → reticle_record{action:"stop"} → reticle_flow_save → reticle_verify{action:"flows"} (and reticle_verify { action: "heal" } on drift). Load those names when you want to save or re-run a flow.'
                 : ' Flows that already exist replay with reticle_verify { action: "flows" }. RECORDING a new one is not reachable from this surface; start the daemon with RETICLE_ADVERTISE_ALL_TOOLS=1 if you need to build one.'),
         inputSchema: toolsShape,
         handler: (_deps, args) => {
@@ -174,9 +224,11 @@ callable) {
                     hint: TOOLS_ARG_HINT,
                 });
             }
-            const names = Array.isArray(args['names'])
+            const listed = Array.isArray(args['names'])
                 ? args['names'].filter((n) => 'string' === typeof n)
                 : undefined;
+            const one = 'string' === typeof args['name'] ? [args['name']] : [];
+            const names = listed === undefined && 0 === one.length ? undefined : [...(listed ?? []), ...one];
             if (names === undefined || 0 === names.length) {
                 // The COUNT is stated, not just implied by the array length. An agent that can see 18 tools
                 // has no way to know whether that is all of them; being told the registry holds more is what
@@ -214,8 +266,9 @@ callable) {
             return Promise.resolve({
                 tools: names.map((n) => {
                     const t = byName.get(n);
-                    if (t !== undefined)
+                    if (t !== undefined) {
                         return { name: n, description: t.description, params: paramInfo(t.inputSchema) };
+                    }
                     // `reticle_run` has answered a merged name with its replacement for a while; the tool
                     // asked to DISCOVER tools still said "unknown tool", which is the wrong answer in the one
                     // place an agent goes to resolve a name it is unsure of. Same redirect, same derivation.
@@ -226,8 +279,8 @@ callable) {
         },
     };
     const runShape = {
-        tool: z.string().describe('Tool name to invoke, e.g. reticle_network.'),
-        args: z.record(z.unknown()).optional().describe('Arguments object for that tool.'),
+        tool: z.string().describe('Tool name to invoke, e.g. reticle_clock.'),
+        args: z.record(z.string(), z.unknown()).optional().describe('Arguments object for that tool.'),
         // Accepted AND FORWARDED, not merely tolerated. reticle_run is the only way to reach an
         // unadvertised tool, so on a machine running several projects it has to be aimable — and
         // `sessionId` is the shape an agent already uses on every other tool. Reported from the field
@@ -274,8 +327,9 @@ callable) {
                 // ...and for 22 of those names the capability DOES exist, it just moved when tools merged.
                 // Answering "unknown tool" there is simply wrong; see merged-name-redirect.
                 const absent = explainAbsent(name);
-                if ('unknown tool' !== absent.error)
+                if ('unknown tool' !== absent.error) {
                     return absent;
+                }
                 return { error: `unknown tool '${name}'`, available: reachable.map((t) => t.name) };
             }
             // The outer aim, forwarded ONLY to a tool that declares a session — injecting it into one that
@@ -327,7 +381,8 @@ callable) {
                 // is reached through here: a stale ref, a paused session, a missing pairing token all came
                 // back as the agent's arguments being wrong, which is advice that spends the retry.
                 const message = error instanceof Error ? error.message : String(error);
-                return { ...takeVersionSkewOnto(buildErrorPayload(message), deps.peerSkew), tool: name };
+                const payload = buildErrorPayload(message, codedRefusalOf(error));
+                return { ...takeVersionSkewOnto(payload, deps.peerSkew), tool: name };
             }
         },
     };

package/dist/surface/tools/empty-session-list.d.ts

@@ -1,10 +1,12 @@
 import { z } from 'zod';
+import { wiringConsent } from '../../portal/session/no-session-next-action.js';
+export { wiringConsent };
 import type { ToolDeps } from './tool-kit.js';
 /** The fields only an empty list carries, declared so a schema-aware client does not strip them. */
 export declare const EMPTY_SESSION_LIST_OUTPUT: {
     why: z.ZodOptional<z.ZodString>;
     next_action: z.ZodOptional<z.ZodObject<{
-        action: z.ZodNativeEnum<{
+        action: z.ZodEnum<{
             readonly START_DEV_SERVER: "start_dev_server";
             readonly RUN_INIT: "run_init";
             readonly OPEN_APP: "open_app";
@@ -14,38 +16,29 @@ export declare const EMPTY_SESSION_LIST_OUTPUT: {
         command: z.ZodOptional<z.ZodString>;
         port: z.ZodOptional<z.ZodNumber>;
         reason: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        action: "start_dev_server" | "run_init" | "open_app" | "reopen_app" | "daemon_split";
-        reason: string;
-        port?: number | undefined;
-        command?: string | undefined;
-    }, {
-        action: "start_dev_server" | "run_init" | "open_app" | "reopen_app" | "daemon_split";
-        reason: string;
-        port?: number | undefined;
-        command?: string | undefined;
-    }>>;
+    }, z.core.$strip>>;
     talk_to_us: z.ZodOptional<z.ZodString>;
-    wired: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    next_step: z.ZodOptional<z.ZodObject<{
+        offered: z.ZodEnum<{
+            readonly LEASE: "lease";
+            readonly INIT_CONSENT: "init_consent";
+        }>;
+        lease: z.ZodOptional<z.ZodString>;
+        consent: z.ZodString;
+    }, z.core.$strip>>;
     lastKnown: z.ZodOptional<z.ZodObject<{
         sessionId: z.ZodString;
         url: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        sessionId: string;
-        url: string;
-    }, {
-        sessionId: string;
-        url: string;
-    }>>;
+    }, z.core.$strip>>;
 };
 /**
- * Wire the calling project when another project's tab is the one currently connected.
+ * The next step for the calling project when another project's tab is the one connected.
  *
  * The list handler only used to reach {@link emptySessionList} when the daemon's whole list was
  * empty. A live tab in project A then answered project B's first call with A's sessions, and B
- * was never wired.
+ * never heard that it was not wired.
  */
-export declare function wireCallerBesideLiveSessions(deps: ToolDeps, sessions: readonly {
+export declare function nextStepBesideLiveSessions(deps: ToolDeps, sessions: readonly {
     projectId?: string;
-}[]): Promise<unknown>;
-export declare function emptySessionList(deps: ToolDeps, sessions: unknown[]): Promise<Record<string, unknown>>;
+}[]): Record<string, unknown> | undefined;
+export declare function emptySessionList(deps: ToolDeps, sessions: unknown[]): Record<string, unknown>;