triflux 10.40.0 → 10.41.1

package/bin/tfx-doctor.mjs

@@ -1,8 +1,13 @@
 #!/usr/bin/env node
 // tfx-doctor — triflux doctor 바로가기
+import { fileURLToPath } from "node:url";
+
 process.argv = [
   process.argv[0],
-  process.argv[1],
+  // triflux.mjs's own isMainModule() guard compares this against its real
+  // path, not this shim's — point argv[1] at triflux.mjs so it recognizes
+  // itself as the entry point instead of silently no-op'ing.
+  fileURLToPath(new URL("./triflux.mjs", import.meta.url)),
   "doctor",
   ...process.argv.slice(2),
 ];

package/bin/tfx-live.mjs

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { execFile } from "node:child_process";
+import { realpathSync } from "node:fs";
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
 import { join as pathJoin, resolve as pathResolve } from "node:path";
@@ -2368,11 +2369,19 @@ export {
   resolveAskTransport,
 };
 
-const isDirectRun =
-  process.argv[1] &&
-  fileURLToPath(import.meta.url) === pathResolve(process.argv[1]);
+function isMainModule() {
+  if (!process.argv[1]) return false;
+  const modulePath = fileURLToPath(import.meta.url);
+  try {
+    return realpathSync(process.argv[1]) === modulePath;
+  } catch {
+    // process.argv[1] doesn't resolve on disk (e.g. `node -e`) — fall back
+    // to a non-symlink-aware comparison instead of treating it as not-main.
+    return pathResolve(process.argv[1]) === modulePath;
+  }
+}
 
