agent-trellis 0.2.0 → 0.4.0

package/dist/lib/terminalPicker.js

@@ -0,0 +1,193 @@
+/**
+ * Minimal, dependency-free arrow-key/checkbox terminal picker
+ * (trellis-onboard-interactive-picker design.md D1) — the interaction
+ * surface `trellis onboard`'s two prompts need (at most four rows, no
+ * search, no pagination) doesn't need a full prompt library; this
+ * hand-rolls just enough raw-mode key handling and ANSI rendering for
+ * that bounded case, matching the project's existing narrow-dependency
+ * precedent (src/lib/envVarNames.ts, src/lib/secretEnv.ts).
+ *
+ * `input`/`output` are injectable (never a CLI flag) purely so tests can
+ * drive the real key-parsing/render loop against a plain stream instead
+ * of a real TTY — same seam pattern (`homeDir`, etc.) used everywhere
+ * else in this project.
+ */
+function defaultStreams() {
+    return { input: process.stdin, output: process.stdout };
+}
+/**
+ * True only when both streams are real, raw-mode-capable terminals — the
+ * exact gate deciding picker vs. the pre-existing numbered-typing prompt
+ * (design.md D2). A stream lacking `setRawMode` (piped input, some
+ * minimal TTYs) always falls back, never hangs or guesses.
+ */
+export function canUseInteractivePicker(streams = defaultStreams()) {
+    const input = streams.input;
+    const output = streams.output;
+    return Boolean(input.isTTY && output.isTTY && typeof input.setRawMode === "function");
+}
+/** Wrapping index navigation — pure, exported for direct unit testing. */
+export function nextIndex(current, delta, length) {
+    return ((current + delta) % length + length) % length;
+}
+/** Pure single-index toggle — exported for direct unit testing. */
+export function toggled(checked, index) {
+    const next = [...checked];
+    next[index] = !next[index];
+    return next;
+}
+const ESC = "\u001b";
+const CTRL_C = "\u0003";
+const HIDE_CURSOR = `${ESC}[?25l`;
+const SHOW_CURSOR = `${ESC}[?25h`;
+/** Parses one raw input chunk into a single logical key — arrow escape
+ * sequences, j/k, space, enter, or Ctrl+C. Anything else is ignored. */
+function parseKey(chunk) {
+    if (chunk === CTRL_C)
+        return "cancel";
+    if (chunk === "\r" || chunk === "\n")
+        return "confirm";
+    if (chunk === " ")
+        return "toggle";
+    if (chunk === `${ESC}[A` || chunk === "k")
+        return "up";
+    if (chunk === `${ESC}[B` || chunk === "j")
+        return "down";
+    return null;
+}
+function withRawMode(streams, body) {
+    const input = streams.input;
+    const output = streams.output;
+    const canSetRawMode = typeof input.setRawMode === "function";
+    if (canSetRawMode)
+        input.setRawMode(true);
+    input.resume();
+    input.setEncoding("utf-8");
+    output.write(HIDE_CURSOR);
+    const restore = () => {
+        output.write(SHOW_CURSOR);
+        if (canSetRawMode)
+            input.setRawMode(false);
+        input.pause();
+    };
+    // Second-layer safety net (design.md D6): a thrown error the caller's
+    // own try/finally doesn't get a chance to run for (process killed
+    // externally) must still not leave the terminal in raw mode/cursor
+    // hidden.
+    process.once("exit", restore);
+    return body().finally(() => {
+        restore();
+        process.removeListener("exit", restore);
+    });
+}
+function moveCursorUp(output, lines) {
+    if (lines > 0)
+        output.write(`${ESC}[${lines}A`);
+}
+function clearLines(output, lines) {
+    for (let i = 0; i < lines; i++) {
+        output.write(`${ESC}[2K`);
+        if (i < lines - 1)
+            output.write(`${ESC}[1B`);
+    }
+    moveCursorUp(output, lines - 1);
+}
+function renderRows(output, rows, previousRowCount) {
+    if (previousRowCount > 0) {
+        clearLines(output, previousRowCount);
+    }
+    for (const row of rows) {
+        output.write(`${row}\n`);
+    }
+}
+function highlightRow(text, isHighlighted) {
+    return isHighlighted ? `> ${ESC}[7m${text}${ESC}[0m` : `  ${text}`;
+}
+/**
+ * Single-select: Up/Down/j/k moves the highlight, Enter confirms. Resolves
+ * the confirmed index, or `null` on Ctrl+C cancel. Caller (onboard.ts)
+ * must have already confirmed `canUseInteractivePicker()` — this function
+ * does not re-check, and assumes `streams.input` genuinely supports raw
+ * mode.
+ */
+export async function runSingleSelectPicker(items, streams = defaultStreams()) {
+    const { input, output } = streams;
+    return withRawMode(streams, () => {
+        return new Promise((resolve) => {
+            let highlighted = 0;
+            let rowCount = 0;
+            const draw = () => {
+                const rows = items.map((label, i) => highlightRow(label, i === highlighted));
+                renderRows(output, rows, rowCount);
+                rowCount = rows.length;
+            };
+            draw();
+            const onData = (chunk) => {
+                const key = parseKey(chunk.toString("utf-8"));
+                if (key === "up") {
+                    highlighted = nextIndex(highlighted, -1, items.length);
+                    draw();
+                }
+                else if (key === "down") {
+                    highlighted = nextIndex(highlighted, 1, items.length);
+                    draw();
+                }
+                else if (key === "confirm") {
+                    input.removeListener("data", onData);
+                    resolve(highlighted);
+                }
+                else if (key === "cancel") {
+                    input.removeListener("data", onData);
+                    resolve(null);
+                }
+            };
+            input.on("data", onData);
+        });
+    });
+}
+/**
+ * Multi-select (checkbox): Up/Down/j/k moves the highlight, Space toggles
+ * the current row, Enter confirms. Resolves the checked indices at
+ * confirm time, or `null` on Ctrl+C cancel. Same precondition as
+ * `runSingleSelectPicker`.
+ */
+export async function runMultiSelectPicker(items, initiallyChecked, streams = defaultStreams()) {
+    const { input, output } = streams;
+    return withRawMode(streams, () => {
+        return new Promise((resolve) => {
+            let highlighted = 0;
+            let checked = [...initiallyChecked];
+            let rowCount = 0;
+            const draw = () => {
+                const rows = items.map((label, i) => highlightRow(`[${checked[i] ? "x" : " "}] ${label}`, i === highlighted));
+                renderRows(output, rows, rowCount);
+                rowCount = rows.length;
+            };
+            draw();
+            const onData = (chunk) => {
+                const key = parseKey(chunk.toString("utf-8"));
+                if (key === "up") {
+                    highlighted = nextIndex(highlighted, -1, items.length);
+                    draw();
+                }
+                else if (key === "down") {
+                    highlighted = nextIndex(highlighted, 1, items.length);
+                    draw();
+                }
+                else if (key === "toggle") {
+                    checked = toggled(checked, highlighted);
+                    draw();
+                }
+                else if (key === "confirm") {
+                    input.removeListener("data", onData);
+                    resolve(checked.flatMap((isChecked, i) => (isChecked ? [i] : [])));
+                }
+                else if (key === "cancel") {
+                    input.removeListener("data", onData);
+                    resolve(null);
+                }
+            };
+            input.on("data", onData);
+        });
+    });
+}

