@reticlehq/server 3.1.0 → 3.2.0

package/dist/status-payload.js

@@ -2,7 +2,9 @@ import { CONTRACT_FINGERPRINT } from '@reticlehq/core';
 import { SERVER_VERSION } from './command/version/identity/server-version.js';
 export function statusPayload(sessionCount, sessions, 
 /** The no-session diagnosis, injected so this stays pure and the port probe stays off this path. */
-why, verifyPort) {
+why, verifyPort, 
+/** The short rendering of the same diagnosis. Absent on a daemon that has no provider wired. */
+whyLead) {
     return {
         running: true,
         version: SERVER_VERSION,
@@ -12,6 +14,7 @@ why, verifyPort) {
         // Only when there is nothing to explain away: a diagnosis printed beside a live session would
         // contradict it.
         ...(0 === sessionCount && why !== undefined ? { why } : {}),
+        ...(0 === sessionCount && whyLead !== undefined ? { whyLead } : {}),
         ...(verifyPort === undefined ? {} : { verifyPort }),
     };
 }

package/dist/surface/http-server.js

@@ -4,7 +4,6 @@ import { MCP_SSE_PATH, MCP_MESSAGE_PATH, MCP_SHUTDOWN_EVENT, STATUS_PATH, DRIVE_
 import { getSessionMetrics } from '../telemetry/session-metrics.js';
 import { noteAgentPeer, PEER_VERSION_PARAM, PEER_CONTRACT_PARAM, } from '../command/version/peer-announce.js';
 import { log } from '../log.js';
-import { reportMcpConnected } from '../telemetry/mcp-connection.js';
 import { isLoopbackHost, isLocalWebOrigin, isLoopbackPeer, requestToken, tokensMatch, } from '../portal/bridge/token-auth.js';
 import { LOOPBACK_IDLE_MS } from './loopback-agent.js';
 /**
@@ -177,10 +176,9 @@ export function createSharedServer(options = {}) {
                 .connect(transport)
                 .then(() => {
                 log('mcp_client_connected', { sessionId: sid });
-                // The one signal that separates "Reticle is running" from "somebody is USING it": a daemon
-                // can sit up for days with nothing attached. It also exposes reconnect churn, which is
-                // indistinguishable from healthy usage in every other metric.
-                reportMcpConnected();
+                // The telemetry for this moved to `oninitialized`, where the client has said its name.
+                // An SSE stream that opens here and never handshakes is a probe, not a client, and
+                // reporting it from this point produced a row that could never name who attached.
             })
                 .catch((err) => {
                 const message = err instanceof Error ? err.message : String(err);

package/dist/surface/mcp/faults/mcp-outage.d.ts

@@ -6,7 +6,8 @@
  * often does a real user's MCP server go down, and does it come back — had no answer outside the
  * machine it happened on.
  *
- * Capped at two events per proxy process, and the cap is the design rather than a limitation. One
+ * Capped at one benign and one fault event PER STAGE per proxy process, and the cap is the design
+ * rather than a limitation. One
  * measured afternoon produced 547 proxy reconnects; an event per reconnect would bill for the
  * pathology instead of measuring it, which is the same mistake the per-call `tool` event made before
  * it was removed. What a dashboard needs is the SHARE OF SESSIONS that lose MCP at all (the first

package/dist/surface/mcp/faults/mcp-outage.js

@@ -6,7 +6,8 @@
  * often does a real user's MCP server go down, and does it come back — had no answer outside the
  * machine it happened on.
  *
- * Capped at two events per proxy process, and the cap is the design rather than a limitation. One
+ * Capped at one benign and one fault event PER STAGE per proxy process, and the cap is the design
+ * rather than a limitation. One
  * measured afternoon produced 547 proxy reconnects; an event per reconnect would bill for the
  * pathology instead of measuring it, which is the same mistake the per-call `tool` event made before
  * it was removed. What a dashboard needs is the SHARE OF SESSIONS that lose MCP at all (the first
@@ -28,6 +29,19 @@ const KNOWN_REASONS = new Set(Object.values(OutageReason));
 function outageReason(raw) {
     return KNOWN_REASONS.has(raw) ? raw : OutageReason.OTHER;
 }
+/**
+ * The daemon retiring on schedule is not a fault, and it is by far the commonest drop.
+ *
+ * Kept as the CLASS rather than the reason itself, because the cap is keyed on it: one benign drop
+ * and one fault per stage, not one event per reason. Keying on the reason would put the volume the
+ * cap exists to prevent straight back — a flapping proxy has several reasons available to it and
+ * would bill for each of them — while keying on the stage alone is what let a scheduled shutdown at
+ * minute one permanently suppress a real outage at minute forty, biasing the metric toward exactly
+ * the rows `daemon_shutdown` was introduced to exclude.
+ */
+function isBenign(reason) {
+    return OutageReason.DAEMON_SHUTDOWN === reason;
+}
 const reported = new Set();
 /** Reset between tests; a real process reports each stage at most once. */
 export function resetOutageReporting() {
@@ -39,13 +53,15 @@ export function resetOutageReporting() {
  * fails — the reconnect it is describing.
  */
 export function reportMcpOutage(stage, facts) {
-    if (reported.has(stage))
+    const reason = outageReason(facts.reason);
+    const slot = `${stage}:${isBenign(reason) ? 'benign' : 'fault'}`;
+    if (reported.has(slot))
         return;
-    reported.add(stage);
+    reported.add(slot);
     void getTelemetry().emit(TelemetryEventKind.MCP_CONNECTION_LOST, {
         outage: {
             stage,
-            reason: outageReason(facts.reason),
+            reason,
             attempts: facts.attempts,
             // Always sent, including zero: zero is the finding — a drop no agent could feel. See
             // McpOutageSchema.pendingLost.

package/dist/surface/mcp/mcp-proxy.d.ts

@@ -107,4 +107,13 @@ export declare function startMcpProxy(port: number,
  */
 ensureDaemon?: () => Promise<void>, 
 /** Observe the real shutdown boundary in transport tests without terminating their worker. */
-exitProcess?: (code: number) => void): Promise<never>;
+exitProcess?: (code: number) => void, 
+/**
+ * Tell the resilience layer this session proved itself usable.
+ *
+ * The same `endpoint` frame that earns a fresh retry budget below also clears the disconnect-storm
+ * counter, and for the same reason: response headers are produced by a daemon that accepts SSE and
+ * drops it, and an `endpoint` frame is not. Optional, because a transport test drives this
+ * function with no resilience installed.
+ */
+onUsableSession?: () => void): Promise<never>;

package/dist/surface/mcp/mcp-proxy.js

@@ -22,7 +22,7 @@ import { flushProxySessionMetrics } from '../../telemetry/proxy-telemetry.js';
  * the whole defect this import closes was the proxy answering a DIFFERENT question from every other
  * surface, and a second copy of the probe is how that comes back.
  */
-import { fetchStatus as fetchDaemonStatus } from '../../command/cli/launch/cli-launch.js';
+import { fetchStatus as fetchDaemonStatus } from '../../command/daemon/binding/daemon-status-probe.js';
 /**
  * Re-exported so every existing caller (and every spec) keeps importing the proxy's log from the
  * proxy. Where the code lives is a file-size decision; where it is imported from is an API.
@@ -304,7 +304,16 @@ export function startMcpProxy(port,
  */
 ensureDaemon, 
 /** Observe the real shutdown boundary in transport tests without terminating their worker. */
-exitProcess = (code) => process.exit(code)) {
+exitProcess = (code) => process.exit(code), 
+/**
+ * Tell the resilience layer this session proved itself usable.
+ *
+ * The same `endpoint` frame that earns a fresh retry budget below also clears the disconnect-storm
+ * counter, and for the same reason: response headers are produced by a daemon that accepts SSE and
+ * drops it, and an `endpoint` frame is not. Optional, because a transport test drives this
+ * function with no resilience installed.
+ */
+onUsableSession = () => undefined) {
     return new Promise((_resolve, reject) => {
         // A client just started us, which is the only honest evidence that Reticle is registered with
         // one at all: a config entry proves somebody wrote JSON, not that a client ever read it. Paired
@@ -452,13 +461,11 @@ exitProcess = (code) => process.exit(code)) {
                 const msg = parseJsonRpc(line);
                 if (null === msg || msg.id === undefined || !pending.take(msg.id))
                     return;
-                if (failure.transport) {
-                    reportMcpOutage(OutageStage.FIRST, {
-                        reason: OutageReason.CONNECT_ERROR,
-                        attempts: failure.attempts,
-                        pendingLost: 1,
-                    });
-                }
+                // No outage is reported here, deliberately. A POST leg that died while the SSE stream is
+                // still up is not the agent losing its tools: `postSocketFailures` on the session summary
+                // already counts it, and reporting it as a lost stream both double-counted and — because
+                // the outage cap is per process — let a transient POST failure in the first minute suppress
+                // the real stream outage in the fortieth.
                 proxyLog('reticle_mcp_proxy_post_unanswered', {
                     port,
                     method: String(msg.method),
@@ -490,6 +497,10 @@ exitProcess = (code) => process.exit(code)) {
                     reportMcpOutage(OutageStage.RECOVERED, { reason: lastDropReason, attempts: cost });
                 attempts = 0;
                 attemptsBeforeDormant = 0;
+                // The disconnects behind us were reconnects, not a runaway. Counting them for the life of
+                // the process made twenty daemon restarts over a working week indistinguishable from twenty
+                // in eight seconds, and the proxy left on the former.
+                onUsableSession();
                 // The new session's McpServer has never seen the client's initialize — replay it first, then
                 // flush whatever the client sent while we were reconnecting.
                 for (const line of replay.replayLines())

package/dist/surface/mcp/mcp.d.ts

@@ -12,7 +12,16 @@ export declare const CALL_TOOL_METHOD = "tools/call";
  * Non-session-bound tools (and tools with no outputSchema) are returned unchanged.
  */
 export declare function withSessionEnvelope(name: string, outputSchema: z.ZodRawShape | undefined): z.ZodRawShape | undefined;
-export declare function firstSentence(description: string): string;
+/**
+ * Abbreviations whose internal period is NOT a sentence end.
+ *
+ * The splitter looked for the first `". "`, which "e.g. " satisfies — so every lean-profile
+ * description containing one was cut off mid-abbreviation. `reticle_act`'s ref parameter reached the
+ * agent as "Element ref from reticle_snapshot or reticle_query (e.g." and stopped: the example gone,
+ * and any contract stated after it gone too. Silent, and it degraded the DEFAULT profile only, which
+ * is the one nobody reads the raw strings for.
+ */
+export { firstSentence } from '../tools/first-sentence.js';
 /**
  * Serialize a tool result to the MCP `text` content block. The agent consumes this text — the
  * typed contract travels separately as `structuredContent`, unchanged by encoding — so the text

package/dist/surface/mcp/mcp.js

@@ -36,6 +36,7 @@ import { log } from '../../log.js';
 import { SERVER_VERSION } from '../../command/version/identity/server-version.js';
 import { setMcpClientNameHook } from '../../telemetry/feedback-context.js';
 import { getSessionMetrics } from '../../telemetry/session-metrics.js';
+import { reportMcpConnected } from '../../telemetry/mcp-connection.js';
 import { parsePredicate } from '@reticlehq/engine/question/predicate/predicate-parse.js';
 /**
  * Merge the runtime-spliced envelope (health/lease/age/control) into a session-bound tool's declared
@@ -70,16 +71,9 @@ function withExample(description, example) {
  * and any contract stated after it gone too. Silent, and it degraded the DEFAULT profile only, which
  * is the one nobody reads the raw strings for.
  */
-const ABBREVIATIONS = ['e.g.', 'i.e.', 'etc.', 'vs.', 'cf.'];
-export function firstSentence(description) {
-    const nl = description.indexOf('\n');
-    const base = nl >= 0 ? description.slice(0, nl) : description;
-    // Mask abbreviations with an equal-length filler so offsets stay valid in the original string.
-    const masked = ABBREVIATIONS.reduce((text, abbr) => text.split(abbr).join('\u0000'.repeat(abbr.length)), base);
-    const dot = masked.search(/\.\s/);
-    const sentence = dot >= 0 ? base.slice(0, dot + 1) : base;
-    return sentence.length > 160 ? `${sentence.slice(0, 159)}…` : sentence;
-}
+// Re-exported because callers (and `mcp.test.ts`) have imported it from here since it lived here.
+export { firstSentence } from '../tools/first-sentence.js';
+import { firstSentence } from '../tools/first-sentence.js';
 /**
  * Parameters carrying the recursive predicate grammar. Advertised compactly in lean profiles.
  *
@@ -124,8 +118,8 @@ const PREDICATE_KINDS = 'Predicate object: { kind, ...fields }. kind is one of e
  * paying for six.
  */
 const PREDICATE_FIELD_GRAMMAR_HINT = ' Bug-catching options: net.count (exact request count — catches double-submit), ' +
-    'net.bodyContains (a substring of what the SERVER answered — catches a UI that echoes the input ' +
-    'it sent instead of the result it got back), net.requestBodyMatches (a shallow JSON match on what ' +
+    'net.bodyMatches (a shallow JSON match on what the SERVER answered — say the FIELD and its value, ' +
+    'because a substring of the body matches key names too), net.requestBodyMatches (the same on what ' +
     'the UI SENT — the verdict for "applying this filter actually puts it in the payload"), ' +
     'console.absent:true (action completed with a CLEAN ' +
     'console), absent:true on element/text (it should be gone). Call reticle_tools for the full field ' +
@@ -218,21 +212,33 @@ tools = tableForSurface(surface)) {
     const shipped = new Set(tableForSurface(surface).map((tool) => tool.name));
     const ours = tools.filter((tool) => shipped.has(tool.name));
     const theirs = tools.filter((tool) => !shipped.has(tool.name));
-    // The `merged` surface keeps `reticle_tools` and drops `reticle_run`, which is not symmetry for
-    // its own sake. `reticle_run` exists to DISPATCH to a tool the surface does not advertise, and
-    // this surface advertises everything, so it has no job left. `reticle_tools` has a second job that
-    // survives: every input schema on a trimmed surface is LEAN, and `{ names: [...] }` is the only
-    // way to get a tool's full parameters — which matters more here than anywhere, because a merged
-    // tool's schema is the union of its members' fields with all of them optional. Recovery messages
-    // across this server also say "Call reticle_tools", and a surface without it turns that advice
-    // into a dead end (see surface-sizes.test.ts).
-    // A surface with no `reticle_run` can invoke only what it advertises, so the catalogue is told to
-    // list exactly that. Anything else is a menu of names the agent cannot order from.
+    /*
+     * `merged` used to drop `reticle_run`, on the reasoning that the hatch "exists to DISPATCH to a
+     * tool the surface does not advertise, and this surface advertises everything, so it has no job
+     * left".
+     *
+     * THE PREMISE WAS FALSE, and it had been false for some time. `MERGED_TOOL_NAMES` is
+     * `CORE_TOOL_NAMES` minus the merged-away names plus `LOOK`; `EXTENDED_TOOL_NAMES` — screenshot,
+     * visual diff, clock, network mock, storage, record, the flow pair, intent, context, capabilities
+     * — is not in it. So eleven registered tools were advertised by nothing, callable by nothing, and
+     * catalogued by nothing: `reticle_tools { names: ["reticle_screenshot"] }` answered `unknown
+     * tool`, on a build where the tool exists and is registered.
+     *
+     * The extended set's own comments say each demoted tool is "still one `reticle_run` hop from any
+     * agent that wants it". That is the trade the demotion was justified by, and dropping the hatch
+     * silently cancelled the half of it we owed the caller. One of the casualties was
+     * `reticle_visual_diff`, which covers the only bug class the registry marks as one Reticle cannot
+     * otherwise see.
+     *
+     * So the hatch stays, and the catalogue lists everything the hatch can reach. `reticle_tools`
+     * keeps its second job either way: every input schema on a trimmed surface is LEAN, and
+     * `{ names: [...] }` is the only way to get full parameters — which matters most here, because a
+     * merged tool's schema is the union of its members' fields with all of them optional. Recovery
+     * messages across this server also say "Call reticle_tools", and a surface without it turns that
+     * advice into a dead end (see surface-sizes.test.ts).
+     */
     const advertisedHere = filterTools([...ours], surface);
-    const callable = surface === TOOL_SURFACE.MERGED
-        ? new Set([...advertisedHere, ...theirs].map((tool) => tool.name))
-        : undefined;
-    const meta = buildDynamicTools([...tools], origin, callable).filter((tool) => surface !== TOOL_SURFACE.MERGED || tool.name !== ReticleTool.RUN);
+    const meta = buildDynamicTools([...tools], origin, undefined);
     return [...advertisedHere, ...theirs, ...meta];
 }
 /**
@@ -512,8 +518,14 @@ tools = tableForSurface(profile)) {
      */
     server.server.oninitialized = () => {
         const info = server.server.getClientVersion();
-        if (info?.name !== undefined)
-            getSessionMetrics().recordClient(info.name, info.version);
+        if (info?.name === undefined)
+            return;
+        getSessionMetrics().recordClient(info.name, info.version);
+        // The one signal that separates "Reticle is running" from "somebody is USING it", reported from
+        // the first moment it can carry WHO. It used to fire from the SSE `connect()` resolution, which
+        // happens before the handshake — so every connect row was anonymous, and the field meant to say
+        // which agent client converts best was empty on every event ever sent.
+        reportMcpConnected(info.name);
     };
     // Which agent is on the other end, for a feedback report. Registered as a lazy hook rather than
     // read here: the handshake has not happened yet at construction time, and a report filed twenty
@@ -540,7 +552,25 @@ tools = tableForSurface(profile)) {
     const advertised = advertisedTools(profile, tools);
     // The names this surface actually hands the agent. Every piece of advice leaving this server is
     // rewritten against it, so a static string cannot route a reader to a tool they were not given.
-    const advertisedNames = new Set(advertised.map((tool) => tool.name));
+    /**
+     * What a name in advice can actually REACH, which is not the same as what is advertised.
+     *
+     * `liveCallText` rewrites mentions of tools this surface cannot reach — it exists because advice
+     * naming `reticle_flow_save` on a surface without it sent agents at a tool that answered "not
+     * reachable on this tool surface". Gated on the ADVERTISED set, it kept firing once the dispatch
+     * hatch came back: `reticle_flow_save` and `reticle_record` are reachable through
+     * `reticle_run` but not advertised, so every mention of them — INCLUDING their own names and the
+     * parameter docs that name the recording to save — was rewritten to
+     * `reticle_verify { action: "explore", persona }`. Two tools with the same wrong name, and a
+     * `flowName` description telling the reader to pass the name that a tool which is not the one
+     * they called was called with.
+     *
+     * With a hatch, every registered tool is reachable and no rewriting is owed. Without one,
+     * advertised IS reachable, which is the case this was written for.
+     */
+    const advertisedNames = advertised.some((tool) => ReticleTool.RUN === tool.name)
+        ? new Set(tools.map((tool) => tool.name))
+        : new Set(advertised.map((tool) => tool.name));
     installFriendlyArgErrors(server, new Map(advertised
         .filter((tool) => tool.example !== undefined)
         .map((tool) => [tool.name, JSON.stringify(tool.example)])), 

package/dist/surface/mcp/proxy/proxy-daemon-probe.d.ts

@@ -5,5 +5,18 @@ export declare function daemonPollDelayMs(attempt: number): number;
  * inside the daemon just to check reachability.
  */
 export declare function probeDaemon(port: number): Promise<boolean>;
-/** Poll until the daemon's HTTP port accepts connections or the deadline is reached. */
-export declare function waitForDaemon(port: number): Promise<void>;
+/**
+ * Poll until a Reticle daemon is SERVING on `port`, or the deadline passes.
+ *
+ * "Accepts a TCP connection" is not the question. A daemon wedged mid-start accepts and never
+ * serves, and so does a stranger holding the port — `port-presence.ts` calls both FOREIGN for
+ * exactly this reason, and every other decision point in the codebase was migrated onto it. This
+ * one was not, so the wake path spawned a daemon, waited on a bare connect, and dialled a corpse.
+ *
+ * Probes are injected (defaulting to the real pair) so the rule is testable without a socket, which
+ * is the same shape `probePresence`'s own callers use.
+ */
+export declare function waitForDaemon(port: number, probes?: {
+    tcpOpen: (port: number) => Promise<boolean>;
+    status: (port: number) => Promise<unknown>;
+}): Promise<void>;

package/dist/surface/mcp/proxy/proxy-daemon-probe.js

@@ -1,5 +1,7 @@
 import * as net from 'node:net';
 import { LOOPBACK_HOST } from '@reticlehq/core';
+import { describePresence, presenceIsUsable, probePresence, PortPresence, } from '../../../command/daemon/binding/port-presence.js';
+import { fetchStatus } from '../../../command/daemon/binding/daemon-status-probe.js';
 const DEFAULT_DAEMON_READY_TIMEOUT_MS = 10_000;
 /**
  * How long to wait for the spawned daemon's port to accept connections before giving up. The default
@@ -39,16 +41,31 @@ export function probeDaemon(port) {
         socket.connect(port, LOOPBACK_HOST);
     });
 }
-/** Poll until the daemon's HTTP port accepts connections or the deadline is reached. */
-export async function waitForDaemon(port) {
+/**
+ * Poll until a Reticle daemon is SERVING on `port`, or the deadline passes.
+ *
+ * "Accepts a TCP connection" is not the question. A daemon wedged mid-start accepts and never
+ * serves, and so does a stranger holding the port — `port-presence.ts` calls both FOREIGN for
+ * exactly this reason, and every other decision point in the codebase was migrated onto it. This
+ * one was not, so the wake path spawned a daemon, waited on a bare connect, and dialled a corpse.
+ *
+ * Probes are injected (defaulting to the real pair) so the rule is testable without a socket, which
+ * is the same shape `probePresence`'s own callers use.
+ */
+export async function waitForDaemon(port, probes = { tcpOpen: probeDaemon, status: fetchStatus }) {
     const deadline = Date.now() + DAEMON_READY_TIMEOUT_MS;
     let attempt = 0;
+    let presence = PortPresence.FREE;
     while (Date.now() < deadline) {
-        const reachable = await probeDaemon(port);
-        if (reachable)
+        presence = await probePresence(port, probes);
+        if (presenceIsUsable(presence))
             return;
         attempt++;
         await delay(daemonPollDelayMs(attempt));
     }
-    throw new Error(`reticle daemon did not become ready on port ${port} within ${DAEMON_READY_TIMEOUT_MS}ms`);
+    // The state we timed out in is the whole diagnosis — FREE means the daemon never came up, FOREIGN
+    // means something is squatting the port. Reporting only the timeout sent readers hunting the
+    // wrong one.
+    throw new Error(`reticle daemon did not become ready on port ${String(port)} within ` +
+        `${String(DAEMON_READY_TIMEOUT_MS)}ms — ${describePresence(presence, port)}`);
 }

package/dist/surface/mcp/proxy/proxy-log.d.ts

@@ -27,18 +27,12 @@ export declare function accountProxyLogWrite(bytesSinceCheck: number, written: n
 /**
  * Reclaim a proxy log that a previous process already let run away. Returns the bytes reclaimed.
  *
- * An uncapped proxy log has filled a disk and broken unrelated builds, Docker and ordinary shell
- * commands with ENOSPC. Nothing in Reticle degrades first, so the failure surfaces as the operating
- * system refusing to write files. Such files already exist on machines that ran an older build, and
- * the cap alone does not help them: nobody should have to find one with `du`.
+ * Path-shaped wrapper over `recoverOversizedLog`, which is where the rule, the in-place truncation
+ * and the ENOSPC incident behind them are written down. Both of Reticle's logs are capped by that
+ * one function; this keeps the name and the `fileSize`/`truncateFile` deps its callers already pass.
  *
- * TRUNCATED IN PLACE, never renamed or unlinked. A rename moves the bytes without reclaiming a byte,
- * and a file that a running process still holds open keeps its blocks allocated after an unlink
- * until that handle closes — which is why `: > ~/.reticle/proxy-4400.log` is the operation to copy
- * here.
- *
- * Best-effort, in the same spirit as `rotateDaemonLog`: refusing to start the MCP server over
- * housekeeping is strictly worse than a large file.
+ * Such files already exist on machines that ran an older build, and the cap alone does not help
+ * them: nobody should have to find one with `du`.
  */
 export declare function recoverOversizedProxyLog(path: string, deps: {
     fileSize(p: string): number;

package/dist/surface/mcp/proxy/proxy-log.js

@@ -10,7 +10,7 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { ReticleDir } from '@reticlehq/core';
 import { log } from '../../../log.js';
-import { MAX_DAEMON_LOG_BYTES, rotateDaemonLog } from '../../../command/daemon/daemon.js';
+import { MAX_DAEMON_LOG_BYTES, recoverOversizedLog, rotateDaemonLog, } from '../../../command/daemon/daemon.js';
 /**
  * Which port this proxy serves, for the log file name. Set once at startup.
  *
@@ -46,30 +46,15 @@ export function accountProxyLogWrite(bytesSinceCheck, written, path, deps) {
 /**
  * Reclaim a proxy log that a previous process already let run away. Returns the bytes reclaimed.
  *
- * An uncapped proxy log has filled a disk and broken unrelated builds, Docker and ordinary shell
- * commands with ENOSPC. Nothing in Reticle degrades first, so the failure surfaces as the operating
- * system refusing to write files. Such files already exist on machines that ran an older build, and
- * the cap alone does not help them: nobody should have to find one with `du`.
+ * Path-shaped wrapper over `recoverOversizedLog`, which is where the rule, the in-place truncation
+ * and the ENOSPC incident behind them are written down. Both of Reticle's logs are capped by that
+ * one function; this keeps the name and the `fileSize`/`truncateFile` deps its callers already pass.
  *
- * TRUNCATED IN PLACE, never renamed or unlinked. A rename moves the bytes without reclaiming a byte,
- * and a file that a running process still holds open keeps its blocks allocated after an unlink
- * until that handle closes — which is why `: > ~/.reticle/proxy-4400.log` is the operation to copy
- * here.
- *
- * Best-effort, in the same spirit as `rotateDaemonLog`: refusing to start the MCP server over
- * housekeeping is strictly worse than a large file.
+ * Such files already exist on machines that ran an older build, and the cap alone does not help
+ * them: nobody should have to find one with `du`.
  */
 export function recoverOversizedProxyLog(path, deps, max = MAX_DAEMON_LOG_BYTES) {
-    try {
-        const size = deps.fileSize(path);
-        if (max >= size)
-            return 0;
-        deps.truncateFile(path);
-        return size;
-    }
-    catch {
-        return 0;
-    }
+    return recoverOversizedLog({ size: () => deps.fileSize(path), truncate: () => deps.truncateFile(path) }, max);
 }
 /** The real filesystem behind the two rotation helpers. */
 const proxyLogFileOps = {

package/dist/surface/tools/act/act-preflight.js

@@ -14,7 +14,7 @@ import { PredicateSchema } from '@reticlehq/engine/question/predicate/predicate-
 import { isGlobalPressCall } from '@reticlehq/core';
 import { SessionReplacedError } from '../../../portal/session/page-commands/pending-commands.js';
 import { assertNativeInputSupported } from './act-danger.js';
-import { unevaluablePredicateReason } from '@reticlehq/engine/question/predicate/predicate-precheck.js';
+import { unevaluablePredicateReason, vacuousPredicateReason, } from '@reticlehq/engine/question/predicate/predicate-precheck.js';
 /**
  * Refuse a sequence whose steps cannot be addressed.
  *
@@ -137,6 +137,11 @@ export function preflightAct(actArgs, until) {
     const unevaluable = unevaluablePredicateReason(until);
     if (unevaluable !== undefined)
         throw new Error(unevaluable);
+    // A predicate that was already true when it was written answered `no-fault` / `already_true` —
+    // verdict-shaped, and carrying no proof of anything the action did. See vacuousPredicateReason.
+    const vacuous = vacuousPredicateReason(until);
+    if (vacuous !== undefined)
+        throw new Error(vacuous);
 }
 /**
  * Dispatch a write, or report that its outcome went unobserved.

package/dist/surface/tools/act/sequence-grade.js

@@ -39,6 +39,19 @@ export function gradeSequence(steps, plan = { planned: steps.length, dispatched:
             because: `a declared consequence did not hold — observed ${observed}`,
         };
     }
+    /*
+     * `unknown` rather than `no-fault`, and the distinction is load-bearing.
+     *
+     * "Nothing was declared" is what `no-fault` means for a single action -- but the engine only says
+     * it over a SETTLED window, because no-fault claims the whole window was observed. Nothing on
+     * this path observes settledness: the caller tracks dispatch and stalls, never settle. Saying
+     * `no-fault` here would claim evidence nobody collected, in the one place this product cannot
+     * afford to overclaim.
+     *
+     * So the enum stays conservative and the SENTENCE carries the whole answer: it names declaring a
+     * consequence as the next move, which is what an agent reading `no-fault` would have done.
+     * Upgrading means plumbing `settled` from the act results through `SequencePlan`.
+     */
     if (0 === declared) {
         return {
             verified: Verified.UNKNOWN,

package/dist/surface/tools/act-capsule.js

@@ -27,7 +27,12 @@ export async function saveFailedAssertCapsule(inputs) {
     // Same rule and same resolver as every other artifact: a capsule written into a sibling repo is
     // evidence filed against a codebase that did not produce it, and it outlives the turn.
     // The caller's answer wins; the resolver is the fallback for callers that have no session.
-    const root = given ?? sessionRoot(deps, asString(args['sessionId']));
+    const root = given ?? bestEffortRoot(deps, asString(args['sessionId']));
+    // No directory this capsule could honestly belong to, so it is not filed. The two things this
+    // must not do are write it somewhere arbitrary and throw: the assertion has already failed, the
+    // verdict is already built, and losing the capsule must never also lose the verdict.
+    if (root === undefined)
+        return undefined;
     const saved = await new CapsuleStore(deps.fs, root).save({
         version: CAPSULE_VERSION,
         id,
@@ -51,3 +56,24 @@ export async function saveFailedAssertCapsule(inputs) {
     });
     return saved ? id : undefined;
 }
+/**
+ * Where this capsule goes, or nothing — never a throw and never somebody else's checkout.
+ *
+ * `sessionRoot` refuses a `sessionId` that names no session, because for a tool the agent CALLED
+ * the alternative is silently writing into the daemon's own project. Here the caller is not a tool
+ * the agent called: it is the evidence capture hanging off a verdict that has already been decided,
+ * and on this path a refusal would convert a red assertion into a tool error. Both of the answers
+ * that refusal exists to prevent are still prevented — nothing is written, and nothing is written
+ * to the wrong root — by declining to file the capsule at all.
+ *
+ * Reachable only when the act's own session AND its navigation successor are gone by the time the
+ * verdict lands, since `act_and_wait` passes the root of the session it actually drove.
+ */
+function bestEffortRoot(deps, sessionId) {
+    try {
+        return sessionRoot(deps, sessionId);
+    }
+    catch {
+        return undefined;
+    }
+}