smol-symphony 0.2.0 → 0.3.0

package/dist/src/core/runner/dispatch-config.js

@@ -0,0 +1,95 @@
+// FCIS rewrite — pure per-dispatch config resolution + eval-mode mount list.
+//
+// Functional core: every export here is a pure, synchronous (data) -> data
+// function. No IO, no clock, no randomness, no node: imports. Imports ONLY from
+// src/types. Ports the runner-facing half of the original
+// src/agent/runner.ts:resolveDispatchConfig / buildEvalModeMounts.
+//
+// WHY this slice exists separate from the per-knob resolvers in core/states.ts:
+// the runner pins ONE struct (adapter + model + effort + max_turns + eval_mode)
+// ONCE at the top of an attempt and reads everything downstream from it
+// (mustFix: config pinning). A workflow reload mid-attempt must NOT be able to
+// redirect the adapter / model / loop budget / mount set on the live VM. This
+// module produces that pinned struct + the derived eval-mode mounts.
+//
+// Override precedence (ported faithfully from the original resolveDispatchConfig):
+//   - adapter:    state.adapter   ?? acp.adapter
+//   - model:      state.model    === undefined ? acp.model  : state.model
+//   - effort:     state.effort   === undefined ? acp.effort : state.effort
+//                 (an explicit `null` on the state means "use the adapter's own
+//                  default", which is DISTINCT from "not declared" → inherit the
+//                  workflow-level default)
+//   - max_turns:  state.max_turns ?? agent.max_turns
+//   - eval_mode:  state.eval_mode === true   (any non-true value ⇒ off)
+import { resolveStateKey } from '../state-resolve.js';
+/**
+ * Fixed guest paths for the eval/debug read-only mounts. Hardcoded (not
+ * configurable) so the prompt body can reference them by literal path. Kept as
+ * exports for tests and any operator-facing surface that needs to mention them.
+ */
+export const EVAL_MODE_ISSUES_GUEST_PATH = '/symphony/issues';
+export const EVAL_MODE_LOGS_GUEST_PATH = '/symphony/logs';
+/**
+ * Resolve effective adapter/model/effort/max_turns/eval_mode for an issue's
+ * current state — the runner's dispatch-config pin. Per-state overrides declared
+ * under `states.<name>` win; otherwise the workflow-level `acp.adapter` /
+ * `acp.model` / `acp.effort` / `agent.max_turns` defaults apply.
+ *
+ * Takes the whole `ServiceConfig` because that is the runner's call shape (it
+ * pins this struct once and reads only from it thereafter, never from
+ * `cfg.acp.*` / `cfg.agent.max_turns` directly).
+ *
+ * Returns `Error` AS DATA when `state` is not declared (after case-insensitive
+ * canonicalization). The orchestrator should never dispatch an issue whose state
+ * is not declared (validateDispatch + reconciliation both gate on that), but
+ * defense in depth: a silent fallback here would mask a tracker/workflow drift
+ * bug as a confusing default-adapter run, so the caller gets an explicit error
+ * value to surface or throw at the IO boundary (functional core: no throwing for
+ * control flow).
+ */
+export function resolveDispatchConfig(cfg, state) {
+    const states = cfg.states;
+    const key = resolveStateKey(states, state);
+    if (key === null) {
+        const declared = Object.keys(states).join(', ');
+        return new Error(`resolveDispatchConfig: state "${state}" is not declared in workflow states (declared: ${declared.length > 0 ? declared : '<none>'})`);
+    }
+    const s = states[key];
+    const adapter = s.adapter ?? cfg.acp.adapter;
+    // Distinguish "not overridden" (undefined) from "explicitly null" (means: use
+    // the adapter default). Only fall back to the workflow-level value when the
+    // state did not declare the key at all.
+    const model = s.model === undefined ? cfg.acp.model : s.model;
+    const effort = s.effort === undefined ? cfg.acp.effort : s.effort;
+    const maxTurns = s.max_turns ?? cfg.agent.max_turns;
+    const evalMode = s.eval_mode === true;
+    return { adapter, model, effort, maxTurns, evalMode };
+}
+/**
+ * Derive the extra read-only bind mounts the eval/debug mode (issue 40)
+ * contributes for a single dispatch. Returns an empty list when the state did
+ * not opt in (`resolved.evalMode === false`) or when neither symphony state root
+ * is configured (defense in depth — the local tracker always sets `tracker.root`
+ * and the loader always sets `logs.root`, but a hand-built ServiceConfig in
+ * tests might not).
+ *
+ * The host paths come straight from config (the loader normalizes both roots to
+ * absolute); the guest paths are the fixed `EVAL_MODE_*` constants so the prompt
+ * body can reference them by literal path. `readonly: true` always — an in-VM
+ * eval/debug agent inspects symphony's own state but must never mutate it.
+ */
+export function buildEvalModeMounts(cfg, resolved) {
+    if (!resolved.evalMode)
+        return [];
+    const mounts = [];
+    const trackerRoot = cfg.tracker.root;
+    if (trackerRoot && trackerRoot.length > 0) {
+        mounts.push({ host: trackerRoot, guest: EVAL_MODE_ISSUES_GUEST_PATH, readonly: true });
+    }
+    const logsRoot = cfg.logs.root;
+    if (logsRoot && logsRoot.length > 0) {
+        mounts.push({ host: logsRoot, guest: EVAL_MODE_LOGS_GUEST_PATH, readonly: true });
+    }
+    return mounts;
+}
+//# sourceMappingURL=dispatch-config.js.map

