@senpi/runtime 3.0.173 → 3.0.181

package/dist/index.js

@@ -14,11 +14,12 @@
 import { readFileSync } from "node:fs";
 import { parse as parseYaml } from "yaml";
 import { join, dirname } from "node:path";
-import { SenpiClient } from "./senpi/client.js";
+import { isMoneyCallTool, SenpiClient, senpiOrderCallsInFlight } from "./senpi/client.js";
+import { MoneyCallTracker, registerMoneyCallHooks } from "./runtime/auto-update/money-call-tracker.js";
 import { buildWalletStatusHint } from "./senpi/strategy-status.js";
 import { bootSkippedStatusLabel, partitionByWalletStatus, readBootWalletStatuses, trackableWalletKeys, } from "./runtime/boot-skip.js";
 import { DeployJobController } from "./deploy/job.js";
-import { registerDeployGatewayMethods } from "./deploy/register.js";
+import { DEPLOY_CAPABILITIES, registerDeployGatewayMethods } from "./deploy/register.js";
 import { createQuantDesk } from "./quant/register.js";
 import { registerUpdateGatewayMethod } from "./runtime/update-register.js";
 import { createStrategiesPublisher } from "./runtime/strategies-telemetry.js";
@@ -28,6 +29,7 @@ import { checkProofCoversRecipe, makeApplyToRuntime, makeWriteRegistry, runtimeC
 import { INSTALL_DEADLINE_MS, WALLET_INSTALL_IN_FLIGHT_CODE } from "./deploy/deadlines.js";
 import { AuditQueryError } from "./runtime/audit-query.types.js";
 import { buildRuntimeStateDir, archiveStateDir } from "./runtime/state-layout.js";
+import { KeyedMutex } from "./utils/keyed-mutex.js";
 import { describeRuntimeEntry } from "./runtime/runtime-descriptor.js";
 import { registerSenpiCli } from "./cli/senpi-commands.js";
 import { readSenpiCliStore, resolveSenpiApiKeyFromStore, resolveSenpiBaseStateDir, } from "./cli/senpi-cli-config.js";
@@ -39,6 +41,7 @@ import { resolveAutoUpdateConfig } from "./runtime/auto-update/types.js";
 import { SkillsCoordinatorUnavailableError, SkillsUpdateCoordinator, resolveSkillsManagerConfig, } from "./skills-manager/index.js";
 import { createScannerProvidersForRun } from "./runtime/create-scanner-providers-for-run.js";
 import { initDsl } from "./dsl/index.js";
+import { exchangeStopClass } from "./dsl/engine/index.js";
 import { initHealth } from "./health/index.js";
 import { initRisk } from "./risk/index.js";
 import { readRiskAuditEntries } from "./risk/risk-audit-log.js";
@@ -46,15 +49,21 @@ import { readEvents } from "./telemetry/event-store.js";
 import { VERSION } from "./version.js";
 import { resolvePackageName } from "./runtime/auto-update/resolve-package-name.js";
 import { runOpenClawPluginsUpdate } from "./runtime/auto-update/run-update-command.js";
+import { UpdateIdleGate } from "./runtime/auto-update/idle-gate.js";
+import { registerIdleGateHooks, resolveUpdateMid } from "./runtime/auto-update/register-idle-gate.js";
+import { resolveUpdateMarkerPath } from "./runtime/auto-update/update-marker.js";
+import { INSTALL_RESULTS_OTEL_FLUSH_MS, INSTALL_RESULTS_OTEL_READY_MS, resolveInstallResultsPath, } from "./runtime/auto-update/install-results.js";
 import { registerSpanHooks } from "./telemetry/spans/index.js";
 import { registerSessionContextSeedHook } from "./prompt/session-context-seed-hook.js";
 import { registerSkillRouterHook } from "./prompt/skill-router-hook.js";
+import { registerCribSheet } from "./tool-surface/crib-hook.js";
 import { getDefaultPiiRedactor, initDefaultPiiRedactor } from "./telemetry/spans/redact-pii.js";
-import { initOtelSdk, shutdownOtelSdk } from "./telemetry/otel-sdk.js";
+import { flushOtelLogs, initOtelSdk, shutdownOtelSdk, waitForOtelInit } from "./telemetry/otel-sdk.js";
 import { getLogLevel, getLogLevelSource, parseLogLevel, setLogLevel, } from "./utils/logger.js";
 import { ExternalScannerIngestError, } from "./scanners/external-scanner-receiver.js";
 import { createLogger } from "./utils/logger.js";
-import { registerToolApprovalGate, resolveToolApprovalsMode, } from "./approvals/tool-approval-gate.js";
+import { PendingApprovalTracker, registerToolApprovalGate, resolveToolApprovalsMode, } from "./approvals/tool-approval-gate.js";
+import { registerTurnContextHooks, turnClassificationAvailable, TurnContextTracker, } from "./approvals/turn-context.js";
 import { registerShowWidgetTool } from "./widgets/index.js";
 import { registerQuantWidgetTurnCap } from "./widgets/turn-cap.js";
 import { EVENT_NAME, SENPI_ERROR_CODE, eventAttrs, scannerUnwiredErrorCode } from "./utils/event-catalog.js";
@@ -72,6 +81,8 @@ import { ingestDispatchMutex, ingestDispatchKey } from "./runtime-api/intake/ing
 import { buildScaffoldErrorRouter } from "./runtime-api/intake/scaffold-error-router.js";
 import { loadRuntimeConfig } from "./runtime/load-runtime-config.js";
 import { errorText } from "./deploy/error-text.js";
+import { initOpenClawHost } from "./host/openclaw-host.js";
+import { hostname } from "node:os";
 import { BOOT_FACTS_CALL_TIMEOUT_MS, planBootFacts, syncBootFacts, } from "./strategy/facts-sync.js";
 /** Initialize all core features (DSL, risk, health) on the given event bus. */
 export function initCore(bus) {
@@ -184,6 +195,45 @@ const WALLET_INSTALL_IN_FLIGHT = `[${WALLET_INSTALL_IN_FLIGHT_CODE}]`;
  * anyone's money is being claimed, which is precisely why it must not answer with the wallet code.
  */
 const RUNTIME_ID_TAKEN = "[E_RUNTIME_ID_TAKEN]";
+/**
+ * One StrategyFacts send per runtime at a time, keyed on runtime id, across the whole process: a
+ * second `register()` in the same process shares it. Separate from `runtimeChangeLock`. Delete does
+ * not take it; an apply queues its send here and does not wait.
+ */
+const factsSendLock = new KeyedMutex();
+/**
+ * Whether this process has already logged the 5.x "cannot classify runs" notice.
+ *
+ * Module-scoped so a gateway reload (which re-registers the plugin and restarts its service in the
+ * same process) does not repeat it. The 5.x case is a host-version limit with no config fix, so
+ * one info line per process is the whole message; the fixable 10.x case stays an ERROR at every
+ * registration and does not read this latch.
+ */
+let legacyTurnClassificationNoticeLogged = false;
+/** Clears {@link legacyTurnClassificationNoticeLogged}. Tests only. */
+export function resetLegacyTurnClassificationNoticeForTests() {
+    legacyTurnClassificationNoticeLogged = false;
+}
+/**
+ * The whole of `register()` in the `"cli-metadata"` pass: the `senpi` CLI root, under the same
+ * preconditions and with the same metadata as the full pass, and nothing else.
+ *
+ * Reads no `api.runtime`: on 10.x that pass's runtime throws on any read, and the host prints the
+ * throw as `runtime failed during register` on every `openclaw senpi …` call (RT566-04). Logs
+ * nothing: a skipped precondition is reported by the full pass, which follows in the same process.
+ */
+function registerSenpiCliMetadata(api) {
+    const config = api.pluginConfig;
+    if (!config)
+        return;
+    const mcpTransport = api.mcpTransport;
+    const apiKey = resolveSenpiApiKeyFromStore(readSenpiCliStore(), typeof config.apiKey === "string" && config.apiKey.length > 0 ? config.apiKey : undefined);
+    if (!mcpTransport && !apiKey)
+        return;
+    api.registerCli((ctx) => {
+        registerSenpiCli(ctx.program);
+    }, { commands: ["senpi"] });
+}
 /**
  * OpenClaw plugin entry.
  * Boots from internal registry (installed_runtimes.json) in stateDir; does not read runtime list from config.
@@ -223,7 +273,16 @@ const senpiRuntimePlugin = {
             warn: (...args) => api.logger.warn(...args),
             error: (message, meta) => api.logger.error(message, meta),
         };
+        // The cli-metadata pass only collects CLI command roots. 10.x hands it a runtime that throws on
+        // any read (RT566-04), so register the `senpi` root and nothing else — and read no api.runtime.
+        if (api.registrationMode === "cli-metadata") {
+            registerSenpiCliMetadata(api);
+            return;
+        }
         pluginLogger.info("[senpi-runtime] register(api) invoked");
+        // Host facts first: every version-gated registration below reads them.
+        const openClawHost = initOpenClawHost(api);
+        pluginLogger.info(`[senpi-runtime] host OpenClaw ${openClawHost.version ?? "unknown"} (${openClawHost.modern ? "modern" : "legacy"})`);
         const config = api.pluginConfig;
         if (!config) {
             pluginLogger.warn("[senpi-runtime] No plugin config found — skipping registration");
@@ -286,8 +345,8 @@ const senpiRuntimePlugin = {
         // Agent telemetry — gateway hooks emit gen_ai spans (llm/tool/subagent) through
         // the shared tracer; on-site MCP calls emit their own spans from SenpiClient.
         try {
-            registerSpanHooks({ api });
-            pluginLogger.info("[senpi-runtime] gen_ai span hooks registered (9 hooks)");
+            const spanHookCount = registerSpanHooks({ api, modernHost: openClawHost.modern });
+            pluginLogger.info(`[senpi-runtime] gen_ai span hooks registered (${spanHookCount} hooks)`);
         }
         catch (err) {
             pluginLogger.warn("[senpi-runtime] failed to register span hooks", {
@@ -326,14 +385,93 @@ const senpiRuntimePlugin = {
                 err: err instanceof Error ? err.message : String(err),
             });
         }
+        // senpi__ crib sheet (OpenClaw 10.x tool-search directory mode only): the
+        // directory folds every MCP tool into one sentence, so the runtime puts
+        // the names back as prependSystemContext. Registers nothing on 5.x.
+        // Its `before_prompt_build` hook needs the same host grant as the approval
+        // turn classification below; without it 10.x drops the hook, so the line
+        // says the crib is inactive and why instead of "registered".
+        try {
+            if (registerCribSheet({
+                api: api,
+                baseStateDir,
+                pluginConfig: config,
+                logger: pluginLogger,
+            })) {
+                // Registered, so the host is modern; only the hook grant is left to check.
+                const cribHook = turnClassificationAvailable({ modernHost: true, config: api.config, pluginId: api.id });
+                pluginLogger.info(cribHook.available
+                    ? "[senpi-runtime] senpi__ crib sheet registered (directory mode only)"
+                    : `[senpi-runtime] senpi__ crib inactive: ${cribHook.reason}` +
+                        (cribHook.configFix ? `; fix: ${cribHook.configFix}` : ""));
+            }
+        }
+        catch (err) {
+            pluginLogger.warn("[senpi-runtime] failed to register the senpi__ crib sheet", {
+                err: err instanceof Error ? err.message : String(err),
+            });
+        }
         // MCP tool approval gate — state-changing senpi MCP tools require an
         // interactive user approval before executing. Prompts reach senpi-web via
         // the bridge's operator.approvals-scoped gateway connection; allow-always
         // decisions persist in <stateDir>/tool-approvals.json.
         // See docs/mcp-tool-approvals-design.md.
+        // Open trade-approval prompts, read by the self-update idle gate (R2).
+        const pendingApprovalTracker = new PendingApprovalTracker();
+        // The turn kind (chat / cron / heartbeat) and session key of each gated
+        // call, for approval telemetry and the 10.x scheduled-turn block (R6, D13).
+        const turnContextTracker = new TurnContextTracker();
+        // One boot-time fact (D15): can this host classify runs at all? Only then
+        // does the gate stop prompts outside a direct chat turn. Without it every
+        // run reads unknown and keeps the pre-10.x prompt, so a box missing the
+        // setting never blocks chat trades; it is reported loudly instead.
+        let turnClassification = turnClassificationAvailable({
+            modernHost: openClawHost.modern,
+            config: api.config,
+            pluginId: api.id,
+        });
+        try {
+            registerTurnContextHooks({ api, tracker: turnContextTracker });
+        }
+        catch (err) {
+            turnClassification = { available: false, reason: "the turn-context hooks failed to register" };
+            pluginLogger.warn("[senpi-runtime] failed to register the approval turn-context hooks", {
+                err: err instanceof Error ? err.message : String(err),
+            });
+        }
+        // Only the logging and the status flag differ by host; the gate below reads the same boolean
+        // either way. On 10.x it is an ERROR at every registration (a box config to fix, or hooks that
+        // failed to register). On 5.x it is a host limit no config can fix, so it is one info line per
+        // process, logged from the service start below: that runs in the gateway only, so the
+        // `openclaw senpi …` CLI children (deploy.py, close.py, an agent exec) register without
+        // printing it.
+        const turnClassificationHostLimit = !turnClassification.available && !openClawHost.modern;
+        const turnClassificationNotice = turnClassification.available
+            ? undefined
+            : `[senpi-tool-approvals] cannot tell chat turns from scheduled or background runs: ${turnClassification.reason}. ` +
+                "Trade approvals are requested in every run, scheduled ones included, " +
+                (turnClassification.configFix
+                    ? `until the box config is fixed (${turnClassification.configFix}).`
+                    : turnClassificationHostLimit
+                        ? "on this OpenClaw version; a 10.x host lifts this."
+                        : "until the runtime registers its turn-context hooks.");
+        const legacyTurnClassificationNotice = turnClassificationHostLimit ? turnClassificationNotice : undefined;
+        if (turnClassificationNotice !== undefined && !turnClassificationHostLimit) {
+            pluginLogger.error(turnClassificationNotice);
+        }
+        const approvalsHostStatus = turnClassification.available
+            ? { turnClassification: "available" }
+            : {
+                turnClassification: "unavailable",
+                reason: turnClassification.reason,
+                ...(turnClassificationHostLimit ? { hostLimit: true } : {}),
+            };
         try {
             registerToolApprovalGate({
                 api,
+                pendingApprovals: pendingApprovalTracker,
+                turnContext: turnContextTracker,
+                turnClassification: turnClassification.available,
                 mode: resolveToolApprovalsMode({
                     pluginConfig: config,
                     env: process.env,
@@ -487,7 +625,7 @@ const senpiRuntimePlugin = {
         // PluginLogger surface (info/warn/error) lacks `debug`, while the
         // Logger contract used by `runtime-api/` includes it.
         const apiLogger = createLogger("[senpi-core][api]");
-        /** One line per instance for the boot StrategyFacts send (ticket 125); see `sendBootFacts`. */
+        /** One line per instance for each StrategyFacts send; see `queueFactsSend`. */
         const factsLogger = createLogger("[senpi-core][strategy-facts]");
         // A gateway seam failed to wire/launch a runtime's external scanner stack: the runtime is up but
         // runs blind on internal scanners only. Two records, by design: a first-class `runtime.scanners_unwired`
@@ -525,24 +663,92 @@ const senpiRuntimePlugin = {
         });
         const autoUpdateLogger = withEventLogger(pluginLogger, "[senpi-core][auto-update]");
         const autoUpdateConfig = resolveAutoUpdateConfig(config?.autoUpdate);
+        // OpenClaw 10.x (>= 2026.8.1): restart-to-apply (R2). The runtime cannot
+        // install itself there, so it waits for its spread slot and an idle box,
+        // writes the install marker, and restarts through mutateConfigFile; the
+        // senpi-agent wrapper installs before the next gateway spawn. On 5.7 and
+        // 5.12 the wiring is the in-process install + config-bump restart.
+        const modernHost = openClawHost.modern;
+        let idleGate;
+        if (modernHost) {
+            // Money calls on every route: the runtime's own in-process MCP calls, plus
+            // the agent's senpi__ calls (direct or through the dispatcher), seen at the
+            // tool hooks. A deploy job is read from the controller (this process) and
+            // its journals (any process).
+            const moneyCalls = new MoneyCallTracker();
+            try {
+                registerMoneyCallHooks({
+                    api: api,
+                    tracker: moneyCalls,
+                    isMoneyTool: isMoneyCallTool,
+                });
+            }
+            catch (err) {
+                pluginLogger.warn("[senpi-runtime] failed to register the self-update money-call hooks", {
+                    err: err instanceof Error ? err.message : String(err),
+                });
+            }
+            idleGate = new UpdateIdleGate({
+                pendingApprovals: () => pendingApprovalTracker.count(),
+                ordersInFlight: () => senpiOrderCallsInFlight() + moneyCalls.count(Date.now()),
+                // Read only from ticks, after register() has constructed the controller below.
+                deploysInFlight: () => deployController.inFlight(Date.now()),
+                logger: pluginLogger,
+            });
+            try {
+                registerIdleGateHooks({ api: api, gate: idleGate, logger: pluginLogger });
+            }
+            catch (err) {
+                pluginLogger.warn("[senpi-runtime] failed to register the self-update idle gate hooks", {
+                    err: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        const openclawStateDir = typeof api.runtime?.state?.resolveStateDir === "function" ? api.runtime.state.resolveStateDir() : undefined;
         const autoUpdateCoordinator = new AutoUpdateCoordinator({
             enabled: true,
             config: autoUpdateConfig,
             packageName: PLUGIN_PACKAGE_NAME,
             currentVersion: VERSION,
+            // The version this process loaded; "applied" is decided from it alone.
+            loadedVersion: VERSION,
             stateDir: join(baseStateDir, "auto-update"),
             logger: autoUpdateLogger,
             // Use the resolved npm package name (not a hardcoded plugin id) so
             // the update follows the same npm channel as the version check —
-            // see runtime/auto-update/run-update-command.ts.
-            runUpdateCommand: runOpenClawPluginsUpdate,
+            // see runtime/auto-update/run-update-command.ts. Not on 10.x, which
+            // refuses plugins update while the gateway runs.
+            runUpdateCommand: modernHost ? undefined : runOpenClawPluginsUpdate,
             configFromApi: api.config,
-            loadConfig: api.runtime?.config
+            loadConfig: !modernHost && api.runtime?.config
                 ? () => api.runtime.config.loadConfig()
                 : undefined,
-            writeConfigFile: api.runtime?.config
+            writeConfigFile: !modernHost && api.runtime?.config
                 ? (c) => api.runtime.config.writeConfigFile(c)
                 : undefined,
+            modernHost,
+            mutateConfigFile: modernHost && typeof api.runtime?.config?.mutateConfigFile === "function"
+                ? (p) => api.runtime.config.mutateConfigFile(p)
+                : undefined,
+            readLiveConfig: modernHost ? openClawHost.currentConfig : undefined,
+            idleGate,
+            mid: modernHost
+                ? resolveUpdateMid({
+                    token: apiKey ?? process.env.SENPI_AUTH_TOKEN ?? process.env.SENPI_API_KEY,
+                    env: process.env,
+                    hostname,
+                })
+                : undefined,
+            updateMarkerPath: modernHost && openclawStateDir ? resolveUpdateMarkerPath(openclawStateDir) : undefined,
+            // The wrapper's install outcomes, reported once per coordinator start (gateway only),
+            // with auto-update on or off. The report runs off the start path: it waits for the OTel
+            // init register() started (else the events go to the no-op logger and the file is gone)
+            // and flushes the logs before deleting the file.
+            installResultsPath: modernHost && openclawStateDir ? resolveInstallResultsPath(openclawStateDir) : undefined,
+            installResultsTelemetry: {
+                ready: () => waitForOtelInit(INSTALL_RESULTS_OTEL_READY_MS),
+                flush: () => flushOtelLogs(INSTALL_RESULTS_OTEL_FLUSH_MS),
+            },
             pluginId: api.id,
             // Drive skills-manager off the auto-update tick. Both success and
             // failure branches of auto-update's tick fire this hook so skills
@@ -622,6 +828,11 @@ const senpiRuntimePlugin = {
         api.registerService({
             id: "senpi-runtime",
             async start() {
+                // The 5.x classification notice (see the approval gate above), once per process.
+                if (legacyTurnClassificationNotice !== undefined && !legacyTurnClassificationNoticeLogged) {
+                    legacyTurnClassificationNoticeLogged = true;
+                    pluginLogger.info(legacyTurnClassificationNotice);
+                }
                 // Deploy-journal janitor: stamp anything a restart left unterminated as `interrupted`.
                 // It never re-enters a deploy state machine — discovery is pull-based via
                 // `senpi deploy status`.
@@ -759,26 +970,16 @@ const senpiRuntimePlugin = {
                     emitEvent(apiLogger, () => buildRuntimeBootSkippedEvent({ runtimeId: entry.id, address: entry.wallet ?? "", status }));
                 }
                 const started = [];
-                const factsPlans = [];
+                // Started runtimes with a facts plan, in boot order; their send runs detached after boot, below.
+                const factsRuntimeIds = [];
                 try {
                     for (const entry of entriesToBoot) {
-                        const hasPath = typeof entry.runtimeYamlPath === "string" && entry.runtimeYamlPath.length > 0;
-                        const hasContent = typeof entry.runtimeYamlContent === "string";
-                        if (hasPath && hasContent)
-                            continue;
-                        if (!hasPath && !hasContent)
+                        const inputs = factsPlanInputs(entry);
+                        if (!inputs)
                             continue;
-                        const pathOrContent = entry.runtimeYamlPath ?? entry.runtimeYamlContent;
-                        const entryStateDir = buildRuntimeStateDir(baseStateDir, entry.id, entry.wallet ?? "");
-                        // Local only (files, no network); the send itself runs detached after boot, below.
-                        const factsPlan = await planInstanceFacts({
-                            runtimeId: entry.id,
-                            wallet: entry.wallet,
-                            stateDir: entryStateDir,
-                            pathOrContent,
-                            fromPath: hasPath,
-                            runtimeYamlDir: hasPath ? dirname(pathOrContent) : entry.runtimeYamlDir,
-                        });
+                        const { pathOrContent, fromPath: hasPath, stateDir: entryStateDir } = inputs;
+                        // Local only (files, no network). Read here for the `factsSent` stamp on this start.
+                        const factsPlan = await planInstanceFacts(inputs);
                         const handle = await run(pathOrContent, {
                             fromPath: hasPath,
                             stateDir: entryStateDir,
@@ -792,7 +993,7 @@ const senpiRuntimePlugin = {
                         runtimeHandles.set(entry.id, handle);
                         started.push(entry.id);
                         if (factsPlan)
-                            factsPlans.push(factsPlan);
+                            factsRuntimeIds.push(entry.id);
                         // ── supervised scanner mount (additive; guarded) ──────────────────
                         // Boot path: used for runtimes already present in the registry at
                         // startup. A runtime installed live, after the API is listening,
@@ -885,8 +1086,12 @@ const senpiRuntimePlugin = {
                     throw err;
                 }
                 pluginLogger.info(`[senpi-runtime] Started ${started.length} runtime${started.length === 1 ? "" : "s"}`);
-                // Detached: the facts send never holds boot or trading. One line per instance.
-                void sendBootFacts(factsPlans, bootStrategyIds).catch((err) => {
+                // Detached: the facts send never holds boot or trading. One line per instance, one instance at
+                // a time, each planned again when its turn comes under the per-runtime facts lock.
+                void (async () => {
+                    for (const runtimeId of factsRuntimeIds)
+                        await queueFactsSend(runtimeId, bootStrategyIds);
+                })().catch((err) => {
                     factsLogger.warn("strategy facts send crashed", err);
                 });
                 // ── HTTP API ──────────────────────────────────────────────────────
@@ -1628,8 +1833,27 @@ const senpiRuntimePlugin = {
             else
                 respond(false, undefined, result.error);
         }, { scope: "operator.write" });
-        // ── StrategyFacts at boot (ticket 125) ─────────────────────────────────
-        /** The boot plan for one instance, or null (logged once as `failed`) when it cannot be made. */
+        // ── StrategyFacts send ─────────────────────────────────────────────────
+        /**
+         * The facts plan inputs for one registry entry, which are also the recipe and state dir boot
+         * starts it with. Null when the entry holds both or neither of a recipe path and recipe content.
+         */
+        function factsPlanInputs(entry) {
+            const hasPath = typeof entry.runtimeYamlPath === "string" && entry.runtimeYamlPath.length > 0;
+            const hasContent = typeof entry.runtimeYamlContent === "string";
+            if (hasPath === hasContent)
+                return null;
+            const pathOrContent = entry.runtimeYamlPath ?? entry.runtimeYamlContent;
+            return {
+                runtimeId: entry.id,
+                wallet: entry.wallet,
+                stateDir: buildRuntimeStateDir(baseStateDir, entry.id, entry.wallet ?? ""),
+                pathOrContent,
+                fromPath: hasPath,
+                runtimeYamlDir: hasPath ? dirname(pathOrContent) : entry.runtimeYamlDir,
+            };
+        }
+        /** The facts plan for one instance, or null (logged once as `failed`) when it cannot be made. */
         async function planInstanceFacts(input) {
             try {
                 const config = await loadRuntimeConfig(input.pathOrContent, { fromPath: input.fromPath });
@@ -1696,6 +1920,43 @@ const senpiRuntimePlugin = {
                     await session.client.disconnect().catch(() => { });
             }
         }
+        /**
+         * Send one runtime's facts under `factsSendLock`. The plan is made from the registry entry and
+         * the state file as they are when the send runs, so the last send for a runtime carries its
+         * current recipe. A runtime no longer in the registry, or whose entry cannot be planned, gets
+         * no send. An unchanged plan makes no call.
+         *
+         * `strategyIds` is the boot's one batched status read (null when that read failed). Without it,
+         * the strategy id is read for this one wallet; a failed read logs its reason and sends nothing.
+         */
+        function queueFactsSend(runtimeId, strategyIds) {
+            return factsSendLock.withKeyLock(runtimeId, async () => {
+                const { readRegistry } = await import("./runtime/strategy-registry.js");
+                const entry = (await readRegistry(baseStateDir)).runtimes.find((e) => e.id === runtimeId);
+                const inputs = entry ? factsPlanInputs(entry) : null;
+                if (!inputs)
+                    return;
+                const plan = await planInstanceFacts(inputs);
+                if (!plan)
+                    return;
+                let ids = strategyIds ?? null;
+                if (strategyIds === undefined && !plan.unchanged) {
+                    const read = await readBootWalletStatuses([plan.wallet.trim().toLowerCase()], (wallets, signal) => withSenpiClient((client) => client.listStrategies({ strategyAddresses: wallets }, { signal })));
+                    if (!read.ok) {
+                        factsLogger.warn("strategy facts failed: could not read the strategy id; retrying next boot", undefined, {
+                            runtimeId: plan.runtimeId,
+                            wallet: plan.wallet,
+                            hash: plan.hash.slice(0, 12),
+                            reason: read.reason,
+                            detail: read.message,
+                        });
+                        return;
+                    }
+                    ids = read.strategyIds;
+                }
+                await sendBootFacts([plan], ids);
+            });
+        }
         /** One connected SenpiClient per job; always disconnected, even on failure. */
         async function withSenpiClient(fn) {
             const client = mcpTransport ? new SenpiClient(mcpTransport) : new SenpiClient({ apiKey });
@@ -1908,6 +2169,13 @@ const senpiRuntimePlugin = {
                         ...(info.slots !== undefined ? { slots: info.slots } : {}),
                     });
                 });
+                // The apply swaps the recipe with no boot, so this send moves the backend's facts (what the
+                // app shows) to the new recipe before the next boot. Detached: the apply has landed and must
+                // not wait on, or fail over, the send. The send plans from the registry entry the apply has
+                // written, and takes the wallet from that entry or its recipe.
+                void queueFactsSend(info.runtimeId).catch((err) => {
+                    factsLogger.warn("strategy facts send crashed", err);
+                });
             },
         });
         registerDeployGatewayMethods(api, {
@@ -1930,7 +2198,10 @@ const senpiRuntimePlugin = {
             // same clean line over a runtime that cannot tick.
             runtimeIsLive: async (id) => runtimeHandles.has(id) && !unwiredRuntimes.has(id),
             installPendingOnWallet: async (wallet) => installsInFlight.has(wallet.trim().toLowerCase()),
-            logger: { info: (line) => api.logger.info(`[senpi-runtime] ${line}`) },
+            logger: {
+                info: (line) => api.logger.info(`[senpi-runtime] ${line}`),
+                warn: (line) => api.logger.warn(`[senpi-runtime] ${line}`),
+            },
         });
         /**
          * Gateway shim for `senpi.ingestExternalScannerData`.
@@ -2055,6 +2326,7 @@ const senpiRuntimePlugin = {
             const runtimeId = typeof ctx.params?.runtimeId === "string" ? ctx.params.runtimeId : undefined;
             const address = typeof ctx.params?.address === "string" ? ctx.params.address : undefined;
             pluginLogger.info("[senpi-runtime] senpi.getDslPositionState", { asset, runtimeId, address });
+            // `exchangeStop` is derived from the state on each response and is not persisted.
             const matches = [];
             for (const [id, handle] of runtimeHandles) {
                 if (runtimeId && id !== runtimeId)
@@ -2065,12 +2337,18 @@ const senpiRuntimePlugin = {
                     if (address) {
                         const state = handle.dsl.getPositionState(address, asset);
                         if (state)
-                            matches.push({ runtimeId: id, address, state });
+                            matches.push({ runtimeId: id, address, state, exchangeStop: exchangeStopClass(state) });
                     }
                     else {
                         const found = handle.dsl.findPositionByAsset(asset);
-                        if (found)
-                            matches.push({ runtimeId: id, address: found.address, state: found.state });
+                        if (found) {
+                            matches.push({
+                                runtimeId: id,
+                                address: found.address,
+                                state: found.state,
+                                exchangeStop: exchangeStopClass(found.state),
+                            });
+                        }
                     }
                 }
                 catch (err) {
@@ -2126,6 +2404,8 @@ const senpiRuntimePlugin = {
                     respond(true, {
                         status: status ? { ...status, runtimeId } : null,
                         updater,
+                        approvals: approvalsHostStatus,
+                        deploy: { capabilities: DEPLOY_CAPABILITIES },
                     });
                 }
                 catch (err) {
@@ -2138,7 +2418,7 @@ const senpiRuntimePlugin = {
                 return;
             }
             const statuses = await collectRuntimeHealthStatuses(runtimeHandles, api.logger);
-            respond(true, { statuses, updater });
+            respond(true, { statuses, updater, approvals: approvalsHostStatus, deploy: { capabilities: DEPLOY_CAPABILITIES } });
         }, { scope: "operator.read" });
         api.registerGatewayMethod("senpi.getSystemState", async (ctx) => {
             const respond = ctx.respond;