create-walle 0.10.2 → 0.10.3

package/template/shared/orphan-parents.js

@@ -0,0 +1,55 @@
+'use strict';
+
+// WP-12 (coding-task-manager/docs/nightly-linux-host-portability-2026-10-27.html §9.4, S-29): the pids an
+// orphan can be re-parented to. The kernel hands an orphan to its nearest living CHILD SUBREAPER ancestor
+// and only falls back to pid 1 without one (prctl(2) PR_SET_CHILD_SUBREAPER). On Linux the `systemd
+// --user` manager is a subreaper for everything in the user's session -- measured on the DGX Spark: this
+// shell's ancestry ends bash -> claude -> CTM -> systemd 2177, and an orphaned proxy, fake Wall-E and
+// spawn-helper all showed ppid 2177, never 1. So `ppid === 1` misses every orphan there.
+//
+// Another process's subreaper flag cannot be read, but an orphan of one of OUR descendants can only go to
+// pid 1 or to one of our own ancestors (gascity #8058's argument), so the set is pid 1 plus each of this
+// process's ancestors that is a `systemd` (the user manager; KiroCrew #10601, jstack #363 use the same
+// test). On every other platform it is exactly {1}: macOS launchd is pid 1.
+
+const fs = require('node:fs');
+
+const MAX_ANCESTRY_STEPS = 64;
+
+function _statusField(status, field) {
+  const m = new RegExp(`^${field}:\\s+(\\d+)`, 'm').exec(status);
+  return m ? Number(m[1]) : null;
+}
+
+/**
+ * @param {{ platform?: string, pid?: number, readFileSync?: Function }} [opts]
+ * @returns {Set<number>} always contains 1; on Linux also every `systemd` ancestor of `pid`.
+ */
+function orphanParentPids({ platform = process.platform, pid = process.pid, readFileSync = fs.readFileSync } = {}) {
+  const parents = new Set([1]);
+  if (platform !== 'linux') return parents;
+  let current = pid;
+  const seen = new Set();
+  for (let step = 0; step < MAX_ANCESTRY_STEPS; step += 1) {
+    let status;
+    try {
+      status = String(readFileSync(`/proc/${current}/status`, 'utf8'));
+    } catch {
+      break; // expected: the ancestor exited mid-walk or /proc is unreadable -- what was found stands
+    }
+    const ppid = _statusField(status, 'PPid');
+    if (!Number.isSafeInteger(ppid) || ppid <= 1 || seen.has(ppid)) break;
+    seen.add(ppid);
+    let comm = '';
+    try {
+      comm = String(readFileSync(`/proc/${ppid}/comm`, 'utf8')).trim();
+    } catch {
+      break; // expected: the parent exited between the two reads
+    }
+    if (comm === 'systemd') parents.add(ppid);
+    current = ppid;
+  }
+  return parents;
+}
+
+module.exports = { orphanParentPids, MAX_ANCESTRY_STEPS };

package/template/shared/release-schema.json

@@ -9,7 +9,7 @@
         21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
         31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
         41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
-        51, 52, 53, 54, 55, 56
+        51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61
       ]
     },
     "walle": {
@@ -25,7 +25,7 @@
         71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
         81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
         97, 98, 99, 100,
-        101
+        101, 102, 103, 104, 105
       ]
     }
   }

package/template/shared/storage/contract.js

