@triflux/remote 10.50.2 → 10.52.0

package/cto/status.mjs

@@ -2,16 +2,9 @@ import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
 import { compactHygieneCounts, projectCtoHygiene } from "./hygiene.mjs";
-import {
-  normalizeLiveSession,
-  pathLabel,
-  readSynapseSnapshot,
-  resolveLakeRootDir,
-  shortHash,
-} from "./lake-root.mjs";
+import { resolveLakeRootDir } from "./lake-root.mjs";
 
 const SCHEMA_VERSION = "cto-lake.v1";
-const SYNAPSE_TIMEOUT_MS = 1500;
 
 function hasFlag(args, flag) {
   return Array.isArray(args) && args.includes(flag);
@@ -25,174 +18,7 @@ function readJson(filePath) {
   return JSON.parse(readFileSync(filePath, "utf8"));
 }
 
-export function deriveRepoRootFromCwd(cwd) {
-  if (typeof cwd !== "string" || !cwd) return "";
-  if (cwd.includes("\\") || /^[A-Za-z]:/u.test(cwd)) return cwd;
-
-  const normalized = cwd.replace(/\/+$/u, "");
-  const gitWorktreeMarker = "/.worktrees/";
-  const gitWorktreeIndex = normalized.indexOf(gitWorktreeMarker);
-  if (gitWorktreeIndex > 0) {
-    const suffix = normalized.slice(
-      gitWorktreeIndex + gitWorktreeMarker.length,
-    );
-    if (/^[^/]+(?:\/|$)/u.test(suffix)) {
-      return normalized.slice(0, gitWorktreeIndex);
-    }
-  }
-
-  const claudeMarker = "/.claude/worktrees/";
-  const claudeIndex = normalized.indexOf(claudeMarker);
-  if (claudeIndex > 0) {
-    const suffix = normalized.slice(claudeIndex + claudeMarker.length);
-    if (/^[^/]+(?:\/|$)/u.test(suffix)) {
-      return normalized.slice(0, claudeIndex);
-    }
-  }
-
-  const codexMarker = "/.codex-swarm/";
-  const codexIndex = normalized.indexOf(codexMarker);
-  if (codexIndex > 0) {
-    const suffix = normalized.slice(codexIndex + codexMarker.length);
-    if (/^wt-[^/]+(?:\/|$)/u.test(suffix)) {
-      return normalized.slice(0, codexIndex);
-    }
-  }
-
-  return cwd;
-}
-
-function redactedCwdFields(cwd) {
-  if (typeof cwd !== "string" || !cwd) return {};
-  const repoRoot = deriveRepoRootFromCwd(cwd);
-  return {
-    cwdLabel: pathLabel(cwd),
-    cwdHash: shortHash(cwd),
-    repoRootLabel: pathLabel(repoRoot),
-    repoRootHash: shortHash(repoRoot),
-  };
-}
-
-function normalizeActiveShard(shard) {
-  return {
-    shard_name:
-      typeof shard?.shard_name === "string"
-        ? shard.shard_name
-        : typeof shard?.shardName === "string"
-          ? shard.shardName
-          : typeof shard?.name === "string"
-            ? shard.name
-            : typeof shard?.id === "string"
-              ? shard.id
-              : null,
-    phase:
-      typeof shard?.phase === "string"
-        ? shard.phase
-        : typeof shard?.status === "string"
-          ? shard.status
-          : "active",
-    members: Array.isArray(shard?.members)
-      ? shard.members.map((member) => String(member))
-      : [],
-  };
-}
-
-function normalizeSynapseOverlay(value) {
-  const sessions = Array.isArray(value)
-    ? value
-    : Array.isArray(value?.sessions)
-      ? value.sessions
-      : Array.isArray(value?.live_sessions)
-        ? value.live_sessions
-        : [];
-  const activeShards = Array.isArray(value?.active_shards)
-    ? value.active_shards
-    : Array.isArray(value?.activeShards)
-      ? value.activeShards
-      : [];
-
-  return {
-    live_sessions: sessions
-      .map((session) => ({
-        ...normalizeLiveSession(session),
-        host: typeof session?.host === "string" ? session.host : "local",
-        ...redactedCwdFields(session?.cwd),
-      }))
-      .filter((session) => session.sessionId),
-    active_shards: activeShards.map(normalizeActiveShard),
-  };
-}
-
-function withTimeout(promise, timeoutMs = SYNAPSE_TIMEOUT_MS) {
-  let timer = null;
-  const timeout = new Promise((_, reject) => {
-    timer = setTimeout(
-      () => reject(new Error("synapse read timeout")),
-      timeoutMs,
-    );
-    if (typeof timer.unref === "function") timer.unref();
-  });
-  return Promise.race([Promise.resolve(promise), timeout]).finally(() => {
-    if (timer) clearTimeout(timer);
-  });
-}
-
-async function readSynapseOverlay(opts) {
-  try {
-    const reader = opts.synapseReader || readSynapseSnapshot;
-    const raw = await withTimeout(
-      reader({
-        rootDir: opts.rootDir,
-        lakeRoot: opts.lakeRoot,
-        synapsePersistPath: opts.synapsePersistPath,
-      }),
-      opts.synapseTimeoutMs || SYNAPSE_TIMEOUT_MS,
-    );
-    return normalizeSynapseOverlay(raw);
-  } catch {
-    return { live_sessions: [], active_shards: [] };
-  }
-}
-
-// active_shards 의 source 는 live_sessions 와 다르다: live_sessions 는 synapse
-// overlay(실시간 세션)에서, active_shards 는 collect 가 .triflux/swarm-locks.json 을
-// snapshot 한 current.json(sources.tfx_swarm.detail.shards)에서 온다. synapse
-// overlay 가 shard 를 채우는 경로가 생기면 그쪽을 우선하고, 없으면 snapshot 으로
-// fallback 한다(현재 overlay 의 active_shards 는 항상 비어 snapshot 을 쓴다).
-function deriveActiveShards(current, overlay) {
-  // overlay(synapse)가 채운 shard 중 식별 가능한 것만 authoritative 로 본다.
-  // normalizeSynapseOverlay 가 shard_name 을 null 로 정규화한 무효 행이 snapshot
-  // fallback 을 가로채지 않도록 먼저 거른다.
-  const overlayShards = Array.isArray(overlay?.active_shards)
-    ? overlay.active_shards.filter((shard) => shard?.shard_name)
-    : [];
-  if (overlayShards.length > 0) return overlayShards;
-  const shards = current?.sources?.tfx_swarm?.detail?.shards;
-  if (!Array.isArray(shards)) return [];
-  return shards.map(normalizeActiveShard).filter((shard) => shard.shard_name);
-}
-
-function deriveLiveSessionGroups(liveSessions) {
-  const groups = new Map();
-  for (const session of liveSessions || []) {
-    if (!session?.repoRootHash) continue;
-    if (!groups.has(session.repoRootHash)) {
-      groups.set(session.repoRootHash, {
-        repoRootLabel: session.repoRootLabel || "",
-        repoRootHash: session.repoRootHash,
-        session_count: 0,
-        sessions: [],
-      });
-    }
-    const group = groups.get(session.repoRootHash);
-    group.session_count += 1;
-    group.sessions.push(session.sessionId);
-  }
-  return [...groups.values()];
-}
-
-function projectStatus(current, overlay) {
-  const liveSessions = overlay.live_sessions;
+function projectStatus(current) {
   return {
     schema_version: current?.schema_version || SCHEMA_VERSION,
     generated_at: current?.generated_at || null,
@@ -200,10 +26,7 @@ function projectStatus(current, overlay) {
     sources: current?.sources || {},
     summary: current?.summary || {},
     ledger_tail: Array.isArray(current?.ledger_tail) ? current.ledger_tail : [],
-    live_sessions: liveSessions,
-    live_session_groups: deriveLiveSessionGroups(liveSessions),
-    active_shards: deriveActiveShards(current, overlay),
-    hygiene: compactHygieneCounts(projectCtoHygiene({ current, overlay })),
+    hygiene: compactHygieneCounts(projectCtoHygiene({ current })),
   };
 }
 
@@ -262,7 +85,7 @@ function renderHumanStatus(status, now) {
     `generated_at: ${status.generated_at || "unknown"} (${formatSnapshotAge(status.generated_at, now)})`,
     `repo: ${formatRepo(status.repo)}`,
     `sources: ${available}/${total} available`,
-    `active: ${status.live_sessions.length} sessions, ${status.active_shards.length} shards, ${activeGoals} goals`,
+    `active: ${activeGoals} goals`,
   ];
   if (recent.length) {
     lines.push("ledger:");
@@ -292,12 +115,7 @@ export async function runStatus(args = [], opts = {}) {
   }
 
   const current = readJson(currentPath);
-  const overlay = await readSynapseOverlay({
-    ...opts,
-    rootDir,
-    lakeRoot,
-  });
-  const status = projectStatus(current, overlay);
+  const status = projectStatus(current);
 
   if (jsonOut) writeJson(stdout, status);
   else stdout.write(renderHumanStatus(status, opts.now ?? Date.now()));

package/hub/index.mjs

@@ -1,21 +1,4 @@
 // @triflux/remote — barrel export (auto-generated by pack.mjs)
-// Server
-export { startHub, getHubInfo, getOrCreateServer } from './server.mjs';
-
-// Store
-export { createStoreAdapter } from './store-adapter.mjs';
-
-// Pipe
-export { createPipeServer, getPipePath } from './pipe.mjs';
-
 // Team
 export { orchestrate, decomposeTask, buildLeadPrompt, buildPrompt } from './team/orchestrator.mjs';
 export { createPsmuxSession, startCapture } from './team/psmux.mjs';
-export { createConductor } from './team/conductor.mjs';
-
-// Swarm
-export { createSwarmLocks } from './team/swarm-locks.mjs';
-export { parseShards, buildFileLeaseMap, buildMcpManifest, computeMergeOrder, planSwarm } from './team/swarm-planner.mjs';
-export { createSwarmHypervisor, SWARM_STATES } from './team/swarm-hypervisor.mjs';
-export { reconcile, buildRedundantIds, shouldRunRedundant } from './team/swarm-reconciler.mjs';
-export { ensureWorktree, prepareIntegrationBranch, rebaseShardOntoIntegration, pruneWorktree, fetchRemoteShard } from './team/worktree-lifecycle.mjs';

package/hub/team/agent-map.json

@@ -23,7 +23,6 @@
   "test-engineer": "codex",
   "qa-tester": "codex",
   "codex": "codex",
-  "gemini": "antigravity",
   "antigravity": "antigravity",
   "agy": "antigravity",
   "claude": "claude"

package/hub/team/agents-row-attach.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+# claude agents 행의 백킹 PTY 안에서 워커 tmux pane 에 붙는다.
+# bg-pty-host 가 출력 이력을 다시 재생하면 바깥 터미널이 tmux 의 오래된 질의에 또 답한다.
+# tmux 는 늦게 온 응답을 키 입력으로 넘기므로 여기서 응답 시퀀스를 걸러 낸다.
+import fcntl
+import os
+import pty
+import re
+import select
+import signal
+import sys
+import termios
+import time
+import tty
+
+# DA1/DA2/DA3, 창 크기 보고(CSI ... t), DECRQM, kitty 키보드 플래그 응답, DCS, OSC
+REPLY = re.compile(
+    rb"\x1b\[[?>=][0-9;]*c"
+    rb"|\x1b\[[0-9]+(?:;[0-9]+)*t"
+    rb"|\x1b\[\?[0-9;]*\$y"
+    rb"|\x1b\[\?[0-9]*u"
+    rb"|\x1bP[^\x1b]*\x1b\\"
+    rb"|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)"
+)
+# 응답이 read 경계에서 잘렸을 때 잠깐 붙잡아 둘 접두
+PARTIAL = re.compile(
+    rb"(?:\x1b\[[?>=]?[0-9;$]*|\x1bP[^\x1b]*\x1b?|\x1b\][^\x07\x1b]*\x1b?)\Z"
+)
+HOLD_SEC = 0.05
+
+
+def strip_replies(buf):
+    """걸러 낸 바이트와, 다음 read 까지 보류할 꼬리를 돌려준다."""
+    cleaned = REPLY.sub(b"", buf)
+    m = PARTIAL.search(cleaned)
+    if m and cleaned[m.start():] != b"\x1b":
+        return cleaned[: m.start()], cleaned[m.start():]
+    return cleaned, b""
+
+
+def copy_winsize(src, dst):
+    try:
+        size = fcntl.ioctl(src, termios.TIOCGWINSZ, b"\0" * 8)
+        fcntl.ioctl(dst, termios.TIOCSWINSZ, size)
+    except OSError:
+        pass
+
+
+def relay(argv, env):
+    pid, fd = pty.fork()
+    if pid == 0:
+        os.execvpe(argv[0], argv, env)
+    stdin = sys.stdin.fileno()
+    stdout = sys.stdout.fileno()
+    copy_winsize(stdin, fd)
+    signal.signal(signal.SIGWINCH, lambda *_: copy_winsize(stdin, fd))
+    saved = termios.tcgetattr(stdin) if os.isatty(stdin) else None
+    if saved:
+        tty.setraw(stdin)
+    pending = b""
+    deadline = 0.0
+    try:
+        while True:
+            # 자식 출력이 계속 바빠도 보류한 바이트가 HOLD_SEC 를 넘겨 묶이지 않게 마감을 둔다.
+            timeout = max(0.0, deadline - time.monotonic()) if pending else None
+            try:
+                ready, _, _ = select.select([stdin, fd], [], [], timeout)
+            except InterruptedError:
+                continue
+            if pending and time.monotonic() >= deadline:
+                os.write(fd, pending)
+                pending = b""
+            if fd in ready:
+                try:
+                    data = os.read(fd, 65536)
+                except OSError:
+                    break
+                if not data:
+                    break
+                os.write(stdout, data)
+            if stdin in ready:
+                # 행 PTY 가 닫히면 slave 읽기는 EIO 를 던진다.
+                try:
+                    data = os.read(stdin, 65536)
+                except OSError:
+                    break
+                if not data:
+                    break
+                out, held = strip_replies(pending + data)
+                if held and not pending:
+                    deadline = time.monotonic() + HOLD_SEC
+                pending = held
+                if out:
+                    os.write(fd, out)
+    finally:
+        if saved:
+            try:
+                termios.tcsetattr(stdin, termios.TCSADRAIN, saved)
+            except termios.error:
+                pass
+    # 행 PTY 가 닫히면 attach client 도 끝낸다. 워커 방은 그대로 남는다.
+    os.close(fd)
+    _, status = os.waitpid(pid, 0)
+    return os.waitstatus_to_exitcode(status)
+
+
+def main():
+    # 사용법: agents-row-attach.py -- <tmux attach 명령>
+    argv = sys.argv[1:]
+    if argv[:1] == ["--"]:
+        argv = argv[1:]
+    if not argv:
+        print("usage: agents-row-attach.py -- <command>", file=sys.stderr)
+        return 2
+    env = {k: v for k, v in os.environ.items() if k not in ("TMUX", "TMUX_PANE")}
+    return relay(argv, env)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/hub/team/agents-row.mjs

@@ -0,0 +1,200 @@
+// hub/team/agents-row.mjs: 워커 tmux pane 을 `claude agents` 행으로 노출한다.
+// 행의 백킹 job 은 공식 `claude --bg --exec` 로 띄운 tmux attach client 다.
+// Enter 를 누르면 그 PTY, 곧 워커가 도는 tmux 방이 열린다(ADR-0026).
+
+import { execFile } from "node:child_process";
+import { accessSync, constants } from "node:fs";
+import { delimiter, dirname, isAbsolute, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { getMultiplexerType, psmuxExec } from "./psmux.mjs";
+
+const execFileAsync = promisify(execFile);
+const ATTACH_HELPER = join(
+  dirname(fileURLToPath(import.meta.url)),
+  "agents-row-attach.py",
+);
+const READ_ONLY_SUFFIX = " [read-only]";
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+
+// daemon 이 띄운 셸의 PATH 는 호출자와 다를 수 있어 절대 경로로 넘긴다.
+export function resolveExecutable(name, envPath = process.env.PATH || "") {
+  if (isAbsolute(name)) return name;
+  for (const dir of envPath.split(delimiter)) {
+    if (!dir) continue;
+    const candidate = join(dir, name);
+    try {
+      accessSync(candidate, constants.X_OK);
+      return candidate;
+    } catch {
+      /* 다음 후보 */
+    }
+  }
+  return "";
+}
+
+/** tmux target 을 서버 안에서 유일한 socket/session/pane ID 로 고정한다. */
+export function resolveTmuxPane(target, { tmux = psmuxExec } = {}) {
+  const out = tmux([
+    "display-message",
+    "-p",
+    "-t",
+    String(target),
+    "#{socket_path}\t#{session_id}\t#{pane_id}\t#{session_name}",
+  ]);
+  const [socketPath, sessionId, paneId, sessionName] = String(out)
+    .trim()
+    .split("\t");
+  if (!socketPath || !/^\$\d+$/u.test(sessionId) || !/^%\d+$/u.test(paneId)) {
+    throw new Error(`tmux pane을 확인할 수 없습니다: ${target}`);
+  }
+  return { socketPath, sessionId, paneId, sessionName };
+}
+
+/**
+ * 행의 백킹 명령. pane 이 등록한 세션에 그대로 있는 동안 attach 를 반복하고,
+ * 방이 사라지면 자기 행을 지운다. 대화형은 python3 중계로 터미널 응답 누수를 걸러 내고,
+ * 그 밖에는 읽기 전용 attach 로 입력 자체를 막는다.
+ */
+export function buildAgentsRowCommand({
+  tmuxBin,
+  claudeBin = "claude",
+  pane,
+  interactive = false,
+  python = "",
+}) {
+  const q = shellQuote;
+  const tmux = `${q(tmuxBin)} -S ${q(pane.socketPath)}`;
+  const readOnly = !(interactive && python);
+  const attach = [
+    ...(readOnly ? [] : [q(python), q(ATTACH_HELPER), "--"]),
+    "env -u TMUX -u TMUX_PANE",
+    tmux,
+    `attach-session -t ${q(pane.paneId)}`,
+    // -r 은 read-only,ignore-size 와 같고 tmux 3.2 이전에도 있다.
+    ...(readOnly ? ["-r"] : []),
+  ].join(" ");
+  // 같은 번호의 다른 방에 붙지 않도록 pane 의 세션 ID 를 매번 대조한다.
+  const alive = `[ "$(${tmux} display-message -p -t ${q(pane.paneId)} '#{session_id}' 2>/dev/null)" = ${q(pane.sessionId)} ]`;
+  // CLAUDE_JOB_DIR 의 끝이 이 job 의 short id 다. job 이 끝난 뒤 지우도록 nohup 으로 띄운다.
+  const removeSelf = `nohup sh -c 'sleep 1; exec "$0" rm "\${CLAUDE_JOB_DIR##*/}"' ${q(claudeBin)} >/dev/null 2>&1 &`;
+  // attach 가 바로 끝나기를 5번 연달아 반복하면 고칠 수 없는 실패로 보고 멈춘다.
+  const loop = `n=0; while ${alive}; do t=$(date +%s); ${attach}; if [ $(($(date +%s) - t)) -lt 2 ]; then n=$((n + 1)); else n=0; fi; [ "$n" -ge 5 ] && break; sleep 1; done`;
+  return { readOnly, command: `${loop}; ${removeSelf}` };
+}
+
+// macOS 에는 CLT 설치 안내만 띄우는 /usr/bin/python3 스텁이 있어 실제로 한 번 돌려 본다.
+async function usablePython(resolve, run) {
+  const python = resolve("python3");
+  if (!python) return "";
+  try {
+    await run(python, ["-c", "import pty"], { timeout: 5_000 });
+    return python;
+  } catch {
+    return "";
+  }
+}
+
+export function parseBackgroundShort(stdout) {
+  const match = /backgrounded · ([0-9a-f]{6,}) ·/u.exec(String(stdout));
+  return match ? match[1] : "";
+}
+
+/**
+ * 워커 pane 하나를 `claude agents` 행으로 연다.
+ * @returns {Promise<{short:string, name:string, readOnly:boolean, pane:object}>}
+ */
+export async function openAgentsRow({
+  name,
+  target,
+  cwd = process.cwd(),
+  interactive = false,
+  _deps = {},
+} = {}) {
+  if (!name) throw new Error("name is required");
+  const tmux = _deps.tmux || psmuxExec;
+  const run = _deps.execFile || execFileAsync;
+  const resolve = _deps.resolveExecutable || resolveExecutable;
+  const pane = resolveTmuxPane(target, { tmux });
+  const tmuxBin = resolve(getMultiplexerType()) || getMultiplexerType();
+  const claudeBin = _deps.claudeBin || resolve("claude") || "claude";
+  const python = interactive ? await usablePython(resolve, run) : "";
+  const { command, readOnly } = buildAgentsRowCommand({
+    tmuxBin,
+    claudeBin,
+    pane,
+    interactive,
+    python,
+  });
+  // 대화형인데 읽기 전용으로 떨어졌으면 행 이름에서 바로 보이게 한다.
+  const rowName = interactive && readOnly ? `${name}${READ_ONLY_SUFFIX}` : name;
+  const { stdout = "", stderr = "" } = await run(
+    claudeBin,
+    ["--bg", "--name", rowName, "--exec", command],
+    { cwd, timeout: 20_000, encoding: "utf8" },
+  );
+  const short = parseBackgroundShort(`${stdout}\n${stderr}`);
+  if (!short) {
+    throw new Error(`claude --bg 출력에서 id를 찾지 못했습니다: ${stdout}`);
+  }
+  return { short, name: rowName, readOnly, pane };
+}
+
+/** 행을 지운다. rm 은 실행 중인 job 도 멈춘다. 워커 tmux 방은 건드리지 않는다. */
+export async function closeAgentsRow(short, { _deps = {} } = {}) {
+  if (!short) return;
+  const run = _deps.execFile || execFileAsync;
+  await run(_deps.claudeBin || "claude", ["rm", short], {
+    timeout: 10_000,
+  }).catch(() => {});
+}
+
+/** 실행이 연 행만 정확히 한 번 닫는다. */
+export function createAgentsRowOwnership(close = closeAgentsRow) {
+  const shorts = new Set();
+  return {
+    get size() {
+      return shorts.size;
+    },
+    add(short) {
+      if (short) shorts.add(short);
+    },
+    async release() {
+      const owned = [...shorts];
+      shorts.clear();
+      await Promise.all(owned.map((short) => close(short)));
+    },
+  };
+}
+
+/**
+ * tfx-live start 가 띄운 Claude 외 CLI 세션을 대화형 행으로 노출한다.
+ * Claude 세션은 원래 목록에 뜨므로 건너뛴다. 실패해도 start 는 성공으로 두고 경고만 돌려준다.
+ */
+export async function exposeLiveSession(
+  { cli, session, name, cwd, remote, ready },
+  _deps,
+) {
+  if (process.env.TFX_AGENTS_ROW === "0") return {};
+  if (remote || cli === "claude" || !ready) return {};
+  try {
+    const row = await openAgentsRow({
+      name: name || session,
+      target: session,
+      cwd,
+      interactive: true,
+      _deps,
+    });
+    return {
+      agentsRow: row.short,
+      ...(row.readOnly
+        ? { agentsRowWarning: "python3 not found; row is read-only" }
+        : {}),
+    };
+  } catch (error) {
+    return { agentsRowWarning: error?.message || String(error) };
+  }
+}

package/hub/team/ansi.mjs

@@ -21,9 +21,6 @@ export function moveTo(row, col) {
 export function moveUp(n = 1) {
   return `${ESC}[${n}A`;
 }
-export function moveDown(n = 1) {
-  return `${ESC}[${n}B`;
-}
 
 // ── 줄 제어 ──
 export const clearLine = `${ESC}[2K`;
@@ -47,7 +44,7 @@ export const FG = {
   gray: `${ESC}[90m`,
   // triflux 브랜드
   codex: `${ESC}[38;2;16;163;127m`, // #10a37f codex green
-  gemini: `${ESC}[38;5;39m`, // blue
+  antigravity: `${ESC}[38;5;39m`, // blue
   claude: `${ESC}[38;2;232;112;64m`, // orange
   triflux: `${ESC}[38;5;214m`, // amber
   accent: `${ESC}[38;5;75m`, // light blue (Catppuccin blue)
@@ -439,40 +436,9 @@ export function progressBar(percent, width = 20, time) {
   return `${fillText}${emptyText}`;
 }
 
-// ── 애니메이션 진행률 바 (shimmer sweep) ──
-export function animatedProgressBar(percent, width = 20, tick = 0) {
-  const ratio = Math.max(0, Math.min(100, percent)) / 100;
-  const filled = Math.round(ratio * width);
-  const empty = width - filled;
-  if (filled === 0 || percent >= 100) return progressBar(percent, width);
-  const baseClr = percent >= 50 ? MOCHA.partial : MOCHA.fail;
-  const pos = tick % (filled + 3);
-  let bar = "";
-  for (let i = 0; i < filled; i++) {
-    const d = Math.abs(i - pos);
-    if (d === 0) bar += `${ESC}[97m█`;
-    else if (d === 1) bar += `${baseClr}▓`;
-    else bar += `${baseClr}█`;
-  }
-  return `${bar}${MOCHA.border}${"░".repeat(empty)}${RESET}`;
-}
-
-// ── 상태 아이콘 ──
 export const STATUS_ICON = {
   running: `${MOCHA.partial}⏳${RESET}`,
   completed: `${MOCHA.ok}✓${RESET}`,
   failed: `${MOCHA.fail}✗${RESET}`,
   pending: `${FG.gray}⏸${RESET}`,
 };
-
-export const CLI_ICON = {
-  codex: `${FG.codex}⚪${RESET}`,
-  gemini: `${FG.gemini}🔵${RESET}`,
-  claude: `${FG.claude}🟠${RESET}`,
-};
-
-// ── 로딩 도트 (braille spinner) ──
-const BRAILLE_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-export function loadingDots(tick = 0, clr = MOCHA.thinking) {
-  return `${clr}${BRAILLE_FRAMES[tick % BRAILLE_FRAMES.length]}${RESET}`;
-}