@kaydash9999/banker-plugins 0.20.2 → 0.20.5

package/skills/ralph-qa/references/seat-spawn.mjs

@@ -0,0 +1,205 @@
+/**
+ * seat-spawn: how the ralph-qa runner (seat-run.mjs) finds a seat CLI and runs it inside its
+ * time limit, with every process the seat started ended when the run returns.
+ *
+ * which(name)     the CLI on PATH, from absolute PATH folders only. libuv on Windows looks in the
+ *                 child's working folder before PATH for a bare name, so the runner always starts
+ *                 a CLI by the absolute path this gives. Windows tries .exe, then .cmd and .bat
+ *                 in each folder, never an extensionless file.
+ * cmdLine(exe, args)  the cmd.exe line for a .cmd or .bat seat (Node refuses to start those
+ *                 without a shell since CVE-2024-27980). Every word is quoted by the MSVC rules;
+ *                 a word holding what cmd.exe reads itself (% ! ^ & | < >, a line break, NUL,
+ *                 or a parenthesis beside a quote, which cmd's quote toggling over \" can bare)
+ *                 makes it null: the seat does not start.
+ * runLimited(opts)  starts the seat with stdin, stdout and stderr on files and resolves with
+ *                 { exit, signal, timedOut, stopped, secs, error, leftover }. On POSIX the seat
+ *                 gets its own process group: the limit sends the group TERM and, after the grace,
+ *                 KILL; a seat that exits on its own has its group sent KILL at once, so nothing it
+ *                 left (a late writer, an MCP server) outlives the run. On Windows the limit ends
+ *                 the tree with System32's taskkill /T /F; a process left after the seat exits on
+ *                 its own is not reached (Windows keeps no group).
+ * stopAll()       ends every seat still running (TERM, then KILL 2 s later; taskkill on Windows).
+ *
+ * No shell and no timeout program: the limit is a timer here, so Git Bash's or System32's
+ * timeout never comes into it.
+ */
+import { spawn, spawnSync } from "node:child_process";
+import { accessSync, closeSync, constants, openSync, statSync } from "node:fs";
+import { posix, win32 } from "node:path";
+
+const running = new Set();
+const STOP_GRACE_MS = 2000;
+// How long a run waits for a seat to go after its KILL before it gives up on it (`leftover`).
+const BACKSTOP_MS = 10000;
+
+const system32 = (file) => win32.join(process.env.SystemRoot || "C:\\Windows", "System32", file);
+
+function pathOf(env, platform) {
+  if (platform !== "win32") return env.PATH || "";
+  const key = Object.keys(env).find((k) => k.toUpperCase() === "PATH");
+  return key ? env[key] || "" : "";
+}
+
+const runnable = (platform) => (file) => {
+  try {
+    if (!statSync(file).isFile()) return false;
+    if (platform !== "win32") accessSync(file, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export function which(name, opts = {}) {
+  const platform = opts.platform || process.platform;
+  const paths = platform === "win32" ? win32 : posix;
+  const exts = platform === "win32" ? [".exe", ".cmd", ".bat"] : [""];
+  const isFile = opts.isFile || runnable(platform);
+  const dirs = pathOf(opts.env || process.env, platform).split(paths.delimiter).filter((dir) => dir && paths.isAbsolute(dir));
+  for (const dir of dirs) {
+    for (const ext of exts) {
+      const file = paths.join(dir, name + ext);
+      if (isFile(file)) return file;
+    }
+  }
+  return null;
+}
+
+const CMD_META = /[%!^&|<>\r\n\0]/;
+const cmdSafe = (w) => !CMD_META.test(w) && !(/[()]/.test(w) && w.includes('"'));
+const quoteWord = (w) => `"${w.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/, "$1$1")}"`;
+
+export function cmdLine(exe, args) {
+  const words = [exe, ...args].map(String);
+  return words.every(cmdSafe) ? words.map(quoteWord).join(" ") : null;
+}
+
+// The files the seat reads and writes, opened for it; "ignore" is passed through.
+function openStdio({ stdin, stdout, stderr }) {
+  const fds = [];
+  const open = (path, flags) => {
+    if (path === undefined || path === "ignore") return "ignore";
+    const fd = openSync(path, flags, 0o600);
+    fds.push(fd);
+    return fd;
+  };
+  try {
+    return { stdio: [open(stdin, "r"), open(stdout, "w"), open(stderr, "w")], fds };
+  } catch (e) {
+    for (const fd of fds) closeSync(fd);
+    throw e;
+  }
+}
+
+// The child process for the seat: a .cmd or .bat through System32's cmd.exe, anything else as is.
+function launch({ exe, args, cwd, env, platform }, stdio) {
+  const viaCmd = platform === "win32" && /\.(cmd|bat)$/i.test(exe);
+  if (!viaCmd) return spawn(exe, args, { cwd, env, stdio, windowsHide: true, detached: platform !== "win32" });
+  const line = cmdLine(exe, args);
+  if (line === null) throw Object.assign(new Error("a word cmd.exe would read"), { code: "unsafe-word" });
+  return spawn(system32("cmd.exe"), ["/d", "/v:off", "/s", "/c", `"${line}"`],
+    { cwd, env, stdio, windowsHide: true, windowsVerbatimArguments: true });
+}
+
+const signalGroup = (pid, sig) => {
+  try {
+    process.kill(-pid, sig);
+  } catch {
+    /* the group is gone */
+  }
+};
+const taskkill = (pid) => spawnSync(system32("taskkill.exe"), ["/T", "/F", "/PID", String(pid)], { stdio: "ignore", windowsHide: true });
+
+// Ends a seat: TERM to its group and KILL after `grace` (POSIX), or taskkill on its tree (Windows).
+function terminate(seat, why, grace) {
+  if (seat.ending) return;
+  seat.ending = why;
+  if (seat.platform === "win32") {
+    taskkill(seat.child.pid);
+    seat.backstop = setTimeout(() => seat.finish(true), BACKSTOP_MS);
+    return;
+  }
+  signalGroup(seat.child.pid, "SIGTERM");
+  seat.killTimer = setTimeout(() => {
+    seat.killed = true;
+    signalGroup(seat.child.pid, "SIGKILL");
+    if (seat.exited) seat.finish(false);
+    else seat.backstop = setTimeout(() => seat.finish(true), BACKSTOP_MS);
+  }, grace);
+}
+
+// The seat's own exit: on POSIX its group is sent KILL now, or when the grace ends if it is being
+// ended, so nothing it left keeps running.
+function onExit(seat, code, signal) {
+  if (seat.child.pid === undefined) return undefined; // a seat that never started: its error ends the run
+  seat.exited = { code, signal };
+  clearTimeout(seat.limitTimer);
+  if (seat.platform === "win32") return seat.finish(false);
+  if (seat.ending && !seat.killed) return undefined;
+  signalGroup(seat.child.pid, "SIGKILL");
+  return seat.finish(false);
+}
+
+function watch(seat, opts) {
+  const { child } = seat;
+  const grace = opts.graceMs ?? Math.min(10000, opts.limitMs / 2);
+  seat.limitTimer = setTimeout(() => terminate(seat, "limit", grace), opts.limitMs);
+  child.on("exit", (code, signal) => onExit(seat, code, signal));
+  child.on("error", (e) => {
+    if (child.pid === undefined) seat.finish(false, e.code || "spawn");
+  });
+}
+
+function result(seat, t0, leftover, error) {
+  const { code = null, signal = null } = seat.exited || {};
+  return {
+    exit: error ? null : code, signal: error ? null : signal, timedOut: seat.ending === "limit", stopped: seat.ending === "stop",
+    secs: Math.round((Date.now() - t0) / 100) / 10, error: error || null, leftover,
+  };
+}
+
+export function runLimited(opts) {
+  const t0 = Date.now();
+  const platform = opts.platform || process.platform;
+  return new Promise((done) => {
+    let io;
+    try {
+      if (!statSync(opts.exe).isFile()) throw Object.assign(new Error("not a file"), { code: "ENOENT" });
+      io = openStdio(opts);
+    } catch (e) {
+      done(result({}, t0, false, e.code || "spawn"));
+      return;
+    }
+    const seat = { platform };
+    seat.finish = (leftover, error) => {
+      if (seat.done) return;
+      seat.done = true;
+      for (const t of [seat.limitTimer, seat.killTimer, seat.backstop]) clearTimeout(t);
+      running.delete(seat);
+      done(result(seat, t0, leftover, error));
+    };
+    try {
+      seat.child = launch({ ...opts, args: opts.args || [], platform }, io.stdio);
+    } catch (e) {
+      seat.finish(false, e.code || "spawn");
+      return;
+    } finally {
+      for (const fd of io.fds) closeSync(fd);
+    }
+    running.add(seat);
+    watch(seat, opts);
+  });
+}
+
+export function stopAll() {
+  const seats = [...running];
+  const ends = seats.map((seat) => new Promise((resolve) => {
+    const finish = seat.finish;
+    seat.finish = (...a) => {
+      finish(...a);
+      resolve();
+    };
+  }));
+  for (const seat of seats) terminate(seat, "stop", STOP_GRACE_MS);
+  return Promise.all(ends);
+}

package/skills/ralph-qa/references/verifier-probe.mjs

@@ -205,6 +205,13 @@ const STRING_VALUE = /^(?:"((?:[^"\\]|\\.)*)"|'([^']*)')\s*(?:#.*)?$/s;
 
 // A dotted key's segments, quotes taken off (escapes kept as written).
 const keyPath = (text) => [...text.matchAll(SEG_RE)].map((m) => m[1] ?? m[2] ?? m[3]);
+// True when a "basic" key segment holds an escape: codex reads the key the escape spells
+// ("sandbox\u005Fmode" is sandbox_mode), and the probe keeps it as written.
+const escapedKey = (text) => [...text.matchAll(SEG_RE)].some((m) => m[1]?.includes("\\"));
+// Such a key leaves the read not whole: what codex reads there is not what the probe placed.
+function markEscape(state, keyText) {
+  if (escapedKey(keyText)) state.unplaced = true;
+}
 
 // The walk's state: where it is (open string, nesting depth, table, array being gathered) and
 // what it found so far.
@@ -305,10 +312,14 @@ function assignment(state, path, value) {
   if (str) state.values[path[0]] = str[1] ?? str[2];
 }
 
-// A table header: the table later keys go in, and the MCP server a [mcp_servers.<name>...] names.
+// A table header: the table later keys go in, and the MCP server a [mcp_servers.<name>...] names. An array of tables
+// under mcp_servers ([[mcp_servers.<name>]], quoted or not) is a server list the probe cannot read: codex refuses it
+// ("invalid type: sequence", 0.144.5), so a seat on it would fail later for no reason the probe gave.
 function enterTable(state, header) {
-  state.roots.add(keyPath(header[2])[0]);
-  state.table = header[1] ? ["[[]]"] : keyPath(header[2]);
+  const path = keyPath(header[2]);
+  state.roots.add(path[0]);
+  state.table = header[1] ? ["[[]]"] : path;
+  if (header[1] && path[0] === "mcp_servers") state.mcpUnread = true;
   if (state.table[0] === "mcp_servers" && state.table.length > 1) state.mcpServers.add(state.table[1]);
 }
 
@@ -324,9 +335,15 @@ function tomlLine(state, line) {
     return;
   }
   const header = HEADER_RE.exec(line);
-  if (header) return enterTable(state, header);
+  if (header) {
+    markEscape(state, header[2]);
+    return enterTable(state, header);
+  }
   const assign = ASSIGN_RE.exec(line);
-  if (assign) return assignment(state, keyPath(assign[1]), assign[2]);
+  if (assign) {
+    markEscape(state, assign[1]);
+    return assignment(state, keyPath(assign[1]), assign[2]);
+  }
   if (!/^\s*(?:#|$)/.test(line)) state.unplaced = true;
 }
 
@@ -361,13 +378,25 @@ const rawMcpNames = (lines) => lines.filter((l) => !/^\s*#/.test(l))
 // defined (table headers, under [mcp_servers], dotted keys), whether servers were written in a
 // form it does not list or that the text names beyond what it listed (`mcpUnread`), whether any
 // table sets a model (`modelKeys`), whether a multi-line string, array or inline table was left
-// open or a line could not be placed (`broken`), and the strings of each top-level array
+// open or a line could not be placed (`broken`, with `brokenAt`: the first line it could not place
+// or the line that opened what is still open), and the strings of each top-level array
 // (`arrays`). Enough for those keys; not a TOML parser.
 export function readToml(text) {
   const state = tomlState();
   const lines = String(text ?? "").split(/\r?\n/);
-  for (const line of lines) tomlLine(state, line);
+  const isOpen = () => state.open !== null || state.depth > 0;
+  // the first line it could not place, and the line that opened what is still open at the end
+  let badAt = 0;
+  let openAt = 0;
+  lines.forEach((line, i) => {
+    const wasOpen = isOpen();
+    const wasBad = state.unplaced;
+    tomlLine(state, line);
+    if (!wasBad && state.unplaced) badAt = i + 1;
+    if (!wasOpen && isOpen()) openAt = i + 1;
+  });
   const unlisted = rawMcpNames(lines).filter((n) => !state.mcpServers.has(n));
+  const broken = isOpen() || state.unplaced;
   return {
     values: state.values,
     roots: [...state.roots],
@@ -375,7 +404,8 @@ export function readToml(text) {
     mcpServers: [...state.mcpServers],
     mcpUnread: state.mcpUnread || unlisted.length > 0,
     modelKeys: state.modelKeys,
-    broken: state.open !== null || state.depth > 0 || state.unplaced,
+    broken,
+    ...(broken ? { brokenAt: Math.min(...[badAt, isOpen() ? openAt : 0].filter(Boolean)) } : {}),
   };
 }
 
@@ -491,7 +521,8 @@ function codexConfigFiles(world) {
 
 // Those layers as one: the first layer with a value wins, MCP servers add up.
 function codexConfig(world) {
-  const layers = codexConfigFiles(world).map((f) => readToml(world.readFile(f)));
+  const files = codexConfigFiles(world);
+  const layers = files.map((f) => readToml(world.readFile(f)));
   const pick = (key) => layers.map((l) => l.values[key]).find((v) => v !== undefined);
   return {
     cfg: { model: pick("model"), model_provider: pick("model_provider"), profile: pick("profile") },
@@ -499,6 +530,7 @@ function codexConfig(world) {
     mcpUnread: layers.some((l) => l.mcpUnread),
     modelKeys: layers.some((l) => l.modelKeys),
     broken: layers.some((l) => l.broken),
+    brokenAt: layers.map((l, k) => (l.broken ? `${files[k]} line ${l.brokenAt}` : null)).filter(Boolean),
   };
 }
 
@@ -512,8 +544,8 @@ function mcpBlockedSeat(seat, conf, notes) {
   const bad = conf.mcpServers.filter((n) => !MCP_NAME.test(n)).length;
   if (!bad && !conf.mcpUnread && !conf.broken) return null;
   if (bad) notes.push(`${bad} MCP server name(s) hold characters \`-c mcp_servers.<name>.enabled=false\` cannot address: rename them to letters, digits, _ and -`);
-  if (conf.mcpUnread) notes.push("the probe could not list every MCP server the codex config defines (one inline mcp_servers table, or a name its walk did not place): write each server as its own [mcp_servers.<name>] table");
-  if (conf.broken) notes.push("the probe could not read the codex config to its end (a multi-line string, array or inline table left open, or a line it could not place), so its list of MCP servers may be short");
+  if (conf.mcpUnread) notes.push("the probe could not list every MCP server the codex config defines (one inline mcp_servers table, an array of tables under mcp_servers, or a name its walk did not place): write each server as its own [mcp_servers.<name>] table");
+  if (conf.broken) notes.push(`the probe could not read the codex config to its end at ${conf.brokenAt.join(", ")} (a multi-line string, array or inline table left open, or a line it could not place, such as a quoted key with a \\ escape that codex reads as another key), so its list of MCP servers may be short`);
   return { ...seat, decision: "unseated", reason: "cli-call-failed" };
 }
 
@@ -530,7 +562,7 @@ function managedBlockedSeat(seat, world, notes) {
   const read = readToml(world.readFile(CODEX_MANAGED));
   const keys = read.roots.filter((k) => SEAT_KEYS.includes(k));
   if (!keys.length && !read.broken) return null;
-  notes.push(`${CODEX_MANAGED} ${keys.length ? `sets ${keys.join(", ")}` : "could not be read to its end"}, which codex applies over the seat's -c flags: the seat cannot hold its guards`);
+  notes.push(`${CODEX_MANAGED} ${keys.length ? `sets ${keys.join(", ")}` : `could not be read to its end (line ${read.brokenAt})`}, which codex applies over the seat's -c flags: the seat cannot hold its guards`);
   return { ...seat, decision: "unseated", reason: "cli-call-failed" };
 }
 
@@ -551,7 +583,7 @@ function requirementsBlockedSeat(seat, world, notes) {
   const allows = (k) => SEAT_ALLOWS[k] !== undefined && (read.arrays[k] ?? []).includes(SEAT_ALLOWS[k]);
   const keys = read.roots.filter((k) => !GUARD_FREE.includes(k) && !allows(k));
   if (!keys.length && !read.broken) return null;
-  notes.push(`${CODEX_REQUIREMENTS} ${keys.length ? `sets ${keys.join(", ")}` : "could not be read to its end"}, which codex holds over the seat's -c, --disable and -s flags: the seat cannot hold its guards`);
+  notes.push(`${CODEX_REQUIREMENTS} ${keys.length ? `sets ${keys.join(", ")}` : `could not be read to its end (line ${read.brokenAt})`}, which codex holds over the seat's -c, --disable and -s flags: the seat cannot hold its guards`);
   return { ...seat, decision: "unseated", reason: "cli-call-failed" };
 }
 
@@ -797,9 +829,11 @@ function opencodeModels(cfg) {
   return { configured: own, models: [own, ...listed] };
 }
 
+const opencodeCache = (world) => join(world.env.XDG_CACHE_HOME || join(world.home, ".cache"), "opencode");
+
 // The providers opencode's local copy of the models.dev list knows; null when it cannot be read.
 function catalogProviders(world) {
-  const file = join(world.env.XDG_CACHE_HOME || join(world.home, ".cache"), "opencode", "models.json");
+  const file = join(opencodeCache(world), "models.json");
   const read = readJsonc(world.readFile(file));
   return read.value ? new Set(Object.keys(read.value)) : null;
 }
@@ -835,6 +869,10 @@ function opencodeSeat(flag, { world, authorFamilies }) {
   notes.push(...cfg.unreadable.map((f) => `config not readable: ${f}`));
   if (world.env.OPENCODE_CONFIG_CONTENT) notes.push("$OPENCODE_CONFIG_CONTENT is not read: the seat command replaces it with its own reviewer agent");
   const catalog = catalogProviders(world);
+  // opencode empties its cache on a start after an update; with the list refresh off it fetches nothing
+  if (!catalog && world.readFile(join(opencodeCache(world), "version")) != null) {
+    notes.push("opencode's models.dev copy is missing or unreadable while its cache version file is there: an opencode start with the list refresh off (the seat and cleanup commands) empties the cache after an update; start opencode once, online and without OPENCODE_DISABLE_MODELS_FETCH, to fetch it again; offline it cannot come back: where the copy let the seat be adopted (single-candidate), each run asks instead (no-catalog), and a run that cannot ask seats the fallback");
+  }
   const closed = closedSet(cfg, catalog);
   const out = flagged(seat, flag, authorFamilies) ?? opencodeDecision(seat, { configured, unsure: cfg.unreadable.length > 0, closed, catalog });
   return withNotes(out, notes);
@@ -933,13 +971,16 @@ function realWorld() {
       const exe = onPath(cmd);
       if (!exe) return { status: 127, stdout: "" };
       // Windows runs .cmd and .bat shims through cmd.exe; the path is quoted and the arguments are fixed words.
+      // System32's cmd.exe (a bare name is looked for in the current folder first), told not to look there for the
+      // bare `node` an npm shim runs.
       const viaCmd = process.platform === "win32" && /\.(cmd|bat)$/i.test(exe);
+      const shell = viaCmd ? join(process.env.SystemRoot || "C:\\Windows", "System32", "cmd.exe") : false;
       const r = spawnSync(viaCmd ? `"${exe}"` : exe, args, {
         encoding: "utf8",
         timeout: 15000,
         maxBuffer: 64 * 1024 * 1024,
-        shell: viaCmd,
-        env: { ...process.env, ...env },
+        shell,
+        env: { ...process.env, ...(viaCmd ? { NoDefaultCurrentDirectoryInExePath: "1" } : {}), ...env },
       });
       return { status: r.status, stdout: r.stdout ?? "" };
     },

package/skills/setup-harness-factory/SKILL.md

@@ -26,6 +26,22 @@ ls -la .claude/agents .claude/skills 2>/dev/null   # 기존 harness 산출물
 - 기존 `.claude/agents/`·`.claude/skills/`·`CLAUDE.md`에 harness 흔적이 있으면 신규 생성이 아니라
   확장·유지보수로 다룬다(harness 자신의 Phase 0 감사 원칙).
 
+### 네트워크 확인 (내려받기 전)
+
+이 스킬이 내려받는 원천에 10초 안에 닿는지 먼저 본다. 닿지 않으면 그 원천에서 받는 단계는 하지 않고, 이미 설치된 것의 확인만 한 뒤 "오프라인이라 설치하지 않음(필요한 것: <못 깐 것>)" 으로 보고한다.
+
+```bash
+[ "${CODEX_SANDBOX_NETWORK_DISABLED:-}" = 1 ] && echo "Codex sandbox 가 네트워크를 막음(아래 실패는 오프라인이 아님)"
+curl --ssl-no-revoke -sSI -o /dev/null --connect-timeout 5 --max-time 10 https://github.com   # 마켓플레이스, git clone
+```
+
+- `curl -sSI` 는 머리만 받는다(본문을 받지 않음). 닿지 못하면 종료 코드가 0 이 아니다(HTTP 상태와 관계없음). `curl` 은 `HTTPS_PROXY` 를 따른다. 확인 줄은 `--ssl-no-revoke` 를 준다. Windows 의 Git Bash curl 도 Schannel 이라, 폐지 목록 서버에 닿지 못하는 망에서 폐지 확인이 실패하면 종료 60 이다(Windows 박스 실측). 다른 curl 은 이 깃발을 받고 무시한다(macOS curl 8.7.1, Rocky 8.10 curl 7.61.1 실측).
+- Windows PowerShell 에서는 같은 주소를 `curl.exe --ssl-no-revoke -sSI -o NUL --connect-timeout 5 --max-time 10 <주소>` 로 보고 `$LASTEXITCODE` 가 0 인지 본다(PowerShell 5.1 의 `curl` 은 `Invoke-WebRequest` 별칭이다). `curl.exe` 는 Windows 시스템 프록시를 따르지 않고 `HTTPS_PROXY` 만 따른다. `--ssl-no-revoke` 는 폐지 목록 서버에 닿지 못하는 망에서 Schannel 의 폐지 확인 실패를 오프라인으로 읽지 않게 한다. 닿는지만 보고 받은 내용은 쓰지 않으므로 이 확인에만 준다. `curl.exe` 가 없으면 `$LASTEXITCODE` 에 앞 명령의 값이 남으므로 `Get-Command curl.exe -ErrorAction SilentlyContinue` 로 먼저 보고, 없으면 확인하지 못한 것으로 적는다.
+- 사내 미러만 열린 망이면 확인 주소를 그 미러로 바꿔 본다.
+- Codex sandbox 가 네트워크를 막는 모드(기본 `workspace-write`, `read-only`)에서는 `CODEX_SANDBOX_NETWORK_DISABLED=1` 이 서고 확인이 모두 실패한다(curl 종료 7, npm `EPERM`). 블록의 첫 줄이 그렇다고 알린다. 그때는 '오프라인' 이 아니라 'sandbox 가 네트워크를 막음' 으로 보고하고, 승인을 받아 sandbox 밖에서 확인부터 다시 한다. Claude Code sandbox 안(`SANDBOX_RUNTIME=1`)에서는 허용 목록 밖 주소를 sandbox 프록시가 막는다. Windows PowerShell 에서는 `$env:CODEX_SANDBOX_NETWORK_DISABLED -eq '1'` 로 본다.
+- 확인이 실패하면 보고에 그 명령, 종료 코드, stderr 첫 줄을 붙인다(예: `npm error code ETIMEDOUT`, `curl: (28) ...`). 원인을 '오프라인' 하나로 짐작하지 않는다.
+- curl 의 종료 60(인증서 검증 실패)도 오프라인이 아니다. 망은 열려 있고, TLS 를 가로채는 사내 프록시의 인증서를 OS 가 믿지 않는 것이다. '인증서 문제로 설치하지 않음' 으로 보고한다.
+
 ## 1. 설치
 ### Claude Code
 세션 안(슬래시 커맨드):
@@ -43,7 +59,7 @@ ls -la .claude/agents .claude/skills 2>/dev/null   # 기존 harness 산출물
 ### Codex CLI
 마켓플레이스 개념이 없고 Python 인스톨러를 쓴다:
 ```bash
-git clone https://github.com/SaehwanPark/meta-harness
+git -c http.lowSpeedLimit=1000 -c http.lowSpeedTime=30 clone https://github.com/SaehwanPark/meta-harness
 cd meta-harness
 python3 scripts/install_harness.py --scope user --layout codex
 # 프로젝트 범위: python3 scripts/install_harness.py --scope project --target <repo> --layout codex

package/skills/setup-insane-search/SKILL.md

@@ -8,6 +8,22 @@ description: "차단이나 봇 방어가 있는 사이트도 우회해 검색하
 차단 사이트 우회(WAF·봇방어; X·Reddit·YouTube·GitHub 등) 검색·페치를 제공하는 `insane-search` 플러그인을
 설치한다. 현재 도구(Claude Code / Codex)를 감지해 알맞은 경로로 진행하고, 이미 설치돼 있으면 skip(멱등). 답변은 한글.
 
+## 0. 네트워크 확인 (내려받기 전)
+
+이 스킬이 내려받는 원천에 10초 안에 닿는지 먼저 본다. 닿지 않으면 그 원천에서 받는 단계는 하지 않고, 이미 설치된 것의 확인만 한 뒤 "오프라인이라 설치하지 않음(필요한 것: <못 깐 것>)" 으로 보고한다.
+
+```bash
+[ "${CODEX_SANDBOX_NETWORK_DISABLED:-}" = 1 ] && echo "Codex sandbox 가 네트워크를 막음(아래 실패는 오프라인이 아님)"
+curl --ssl-no-revoke -sSI -o /dev/null --connect-timeout 5 --max-time 10 https://github.com   # 마켓플레이스(GitHub)
+```
+
+- `curl -sSI` 는 머리만 받는다(본문을 받지 않음). 닿지 못하면 종료 코드가 0 이 아니다(HTTP 상태와 관계없음). `curl` 은 `HTTPS_PROXY` 를 따른다. 확인 줄은 `--ssl-no-revoke` 를 준다. Windows 의 Git Bash curl 도 Schannel 이라, 폐지 목록 서버에 닿지 못하는 망에서 폐지 확인이 실패하면 종료 60 이다(Windows 박스 실측). 다른 curl 은 이 깃발을 받고 무시한다(macOS curl 8.7.1, Rocky 8.10 curl 7.61.1 실측).
+- Windows PowerShell 에서는 같은 주소를 `curl.exe --ssl-no-revoke -sSI -o NUL --connect-timeout 5 --max-time 10 <주소>` 로 보고 `$LASTEXITCODE` 가 0 인지 본다(PowerShell 5.1 의 `curl` 은 `Invoke-WebRequest` 별칭이다). `curl.exe` 는 Windows 시스템 프록시를 따르지 않고 `HTTPS_PROXY` 만 따른다. `--ssl-no-revoke` 는 폐지 목록 서버에 닿지 못하는 망에서 Schannel 의 폐지 확인 실패를 오프라인으로 읽지 않게 한다. 닿는지만 보고 받은 내용은 쓰지 않으므로 이 확인에만 준다. `curl.exe` 가 없으면 `$LASTEXITCODE` 에 앞 명령의 값이 남으므로 `Get-Command curl.exe -ErrorAction SilentlyContinue` 로 먼저 보고, 없으면 확인하지 못한 것으로 적는다.
+- 사내 미러만 열린 망이면 확인 주소를 그 미러로 바꿔 본다.
+- Codex sandbox 가 네트워크를 막는 모드(기본 `workspace-write`, `read-only`)에서는 `CODEX_SANDBOX_NETWORK_DISABLED=1` 이 서고 확인이 모두 실패한다(curl 종료 7, npm `EPERM`). 블록의 첫 줄이 그렇다고 알린다. 그때는 '오프라인' 이 아니라 'sandbox 가 네트워크를 막음' 으로 보고하고, 승인을 받아 sandbox 밖에서 확인부터 다시 한다. Claude Code sandbox 안(`SANDBOX_RUNTIME=1`)에서는 허용 목록 밖 주소를 sandbox 프록시가 막는다. Windows PowerShell 에서는 `$env:CODEX_SANDBOX_NETWORK_DISABLED -eq '1'` 로 본다.
+- 확인이 실패하면 보고에 그 명령, 종료 코드, stderr 첫 줄을 붙인다(예: `npm error code ETIMEDOUT`, `curl: (28) ...`). 원인을 '오프라인' 하나로 짐작하지 않는다.
+- curl 의 종료 60(인증서 검증 실패)도 오프라인이 아니다. 망은 열려 있고, TLS 를 가로채는 사내 프록시의 인증서를 OS 가 믿지 않는 것이다. '인증서 문제로 설치하지 않음' 으로 보고한다.
+
 ## Claude Code · 세션 안 (슬래시 커맨드)
 ```
 /plugin marketplace add https://github.com/fivetaku/gptaku_plugins.git

package/skills/setup-java/SKILL.md

@@ -26,6 +26,25 @@ if (Get-Command java -ErrorAction SilentlyContinue) { java -version } else { "ja
 [Environment]::GetEnvironmentVariable('JAVA_HOME','User')
 ```
 
+### 네트워크 확인 (내려받기 전)
+
+이 스킬이 내려받는 원천에 10초 안에 닿는지 먼저 본다. 닿지 않으면 그 원천에서 받는 단계는 하지 않고, 이미 설치된 것의 확인만 한 뒤 "오프라인이라 설치하지 않음(필요한 것: <못 깐 것>)" 으로 보고한다.
+
+```bash
+[ "${CODEX_SANDBOX_NETWORK_DISABLED:-}" = 1 ] && echo "Codex sandbox 가 네트워크를 막음(아래 실패는 오프라인이 아님)"
+curl --ssl-no-revoke -sSI -o /dev/null --connect-timeout 5 --max-time 10 https://packages.adoptium.net   # Debian 12 의 Adoptium 저장소
+```
+
+- `curl -sSI` 는 머리만 받는다(본문을 받지 않음). 닿지 못하면 종료 코드가 0 이 아니다(HTTP 상태와 관계없음). `curl` 은 `HTTPS_PROXY` 를 따른다. 확인 줄은 `--ssl-no-revoke` 를 준다. Windows 의 Git Bash curl 도 Schannel 이라, 폐지 목록 서버에 닿지 못하는 망에서 폐지 확인이 실패하면 종료 60 이다(Windows 박스 실측). 다른 curl 은 이 깃발을 받고 무시한다(macOS curl 8.7.1, Rocky 8.10 curl 7.61.1 실측).
+- Windows PowerShell 에서는 같은 주소를 `curl.exe --ssl-no-revoke -sSI -o NUL --connect-timeout 5 --max-time 10 <주소>` 로 보고 `$LASTEXITCODE` 가 0 인지 본다(PowerShell 5.1 의 `curl` 은 `Invoke-WebRequest` 별칭이다). `curl.exe` 는 Windows 시스템 프록시를 따르지 않고 `HTTPS_PROXY` 만 따른다. `--ssl-no-revoke` 는 폐지 목록 서버에 닿지 못하는 망에서 Schannel 의 폐지 확인 실패를 오프라인으로 읽지 않게 한다. 닿는지만 보고 받은 내용은 쓰지 않으므로 이 확인에만 준다. `curl.exe` 가 없으면 `$LASTEXITCODE` 에 앞 명령의 값이 남으므로 `Get-Command curl.exe -ErrorAction SilentlyContinue` 로 먼저 보고, 없으면 확인하지 못한 것으로 적는다.
+- 사내 미러만 열린 망이면 확인 주소를 그 미러로 바꿔 본다.
+- OS 패키지 관리자(dnf, apt, brew, winget)의 단계는 자기 설정의 미러를 쓰므로 이 확인과 관계없이 시도하고, 실패하면 그 단계를 실패로 보고한다.
+  - 패킷을 버리거나 답하지 않는 망에서 dnf 는 저장소마다 약 2분(SYN 을 버리는 망 실측 121초), apt 는 원천마다 약 4분(답하지 않는 원천 실측 247초) 기다린 뒤 실패로 끝난다. 시간 제한은 관리자 설정을 따르므로 이 스킬이 바꾸지 않는다.
+  - `apt-get update` 는 받지 못해도 종료 0 이다. 출력의 `W: Failed to fetch` 가 있으면 그 단계를 실패로 보고한다.
+- Codex sandbox 가 네트워크를 막는 모드(기본 `workspace-write`, `read-only`)에서는 `CODEX_SANDBOX_NETWORK_DISABLED=1` 이 서고 확인이 모두 실패한다(curl 종료 7, npm `EPERM`). 블록의 첫 줄이 그렇다고 알린다. 그때는 '오프라인' 이 아니라 'sandbox 가 네트워크를 막음' 으로 보고하고, 승인을 받아 sandbox 밖에서 확인부터 다시 한다. Claude Code sandbox 안(`SANDBOX_RUNTIME=1`)에서는 허용 목록 밖 주소를 sandbox 프록시가 막는다. Windows PowerShell 에서는 `$env:CODEX_SANDBOX_NETWORK_DISABLED -eq '1'` 로 본다.
+- 확인이 실패하면 보고에 그 명령, 종료 코드, stderr 첫 줄을 붙인다(예: `npm error code ETIMEDOUT`, `curl: (28) ...`). 원인을 '오프라인' 하나로 짐작하지 않는다.
+- curl 의 종료 60(인증서 검증 실패)도 오프라인이 아니다. 망은 열려 있고, TLS 를 가로채는 사내 프록시의 인증서를 OS 가 믿지 않는 것이다. '인증서 문제로 설치하지 않음' 으로 보고한다.
+
 ## 1. Rocky Linux 8
 ```bash
 sudo dnf install -y java-21-openjdk-devel
@@ -51,7 +70,7 @@ export JAVA_HOME="$(dirname "$(dirname "$(readlink -f "$(command -v javac)")")")
 ⚠️ **default·backports 저장소 모두 JDK 21을 제공하지 않는다.** Adoptium 레포 추가가 유일한 경로(재확인: 배포판이 이후 21을 backport하면 이 단계는 생략 가능).
 ```bash
 sudo apt-get install -y wget gnupg
-wget -qO - https://packages.adoptium.net/artifactory/api/gpg/key/public | \
+wget -qO - --timeout=10 --tries=2 https://packages.adoptium.net/artifactory/api/gpg/key/public | \
   sudo gpg --dearmor -o /usr/share/keyrings/adoptium.gpg
 echo "deb [signed-by=/usr/share/keyrings/adoptium.gpg] https://packages.adoptium.net/artifactory/deb bookworm main" | \
   sudo tee /etc/apt/sources.list.d/adoptium.list

package/skills/setup-lsp/SKILL.md

@@ -40,6 +40,44 @@ ls src/main/resources/application.* >/dev/null 2>&1 && echo "lang: spring"
 ```
 > Windows(PowerShell): `Get-Command claude,codex,npm,pipx,java`, `Test-Path tsconfig.json,pom.xml` 등으로 동일 감지. jdtls 는 `jdtls.bat`.
 
+### 네트워크 확인 (내려받기 전)
+
+이 스킬이 내려받는 원천에 닿는지 먼저 본다(curl 은 10초, npm 은 15초 안). 닿지 않으면 그 원천에서 받는 단계는 하지 않고, 이미 설치된 것의 확인만 한 뒤 "오프라인이라 설치하지 않음(필요한 것: <못 깐 것>)" 으로 보고한다.
+
+```bash
+[ "${CODEX_SANDBOX_NETWORK_DISABLED:-}" = 1 ] && echo "Codex sandbox 가 네트워크를 막음(아래 실패는 오프라인이 아님)"
+in15() { "$@" & p=$!; ( sleep 15 && kill "$p" ) > /dev/null 2>&1 & k=$!; wait "$p" 2>/dev/null; r=$?; kill "$k" 2>/dev/null; wait "$k" 2>/dev/null; [ "$r" = 143 ] && echo "15초 안에 끝나지 않아 멈춤(패킷을 버리는 망일 수 있음)"; return "$r"; }
+in15 sh -c 'cd ~ && exec npm ping --fetch-retries=0 --fetch-timeout=10000 --no-update-notifier'                              # ts, bash 서버(npm)
+# pip 이 읽는 설정 전부(PIP_CONFIG_FILE 포함)를 홈 폴더에서 읽는다. install 절이 global 절보다 앞선다
+L=$( (cd ~ && { pip config list || pip3 config list || python3.13 -m pip config list || python3.12 -m pip config list || python3.11 -m pip config list || python3 -m pip config list; }) 2>/dev/null) || echo "pip 설정을 읽지 못함(pip 이 없거나 10 미만). 사내 미러를 쓰면 확인 주소를 그 미러로 바꿔 본다"
+I="${PIP_INDEX_URL:-$(printf '%s\n' "$L" | sed -n "s/^install\.index-url='\(.*\)'$/\1/p")}"
+I="${I:-$(printf '%s\n' "$L" | sed -n "s/^global\.index-url='\(.*\)'$/\1/p")}"
+I=$(printf %s "${I:-https://pypi.org/simple}" | sed -E 's#^([A-Za-z][A-Za-z0-9+.-]*://)[^/]*@#\1#; s#/$##')   # 주소의 사용자 정보는 뗌
+printf 'url = "%s"\n' "$I/pip/" | curl --ssl-no-revoke -K - -sSI -o /dev/null --connect-timeout 5 --max-time 10   # py 서버(pipx)
+curl --ssl-no-revoke -sSI -o /dev/null --connect-timeout 5 --max-time 10 https://download.eclipse.org   # jdtls
+curl --ssl-no-revoke -sSI -o /dev/null --connect-timeout 5 --max-time 10 https://github.com             # lsp-mcp
+curl --ssl-no-revoke -sSI -o /dev/null --connect-timeout 5 --max-time 10 https://vmware.gallery.vsassets.io   # Spring Boot LS(VSIX)
+curl --ssl-no-revoke -sSI -o /dev/null --connect-timeout 5 --max-time 10 https://marketplace.visualstudio.com # Spring Boot LS(VSIX 대체 원천. 둘 중 하나만 닿아도 받을 수 있다)
+```
+
+- `npm ping` 은 홈 폴더에서 부른다. 지금 폴더에 있는 프로젝트의 `.npmrc` 가 정한 레지스트리와 토큰을 따르지 않게 하려는 것이다.
+- `npm ping` 은 15초 감시(`in15`) 안에서 부른다. 패킷을 버리는 망에서 npm 은 연결에 시간 제한을 두지 않아(`--fetch-timeout` 은 받는 중의 쉼만 잰다) OS 의 연결 재시도가 끝날 때까지 기다린다(Rocky 8.10 실측 130초). 15초 안에 끝나지 않으면 `15초 안에 끝나지 않아 멈춤(패킷을 버리는 망일 수 있음)` 과 종료 143 이다. `--no-update-notifier` 는 npm 이 제 판을 묻는 요청을 하나 더 내지 않게 한다.
+- `npm ping` 이 실패하면 ping 에 답하지 않는 사내 미러일 수 있다. `(cd ~ && T=$(mktemp -d) && { npm view bash-language-server version --fetch-retries=0 --fetch-timeout=10000 --cache "$T" --no-update-notifier; r=$?; rm -rf "$T"; exit $r; })` 도 실패해야 오프라인으로 본다. 이 스킬이 설치할 패키지(`bash-language-server`)를 빈 캐시로 물으므로 옛 값이 나올 수 없다. ping 이 15초 감시에 걸려 멈췄으면(종료 143) 이 확인은 하지 않는다. 같은 레지스트리라 같은 시간을 또 기다린다.
+- `npm` 이 없으면(명령 없음) 오프라인이 아니라 확인하지 못한 것이다. Node 를 먼저 갖춘다(`setup-node`).
+- `npm ping` 은 npm 의 프록시 설정(`proxy`, `https-proxy`)을 따른다. 사내 미러만 열린 망이면 그 미러가 쓰이는지 npm 설정을 본다.
+- `curl -sSI` 는 머리만 받는다(본문을 받지 않음). 닿지 못하면 종료 코드가 0 이 아니다(HTTP 상태와 관계없음). `curl` 은 `HTTPS_PROXY` 를 따른다. 확인 줄은 `--ssl-no-revoke` 를 준다. Windows 의 Git Bash curl 도 Schannel 이라, 폐지 목록 서버에 닿지 못하는 망에서 폐지 확인이 실패하면 종료 60 이다(Windows 박스 실측). 다른 curl 은 이 깃발을 받고 무시한다(macOS curl 8.7.1, Rocky 8.10 curl 7.61.1 실측).
+- PyPI 는 pip 이 쓰는 색인(`PIP_INDEX_URL`, `pip config list` 의 `install.index-url` 이나 `global.index-url`, 없으면 pypi.org)의 작은 쪽(`<색인>/pip/`)을 본다.
+- `pip config get` 은 `PIP_CONFIG_FILE` 로 준 파일을 읽지 않아(pip 25.0 실측) `pip config list` 를 읽는다.
+- Rocky 8 의 기본 pip(9.0.3, `pip3`)은 `config` 명령이 없고 `pip` 이름은 없다(Rocky 8.10 실측). 그래서 판 붙은 python(3.13, 3.12, 3.11)의 pip 도 차례로 본다.
+- 홈 폴더에서 읽는다. `python3 -m pip` 는 지금 폴더를 import 경로 맨 앞에 두어, 지금 폴더에 있는 남의 저장소의 `pip/` 가 실행될 수 있다.
+- bash 블록은 주소를 명령 인자가 아니라 표준 입력의 curl 설정(`-K -`)으로 넘긴다. 명령 인자는 같은 PC 의 다른 사용자가 `ps` 로 볼 수 있어, 경로나 질의에 든 토큰도 거기 싣지 않는다. 사용자 정보(`사용자:토큰@`)는 떼고 묻는다. 닿는지만 보므로 인증은 필요 없다(401 도 닿은 것이다). Windows 에서도 뗀 주소를 쓴다.
+- Windows PowerShell 에서는 같은 주소를 `curl.exe --ssl-no-revoke -sSI -o NUL --connect-timeout 5 --max-time 10 <주소>` 로 보고 `$LASTEXITCODE` 가 0 인지 본다(PowerShell 5.1 의 `curl` 은 `Invoke-WebRequest` 별칭이다). `curl.exe` 는 Windows 시스템 프록시를 따르지 않고 `HTTPS_PROXY` 만 따른다. `--ssl-no-revoke` 는 폐지 목록 서버에 닿지 못하는 망에서 Schannel 의 폐지 확인 실패를 오프라인으로 읽지 않게 한다. 닿는지만 보고 받은 내용은 쓰지 않으므로 이 확인에만 준다. `curl.exe` 가 없으면 `$LASTEXITCODE` 에 앞 명령의 값이 남으므로 `Get-Command curl.exe -ErrorAction SilentlyContinue` 로 먼저 보고, 없으면 확인하지 못한 것으로 적는다. `npm ping` 은 `Push-Location ~; npm ping --fetch-retries=0 --fetch-timeout=10000 --no-update-notifier; Pop-Location` 처럼 홈에서 부르고 돌아온다(돌아오지 않으면 뒤 단계가 프로젝트가 아니라 홈에서 돈다). PowerShell 에는 15초 감시를 두지 않는다(Windows 의 연결 시간 제한은 약 21초로 알려져 있다. 미실측).
+- 사내 미러만 열린 망이면 확인 주소를 그 미러로 바꿔 본다.
+- Codex sandbox 가 네트워크를 막는 모드(기본 `workspace-write`, `read-only`)에서는 `CODEX_SANDBOX_NETWORK_DISABLED=1` 이 서고 확인이 모두 실패한다(curl 종료 7, npm `EPERM`). 블록의 첫 줄이 그렇다고 알린다. 그때는 '오프라인' 이 아니라 'sandbox 가 네트워크를 막음' 으로 보고하고, 승인을 받아 sandbox 밖에서 확인부터 다시 한다. Claude Code sandbox 안(`SANDBOX_RUNTIME=1`)에서는 허용 목록 밖 주소를 sandbox 프록시가 막는다. Windows PowerShell 에서는 `$env:CODEX_SANDBOX_NETWORK_DISABLED -eq '1'` 로 본다.
+- 확인이 실패하면 보고에 그 명령, 종료 코드, stderr 첫 줄을 붙인다(예: `npm error code ETIMEDOUT`, `curl: (28) ...`). 원인을 '오프라인' 하나로 짐작하지 않는다.
+- curl 의 종료 60(인증서 검증 실패)도 오프라인이 아니다. 망은 열려 있고, TLS 를 가로채는 사내 프록시의 인증서를 OS 가 믿지 않는 것이다. '인증서 문제로 설치하지 않음' 으로 보고한다.
+- curl 은 닿는데 npm 만 인증서 오류(`UNABLE_TO_VERIFY_LEAF_SIGNATURE`, `SELF_SIGNED_CERT_IN_CHAIN`, `UNABLE_TO_GET_ISSUER_CERT_LOCALLY`)로 실패하면 망은 열려 있고 npm 이 사내 인증서를 믿지 않는 것이다(npm 은 OS 인증서 저장소를 쓰지 않는다). '인증서 문제로 설치하지 않음' 으로 보고하고 `NODE_EXTRA_CA_CERTS=<사내 CA 파일>` 을 안내한다. Node 24 는 `NODE_OPTIONS=--use-system-ca` 도 된다.
+
 ## 1. 사전요구(preflight)
 
 각 서버는 선행 런타임이 필요하다 - **없으면 먼저 해당 setup 스킬을 실행**(추정·강행 금지):
@@ -86,10 +124,11 @@ for c in basedpyright-langserver ruff; do command -v $c >/dev/null && echo "✓
 **jdtls (Java LSP)** - Eclipse 최신 스냅샷:
 ```bash
 mkdir -p ~/.local/jdtls
-curl -fLo /tmp/jdtls.tar.gz \
-  "https://download.eclipse.org/jdtls/snapshots/jdt-language-server-latest.tar.gz"
-tar -xzf /tmp/jdtls.tar.gz -C ~/.local/jdtls
-rm /tmp/jdtls.tar.gz
+T=$(mktemp -d) \
+  && curl -fL --connect-timeout 10 --speed-limit 1000 --speed-time 30 -o "$T/jdtls.tar.gz" \
+       "https://download.eclipse.org/jdtls/snapshots/jdt-language-server-latest.tar.gz" \
+  && tar -xzf "$T/jdtls.tar.gz" -C ~/.local/jdtls
+rm -rf "$T"
 chmod +x ~/.local/jdtls/bin/jdtls
 which jdtls        # PATH 에 ~/.local/jdtls/bin 필요
 ```
@@ -97,28 +136,31 @@ which jdtls        # PATH 에 ~/.local/jdtls/bin 필요
 
 **Spring Boot Language Server** - VSIX(=ZIP) 다운로드. vsassets.io/marketplace 가 **HTML 에러페이지**를 반환할 수 있어 **ZIP 매직바이트(`504b0304`) 검증** 후 `find` 로 `*-exec.jar` 탐색 + 심볼릭 링크:
 ```bash
+(
 set -euo pipefail
-TARGET="$HOME/.local/spring-boot-ls"; VSIX=/tmp/sbls.vsix; LINK=spring-boot-language-server.jar
+TARGET="$HOME/.local/spring-boot-ls"; T=$(mktemp -d); trap 'rm -rf "$T"' EXIT; VSIX="$T/sbls.vsix"; LINK=spring-boot-language-server.jar
 mkdir -p "$TARGET"
 VSIX_URL="https://vmware.gallery.vsassets.io/_apis/public/gallery/publisher/vmware/extension/vscode-spring-boot/latest/assetbyname/Microsoft.VisualStudio.Services.VSIXPackage"
 FALLBACK="https://marketplace.visualstudio.com/_apis/public/gallery/publishers/vmware/vsextensions/vscode-spring-boot/latest/vspackage"
-curl -fL --connect-timeout 30 --retry 2 -H "User-Agent: Mozilla/5.0" -o "$VSIX" "$VSIX_URL" 2>/dev/null \
-  || curl -fL --connect-timeout 30 --retry 2 -H "User-Agent: Mozilla/5.0" -o "$VSIX" "$FALLBACK"
+curl -fL --connect-timeout 30 --speed-limit 1000 --speed-time 30 --retry 2 -H "User-Agent: Mozilla/5.0" -o "$VSIX" "$VSIX_URL" 2>/dev/null \
+  || curl -fL --connect-timeout 30 --speed-limit 1000 --speed-time 30 --retry 2 -H "User-Agent: Mozilla/5.0" -o "$VSIX" "$FALLBACK"
 # ZIP 매직 검증 (HTML 에러페이지면 즉시 중단)
 [ "$(xxd -l 4 "$VSIX" | awk 'NR==1{print $2$3}')" = "504b0304" ] \
   || { echo "✗ ZIP 아님(HTML 에러페이지?)"; rm -f "$VSIX"; exit 1; }
-rm -rf "${TARGET:?}"/*; unzip -o -q "$VSIX" -d "$TARGET"
+find "${TARGET:?}" -mindepth 1 -delete; unzip -o -q "$VSIX" -d "$TARGET"   # 글롭 없이 비움(zsh 는 빈 폴더의 * 에서 멈춤)
 JAR=$(find "$TARGET" -name "spring-boot-language-server-*-exec.jar" | sort -V | tail -1)
 [ -n "$JAR" ] || { echo "✗ exec.jar 미발견"; rm -f "$VSIX"; exit 1; }
 ln -sf "$(basename "$JAR")" "$(dirname "$JAR")/$LINK"     # 디렉토리 이동에도 유효한 상대 링크
 rm -f "$VSIX"; find ~/.local/spring-boot-ls -name "$LINK" -ls
+)
 ```
+블록 전체가 괄호 안의 서브셸에서 돈다. `set -e`, EXIT trap, `exit 1` 이 이 블록 안에만 머물러, 같은 셸의 다음 명령을 끝내거나 그 셸이 끝날 때 다른 `T` 를 지우지 않는다.
 > Windows: 심볼릭 링크는 **개발자 모드/관리자 권한** 필요 → 없으면 `Copy-Item` 복사 fallback(둘 다 동작). 매직검증·find 는 PowerShell 로 동일 수행, JAR 경로는 `.Replace('\','/')`. RHEL8 에 `xxd` 없으면 `dnf install -y vim-common` 또는 `od -An -tx1 -N4`.
 
 ## 6. lsp-mcp 브리지 설치 (Codex 경로 - Claude Code 는 건너뜀)
 ```bash
 mkdir -p ~/.local/src
-git clone https://github.com/CesarPetrescu/lsp-mcp.git ~/.local/src/lsp-mcp
+git -c http.lowSpeedLimit=1000 -c http.lowSpeedTime=30 clone https://github.com/CesarPetrescu/lsp-mcp.git ~/.local/src/lsp-mcp
 pipx install --editable ~/.local/src/lsp-mcp     # → ~/.local/bin/codex-lsp-bridge (Windows: .exe)
 which codex-lsp-bridge && codex-lsp-bridge --help | head -5
 ```
@@ -144,7 +186,7 @@ language_id = "spring-boot-properties"
 EOF
 # TOML 유효성 (중복/문법오류 즉시 감지). tomllib 는 Python 3.11+ - RHEL8/Rocky8 기본 python3(3.6)면 setup-python 의 3.11 을 쓴다:
 PY="$(command -v python3.12 || command -v python3.11 || command -v python3)"
-"$PY" -c "import tomllib; tomllib.loads(open('config/default.toml',encoding='utf-8').read()); print('OK lsp-mcp TOML')" 2>/dev/null \
+(cd ~ && "$PY" -c "import tomllib; tomllib.loads(open('$HOME/.local/src/lsp-mcp/config/default.toml',encoding='utf-8').read()); print('OK lsp-mcp TOML')") 2>/dev/null \
   || echo "⚠ tomllib(3.11+) 미가용 - append 는 위 grep guard 로 이미 적용됨, setup-python 설치 후 재검증"
 cd - >/dev/null
 ```
@@ -156,7 +198,7 @@ cd - >/dev/null
 ### 7-Codex - `[mcp_servers.lsp_bridge]` 등록
 OMX 가 배포한 기존 엔트리를 보존하려 **Python replace-or-append** 로 patch(전체 덮어쓰기 금지):
 ```bash
-python3 - << 'PY'
+(cd ~ && python3 - << 'PY'   # 홈에서: -c, -m, 표준 입력 스크립트는 지금 폴더의 모듈을 먼저 불러온다
 import re
 from pathlib import Path
 home = str(Path.home())                        # Windows: str(Path.home()).replace("\\","/")
@@ -178,8 +220,9 @@ txt = rep(txt, "mcp_servers.lsp_bridge", block + "\n")
 p.write_text(txt, encoding="utf-8")            # Windows: encoding 필수(CP949 회피)
 print("patched")
 PY
+)
 PY="$(command -v python3.12 || command -v python3.11 || command -v python3)"   # tomllib=3.11+
-"$PY" -c "import tomllib; tomllib.loads(open('$HOME/.codex/config.toml',encoding='utf-8').read()); print('OK config.toml valid')" 2>/dev/null \
+(cd ~ && "$PY" -c "import tomllib; tomllib.loads(open('$HOME/.codex/config.toml',encoding='utf-8').read()); print('OK config.toml valid')") 2>/dev/null \
   || echo "⚠ tomllib(3.11+) 미가용 - patch 는 적용됨, setup-python 후 재검증"
 ```
 
@@ -213,7 +256,7 @@ jdtls --version 2>/dev/null || which jdtls           # Windows: jdtls.bat
 codex-lsp-bridge --help | head -3
 grep -q 'lsp_bridge' ~/.codex/config.toml && echo "✓ config.toml lsp_bridge" || echo "✗ 미등록"
 PY="$(command -v python3.12 || command -v python3.11 || command -v python3)"   # tomllib=3.11+
-"$PY" -c "import tomllib; tomllib.loads(open('$HOME/.codex/config.toml',encoding='utf-8').read()); print('✓ config.toml valid')" 2>/dev/null || echo "⚠ tomllib(3.11+) 미가용 - setup-python 후 재검증"
+(cd ~ && "$PY" -c "import tomllib; tomllib.loads(open('$HOME/.codex/config.toml',encoding='utf-8').read()); print('✓ config.toml valid')") 2>/dev/null || echo "⚠ tomllib(3.11+) 미가용 - setup-python 후 재검증"
 # Claude 만: lsp_servers 도구로 인식 서버 나열
 ```
 4-field 보고: **변경**(설치 서버·브리지·config 배선) / **Evidence**(위 --version·valid 출력) / **검증**(각 서버 응답 + 브리지·config TOML valid + 런타임 인식) / **Unknown**(네트워크 차단으로 미설치·JDK 21 부재로 java/spring 스킵 등).