-if (isDirectRun) {
+if (isMainModule()) {
   main().catch((error) => {
     printJson({
       ok: false,

package/bin/tfx-setup.mjs

@@ -1,8 +1,13 @@
 #!/usr/bin/env node
 // tfx-setup — triflux setup 바로가기
+import { fileURLToPath } from "node:url";
+
 process.argv = [
   process.argv[0],
-  process.argv[1],
+  // triflux.mjs's own isMainModule() guard compares this against its real
+  // path, not this shim's — point argv[1] at triflux.mjs so it recognizes
+  // itself as the entry point instead of silently no-op'ing.
+  fileURLToPath(new URL("./triflux.mjs", import.meta.url)),
   "setup",
   ...process.argv.slice(2),
 ];

package/hub/router.mjs

@@ -1343,6 +1343,7 @@ export function createRouter(store) {
       staleTimer = setInterval(() => {
         try {
           store.sweepStaleAgents();
+          router.reelectStaleRoles();
         } catch {}
       }, 120000);
       sweepTimer.unref();
@@ -1360,6 +1361,18 @@ export function createRouter(store) {
       }
     },
 
+    reelectStaleRoles({ reason = "sweep" } = {}) {
+      for (const roleName of ROLE_TOPICS) {
+        const role = roleStates.get(roleName);
+        const leader = role?.leaderAgentId
+          ? buildRoleCandidate(role.leaderAgentId, roleName)
+          : null;
+        if (!isCandidateLive(leader)) {
+          ensureRoleLeader(roleName, { reason });
+        }
+      }
+    },
+
     getQueueDepths() {
       const counts = { urgent: 0, normal: 0, dlq: store.getAuditStats().dlq };
       for (const record of liveMessages.values()) {

package/hub/workers/claude-worker.mjs

@@ -113,6 +113,7 @@ function buildClaudeArgs(worker, options) {
   if (options.includePartialMessages) args.push("--include-partial-messages");
   if (options.replayUserMessages) args.push("--replay-user-messages");
   if (options.model) args.push("--model", options.model);
+  if (options.effort) args.push("--effort", options.effort);
   if (options.allowDangerouslySkipPermissions)
     args.push("--dangerously-skip-permissions");
   if (options.permissionMode)
@@ -143,6 +144,7 @@ export class ClaudeWorker {
     this.cwd = options.cwd || process.cwd();
     this.env = { ...process.env, ...(options.env || {}) };
     this.model = options.model || null;
+    this.effort = options.effort || null;
     this.permissionMode = options.permissionMode || null;
     this.allowDangerouslySkipPermissions =
       options.allowDangerouslySkipPermissions !== false;
@@ -323,6 +325,7 @@ export class ClaudeWorker {
 
     const args = buildClaudeArgs(this, {
       model: this.model,
+      effort: this.effort,
       permissionMode: this.permissionMode,
       allowDangerouslySkipPermissions: this.allowDangerouslySkipPermissions,
       includePartialMessages: this.includePartialMessages,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triflux",
-  "version": "10.40.0",
+  "version": "10.41.1",
   "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Antigravity, and Claude",
   "type": "module",
   "bin": {

package/scripts/__tests__/release-governance.test.mjs

@@ -165,7 +165,13 @@ describe("release governance scripts", () => {
       );
       assert.deepEqual(
         tagOnlyPublish.steps.map((step) => step.label),
-        ["git tag", "git push", "gh release create"],
+        [
+          "git tag",
+          "git push branch",
+          "git push tag",
+          "wait for tag",
+          "gh release create",
+        ],
       );
 
       const executed = [];
@@ -178,6 +184,9 @@ describe("release governance scripts", () => {
         execFileSyncFn: (command, args) => {
           executed.push([command, ...args].join(" "));
           if (command === "git" && args[0] === "rev-parse") return "tag\n";
+          if (command === "git" && args[0] === "ls-remote") {
+            return "abc123\trefs/tags/v1.2.3\n";
+          }
           if (command === "gh" && args[0] === "release") {
             return '{"tagName":"v1.2.3"}\n';
           }
@@ -187,7 +196,9 @@ describe("release governance scripts", () => {
       assert.equal(resumedPublish.allowExistingArtifacts, true);
       assert.deepEqual(executed, [
         "git rev-parse --verify v1.2.3",
-        "git push origin HEAD --tags",
+        "git push origin HEAD",
+        "git push origin v1.2.3",
+        "git ls-remote --tags origin v1.2.3",
         "gh release view v1.2.3 --json tagName",
       ]);
 
@@ -222,6 +233,41 @@ describe("release governance scripts", () => {
     }
   });
 
+  it("tag-only(CI) 모드는 preflight로 HEAD==origin/main을 검증하고 branch push를 생략한다", async () => {
+    const root = makeRepo();
+    const prevRef = process.env.GITHUB_REF_NAME;
+    process.env.GITHUB_REF_NAME = "main";
+    try {
+      assertVersionSync({ rootDir: root, fix: true });
+      const executed = [];
+      await publishRelease({
+        rootDir: root,
+        version: "1.2.3",
+        dryRun: false,
+        publishNpm: false,
+        pushBranch: false,
+        createGithubRelease: false,
+        tagPoll: { attempts: 1, sleepFn: async () => {} },
+        execFileSyncFn: (command, args) => {
+          executed.push([command, ...args].join(" "));
+          if (command === "git" && args[0] === "rev-parse") {
+            return "deadbeef\n";
+          }
+          return "";
+        },
+      });
+      assert.ok(executed.includes("git fetch origin main"));
+      assert.ok(executed.includes("git rev-parse HEAD"));
+      assert.ok(executed.includes("git rev-parse origin/main"));
+      assert.ok(executed.includes("git push origin v1.2.3"));
+      assert.ok(!executed.includes("git push origin HEAD"));
+    } finally {
+      if (prevRef === undefined) delete process.env.GITHUB_REF_NAME;
+      else process.env.GITHUB_REF_NAME = prevRef;
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
   it("release workflows use trusted publishing and skip duplicate tag publishes", () => {
     const releaseWorkflow = readFileSync(
       new URL("../../.github/workflows/release.yml", import.meta.url),
@@ -230,6 +276,7 @@ describe("release governance scripts", () => {
     assert.match(releaseWorkflow, /actions:\s*write/);
     assert.match(releaseWorkflow, /node-version:\s*24/);
     assert.match(releaseWorkflow, /publish\.mjs.*--skip-npm.*--allow-existing/);
+    assert.match(releaseWorkflow, /publish\.mjs.*--tag-only/);
     assert.match(
       releaseWorkflow,
       /gh workflow run npm-publish\.yml --ref \$\{\{ github\.ref_name \}\}/,

package/scripts/release/publish.mjs

@@ -3,6 +3,40 @@ import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { assertVersionSync, parseArgs, ROOT, runCommand } from "./lib.mjs";
 
+const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+export async function waitForRemoteTag(
+  tagName,
+  {
+    rootDir = ROOT,
+    execFileSyncFn,
+    attempts = 30,
+    intervalMs = 2000,
+    sleepFn = defaultSleep,
+  } = {},
+) {
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    try {
+      const out = runCommand(
+        "git",
+        ["ls-remote", "--tags", "origin", tagName],
+        {
+          cwd: rootDir,
+          execFileSyncFn,
+          stdio: "pipe",
+        },
+      );
+      if (String(out).includes(`refs/tags/${tagName}`)) return true;
+    } catch {
+      // Transient network/auth blips are retried below.
+    }
+    if (attempt < attempts - 1) await sleepFn(intervalMs);
+  }
+  throw new Error(
+    `Tag ${tagName} not visible on origin after ${attempts} attempts`,
+  );
+}
+
 export async function publishRelease({
   version,
   rootDir = ROOT,
@@ -12,6 +46,8 @@ export async function publishRelease({
   publishNpm = true,
   provenance = false,
   allowExistingArtifacts = false,
+  pushBranch = true,
+  tagPoll = {},
   execFileSyncFn,
 } = {}) {
   const sync = assertVersionSync({ rootDir });
@@ -73,14 +109,27 @@ export async function publishRelease({
         }))
       : []),
     { label: "git tag", command: "git", args: ["tag", `v${releaseVersion}`] },
-    {
-      label: "git push",
-      command: "git",
-      args: ["push", "origin", "HEAD", "--tags"],
-    },
   ];
+  if (pushBranch) {
+    steps.push({
+      label: "git push branch",
+      command: "git",
+      args: ["push", "origin", "HEAD"],
+    });
+  }
+  steps.push({
+    label: "git push tag",
+    command: "git",
+    args: ["push", "origin", `v${releaseVersion}`],
+  });
 
   if (createGithubRelease) {
+    steps.push({
+      label: "wait for tag",
+      kind: "wait-tag",
+      command: "git",
+      args: ["ls-remote", "--tags", "origin", `v${releaseVersion}`],
+    });
     steps.push({
       label: "gh release create",
       command: "gh",
@@ -125,11 +174,45 @@ export async function publishRelease({
   };
 
   if (!dryRun) {
+    if (!pushBranch) {
+      const branch = process.env.GITHUB_REF_NAME || "main";
+      runCommand("git", ["fetch", "origin", branch], {
+        cwd: rootDir,
+        execFileSyncFn,
+      });
+      const head = String(
+        runCommand("git", ["rev-parse", "HEAD"], {
+          cwd: rootDir,
+          execFileSyncFn,
+          stdio: "pipe",
+        }),
+      ).trim();
+      const remote = String(
+        runCommand("git", ["rev-parse", `origin/${branch}`], {
+          cwd: rootDir,
+          execFileSyncFn,
+          stdio: "pipe",
+        }),
+      ).trim();
+      if (head !== remote) {
+        throw new Error(
+          `Refusing tag-only publish: HEAD ${head} != origin/${branch} ${remote} (stale checkout or unpushed ${branch})`,
+        );
+      }
+    }
     for (const step of steps) {
       const tagName = `v${releaseVersion}`;
       if (step.label === "git tag" && shouldSkipExistingTag(tagName)) {
         continue;
       }
+      if (step.kind === "wait-tag") {
+        await waitForRemoteTag(tagName, {
+          rootDir,
+          execFileSyncFn,
+          ...tagPoll,
+        });
+        continue;
+      }
       if (
         step.label === "gh release create" &&
         shouldSkipExistingGithubRelease(tagName)
@@ -151,6 +234,7 @@ export async function publishRelease({
     publishNpm,
     provenance,
     allowExistingArtifacts,
+    pushBranch,
     dryRun,
     notesPath,
     steps: steps.map((step) => ({
@@ -175,6 +259,7 @@ if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
     publishNpm: !args["skip-npm"],
     provenance: Boolean(args.provenance || envProvenance),
     allowExistingArtifacts: Boolean(args["allow-existing"]),
+    pushBranch: !args["tag-only"],
   });
   console.log(JSON.stringify(result, null, 2));
 }

package/scripts/tfx-route-worker.mjs

@@ -77,6 +77,10 @@ function parseArgs(argv) {
         args.model = next;
         index += 1;
         break;
+      case "--effort":
+        args.effort = next;
+        index += 1;
+        break;
       case "--timeout-ms":
         args.timeoutMs = Number(next);
         index += 1;
@@ -219,6 +223,7 @@ const worker = await createWorker(args.type, {
   command: args.command,
   commandArgs: parseJsonArray(args.commandArgsJson, "--command-args-json"),
   model: args.model,
+  effort: args.effort,
   timeoutMs: args.timeoutMs,
   approvalMode: args.approvalMode,
   permissionMode: args.permissionMode,

package/scripts/tfx-route.sh

@@ -1873,12 +1873,36 @@ get_claude_model() {
   esac
 }
 
+get_claude_effort() {
+  # Claude Code exposes a separate --effort flag. Preserve high-end effort
+  # levels instead of collapsing them into "high". `claude --effort` accepts
+  # exactly low/medium/high/xhigh/max (an unknown value warns and falls back to
+  # the default).
+  case "$CLI_EFFORT" in
+    low) echo "low" ;;
+    medium) echo "medium" ;;
+    high) echo "high" ;;
+    xhigh) echo "xhigh" ;;
+    max) echo "max" ;;
+    *max*) echo "max" ;;
+    *xhigh*) echo "xhigh" ;;
+    *high*) echo "high" ;;
+    *med*) echo "medium" ;;
+    n/a|agy_v1|"") echo "" ;;
+    *low*) echo "low" ;;
+    *) echo "" ;;
+  esac
+}
+
 emit_claude_native_metadata() {
   local model
   model=$(get_claude_model)
+  local effort
+  effort=$(get_claude_effort)
   echo "ROUTE_TYPE=claude-native"
   echo "AGENT=$AGENT_TYPE"
   echo "MODEL=$model"
+  echo "EFFORT=$effort"
   echo "RUN_MODE=$RUN_MODE"
   echo "OPUS_OVERSIGHT=$OPUS_OVERSIGHT"
   echo "TIMEOUT=$TIMEOUT_SEC"
@@ -3022,8 +3046,9 @@ EOF
     fi
 
   elif [[ "$CLI_TYPE" == "claude" ]]; then
-    local claude_model
+    local claude_model claude_effort
     claude_model=$(get_claude_model)
+    claude_effort=$(get_claude_effort)
     local -a claude_worker_args=(
       "--command" "$CLI_CMD"
       "--command-args-json" "$CLAUDE_BIN_ARGS_JSON"
@@ -3031,6 +3056,7 @@ EOF
       "--permission-mode" "bypassPermissions"
       "--allow-dangerously-skip-permissions"
     )
+    [ -n "$claude_effort" ] && claude_worker_args+=("--effort" "$claude_effort")
 
     run_stream_worker "claude" "$FULL_PROMPT" "$use_tee" "${claude_worker_args[@]}" || exit_code=$?
     if [[ "$exit_code" -ne 0 && "$exit_code" -ne 124 ]]; then

package/skills/tfx-auto/SKILL.md

@@ -72,7 +72,9 @@ echo "USER_PREFERRED_MODE: ${USER_MODE:-none}"
 > **MANDATORY RULES**
 >
 > 1. **실행**: CLI 에이전트는 반드시 `Bash("bash ~/.claude/scripts/tfx-route.sh ...")`. Claude 네이티브(explore/verifier/test-engineer/qa-tester)만 `Agent()`.
-> 2. **비용**: Codex 우선 → Antigravity → Claude 최후 수단. `claude` 선택 전 "Codex로 가능한가?" 재확인.
+> 2. **비용/편향 분리**: 실행 워커 비용은 Codex/Antigravity 우선으로 낮추되, consensus/debate/panel에서는 Claude/Opus를 최후수단이 아니라 counter-bias outvoice로 둔다. Claude가 실행을 맡는 경우는 명시적 `--cli claude`, Claude-native host role, 또는 fallback뿐이다.
+> 2-a. **Anti-bias triad**: Triflux의 본가 목적은 Codex↔Claude 균형으로 단일 모델 편향을 줄이는 것이다. `triad`는 Claude/Opus(counter-bias outvoice) + Codex(implementation/reality check) + Antigravity(product/UX auxiliary)를 보존하고, disputed/minority view를 삭제하지 않는다.
+> 2-b. **Claude effort**: Claude lane은 Claude Code CLI의 `--model`과 `--effort`를 사용한다. Triflux의 `CLI_EFFORT`/profile 값은 `low|medium|high|xhigh|max` Claude effort로 매핑한다(`ultracode`는 `claude --effort` 값이 아니라 하니스 모드이므로 기본 effort로 매핑된다). skill 문서가 모델 ID를 하드코딩하지 않는다.
 > 3. **DAG**: SEQUENTIAL/DAG이면 레벨 기반 순차 실행. `.omc/context/{sid}/` 생성, context_output 저장, 실패 시 후속 SKIP.
 > 4. **트리아지**: Codex `exec --full-auto` 분류 + Opus 인라인 분해. Agent 스폰 금지.
 > 5. **thorough**: `-t`/`--thorough` 시 파이프라인 init 필수. 커맨드 숏컷은 항상 quick.
@@ -114,7 +116,7 @@ ARGUMENTS 에 아래 플래그가 있으면 Step 0 스마트 라우팅의 내부
 | `--shape` | `debate` | 옵션 비교 + 점수화 + 최종 추천 | debate renderer |
 | `--shape` | `panel` | 전문가 roster 기반 시뮬레이션 | panel renderer |
 | `--cli-set` | `triad` (기본) | Claude + Codex + Antigravity | consensus participants |
-| `--cli-set` | `no-antigravity` | Claude + Codex partial degrade | consensus participants |
+| `--cli-set` | `no-antigravity` | Claude/Opus outvoice + Codex partial degrade | consensus participants |
 | `--cli-set` | `custom` | 기존 3 CLI 내부 subset/repetition 만 허용 | consensus participants |
 | `--options` | `"A|B|C"` | debate 비교 대상 | debate normalizer |
 | `--criteria` | `"latency|complexity|operability"` | debate 평가 기준 | debate normalizer |
@@ -284,8 +286,8 @@ shape 의미:
 
 | 값 | 의미 | 비고 |
 |----|------|------|
-| `triad` | Claude + Codex + Antigravity | 기본값 |
-| `no-antigravity` | Claude + Codex | Antigravity 미가용 degrade |
+| `triad` | Claude/Opus outvoice + Codex + Antigravity | 기본값 |
+| `no-antigravity` | Claude/Opus outvoice + Codex | Antigravity 미가용 degrade |
 | `custom` | 기존 3 CLI 내부 subset/repetition 만 허용 | 신규 provider 추가 금지 |
 
 shape 입력 정규화:
@@ -331,7 +333,7 @@ shape 별 `shape_input`:
 2. `--mode consensus` 확인
 3. `--shape` 기본값 보정 (`consensus`)
 4. shape 별 payload 정규화
-5. Claude native + headless Codex/Antigravity 동시 dispatch
+5. Claude/Opus outvoice + headless Codex/Antigravity 동시 dispatch
 6. 결과 수집
 7. 공통 `meta_judgment` 생성
 8. shape renderer 로 markdown/json 출력
@@ -386,7 +388,7 @@ shape 별 orchestration 정책:
 
 - 목적: 각 participant 의 findings 를 합의/충돌 항목으로 압축하고 `FIX_FIRST` / `merge` / `defer` 같은 실행 결정을 빠르게 내린다.
 - 수집 단위: 옵션 비교가 아니라 finding/assertion 단위다. 동일 결론이라도 근거가 다르면 separate evidence 로 보존한다.
-- 합의 판정: 3자 중 2자 이상이 같은 remediation 또는 risk assessment 를 지지하면 provisional agreement 로 분류하고, Claude 가 최종 `resolved_items` 승격 여부를 결정한다.
+- 합의 판정: 3자 중 2자 이상이 같은 remediation 또는 risk assessment 를 지지하면 provisional agreement 로 분류하고, Claude/Opus outvoice가 반론을 제공하고 lead가 최종 `resolved_items` 승격 여부를 결정한다.
 - 충돌 승격: P1/P2 급 충돌은 score 와 무관하게 `user_decision_needed` 또는 `FIX_FIRST` 로 승격한다. score 가 높아도 안전 이슈를 묻지 않는다.
 - degrade: `no-antigravity` 또는 partial timeout 시 2자 합의를 허용하되 root meta 의 `status=partial` 과 누락 participant 이유를 반드시 남긴다.
 
@@ -559,7 +561,7 @@ shape 별 orchestration 정책:
 - roster 규칙: `--experts` 미지정 시 기본 roster 를 채우되 각 CLI 가 서로 다른 전문성을 대표하도록 배분한다. 동일 전문가를 중복 배정하지 않는다.
 - 발언 구조: participant raw answer 를 그대로 이어붙이지 말고 `expert -> thesis -> supporting evidence -> concern -> recommendation` 구조로 정리한다.
 - 합의 규칙: panel 은 unanimity 보다 "majority view + minority view + open questions" 보존이 중요하다. minority 가 P1/P2 를 제기하면 별도 `open_questions` 로 승격한다.
-- moderator 역할: Claude 는 moderator 로서 panel synthesis 를 담당하지만, 자기 의견을 추가 participant 처럼 중복 집계하지 않는다.
+- moderator 역할: Claude/Opus outvoice 는 moderator 로서 panel synthesis 를 담당하지만, 자기 의견을 추가 participant 처럼 중복 집계하지 않는다.
 
 출력 schema 예시:
 
@@ -853,7 +855,9 @@ Agent(subagent_type="oh-my-claudecode:{agent}", model="{model}", prompt="{prompt
 
 | 입력 | CLI | MCP |
 |------|-----|-----|
-| codex / executor / build-fixer / spark / debugger / deep-executor | Codex | implement |
+| codex / executor / spark | Codex (high; 복잡 구현은 deep-executor/xhigh) | implement |
+| debugger / deep-executor | Codex (xhigh) | implement |
+| build-fixer | Codex (low) | implement |
 | architect / planner / critic / analyst | Codex (xhigh) | analyze |
 | scientist / document-specialist | Codex | analyze |
 | code-reviewer / security-reviewer / quality-reviewer | Codex (review) | review |

package/skills/tfx-consensus/SKILL.md

@@ -43,6 +43,7 @@ echo "$(date -u +%Y-%m-%dT%H:%M:%SZ) tfx-consensus -> tfx-auto --mode consensus"
 tfx-consensus 는 여전히 consensus family 의 canonical semantics 를 대표하지만, 별도 엔진으로 유지하지 않는다. Phase 4a 부터 공통 orchestration, participant 상태, artifact 경로, `meta_judgment` 스키마를 `tfx-auto --mode consensus` 가 소유한다.
 
 공통 계약:
+- Triflux anti-bias contract: `triad`는 Claude/Opus counter-bias outvoice + Codex implementation/reality check + Antigravity product/UX auxiliary 관점을 보존한다. Claude/Opus는 합의에서 minority/dispute를 지우는 최종 심판이 아니라 반론/위험/필요 증거를 명시하는 outvoice다.
 - artifact 경로: `.omc/artifacts/consensus/<session-id>/consensus.{md,json}`
 - 공통 메타 유틸: `hub/team/consensus-meta.mjs`
 - 공통 root 메타: `mode`, `shape`, `topic`, `cli_set`, `participants`, `status`

package/skills/tfx-debate/SKILL.md

@@ -48,8 +48,8 @@ echo "$(date -u +%Y-%m-%dT%H:%M:%SZ) tfx-debate -> tfx-auto --mode consensus --s
 tfx-debate 의 본질은 "3-CLI 토론 엔진"이 아니라 "옵션 비교와 최종 추천을 내는 보고서 shape" 였다. Phase 4a 부터 orchestration root 는 `--mode consensus` 로 통합되고, debate 의미는 `--shape debate` 로 보존된다.
 
 공통 규약:
-- participants 기본값은 `triad` (Claude + Codex + Antigravity)
-- `--cli-set no-antigravity` 시 partial consensus 로 degrade 가능
+- participants 기본값은 `triad` (Claude/Opus counter-bias outvoice + Codex + Antigravity)
+- `--cli-set no-antigravity` 시 Claude/Opus + Codex partial consensus 로 degrade 가능
 - 공통 `meta_judgment` 는 `hub/team/consensus-meta.mjs` 스키마를 따른다
 
 ## 마이그레이션 가이드

package/skills/tfx-panel/SKILL.md

@@ -48,7 +48,7 @@ echo "$(date -u +%Y-%m-%dT%H:%M:%SZ) tfx-panel -> tfx-auto --mode consensus --sh
 tfx-panel 의 본질은 "패널 전용 orchestration" 이 아니라 "전문가 roster 를 주입한 뒤 panel 보고서로 렌더링하는 shape" 였다. Phase 4a 부터 공통 합의 루프는 `--mode consensus` 아래에 남기고, 전문가 분배와 panel renderer 만 `--shape panel` 이 책임진다.
 
 공통 규약:
-- participants 기본값은 `triad`
+- participants 기본값은 `triad` (Claude/Opus counter-bias outvoice + Codex + Antigravity)
 - 공통 `meta_judgment` 는 `mode_specific_meta.panel_size`, `mode_specific_meta.expert_distribution` 만 shape 확장으로 추가한다
 - artifact 경로는 `.omc/artifacts/consensus/<session-id>/panel.{md,json}` 로 통일한다