package/dist/src/core/runner/dispatch-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch-config.js","sourceRoot":"","sources":["../../../../src/core/runner/dispatch-config.ts"],"names":[],"mappings":"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"}

package/dist/src/core/runner/injection.js

@@ -0,0 +1,61 @@
+// FCIS rewrite — pure runtime-injection fold for adapter dispatch.
+//
+// Ported faithfully from the reference `src/agent/runner.ts`
+// (`applyRuntimeInjections` + `applyModelInjection`) and the per-adapter
+// `ModelInjection`/`EffortInjection` channels declared by `src/agent/adapters.ts`.
+// The reference ran inside the async dispatch pipeline, but the composition was
+// already pure: a `(data) -> data` fold of the model + effort injections a
+// profile declares into one runtime descriptor across three orthogonal channels
+// (env vars, extra argv, staged guest files), with NO IO.
+//
+// Faithful semantics preserved from the reference:
+//   • model is folded BEFORE effort, so effort wins on env-key collisions; staged
+//     files from both are kept in order (`runtimeExtraFiles.push`).
+//   • model injection applies only when `model` is a non-empty string
+//     (reference: `if (resolved.model)`); effort applies only when `effort` is
+//     non-empty AND the profile declares an `effortInjection`.
+//   • staged files become guest files with mode 0o600.
+//   • adapter binary is `binary[0]`; effective argv is `binary.slice(1)` ++ folded args.
+/** Mode every staged guest file is written with (reference: `mode: 0o600`). */
+export const STAGED_FILE_MODE = 0o600;
+/**
+ * Fold one `ModelInjection` into the accumulator across the three channels,
+ * returning a NEW accumulator (no input mutation):
+ *   • env       — merged key-by-key, later value wins on collision.
+ *   • extraArgs — appended in order.
+ *   • stagedFiles → guest files at mode 0o600, appended in order.
+ */
+export function foldInjection(acc, inj) {
+    const runtimeEnv = { ...acc.runtimeEnv, ...inj.env };
+    const runtimeArgs = inj.extraArgs ? [...acc.runtimeArgs, ...inj.extraArgs] : [...acc.runtimeArgs];
+    const runtimeExtraFiles = [...acc.runtimeExtraFiles];
+    for (const f of inj.stagedFiles ?? []) {
+        runtimeExtraFiles.push({ guestPath: f.guestPath, content: f.content, mode: STAGED_FILE_MODE });
+    }
+    return { runtimeEnv, runtimeArgs, runtimeExtraFiles };
+}
+/**
+ * Compose a profile's model + effort injections into one runtime descriptor.
+ * The single decision-bearing function for this slice.
+ */
+export function applyRuntimeInjections(profile, choices) {
+    let acc = { runtimeEnv: {}, runtimeArgs: [], runtimeExtraFiles: [] };
+    if (isNonEmpty(choices.model))
+        acc = foldInjection(acc, profile.modelInjection(choices.model));
+    if (isNonEmpty(choices.effort) && profile.effortInjection) {
+        acc = foldInjection(acc, profile.effortInjection(choices.effort));
+    }
+    return {
+        adapterBin: profile.binary[0] ?? '',
+        effectiveAdapterArgs: [...profile.binary.slice(1), ...acc.runtimeArgs],
+        ...acc,
+    };
+}
+/**
+ * The reference applied an injection only on a truthy, non-empty string knob
+ * (`if (resolved.model)`); `null` and `''` both skip. Kept exactly.
+ */
+function isNonEmpty(value) {
+    return value !== null && value.length > 0;
+}
+//# sourceMappingURL=injection.js.map

