agent-trellis 0.2.0 → 0.3.0

package/dist/lib/memoryGraph.js

@@ -0,0 +1,101 @@
+/**
+ * Converts canonical `memories/*.md` into `@modelcontextprotocol/
+ * server-memory`'s own on-disk JSON-lines knowledge-graph format, and
+ * upserts them into an existing graph file without disturbing anything
+ * else in it (trellis-memory-sync) — closing P6's explicitly-left-open
+ * "auto-ingesting memories/*.md content into the running memory
+ * server's store" gap.
+ *
+ * Each line in that file is one JSON object, either
+ * `{type:"entity", name, entityType, observations}` or
+ * `{type:"relation", from, to, relationType}` — the real, documented
+ * shape the official server persists and reads back on its own next
+ * startup (this project writes the file directly; it never spawns or
+ * talks to a running server process).
+ *
+ * `entityType: "trellis-memory"` is this project's own in-band ownership
+ * marker — simpler than a separate ledger file (unlike MCP server sync,
+ * every agent connected to this one server shares the exact same graph,
+ * so there's no per-agent rendering to track). An existing entity with
+ * the same name but a different `entityType` was created by something
+ * else (an agent's own runtime tool calls, most likely) and is left
+ * completely untouched — reported as a conflict, never overwritten.
+ */
+import { readFileSync } from "node:fs";
+export const TRELLIS_MEMORY_ENTITY_TYPE = "trellis-memory";
+export function parseMemoryGraph(content) {
+    const lines = [];
+    for (const raw of content.split("\n")) {
+        const trimmed = raw.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed.type === "entity" || parsed.type === "relation") {
+                lines.push(parsed);
+            }
+        }
+        catch {
+            // Not valid JSON — skip rather than fail the whole file; a
+            // hand-edited or partially-written line shouldn't block every
+            // other, unrelated line in the graph.
+        }
+    }
+    return lines;
+}
+export function renderMemoryGraph(lines) {
+    if (lines.length === 0)
+        return "";
+    return `${lines.map((line) => JSON.stringify(line)).join("\n")}\n`;
+}
+/**
+ * Pure: computes the next graph state and a human-readable plan, given
+ * the current graph's raw content (or `undefined` if the file doesn't
+ * exist yet) and canonical's memory entries. Every non-`trellis-memory`
+ * entity and every relation passes through completely untouched,
+ * regardless of what canonical wants.
+ */
+export function planMemorySync(canonical, currentGraphContent) {
+    const existingLines = currentGraphContent !== undefined ? parseMemoryGraph(currentGraphContent) : [];
+    const untouchedLines = existingLines.filter((line) => !(line.type === "entity" && line.entityType === TRELLIS_MEMORY_ENTITY_TYPE));
+    const existingTrellisEntities = new Map(existingLines.filter((line) => line.type === "entity" && line.entityType === TRELLIS_MEMORY_ENTITY_TYPE).map((e) => [e.name, e]));
+    const existingOtherEntityNames = new Set(existingLines.filter((line) => line.type === "entity" && line.entityType !== TRELLIS_MEMORY_ENTITY_TYPE).map((e) => e.name));
+    const items = [];
+    const nextTrellisEntities = [];
+    let changed = false;
+    const canonicalNames = new Set(canonical.memories.map((m) => m.name));
+    for (const memory of canonical.memories) {
+        if (existingOtherEntityNames.has(memory.name)) {
+            items.push({ name: memory.name, action: "conflict", detail: `an entity named "${memory.name}" already exists in the graph and wasn't created by Trellis — resolve by hand` });
+            continue;
+        }
+        let content;
+        try {
+            content = readFileSync(memory.file, "utf-8");
+        }
+        catch (err) {
+            items.push({ name: memory.name, action: "conflict", detail: `could not read ${memory.file}: ${err instanceof Error ? err.message : String(err)}` });
+            continue;
+        }
+        const desired = { type: "entity", name: memory.name, entityType: TRELLIS_MEMORY_ENTITY_TYPE, observations: [content] };
+        const existing = existingTrellisEntities.get(memory.name);
+        nextTrellisEntities.push(desired);
+        if (existing && existing.observations.length === 1 && existing.observations[0] === content) {
+            items.push({ name: memory.name, action: "already-synced", detail: "graph content is already identical" });
+        }
+        else {
+            items.push({ name: memory.name, action: "create", detail: existing ? "will update the existing entity's observation" : "will create a new entity" });
+            changed = true;
+        }
+    }
+    for (const [name] of existingTrellisEntities) {
+        if (canonicalNames.has(name))
+            continue; // still wanted, handled above
+        items.push({ name, action: "remove", detail: "no longer in canonical — will be removed from the graph" });
+        changed = true;
+    }
+    if (!changed) {
+        return { items };
+    }
+    return { items, nextGraph: [...untouchedLines, ...nextTrellisEntities] };
+}