@@ -783,6 +783,9 @@ const OP_META = {
   recordResumeLineage: { kind: 'write', equality: 'exact', domain: 'firehose', tables: ['session_resume_lineage'] },
   // WP-0 change feed: the ACK is a write on the firehose file (db.js:19895).
   ackConversationChanges: { kind: 'write', equality: 'exact', domain: 'firehose', tables: ['conversation_projection_outbox_v2', 'conversation_projection_deletes_v2'] },
+  conversationSyncVector: { kind: 'write', equality: 'exact', domain: 'firehose', tables: ['conversation_item_clock', 'conversation_vv', 'conversation_local_seq'] },
+  conversationSyncChanges: { kind: 'write', equality: 'exact', domain: 'firehose', tables: ['conversation_item_clock', 'conversation_vv', 'conversation_local_seq'] },
+  conversationSyncApply: { kind: 'write', equality: 'exact', domain: 'firehose', tables: ['conversation_text_items_v2', 'conversation_item_placement_v2', 'conversation_item_clock', 'conversation_vv'] },
   // --- core (session identity, user content, runtime control state; latency-critical) ---
   updateRuntimeInputEnvelope: { kind: 'write', equality: 'exact', domain: 'core', tables: ['ctm_runtime_input_envelopes'] },
   upsertRuntimeRouteSnapshot: { kind: 'write', equality: 'exact', domain: 'core', tables: ['ctm_runtime_route_snapshots'] },

package/template/wall-e/adapters/imessage.js

@@ -15,6 +15,7 @@ const DEFAULT_SERVICES = ['iMessage', 'SMS', 'RCS'];
 const AdapterBase = require('./adapter-base');
 const { decodeAttributedBodyText } = require('../lib/imessage/typedstream-text');
 const { editedCurrentText } = require('../lib/imessage/bplist-min');
+const { boolFlag } = require('../lib/env-flags');
 
 function normalizeServices(services) {
   const requested = Array.isArray(services) ? services : [];
@@ -217,6 +218,16 @@ class IMessageAdapter extends AdapterBase {
   }
 }
 
+// D-5/S-21 (shared-memory WP-2, Q-2): this adapter is OFF on a `role:'box'` machine — the box
+// shares the hub's Apple ID (3/3 probed guids matched), so both Macs would ingest the same
+// chat.db and double-extract it. A machine with a DIFFERENT Apple ID opts in with
+// WALLE_IMESSAGE_INGEST=1. Ingest itself is host-local and never duplicates rows (deterministic
+// ids), so a role we cannot read keeps today's behaviour: the adapter stays active.
+function imessageIngestEnabled(placement) {
+  if (!placement || placement.role !== 'box') return true;
+  return boolFlag('WALLE_IMESSAGE_INGEST', false);
+}
+
 // D-18: service-alert-store's addServiceAlert() is async and needs a kvStore
 // ({getKv,setKv}) rather than a single call, so this is the "tiny helper"
 // the WP-1 brief calls for -- shared by agent.js and lib/scheduler-worker-jobs.js
@@ -248,5 +259,6 @@ function buildHealthReporter(kvStore, { addServiceAlert, fdaGuidance } = {}) {
 module.exports = IMessageAdapter;
 module.exports.IMessageAdapter = IMessageAdapter;
 module.exports.buildHealthReporter = buildHealthReporter;
+module.exports.imessageIngestEnabled = imessageIngestEnabled;
 module.exports.normalizeServices = normalizeServices;
 module.exports.DEFAULT_SERVICES = DEFAULT_SERVICES;

package/template/wall-e/agent.js

@@ -103,6 +103,8 @@ const {
 // interval engine) is gone with it — on-demand skill execution in skill-planner
 // is untouched.
 const { runDueJobs, recoverLostRuns } = require('./jobs/job-runner');
+// shared-memory WP-2 (D-5/S-17/S-19): the derivation-home gate for `placement: 'home'` jobs.
+const { runIfHome } = require('./lib/derivation-home');
 const { getIncidentLog } = require('./lib/incident-log');
 const { ProcessErrorReporter } = require('./lib/process-error-reporter');
 const errorSink = require('./lib/error-sink');
@@ -526,8 +528,8 @@ async function main() {
   // When CTM is unreachable the bridge fails closed to the local rules (no hang).
   try {
     const { configure: configurePermissions } = require('./tools/permission-checker');
-    const ctmPort = process.env.CTM_PORT || require('./lib/ctm-endpoint').ctmPort();
-    configurePermissions({ ctmUrl: `http://localhost:${ctmPort}`, ctmToken: process.env.CTM_TOKEN });
+    const { resolveApiBaseUrl } = require('./memory/ctm-context-client'); // R-7: one resolver; WALLE_CTM_API=0 = bridge off
+    configurePermissions({ ctmUrl: resolveApiBaseUrl(process.env) || null, ctmToken: process.env.CTM_TOKEN });
   } catch (e) { console.warn('[wall-e] permission bridge configure failed:', e.message); }
 
   let eventLoopWatchdog = null;
@@ -1279,6 +1281,7 @@ async function main() {
   // preserved.
   scheduler.register({
     name: 'ingest',
+    placement: 'any', // D-5(a): host-local ingest runs where the data lives (the iMessage adapter gates itself, S-21)
     // WP-1b (E-6 follow-up): derived from enabled poll adapters' manifests
     // (adapters/registry.js:ingestNetworkClass) — local-only dev still
     // ingests local sources (imessage) while enabled Slack keeps it external.
@@ -1303,6 +1306,7 @@ async function main() {
   // projection; it is the only way coding-session text reaches the brain (D-11a).
   scheduler.register({
     name: 'conversation-subscriber',
+    placement: 'any', // D-11a: pulls CTM's own conversation feed — host-local
     networkClass: 'local',
     run: () => require('./memory/conversation-subscriber').runConversationSubscriberOnce({ brain }),
     intervalMs: clampInterval(config.intervals?.conversation_subscriber_ms, 30 * 1000),
@@ -1316,8 +1320,9 @@ async function main() {
 
   scheduler.register({
     name: 'memory-consolidation',
+    placement: 'home', // D-5(c)/S-17: derives from replicated walle-coding rows — derivation home only
     networkClass: 'local', // WP-6: decisions are the deterministic defaultDecision (no model call); FTS search + loopback CTM reads only
-    run: () => require('./memory/consolidation').runMemoryConsolidation({ brain }),
+    run: () => runIfHome('memory-consolidation', () => require('./memory/consolidation').runMemoryConsolidation({ brain })),
     intervalMs: clampInterval(config.intervals?.memory_consolidation_ms, 60 * 60 * 1000),
     pool: 'maintenance',
     lane: 2,
@@ -1350,6 +1355,7 @@ async function main() {
 
   scheduler.register({
     name: 'think',
+    placement: 'any', // D-5(d): extraction of locally ingested pending memories runs everywhere (think gates only its derived steps, S-18/S-20)
     networkClass: 'llm',
     // WP-7: think's model calls stop 15 s before the job request deadline. A worker run reads that deadline
     // from its runtime execution context; this in-process run (no worker pool) is bounded by the same constant.
@@ -1375,6 +1381,7 @@ async function main() {
 
   scheduler.register({
     name: 'jobs',
+    placement: 'any', // D-5(c)/S-16: the engine gates derived action_kinds itself; builtin jobs run everywhere
     networkClass: 'llm',
     // surface-redesign WP-3 §5: ONE scheduler job over the jobs/job_runs
     // records, replacing the `tasks` and `skills` registrations. runDueJobs
@@ -1406,8 +1413,9 @@ async function main() {
 
   scheduler.register({
     name: 'reflect',
+    placement: 'home', // D-5(c)/S-19: rewrites entities from every node's rows (LWW churn) — derivation home only
     networkClass: 'llm',
-    run: () => reflect.runOnce(),
+    run: () => runIfHome('reflect', () => reflect.runOnce()),
     intervalMs: clampInterval(config.intervals?.reflect_ms, 3600000),
     pool: 'llm_background',
     lane: 2,
@@ -1427,6 +1435,7 @@ async function main() {
 
   scheduler.register({
     name: 'backfill',
+    placement: 'any', // host-local backfill over this node's own rows (embeddings are derived per node, id-stable)
     // E-6: calls embeddings.batchComputeEmbeddings, which routes to whatever
     // embedding provider is configured — MAY hit a remote provider, not
     // guaranteed local-Ollama.
@@ -1463,6 +1472,7 @@ async function main() {
   // is idempotent (skips if today's already exists) and createBackup is now non-blocking.
   scheduler.register({
     name: 'daily-backup',
+    placement: 'any', // local sqlite file copy only — every node backs up its own brain file
     networkClass: 'local', // local sqlite file copy only
     run: async () => {
       const r = await brain.ensureDailyBackup();
@@ -1496,6 +1506,7 @@ async function main() {
   let walOverThresholdStreak = 0;
   scheduler.register({
     name: 'wal-checkpoint',
+    placement: 'any', // host-local WAL hygiene for this node's own file
     networkClass: 'local', // local sqlite WAL checkpoint/planner-optimize only
     worker: false,
     workerHeavy: false,
@@ -1599,6 +1610,7 @@ async function main() {
   // short brain-owner op (WP-6: the writer is never held for the whole sweep), age-gated + batched. See the 2026-05-31 audit.
   scheduler.register({
     name: 'brain-retention',
+    placement: 'any', // local table pruning only — each node prunes its own file
     networkClass: 'local', // local table pruning only
     run: async () => await brain.brainRetentionJob(require('./loops/brain-write').brainWrite),
     intervalMs: 24 * 60 * 60 * 1000,
@@ -1616,12 +1628,62 @@ async function main() {
     onError: (err) => console.error('[brain-retention] Error:', err.message),
   });
 
+  // shared-memory WP-0 §6.3: give every pre-existing replicated row a v2 clock, one bounded
+  // owner page (2,000 rows) per tick; a no-op once the kv cursor says done. Never boot work.
+  scheduler.register({
+    name: 'brain-clock-seed',
+    placement: 'any', // WP-0 (S-71): this node's own pre-existing rows need their v2 clock locally
+    networkClass: 'local',
+    worker: false,
+    workerHeavy: false,
+    executionClass: 'constant-time-control',
+    run: async () => {
+      const state = require('./brain/brain-sync-store').clockSeedState(brain.getDb());
+      if (state && state.done) return { skipped: true, reason: 'done' };
+      return require('./loops/brain-write').brainWrite('brainSyncClockSeed', { limit: 2000 });
+    },
+    intervalMs: 5000,
+    pool: 'maintenance',
+    lane: 2,
+    priority: 11,
+    startDelayMs: 60000,
+    onError: (err) => console.error('[brain-clock-seed] Error:', err.message),
+  });
+
+  // shared-memory WP-4 §6.7: drive the join import one bounded page per tick, only while a join
+  // is in flight (verifying/importing). A no-op otherwise — a machine that never joins pays
+  // nothing but the kv read. Same owner-routed seam as brain-clock-seed: the job's handle is
+  // read-only, so the page (four replicated tables + their clock rows, sentinel on) runs on the
+  // owner's write connection. The kv cursor makes a killed import resume without duplicates.
+  scheduler.register({
+    name: 'brain-join-import',
+    placement: 'any', // the imported rows land on THIS member's own brain
+    networkClass: 'local',
+    worker: false,
+    workerHeavy: false,
+    executionClass: 'constant-time-control',
+    run: async () => {
+      const state = require('./brain/brain-join').joinStatus(brain.getDb());
+      if (!state || state.state === 'none' || state.state === 'done' || state.state === 'failed') {
+        return { skipped: true, reason: (state && state.state) || 'none' };
+      }
+      return require('./loops/brain-write').brainWrite('brainSyncV2JoinStep', { limit: 5000 });
+    },
+    intervalMs: 2000,
+    pool: 'maintenance',
+    lane: 2,
+    priority: 11,
+    startDelayMs: 75000,
+    onError: (err) => console.error('[brain-join-import] Error:', err.message),
+  });
+
   // Model facts sync daemon fallback. LiteLLM supplies broad provider context-
   // window/cost FACTS into model_facts ONLY — model-facts-registry-separation-
   // session-owned-window WP-3 replaced the old pricing-sync skill (which
   // wrote straight into model_registry route rows) in place.
   scheduler.register({
     name: 'model-facts-sync',
+    placement: 'any', // D-19: the facts catalog is shared, the write is idempotent per node
     networkClass: 'external', // fetches the LiteLLM facts catalog
     run: async () => {
       const sync = require('./skills/_bundled/model-facts-sync/run');
@@ -1657,6 +1719,7 @@ async function main() {
   // write through the brain owner.
   scheduler.register({
     name: 'connections',
+    placement: 'any', // D-12: probes THIS machine's credential surface and writes its own record
     networkClass: 'external', // Slack auth.test + the gateway /_status
     run: () => runConnectionProbe(),
     intervalMs: 300000, // 5 min (D-12)
@@ -1678,6 +1741,7 @@ async function main() {
   // dry-run so operators can inspect candidate counts before enabling it.
   scheduler.register({
     name: 'telemetry:cleanup',
+    placement: 'any', // local telemetry-DB row deletes/redactions on this node's own store
     networkClass: 'local', // local telemetry-DB row deletes/redactions only, no outbound sends
     run: async () => {
       const { runTelemetryCleanup, isTelemetryCleanupLive } = require('./api-walle');
@@ -1712,6 +1776,7 @@ async function main() {
   // Weekly coding-agent benchmark suite (Phase 5)
   scheduler.register({
     name: 'agent-benchmark',
+    placement: 'any', // opt-in per-machine evaluation (heavyEvalJobsEnabled), writes only its own results
     networkClass: 'llm',
     run: async () => {
       const { runAgentBenchmarkSuite, detectRegressions, resolveModelName } = require('./runtime/evaluation/agent-runner');
@@ -1762,6 +1827,7 @@ async function main() {
   // Weekly full evaluation loop (Phase 8: benchmarks + regressions + mining + promotions + aggregation)
   scheduler.register({
     name: 'weekly-eval-loop',
+    placement: 'any', // opt-in per-machine evaluation loop (Sundays, heavyEvalJobsEnabled)
     networkClass: 'llm',
     run: async () => {
       const { run: runWeeklyEval } = require('./runtime/evaluation/weekly-eval-loop');
@@ -1797,6 +1863,7 @@ async function main() {
   // is no day-of-week gate because the evaluator owns its own timing.
   scheduler.register({
     name: 'helper-rules-probe',
+    placement: 'any', // local sqlite read + one owner-path write on this node's own outcome stream
     networkClass: 'local', // local sqlite read + one owner-path write, no provider call
     run: async () => runRuntimeJob(
       'helper-rules-probe',

package/template/wall-e/api-walle.js

@@ -37,7 +37,7 @@ const { handleSkillsApi } = require('./http/skills-api');
 const { handleSlackApi } = require('./http/slack-api');
 const { handleSystemApi } = require('./http/system-api');
 const { handleTelemetryApi } = require('./http/telemetry-api');
-const { handleModelProxyProvidersFeed } = require('./http/model-proxy-providers');
+const { handleModelProxyProvidersFeed, handleDelegateDefaultsFeed, handleProviderExport } = require('./http/model-proxy-providers');
 const {
   jsonResponse,
   parseLimit,
@@ -2334,6 +2334,26 @@ function routeWalleApi(req, res, url, routeHandlers = {}) {
     errorStatus: apiReadErrorStatus,
   });
   if (providerFeedHandled !== false) return providerFeedHandled;
+  // WP-1 (docs/remote-box-model-access-2026-10-26.html §6.1): the box's own /delegate defaults, so
+  // the hub can say whether the box can reach the route its pick names. Same loopback guard and the
+  // same dispatch site as the provider feed above.
+  const delegateDefaultsHandled = handleDelegateDefaultsFeed(req, res, url, {
+    isLoopbackRequest: ctmTransportSecurity?.isLoopbackRequest,
+    brainAvailable: !!brain,
+    errorStatus: apiReadErrorStatus,
+  });
+  if (delegateDefaultsHandled !== false) return delegateDefaultsHandled;
+  // WP-5 (docs/remote-box-model-access-2026-10-26.html §5.1 R-5/R-6, §6.4): the hub's CTM reads
+  // ONE route WITH its key here, to copy it onto a paired box on an explicit click. Same loopback
+  // guard and the same dispatch site as the two leaves above — it is the only route that returns a
+  // credential, and loopback is what confines it to this host.
+  const providerExportHandled = handleProviderExport(req, res, url, {
+    readBrain,
+    isLoopbackRequest: ctmTransportSecurity?.isLoopbackRequest,
+    brainAvailable: !!brain,
+    errorStatus: apiReadErrorStatus,
+  });
+  if (providerExportHandled !== false) return providerExportHandled;
   if (url.pathname === '/api/wall-e/background/completion' && req.method === 'POST') {
     if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
     return handleBackgroundCompletionApi(req, res, url, { brain });

package/template/wall-e/bin/train-gemma-e4b-tooluse.js

@@ -1953,7 +1953,7 @@ function printHelp() {
   node wall-e/bin/train-gemma-e4b-tooluse.js validate-dataset --output-dir /tmp/run
   node wall-e/bin/train-gemma-e4b-tooluse.js dry-run-train --output-dir /tmp/run --base-model /path/to/base
   node wall-e/bin/train-gemma-e4b-tooluse.js train --output-dir /tmp/run --base-model /path/to/base --iters 600 --max-seq-length 8192
-  node wall-e/bin/train-gemma-e4b-tooluse.js train --backend cuda --remote-host spark@dgx-spark --preset best-practice --output-dir /tmp/run --base-model /path/to/base --remote-base-model ~/models/gemma-4-E4B-it
+  node wall-e/bin/train-gemma-e4b-tooluse.js train --backend cuda --remote-host dgx-spark --preset best-practice --output-dir /tmp/run --base-model /path/to/base --remote-base-model ~/models/gemma-4-E4B-it
   node wall-e/bin/train-gemma-e4b-tooluse.js register-candidate --output-dir /tmp/run --alias gemma-e4b-tooluse-v1
 
 Dataset export options:
@@ -2049,7 +2049,7 @@ Backend / DGX Spark (CUDA) options:
   --backend mlx|cuda      mlx = local Metal (default); cuda = PyTorch/PEFT/bitsandbytes
   --load-in-4bit true|false   NF4 QLoRA on the CUDA path (default true)
   --remote-host user@host     run the CUDA launcher on the Spark over ssh/rsync
-                              (e.g. spark@dgx-spark); omit to run on a local CUDA box
+                              (e.g. dgx-spark, an alias naming the login); omit for a local CUDA box
   --remote-root path          remote run root (default ~/walle-training)
   --remote-base-model path    remote-side base model path on the Spark
   --remote-python path        remote venv python (default ~/.cuda-train-env/bin/python3)

package/template/wall-e/bin/walle-mcp-stdio.js

@@ -48,9 +48,9 @@ const TOOL_PROXY_TIMEOUTS_MS = Object.freeze({
   walle_lookup_context: 60000, walle_context_hint: 60000,
   walle_postflight_check: 60000, walle_search_sessions: 60000,
   walle_get_session: 60000, walle_context_pack: 90000,
-  ask_walle: 240000, walle_worker_wait: 545000,
+  ask_walle: 240000, walle_worker_wait: 545000, walle_landing_wait: 545000, // WP-4 §6.4: the landing wait polls up to 540000 ms; its proxy deadline outlasts it.
   walle_imessage_search: 10000, walle_imessage_read_chat: 10000,
-  walle_imessage_list_chats: 10000,
+  walle_imessage_list_chats: 10000, hub_exec: 125000, // hub bridge §6.4: exec 120000 + the client's 2 s grace (memory/hub-bridge-client.js) + 2 s HTTP grace = 124000; 125000 outlasts it.
   walle_delegate_implementation: LAUNCH_TOOL_PROXY_TIMEOUT_MS, walle_resume_worker: LAUNCH_TOOL_PROXY_TIMEOUT_MS, // R-3: the daemon's own CTM deadline is 30000 (mcp-server.js, delegate + resume) + 5000
 });
 
@@ -170,9 +170,9 @@ function _localControlPlaneEnabled() {
 async function _localControlResponseOne(message) {
   // WP-4 §6.4: the caller harness's `explore` cell lives in the daemon (this process owns no
   // brain): read-only endpoint, existing breaker machinery, 1500 ms bound, fail-open 'on'.
-  const options = message?.method === 'initialize'
-    ? { leadGuidance: { explore: await fetchExploreCellState({ agent: leadAgentFromClientInfo(message.params?.clientInfo), requestFn: (path) => _executeDaemonRequest(() => httpJsonGet({ host: process.env.WALLE_HOST || '127.0.0.1', port: _wallePort(), path })) }) } }
-    : undefined;
+  const options = await require('../memory/hub-bridge-client').controlPlaneOptions(message, { // R-1/R-2/WP-2/WP-3: this file is at a frozen ceiling, so the gate, the hub context and the list_changed timer live in hub-bridge-client.js
+    writeMessage, leadGuidance: () => fetchExploreCellState({ agent: leadAgentFromClientInfo(message.params?.clientInfo), requestFn: (path) => _executeDaemonRequest(() => httpJsonGet({ host: process.env.WALLE_HOST || '127.0.0.1', port: _wallePort(), path })) }).then((explore) => ({ explore })),
+  });
   let control = handleProtocolMessage(message, options);
   if (!control.handled) {
     control = require('../mcp-contract').handleControlMessage(message, options);