package/dist/src/core/runner/injection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"injection.js","sourceRoot":"","sources":["../../../../src/core/runner/injection.ts"],"names":[],"mappings":"AAAA,mEAAmE;AACnE,EAAE;AACF,6DAA6D;AAC7D,yEAAyE;AACzE,mFAAmF;AACnF,gFAAgF;AAChF,2EAA2E;AAC3E,gFAAgF;AAChF,0DAA0D;AAC1D,EAAE;AACF,mDAAmD;AACnD,kFAAkF;AAClF,oEAAoE;AACpE,sEAAsE;AACtE,+EAA+E;AAC/E,+DAA+D;AAC/D,uDAAuD;AACvD,yFAAyF;AAWzF,+EAA+E;AAC/E,MAAM,CAAC,MAAM,gBAAgB,GAAG,KAAK,CAAC;AAItC;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,GAAgB,EAAE,GAAmB;IACjE,MAAM,UAAU,GAA2B,EAAE,GAAG,GAAG,CAAC,UAAU,EAAE,GAAG,GAAG,CAAC,GAAG,EAAE,CAAC;IAC7E,MAAM,WAAW,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,WAAW,EAAE,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,WAAW,CAAC,CAAC;IAClG,MAAM,iBAAiB,GAAoB,CAAC,GAAG,GAAG,CAAC,iBAAiB,CAAC,CAAC;IACtE,KAAK,MAAM,CAAC,IAAI,GAAG,CAAC,WAAW,IAAI,EAAE,EAAE,CAAC;QACtC,iBAAiB,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,SAAS,EAAE,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC,CAAC;IACjG,CAAC;IACD,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,iBAAiB,EAAE,CAAC;AACxD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,sBAAsB,CACpC,OAAuB,EACvB,OAAuB;IAEvB,IAAI,GAAG,GAAgB,EAAE,UAAU,EAAE,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE,iBAAiB,EAAE,EAAE,EAAE,CAAC;IAElF,IAAI,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,GAAG,GAAG,aAAa,CAAC,GAAG,EAAE,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;IAC/F,IAAI,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;QAC1D,GAAG,GAAG,aAAa,CAAC,GAAG,EAAE,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;IACpE,CAAC;IAED,OAAO;QACL,UAAU,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE;QACnC,oBAAoB,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,WAAW,CAAC;QACtE,GAAG,GAAG;KACP,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,SAAS,UAAU,CAAC,KAAoB;IACtC,OAAO,KAAK,KAAK,IAAI,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;AAC5C,CAAC"}

package/dist/src/core/runner/mise.js