package/dist/lib/realHomeSnapshot.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `--real` sandbox mode's allowlist (trellis-real-sandbox-verification
+ * design.md D1): every real dotfile path a probe (src/probes/*.ts) is
+ * already known to read, and nothing else. Allowlist, not denylist —
+ * anything this project doesn't already know to be structural (real
+ * OAuth token storage, session/history logs, credentials) is never
+ * copied out of a developer's real `$HOME` because it was never named
+ * here, not because it was excluded after the fact. Kept in sync with
+ * each probe's own `join(homeDir, ...)` calls by direct source
+ * cross-reference, not by assumption.
+ */
+export declare const REAL_HOME_ALLOWLIST: readonly string[];
+/**
+ * Copies only allowlisted paths that actually exist under `sourceHome`
+ * into `destHome` — a missing entry is a normal, expected state (not
+ * every agent is installed), never an error. `dereference: true` is
+ * required, not incidental: `sync`'s own real output is symlinks
+ * (skills, instructions) pointing back at `sourceHome`'s own
+ * `.trellis/` — a container mounting a snapshot that kept those
+ * symlinks as symlinks would get a dangling reference to a path that
+ * doesn't exist inside it. Copying real content instead is what makes
+ * the snapshot self-contained (found by actually running this against
+ * a real, already-synced machine — not by inspection). Returns the
+ * relative paths actually copied, for the caller to report.
+ */
+export declare function buildRealHomeSnapshot(sourceHome: string, destHome: string): string[];

package/dist/lib/realHomeSnapshot.js

@@ -0,0 +1,77 @@
+/**
+ * `--real` sandbox mode's allowlist (trellis-real-sandbox-verification
+ * design.md D1): every real dotfile path a probe (src/probes/*.ts) is
+ * already known to read, and nothing else. Allowlist, not denylist —
+ * anything this project doesn't already know to be structural (real
+ * OAuth token storage, session/history logs, credentials) is never
+ * copied out of a developer's real `$HOME` because it was never named
+ * here, not because it was excluded after the fact. Kept in sync with
+ * each probe's own `join(homeDir, ...)` calls by direct source
+ * cross-reference, not by assumption.
+ */
+import { cpSync, existsSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+export const REAL_HOME_ALLOWLIST = [
+    // claude-code (src/probes/claude-code.ts)
+    ".claude.json",
+    ".claude/skills",
+    ".claude/agents",
+    ".claude/CLAUDE.md",
+    // codex (src/probes/codex.ts)
+    ".codex/config.toml",
+    ".agents/skills",
+    ".codex/skills",
+    // kiro (src/probes/kiro.ts)
+    ".kiro/settings/mcp.json",
+    ".kiro/skills",
+    ".kiro/steering/CLAUDE.md",
+    // pi (src/probes/pi.ts)
+    ".pi/agent/settings.json",
+    ".pi/agent/skills",
+    ".pi/agent/AGENTS.override.md",
+    ".pi/agent/AGENTS.md",
+    ".pi/agent/AGENTS.MD",
+    ".pi/agent/CLAUDE.md",
+    ".pi/agent/CLAUDE.MD",
+    // this machine's own real canonical source, if it already has one —
+    // Trellis's own managed data, not a third-party agent's.
+    ".trellis",
+];
+/**
+ * Copies only allowlisted paths that actually exist under `sourceHome`
+ * into `destHome` — a missing entry is a normal, expected state (not
+ * every agent is installed), never an error. `dereference: true` is
+ * required, not incidental: `sync`'s own real output is symlinks
+ * (skills, instructions) pointing back at `sourceHome`'s own
+ * `.trellis/` — a container mounting a snapshot that kept those
+ * symlinks as symlinks would get a dangling reference to a path that
+ * doesn't exist inside it. Copying real content instead is what makes
+ * the snapshot self-contained (found by actually running this against
+ * a real, already-synced machine — not by inspection). Returns the
+ * relative paths actually copied, for the caller to report.
+ */
+export function buildRealHomeSnapshot(sourceHome, destHome) {
+    const copied = [];
+    for (const rel of REAL_HOME_ALLOWLIST) {
+        const src = join(sourceHome, rel);
+        if (!existsSync(src))
+            continue;
+        const dest = join(destHome, rel);
+        // On a case-insensitive filesystem (macOS default), two distinct
+        // allowlist entries (e.g. `AGENTS.md`/`AGENTS.MD` — pi's own
+        // case-sensitive candidate list, src/probes/pi.ts) can resolve to
+        // the identical real file; a `dest` an earlier entry already
+        // created (case-insensitively) needs no second, redundant copy —
+        // found by actually running this against a real machine, where it
+        // also tripped a Node `cpSync` quirk re-copying a symlink onto its
+        // own already-materialized destination.
+        if (existsSync(dest)) {
+            copied.push(rel);
+            continue;
+        }
+        mkdirSync(dirname(dest), { recursive: true });
+        cpSync(src, dest, { recursive: true, dereference: true });
+        copied.push(rel);
+    }
+    return copied;
+}

package/dist/lib/terminalPicker.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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.
+ */
+import type { Readable, Writable } from "node:stream";
+export interface PickerStreams {
+    input: NodeJS.ReadStream | Readable;
+    output: NodeJS.WriteStream | Writable;
+}
+/**
+ * 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 declare function canUseInteractivePicker(streams?: PickerStreams): boolean;
+/** Wrapping index navigation — pure, exported for direct unit testing. */
+export declare function nextIndex(current: number, delta: number, length: number): number;
+/** Pure single-index toggle — exported for direct unit testing. */
+export declare function toggled(checked: readonly boolean[], index: number): boolean[];
+/**
+ * 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 declare function runSingleSelectPicker(items: string[], streams?: PickerStreams): Promise<number | null>;
+/**
+ * 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 declare function runMultiSelectPicker(items: string[], initiallyChecked: readonly boolean[], streams?: PickerStreams): Promise<number[] | null>;

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;
     }