package/dist/lib/tomlSection.d.ts

@@ -23,10 +23,11 @@ export interface SectionRange {
  */
 export declare function findSection(content: string, header: string): SectionRange | null;
 /**
- * Returns the current stored text of `[mcp_servers.<name>]` (or `null` if
- * it doesn't exist), for comparing against `renderServerSection`'s output
- * to decide create/repair vs. no-op — exact text equality is enough here,
- * no parsing needed on either side.
+ * Returns the current stored text of a server's full owned range (see
+ * `findServerRange`) — or `null` if it doesn't exist — for comparing
+ * against `renderServerSection`'s output to decide create/repair vs.
+ * no-op. Exact text equality is enough here, no parsing needed on either
+ * side.
  */
 export declare function currentServerSectionText(content: string, name: string): string | null;
 /**
@@ -40,9 +41,22 @@ export declare function currentServerSectionText(content: string, name: string):
  * than this function silently rendering nothing for it.
  */
 export declare function codexBearerTokenEnvVar(def: McpServerDef): string | undefined;
-/** Renders a `[mcp_servers.<name>]` block for a bounded, known shape —
- * this is templating, not general TOML serialization. */
+/** Renders a `[mcp_servers.<name>]` block (plus, when `staticEnv` is set,
+ * an immediately-adjacent `[mcp_servers.<name>.env]` block — see
+ * `findServerRange`) for a bounded, known shape — this is templating,
+ * not general TOML serialization. */
 export declare function renderServerSection(name: string, def: McpServerDef): string;
+/**
+ * Reads a server's `[mcp_servers.<name>.env]` table's literal key-value
+ * pairs directly from real `config.toml` text — the exact inverse of
+ * `renderServerSection`'s own `static_env` block, the only piece of a
+ * Codex server's `static_env` that `codex mcp list --json` cannot ever
+ * report (it only exposes `env_vars`, i.e. names, from the *main*
+ * table — trellis-migrate-mcp-servers design.md D3). Returns `undefined`
+ * if the table doesn't exist; a malformed line inside it is skipped, not
+ * fatal, matching `parseMemoryGraph`'s own tolerant-parse precedent.
+ */
+export declare function readServerEnvTable(content: string, name: string): Record<string, string> | undefined;
 /**
  * Replaces an existing section in place, or appends a new one at EOF
  * (with a leading blank-line separator) if none exists yet. Never touches

package/dist/lib/tomlSection.js

@@ -36,6 +36,9 @@ function tomlStringArray(values) {
 function serverHeader(name) {
     return `mcp_servers.${tomlKeySegment(name)}`;
 }
+function envHeader(name) {
+    return `${serverHeader(name)}.env`;
+}
 /**
  * Finds an existing `[header]` table's exact line range: `start` is the
  * header line itself, `end` is the line before the next table header (any
@@ -70,14 +73,42 @@ export function findSection(content, header) {
     return { start, end };
 }
 /**
- * Returns the current stored text of `[mcp_servers.<name>]` (or `null` if
- * it doesn't exist), for comparing against `renderServerSection`'s output
- * to decide create/repair vs. no-op — exact text equality is enough here,
- * no parsing needed on either side.
+ * A server's full owned range: its main `[mcp_servers.<name>]` table,
+ * extended to also cover an immediately-following `[mcp_servers.<name>.env]`
+ * table (skipping only blank/comment padding in between — the same skip
+ * rule `findSection`'s own trailing trim already applies) when one is
+ * present. The two are rendered and managed as one atomic unit whenever
+ * `staticEnv` is set (trellis-mcp-static-env-and-disabled-servers
+ * design.md D3) — create/repair/remove must never touch one without the
+ * other.
+ */
+function findServerRange(content, name) {
+    const main = findSection(content, serverHeader(name));
+    if (!main) {
+        return null;
+    }
+    const lines = content.split("\n");
+    let i = main.end + 1;
+    while (i < lines.length && (lines[i].trim() === "" || lines[i].trim().startsWith("#"))) {
+        i += 1;
+    }
+    if (i < lines.length && lines[i].trim() === `[${envHeader(name)}]`) {
+        const envRange = findSection(content, envHeader(name));
+        if (envRange) {
+            return { start: main.start, end: envRange.end };
+        }
+    }
+    return main;
+}
+/**
+ * Returns the current stored text of a server's full owned range (see
+ * `findServerRange`) — or `null` if it doesn't exist — for comparing
+ * against `renderServerSection`'s output to decide create/repair vs.
+ * no-op. Exact text equality is enough here, no parsing needed on either
+ * side.
  */
 export function currentServerSectionText(content, name) {
-    const header = serverHeader(name);
-    const range = findSection(content, header);
+    const range = findServerRange(content, name);
     if (!range) {
         return null;
     }
@@ -103,8 +134,10 @@ export function codexBearerTokenEnvVar(def) {
         return undefined;
     return BEARER_TOKEN_VALUE_RE.exec(value)?.[1];
 }
-/** Renders a `[mcp_servers.<name>]` block for a bounded, known shape —
- * this is templating, not general TOML serialization. */
+/** Renders a `[mcp_servers.<name>]` block (plus, when `staticEnv` is set,
+ * an immediately-adjacent `[mcp_servers.<name>.env]` block — see
+ * `findServerRange`) for a bounded, known shape — this is templating,
+ * not general TOML serialization. */
 export function renderServerSection(name, def) {
     const lines = [`[${serverHeader(name)}]`];
     if (def.transport === "stdio") {
@@ -122,16 +155,50 @@ export function renderServerSection(name, def) {
         if (bearerEnvVar)
             lines.push(`bearer_token_env_var = ${tomlString(bearerEnvVar)}`);
     }
+    const staticEnvEntries = Object.entries(def.staticEnv ?? {});
+    if (staticEnvEntries.length > 0) {
+        lines.push(`[${envHeader(name)}]`);
+        for (const [key, value] of staticEnvEntries) {
+            lines.push(`${tomlKeySegment(key)} = ${tomlString(value)}`);
+        }
+    }
     return lines.join("\n");
 }
+const ENV_TABLE_LINE_RE = /^("(?:[^"\\]|\\.)*"|[A-Za-z0-9_-]+)\s*=\s*("(?:[^"\\]|\\.)*")\s*$/;
+/**
+ * Reads a server's `[mcp_servers.<name>.env]` table's literal key-value
+ * pairs directly from real `config.toml` text — the exact inverse of
+ * `renderServerSection`'s own `static_env` block, the only piece of a
+ * Codex server's `static_env` that `codex mcp list --json` cannot ever
+ * report (it only exposes `env_vars`, i.e. names, from the *main*
+ * table — trellis-migrate-mcp-servers design.md D3). Returns `undefined`
+ * if the table doesn't exist; a malformed line inside it is skipped, not
+ * fatal, matching `parseMemoryGraph`'s own tolerant-parse precedent.
+ */
+export function readServerEnvTable(content, name) {
+    const range = findSection(content, envHeader(name));
+    if (!range) {
+        return undefined;
+    }
+    const lines = content.split("\n").slice(range.start + 1, range.end + 1);
+    const result = {};
+    for (const line of lines) {
+        const match = ENV_TABLE_LINE_RE.exec(line.trim());
+        if (!match)
+            continue;
+        const rawKey = match[1];
+        const key = rawKey.startsWith('"') ? JSON.parse(rawKey) : rawKey;
+        result[key] = JSON.parse(match[2]);
+    }
+    return result;
+}
 /**
  * Replaces an existing section in place, or appends a new one at EOF
  * (with a leading blank-line separator) if none exists yet. Never touches
  * any line outside the section it locates or the single appended block.
  */
 export function upsertSection(content, name, def) {
-    const header = serverHeader(name);
-    const existing = findSection(content, header);
+    const existing = findServerRange(content, name);
     const newLines = renderServerSection(name, def).split("\n");
     if (existing) {
         const lines = content.split("\n");
@@ -147,8 +214,7 @@ export function upsertSection(content, name, def) {
  * No-op if the section doesn't exist — idempotent.
  */
 export function removeSection(content, name) {
-    const header = serverHeader(name);
-    const existing = findSection(content, header);
+    const existing = findServerRange(content, name);
     if (!existing) {
         return content;
     }

package/dist/pi-bridge/bundle.js

@@ -7818,7 +7818,7 @@ var require_identity = __commonJS({
     var NODE_TYPE = /* @__PURE__ */ Symbol.for("yaml.node.type");
     var isAlias = (node2) => !!node2 && typeof node2 === "object" && node2[NODE_TYPE] === ALIAS;
     var isDocument = (node2) => !!node2 && typeof node2 === "object" && node2[NODE_TYPE] === DOC;
-    var isMap = (node2) => !!node2 && typeof node2 === "object" && node2[NODE_TYPE] === MAP;
+    var isMap2 = (node2) => !!node2 && typeof node2 === "object" && node2[NODE_TYPE] === MAP;
     var isPair = (node2) => !!node2 && typeof node2 === "object" && node2[NODE_TYPE] === PAIR;
     var isScalar = (node2) => !!node2 && typeof node2 === "object" && node2[NODE_TYPE] === SCALAR;
     var isSeq = (node2) => !!node2 && typeof node2 === "object" && node2[NODE_TYPE] === SEQ;
@@ -7854,7 +7854,7 @@ var require_identity = __commonJS({
     exports.isAlias = isAlias;
     exports.isCollection = isCollection;
     exports.isDocument = isDocument;
-    exports.isMap = isMap;
+    exports.isMap = isMap2;
     exports.isNode = isNode;
     exports.isPair = isPair;
     exports.isScalar = isScalar;
@@ -11966,9 +11966,9 @@ var require_resolve_flow_collection = __commonJS({
     var blockMsg = "Block collections are not allowed within flow collections";
     var isBlock = (token) => token && (token.type === "block-map" || token.type === "block-seq");
     function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onError, tag) {
-      const isMap = fc.start.source === "{";
-      const fcName = isMap ? "flow map" : "flow sequence";
-      const NodeClass = tag?.nodeClass ?? (isMap ? YAMLMap.YAMLMap : YAMLSeq.YAMLSeq);
+      const isMap2 = fc.start.source === "{";
+      const fcName = isMap2 ? "flow map" : "flow sequence";
+      const NodeClass = tag?.nodeClass ?? (isMap2 ? YAMLMap.YAMLMap : YAMLSeq.YAMLSeq);
       const coll = new NodeClass(ctx.schema);
       coll.flow = true;
       const atRoot = ctx.atRoot;
@@ -12004,7 +12004,7 @@ var require_resolve_flow_collection = __commonJS({
             offset = props.end;
             continue;
           }
-          if (!isMap && ctx.options.strict && utilContainsNewline.containsNewline(key))
+          if (!isMap2 && ctx.options.strict && utilContainsNewline.containsNewline(key))
             onError(
               key,
               // checked by containsNewline()
@@ -12044,7 +12044,7 @@ var require_resolve_flow_collection = __commonJS({
             }
           }
         }
-        if (!isMap && !sep && !props.found) {
+        if (!isMap2 && !sep && !props.found) {
           const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep, null, props, onError);
           coll.items.push(valueNode);
           offset = valueNode.range[2];
@@ -12067,7 +12067,7 @@ var require_resolve_flow_collection = __commonJS({
             startOnNewline: false
           });
           if (valueProps.found) {
-            if (!isMap && !props.found && ctx.options.strict) {
+            if (!isMap2 && !props.found && ctx.options.strict) {
               if (sep)
                 for (const st of sep) {
                   if (st === valueProps.found)
@@ -12099,7 +12099,7 @@ var require_resolve_flow_collection = __commonJS({
           const pair = new Pair.Pair(keyNode, valueNode);
           if (ctx.options.keepSourceTokens)
             pair.srcToken = collItem;
-          if (isMap) {
+          if (isMap2) {
             const map = coll;
             if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode))
               onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
@@ -12115,7 +12115,7 @@ var require_resolve_flow_collection = __commonJS({
           offset = valueNode ? valueNode.range[2] : valueProps.end;
         }
       }
-      const expectedEnd = isMap ? "}" : "]";
+      const expectedEnd = isMap2 ? "}" : "]";
       const [ce, ...ee] = fc.end;
       let cePos = offset;
       if (ce?.source === expectedEnd)
@@ -15016,7 +15016,7 @@ var require_public_api = __commonJS({
         return docs;
       return Object.assign([], { empty: true }, composer$1.streamInfo());
     }
-    function parseDocument(source, options = {}) {
+    function parseDocument2(source, options = {}) {
       const { lineCounter: lineCounter2, prettyErrors } = parseOptions(options);
       const parser$1 = new parser.Parser(lineCounter2?.addNewLine);
       const composer$1 = new composer.Composer(options);
@@ -15042,7 +15042,7 @@ var require_public_api = __commonJS({
       } else if (options === void 0 && reviver && typeof reviver === "object") {
         options = reviver;
       }
-      const doc = parseDocument(src, options);
+      const doc = parseDocument2(src, options);
       if (!doc)
         return null;
       doc.warnings.forEach((warning) => log.warn(doc.options.logLevel, warning));
@@ -15078,7 +15078,7 @@ var require_public_api = __commonJS({
     }
     exports.parse = parse3;
     exports.parseAllDocuments = parseAllDocuments;
-    exports.parseDocument = parseDocument;
+    exports.parseDocument = parseDocument2;
     exports.stringify = stringify;
   }
 });
@@ -27243,7 +27243,7 @@ import { homedir as homedir2 } from "node:os";
 
 // src/core/canonical.ts
 var import_yaml = __toESM(require_dist2(), 1);
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, join } from "node:path";
 
@@ -27260,6 +27260,10 @@ function resolveScope(scope, managedAgents) {
 }
 
 // src/core/canonical.ts
+function fromServerDefYaml(def) {
+  const { static_env, ...rest } = def;
+  return static_env ? { ...rest, staticEnv: static_env } : rest;
+}
 function trellisRoot(homeDir) {
   return join(homeDir, ".trellis");
 }
@@ -27303,8 +27307,9 @@ function loadServersYaml(path) {
     return { servers: {}, knownHostInjected: [] };
   }
   const parsed = (0, import_yaml.parse)(readFileSync(path, "utf-8")) ?? {};
+  const servers = Object.fromEntries(Object.entries(parsed.servers ?? {}).map(([name, def]) => [name, fromServerDefYaml(def)]));
   return {
-    servers: parsed.servers ?? {},
+    servers,
     knownHostInjected: parsed.known_host_injected ?? [],
     hub: parsed.hub
   };
@@ -27416,6 +27421,33 @@ function codexBearerTokenEnvVar(def) {
   return BEARER_TOKEN_VALUE_RE.exec(value)?.[1];
 }
 
+// src/lib/secretEnv.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+var LINE_RE = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/;
+function parseDotenv(content) {
+  const result = {};
+  for (const rawLine of content.split("\n")) {
+    const line = rawLine.trim();
+    if (line === "" || line.startsWith("#")) continue;
+    const match = LINE_RE.exec(line);
+    if (match) result[match[1]] = match[2];
+  }
+  return result;
+}
+function loadEnvFile(path) {
+  return existsSync2(path) ? parseDotenv(readFileSync2(path, "utf-8")) : {};
+}
+function resolveSecretEnv(names, policy) {
+  const result = {};
+  if (policy.envFile) {
+    const map = loadEnvFile(policy.envFile);
+    for (const name of names) result[name] = map[name];
+  } else {
+    for (const name of names) result[name] = process.env[name];
+  }
+  return result;
+}
+
 // src/adapters/mcpPlan.ts
 var HUB_ENTRY_NAME = "trellis-hub";
 var CODEX_STDIO_URL_CRASH_NOTE = ' On Codex specifically, this crashes the entire process at startup ("url is not supported for stdio"), not just this one server \u2014 see docs/research.md.';
@@ -27429,7 +27461,9 @@ var DANGEROUS_LITERAL_PATTERNS = [
   { label: "mcp-router token (mcpr_)", pattern: /mcpr_/ }
 ];
 function findLiteralSecret(def) {
-  const candidates = [def.command, def.url, ...def.args ?? [], ...Object.values(def.headers ?? {})].filter((v) => typeof v === "string");
+  const candidates = [def.command, def.url, ...def.args ?? [], ...Object.values(def.headers ?? {}), ...Object.values(def.staticEnv ?? {})].filter(
+    (v) => typeof v === "string"
+  );
   for (const candidate of candidates) {
     for (const { label, pattern } of DANGEROUS_LITERAL_PATTERNS) {
       if (pattern.test(candidate)) {
@@ -27439,7 +27473,13 @@ function findLiteralSecret(def) {
   }
   return void 0;
 }
-function resolveMcpPlan(agentId, mcp, managedAgents) {
+function findUnresolvedEnvName(def, policy) {
+  const names = def.env ?? [];
+  if (names.length === 0) return void 0;
+  const resolved = resolveSecretEnv(names, policy);
+  return names.find((name) => !resolved[name]);
+}
+function resolveMcpPlan(agentId, mcp, managedAgents, policy) {
   if (mcp.hub) {
     if (mcp.knownHostInjected.includes(HUB_ENTRY_NAME)) {
       return { desired: [], conflicts: [{ name: HUB_ENTRY_NAME, message: collisionMessage(HUB_ENTRY_NAME, agentId) }] };
@@ -27449,6 +27489,9 @@ function resolveMcpPlan(agentId, mcp, managedAgents) {
   const desired = [];
   const conflicts = [];
   for (const [name, def] of Object.entries(mcp.servers)) {
+    if (def.enabled === false) {
+      continue;
+    }
     if (!isInScope(agentId, def.agents, managedAgents)) {
       continue;
     }
@@ -27471,38 +27514,20 @@ function resolveMcpPlan(agentId, mcp, managedAgents) {
       });
       continue;
     }
+    const unresolvedName = findUnresolvedEnvName(def, policy);
+    if (unresolvedName) {
+      const source = policy.envFile ?? "process environment";
+      conflicts.push({
+        name,
+        message: `refusing to write MCP server "${name}": its declared env var "${unresolvedName}" has no resolvable value in ${source} \u2014 writing it now would silently break this server's connection once the agent starts it (trellis-mcp-static-env-and-disabled-servers)`
+      });
+      continue;
+    }
     desired.push({ name, def });
   }
   return { desired, conflicts };
 }
 
-// src/lib/secretEnv.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
-var LINE_RE = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/;
-function parseDotenv(content) {
-  const result = {};
-  for (const rawLine of content.split("\n")) {
-    const line = rawLine.trim();
-    if (line === "" || line.startsWith("#")) continue;
-    const match = LINE_RE.exec(line);
-    if (match) result[match[1]] = match[2];
-  }
-  return result;
-}
-function loadEnvFile(path) {
-  return existsSync2(path) ? parseDotenv(readFileSync2(path, "utf-8")) : {};
-}
-function resolveSecretEnv(names, policy) {
-  const result = {};
-  if (policy.envFile) {
-    const map = loadEnvFile(policy.envFile);
-    for (const name of names) result[name] = map[name];
-  } else {
-    for (const name of names) result[name] = process.env[name];
-  }
-  return result;
-}
-
 // src/lib/envVarNames.ts
 var TEMPLATE_VAR_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
 function extractTemplateVarNames(value) {
@@ -31974,7 +31999,12 @@ async function connectStdio(def, secretsPolicy, timeoutMs) {
   const transport = new StdioClientTransport({
     command: def.command,
     args: def.args,
-    env: { ...getDefaultEnvironment(), ...namedEnv }
+    // staticEnv merges last: a literal, intentionally-plain value (an
+    // email, an environment tag) always wins over an unresolved name-only
+    // entry's empty-string fallback for the same key — though in practice
+    // resolveMcpPlan's D6 refusal never lets an unresolved name reach
+    // this point at all (trellis-mcp-static-env-and-disabled-servers).
+    env: { ...getDefaultEnvironment(), ...namedEnv, ...def.staticEnv ?? {} }
   });
   return connectWithCleanup(client, transport, timeoutMs, `connect timed out after ${timeoutMs}ms`);
 }
@@ -32029,7 +32059,7 @@ function registerServerTools(pi, serverName, client, timeoutMs) {
 }
 async function trellisMcpBridge(pi, homeDir = homedir2(), connectTimeoutMs = DEFAULT_CONNECT_TIMEOUT_MS) {
   const canonical = loadCanonicalSource(homeDir);
-  const { desired } = resolveMcpPlan("pi", canonical.mcp, ALL_AGENTS);
+  const { desired } = resolveMcpPlan("pi", canonical.mcp, ALL_AGENTS, canonical.secretsPolicy);
   const clients = /* @__PURE__ */ new Set();
   const closeClient = async (client) => {
     if (!clients.delete(client)) return;

package/dist/pi-bridge/index.js

@@ -75,7 +75,12 @@ async function connectStdio(def, secretsPolicy, timeoutMs) {
     const transport = new StdioClientTransport({
         command: def.command,
         args: def.args,
-        env: { ...getDefaultEnvironment(), ...namedEnv },
+        // staticEnv merges last: a literal, intentionally-plain value (an
+        // email, an environment tag) always wins over an unresolved name-only
+        // entry's empty-string fallback for the same key — though in practice
+        // resolveMcpPlan's D6 refusal never lets an unresolved name reach
+        // this point at all (trellis-mcp-static-env-and-disabled-servers).
+        env: { ...getDefaultEnvironment(), ...namedEnv, ...(def.staticEnv ?? {}) },
     });
     return connectWithCleanup(client, transport, timeoutMs, `connect timed out after ${timeoutMs}ms`);
 }
@@ -135,7 +140,7 @@ export default async function trellisMcpBridge(pi, homeDir = homedir(), connectT
     // independent of whether `trellis onboard` was ever run to add pi to
     // managed.yaml. managedAgents governs static config-file writes; this
     // is pi reading canonical directly at its own runtime, P4's own concern.
-    const { desired } = resolveMcpPlan("pi", canonical.mcp, ALL_AGENTS);
+    const { desired } = resolveMcpPlan("pi", canonical.mcp, ALL_AGENTS, canonical.secretsPolicy);
     const clients = new Set();
     const closeClient = async (client) => {
         if (!clients.delete(client))