triflux 10.9.32 → 10.11.0

package/CLAUDE.md

@@ -0,0 +1,159 @@
+# triflux — Claude Code 운영 가이드
+
+<core-systems>
+## 핵심 스킬 시스템 (항상 인지)
+
+이 프로젝트는 3개의 스킬 시스템을 동시에 사용한다. 어떤 작업이든 해당 시스템의 스킬이 있는지 먼저 확인한다.
+
+| 시스템 | 접두사 | 용도 | 스킬 수 |
+|--------|--------|------|---------|
+| **triflux** | `/tfx-*` | CLI 라우팅, 멀티모델 오케스트레이션, 스웜, 원격 실행 | ~40개 |
+| **gstack** | `/` (접두사 없음) | QA, ship, investigate, design, review, checkpoint | ~35개 |
+| **omc** | `/oh-my-claudecode:*` | autopilot, ralph, team, ultrawork, ccg | ~25개 |
+
+스킬을 모르면 자연어 라우팅(`.claude/rules/tfx-routing.md`)으로 자동 매핑된다.
+세션 종료 전 메모리 파일이 3개+ 변경됐으면 `/memory-hygiene` 제안을 검토한다.
+</core-systems>
+
+<psmux-wt>
+## psmux/WT 규칙
+
+psmux 세션·WT 패인을 생성/조작/정리할 때 `tfx-psmux-rules` 스킬을 참조한다.
+WT 프리징 방지: exit → sleep 2 → kill 순서. 바로 kill하지 않는다.
+
+### wt.exe → wt-manager 경유
+
+safety-guard가 `wt.exe`, `wt new-tab`, `wt split-pane`, `Start-Process wt`를 차단한다.
+`hub/team/wt-manager.mjs`의 API를 사용한다.
+
+| 용도 | API |
+|------|-----|
+| 새 탭 | `createTab({ title, command, profile, cwd })` |
+| 패인 분할 | `splitPane({ direction: 'H'\|'V', title, command })` |
+| 다중 배치 | `applySplitLayout([{ title, command, direction }])` |
+| 탭 정리 | `closeTab(title)` / `closeStale({ olderThanMs, titlePattern })` |
+
+차단과 대안은 항상 쌍으로 존재해야 한다. 차단만 추가하고 대안을 안 만들면 데드락.
+
+### raw `psmux kill-session` → psmux wrapper 경유
+
+safety-guard가 raw `psmux kill-session`을 차단한다.
+세션 정리는 `hub/team/psmux.mjs` 공개 API 또는 internal wrapper로 우회한다.
+
+| 용도 | API / 래퍼 |
+|------|------------|
+| 세션 조회 | `listSessions({ filterTitle?, olderThanMs? })` |
+| title prefix / regex kill | `killSessionByTitle(titlePattern)` |
+| stale idle 세션 정리 | `pruneStale({ olderThanMs, dryRun })` |
+| Bash 훅 우회용 래퍼 | `node hub/team/psmux.mjs --internal kill-by-title <prefix\|/regex/>` |
+
+### psmux에서 Codex 실행
+
+| 방식 | 동작 | 이유 |
+|------|------|------|
+| `codex` (interactive) | 불가 | psmux에서 TTY를 못 잡음 |
+| `codex < prompt.md` | 불가 | "stdin is not a terminal" |
+| `codex exec "$(cat prompt.md)" -s danger-full-access --dangerously-bypass-approvals-and-sandbox` | 사용 | 유일한 안전 경로 |
+
+`codex exec`는 config.toml `approval_mode`를 무시하므로 `--dangerously-bypass-approvals-and-sandbox` 필수.
+`-s` 유효값: read-only, workspace-write, danger-full-access.
+</psmux-wt>
+
+<codex-config>
+## Codex config.toml
+
+config.toml에 이미 설정된 값은 CLI 플래그로 중복 지정하지 않는다.
+
+| config.toml에 있으면 | CLI에서 생략 |
+|---------------------|-------------|
+| `approval_mode = "auto"` | `-a`, `--full-auto` |
+| `sandbox = "workspace-write"` | `-s`, `--full-auto` |
+
+안전 패턴: config.toml에 기본값을 두고, CLI에서는 `--profile` 선택만 한다.
+</codex-config>
+
+<account-broker>
+## AccountBroker (계정 브로커)
+
+conductor, headless, swarm-hypervisor가 하나의 AccountBroker 싱글턴을 공유한다.
+
+| 항목 | 설명 |
+|------|------|
+| 계정별 CircuitBreaker | 장애 격리 — 한 계정 오류가 다른 계정에 전파되지 않음 |
+| busy 플래그 | 동일 계정 이중 임대(double-lease) 방지 |
+| `/broker/reload` | 장시간 세션 중 accounts.json 핫리로드 |
+| EventEmitter 이벤트 | `lease`, `release`, `cooldown`, `tierFallback`, `circuitOpen`, `circuitClose`, `noAvailableAccounts` — HUD 연동용 |
+</account-broker>
+
+<remote>
+## 원격 실행
+
+### 스킬 구분
+
+| 스킬 | 대상 | 방식 |
+|------|------|------|
+| tfx-codex-swarm | 로컬 전용 | 로컬 worktree + psmux |
+| tfx-remote-spawn | Claude Code 원격 | SSH → Claude Code 세션 → 내부 tfx 라우팅 |
+
+codex를 SSH 너머로 직접 실행하지 않는다. config.toml 충돌 + TTY 문제.
+원격에서 codex가 필요하면: remote-spawn → Claude Code → Claude가 내부에서 codex 호출.
+
+### SSH 패턴
+
+hosts.json `os` 필드로 대상 셸을 판단한다. safety-guard도 이 필드를 참조.
+
+| 대상 OS | 셸 | 패턴 |
+|---------|-----|------|
+| windows | PowerShell | scp + `pwsh -File` 필수. `$var` → `$env:VAR`, `2>/dev/null` → `2>$null` |
+| darwin | zsh | 인라인 가능. brew PATH 주의 (`/opt/homebrew/bin`) |
+| linux | bash | 인라인 가능. 표준 POSIX |
+
+- `~` → `$HOME` 변환은 모든 OS 공통
+</remote>
+
+<headless-retrieval>
+## Headless 결과 회수
+
+background로 실행한 headless 결과는 **반드시 task-notification 완료 후** 읽는다.
+
+| 패턴 | 올바름 | 이유 |
+|------|--------|------|
+| task-notification 후 output 파일 읽기 | YES | 프로세스 종료 = 워커 전부 완료 |
+| task-notification 전 output 파일 tail | NO | 시작 메시지만 보이고 "실패"로 오진 |
+| psmux capture-pane으로 중간 체크 | NO | 워커 진행 중이면 빈 화면일 수 있음 |
+
+완료 마커: `=== HEADLESS_COMPLETE succeeded=N failed=N total=N ===`
+워커 상세: `$TMPDIR/tfx-headless/{sessionName}-worker-N.txt`
+</headless-retrieval>
+
+<cross-review>
+## 교차 검증
+
+- Claude 작성 코드 → Codex 리뷰
+- Codex 작성 코드 → Claude 리뷰
+- 동일 모델 self-approve 하지 않는다
+- git commit 전 미검증 파일 감지 시 nudge
+</cross-review>
+
+<session-context>
+## 맥락 이탈 판단
+
+현재 세션 맥락과 무관한 요청이 감지되면 psmux 격리를 제안한다.
+
+| 확신도 | 신호 | 행동 |
+|--------|------|------|
+| 확실 | "새 탭", "별도로", "새 세션" | 바로 psmux spawn |
+| 높음 | 다른 프로젝트/스택 언급 | 분리 제안 |
+| 중간 | 작업 유형 전환 | 분리 제안 + 현재 세션 옵션 |
+| 낮음 | 현재 작업 연장 | 세션 유지 |
+</session-context>
+
+## 세부 규칙은 `.claude/rules/` 참조
+
+| 파일 | 내용 |
+|------|------|
+| `.claude/rules/tfx-routing.md` | 자연어 → 스킬 라우팅, CLI 라우팅 Layer 1~3, 충돌 해소 |
+| `.claude/rules/tfx-execution-skill-map.md` | tfx-auto / multi / swarm 실행 엔진 매핑, 격리 기준, 안티패턴 |
+| `.claude/rules/tfx-update-logic.md` | triflux / OMC / gstack / Codex / Gemini 업데이트 로직 |
+
+Claude Code는 `.claude/rules/*.md` 를 자동 로드한다. Codex CLI는 `@import` 미지원이므로 필요 시 `AGENTS.md` 를 독립 유지한다.