@@ -0,0 +1,210 @@
+// FCIS rewrite — pure mise (jdx/mise) toolchain-provisioning deciders (issue 209).
+//
+// Functional core: every export is a pure, synchronous (data) -> data function or
+// a constant. No IO, no async, no clock, no randomness, no node: imports. Imports
+// ONLY type-only from src/types.
+//
+// The contract: the agent image ships ONLY the `mise` binary (+ glibc essentials).
+// node + the agent CLIs come from a STAGED mise SYSTEM config (/etc/mise/config.toml);
+// project toolchains come from the consuming repo's own mise.toml. Everything installs
+// into MISE_DATA_GUEST_DIR, which lives on the guest ROOTFS (ext4, ephemeral per VM) —
+// NOT a bind mount. The gondolin sandboxfs bind mount has no chmod opcode (chmod is a
+// silent no-op there), so mise's create-then-chmod extractor + npm postinstall produce
+// NON-executable binaries on it; the rootfs honors chmod, so installs land executable
+// (issue 222). The pure downloads — node tarballs + npm packages, no exec bit needed —
+// DO persist on a sandboxfs bind mount (MISE_CACHE_GUEST_DIR) so a cold install isn't
+// re-downloaded every dispatch.
+//
+// These deciders assemble the data the shell EXECUTES: the download-cache mount, the boot
+// env (MISE_DATA_DIR + MISE_YES + npm_config_cache), the staged system-config guest file,
+// the pre-install prep argv (point mise's downloads at the cache), and the
+// `mise trust … && mise install` argv. The actual execs (mount, stage, prep, install,
+// probe) live in the shell dispatcher.
+// ─── fixed guest-side constants ────────────────────────────────────────────────
+/**
+ * Guest path mise installs the toolchain into. Lives on the guest ROOTFS (ext4,
+ * unmounted, ephemeral per VM) — NOT a bind mount — so mise's create-then-chmod installs
+ * land executable (the sandboxfs bind mount silently drops chmod; issue 222).
+ */
+export const MISE_DATA_GUEST_DIR = '/opt/symphony/mise-data';
+/**
+ * Guest shims dir mise populates under the data dir. Prepended to the probe/launch
+ * PATH so the agent's CHILD processes (project build/test) resolve the project's
+ * tools; the AGENT runtime node is resolved separately via `mise which node` so a
+ * project mise.toml can't downgrade it (see {@link miseNodeResolveExpr}).
+ */
+export const MISE_SHIMS_GUEST_DIR = `${MISE_DATA_GUEST_DIR}/shims`;
+/**
+ * Guest mount point for the persistent mise DOWNLOAD CACHE — the host
+ * `gondolin.mise.data_dir` bind-mounted RW here (issue 222). Downloads are pure data
+ * (node tarballs + npm packages; no exec bit), so they live safely on the sandboxfs bind
+ * mount the install dir can't use. mise's tool-download dir + npm's package cache point
+ * here (see {@link buildMisePrepCommand} + {@link buildMiseEnv}) so a cold install isn't
+ * re-fetched every dispatch.
+ */
+export const MISE_CACHE_GUEST_DIR = '/opt/symphony/mise-cache';
+/** Guest path the symphony-bundled mise SYSTEM config is staged at (lowest precedence). */
+export const MISE_SYSTEM_CONFIG_GUEST_PATH = '/etc/mise/config.toml';
+/**
+ * The egress hosts the staged SYSTEM config's tools need so `mise install` can fetch
+ * node (mise's node backend → nodejs.org) + the agent CLIs (the `npm:` backend →
+ * registry.npmjs.org), mise's own registry metadata (mise.jdx.dev), and mise's
+ * precompiled tool-version lists (mise-versions.jdx.dev — `GET /tools/node.toml`, the
+ * version index `node@<N>` resolves against on a cold mise cache; issues 223 + 231).
+ * Always seeded into the egress allowlist DEFAULT (parse.ts; mise provisioning is
+ * unconditional, issue 233) so the firewall doesn't silently block provisioning.
+ * PROJECT toolchains may need MORE
+ * per-tool hosts (rustup → static.rust-lang.org, gradle → services.gradle.org, JDK →
+ * api.adoptium.net); the consuming repo adds those to `egress.allowed_hosts` (which
+ * REPLACES this default). SECURITY: firewall hosts only — no credential is ever
+ * substituted for these.
+ */
+export const MISE_EGRESS_HOSTS = [
+    'nodejs.org',
+    'registry.npmjs.org',
+    'mise.jdx.dev',
+    'mise-versions.jdx.dev',
+];
+/** Non-secret mode for the staged system config — it is config, not a credential. */
+export const MISE_SYSTEM_CONFIG_MODE = 0o644;
+/**
+ * Project-config filenames mise recognises in a workspace. Used by
+ * {@link hasProjectMiseConfig} to detect whether the consuming repo contributes its
+ * own toolchains on top of the staged system config (purely informational — the
+ * `mise install` cwd=workspace picks them up regardless).
+ */
+export const MISE_PROJECT_CONFIG_FILENAMES = [
+    'mise.toml',
+    '.mise.toml',
+    'mise.local.toml',
+    '.mise.local.toml',
+    '.tool-versions',
+];
+// ─── POSIX single-quote-safe shell quoting (pure) ──────────────────────────────
+/**
+ * Wrap a value in single quotes, escaping any embedded single quote via the
+ * canonical `'\''` close-escape-reopen trick. Used for EVERY host-controlled value
+ * interpolated into a `/bin/sh -c '…'` guest script (the workspace path, the system
+ * config path, the adapter name) so a `'` cannot break out and inject commands.
+ */
+export function shQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+// ─── env / mount / staged file ─────────────────────────────────────────────────
+/**
+ * The mise boot/exec env. `MISE_DATA_DIR` points mise at the rootfs install dir (where
+ * chmod works); `MISE_YES=1` answers mise's trust/confirm prompts (the staged + project
+ * configs are symphony-managed); `npm_config_cache` points the `npm:`-backend package
+ * cache at the persistent sandboxfs download cache so it survives across dispatches
+ * (issue 222). Always populated — mise provisioning is unconditional (issue 233).
+ */
+export function buildMiseEnv() {
+    return {
+        MISE_DATA_DIR: MISE_DATA_GUEST_DIR,
+        MISE_YES: '1',
+        npm_config_cache: `${MISE_CACHE_GUEST_DIR}/npm`,
+    };
+}
+/**
+ * The symphony-managed mise DOWNLOAD-CACHE mount (host `data_dir` → guest cache dir, RW).
+ * Always returned — mise provisioning is unconditional (issue 233). The host dir is
+ * bind-mounted at MISE_CACHE_GUEST_DIR — NOT the install dir: installs need chmod
+ * (rootfs only), but the cached downloads are pure data the sandboxfs bind mount holds
+ * fine (issue 222). NOT a user `gondolin.volumes` entry — the runner owns it.
+ */
+export function buildMiseMount(cfg) {
+    // ensureHostDir: the cache dir is symphony-managed — the VM adapter mkdir -p's the
+    // host path before mounting it RW (it may not exist on a fresh host / custom dir).
+    return { host: cfg.gondolin.mise.data_dir, guest: MISE_CACHE_GUEST_DIR, readonly: false, ensureHostDir: true };
+}
+/**
+ * The pre-install prep argv (issue 222), run with cwd = workspace BEFORE `mise install`.
+ * Creates the rootfs install dir + the persistent cache subdirs, then symlinks mise's
+ * tool-DOWNLOAD dir (`<data>/downloads`) onto the persistent cache (`<cache>/downloads`)
+ * so node tarballs + extracted-source downloads survive across dispatches while the
+ * installs/extracts themselves stay on the chmod-capable rootfs `<data>`. `ln -sfn`
+ * replaces any stale link in place (the `-n` keeps it from descending into an existing
+ * symlinked dir). Best-effort in the shell: a failure just costs a cold re-download, not a
+ * broken install. Every path is a fixed symphony-owned constant (no host input → no
+ * shell-injection surface, unlike {@link buildMiseInstallCommand}).
+ */
+export function buildMisePrepCommand() {
+    const script = `mkdir -p ${MISE_DATA_GUEST_DIR} ${MISE_CACHE_GUEST_DIR}/downloads ${MISE_CACHE_GUEST_DIR}/npm && ` +
+        `ln -sfn ${MISE_CACHE_GUEST_DIR}/downloads ${MISE_DATA_GUEST_DIR}/downloads`;
+    return ['/bin/sh', '-c', script];
+}
+/** The symphony-bundled mise SYSTEM config as a staged guest file. Carries no secret → 0644. */
+export function miseSystemConfigFile(source) {
+    return { guestPath: MISE_SYSTEM_CONFIG_GUEST_PATH, content: source, mode: MISE_SYSTEM_CONFIG_MODE };
+}
+// ─── install command ───────────────────────────────────────────────────────────
+/**
+ * The `mise trust … && mise install` argv the shell runs with cwd = workspace
+ * (installs the merged SYSTEM + project tool set). Trust is best-effort (`|| true`)
+ * for both the staged system config and the workspace so a project WITHOUT a mise
+ * config does not fail the chain; `exec mise install` then governs the exit code.
+ * mise provisioning is unconditional (issue 233), so the shell always runs it.
+ */
+export function buildMiseInstallCommand(workspacePath) {
+    const script = `mise trust ${shQuote(MISE_SYSTEM_CONFIG_GUEST_PATH)} >/dev/null 2>&1 || true; ` +
+        `mise trust ${shQuote(workspacePath)} >/dev/null 2>&1 || true; ` +
+        `exec mise install`;
+    return ['/bin/sh', '-c', script];
+}
+/**
+ * Operator-facing message for a failed in-guest `mise install` (issue 209). Thrown
+ * by the shell dispatcher as a ByoContractError before the agent launches, so a
+ * toolchain-provisioning failure surfaces with the guest's own stderr tail rather
+ * than a later opaque ENOENT (no node / no adapter shim). `code` is the exec exit.
+ */
+export function miseInstallFailureMessage(code, stderr) {
+    const tail = stderr.trim();
+    const detail = tail ? ` Guest stderr: ${tail}` : '';
+    return (`mise install failed (exit ${code}) while provisioning the agent toolchain ` +
+        `(node + the agent CLIs from the staged SYSTEM config, plus any project mise.toml). ` +
+        `Check the agent image ships \`mise\`, the egress allowlist reaches the tool hosts ` +
+        `(nodejs.org / registry.npmjs.org / the mise registry), and the data dir is writable.` +
+        detail);
+}
+// ─── project-config detection ──────────────────────────────────────────────────
+/**
+ * Whether the workspace ships its own mise project config (so it contributes
+ * toolchains on top of the staged system config). Purely informational — the shell
+ * uses it for an operator log line; `mise install` picks up the project config
+ * regardless.
+ */
+export function hasProjectMiseConfig(workspaceEntries) {
+    return workspaceEntries.some((e) => MISE_PROJECT_CONFIG_FILENAMES.includes(e));
+}
+// ─── node resolution (load-bearing) ────────────────────────────────────────────
+/**
+ * The shell `$(…)` expression the BYO probe captures into $NODE_PATH to resolve the
+ * AGENT runtime node to a concrete, SYSTEM-scoped absolute path: `mise which node`
+ * run from `/`. mise provisioning is the only toolchain path (issue 233), so this is
+ * unconditional. Resolving from `/` matters: a project's mise.toml can override `node`
+ * in the workspace and the mise `node` shim re-resolves the version BY CWD, so running
+ * from the workspace would launch the AGENT (which must stay Node ≥ 21 for the
+ * launcher's global WebSocket) on the project's node. Resolving from `/` applies only
+ * the staged SYSTEM config, pinning the agent's node; the agent's CHILD processes still
+ * get the project node via the workspace shims on PATH.
+ */
+export function miseNodeResolveExpr() {
+    return `$(cd / && mise which node)`;
+}
+/**
+ * The full `/bin/sh -c` BYO pre-launch probe script (issue 209 moved it into core so
+ * the `mise which node` resolution is a unit-testable decision). Resolves the agent
+ * node (system-scoped) + the adapter CLI (a mise shim on PATH), asserts Node ≥ 21 /
+ * the global WebSocket, confirms the staged launcher materialized, then prints
+ * `<node>\n<adapter>`. Every host-controlled value is shQuoted. The shell runs this
+ * and maps a non-zero exit via byoProbeFailureMessage.
+ */
+export function buildByoProbeScript(adapterName, launcherGuestPath) {
+    return (`set -e; ` +
+        `NODE_PATH=${miseNodeResolveExpr()} || { echo "MISSING_NODE" >&2; exit 11; }; ` +
+        `ADAPTER_PATH=$(command -v ${shQuote(adapterName)}) || { echo "MISSING_ADAPTER" >&2; exit 12; }; ` +
+        `"$NODE_PATH" -e 'process.exit(typeof WebSocket==="function"?0:21)' || { echo "NODE_TOO_OLD" >&2; exit 21; }; ` +
+        `test -f ${shQuote(launcherGuestPath)} || { echo "MISSING_LAUNCHER" >&2; exit 13; }; ` +
+        `printf '%s\\n%s\\n' "$NODE_PATH" "$ADAPTER_PATH"`);
+}
+//# sourceMappingURL=mise.js.map

package/dist/src/core/runner/mise.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mise.js","sourceRoot":"","sources":["../../../../src/core/runner/mise.ts"],"names":[],"mappings":"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"}