@reticlehq/server 3.7.0 → 3.8.1

package/dist/portal/realm/web-realm.js

@@ -58,22 +58,25 @@ const PAGE_CAPABILITIES = [
 ];
 /** Why an action's settle wait ended, when the page said. */
 function readSettleReason(result) {
-    if ('object' !== typeof result || null === result)
+    if ('object' !== typeof result || null === result) {
         return undefined;
+    }
     const reason = result.settleReason;
     return 'string' === typeof reason ? reason : undefined;
 }
 /** A network event's correlation id, if it carries one. Events are `unknown` at this boundary. */
 function readRequestId(data) {
-    if ('object' !== typeof data || null === data)
+    if ('object' !== typeof data || null === data) {
         return undefined;
+    }
     const id = data.id;
     return 'string' === typeof id ? id : undefined;
 }
 /** What the request was pointed at, for a blind spot a person has to read. */
 function readUrl(data) {
-    if ('object' !== typeof data || null === data)
+    if ('object' !== typeof data || null === data) {
         return undefined;
+    }
     const url = data.url;
     return 'string' === typeof url ? url : undefined;
 }
@@ -158,6 +161,11 @@ export const NOT_EVIDENCE = {
  */
 export const NO_PROTOCOL_CHANNEL = {
     download: 'a file the application produced; the protocol has no channel for an emitted artifact',
+    // Recorded for the episode, not yet read by a verdict. Both are screen facts and belong on `ui`,
+    // but putting them there changes what an assertion sees (a canvas animating every frame is a
+    // screen that never settles), and that ships only after the fixture bench measures it.
+    media: 'media playback state; kept as evidence, not yet adjudicated on `ui`',
+    canvas: 'a digest of canvas pixels; kept as evidence, not yet adjudicated on `ui`',
 };
 /**
  * The capabilities that change the world, and therefore need an attribution window.
@@ -193,6 +201,7 @@ const REPORTED_AS_COVERAGE = new Set([
  */
 const PROTOCOL_ANOMALY = {
     [ContradictionKind.UI_ADVANCED_REQUEST_FAILED]: AnomalyKind.ADVANCED_OVER_FAILURE,
+    [ContradictionKind.UI_ADVANCED_UNSIGNALLED]: AnomalyKind.ADVANCED_OVER_FAILURE,
     [ContradictionKind.SIGNAL_CONTRADICTED]: AnomalyKind.CLAIMED_OVER_FAILURE,
     [ContradictionKind.RESPONSE_IGNORED]: AnomalyKind.EFFECT_DISCARDED,
     [ContradictionKind.SIGNAL_WITHOUT_CONSEQUENCE]: AnomalyKind.CLAIM_UNCORROBORATED,
@@ -260,8 +269,9 @@ export class WebRealm extends Realm {
         super();
         this.#deps = deps;
         const breaker = deps.mutations;
-        if (breaker !== undefined)
+        if (breaker !== undefined) {
             this.mutate = (mutation) => breaker.mutate(mutation);
+        }
         const port = deps.fixtures;
         if (port !== undefined) {
             this.captureFixture = async () => ({
@@ -348,8 +358,9 @@ export class WebRealm extends Realm {
         // rule `HandshakeFacts` states for every field it carries. Such a page gets the full list,
         // which is the behaviour it had before anyone could ask.
         const served = this.#deps.session.commands;
-        if (served === undefined)
+        if (served === undefined) {
             return PAGE_CAPABILITIES;
+        }
         const offered = new Set(served);
         return PAGE_CAPABILITIES.filter((c) => offered.has(c.name));
     }
@@ -426,8 +437,9 @@ export class WebRealm extends Realm {
             const channel = CHANNEL_OF_PREFIX[String(event.type).split('.')[0] ?? ''];
             // Unrecognised prefix: reported on no channel rather than guessed onto one. An observation
             // attributed to a source that did not produce it is worse than an observation nobody has.
-            if (channel === undefined)
+            if (channel === undefined) {
                 continue;
+            }
             out.push({
                 id: `${window.id}-${String(index)}`,
                 window: window.id,
@@ -528,7 +540,11 @@ export class WebRealm extends Realm {
      */
     #effectElsewhere(window) {
         const events = this.#deps.session.eventsSince(window.openedAt);
-        return findContradictions(events, { actionSince: window.openedAt })
+        return findContradictions(events, {
+            actionSince: window.openedAt,
+            appOrigin: this.#deps.session.url,
+            background: this.#deps.session.background,
+        })
             .filter((c) => ContradictionKind.CONSEQUENCE_ELSEWHERE === c.kind)
             .map((c) => ({
             kind: BlindSpotKind.EFFECT_ELSEWHERE,
@@ -549,12 +565,15 @@ export class WebRealm extends Realm {
         const opened = new Map();
         for (const event of this.#deps.session.eventsSince(window.openedAt)) {
             const id = readRequestId(event.data);
-            if (id === undefined)
+            if (id === undefined) {
                 continue;
-            if (event.type === EventType.NET_PENDING)
+            }
+            if (event.type === EventType.NET_PENDING) {
                 opened.set(id, readUrl(event.data) ?? id);
-            else if (event.type === EventType.NET_REQUEST)
+            }
+            else if (event.type === EventType.NET_REQUEST) {
                 opened.delete(id);
+            }
         }
         return [...opened.values()].map((where) => ({
             kind: BlindSpotKind.STILL_IN_FLIGHT,
@@ -589,7 +608,11 @@ export class WebRealm extends Realm {
         // finding relative to ONE action. Passing `{}` left that rule switched off, and a planted
         // double submit came back proved. In this protocol the window IS the action's extent, so
         // its opening moment is exactly the boundary those rules are asking for.
-        const found = findContradictions(events, { actionSince: window.openedAt }).filter((c) => !REPORTED_AS_COVERAGE.has(c.kind));
+        const found = findContradictions(events, {
+            actionSince: window.openedAt,
+            appOrigin: this.#deps.session.url,
+            background: this.#deps.session.background,
+        }).filter((c) => !REPORTED_AS_COVERAGE.has(c.kind));
         // Synchronous underneath: the rules read a buffer that is already in memory. The interface
         // is async for a realm that has to go and ask.
         return Promise.resolve(found.map((contradiction) => {
@@ -622,18 +645,22 @@ export class WebRealm extends Realm {
     async locate(query) {
         const args = 'object' === typeof query && null !== query ? { ...query } : {};
         const result = await this.#deps.session.command(ReticleCommand.QUERY, args);
-        if (true !== result.ok)
+        if (true !== result.ok) {
             return [];
+        }
         const elements = result.result?.elements;
-        if (!Array.isArray(elements))
+        if (!Array.isArray(elements)) {
             return [];
+        }
         const found = [];
         for (const element of elements) {
-            if ('object' !== typeof element || null === element)
+            if ('object' !== typeof element || null === element) {
                 continue;
+            }
             const ref = element.ref;
-            if ('string' !== typeof ref)
+            if ('string' !== typeof ref) {
                 continue;
+            }
             const name = element.name;
             const text = element.text;
             found.push({

package/dist/portal/session/control-envelope.d.ts

@@ -30,7 +30,7 @@ interface PausedResult {
  * human's message entirely (not merely hides it). Declared here beside PausedResult so the schema and
  * the runtime shape are the same source; spread into each act tool's outputSchema.
  */
-export declare const pausedOutputShape: z.ZodRawShape;
+export declare const pausedOutputShape: Record<string, z.ZodType>;
 /** The optional `control` key `withControl` may add — keeps callers' return types honest. */
 type ControlSpread = {
     control?: ControlEnvelope;

package/dist/portal/session/dev-server/served-document.d.ts

@@ -1,8 +1,3 @@
-/**
- * The document a local dev server actually serves: its CSP header and HTML, read once and failing
- * soft. Shared by `doctor` (is a policy blocking the bridge?) and a lease that never dialled (was
- * it the page's own policy?), which is why it lives beside the dev-server probe and not in either.
- */
 /** What a served page said about its policy. The same shape `diagnoseObservedWebCsp` reads. */
 export interface ObservedWebDocument {
     url: string;

package/dist/portal/session/dev-server/served-document.js

@@ -1,3 +1,9 @@
+/**
+ * The document a local dev server actually serves: its CSP header and HTML, read once and failing
+ * soft. Shared by `doctor` (is a policy blocking the bridge?) and a lease that never dialled (was
+ * it the page's own policy?), which is why it lives beside the dev-server probe and not in either.
+ */
+import { originOf } from '@reticlehq/core';
 const CSP_HEADER = 'content-security-policy';
 const DOCUMENT_TIMEOUT_MS = 1_000;
 const LOOPBACK_HOSTS = ['localhost', '127.0.0.1', '[::1]'];
@@ -13,14 +19,6 @@ function loopbackDocumentUrl(raw) {
         return undefined;
     }
 }
-function originOf(raw) {
-    try {
-        return new URL(raw).origin;
-    }
-    catch {
-        return undefined;
-    }
-}
 /** A connected tab for this project, or on its observed origin, disproves a CSP diagnosis. */
 export function hasConnectedDocument(sessions, documentUrls, projectId) {
     if (projectId !== undefined && sessions.some((session) => session.projectId === projectId)) {

package/dist/portal/session/facts/handshake-facts.d.ts

@@ -1,4 +1,4 @@
-import type { ChannelId } from '@reticlehq/core';
+import type { ChannelId, HelloInstrumentation } from '@reticlehq/core';
 /**
  * What the page told us about itself when it connected.
  *
@@ -46,6 +46,13 @@ export interface HandshakeFacts {
      * `false` separates "the project turned it off" from "nothing provides one".
      */
     sourceMapping?: boolean | undefined;
+    /**
+     * Who put the SDK in this page, when it said: `injected` by a hosted verifier, or `installed` by
+     * the app. Undefined means installed, as every SDK before the field was.
+     *
+     * Read by the session listing, so a URL-only check never looks like an app with the SDK installed.
+     */
+    instrumentation?: HelloInstrumentation | undefined;
     /**
      * Extra key names this app declared sensitive via `connect({ redact: { keys } })`.
      *

package/dist/portal/session/first-run-wiring.d.ts

@@ -1,42 +1,9 @@
-export interface WiredStep {
-    mark: string;
-    title: string;
-    target: string;
-}
-export interface WireOutcome {
-    ok: boolean;
-    /** Where init ran. */
-    directory: string;
-    /** Every step of init's plan, applied or not, as it printed them. */
-    steps: WiredStep[];
-    /** The app's url, when init got as far as the dev server. */
-    url?: string;
-    /** Why it stopped, in init's words or ours. */
-    error?: string;
-}
-export interface RunResult {
-    code: number;
-    stdout: string;
-    stderr: string;
-}
-export type RunCli = (args: readonly string[], cwd: string) => Promise<RunResult>;
 export interface FirstRunWiring {
     /**
-     * The directory init would run in, or undefined when it cannot be told without guessing: a
-     * daemon started in the home directory or at a filesystem root has no project of its own.
+     * The unwired web app at `cwd`, or undefined when it cannot be told without guessing: a daemon
+     * started in the home directory or at a filesystem root has no project of its own.
      */
     projectDirectory(cwd: string): string | undefined;
-    wire(directory: string): Promise<WireOutcome>;
 }
 export declare function projectDirectoryOf(cwd: string, home?: string, wired?: (dir: string) => boolean): string | undefined;
-/** init's plan lines, and the one JSON object it prints last under `--json`. */
-export declare function readInitOutput(stdout: string): {
-    steps: WiredStep[];
-    result: unknown;
-};
-export declare function firstRunWiring(options: {
-    /** This daemon's port, so init wires the app to it rather than choosing another. */
-    port: number;
-    cliPath: string;
-    run?: RunCli;
-}): FirstRunWiring;
+export declare function firstRunWiring(): FirstRunWiring;

package/dist/portal/session/first-run-wiring.js

@@ -1,36 +1,25 @@
 /**
- * Wiring the app the first time an agent needs it, instead of at installation.
+ * Which unwired web app a caller is in.
  *
- * Installing Reticle puts a CLI and an MCP server on the machine and touches no project. The app is
- * instrumented the first time an agent actually uses Reticle against it: the daemon runs its own
- * CLI's `init` in the project directory, the same codemod, dev-server start and connect a person
- * would have run by hand, and reports what it changed.
- *
- * A child process rather than an import: the daemon never imports `@reticlehq/init`
- * (library-path-boundary.test.ts), and running the CLI keeps that line where it is.
- *
- * Once per directory for the life of the daemon. A second call returns the first answer, so an agent
- * that asks again after a failure is told the same thing rather than re-running a codemod on files
- * the first run already changed.
+ * Installing Reticle puts a CLI and an MCP server on the machine and touches no project. The
+ * daemon never wires a project by itself: `init` changes the user's files, so it runs only when
+ * the user agrees (the agent runs the command, or the user does). The daemon only finds the
+ * unwired app, so that the first session call can offer the zero-install lease and the consent
+ * question for it.
  */
-import { spawn } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { isWebApp } from '@reticlehq/init';
 import { readProjectId } from '../../command/cli/ports/resolve/cli-port.js';
-/** init has a dev server to start and a page to wait for; past this it is not coming. */
-const WIRE_TIMEOUT_MS = 120_000;
-/** A plan line as init prints it: `[✓] Vite plugin → vite.config.ts`. */
-const PLAN_LINE = /^\s*\[(.)\]\s+(.+?)\s+→\s+(.+)$/;
 export function projectDirectoryOf(cwd, home = homedir(), wired = (dir) => readProjectId(dir) !== undefined) {
     const dir = resolve(cwd);
     if (dir === resolve(home) || dir === resolve('/'))
         return undefined;
-    // Already wired: nothing for a first run to do, and init over a wired app proves nothing.
+    // Already wired: there is no step to offer.
     if (wired(dir))
         return undefined;
-    // Only an app with a page: a daemon started in a library or API package wrote a config there.
+    // Only an app with a page: a library or an API package has nothing to lease or to wire.
     return isWebApp('.', {
         exists: (p) => existsSync(join(dir, p)),
         readFile: (p) => {
@@ -45,88 +34,6 @@ export function projectDirectoryOf(cwd, home = homedir(), wired = (dir) => readP
         ? dir
         : undefined;
 }
-/** init's plan lines, and the one JSON object it prints last under `--json`. */
-export function readInitOutput(stdout) {
-    const steps = stdout
-        .split('\n')
-        .map((line) => PLAN_LINE.exec(line))
-        .flatMap((m) => null === m
-        ? []
-        : [{ mark: m[1] ?? '', title: (m[2] ?? '').trim(), target: (m[3] ?? '').trim() }]);
-    const at = stdout.lastIndexOf('\n{\n') + 1;
-    let result;
-    try {
-        result = JSON.parse(stdout.slice(at));
-    }
-    catch {
-        result = undefined;
-    }
-    return { steps, result };
-}
-function nodeRun(cliPath) {
-    return (args, cwd) => new Promise((done) => {
-        const child = spawn(process.execPath, [cliPath, ...args], {
-            cwd,
-            stdio: ['ignore', 'pipe', 'pipe'],
-            env: process.env,
-        });
-        let stdout = '';
-        let stderr = '';
-        child.stdout.on('data', (chunk) => (stdout += chunk.toString('utf8')));
-        child.stderr.on('data', (chunk) => (stderr += chunk.toString('utf8')));
-        const timer = setTimeout(() => child.kill(), WIRE_TIMEOUT_MS);
-        child.on('error', (error) => {
-            clearTimeout(timer);
-            done({ code: 1, stdout, stderr: `${stderr}${error.message}` });
-        });
-        child.on('close', (code) => {
-            clearTimeout(timer);
-            done({ code: code ?? 1, stdout, stderr });
-        });
-    });
-}
-export function firstRunWiring(options) {
-    const run = options.run ?? nodeRun(options.cliPath);
-    const done = new Map();
-    return {
-        projectDirectory: (cwd) => projectDirectoryOf(cwd),
-        wire(directory) {
-            const held = done.get(directory);
-            if (held !== undefined)
-                return held;
-            const outcome = run(['init', '--no-mcp', '--json', '--port', String(options.port)], directory)
-                .then(({ code, stdout, stderr }) => {
-                // Under --json the plan lines may go to stderr, keeping stdout for the one object.
-                const { result } = readInitOutput(stdout);
-                const { steps } = readInitOutput(`${stdout}\n${stderr}`);
-                const record = 'object' === typeof result && null !== result
-                    ? result
-                    : {};
-                const url = 'string' === typeof record['url'] ? record['url'] : undefined;
-                const ok = 0 === code && true === record['ok'];
-                const lastError = stderr.trim().split('\n').at(-1);
-                return {
-                    ok,
-                    directory,
-                    steps,
-                    ...(url === undefined ? {} : { url }),
-                    ...(ok
-                        ? {}
-                        : {
-                            error: lastError !== undefined && 0 < lastError.length
-                                ? lastError
-                                : `init exited ${String(code)}`,
-                        }),
-                };
-            })
-                .catch((error) => ({
-                ok: false,
-                directory,
-                steps: [],
-                error: error instanceof Error ? error.message : String(error),
-            }));
-            done.set(directory, outcome);
-            return outcome;
-        },
-    };
+export function firstRunWiring() {
+    return { projectDirectory: (cwd) => projectDirectoryOf(cwd) };
 }

package/dist/portal/session/live-control-tools.js

@@ -14,6 +14,20 @@ async function settledJournal(session) {
     await session.flushJournal?.();
     return session.readJournalActions();
 }
+/**
+ * Did the caller name a session that has DEPARTED?
+ *
+ * `resolve` answers a departed id with its live SUCCESSOR. That is right for everything that
+ * observes -- a tab reloads, its id survives in sessionStorage, and an `assert` should keep
+ * working -- and wrong for a call that changes a session's state: it acts on a tab the caller never
+ * named (#983, #1774). An id the daemon has never seen is not departed; it falls through to
+ * `resolve`, which refuses it with the live ids named.
+ */
+function namedSessionDeparted(sessions, requested) {
+    return (requested !== undefined &&
+        sessions.get(requested) === undefined &&
+        sessions.departed(requested) !== undefined);
+}
 /**
  * The session an id-less yield hands back.
  *
@@ -70,6 +84,20 @@ function endingTurnWithNothingAttached(deps, id) {
 const DISCONNECT_NEEDS_SESSION_ID = '`disconnect: true` needs the `sessionId` of the page to detach — list them with ' +
     'reticle_session{action:"list"}; it is never picked for you, because detaching the wrong window ' +
     'cuts you off from the app.';
+/** A resume on a named session that has departed: there is no pause left to clear (#1774). */
+function resumeDepartedNote(requested) {
+    return (`session '${requested}' had already disconnected, so there was no pause to clear. ` +
+        'Nothing else was resumed: a named session is matched exactly, never substituted.');
+}
+/**
+ * A review on a named session that has departed. Marks belong to one tab, so a listing from another
+ * tab answers a question the caller did not ask.
+ */
+function reviewDepartedError(requested) {
+    return (`session '${requested}' had already disconnected, so its marks are gone. ` +
+        'No other session was read: a named session is matched exactly, never substituted. ' +
+        'List the live sessions with reticle_session{action:"list"}.');
+}
 /** The agent's claim, when it is one of the words a run verdict uses. */
 function claimOf(value) {
     const claims = [
@@ -89,7 +117,7 @@ export const LIVE_CONTROL_TOOLS = [
             'until the daemon restarts — for a stray window (a hidden desktop webview, a 404 page) that keeps coming back. ' +
             'Ending a tab you leased also releases that lease (`leaseReleased: true`).',
         inputSchema: {
-            summary: z.string().optional(),
+            summary: z.string().optional().describe('One sentence: what this session proved.'),
             claim: z
                 .enum([VerdictStatus.PASS, VerdictStatus.FAIL, VerdictStatus.PARTIAL])
                 .optional()
@@ -133,23 +161,14 @@ export const LIVE_CONTROL_TOOLS = [
                 return Promise.resolve({ ended: true, note: YIELD_WITHOUT_SESSION_NOTE });
             }
             // A NAMED session that has DEPARTED is already ended, and nothing else may be ended in its
-            // place.
-            //
-            // `resolve` answers a departed id with its live SUCCESSOR. That is right for everything
-            // that observes -- a tab reloads, its id survives in sessionStorage, and an `assert` should
-            // keep working -- and wrong here, because ending a session is destructive and cannot be
-            // taken back. Reported from the field: `sessionId: "sac14d46c…"` returned `ended: true` for
-            // `"s08e37e5c…"`, once where the requested session's browser had just closed, so the
-            // behaviour was "target missing => end something else" rather than "target missing => say
-            // so" (#983).
+            // place. Ending a session is destructive and cannot be taken back. Reported from the field:
+            // `sessionId: "sac14d46c…"` returned `ended: true` for `"s08e37e5c…"`, once where the
+            // requested session's browser had just closed, so the behaviour was "target missing => end
+            // something else" rather than "target missing => say so" (#983).
             //
             // Not an error, either: this tool is documented as idempotent, and "the session you named is
-            // already gone" is precisely the idempotent answer. An id the daemon has never seen IS a
-            // mistake about which tab, and falls through to `resolve`, which refuses it with the live
-            // ids named.
-            if (requested !== undefined &&
-                deps.sessions.get(requested) === undefined &&
-                deps.sessions.departed(requested) !== undefined) {
+            // already gone" is precisely the idempotent answer.
+            if (namedSessionDeparted(deps.sessions, requested)) {
                 return Promise.resolve({
                     ended: true,
                     sessionId: requested,
@@ -231,6 +250,17 @@ export const LIVE_CONTROL_TOOLS = [
                     note: YIELD_WITHOUT_SESSION_NOTE,
                 });
             }
+            // A NAMED session that has DEPARTED has nothing to hand back, and no other tab may be marked
+            // as waiting in its place (#1774). The same idempotent answer `end` gives.
+            if (namedSessionDeparted(deps.sessions, requested)) {
+                return Promise.resolve({
+                    yielded: true,
+                    mode: ask ? PresenterTone.ASK : PresenterTone.WAITING,
+                    sessionId: requested,
+                    note: `session '${String(requested)}' had already disconnected, so there was nothing to yield. ` +
+                        'Nothing else was yielded: a named session is matched exactly, never substituted.',
+                });
+            }
             const session = resolveYieldTarget(deps.sessions, requested);
             const note = asString(args['note']);
             const tone = ask ? PresenterTone.ASK : PresenterTone.WAITING;
@@ -253,9 +283,15 @@ export const LIVE_CONTROL_TOOLS = [
         description: 'Clear a human pause and resume driving the page. Sets state "active" and syncs the panel ' +
             '(PRESENTER). Call after you have addressed the human guidance returned by a paused reticle_act.',
         inputSchema: { ...sessionIdShape },
-        outputSchema: { ok: z.boolean() },
+        outputSchema: { ok: z.boolean(), note: z.string().optional() },
         handler: (deps, args) => {
-            const session = deps.sessions.resolve(asString(args['sessionId']));
+            const requested = asString(args['sessionId']);
+            // A NAMED session that has DEPARTED has no pause to clear. Resuming its successor would clear a
+            // pause the human set by hand on a tab the agent never named (#1774). Idempotent, as `end` is.
+            if (namedSessionDeparted(deps.sessions, requested)) {
+                return Promise.resolve({ ok: true, note: resumeDepartedNote(String(requested)) });
+            }
+            const session = deps.sessions.resolve(requested);
             // setState echoes ACTIVE to the panel in a single PRESENTER push.
             session.setState(SessionState.ACTIVE);
             return Promise.resolve({ ok: true });
@@ -334,7 +370,13 @@ export const LIVE_CONTROL_TOOLS = [
                 .describe('The note on the mark that was actually retired. CHECK IT against the mark you meant to resolve: a bare `resolved:true` cannot tell you it closed the right one, and ids are only meaningful while the session that issued them lives.'),
         },
         handler: (deps, args) => {
-            const session = deps.sessions.resolve(asString(args['sessionId']));
+            const requested = asString(args['sessionId']);
+            // A NAMED session that has DEPARTED is refused, not substituted: a listing or a `resolve` on its
+            // successor reads or retires marks on a tab the caller never named (#1774).
+            if (namedSessionDeparted(deps.sessions, requested)) {
+                throw new Error(reviewDepartedError(String(requested)));
+            }
+            const session = deps.sessions.resolve(requested);
             const resolveId = asString(args['resolve']);
             let resolved;
             let resolvedNote;

package/dist/portal/session/no-session-next-action.d.ts

@@ -28,6 +28,8 @@ interface NextActionFacts {
     everConnected: boolean;
     initialized: boolean;
     listening: readonly number[];
+    /** Scanned ports that serve a page from a process that cannot be tied to this project. */
+    otherListeners?: readonly number[];
     dev: DevCommand | undefined;
     /**
      * File-existence predicate for the project root, pure for testing.
@@ -114,6 +116,15 @@ export declare function departedPortGone(facts: {
     listening: readonly number[];
     slowListeners?: readonly number[];
 }): boolean;
+export declare const INIT_COMMAND = "npx @reticlehq/server init";
+/**
+ * The consent question for wiring, in one wording for every place that offers `init`: the
+ * handshake, the first session call, every next action and the plugin hook. `init` changes the user's files, so the
+ * agent asks first. The lease changes nothing, so it needs no question.
+ */
+export declare function wiringConsent(init?: string): string;
+/** The zero-install call, with the URL only when it can be named without guessing. */
+export declare function zeroInstallLease(url: string | undefined): string;
 export declare function nextActionFor(facts: NextActionFacts): NoSessionNextAction;
 /** The same action as one sentence, for the prose message the human reads. */
 export declare function renderNextAction(next: NoSessionNextAction): string;