package/bin/triflux.mjs

@@ -882,7 +882,11 @@ function getClaudeRoutingSyncSummary(results) {
     (summary, result) => ({
       changed:
         summary.changed +
-        (result.action === "created" || result.action === "updated" ? 1 : 0),
+        (result.action === "created" ||
+        result.action === "updated" ||
+        result.action === "removed"
+          ? 1
+          : 0),
       skipped: summary.skipped + (result.skipped ? 1 : 0),
     }),
     { changed: 0, skipped: 0 },

package/hooks/keyword-rules.json

@@ -664,6 +664,45 @@
       "exclusive": false,
       "state": null,
       "mcp_route": null
+    },
+    {
+      "id": "tfx-ship",
+      "patterns": [
+        {
+          "source": "\\btfx[\\s-]?ship\\b",
+          "flags": "i"
+        },
+        {
+          "source": "/ship\\b",
+          "flags": "i"
+        },
+        {
+          "source": "\\brelease\\b",
+          "flags": "i"
+        },
+        {
+          "source": "\\bpublish\\b",
+          "flags": "i"
+        },
+        {
+          "source": "배포(?!자|사|장|처)",
+          "flags": ""
+        },
+        {
+          "source": "릴리[즈스]",
+          "flags": ""
+        },
+        {
+          "source": "쉽\\s*(?:해|하자|가자|쳐)",
+          "flags": ""
+        }
+      ],
+      "skill": "tfx-ship",
+      "priority": 3,
+      "supersedes": ["gstack-ship"],
+      "exclusive": false,
+      "state": null,
+      "mcp_route": null
     }
   ]
 }

package/hub/bridge.mjs

@@ -21,6 +21,12 @@ import { fileURLToPath } from "node:url";
 import { parseArgs as nodeParseArgs } from "node:util";
 
 import { getPipelineStateDbPath } from "./pipeline/state.mjs";
+import {
+  createRetryStateMachine,
+  DEFAULT_ESCALATION_CHAIN,
+  loadSnapshot,
+  saveSnapshot,
+} from "./team/retry-state-machine.mjs";
 
 const HUB_PID_FILE = join(homedir(), ".claude", "cache", "tfx-hub", "hub.pid");
 const HUB_TOKEN_FILE = join(homedir(), ".claude", ".tfx-hub-token");
@@ -409,6 +415,10 @@ export function parseArgs(argv) {
       done: { type: "boolean" },
       "mcp-profile": { type: "string" },
       "session-key": { type: "string" },
+      snapshot: { type: "string" },
+      "snapshot-file": { type: "string" },
+      event: { type: "string" },
+      "max-iterations": { type: "string" },
     },
     allowPositionals: true,
     strict: false,
@@ -1079,6 +1089,124 @@ async function cmdHitlPending() {
   return emitJson(outcome?.result || unavailableResult());
 }
 
+// ---------------------------------------------------------------------------
+// retry-run / retry-status — Phase 3 Step C2 bridge 서브커맨드.
+// retry-state-machine.mjs 를 multi-process safe 하게 외부 호출용 wrap.
+// 사용자 워크플로우:
+//   1) 첫 호출: retry-run --snapshot X --mode ralph --event start
+//      → 새 SM 생성, PLANNING → EXECUTING transition, snapshot 저장
+//   2) verify 성공 시: retry-run --snapshot X --event verify-success
+//      → DONE, 종료 판단 반환
+//   3) verify 실패 시: retry-run --snapshot X --event verify-fail --reason R
+//      → DIAGNOSING 또는 STUCK/BUDGET_EXCEEDED, 종료 판단 반환
+//   4) 다음 iter 시작: retry-run --snapshot X --event start
+// 출력: {ok, current, iterations, done, shouldStop, reason?, cli?} JSON.
+// ---------------------------------------------------------------------------
+
+function buildRetrySmFromArgs(args, snapshot) {
+  const mode = args.mode || snapshot?.mode || "bounded";
+  const maxIterations =
+    args["max-iterations"] !== undefined
+      ? Number(args["max-iterations"])
+      : snapshot?.maxIterations;
+  const sessionId = args["session-id"] || snapshot?.sessionId || null;
+  const cliChain = snapshot?.cliChain;
+
+  const sm = createRetryStateMachine({
+    mode,
+    maxIterations,
+    sessionId,
+    cliChain,
+  });
+  if (snapshot) sm.applySnapshot(snapshot);
+  return sm;
+}
+
+async function cmdRetryRun(args) {
+  const snapshotFile = args.snapshot || args["snapshot-file"];
+  const event = args.event;
+  const reason = args.reason || "";
+
+  if (!snapshotFile) {
+    console.error("--snapshot <path> required");
+    return false;
+  }
+  if (!event) {
+    console.error("--event <start|verify-success|verify-fail> required");
+    return false;
+  }
+
+  const existing = loadSnapshot(snapshotFile);
+  const sm = buildRetrySmFromArgs(args, existing);
+
+  let result;
+  switch (event) {
+    case "start":
+      result = sm.startIteration();
+      break;
+    case "verify-success":
+      result = sm.reportVerifySuccess();
+      break;
+    case "verify-fail":
+      result = sm.reportVerifyFail(reason || "unspecified");
+      break;
+    default:
+      console.error(`unknown --event: ${event}`);
+      return false;
+  }
+
+  const snap = sm.serialize();
+  saveSnapshot(snapshotFile, snap);
+
+  const terminal = ["DONE", "STUCK", "BUDGET_EXCEEDED"].includes(snap.current);
+  const cli = snap.cliChain?.[snap.cliIndex] || null;
+  const out = {
+    ok: true,
+    current: snap.current,
+    iterations: snap.iterations,
+    cliIndex: snap.cliIndex,
+    cli,
+    done: snap.current === "DONE",
+    shouldStop: terminal,
+    stuckCounter: snap.stuckCounter,
+    lastFailureReason: snap.lastFailureReason,
+    transition: result,
+  };
+  console.log(JSON.stringify(out));
+  return true;
+}
+
+async function cmdRetryStatus(args) {
+  const snapshotFile = args.snapshot || args["snapshot-file"];
+  if (!snapshotFile) {
+    console.error("--snapshot <path> required");
+    return false;
+  }
+  const snap = loadSnapshot(snapshotFile);
+  if (!snap) {
+    console.log(JSON.stringify({ ok: true, exists: false }));
+    return true;
+  }
+  const terminal = ["DONE", "STUCK", "BUDGET_EXCEEDED"].includes(snap.current);
+  const cli = snap.cliChain?.[snap.cliIndex] || null;
+  console.log(
+    JSON.stringify({
+      ok: true,
+      exists: true,
+      current: snap.current,
+      iterations: snap.iterations,
+      maxIterations: snap.maxIterations,
+      cliIndex: snap.cliIndex,
+      cli,
+      mode: snap.mode,
+      shouldStop: terminal,
+      stuckCounter: snap.stuckCounter,
+      lastFailureReason: snap.lastFailureReason,
+    }),
+  );
+  return true;
+}
+
 export async function main(argv = process.argv.slice(2)) {
   const cmd = argv[0];
   const args = parseArgs(argv.slice(1));
@@ -1138,9 +1266,13 @@ export async function main(argv = process.argv.slice(2)) {
       return await cmdHitlSubmit(args);
     case "hitl-pending":
       return await cmdHitlPending(args);
+    case "retry-run":
+      return await cmdRetryRun(args);
+    case "retry-status":
+      return await cmdRetryStatus(args);
     default:
       console.error(
-        "사용법: bridge.mjs <register|result|control|handoff|publish|send-input|context|deregister|assign-async|assign-result|assign-status|assign-retry|team-info|team-task-list|team-task-update|team-send-message|pipeline-state|pipeline-advance|pipeline-init|pipeline-list|ping|delegator-delegate|delegator-reply|delegator-status|hitl-request|hitl-submit|hitl-pending> [--옵션]",
+        "사용법: bridge.mjs <register|result|control|handoff|publish|send-input|context|deregister|assign-async|assign-result|assign-status|assign-retry|team-info|team-task-list|team-task-update|team-send-message|pipeline-state|pipeline-advance|pipeline-init|pipeline-list|ping|delegator-delegate|delegator-reply|delegator-status|hitl-request|hitl-submit|hitl-pending|retry-run|retry-status> [--옵션]",
       );
       process.exit(1);
   }

package/hub/cli-adapter-base.mjs

@@ -147,7 +147,6 @@ export function buildExecCommand(prompt, resultFile = null, opts = {}) {
     profile,
     skipGitRepoCheck = true,
     sandboxBypass = true,
-    cwd,
     mcpServers,
   } = opts;
 

package/hub/lib/tfx-route-args.mjs

@@ -0,0 +1,222 @@
+// hub/lib/tfx-route-args.mjs
+// Phase 3 Step B — tfx-auto / tfx-route 플래그 파서.
+// 설계 문서: .triflux/plans/phase3-lead-codex-ralph-escalate.md
+//
+// 입력: ARGUMENTS 문자열 또는 토큰 배열.
+// 출력: {cli, mode, parallel, retry, isolation, remote, lead, noClaudeNative,
+//        maxIterations, task, warnings}.
+//
+// 기존 플래그 (Phase 2 v10.9.33+):
+//   --cli {auto|codex|gemini|claude}
+//   --mode {quick|deep|consensus}
+//   --parallel {1|N|swarm}
+//   --retry {0|1|ralph|auto-escalate}    (Phase 3 에서 ralph/auto-escalate 신규)
+//   --isolation {none|worktree}
+//   --remote {none|<host>}
+//
+// Phase 3 신규:
+//   --lead {claude|codex}             (tfx-auto-codex 의미 흡수)
+//   --no-claude-native                (Claude native sub-agent 경로 disable)
+//   --max-iterations <N>              (ralph / auto-escalate 상한, 0=unlimited)
+
+export const DEFAULT_OPTIONS = Object.freeze({
+  cli: "auto",
+  mode: "quick",
+  parallel: "1",
+  retry: "1",
+  isolation: "none",
+  remote: "none",
+  lead: "claude",
+  noClaudeNative: false,
+  maxIterations: 0,
+});
+
+const VALID_VALUES = Object.freeze({
+  cli: ["auto", "codex", "gemini", "claude"],
+  mode: ["quick", "deep", "consensus"],
+  retry: ["0", "1", "ralph", "auto-escalate"],
+  isolation: ["none", "worktree"],
+  lead: ["claude", "codex"],
+});
+
+const VALUE_FLAGS = new Set([
+  "--cli",
+  "--mode",
+  "--parallel",
+  "--retry",
+  "--isolation",
+  "--remote",
+  "--lead",
+  "--max-iterations",
+]);
+
+const BOOL_FLAGS = new Set(["--no-claude-native"]);
+
+export function parseArgs(input) {
+  const tokens = Array.isArray(input)
+    ? input.slice()
+    : tokenize(String(input || ""));
+  const opts = { ...DEFAULT_OPTIONS };
+  const warnings = [];
+  const taskTokens = [];
+
+  let i = 0;
+  while (i < tokens.length) {
+    const raw = tokens[i];
+
+    if (BOOL_FLAGS.has(raw)) {
+      applyBool(opts, raw);
+      i += 1;
+      continue;
+    }
+
+    // --flag=value 지원
+    const eqIdx = raw.indexOf("=");
+    let flag = raw;
+    let value = null;
+    if (eqIdx > 0 && raw.startsWith("--")) {
+      flag = raw.slice(0, eqIdx);
+      value = raw.slice(eqIdx + 1);
+    }
+
+    if (VALUE_FLAGS.has(flag)) {
+      if (value === null) {
+        const next = tokens[i + 1];
+        if (next === undefined || next.startsWith("--")) {
+          warnings.push(`${flag} needs a value`);
+          i += 1;
+          continue;
+        }
+        value = next;
+        i += 2;
+      } else {
+        i += 1;
+      }
+      applyValue(opts, flag, value, warnings);
+      continue;
+    }
+
+    if (raw.startsWith("--")) {
+      warnings.push(`unknown flag: ${raw}`);
+      i += 1;
+      continue;
+    }
+
+    taskTokens.push(raw);
+    i += 1;
+  }
+
+  validate(opts, warnings);
+
+  return {
+    ...opts,
+    task: taskTokens.join(" ").trim(),
+    warnings,
+  };
+}
+
+function tokenize(str) {
+  const tokens = [];
+  let cur = "";
+  let quote = null;
+  for (const ch of str) {
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+      } else {
+        cur += ch;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      if (cur) {
+        tokens.push(cur);
+        cur = "";
+      }
+      continue;
+    }
+    cur += ch;
+  }
+  if (cur) tokens.push(cur);
+  return tokens;
+}
+
+function applyBool(opts, flag) {
+  switch (flag) {
+    case "--no-claude-native":
+      opts.noClaudeNative = true;
+      break;
+  }
+}
+
+function applyValue(opts, flag, value, warnings) {
+  switch (flag) {
+    case "--cli":
+      opts.cli = value;
+      break;
+    case "--mode":
+      opts.mode = value;
+      break;
+    case "--parallel":
+      opts.parallel = value;
+      break;
+    case "--retry":
+      opts.retry = value;
+      break;
+    case "--isolation":
+      opts.isolation = value;
+      break;
+    case "--remote":
+      opts.remote = value;
+      break;
+    case "--lead":
+      opts.lead = value;
+      break;
+    case "--max-iterations": {
+      const n = Number.parseInt(value, 10);
+      if (Number.isNaN(n) || n < 0) {
+        warnings.push(
+          `invalid --max-iterations=${value}, expected non-negative integer (0=unlimited)`,
+        );
+      } else {
+        opts.maxIterations = n;
+      }
+      break;
+    }
+  }
+}
+
+function validate(opts, warnings) {
+  for (const key of Object.keys(VALID_VALUES)) {
+    if (!VALID_VALUES[key].includes(opts[key])) {
+      warnings.push(
+        `invalid --${key}=${opts[key]}, expected one of ${VALID_VALUES[key].join("|")}`,
+      );
+    }
+  }
+  if (
+    opts.parallel !== "1" &&
+    opts.parallel !== "swarm" &&
+    !/^\d+$/.test(opts.parallel)
+  ) {
+    warnings.push(`invalid --parallel=${opts.parallel}, expected 1|N|swarm`);
+  }
+  const parallelOne = opts.parallel === "1" || opts.parallel === 1;
+  if (parallelOne && opts.isolation === "worktree") {
+    warnings.push(
+      "--isolation worktree requires --parallel >=2 or swarm; forcing isolation=none",
+    );
+    opts.isolation = "none";
+  }
+  if (opts.remote !== "none" && opts.parallel !== "swarm") {
+    warnings.push(
+      `--remote ${opts.remote} ignored (requires --parallel swarm)`,
+    );
+  }
+}
+
+export { VALID_VALUES };

package/hub/server.mjs

@@ -1057,7 +1057,7 @@ export async function startHub({
       if (path === "/synapse/heartbeat" && req.method === "POST") {
         try {
           const body = await parseBody(req);
-          const { sessionId, ...partial } = body || {};
+          const { sessionId, partial } = body || {};
           const ok = synapseRegistry.heartbeat(sessionId, partial);
           if (!ok) {
             throw new Error("heartbeat failed");

package/hub/team/conductor.mjs

@@ -28,6 +28,7 @@ import {
   getConductorRegistry,
 } from "./conductor-registry.mjs";
 import { createEventLog } from "./event-log.mjs";
+import { buildSpawnSpecForMode, MODES } from "./execution-mode.mjs";
 import { createHealthProbe } from "./health-probe.mjs";
 import { buildLauncher } from "./launcher-template.mjs";
 import {
@@ -490,6 +491,14 @@ export function createConductor(opts = {}) {
     let recentOutput = "";
 
     const spawnCwd = session.config.workdir || launcher.cwd || undefined;
+    const spawnSpec = buildSpawnSpecForMode(MODES.HEADLESS, {
+      cli: session.config.agent,
+      prompt: session.config.prompt,
+      profile: session.config.profile,
+      model: session.config.model,
+      mcpServers: session.config.mcpServers,
+      resolveCommand: opts.deps?.resolveCliExecutable,
+    });
 
     // #90 branch guard: shard spawn cwd가 main 브랜치면 즉시 abort.
     // swarm shard는 반드시 shard 전용 worktree 브랜치에서 실행되어야 한다.
@@ -524,8 +533,8 @@ export function createConductor(opts = {}) {
 
     let child;
     try {
-      child = spawnFn(launcher.command, {
-        shell: true,
+      child = spawnFn(spawnSpec.command, spawnSpec.args, {
+        shell: false,
         cwd: spawnCwd,
         env: {
           ...process.env,
@@ -544,6 +553,7 @@ export function createConductor(opts = {}) {
         session: session.id,
         error: err.message,
         cwd: spawnCwd || null,
+        command: spawnSpec.command,
       });
       handleFailure(session, `spawn_error:${err.message}`);
       return;
@@ -561,7 +571,9 @@ export function createConductor(opts = {}) {
       session: session.id,
       agent: session.config.agent,
       pid: child.pid,
-      command: launcher.command,
+      command: spawnSpec.command,
+      args: spawnSpec.args,
+      legacyCommand: launcher.command,
       restart: session.restarts,
     });